URL https://opencores.org/ocsvn/zipcpu/zipcpu/trunk

Subversion Repositories zipcpu

[/] [zipcpu/] [trunk/] [sw/] [zasm/] [zasm.y] - Blame information for rev 13

Go to most recent revision | Details | Compare with Previous | View Log


/*******************************************************************************
**
** Filename:    zasm.y
**
** Project:     Zip CPU -- a small, lightweight, RISC CPU core
**
** Purpose:     The parser for the Zip Assembler.  This is actually not just
**              the parser, but the main program as well.
**
** Creator:     Dan Gisselquist, Ph.D.
**              Gisselquist Tecnology, LLC
**
********************************************************************************
**
** Copyright (C) 2015, Gisselquist Technology, LLC
**
** This program is free software (firmware): you can redistribute it and/or
** modify it under the terms of  the GNU General Public License as published
** by the Free Software Foundation, either version 3 of the License, or (at
** your option) any later version.
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
** FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
** for more details.
**
** You should have received a copy of the GNU General Public License along
** with this program.  (It's in the $(ROOT)/doc directory, run make with no
** target there if the PDF file isn't present.)  If not, see
**  for a copy.
**
** License:     GPL, v3, as defined and found on www.gnu.org,
**              http://www.gnu.org/licenses/gpl.html
**
**
*******************************************************************************/
 
%{
 #include 
 #include 
 #include "asmdata.h"
 
  extern "C" int yylex(void);
  extern "C" int yyparse(void);
  // extern "C" FILE *yyin;
  void yyerror(const char *);
  unsigned int global_parser_pc;
  char *master_input_filename = NULL;
  extern int yylineno;
  char  *linecp = NULL; // A copy of the input line
%}
 
%token COMMA EQU PLUS MINUS TIMES HERE DOLLAR COLON
%token BOOLEANOR BITWISEOR BOOLEANAND BITWISEAND BITWISEXOR DOT
%token WORD FILL
%token LOADOP STOROP LDIOP
%token BAREOP BRANCHOP COND DUALOP IDENTIFIER INT LDHLOP REG SINGLOP
 
%union {
        ZPARSER::ZIPREG         u_reg;
        ZPARSER::ZIPCOND        u_cond;
        int                     u_ival;
        LEXOPCODE               u_op;
        char                    *u_id;
        ASMLINE                 *u_ln;
        AST                     *u_ast;
}
 
%type                   REG
%type           COND opcond
%type           INT
%type                   IDENTIFIER
%type                   BAREOP SINGLOP DUALOP BRANCHOP LDHLOP
%type                   unlabeledline instruction wordlist fillist opb
%type                   bareop singlop dualop loadop storop line
%type                   expr value multident
 
%% /* The grammar follows */
 
input:
  %empty
| input line { if ($2) {objcode += $2; global_parser_pc += $2->nlines(); if ($2->isdefined()) delete $2; } }
;
 
line:
   '\n' { $$ = NULL; }
| unlabeledline '\n' { $$ = $1; }
| multident COLON unlabeledline '\n' {
        if ($1->m_node_type == 'I') {
                if (((AST_IDENTIFIER*)$1)->m_id[0] == 'L')
                        stb_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));
                else
                        gbl_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));
                delete $1;
                }
        $$ = $3;
        }
| multident COLON '\n' {
        if ($1->m_node_type == 'I') {
                if (((AST_IDENTIFIER*)$1)->m_id[0] == 'L')
                        stb_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));
                else
                        gbl_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));
                delete $1;
        }
        $$ = new VLINE();
        }
| multident EQU expr '\n' {
        if ($1->m_node_type == 'I') {
                stb_define(((AST_IDENTIFIER *)$1)->m_id, $3);
                delete $1;
        }
        $$ = new VLINE();
        }
;
 
unlabeledline:
  instruction   { $$ = $1; }
| WORD wordlist { $$ = $2; }
| FILL fillist { $$ = $2; }
;
 
wordlist:
  expr  {
        if ($1->isdefined())
                $$ = new DLINE($1->eval());
        else {
                $$ = new VLINE();
                yyerror("ERROR: word list undefined");
        }}
| expr COMMA wordlist {
        if ($1->isdefined())
                $$ = new DLINE($1->eval());
        else {
                $$ = new VLINE();
                yyerror("ERROR: word list undefined\n");
        }}
