cvsuser 03/01/31 02:54:09
Modified: languages/imcc ChangeLog imc.c imc.h imcc.l imcc.y
instructions.c instructions.h main.c optimizer.c
optimizer.h parser.h parser_util.c pbc.c pbc.h
Log:
imcc
Revision Changes Path
1.7 +10 -0 parrot/languages/imcc/ChangeLog
Index: ChangeLog
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/ChangeLog,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -w -r1.6 -r1.7
--- ChangeLog 21 Jan 2003 10:11:30 -0000 1.6
+++ ChangeLog 31 Jan 2003 10:54:08 -0000 1.7
@@ -1,3 +1,13 @@
+- 2003-01-31 leo
+ * version 0.0.9.11
+ * changed the until now global Parrot_Interp * to
+ a local one
+ This implies:
+ *****************************************************
+ CHANGES in many function prototypes, which now take a
+ interpreter param
+ *****************************************************
+
- 2003-01-20 leo
* version 0.0.9.10
* the -r command line option is now optional, default mode now
1.29 +7 -7 parrot/languages/imcc/imc.c
Index: imc.c
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/imc.c,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -w -r1.28 -r1.29
--- imc.c 21 Jan 2003 10:11:31 -0000 1.28
+++ imc.c 31 Jan 2003 10:54:08 -0000 1.29
@@ -24,7 +24,7 @@
static IMCStack nodeStack;
/* allocate is the main loop of the allocation algorithm */
-void allocate() {
+void allocate(struct Parrot_Interp *interpreter) {
int to_spill;
int todo;
@@ -38,7 +38,7 @@
imc_stat_init();
/* consecutive labels, if_branch, unused_labels ... */
- pre_optimize();
+ pre_optimize(interpreter);
nodeStack = imcstack_new();
dont_optimize = n_spilled = 0;
@@ -61,7 +61,7 @@
if (dont_optimize)
todo = 0;
else
- todo = optimize();
+ todo = optimize(interpreter);
}
todo = 1;
while (todo) {
@@ -74,7 +74,7 @@
to_spill = try_allocate();
if ( to_spill >= 0 ) {
- spill(to_spill);
+ spill(interpreter, to_spill);
build_reglist();
life_analysis();
}
@@ -577,7 +577,7 @@
*/
-void spill(int spilled) {
+void spill(struct Parrot_Interp *interpreter, int spilled) {
Instruction * tmp, *ins;
int i, n;
@@ -616,7 +616,7 @@
sprintf(buf, "%d", n_spilled);
regs[2] = mk_const(str_dup(buf), 'I');
sprintf(buf, "%%s, %%s[%%s] #FETCH %s", new_symbol->name);
- tmp = INS("set", buf, regs, 3, 4, 0);
+ tmp = INS(interpreter, "set", buf, regs, 3, 4, 0);
tmp->bbindex = ins->bbindex;
tmp->flags |= ITSPILL;
/* insert tmp before actual ins */
@@ -633,7 +633,7 @@
regs[1] = mk_const(str_dup(buf), 'I');
regs[2] = new_symbol;
sprintf(buf, "%%s[%%s], %%s #STORE %s", old_symbol->name);
- tmp = INS("set", buf, regs, 3, 2, 0);
+ tmp = INS(interpreter, "set", buf, regs, 3, 2, 0);
tmp->bbindex = ins->bbindex;
tmp->flags |= ITSPILL;
/* insert tmp after ins */
1.23 +5 -6 parrot/languages/imcc/imc.h
Index: imc.h
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/imc.h,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -w -r1.22 -r1.23
--- imc.h 21 Jan 2003 10:11:31 -0000 1.22
+++ imc.h 31 Jan 2003 10:54:08 -0000 1.23
@@ -1,7 +1,7 @@
#ifndef __IMC_H
#define __IMC_H
-#define IMCC_VERSION "0.0.9.9"
+#define IMCC_VERSION "0.0.9.11"
#include <stdio.h>
#include <stdlib.h>
@@ -48,18 +48,18 @@
int interferes(SymReg * r0, SymReg * r1);
int map_colors(int x, SymReg ** graph, int colors[], int typ);
void build_interference_graph(void);
-void allocate(void);
+void allocate(struct Parrot_Interp *);
int simplify (void);
void order_spilling (void);
-void spill (int);
+void spill (struct Parrot_Interp *, int);
int try_allocate(void);
void restore_interference_graph(void);
void free_reglist(void);
int neighbours(int node);
-int check_op(char * fullname, char *op, SymReg *r[]);
-int is_op(char *);
+int check_op(struct Parrot_Interp *, char * fullname, char *op, SymReg *r[]);
+int is_op(struct Parrot_Interp *, char *);
/* This should be common with Cola */
@@ -68,7 +68,6 @@
/* globals */
-EXTERN struct Parrot_Interp *interpreter;
EXTERN int IMCC_DEBUG;
EXTERN int IMCC_VERBOSE;
1.25 +17 -17 parrot/languages/imcc/imcc.l
Index: imcc.l
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/imcc.l,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -w -r1.24 -r1.25
--- imcc.l 21 Jan 2003 10:11:31 -0000 1.24
+++ imcc.l 31 Jan 2003 10:54:08 -0000 1.25
@@ -14,10 +14,10 @@
#include <stdlib.h>
#include <string.h>
#include "imc.h"
-#include "imcparser.h"
#include "parser.h"
#define YY_NO_UNPUT
+#define YY_DECL int yylex(YYSTYPE *valp, struct Parrot_Interp *interp)
int state;
%}
@@ -80,7 +80,7 @@
}
<emit,INITIAL>[ISNP]{DIGIT}{DIGIT}? {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return REG;
}
@@ -133,12 +133,12 @@
<emit,INITIAL>{LETTER}{LETTERDIGIT}*":" {
yytext[yyleng-1] = 0; /* trim last ':' */
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(LABEL);
}
<emit>{DOT}{LETTER}{LETTERDIGIT}* {
- yylval.s = str_dup(yytext+1);
+ valp->s = str_dup(yytext+1);
return(MACRO);
}
@@ -146,57 +146,57 @@
if (!is_def) {
SymReg *r = find_sym(yytext);
if (r && (r->type & (VTIDENTIFIER|VT_CONSTP))) {
- yylval.sr = r;
+ valp->sr = r;
return VAR;
}
}
- yylval.s = str_dup(yytext);
- return(is_op(yylval.s) ? PARROT_OP : IDENTIFIER);
+ valp->s = str_dup(yytext);
+ return(is_op(interp, valp->s) ? PARROT_OP : IDENTIFIER);
}
<emit,INITIAL>{FLOATNUM} {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(FLOATC);
}
<emit,INITIAL>{SIGN}?{DIGIT}+ {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(INTC);
}
<emit,INITIAL>{HEX} {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(INTC);
}
<emit,INITIAL>{BIN} {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(INTC);
}
<emit,INITIAL>{STRINGCONSTANT} {
- yylval.s = str_dup(yytext); /* XXX delete quotes, -> emit, pbc */
+ valp->s = str_dup(yytext); /* XXX delete quotes, -> emit, pbc */
return(STRINGC);
}
<emit,INITIAL>{CHARCONSTANT} {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(STRINGC);
}
<emit,INITIAL>\$I[0-9]+ {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(IREG);
}
<emit,INITIAL>\$N[0-9]+ {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(NREG);
}
<emit,INITIAL>\$S[0-9]+ {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(SREG);
}
<emit,INITIAL>\$P[0-9]+ {
- yylval.s = str_dup(yytext);
+ valp->s = str_dup(yytext);
return(PREG);
}
1.40 +106 -81 parrot/languages/imcc/imcc.y
Index: imcc.y
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/imcc.y,v
retrieving revision 1.39
retrieving revision 1.40
diff -u -w -r1.39 -r1.40
--- imcc.y 22 Jan 2003 15:57:11 -0000 1.39
+++ imcc.y 31 Jan 2003 10:54:08 -0000 1.40
@@ -21,8 +21,18 @@
#include "parser.h"
#define YYDEBUG 1
+#define YYERROR_VERBOSE 1
+/*
+ * we use a pure parser wtih the interpreter as a parameter
+ * this still doesn't make the parser reentrant, there are too
+ * many globals around.
+ * These globals should go into one structure, which could be
+ * attached to the interpreter
+ */
+#define YYPARSE_PARAM interp
+#define YYLEX_PARAM interp
/*
* Choosing instructions for Parrot is pretty easy since
* many are polymorphic.
@@ -64,7 +74,10 @@
* op
*
*/
-static Instruction * MK_I(const char * fmt, SymReg ** r) {
+static
+Instruction *
+MK_I(struct Parrot_Interp *interpreter, const char * fmt, SymReg ** r)
+{
char opname[64];
char *p;
const char *q;
@@ -78,7 +91,7 @@
#if OPDEBUG
fprintf(stderr, "op '%s' format '%s' (%d)\n", opname, fmt?:"",nargs);
#endif
- return iANY(opname, fmt, r, 1);
+ return iANY(interpreter, opname, fmt, r, 1);
}
/*
@@ -122,27 +135,32 @@
/*
* substr or X = P[key]
*/
-static Instruction * iINDEXFETCH(SymReg * r0, SymReg * r1, SymReg * r2) {
+static Instruction *
+iINDEXFETCH(struct Parrot_Interp *interp, SymReg * r0, SymReg * r1,
+ SymReg * r2)
+{
if(r0->set == 'S' && r1->set == 'S' && r2->set == 'I') {
SymReg * r3 = mk_const("1", 'I');
- return MK_I("substr %s, %s, %s, 1", R4(r0, r1, r2, r3));
+ return MK_I(interp, "substr %s, %s, %s, 1", R4(r0, r1, r2, r3));
}
keyvec |= KEY_BIT(2);
- return MK_I("set %s, %s[%s]", R3(r0,r1,r2));
+ return MK_I(interp, "set %s, %s[%s]", R3(r0,r1,r2));
}
/*
* substr or P[key] = X
*/
-static Instruction * iINDEXSET(SymReg * r0, SymReg * r1, SymReg * r2) {
+static Instruction *
+iINDEXSET(struct Parrot_Interp *interp, SymReg * r0, SymReg * r1, SymReg * r2)
+{
if(r0->set == 'S' && r1->set == 'I' && r2->set == 'S') {
SymReg * r3 = mk_const("1", 'I');
- MK_I("substr %s, %s, %s, %s", R4(r0, r1,r3, r2));
+ MK_I(interp, "substr %s, %s, %s, %s", R4(r0, r1,r3, r2));
}
else if (r0->set == 'P') {
keyvec |= KEY_BIT(1);
- MK_I("set %s[%s], %s", R3(r0,r1,r2));
+ MK_I(interp, "set %s[%s], %s", R3(r0,r1,r2));
}
else {
fataly(EX_SOFTWARE, "iINDEXSET", line,"unsupported indexed set op\n");
@@ -151,7 +169,8 @@
}
/* return the index of a PMC class */
-static int get_pmc_num(char *pmc_type)
+static int
+get_pmc_num(struct Parrot_Interp *interpreter, char *pmc_type)
{
STRING * s = string_make(interpreter, pmc_type,
(UINTVAL) strlen(pmc_type), NULL, 0, NULL);
@@ -161,18 +180,20 @@
}
/* only .PmcType */
-SymReg * macro(char *name)
+SymReg *
+macro(struct Parrot_Interp *interp, char *name)
{
SymReg * r;
char buf[16];
- int type = get_pmc_num(name);
+ int type = get_pmc_num(interp, name);
sprintf(buf, "%d", type);
r = mk_const(str_dup(buf), 'I');
return r;
}
static Instruction *
-multi_keyed(char *name, SymReg ** r, int nr, int emit)
+multi_keyed(struct Parrot_Interp *interpreter,char *name,
+SymReg ** r, int nr, int emit)
{
int i, keyf, kv, n;
char buf[16];
@@ -224,7 +245,7 @@
nreg[1] = r[i+1];
nreg[2] = preg[n];
/* set p_k px */
- ins = iANY(str_dup("set"), 0, nreg, 0);
+ ins = iANY(interpreter, str_dup("set"), 0, nreg, 0);
}
else {
keyvec = 1 << 2;
@@ -232,7 +253,7 @@
nreg[1] = r[i];
nreg[2] = r[i+1];
/* set py|z p_k */
- iANY(str_dup("set"), 0, nreg, 1);
+ iANY(interpreter, str_dup("set"), 0, nreg, 1);
}
i++;
}
@@ -244,28 +265,31 @@
nreg[0] = r[i];
nreg[1] = preg[n];
/* set n, px */
- ins = iANY(str_dup("set"), 0, nreg, 0);
+ ins = iANY(interpreter, str_dup("set"), 0, nreg, 0);
}
else {
nreg[0] = preg[n];
nreg[1] = r[i];
/* set px, n */
- iANY(str_dup("set"), 0, nreg, 1);
+ iANY(interpreter, str_dup("set"), 0, nreg, 1);
}
}
}
/* make a new undef */
- iNEW(preg[0], str_dup("PerlUndef"), 1);
+ iNEW(interpreter, preg[0], str_dup("PerlUndef"), 1);
/* emit the operand */
nargs = 3;
keyvec = 0;
- iANY(name, 0, preg, 1);
+ iANY(interpreter, name, 0, preg, 1);
/* emit the LHS op */
emitb(ins);
return ins;
}
-Instruction * iANY(char * name, const char *fmt, SymReg **r, int emit) {
+Instruction *
+iANY(struct Parrot_Interp *interpreter, char * name,
+ const char *fmt, SymReg **r, int emit)
+{
char fullname[64];
int i;
int dirs = 0;
@@ -273,7 +297,7 @@
Instruction * ins;
#if 1
- ins = multi_keyed(name, r, nargs, emit);
+ ins = multi_keyed(interpreter, name, r, nargs, emit);
if (ins)
return ins;
#endif
@@ -399,6 +423,7 @@
%type <sr> pasm_args lhs
%token <sr> VAR
+%pure_parser
%start program
@@ -406,8 +431,8 @@
program: { open_comp_unit(); }
statements { $$ = 0;
- allocate();
- emit_flush();
+ allocate(interp);
+ emit_flush(interp);
}
;
@@ -419,7 +444,7 @@
pasmline: labels pasm_inst '\n' { $$ = 0; }
;
pasm_inst: {clear_state();}
- PARROT_OP pasm_args { $$ = iANY($2,0,regs,1); free($2); }
+ PARROT_OP pasm_args { $$ = iANY(interp, $2,0,regs,1); free($2); }
| /* none */ { $$ = 0;}
;
@@ -430,7 +455,7 @@
emit:
EMIT { open_comp_unit(); }
pasmcode
- EOM { emit_flush(); $$=0;}
+ EOM { emit_flush(interp); $$=0;}
;
@@ -439,8 +464,8 @@
statements ESUB
{
$$ = 0;
- allocate();
- emit_flush();
+ allocate(interp);
+ emit_flush(interp);
}
| emit { $$=0; }
;
@@ -483,23 +508,23 @@
| LOCAL { is_def=1; } type IDENTIFIER { mk_ident($4, $3);is_def=0; }
| CONST { is_def=1; } type IDENTIFIER '=' const
{ mk_const_ident($4, $3, $6);is_def=0; }
- | PARAM { is_def=1; } type IDENTIFIER { $$ = MK_I("restore",
+ | PARAM { is_def=1; } type IDENTIFIER { $$ = MK_I(interp, "restore",
R1(mk_ident($4, $3)));is_def=0; }
- | PARAM reg { $$ = MK_I("restore", R1($2)); }
- | RESULT var { $$ = MK_I("restore", R1($2)); }
- | ARG var { $$ = MK_I("save", R1($2)); }
- | RETURN var { $$ = MK_I("save", R1($2)); }
- | CALL IDENTIFIER { $$ = MK_I("bsr",
+ | PARAM reg { $$ = MK_I(interp, "restore", R1($2)); }
+ | RESULT var { $$ = MK_I(interp, "restore", R1($2)); }
+ | ARG var { $$ = MK_I(interp, "save", R1($2)); }
+ | RETURN var { $$ = MK_I(interp, "save", R1($2)); }
+ | CALL IDENTIFIER { $$ = MK_I(interp, "bsr",
R1(mk_address($2, U_add_once)));}
- | GOTO IDENTIFIER { $$ = MK_I("branch",
+ | GOTO IDENTIFIER { $$ = MK_I(interp, "branch",
R1(mk_address($2, U_add_once)));}
- | INC var { $$ = MK_I("inc",R1($2)); }
- | DEC var { $$ = MK_I("dec",R1($2)); }
- | PRINT var { $$ = MK_I("print",R1($2)); }
- | SAVEALL { $$ = MK_I("saveall" ,R0()); }
- | RESTOREALL { $$ = MK_I("restoreall" ,R0()); }
- | END { $$ = MK_I("end" ,R0()); }
- | PARROT_OP vars { $$ = iANY($1,0,regs, 1); free($1); }
+ | INC var { $$ = MK_I(interp, "inc",R1($2)); }
+ | DEC var { $$ = MK_I(interp, "dec",R1($2)); }
+ | PRINT var { $$ = MK_I(interp, "print",R1($2)); }
+ | SAVEALL { $$ = MK_I(interp, "saveall" ,R0()); }
+ | RESTOREALL { $$ = MK_I(interp, "restoreall" ,R0()); }
+ | END { $$ = MK_I(interp, "end" ,R0()); }
+ | PARROT_OP vars { $$ = iANY(interp, $1,0,regs, 1);
free($1); }
| /* none */ { $$ = 0;}
;
@@ -515,61 +540,61 @@
;
assignment:
- target '=' var { $$ = MK_I("set", R2($1, $3)); }
- | target '=' '!' var { $$ = MK_I("not", R2($1, $4));}
- | target '=' '-' var { $$ = MK_I("neg", R2($1, $4));}
- | target '=' '~' var { $$ = MK_I("bnot", R2($1, $4));}
- | target '=' var '+' var { $$ = MK_I("add", R3($1, $3, $5)); }
- | target '=' var '-' var { $$ = MK_I("sub", R3($1, $3, $5)); }
- | target '=' var '*' var { $$ = MK_I("mul", R3($1, $3, $5)); }
- | target '=' var POW var { $$ = MK_I("pow", R3($1, $3, $5)); }
- | target '=' var '/' var { $$ = MK_I("div", R3($1, $3, $5)); }
- | target '=' var '%' var { $$ = MK_I("mod", R3($1, $3, $5)); }
- | target '=' var '.' var { $$ = MK_I("concat", R3($1,$3,$5)); }
- | target '=' var SHIFT_LEFT var { $$ = MK_I("shl", R3($1, $3, $5)); }
- | target '=' var SHIFT_RIGHT var { $$ = MK_I("shr", R3($1, $3, $5)); }
- | target '=' var SHIFT_RIGHT_U var { $$ = MK_I("lsr", R3($1, $3, $5)); }
- | target '=' var LOG_AND var { $$ = MK_I("and", R3($1, $3, $5)); }
- | target '=' var LOG_OR var { $$ = MK_I("or", R3($1, $3, $5)); }
- | target '=' var LOG_XOR var { $$ = MK_I("xor", R3($1, $3, $5)); }
- | target '=' var '&' var { $$ = MK_I("band", R3($1, $3, $5)); }
- | target '=' var '|' var { $$ = MK_I("bor", R3($1, $3, $5)); }
- | target '=' var '~' var { $$ = MK_I("bxor", R3($1, $3, $5)); }
- | target '=' var '[' keylist ']' { $$ = iINDEXFETCH($1, $3, $5); }
- | var '[' keylist ']' '=' var { $$ = iINDEXSET($1, $3, $6); }
- | target '=' NEW classname { $$ = iNEW($1, $4, 1); }
- | target '=' DEFINED var { $$ = MK_I("defined",R2($1,$4)); }
+ target '=' var { $$ = MK_I(interp, "set", R2($1,
$3)); }
+ | target '=' '!' var { $$ = MK_I(interp, "not", R2($1, $4));}
+ | target '=' '-' var { $$ = MK_I(interp, "neg", R2($1, $4));}
+ | target '=' '~' var { $$ = MK_I(interp, "bnot", R2($1, $4));}
+ | target '=' var '+' var { $$ = MK_I(interp, "add", R3($1, $3,
$5)); }
+ | target '=' var '-' var { $$ = MK_I(interp, "sub", R3($1, $3,
$5)); }
+ | target '=' var '*' var { $$ = MK_I(interp, "mul", R3($1, $3,
$5)); }
+ | target '=' var POW var { $$ = MK_I(interp, "pow", R3($1, $3,
$5)); }
+ | target '=' var '/' var { $$ = MK_I(interp, "div", R3($1, $3,
$5)); }
+ | target '=' var '%' var { $$ = MK_I(interp, "mod", R3($1, $3,
$5)); }
+ | target '=' var '.' var { $$ = MK_I(interp, "concat",
R3($1,$3,$5)); }
+ | target '=' var SHIFT_LEFT var { $$ = MK_I(interp, "shl", R3($1, $3, $5)); }
+ | target '=' var SHIFT_RIGHT var { $$ = MK_I(interp, "shr", R3($1, $3,
$5)); }
+ | target '=' var SHIFT_RIGHT_U var { $$ = MK_I(interp, "lsr", R3($1, $3,
$5)); }
+ | target '=' var LOG_AND var { $$ = MK_I(interp, "and", R3($1, $3, $5)); }
+ | target '=' var LOG_OR var { $$ = MK_I(interp, "or", R3($1, $3, $5)); }
+ | target '=' var LOG_XOR var { $$ = MK_I(interp, "xor", R3($1, $3, $5)); }
+ | target '=' var '&' var { $$ = MK_I(interp, "band", R3($1, $3,
$5)); }
+ | target '=' var '|' var { $$ = MK_I(interp, "bor", R3($1, $3,
$5)); }
+ | target '=' var '~' var { $$ = MK_I(interp, "bxor", R3($1, $3,
$5)); }
+ | target '=' var '[' keylist ']' { $$ = iINDEXFETCH(interp, $1, $3, $5); }
+ | var '[' keylist ']' '=' var { $$ = iINDEXSET(interp, $1, $3, $6); }
+ | target '=' NEW classname { $$ = iNEW(interp, $1, $4, 1); }
+ | target '=' DEFINED var { $$ = MK_I(interp,
"defined",R2($1,$4)); }
| target '=' DEFINED var '[' keylist ']' { keyvec=KEY_BIT(2);
- $$ = MK_I("defined", R3($1, $4, $6));}
- | target '=' CLONE var { $$ = MK_I("clone",R2($1, $4));
+ $$ = MK_I(interp, "defined", R3($1, $4, $6));}
+ | target '=' CLONE var { $$ = MK_I(interp, "clone",R2($1, $4));
}
- | target '=' ADDR IDENTIFIER { $$ = MK_I("set_addr",
+ | target '=' ADDR IDENTIFIER { $$ = MK_I(interp, "set_addr",
R2($1, mk_address($4,U_add_once))); }
- | target '=' GLOBAL string { $$ = MK_I("find_global",R2($1,$4)); }
- | GLOBAL string '=' var { $$ = MK_I("store_global",R2($2,$4)); }
+ | target '=' GLOBAL string { $$ = MK_I(interp, "find_global",R2($1,$4)); }
+ | GLOBAL string '=' var { $$ = MK_I(interp, "store_global",R2($2,$4)); }
| NEW { expect_pasm = 1; }
- target COMMA newtype { $$ = MK_I("new", R2($3, $5)); }
- | DEFINED target COMMA var { $$ = MK_I("defined", R2($2, $4)); }
+ target COMMA newtype { $$ = MK_I(interp, "new", R2($3, $5)); }
+ | DEFINED target COMMA var { $$ = MK_I(interp, "defined", R2($2, $4));
}
| DEFINED target COMMA var '[' keylist ']' { keyvec=KEY_BIT(2);
- $$ = MK_I("defined", R3($2, $4, $6));}
- | CLONE target COMMA var { $$ = MK_I("clone", R2($2, $4)); }
+ $$ = MK_I(interp, "defined", R3($2, $4,
$6));}
+ | CLONE target COMMA var { $$ = MK_I(interp, "clone", R2($2, $4)); }
;
newtype:
- MACRO { $$ = macro($1); free($1); }
+ MACRO { $$ = macro(interp, $1); free($1); }
| const
;
if_statement:
- IF var relop var GOTO IDENTIFIER { $$=MK_I($3,R3($2,$4,
+ IF var relop var GOTO IDENTIFIER { $$=MK_I(interp, $3,R3($2,$4,
mk_address($6,U_add_once))); }
- | IF var GOTO IDENTIFIER {$$= MK_I("if", R2($2,
+ | IF var GOTO IDENTIFIER {$$= MK_I(interp, "if", R2($2,
mk_address($4, U_add_once))); }
- | UNLESS var GOTO IDENTIFIER {$$= MK_I("unless",R2($2,
+ | UNLESS var GOTO IDENTIFIER {$$= MK_I(interp, "unless",R2($2,
mk_address($4, U_add_once))); }
- | IF var COMMA IDENTIFIER { $$= MK_I("if", R2($2,
+ | IF var COMMA IDENTIFIER { $$= MK_I(interp, "if", R2($2,
mk_address($4, U_add_once))); }
- | UNLESS var COMMA IDENTIFIER { $$= MK_I("unless", R2($2,
+ | UNLESS var COMMA IDENTIFIER { $$= MK_I(interp, "unless", R2($2,
mk_address($4, U_add_once))); }
;
@@ -608,7 +633,7 @@
IDENTIFIER { $$ = mk_address($1, U_add_once); }
| PARROT_OP { $$ = mk_address($1, U_add_once); }
| var
- | MACRO { $$ = macro($1); free($1); }
+ | MACRO { $$ = macro(interp, $1); free($1); }
;
var: VAR
@@ -650,7 +675,7 @@
int yyerror(char * s)
{
- fprintf(stderr, "last token = [%s]\n", yylval.s);
+ /* fprintf(stderr, "last token = [%s]\n", yylval.s); */
fprintf(stderr, "(error) line %d: %s\n", line, s );
fprintf(stderr, "Didn't create output asm.\n" );
exit(EX_UNAVAILABLE);
1.20 +15 -10 parrot/languages/imcc/instructions.c
Index: instructions.c
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/instructions.c,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -w -r1.19 -r1.20
--- instructions.c 22 Jan 2003 15:57:11 -0000 1.19
+++ instructions.c 31 Jan 2003 10:54:08 -0000 1.20
@@ -341,15 +341,18 @@
}
static char *output;
-static int e_file_open(char *file)
+static int e_file_open(void *param)
{
+ char *file = (char *) param;
+
if (strcmp(file, "-"))
freopen(file, "w", stdout);
output = file;
return 1;
}
-static int e_file_close(void) {
+static int e_file_close(void *param) {
+ UNUSED(param);
printf("\n\n");
fclose(stdout);
info(1, "assembly module %s written.\n", output);
@@ -357,7 +360,8 @@
}
-static int e_file_emit(Instruction * ins) {
+static int e_file_emit(void *param, Instruction * ins) {
+ UNUSED(param);
if ((ins->type & ITLABEL) || ! *ins->op)
printf(ins_fmt(ins));
else
@@ -373,16 +377,17 @@
static int emitter;
-int emit_open(int type, char *file)
+int emit_open(int type, void *param)
{
emitter = type;
- return (emitters[emitter]).open(file);
+ return (emitters[emitter]).open(param);
return 0;
}
-int emit_flush() {
+int emit_flush(void *param) {
Instruction * ins, *next;
+ struct Parrot_Interp *interpreter = (struct Parrot_Interp *)param;
/* first instruction should be ".sub" -- make sure we allocate P31
* _after_ subroutine entry. And after the "saveall", or any
* other assortment of pushes. */
@@ -397,11 +402,11 @@
|| strcmp(ins->fmt, "saveall") == 0)) {
ins = ins->next;
}
- spill_ins = iNEW(p31, str_dup("PerlArray"), 0);
+ spill_ins = iNEW(interpreter, p31, str_dup("PerlArray"), 0);
insert_ins(ins, spill_ins);
}
for (ins = instructions; ins; ins = ins->next) {
- (emitters[emitter]).emit(ins);
+ (emitters[emitter]).emit(param, ins);
}
for (ins = instructions; ins; ) {
next = ins->next;
@@ -411,9 +416,9 @@
close_comp_unit();
return 0;
}
-int emit_close()
+int emit_close(void *param)
{
- return (emitters[emitter]).close();
+ return (emitters[emitter]).close(param);
}
/*
* Local variables:
1.16 +11 -11 parrot/languages/imcc/instructions.h
Index: instructions.h
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/instructions.h,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -w -r1.15 -r1.16
--- instructions.h 22 Jan 2003 15:57:11 -0000 1.15
+++ instructions.h 31 Jan 2003 10:54:08 -0000 1.16
@@ -66,16 +66,16 @@
*/
#ifdef _PARSER
Instruction * _mk_instruction(const char *,const char *, SymReg **, int);
-Instruction * iANY(char * name, const char *fmt, SymReg **r, int emit);
+Instruction * iANY(struct Parrot_Interp *, char * name, const char *fmt, SymReg
**r, int emit);
#else
#define _mk_instruction(a,b,c,d) dont_use(a,b)
-#define iANY(a,b,c,d) dont_use(a,b)
+#define iANY(i,a,b,c,d) dont_use(a,b)
#endif
-Instruction * INS(char * name, char *fmt, SymReg **regs, int nargs, int keyv,
- int emit);
+Instruction * INS(struct Parrot_Interp *, char * name,
+ char *fmt, SymReg **regs, int nargs, int keyv, int emit);
Instruction * INS_LABEL(SymReg * r0, int emit);
-Instruction * iNEW(SymReg * r0, char * type, int emit);
+Instruction * iNEW(struct Parrot_Interp *,SymReg * r0, char * type, int emit);
Instruction * emitb(Instruction *);
int instruction_reads(Instruction *, SymReg *);
int instruction_writes(Instruction *, SymReg *);
@@ -95,16 +95,16 @@
EXTERN Instruction* instructions;
typedef struct _emittert {
- int (*open)(char *file);
- int (*emit)(Instruction *ins);
- int (*close)(void);
+ int (*open)(void *param);
+ int (*emit)(void *param, Instruction *ins);
+ int (*close)(void *param);
} Emitter;
enum Emitter_type { EMIT_FILE, EMIT_PBC };
-int emit_open(int type, char *file);
-int emit_flush(void);
-int emit_close(void);
+int emit_open(int type, void *param);
+int emit_flush(void *param);
+int emit_close(void *param);
void open_comp_unit(void);
void close_comp_unit(void);
1.11 +8 -6 parrot/languages/imcc/main.c
Index: main.c
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/main.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -w -r1.10 -r1.11
--- main.c 27 Jan 2003 17:06:45 -0000 1.10
+++ main.c 31 Jan 2003 10:54:08 -0000 1.11
@@ -46,8 +46,8 @@
exit(0);
}
-#define setopt(flag) Parrot_setflag(interpreter, flag, (*argv)[0]+2)
-#define unsetopt(flag) Parrot_setflag(interpreter, flag, 0)
+#define setopt(flag) Parrot_setflag(interp, flag, (*argv)[0]+2)
+#define unsetopt(flag) Parrot_setflag(interp, flag, 0)
/* most stolen from test_main.c */
static char *
@@ -181,7 +181,8 @@
int stacktop;
struct PackFile *pf;
- interpreter = Parrot_new();
+ struct Parrot_Interp *interpreter = Parrot_new();
+
Parrot_init(interpreter, (void*)&stacktop);
pf = PackFile_new(0);
interpreter->code = pf;
@@ -245,15 +246,16 @@
fclose(yyin);
}
else {
+ int per_pbc = write_pbc | run_pbc;
info(1, "using optimization '%s'\n", optimizer_opt);
line = 1;
- emit_open(write_pbc | run_pbc, output);
+ emit_open(per_pbc, per_pbc ? (void*)interpreter : (void*)output);
debug(1, "Starting parse...\n");
- yyparse();
- emit_close();
+ yyparse((void *) interpreter);
+ emit_close(interpreter);
fclose(yyin);
info(1, "%ld lines compiled.\n", line);
1.9 +14 -14 parrot/languages/imcc/optimizer.c
Index: optimizer.c
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/optimizer.c,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -w -r1.8 -r1.9
--- optimizer.c 21 Jan 2003 10:11:31 -0000 1.8
+++ optimizer.c 31 Jan 2003 10:54:08 -0000 1.9
@@ -49,23 +49,23 @@
* because Px where different before
*
*/
-static void if_branch(void);
+static void if_branch(struct Parrot_Interp *);
static void branch_branch(void);
static void unused_label(void);
static int used_once(void);
-static int loop_optimization(void);
+static int loop_optimization(struct Parrot_Interp *);
static int clone_remove(void);
-void pre_optimize() {
+void pre_optimize(struct Parrot_Interp *interp) {
if (*optimizer_opt != '0') { /* XXX */
- if_branch();
+ if_branch(interp);
branch_branch();
/* XXX cfg / loop detection breaks e.g. in t/compiler/5_3 */
unused_label();
}
}
-int optimize() {
+int optimize(struct Parrot_Interp *interp) {
if (*optimizer_opt > '1') { /* XXX */
/* constant_propagation(); N/Y */
@@ -73,7 +73,7 @@
return 1;
if (used_once())
return 1;
- if (loop_optimization())
+ if (loop_optimization(interp))
return 1;
}
return 0;
@@ -108,7 +108,7 @@
* branch L2 ---
* L1: L2:
*/
-static void if_branch()
+static void if_branch(struct Parrot_Interp *interp)
{
Instruction *ins, *last;
int reg;
@@ -136,7 +136,7 @@
if ((neg_op = get_neg_op(last->op, &args)) != 0) {
Instruction * tmp;
last->r[reg] = go;
- tmp = INS((char*)neg_op, "", last->r, args, 0, 0);
+ tmp = INS(interp, (char*)neg_op, "", last->r, args, 0, 0);
last->opnum = tmp->opnum;
last->opsize = tmp->opsize;
free(last->op);
@@ -388,7 +388,7 @@
/* move the instruction ins before loop in bb */
static int
-move_ins_out(Instruction **ins, Basic_block *bb)
+move_ins_out(struct Parrot_Interp *interp, Instruction **ins, Basic_block *bb)
{
Basic_block *pred;
Instruction * next, *out;
@@ -418,7 +418,7 @@
regs[0] = 0;
sprintf(buf, "# Invar moved: %s",ins_string(out->next));
- tmp = INS("", buf, regs, 0, 0, 0);
+ tmp = INS(interp, "", buf, regs, 0, 0, 0);
insert_ins((*ins)->prev, tmp);
}
ostat.invariants_moved++;
@@ -429,7 +429,7 @@
}
static int
-loop_one(int bnr)
+loop_one(struct Parrot_Interp *interp, int bnr)
{
Basic_block *bb = bb_list[bnr];
Instruction *ins;
@@ -444,7 +444,7 @@
reason = 0;
if (is_invariant(ins)) {
debug(2, "found invariant %s\n", ins_string(ins));
- if (move_ins_out(&ins, bb)) {
+ if (move_ins_out(interp, &ins, bb)) {
changed++;
ins = ins->prev;
}
@@ -457,7 +457,7 @@
}
int
-loop_optimization()
+loop_optimization(struct Parrot_Interp *interp)
{
int l, bb, loop_depth;
int changed = 0;
@@ -470,7 +470,7 @@
debug(2, "loop_depth %d\n", l);
for (bb = 0; bb < n_basic_blocks; bb++)
if (bb_list[bb]->loop_depth == l) {
- changed |= loop_one(bb);
+ changed |= loop_one(interp, bb);
}
/* currently e.g. mandel.p6 breaks, if not only the most
* inner loop is changed, but outer loops to */
1.4 +3 -3 parrot/languages/imcc/optimizer.h
Index: optimizer.h
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/optimizer.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -w -r1.3 -r1.4
--- optimizer.h 21 Jan 2003 10:11:31 -0000 1.3
+++ optimizer.h 31 Jan 2003 10:54:08 -0000 1.4
@@ -1,7 +1,7 @@
#ifndef __OPTIMIZER_H
#define __OPTIMIZER_H
-void pre_optimize(void);
-int optimize(void);
-void post_optimize(void);
+void pre_optimize(struct Parrot_Interp *);
+int optimize(struct Parrot_Interp *);
+void post_optimize(struct Parrot_Interp *);
#endif
1.6 +5 -3 parrot/languages/imcc/parser.h
Index: parser.h
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/parser.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -w -r1.5 -r1.6
--- parser.h 21 Jan 2003 10:11:31 -0000 1.5
+++ parser.h 31 Jan 2003 10:54:08 -0000 1.6
@@ -7,6 +7,8 @@
#define EXTERN extern
#endif
+#include "imcparser.h"
+
EXTERN SymReg *regs[IMCC_MAX_REGS];
EXTERN int keyvec;
EXTERN int nargs;
@@ -22,10 +24,10 @@
#define KEY_BIT(argnum) (1 << (argnum))
-SymReg * macro(char *name);
+SymReg * macro(struct Parrot_Interp *, char *name);
int yyerror(char *);
-int yyparse(void);
-int yylex(void);
+int yyparse(void *param);
+int yylex(YYSTYPE *valp, struct Parrot_Interp *);
void op_fullname(char * dest, const char * name, SymReg * args[], int);
void open_comp_unit(void);
void register_compilers(Parrot_Interp);
1.8 +16 -11 parrot/languages/imcc/parser_util.c
Index: parser_util.c
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/parser_util.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -w -r1.7 -r1.8
--- parser_util.c 21 Jan 2003 10:11:31 -0000 1.7
+++ parser_util.c 31 Jan 2003 10:54:08 -0000 1.8
@@ -25,9 +25,11 @@
/*
* new P, .SomeThing
*/
-Instruction * iNEW(SymReg * r0, char * type, int emit) {
+Instruction *
+iNEW(struct Parrot_Interp *interpreter, SymReg * r0, char * type, int emit)
+{
char fmt[256];
- SymReg *pmc = macro(type);
+ SymReg *pmc = macro(interpreter, type);
/* XXX check, if type exists, but aove keyed search
* gives 0 for non existing PMCs */
sprintf(fmt, "%%s, %d\t # .%s", atoi(pmc->name), type);
@@ -38,7 +40,7 @@
regs[0] = r0;
regs[1] = pmc;
nargs = 2;
- return iANY("new", fmt, regs, emit);
+ return iANY(interpreter, "new", fmt, regs, emit);
}
/* TODO get rid of nargs */
@@ -71,7 +73,9 @@
*dest = '\0';
}
-int check_op(char *fullname, char *name, SymReg *r[])
+int
+check_op(struct Parrot_Interp *interpreter, char *fullname,
+ char *name, SymReg *r[])
{
int op, narg;
for (narg = 0; regs[narg]; narg++) ;
@@ -81,7 +85,7 @@
}
-int is_op(char *name)
+int is_op(struct Parrot_Interp *interpreter, char *name)
{
return interpreter->op_lib->op_code(name, 0) >= 0
|| interpreter->op_lib->op_code(name, 1) >= 0;
@@ -97,12 +101,13 @@
*
* s. e.g. imc.c for usage
*/
-Instruction * INS(char * name, char *fmt, SymReg **r, int n,
- int keys, int emit)
+Instruction *
+INS(struct Parrot_Interp *interpreter, char *name, char *fmt, SymReg **r,
+ int n, int keys, int emit)
{
nargs = n;
keyvec = keys;
- return iANY(name, fmt, r, emit);
+ return iANY(interpreter, name, fmt, r, emit);
}
/* imcc_compile(interp*, const char*)
@@ -137,10 +142,10 @@
line = 1;
yy_scan_string(s);
/* s. also e_pbc_open for reusing code/consts ... */
- emit_open(1, NULL);
+ emit_open(1, interp);
/* XXX where to put constants */
- yyparse();
- emit_close();
+ yyparse((void *) interp);
+ emit_close(interp);
#ifdef EVAL_TEST
pc = (opcode_t *) interp->code->byte_code;
1.18 +31 -24 parrot/languages/imcc/pbc.c
Index: pbc.c
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/pbc.c,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -w -r1.17 -r1.18
--- pbc.c 28 Jan 2003 09:20:40 -0000 1.17
+++ pbc.c 31 Jan 2003 10:54:08 -0000 1.18
@@ -99,11 +99,12 @@
globals.cs = NULL;
}
-int e_pbc_open(char *dummy) {
+int e_pbc_open(void *param) {
struct cs_t *cs;
+ struct Parrot_Interp *interpreter = (struct Parrot_Interp *)param;
+
/* make a new code segment
*/
- UNUSED(dummy);
if (!globals.cs) {
/* register cleanup code */
Parrot_on_exit(imcc_globals_destroy, NULL);
@@ -139,7 +140,8 @@
/* get size/line of bytecode in ops till now */
-static int get_old_size(int *ins_line)
+static int
+get_old_size(struct Parrot_Interp *interpreter, int *ins_line)
{
size_t size;
struct subs *s;
@@ -223,7 +225,8 @@
/* store global labels and bsr for later fixup
* return size in ops
*/
-static int store_labels(int *src_lines)
+static int
+store_labels(struct Parrot_Interp *interpreter, int *src_lines)
{
Instruction * ins;
int code_size;
@@ -314,7 +317,7 @@
/* add inter_cs jump */
sprintf(buf, "%d", globals.inter_seg_n);
r[0] = mk_const(str_dup(buf), 'I');
- INS("branch_cs", "", r, 1, 0, 1);
+ INS(interpreter, "branch_cs", "", r, 1, 0, 1);
/* finally generate fixup table entry */
PackFile_FixupTable_new_entry_t0(interpreter, code_seg, offset);
}
@@ -341,7 +344,7 @@
}
/* fix global branches */
-void fixup_bsrs()
+void fixup_bsrs(struct Parrot_Interp *interpreter)
{
int i, pc, addr;
SymReg * bsr, *lab;
@@ -427,7 +430,7 @@
/* add constant string to constants */
static int
-add_const_str(char *str) {
+add_const_str(struct Parrot_Interp *interpreter, char *str) {
int k, l;
SymReg * r;
char *o;
@@ -463,7 +466,7 @@
}
static int
-add_const_num(char *buf) {
+add_const_num(struct Parrot_Interp *interpreter, char *buf) {
int k;
SymReg * r;
@@ -481,7 +484,8 @@
/* add constant key to constants */
static int
-add_const_key(opcode_t key[], int size, char *s_key) {
+add_const_key(struct Parrot_Interp *interpreter, opcode_t key[],
+ int size, char *s_key) {
int k;
SymReg *r;
struct PackFile_Constant *pfc;
@@ -515,7 +519,7 @@
*/
static opcode_t
-build_key(SymReg *reg)
+build_key(struct Parrot_Interp *interpreter, SymReg *reg)
{
#define KEYLEN 21
opcode_t key[KEYLEN], *pc, size;
@@ -579,11 +583,11 @@
/* now we have a packed key, which packfile can work on */
/* XXX endianess? probably no, we pack/unpack on the very
* same computer */
- k = add_const_key(key, size, s_key);
+ k = add_const_key(interpreter, key, size, s_key);
return k;
}
-static void add_1_const(SymReg *r)
+static void add_1_const(struct Parrot_Interp *interpreter, SymReg *r)
{
if (r->color >= 0)
return;
@@ -597,15 +601,15 @@
r->color = atoi(r->name);
break;
case 'S':
- r->color = add_const_str(r->name);
+ r->color = add_const_str(interpreter, r->name);
break;
case 'N':
- r->color = add_const_num(r->name);
+ r->color = add_const_num(interpreter, r->name);
break;
case 'K':
for (r = r->nextkey; r; r = r->nextkey)
if (r->type & VTCONST)
- add_1_const(r);
+ add_1_const(interpreter, r);
default:
break;
}
@@ -614,7 +618,8 @@
}
/* store a constants idx for later reuse */
-static void constant_folding(void)
+static void
+constant_folding(struct Parrot_Interp *interpreter)
{
SymReg * r;
int i;
@@ -623,7 +628,7 @@
for(i = 0; i < HASH_SIZE; i++)
for(r = ghash[i]; r; r = r->next) {
if (r->type & VTCONST) {
- add_1_const(r);
+ add_1_const(interpreter, r);
}
}
@@ -634,7 +639,8 @@
* now let the fun begin, actually emit code for one ins
*/
-int e_pbc_emit(Instruction * ins) {
+int e_pbc_emit(void *param, Instruction * ins) {
+ struct Parrot_Interp *interpreter = (struct Parrot_Interp *)param;
int ok = 0;
static opcode_t * pc, npc;
op_info_t *op_info;
@@ -649,10 +655,10 @@
int bytes;
make_new_sub(); /* we start a new compilation unit */
- code_size = store_labels(&ins_size);
- oldsize = get_old_size(&ins_line);
+ code_size = store_labels(interpreter, &ins_size);
+ oldsize = get_old_size(interpreter, &ins_line);
debug(1, "code_size(ops) %d oldsize %d\n", code_size, oldsize);
- constant_folding();
+ constant_folding(interpreter);
store_sub_size(code_size, ins_size);
bytes = (oldsize + code_size) * sizeof(opcode_t);
interpreter->code->byte_code =
@@ -716,7 +722,7 @@
debug(1," %d", r->color);
break;
case PARROT_ARG_KC:
- *pc++ = build_key(ins->r[i]);
+ *pc++ = build_key(interpreter, ins->r[i]);
debug(1," %d", pc[-1]);
break;
default:
@@ -730,9 +736,10 @@
return ok;
}
-int e_pbc_close(){
+int e_pbc_close(void *param){
+ struct Parrot_Interp *interpreter = (struct Parrot_Interp *)param;
- fixup_bsrs();
+ fixup_bsrs(interpreter);
return 0;
}
1.3 +4 -4 parrot/languages/imcc/pbc.h
Index: pbc.h
===================================================================
RCS file: /cvs/public/parrot/languages/imcc/pbc.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -w -r1.2 -r1.3
--- pbc.h 22 Dec 2002 17:23:04 -0000 1.2
+++ pbc.h 31 Jan 2003 10:54:08 -0000 1.3
@@ -1,9 +1,9 @@
#ifndef __PBC_H
#define __PBC_H
-int e_pbc_open(char *);
-int e_pbc_emit(Instruction * ins);
-int e_pbc_close(void);
-void fixup_bsrs(void);
+int e_pbc_open(void *);
+int e_pbc_emit(void *, Instruction * ins);
+int e_pbc_close(void *);
+void fixup_bsrs(struct Parrot_Interp *interpreter);
#endif
