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

Subversion Repositories zipcpu

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

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 Technology, 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 
 #include "asmdata.h"
 
#define DEFAULT_OUTPUT_FNAME    "z.out"
#define YYDEBUG 1
 
  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
 
%left BOOLEANOR
%left BOOLEANAND
%left BITWISEOR BITWISEXOR
%left BITWISEAND
%left '%'
%left PLUS MINUS
%left TIMES '/'
 
%% /* 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");
        }}
| wordlist COMMA expr {
        if ($3->isdefined()) {
                LLINE   *ln;
                if ($1->m_state == 'L') {
                        ln = ((LLINE *)$1);
                } else {
                        ln = new LLINE();
                        ln->addline($1);
                } ln->addline(new DLINE($3->eval()));
                $$ = ln;
        } 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 %prec TIMES  { $$ = new AST_BRANCH('-',new AST_NUMBER(0), $2); }
|       expr PLUS expr          { $$ = new AST_BRANCH('+',$1,$3); }
|       expr MINUS expr         { $$ = new AST_BRANCH('-',$1,$3); }
|       expr TIMES expr         { $$ = new AST_BRANCH('*',$1,$3); }
|       expr '/' expr           { $$ = new AST_BRANCH('/',$1,$3); }
|       expr '%' expr           { $$ = new AST_BRANCH('%',$1,$3); }
|       expr BOOLEANOR expr     { $$ = new AST_BRANCH('o',$1,$3); }
|       expr BITWISEOR expr     { $$ = new AST_BRANCH('|',$1,$3); }
|       expr BOOLEANAND expr    { $$ = new AST_BRANCH('a',$1,$3); }
|       expr BITWISEAND expr    { $$ = new AST_BRANCH('&',$1,$3); }
|       expr BITWISEXOR expr    { $$ = 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 
#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(pid_t &pid, const char *path = NULL, const char *zname = NULL) {
        int     pipefd[2];
 
        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
 
                // Close the reader: we write only
                close(pipefd[0]);
 
                // Adjust stdout to write to our pipe instead of anywhere else
                fdout = pipefd[1];
                close(STDOUT_FILENO);
                dup2(fdout, STDOUT_FILENO);
 
                char    *zpp_path;
                if (path != NULL) {
                        zpp_path = new char[strlen(path+1+strlen("/zpp"))];
                        strcpy(zpp_path, path);
                        strcat(zpp_path, "/zpp");
                } else zpp_path = strdup("zpp");
 
                // This call should never return
                //      We have to pass the name here, rather than an open file,
                // since zpp needs to mark for us what file it is in at all
                // times.
                if (zname)
                        execlp(zpp_path, "zpp", zname, NULL);
                else
                        execlp(zpp_path, "zpp", NULL);
 
                fprintf(stderr, "Could not start pre-processor!\n");
                perror("O/S Err:");
 
                exit(-5);
        }
 
        close(pipefd[1]);
        return fdopen(pipefd[0], "r");
}
 
void    usage(void) {
        printf("USAGE: zasm [-h] [-d] [-E] [-o ]  [ ]* ...\n");
        printf("\t-d\tTurns on debugging in the parser\n");
        printf("\t-E\tProduces preprocessor output only\n");
        printf("\t-h\tDisplays this message\n");
        printf("\t-o \tWrites the output to .  The\n"
                "\t\tdefault output file is \"" DEFAULT_OUTPUT_FNAME "\".\n");
 
        printf("\t-I \tSearch  for include files.\n");
}
 
int     main(int argc, char **argv) {
        int     skp = 0;
        const char      *zout_fname = NULL;
        char            *path_to_zasm = NULL;
        bool    preprocess_only = false;
        FILE            *ppout;
        pid_t           zpp_pid;
        int             zpp_status;
        std::string     inclist;
        if (NULL != getenv("ZIPINC"))
                inclist = getenv("ZIPINC");
 
        master_input_filename = NULL;
 
        // Find what directory zasm is in, so that we can find zpp when
        // necessary.
        path_to_zasm = NULL;
        if (strchr(argv[0], '/')) {
                path_to_zasm = strdup(argv[0]);
                char *ptr = strrchr(path_to_zasm,'/');
                *ptr = '\0';
        }
 
        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++;
                        } else if (argv[argn+skp][1] == 'E')
                                preprocess_only = true;
                        else if (argv[argn+skp][1] == 'I') {
                                if (argv[argn+skp][2]) {
                                        if (inclist.size() != 0) {
                                                inclist += std::string(":");
                                                inclist += &argv[argn+skp][2];
                                        } else
                                                inclist = &argv[argn+skp][2];
                                } else if (argn+skp+1
                                        if (inclist.size() != 0) {
                                                inclist += std::string(":");
                                                inclist += argv[argn+skp+1];
                                        } else
                                                inclist = argv[argn+skp+1];
                                        skp++;
                                }
                        } else if (argv[argn+skp][1] == 'd')
                                yydebug = 1;
                        else if (argv[argn+skp][1] == 'h') {
                                usage();
                                exit(0);
                        }
 
                        skp++;
                        argn--;
                } else {
                        argv[argn] = argv[argn+skp];
                }
        } argc -= skp;
 
        if (zout_fname) {
                for(int argn=0; argn
                        if (strcmp(zout_fname, argv[argn])==0) {
                                fprintf(stderr, "ERR: Cowardly refusing to overwrite \'%s\'\n", zout_fname);
                                exit(-2);
                        }
                }
        }
 
        if (preprocess_only) {
                objcode.open("/dev/null");
                if (zout_fname)
                        ppout = fopen(zout_fname, "w");
                else
                        ppout = stdout;
        } else {
                if (!zout_fname)
                        zout_fname = DEFAULT_OUTPUT_FNAME;
 
                objcode.open(zout_fname);
        }
 
        setenv("ZIPINC",inclist.c_str(), 1);
        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]);
                        if (preprocess_only) {
                                FILE    *fp = run_preprocessor(zpp_pid, path_to_zasm, master_input_filename);
                                int     ch;
                                while(EOF != (ch = fgetc(fp)))
                                        fputc(ch, ppout);
                                waitpid(zpp_pid, &zpp_status, WNOHANG);
                        } else {
                                yyrestart(run_preprocessor(zpp_pid, path_to_zasm, master_input_filename));
                                yylineno = 1;
                                yyparse();
                                waitpid(zpp_pid, &zpp_status, WNOHANG);
                        }
                }
        } else { // Run from Stdin
                extern  FILE    *yyin;
                extern  void    yyrestart(FILE *);
 
                create_new_context();
                master_input_filename = strdup("(stdin)");
                if (preprocess_only) {
                        int     ch;
                                FILE    *fp = run_preprocessor(zpp_pid, path_to_zasm, master_input_filename);
                        while(EOF != (ch = fgetc(fp)))
                                fputc(ch, ppout);
                        waitpid(zpp_pid, &zpp_status, WNOHANG);
                } else {
                        yyin = run_preprocessor(zpp_pid, NULL);
                        yyrestart(yyin);
                        yyparse();
                        waitpid(zpp_pid, &zpp_status, WNOHANG);
                }
        }
 
        if (0 != WEXITSTATUS(zpp_status)) {
                if (!preprocess_only) {
                        objcode.close();
                        unlink(zout_fname);
                }
        } if (!objcode.reduce())
                fprintf(stderr, "Not all symbols defined!\n");
}
 
 

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	69	dgisselq	`** Gisselquist Technology, LLC`
12	13	dgisselq	`**`
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	36	dgisselq	`#include`
41	13	dgisselq	`#include`
42			`#include "asmdata.h"`
43
44	26	dgisselq	`#define DEFAULT_OUTPUT_FNAME "z.out"`
45			`#define YYDEBUG 1`
46
47	13	dgisselq	`extern "C" int yylex(void);`
48			`extern "C" int yyparse(void);`
49			`// extern "C" FILE *yyin;`
50			`void yyerror(const char *);`
51			`unsigned int global_parser_pc;`
52			`char *master_input_filename = NULL;`
53			`extern int yylineno;`
54			`char *linecp = NULL; // A copy of the input line`
55			`%}`
56
57			`%token COMMA EQU PLUS MINUS TIMES HERE DOLLAR COLON`
58			`%token BOOLEANOR BITWISEOR BOOLEANAND BITWISEAND BITWISEXOR DOT`
59			`%token WORD FILL`
60			`%token LOADOP STOROP LDIOP`
61			`%token BAREOP BRANCHOP COND DUALOP IDENTIFIER INT LDHLOP REG SINGLOP`
62
63			`%union {`
64			`ZPARSER::ZIPREG u_reg;`
65			`ZPARSER::ZIPCOND u_cond;`
66			`int u_ival;`
67			`LEXOPCODE u_op;`
68			`char *u_id;`
69			`ASMLINE *u_ln;`
70			`AST *u_ast;`
71			`}`
72
73			`%type REG`
74			`%type COND opcond`
75			`%type INT`
76			`%type IDENTIFIER`
77			`%type BAREOP SINGLOP DUALOP BRANCHOP LDHLOP`
78			`%type unlabeledline instruction wordlist fillist opb`
79			`%type bareop singlop dualop loadop storop line`
80			`%type expr value multident`
81
82	26	dgisselq	`%left BOOLEANOR`
83			`%left BOOLEANAND`
84			`%left BITWISEOR BITWISEXOR`
85			`%left BITWISEAND`
86	34	dgisselq	`%left '%'`
87	26	dgisselq	`%left PLUS MINUS`
88			`%left TIMES '/'`
89
90	13	dgisselq	`%% /* The grammar follows */`
91
92			`input:`
93			`%empty`
94			`\| input line { if ($2) {objcode += $2; global_parser_pc += $2->nlines(); if ($2->isdefined()) delete $2; } }`
95			`;`
96
97			`line:`
98			`'\n' { $$ = NULL; }`
99			`\| unlabeledline '\n' { $$ = $1; }`
100			`\| multident COLON unlabeledline '\n' {`
101			`if ($1->m_node_type == 'I') {`
102			`if (((AST_IDENTIFIER*)$1)->m_id[0] == 'L')`
103			`stb_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
104			`else`
105			`gbl_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
106			`delete $1;`
107			`}`
108			`$$ = $3;`
109			`}`
110			`\| multident COLON '\n' {`
111			`if ($1->m_node_type == 'I') {`
112			`if (((AST_IDENTIFIER*)$1)->m_id[0] == 'L')`
113			`stb_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
114			`else`
115			`gbl_define(((AST_IDENTIFIER *)$1)->m_id, new AST_NUMBER(global_parser_pc));`
116			`delete $1;`
117			`}`
118			`$$ = new VLINE();`
119			`}`
120			`\| multident EQU expr '\n' {`
121			`if ($1->m_node_type == 'I') {`
122			`stb_define(((AST_IDENTIFIER *)$1)->m_id, $3);`
123			`delete $1;`
124			`}`
125			`$$ = new VLINE();`
126			`}`
127			`;`
128
129			`unlabeledline:`
130			`instruction { $$ = $1; }`
131			`\| WORD wordlist { $$ = $2; }`
132			`\| FILL fillist { $$ = $2; }`
133			`;`
134
135			`wordlist:`
136			`expr {`
137			`if ($1->isdefined())`
138			`$$ = new DLINE($1->eval());`
139			`else {`
140			`$$ = new VLINE();`
141			`yyerror("ERROR: word list undefined");`
142			`}}`
143	16	dgisselq	`\| wordlist COMMA expr {`
144			`if ($3->isdefined()) {`
145			`LLINE *ln;`
146			`if ($1->m_state == 'L') {`
147			`ln = ((LLINE *)$1);`
148			`} else {`
149			`ln = new LLINE();`
150			`ln->addline($1);`
151			`} ln->addline(new DLINE($3->eval()));`
152			`$$ = ln;`
153			`} else {`
154	13	dgisselq	`$$ = new VLINE();`
155			`yyerror("ERROR: word list undefined\n");`
156			`}}`
157			`;`
158
159			`fillist:`
160			`expr COMMA expr {`
161			`if (($1->isdefined())&&($3->isdefined())) {`
162			`int ntimes = $1->eval(),`
163			`val = $3->eval();`
164			`LLINE *ln = new LLINE();`
165			`for(int i=0; i`
166			`ln->addline(new DLINE(val));`
167			`$$ = ln;`
168			`} else {`
169			`yyerror("Fill list undefined\n");`
170			`$$ = new VLINE();`
171			`}`
172			`}`
173			`;`
174
175			`instruction:`
176			`dualop opb COMMA REG {`
177			`$$ = $1;`
178			`((TLINE)$1)->m_imm = ((TLINE)$2)->m_imm; ((TLINE*)$2)->m_imm = NULL;`
179			`((TLINE)$1)->m_opb = ((TLINE)$2)->m_opb;`
180			`((TLINE*)$1)->m_opa = $4;`
181			`if ($1->isdefined()) {`
182			`$$ = ((TLINE*)$1)->eval();`
183			`delete $1;`
184			`delete $2;`
185			`}`
186			`}`
187			`\| dualop opb COMMA multident {`
188			`char buf[256];`
189			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());`
190			`yyerror(buf);`
191			`$$ = new VLINE();`
192			`delete $1;`
193			`delete $2;`
194			`delete $4;`
195			`}`
196			`\| singlop opb {`
197			`$$ = $1;`
198			`((TLINE)$1)->m_imm = ((TLINE)$2)->m_imm; ((TLINE*)$2)->m_imm = NULL;`
199			`((TLINE)$1)->m_opb = ((TLINE)$2)->m_opb;`
200			`if ($1->isdefined()) {`
201			`$$ = ((TLINE *)$1)->eval();`
202			`delete $1;`
203			`}`
204			`}`
205			`\| bareop { $$ = $1; }`
206			`\| LDHLOP opcond expr COMMA REG {`
207			`TLINE *tln = new TLINE;`
208			`tln->m_opcode = $1;`
209			`tln->m_cond = $2;`
210			`tln->m_imm = $3;`
211			`tln->m_opa = $5;`
212
213			`if (tln->isdefined()) {`
214			`$$ = tln->eval();`
215			`delete tln;`
216			`} else`
217			`$$ = tln;`
218			`}`
219			`\| LDHLOP opcond expr COMMA multident {`
220			`char buf[256];`
221			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$5)->m_id.c_str());`
222			`yyerror(buf);`
223			`$$ = new VLINE();`
224			`delete $3;`
225			`delete $5;`
226			`}`
227			`\| LDIOP expr COMMA REG {`
228			`TLINE *tln = new TLINE;`
229			`tln->m_opcode = OP_LDI;`
230			`tln->m_cond = ZPARSER::ZIPC_ALWAYS;`
231			`tln->m_imm = $2;`
232			`tln->m_opa = $4;`
233
234			`if (tln->isdefined()) {`
235			`$$ = tln->eval();`
236			`delete tln;`
237			`} else`
238			`$$ = tln;`
239			`}`
240			`\| LDIOP expr COMMA multident {`
241			`char buf[256];`
242			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());`
243			`yyerror(buf);`
244			`$$ = new VLINE();`
245			`delete $2;`
246			`delete $4;`
247			`}`
248			`\| BRANCHOP expr {`
249			`TLINE *tln = new TLINE;`
250			`tln->m_opcode = $1;`
251			`tln->m_imm = $2;`
252
253			`if (tln->isdefined()) {`
254			`$$ = tln->eval();`
255			`delete tln;`
256			`} else`
257			`$$ = tln;`
258			`}`
259			`\| loadop opb COMMA REG {`
260			`TLINE *tln = new TLINE;`
261			`((TLINE*)$2)->m_opcode = OP_LOD;`
262			`((TLINE)$2)->m_cond = ((TLINE)$1)->m_cond;`
263			`((TLINE*)$2)->m_opa = $4;`
264
265			`delete $1;`
266
267			`if (((TLINE *)$2)->isdefined()) {`
268			`$$ = ((TLINE *)$2)->eval();`
269			`delete $2;`
270			`} else`
271			`$$ = $2;`
272			`}`
273			`\| loadop opb COMMA multident {`
274			`char buf[256];`
275			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$4)->m_id.c_str());`
276			`yyerror(buf);`
277			`$$ = new VLINE();`
278			`delete $1;`
279			`delete $2;`
280			`delete $4;`
281			`}`
282			`\| storop REG COMMA opb {`
283			`TLINE *tln = new TLINE;`
284			`tln->m_opcode = OP_STO;`
285			`tln->m_cond = ((TLINE*)$1)->m_cond;`
286			`tln->m_imm = ((TLINE*)$4)->m_imm;`
287			`tln->m_opb = ((TLINE*)$4)->m_opb;`
288			`tln->m_opa = $2;`
289
290			`delete $1;`
291
292			`if (tln->isdefined()) {`
293			`$$ = tln->eval();`
294			`delete tln;`
295			`} else`
296			`$$ = tln;`
297			`}`
298			`\| storop multident COMMA opb {`
299			`char buf[256];`
300			`sprintf(buf, "%s is not a register", ((AST_IDENTIFIER *)$2)->m_id.c_str());`
301			`yyerror(buf);`
302			`$$ = new VLINE();`
303			`delete $1;`
304			`delete $2;`
305			`delete $4;`
306			`}`
307			`;`
308
309			`dualop: DUALOP opcond {`
310			`TLINE *tln = new TLINE();`
311			`tln->m_opcode = $1;`
312			`tln->m_cond = $2;`
313			`$$ = tln;`
314			`}`
315			`;`
316
317			`singlop: SINGLOP opcond {`
318			`TLINE *tln = new TLINE();`
319			`tln->m_opcode = $1;`
320			`tln->m_cond = $2;`
321			`$$ = tln;`
322			`}`
323			`;`
324
325			`storop: STOROP opcond {`
326			`TLINE *tln = new TLINE();`
327			`tln->m_opcode = OP_STO;`
328			`tln->m_cond = $2;`
329			`$$ = tln;`
330			`}`
331			`;`
332
333			`loadop: LOADOP opcond {`
334			`TLINE *tln = new TLINE();`
335			`tln->m_opcode = OP_LOD;`
336			`tln->m_cond = $2;`
337			`$$ = tln;`
338			`}`
339			`;`
340
341			`bareop: BAREOP opcond {`
342			`TLINE *tln = new TLINE();`
343			`tln->m_opcode = $1;`
344			`tln->m_cond = $2;`
345			`$$ = tln;`
346			`}`
347			`;`
348
349			`opcond:`
350			`COND { $$ = $1; }`
351			`\| %empty { $$ = ZPARSER::ZIPC_ALWAYS; }`
352			`;`
353
354			`opb:`
355			`expr {`
356			`TLINE *tln = new TLINE();`
357			`tln->m_imm = $1;`
358			`$$ = tln;`
359			`}`
360			`\| expr PLUS REG {`
361			`TLINE *tln = new TLINE();`
362			`tln->m_imm = $1;`
363			`tln->m_opb = $3;`
364			`$$ = tln;`
365			`}`
366			`\| expr '(' REG ')' {`
367			`TLINE *tln = new TLINE();`
368			`tln->m_imm = $1;`
369			`tln->m_opb = $3;`
370			`$$ = tln;`
371			`}`
372			`\| '(' REG ')' {`
373			`TLINE *tln = new TLINE();`
374			`tln->m_imm = new AST_NUMBER(0);`
375			`tln->m_opb = $2;`
376			`$$ = tln;`
377			`}`
378			`\| REG {`
379			`TLINE *tln = new TLINE();`
380			`tln->m_imm = new AST_NUMBER(0);`
381			`tln->m_opb = $1;`
382			`$$ = tln;`
383			`}`
384			`;`
385
386			`expr:`
387			`value { $$ = $1; }`
388	34	dgisselq	`\| MINUS value %prec TIMES { $$ = new AST_BRANCH('-',new AST_NUMBER(0), $2); }`
389			`\| expr PLUS expr { $$ = new AST_BRANCH('+',$1,$3); }`
390			`\| expr MINUS expr { $$ = new AST_BRANCH('-',$1,$3); }`
391			`\| expr TIMES expr { $$ = new AST_BRANCH('*',$1,$3); }`
392			`\| expr '/' expr { $$ = new AST_BRANCH('/',$1,$3); }`
393			`\| expr '%' expr { $$ = new AST_BRANCH('%',$1,$3); }`
394			`\| expr BOOLEANOR expr { $$ = new AST_BRANCH('o',$1,$3); }`
395			`\| expr BITWISEOR expr { $$ = new AST_BRANCH('\|',$1,$3); }`
396			`\| expr BOOLEANAND expr { $$ = new AST_BRANCH('a',$1,$3); }`
397			`\| expr BITWISEAND expr { $$ = new AST_BRANCH('&',$1,$3); }`
398			`\| expr BITWISEXOR expr { $$ = new AST_BRANCH('^',$1,$3); }`
399	13	dgisselq	`\| '(' expr ')' { $$ = $2; }`
400			`;`
401			`/* expr OR (\|) value */`
402			`/* expr XOR (^) value */`
403			`/* expr AND (&) value */`
404
405			`value:`
406			`INT { $$ = new AST_NUMBER($1); }`
407			`\| multident { $$ = $1; }`
408			`\| HERE { $$ = new AST_NUMBER(global_parser_pc); }`
409			`;`
410
411			`multident:`
412			`IDENTIFIER { $$ = new AST_IDENTIFIER($1); delete $1; }`
413			`\| multident DOT IDENTIFIER { $$ = new AST_IDENTIFIER($1,$3); delete $3; }`
414			`;`
415			`%%`
416
417			`#include`
418			`#include`
419	26	dgisselq	`#include`
420	13	dgisselq	`#include`
421			`#include`
422			`#include`
423	36	dgisselq	`#include`
424	13	dgisselq
425			`OBJFILE objcode;`
426
427			`void yyerror(const char *str) {`
428			`fprintf(stderr, "%s:%d: ERROR: %s\n", master_input_filename, yylineno, str);`
429			`if (linecp) fprintf(stderr, "Offending line was: %s\n", linecp);`
430			`}`
431
432	26	dgisselq	`FILE run_preprocessor(pid_t &pid, const char path = NULL, const char *zname = NULL) {`
433	13	dgisselq	`int pipefd[2];`
434
435			`if (pipe(pipefd)!=0) {`
436			`fprintf(stderr, "PIPE FAILED!\n");`
437			`perror("O/S Err:");`
438			`exit(-2);`
439			`} if ((zname)&&(access(zname, R_OK)!=0)) { // if !zname, then use stdin`
440			`fprintf(stderr, "Cannot open %s\n", zname);`
441			`perror("O/S Err:");`
442			`exit(-2);`
443			`}`
444
445
446			`if (0 == (pid = fork())) {`
447			`int fdin, fdout;`
448
449			`// Child process -- run the preprocessor`
450
451	16	dgisselq	`// Close the reader: we write only`
452	13	dgisselq	`close(pipefd[0]);`
453
454	16	dgisselq	`// Adjust stdout to write to our pipe instead of anywhere else`
455	13	dgisselq	`fdout = pipefd[1];`
456			`close(STDOUT_FILENO);`
457			`dup2(fdout, STDOUT_FILENO);`
458
459	16	dgisselq	`char *zpp_path;`
460			`if (path != NULL) {`
461			`zpp_path = new char[strlen(path+1+strlen("/zpp"))];`
462			`strcpy(zpp_path, path);`
463			`strcat(zpp_path, "/zpp");`
464			`} else zpp_path = strdup("zpp");`
465
466	13	dgisselq	`// This call should never return`
467	16	dgisselq	`// We have to pass the name here, rather than an open file,`
468			`// since zpp needs to mark for us what file it is in at all`
469			`// times.`
470			`if (zname)`
471			`execlp(zpp_path, "zpp", zname, NULL);`
472			`else`
473			`execlp(zpp_path, "zpp", NULL);`
474	13	dgisselq
475			`fprintf(stderr, "Could not start pre-processor!\n");`
476			`perror("O/S Err:");`
477
478			`exit(-5);`
479			`}`
480
481			`close(pipefd[1]);`
482			`return fdopen(pipefd[0], "r");`
483			`}`
484
485	26	dgisselq	`void usage(void) {`
486			`printf("USAGE: zasm [-h] [-d] [-E] [-o ] [ ]* ...\n");`
487			`printf("\t-d\tTurns on debugging in the parser\n");`
488			`printf("\t-E\tProduces preprocessor output only\n");`
489			`printf("\t-h\tDisplays this message\n");`
490			`printf("\t-o \tWrites the output to . The\n"`
491			`"\t\tdefault output file is \"" DEFAULT_OUTPUT_FNAME "\".\n");`
492
493			`printf("\t-I` `\tSearch` `for include files.\n");`
494			`}`
495
496	13	dgisselq	`int main(int argc, char **argv) {`
497			`int skp = 0;`
498			`const char *zout_fname = NULL;`
499	16	dgisselq	`char *path_to_zasm = NULL;`
500			`bool preprocess_only = false;`

Browse

Tools

Subversion Repositories zipcpu

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