;
 
fillist:
  expr COMMA expr {
                if (($1->isdefined())&&($3->isdefined())) {
                        int     ntimes = $1->eval(),
                                val = $3->eval();
                        LLINE   *ln = new LLINE();
                        for(int i=0; i
                                ln->addline(new DLINE(val));
                        $$ = ln;
                } else {
                        yyerror("Fill list undefined\n");
                        $$ = new VLINE();
                }
        }
;
 
instruction:
  dualop  opb COMMA REG {
                $$ = $1;
                ((TLINE*)$1)->m_imm = ((TLINE*)$2)->m_imm; ((TLINE*)$2)->m_imm = NULL;
                ((TLINE*)$1)->m_opb = ((TLINE*)$2)->m_opb;
                ((TLINE*)$1)->m_opa = $4;
                if ($1->isdefined()) {
                        $$ = ((TLINE*)$1)->eval();
                        delete $1;
                        delete $2;
                }
        }
| dualop  opb COMMA multident {
                char    buf[256];
                sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());
                yyerror(buf);
                $$ = new VLINE();
                delete $1;
                delete $2;
                delete $4;
        }
| singlop opb   {
                $$ = $1;
                ((TLINE*)$1)->m_imm = ((TLINE*)$2)->m_imm; ((TLINE*)$2)->m_imm = NULL;
                ((TLINE*)$1)->m_opb = ((TLINE*)$2)->m_opb;
                if ($1->isdefined()) {
                        $$ = ((TLINE *)$1)->eval();
                        delete $1;
                }
        }
| bareop        { $$ = $1; }
| LDHLOP  opcond expr COMMA REG {
                TLINE *tln = new TLINE;
                tln->m_opcode = $1;
                tln->m_cond   = $2;
                tln->m_imm    = $3;
                tln->m_opa    = $5;
 
                if (tln->isdefined()) {
                        $$ = tln->eval();
                        delete tln;
                } else
                        $$ = tln;
        }
| LDHLOP  opcond expr COMMA multident {
                char    buf[256];
                sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$5)->m_id.c_str());
                yyerror(buf);
                $$ = new VLINE();
                delete $3;
                delete $5;
        }
| LDIOP          expr COMMA REG {
                TLINE *tln = new TLINE;
                tln->m_opcode = OP_LDI;
                tln->m_cond   = ZPARSER::ZIPC_ALWAYS;
                tln->m_imm    = $2;
                tln->m_opa    = $4;
 
                if (tln->isdefined()) {
                        $$ = tln->eval();
                        delete tln;
                } else
                        $$ = tln;
        }
| LDIOP  expr COMMA multident {
                char    buf[256];
                sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());
                yyerror(buf);
                $$ = new VLINE();
                delete $2;
                delete $4;
        }
| BRANCHOP  expr        {
                TLINE *tln = new TLINE;
                tln->m_opcode = $1;
                tln->m_imm    = $2;
 
                if (tln->isdefined()) {
                        $$ = tln->eval();
                        delete tln;
                } else
                        $$ = tln;
        }
| loadop opb COMMA REG {
                TLINE *tln = new TLINE;
                ((TLINE*)$2)->m_opcode = OP_LOD;
                ((TLINE*)$2)->m_cond   = ((TLINE*)$1)->m_cond;
                ((TLINE*)$2)->m_opa    = $4;
 
                delete $1;
 
                if (((TLINE *)$2)->isdefined()) {
                        $$ = ((TLINE *)$2)->eval();
                        delete $2;
                } else
                        $$ = $2;
        }
| loadop opb COMMA multident {
                char    buf[256];
                sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());
                yyerror(buf);
                $$ = new VLINE();
                delete $1;
                delete $2;
                delete $4;
        }
| storop REG COMMA opb {
                TLINE *tln = new TLINE;
                tln->m_opcode = OP_STO;
                tln->m_cond   = ((TLINE*)$1)->m_cond;
                tln->m_imm    = ((TLINE*)$4)->m_imm;
                tln->m_opb    = ((TLINE*)$4)->m_opb;
                tln->m_opa    = $2;
 
                delete $1;
 
                if (tln->isdefined()) {
                        $$ = tln->eval();
                        delete tln;
                } else
                        $$ = tln;
        }
| storop multident COMMA opb {
                char    buf[256];
                sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$2)->m_id.c_str());
                yyerror(buf);
                $$ = new VLINE();
                delete $1;
                delete $2;
                delete $4;
        }
;
 
dualop: DUALOP  opcond {
        TLINE *tln = new TLINE();
        tln->m_opcode = $1;
        tln->m_cond   = $2;
        $$ = tln;
        }
;
 
singlop: SINGLOP opcond {
        TLINE *tln = new TLINE();
        tln->m_opcode = $1;
        tln->m_cond   = $2;
        $$ = tln;
        }
;
 
storop: STOROP opcond {
        TLINE *tln = new TLINE();
        tln->m_opcode = OP_STO;
        tln->m_cond   = $2;
        $$ = tln;
        }
;
 
loadop: LOADOP opcond {
        TLINE *tln = new TLINE();
        tln->m_opcode = OP_LOD;
        tln->m_cond   = $2;
        $$ = tln;
        }
;
 
bareop: BAREOP  opcond {
        TLINE *tln = new TLINE();
        tln->m_opcode = $1;
        tln->m_cond   = $2;
        $$ = tln;
        }
;
 
opcond:
        COND    { $$ = $1; }
|       %empty  { $$ = ZPARSER::ZIPC_ALWAYS; }
;
 
opb:
        expr    {
                TLINE *tln = new TLINE();
                tln->m_imm = $1;
                $$ = tln;
        }
|       expr PLUS REG {
                TLINE *tln = new TLINE();
                tln->m_imm = $1;
                tln->m_opb = $3;
                $$ = tln;
        }
|       expr '(' REG ')' {
                TLINE *tln = new TLINE();
                tln->m_imm = $1;
                tln->m_opb = $3;
                $$ = tln;
        }
|       '(' REG ')' {
                TLINE *tln = new TLINE();
                tln->m_imm = new AST_NUMBER(0);
                tln->m_opb = $2;
                $$ = tln;
        }
|       REG {
                TLINE *tln = new TLINE();
                tln->m_imm = new AST_NUMBER(0);
                tln->m_opb = $1;
                $$ = tln;
        }
;
 
expr:
        value                   { $$ = $1; }
|       MINUS value             { $$ = new AST_BRANCH('-',new AST_NUMBER(0), $2); }
|       expr PLUS value         { $$ = new AST_BRANCH('+',$1,$3); }
|       expr MINUS value        { $$ = new AST_BRANCH('-',$1,$3); }
|       expr TIMES value        { $$ = new AST_BRANCH('*',$1,$3); }
|       expr BOOLEANOR value    { $$ = new AST_BRANCH('o',$1,$3); }
|       expr BITWISEOR value    { $$ = new AST_BRANCH('|',$1,$3); }
|       expr BOOLEANAND value   { $$ = new AST_BRANCH('a',$1,$3); }
|       expr BITWISEAND value   { $$ = new AST_BRANCH('&',$1,$3); }
|       expr BITWISEXOR value   { $$ = new AST_BRANCH('^',$1,$3); }
|       '(' expr ')'            { $$ = $2; }
;
        /* expr OR  (|) value */
        /* expr XOR (^) value */
        /* expr AND (&) value */
 
value:
        INT     { $$ = new AST_NUMBER($1); }
| multident     { $$ = $1; }
| HERE          { $$ = new AST_NUMBER(global_parser_pc); }
;
 
multident:
        IDENTIFIER              { $$ = new AST_IDENTIFIER($1); delete $1; }
| multident DOT IDENTIFIER      { $$ = new AST_IDENTIFIER($1,$3); delete $3; }
;
%%
 
#include 
#include 
#include 
#include 
#include 
 
OBJFILE objcode;
 
void    yyerror(const char *str) {
        fprintf(stderr, "%s:%d: ERROR: %s\n", master_input_filename, yylineno, str);
        if (linecp) fprintf(stderr, "Offending line was: %s\n", linecp);
}
 
FILE    *run_preprocessor(const char *zname = NULL) {
        int     pipefd[2];
        int     pid;
 
        if (pipe(pipefd)!=0) {
                fprintf(stderr, "PIPE FAILED!\n");
                perror("O/S Err:");
                exit(-2);
        } if ((zname)&&(access(zname, R_OK)!=0)) { // if !zname, then use stdin
                fprintf(stderr, "Cannot open %s\n", zname);
                perror("O/S Err:");
                exit(-2);
        }
 
 
        if (0 == (pid = fork())) {
                int     fdin, fdout;
 
                // Child process -- run the preprocessor
                if (zname) {
                        fdin = open(zname, O_RDONLY);
                        close(STDIN_FILENO);
                        dup2(fdin, STDIN_FILENO);
                } // else use stdin, already set up
 
                close(pipefd[0]);
 
                fdout = pipefd[1];
                close(STDOUT_FILENO);
                dup2(fdout, STDOUT_FILENO);
 
                // This call should never return
                execlp("./zpp", "zpp", NULL);
 
                fprintf(stderr, "Could not start pre-processor!\n");
                perror("O/S Err:");
 
                exit(-5);
        }
 
        close(pipefd[1]);
        return fdopen(pipefd[0], "r");
}
 
int     main(int argc, char **argv) {
        int     skp = 0;
        const char      *zout_fname = NULL;
        master_input_filename = NULL;
 
        skp=1;
        for(int argn=0; argn+skp
                if (argv[argn+skp][0] == '-') {
                        if (argv[argn+skp][1] == 'o') {
                                if (zout_fname)
                                        free((void *)zout_fname);
                                zout_fname = strdup(argv[argn+skp+1]);
                                skp++;
                        }
 
                        skp++;
                } argv[argn] = argv[argn+skp];
        } argc -= skp;
 
        if (!zout_fname)
                zout_fname = "z.out";
 
        objcode.open(zout_fname);
 
        master_input_filename = NULL;
 
        if (argc > 0) {
                for(int argn=0; argn
                        extern  FILE    *yyin;
                        extern  void    yyrestart(FILE *);
                        FILE    *tst;
 
                        create_new_context();
                        if (master_input_filename)
                                free(master_input_filename);
                        master_input_filename = strdup(argv[argn]);
                        yyrestart(run_preprocessor(master_input_filename));
                        yylineno = 1;
                        yyparse();
                }
        } else { // Run from Stdin
                extern  FILE    *yyin;
                extern  void    yyrestart(FILE *);
 
                create_new_context();
                master_input_filename = strdup("(stdin)");
                yyin = run_preprocessor(NULL);
                yyrestart(yyin);
                yyparse();
        }
 
        if (!objcode.reduce())
                fprintf(stderr, "Not all symbols defined!\n");
}
 
 

Browse

Tools

Subversion Repositories zipcpu

[/] [zipcpu/] [trunk/] [sw/] [zasm/] [zasm.y] - Blame information for rev 13

Line No.	Rev	Author	Line
1	13	dgisselq	`/*******************************************************************************`
2			`**`
3			`** Filename: zasm.y`
4			`**`
5			`** Project: Zip CPU -- a small, lightweight, RISC CPU core`
6			`**`
7			`** Purpose: The parser for the Zip Assembler. This is actually not just`
8			`** the parser, but the main program as well.`
9			`**`
10			`** Creator: Dan Gisselquist, Ph.D.`
11			`** Gisselquist Tecnology, LLC`
12			`**`
13			`********************************************************************************`
14			`**`
15			`** Copyright (C) 2015, Gisselquist Technology, LLC`
16			`**`
17			`** This program is free software (firmware): you can redistribute it and/or`
18			`** modify it under the terms of the GNU General Public License as published`
19			`** by the Free Software Foundation, either version 3 of the License, or (at`
20			`** your option) any later version.`
21			`**`
22			`** This program is distributed in the hope that it will be useful, but WITHOUT`
23			`** ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or`
24			`** FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
25			`** for more details.`
26			`**`
27			`** You should have received a copy of the GNU General Public License along`
28			`** with this program. (It's in the $(ROOT)/doc directory, run make with no`
29			`** target there if the PDF file isn't present.) If not, see`
30			`** for a copy.`
31			`**`
32			`** License: GPL, v3, as defined and found on www.gnu.org,`
33			`** http://www.gnu.org/licenses/gpl.html`
34			`**`
35			`**`
36			`*******************************************************************************/`
37
38			`%{`
39			`#include`
40			`#include`
41			`#include "asmdata.h"`
42
43			`extern "C" int yylex(void);`
44			`extern "C" int yyparse(void);`
45			`// extern "C" FILE *yyin;`
46			`void yyerror(const char *);`
47			`unsigned int global_parser_pc;`
48			`char *master_input_filename = NULL;`
49			`extern int yylineno;`
50			`char *linecp = NULL; // A copy of the input line`
51			`%}`
52
53			`%token COMMA EQU PLUS MINUS TIMES HERE DOLLAR COLON`
54			`%token BOOLEANOR BITWISEOR BOOLEANAND BITWISEAND BITWISEXOR DOT`
55			`%token WORD FILL`
56			`%token LOADOP STOROP LDIOP`
57			`%token BAREOP BRANCHOP COND DUALOP IDENTIFIER INT LDHLOP REG SINGLOP`
58
59			`%union {`
60			`ZPARSER::ZIPREG u_reg;`
61			`ZPARSER::ZIPCOND u_cond;`
62			`int u_ival;`
63			`LEXOPCODE u_op;`
64			`char *u_id;`
65			`ASMLINE *u_ln;`
66			`AST *u_ast;`
67			`}`
68
69			`%type REG`
70			`%type COND opcond`
71			`%type INT`
72			`%type IDENTIFIER`
73			`%type BAREOP SINGLOP DUALOP BRANCHOP LDHLOP`
74			`%type unlabeledline instruction wordlist fillist opb`
75			`%type bareop singlop dualop loadop storop line`
76			`%type expr value multident`
77
78			`%% /* The grammar follows */`
79
80			`input:`
81			`%empty`
82			`\| input line { if ($2) {objcode += $2; global_parser_pc += $2->nlines(); if ($2->isdefined()) delete $2; } }`
83			`;`
84
85			`line:`
86			`'\n' { $$ = NULL; }`
87			`\| unlabeledline '\n' { $$ = $1; }`
88			`\| multident COLON unlabeledline '\n' {`
89			`if ($1->m_node_type == 'I') {`
90			`if (((AST_IDENTIFIER*)$1)->m_id[0] == 'L')`
91			`stb_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
92			`else`
93			`gbl_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
94			`delete $1;`
95			`}`
96			`$$ = $3;`
97			`}`
98			`\| multident COLON '\n' {`
99			`if ($1->m_node_type == 'I') {`
100			`if (((AST_IDENTIFIER*)$1)->m_id[0] == 'L')`
101			`stb_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
102			`else`
103			`gbl_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
104			`delete $1;`
105			`}`
106			`$$ = new VLINE();`
107			`}`
108			`\| multident EQU expr '\n' {`
109			`if ($1->m_node_type == 'I') {`
110			`stb_define(((AST_IDENTIFIER *)$1)->m_id, $3);`
111			`delete $1;`
112			`}`
113			`$$ = new VLINE();`
114			`}`
115			`;`
116
117			`unlabeledline:`
118			`instruction { $$ = $1; }`
119			`\| WORD wordlist { $$ = $2; }`
120			`\| FILL fillist { $$ = $2; }`
121			`;`
122
123			`wordlist:`
124			`expr {`
125			`if ($1->isdefined())`
126			`$$ = new DLINE($1->eval());`
127			`else {`
128			`$$ = new VLINE();`
129			`yyerror("ERROR: word list undefined");`
130			`}}`
131			`\| expr COMMA wordlist {`
132			`if ($1->isdefined())`
133			`$$ = new DLINE($1->eval());`
134			`else {`
135			`$$ = new VLINE();`
136			`yyerror("ERROR: word list undefined\n");`
137			`}}`
138			`;`
139
140			`fillist:`
141			`expr COMMA expr {`
142			`if (($1->isdefined())&&($3->isdefined())) {`
143			`int ntimes = $1->eval(),`
144			`val = $3->eval();`
145			`LLINE *ln = new LLINE();`
146			`for(int i=0; i`
147			`ln->addline(new DLINE(val));`
148			`$$ = ln;`
149			`} else {`
150			`yyerror("Fill list undefined\n");`
151			`$$ = new VLINE();`
152			`}`
153			`}`
154			`;`
155
156			`instruction:`
157			`dualop opb COMMA REG {`
158			`$$ = $1;`
159			`((TLINE)$1)->m_imm = ((TLINE)$2)->m_imm; ((TLINE*)$2)->m_imm = NULL;`
160			`((TLINE)$1)->m_opb = ((TLINE)$2)->m_opb;`
161			`((TLINE*)$1)->m_opa = $4;`
162			`if ($1->isdefined()) {`
163			`$$ = ((TLINE*)$1)->eval();`
164			`delete $1;`
165			`delete $2;`
166			`}`
167			`}`
168			`\| dualop opb COMMA multident {`
169			`char buf[256];`
170			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());`
171			`yyerror(buf);`
172			`$$ = new VLINE();`
173			`delete $1;`
174			`delete $2;`
175			`delete $4;`
176			`}`
177			`\| singlop opb {`
178			`$$ = $1;`
179			`((TLINE)$1)->m_imm = ((TLINE)$2)->m_imm; ((TLINE*)$2)->m_imm = NULL;`
180			`((TLINE)$1)->m_opb = ((TLINE)$2)->m_opb;`
181			`if ($1->isdefined()) {`
182			`$$ = ((TLINE *)$1)->eval();`
183			`delete $1;`
184			`}`
185			`}`
186			`\| bareop { $$ = $1; }`
187			`\| LDHLOP opcond expr COMMA REG {`
188			`TLINE *tln = new TLINE;`
189			`tln->m_opcode = $1;`
190			`tln->m_cond = $2;`
191			`tln->m_imm = $3;`
192			`tln->m_opa = $5;`
193
194			`if (tln->isdefined()) {`
195			`$$ = tln->eval();`
196			`delete tln;`
197			`} else`
198			`$$ = tln;`
199			`}`
200			`\| LDHLOP opcond expr COMMA multident {`
201			`char buf[256];`
202			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$5)->m_id.c_str());`
203			`yyerror(buf);`
204			`$$ = new VLINE();`
205			`delete $3;`
206			`delete $5;`
207			`}`
208			`\| LDIOP expr COMMA REG {`
209			`TLINE *tln = new TLINE;`
210			`tln->m_opcode = OP_LDI;`
211			`tln->m_cond = ZPARSER::ZIPC_ALWAYS;`
212			`tln->m_imm = $2;`
213			`tln->m_opa = $4;`
214
215			`if (tln->isdefined()) {`
216			`$$ = tln->eval();`
217			`delete tln;`
218			`} else`
219			`$$ = tln;`
220			`}`
221			`\| LDIOP expr COMMA multident {`
222			`char buf[256];`
223			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());`
224			`yyerror(buf);`
225			`$$ = new VLINE();`
226			`delete $2;`
227			`delete $4;`
228			`}`
229			`\| BRANCHOP expr {`
230			`TLINE *tln = new TLINE;`
231			`tln->m_opcode = $1;`
232			`tln->m_imm = $2;`
233
234			`if (tln->isdefined()) {`
235			`$$ = tln->eval();`
236			`delete tln;`
237			`} else`
238			`$$ = tln;`
239			`}`
240			`\| loadop opb COMMA REG {`
241			`TLINE *tln = new TLINE;`
242			`((TLINE*)$2)->m_opcode = OP_LOD;`
243			`((TLINE)$2)->m_cond = ((TLINE)$1)->m_cond;`
244			`((TLINE*)$2)->m_opa = $4;`
245
246			`delete $1;`
247
248			`if (((TLINE *)$2)->isdefined()) {`
249			`$$ = ((TLINE *)$2)->eval();`
250			`delete $2;`
251			`} else`
252			`$$ = $2;`
253			`}`
254			`\| loadop opb COMMA multident {`
255			`char buf[256];`
256			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());`
257			`yyerror(buf);`
258			`$$ = new VLINE();`
259			`delete $1;`
260			`delete $2;`
261			`delete $4;`
262			`}`
263			`\| storop REG COMMA opb {`
264			`TLINE *tln = new TLINE;`
265			`tln->m_opcode = OP_STO;`
266			`tln->m_cond = ((TLINE*)$1)->m_cond;`
267			`tln->m_imm = ((TLINE*)$4)->m_imm;`
268			`tln->m_opb = ((TLINE*)$4)->m_opb;`
269			`tln->m_opa = $2;`
270
271			`delete $1;`
272
273			`if (tln->isdefined()) {`
274			`$$ = tln->eval();`
275			`delete tln;`
276			`} else`
277			`$$ = tln;`
278			`}`
279			`\| storop multident COMMA opb {`
280			`char buf[256];`
281			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$2)->m_id.c_str());`
282			`yyerror(buf);`
283			`$$ = new VLINE();`
284			`delete $1;`
285			`delete $2;`
286			`delete $4;`
287			`}`
288			`;`
289
290			`dualop: DUALOP opcond {`
291			`TLINE *tln = new TLINE();`
292			`tln->m_opcode = $1;`
293			`tln->m_cond = $2;`
294			`$$ = tln;`
295			`}`
296			`;`
297
298			`singlop: SINGLOP opcond {`
299			`TLINE *tln = new TLINE();`
300			`tln->m_opcode = $1;`
301			`tln->m_cond = $2;`
302			`$$ = tln;`
303			`}`
304			`;`
305
306			`storop: STOROP opcond {`
307			`TLINE *tln = new TLINE();`
308			`tln->m_opcode = OP_STO;`
309			`tln->m_cond = $2;`
310			`$$ = tln;`
311			`}`
312			`;`
313
314			`loadop: LOADOP opcond {`
315			`TLINE *tln = new TLINE();`
316			`tln->m_opcode = OP_LOD;`
317			`tln->m_cond = $2;`
318			`$$ = tln;`
319			`}`
320			`;`
321
322			`bareop: BAREOP opcond {`
323			`TLINE *tln = new TLINE();`
324			`tln->m_opcode = $1;`
325			`tln->m_cond = $2;`
326			`$$ = tln;`
327			`}`
328			`;`
329
330			`opcond:`
331			`COND { $$ = $1; }`
332			`\| %empty { $$ = ZPARSER::ZIPC_ALWAYS; }`
333			`;`
334
335			`opb:`
336			`expr {`
337			`TLINE *tln = new TLINE();`
338			`tln->m_imm = $1;`
339			`$$ = tln;`
340			`}`
341			`\| expr PLUS REG {`
342			`TLINE *tln = new TLINE();`
343			`tln->m_imm = $1;`
344			`tln->m_opb = $3;`
345			`$$ = tln;`
346			`}`
347			`\| expr '(' REG ')' {`
348			`TLINE *tln = new TLINE();`
349			`tln->m_imm = $1;`
350			`tln->m_opb = $3;`
351			`$$ = tln;`
352			`}`
353			`\| '(' REG ')' {`
354			`TLINE *tln = new TLINE();`
355			`tln->m_imm = new AST_NUMBER(0);`
356			`tln->m_opb = $2;`
357			`$$ = tln;`
358			`}`
359			`\| REG {`
360			`TLINE *tln = new TLINE();`
361			`tln->m_imm = new AST_NUMBER(0);`
362			`tln->m_opb = $1;`
363			`$$ = tln;`
364			`}`
365			`;`
366
367			`expr:`
368			`value { $$ = $1; }`
369			`\| MINUS value { $$ = new AST_BRANCH('-',new AST_NUMBER(0), $2); }`
370			`\| expr PLUS value { $$ = new AST_BRANCH('+',$1,$3); }`
371			`\| expr MINUS value { $$ = new AST_BRANCH('-',$1,$3); }`
372			`\| expr TIMES value { $$ = new AST_BRANCH('*',$1,$3); }`
373			`\| expr BOOLEANOR value { $$ = new AST_BRANCH('o',$1,$3); }`
374			`\| expr BITWISEOR value { $$ = new AST_BRANCH('\|',$1,$3); }`
375			`\| expr BOOLEANAND value { $$ = new AST_BRANCH('a',$1,$3); }`
376			`\| expr BITWISEAND value { $$ = new AST_BRANCH('&',$1,$3); }`
377			`\| expr BITWISEXOR value { $$ = new AST_BRANCH('^',$1,$3); }`
378			`\| '(' expr ')' { $$ = $2; }`
379			`;`
380			`/* expr OR (\|) value */`
381			`/* expr XOR (^) value */`
382			`/* expr AND (&) value */`
383
384			`value:`
385			`INT { $$ = new AST_NUMBER($1); }`
386			`\| multident { $$ = $1; }`
387			`\| HERE { $$ = new AST_NUMBER(global_parser_pc); }`
388			`;`
389
390			`multident:`
391			`IDENTIFIER { $$ = new AST_IDENTIFIER($1); delete $1; }`
392			`\| multident DOT IDENTIFIER { $$ = new AST_IDENTIFIER($1,$3); delete $3; }`
393			`;`
394			`%%`
395
396			`#include`
397			`#include`
398			`#include`
399			`#include`
400			`#include`
401
402			`OBJFILE objcode;`
403
404			`void yyerror(const char *str) {`
405			`fprintf(stderr, "%s:%d: ERROR: %s\n", master_input_filename, yylineno, str);`
406			`if (linecp) fprintf(stderr, "Offending line was: %s\n", linecp);`
407			`}`
408
409			`FILE run_preprocessor(const char zname = NULL) {`
410			`int pipefd[2];`
411			`int pid;`
412
413			`if (pipe(pipefd)!=0) {`
414			`fprintf(stderr, "PIPE FAILED!\n");`
415			`perror("O/S Err:");`
416			`exit(-2);`
417			`} if ((zname)&&(access(zname, R_OK)!=0)) { // if !zname, then use stdin`
418			`fprintf(stderr, "Cannot open %s\n", zname);`
419			`perror("O/S Err:");`
420			`exit(-2);`
421			`}`
422
423
424			`if (0 == (pid = fork())) {`
425			`int fdin, fdout;`
426
427			`// Child process -- run the preprocessor`
428			`if (zname) {`
429			`fdin = open(zname, O_RDONLY);`
430			`close(STDIN_FILENO);`
431			`dup2(fdin, STDIN_FILENO);`
432			`} // else use stdin, already set up`
433
434			`close(pipefd[0]);`
435
436			`fdout = pipefd[1];`
437			`close(STDOUT_FILENO);`
438			`dup2(fdout, STDOUT_FILENO);`
439
440			`// This call should never return`
441			`execlp("./zpp", "zpp", NULL);`
442
443			`fprintf(stderr, "Could not start pre-processor!\n");`
444			`perror("O/S Err:");`
445
446			`exit(-5);`
447			`}`
448
449			`close(pipefd[1]);`
450			`return fdopen(pipefd[0], "r");`
451			`}`
452
453			`int main(int argc, char **argv) {`
454			`int skp = 0;`
455			`const char *zout_fname = NULL;`
456			`master_input_filename = NULL;`
457
458			`skp=1;`
459			`for(int argn=0; argn+skp`
460			`if (argv[argn+skp][0] == '-') {`
461			`if (argv[argn+skp][1] == 'o') {`
462			`if (zout_fname)`
463			`free((void *)zout_fname);`
464			`zout_fname = strdup(argv[argn+skp+1]);`
465			`skp++;`
466			`}`
467
468			`skp++;`
469			`} argv[argn] = argv[argn+skp];`
470			`} argc -= skp;`
471
472			`if (!zout_fname)`
473			`zout_fname = "z.out";`
474
475			`objcode.open(zout_fname);`
476
477			`master_input_filename = NULL;`
478
479			`if (argc > 0) {`
480			`for(int argn=0; argn`
481			`extern FILE *yyin;`
482			`extern void yyrestart(FILE *);`
483			`FILE *tst;`
484
485			`create_new_context();`
486			`if (master_input_filename)`
487			`free(master_input_filename);`
488			`master_input_filename = strdup(argv[argn]);`
489			`yyrestart(run_preprocessor(master_input_filename));`
490			`yylineno = 1;`
491			`yyparse();`
492			`}`
493			`} else { // Run from Stdin`
494			`extern FILE *yyin;`
495			`extern void yyrestart(FILE *);`
496
497			`create_new_context();`
498			`master_input_filename = strdup("(stdin)");`
499			`yyin = run_preprocessor(NULL);`
500			`yyrestart(yyin);`
501			`yyparse();`
502			`}`
503
504			`if (!objcode.reduce())`
505			`fprintf(stderr, "Not all symbols defined!\n");`
506			`}`
507
508