解释器的代码....

 

这个是书上的例子,

 

%{
#include <stdio.h>
#include <stdlib.h>
#define STRSIZE  64
#include  " y.tab.h "
#include  " intall.h "
extern void lexerror() ;
int strcnt  =   0 ;
char string [ STRSIZE + 1 ]   = { 0 } ;
%}
%start STR1 COMM
%%
<INITIAL> " + "     {return(ADDOP) ; }
<INITIAL> " - "     {return(SUBOP) ; }
<INITIAL> " * "     {return(MULOP) ; }
<INITIAL> " / "     {return(DIVOP) ; }

<INITIAL> " = "     {return(ASGNOP) ; }
<INITIAL> " == "     {return(EQOP) ; }
<INITIAL> " > "     {return(GTOP) ; }
<INITIAL> " >= "     {return(GEOP) ; }
<INITIAL> " < "     {return(LSOP) ; }
<INITIAL> " <= "     {return(LEOP) ; }
<INITIAL> " != "     {return(NTOP) ; }

<INITIAL> " { "     {return(LC) ; }
<INITIAL> " } "     {return(RC) ; }
<INITIAL> " ( "     {return(LP) ; }
<INITIAL> " ) "     {return(RP) ; }
<INITIAL> " ; "     {return(SM) ; }
<INITIAL> " , "     {return(CM) ; }
<INITIAL> "         {
                strcnt = 0;
                BEGIN STR1;
                }
<INITIAL> " /* "     BEGIN COMM;
<INITIAL>if     {return(IF);}
<INITIAL>else   {return(ELSE);}
<INITIAL>while  {return(WHILE);}
<INITIAL>put    {return(PUT);}
<INITIAL>get    {return(GET);}
<INITIAL>[a-z]    {
                yylval.idno = yytext[0] -'a';
                return(IDENT);
                }
<INITIAL>[0-9]+ {
                yylval.num = atoi((char*)yytext);
                return(NUMBER);
                }
<INITIAL>[ ] ;
<INITIAL>[a-z0-9]+ {lexerror( " word invalid " );}
<INITIAL>.        {lexerror( " character invalid " );}
<STR1> "             {
                if (strcnt> = STRSIZE)lexerror( " string too long " ) ;
                string [ strcnt ]      =  ' 0 ' ;
                yylval.addr  =  pool(string) ;             
                BEGIN INITIAL ;
                return(STRING) ;
                }
<STR1>/ "         {
                if (strcnt < STRSIZE)
                    string[strcnt++] = ' " ' ;
                }
<STR1>/n        {
                if (strcnt < STRSIZE)
                    string [ strcnt++ ]   =  ' ' ;                  
                }
<STR1>          {
                lexerror( " string not closed " ) ;
                string [ strcnt ]   =  ' 0 ' ;
                yylval.addr  =  pool(string) ;
                BEGIN INITIAL ;
                return(STRING) ;
                }
<STR1>.            {
                if (strcnt <STRSIZE)string [ strcnt++ ]   =  yytext [ 0 ] ;
                }
<COMM> " */ "         {
                BEGIN INITIAL ;     
                }
<COMM>          ;
<COMM>.             ;
%%
void lexerror(char *s)
{
  extern int yynerrs ,  yylineno ;
  ++yynerrs ;
  fprintf(stderr , " %d:%s " , yylineno , s) ;
}

 

 

这个文件应该多留心 字符串和注释的写法

 

% ... {
#include <stdio.h>
#include "intall.h"
#define ID        100
#define NUM       101
#define STR          102
#define NODESIZE  100

int nodecnt = 0;
struct node...{
  int ntype;
  int nvalue;
  struct node *left;
  struct node *right;
}nodearea[NODESIZE] = ...{0};
%}
% union ... {
  int idno;
  int num;
  int addr;
  int label;
  struct node *nodep;
}

% token  < idno >  IDENT
% token  < num >   NUMBER
% token  < addr >  STRING
% token IF ELSE WHILE GET PUT
% token LP RP
% token LC RC
% token CM SM
% token ASGNOP
% token EQOP GTOP GEOP LSOP LEOP NTOP
% left  ADDOP SUBOP
% left  MULOP DIVOP
% right MINUS
% type   < label >   if .prefix  while .prefix
% type   < nodep >  expr cond
%%
s        :stmt.list
        ;
stmt.list
        : /**/ /*empty*/
         | stmt.list stmt
        ;
stmt    :IDENT ASGNOP expr SM
             ... {
            genexpr($3);
            clearnode();
            gencode(OP_POP, $1);
            }
         | if .prefix stmt
             ... {gencode(OP_LBL,$1);}
         | if .prefix stmt    ELSE 
             ... {
            gencode(OP_JMP, $<label>$ = newlbl());
            gencode(OP_LBL,$1);
            }
        stmt
             ... {gencode(OP_LBL, $<label>$);}
         | while .prefix 
             ... {
            gencode(OP_JPF, $<label>4 = newlbl());
            }
        stmt
             ... {
            gencode(OP_JMP, $1);
            gencode(OP_LBL, $<label>2);
            }
         | PUT LP put.list RP SM
         | GET LP IDENT RP SM
             ... {gencode(OP_GET,$3);}
         | LC stmt.list RC
         | SM
         | error SM
             ... {//可以使用一?机制来?制解析器相信??已?被完全修?了
            yyerrok;
            clearnode();
            }
         | error RC
             ... {
            yyerrok;
            clearnode();
            }
        ;
if .prefix
        :IF LP cond RP
         ... {
        genexpr($3);
        clearnode();
        gencode(OP_JPF,$$ = newlbl());
        }
        ;
while .prefix
        :WHILE LP cond RP
         ... {
        gencode(OP_LBL,$$ = newlbl());
        genexpr($3);
        clearnode();
        }  
        ;
put.list
        :id.num.or.str
         | put.list CM id.num.or.str
        ;
id.num.or.str
        :IDENT
             ... {gencode(OP_PUTI, $1);}
         | NUMBER
             ... {gencode(OP_PUTN, $1);}
         | STRING
             ... {gencode(OP_PUTS, $1);}
        ;
cond    :expr EQOP expr
             ... {$$ = makeexpr(EQ, $1, $3);}
         | expr GTOP expr
             ... {$$ = makeexpr(GT, $1, $3);}
         | expr GEOP expr
             ... {$$ = makeexpr(GE, $1, $3);}
         | expr LSOP expr
             ... {$$ = makeexpr(LS, $1, $3);}
         | expr LEOP expr
             ... {$$ = makeexpr(LE, $1, $3);}
         | expr NTOP expr
             ... {$$ = makeexpr(NT, $1, $3);}
        ;
expr    :expr ADDOP expr
             ... {$$ = makeexpr(ADD, $1, $3);}
         | expr SUBOP expr
             ... {$$ = makeexpr(SUB, $1, $3);}
         | expr MULOP expr
             ... {$$ = makeexpr(MUL, $1, $3);}
         | expr DIVOP expr
             ... {$$ = makeexpr(DIV, $1, $3);}
         | SUBOP expr    % prec MINUS
             ... {$$ = makeexpr(MIN, $2, 0);}
         | LP expr RP
             ... {$$ = $2;}
         | IDENT
             ... {$$ = makenode(ID, $1);}
         | NUMBER
             ... {$$ = makenode(NUM, $1);}
        ;
%%
int  yyerror( char   * str) ... {
    printf("%s ", str);
}

void  clearnode()
... {
    nodecnt = 0;
}

struct  node  * getnode()
... {
    if (nodecnt > NODESIZE)...{
        fatal("nodearea overflow");    
    }
    return (&nodearea[nodecnt++]);
}

struct  node  * makenode( int  type ,  int  value)
... {
    struct node *p;
    
    p = getnode();
    p->ntype = type;
    p->nvalue = value;
    p->left = NULL;
    p->right = NULL;
    return(p);
}

struct  node  * makeexpr( int  type,  struct  node  * left,  struct  node *  right)
... {
    struct node *p;
    
    p = makenode(type ,0);
    p->left = left;
    p->right = right;
    
    return(p);
}
/**/ /*式のとリーから中間コードを生成する*/
void  genexpr( struct  node *  p)
... {
    if(p == NULL)...{
        return;
    }
    if(p->left)...{
        genexpr(p->left);
    }
    if(p->right)...{
        genexpr(p->right);
    }
    switch (p->ntype)...{
    case ID:
        gencode(OP_PSHI, p->nvalue);
        break;
    case NUM:
        gencode(OP_PSHN, p->nvalue);
        break;
    default:
        gencode(OP_CAL, p->ntype);
        break;
    }    
}

 

接下来是intmain.c

 

#include  < stdio.h >
#include  < string .h >
#include  < stdlib.h >
#include  " intall.h "
extern   int  yynerrs;
extern  FILE *  yyin;
int  dmpFlag  =   0 ;
#ifdef YYDEBUG
   extern   int  yydebug;  
#endif

int  main( int  ac,  char *  av[])
... {
    if(ac < 2)...{
        fatal("option error");
    }
    if(!(yyin = fopen(av[1],"r")))...{
        fatal("open error");
    }
    if(ac >= 3 && !strcmp(av[2],"-d"))...{
        dmpFlag = 1;        
#ifdef YYDEBUG
    yydebug = 1;
#endif
    }
    if(yyparse() || yynerrs)...{
        fatal("not executed");    
    }
    defref();
    if (dmpFlag)...{
        dumpcode();
    }
    execute();
}

void  fatal( char   * s)
... {
    fprintf(stderr, "%s!!!. ", s);    
    exit(0);
}

intgen.c

 

#include  < stdio.h >
#include  < string .h >
#include  " intall.h "

#define  CODESIZE   1000
#define  POOLSIZE   200
#define  LBLSIZE    100
int  codecnt  =   0 ;
struct  code_t codearea[CODESIZE]  =   ... {0} ;
int  poolcnt  =   0 ;
char  poolarea[POOLSIZE]  =   ... {0} ;
int  labelno  =   0 ;
int  lbltable[LBLSIZE]  =   ... {0} ;

/**/ /*中間コードを中間コード領域に出力する*/
void  gencode( int  op,  int  sub)
... {
    if (codecnt >=CODESIZE)...{
        fatal("codearea overflow");
    }
    codearea[codecnt].opcode = op;
    codearea[codecnt++].subcode = sub;
}

/**/ /*文字列プール領域に文字列をプールする*/
int  pool( char *  p)
... {
    int i,j;
    j = poolcnt;
    if ((i = poolcnt + strlen(p) + 1) > POOLSIZE)...{
        fatal("poolarea overflow");
    }
    strcpy(&poolarea[poolcnt],p);
    poolcnt = i;
    return (j);
}

int  newlbl()
... {
    if(labelno >= LBLSIZE)...{
        fatal("label overflow");
    }
    return (labelno++);
}

void  defref()
... {
    int i;
    for (i = 0; i < codecnt; ++i)...{
        if (codearea[i].opcode == OP_LBL)...{
            lbltable[codearea[i].subcode] = i;
        }
    }
    for (i = 0;i < codecnt; ++i)...{
        if(codearea[i].opcode == OP_JMP || codearea[i].opcode == OP_JPF)...{
            codearea[i].subcode = lbltable[codearea[i].subcode];
        }    
    }
}

intexec.c,这个才是真正的ACTION...

 

#include  < stdio.h >
#include  " intall.h "
#define  STKSIZE   100
extern   int  codecnt;
extern   char  poolarea[];
extern   struct  code_t codearea[];
int  sp  =   - 1 ;
int  stack[STKSIZE]  =   ... {0} ;
int  pc  =   0 ;
int  valarea[ ' z '   -   ' a '   +   1 ]  =   ... {0} ;
/**/ /*
  中間コードを実行する
*/
void  execute()
... {
    int sub;
    
    while (pc < codecnt)...{
        sub = codearea[pc].subcode;
        switch (codearea[pc].opcode)...{
        case OP_POP:
            valarea[sub] = stack[sp--];
            break;
        case OP_PSHI:
            if (++sp >= STKSIZE)fatal("stack overflow!!");
            stack[sp] = valarea[sub];
            break;
        case OP_PSHN:
            if (++sp >= STKSIZE)fatal("stack overflow!!");
            stack[sp] = sub;
            break;
        case OP_JMP:
            pc = sub;
            break;    
        case OP_JPF:
            if (stack[sp--] == 0)...{
                pc = sub;
            }
            break;
        case OP_GET:
            scanf("%d", &valarea[sub]);
            break;    
        case OP_PUTI:
            printf("%d", valarea[sub]);
            break;
        case OP_PUTN:
            printf("%d",sub);
            break;
        case OP_PUTS:
            printf("%s", &poolarea[sub]);
            break;
        case OP_CAL:
            switch (sub)...{
                case ADD:
                    --sp;
                    stack[sp] = stack[sp] + stack[sp + 1];
                    break;
                case SUB:
                    --sp;
                    stack[sp] = stack[sp] - stack[sp + 1];
                    break;
                case MUL:
                    --sp;
                    stack[sp] = stack[sp] * stack[sp + 1];
                    break;
                case DIV:
                    --sp;
                    stack[sp] = stack[sp] / stack[sp + 1];
                    break;
                case MIN:
                    --sp;
                    stack[sp] = -stack[sp];
                    break;
                case EQ:
                    --sp;
                    stack[sp] = stack[sp] == stack[sp + 1];
                    break;
                case GT:
                    --sp;
                    stack[sp] = stack[sp] > stack[sp + 1];
                    break;
                case GE:
                    --sp;
                    stack[sp] = stack[sp] >= stack[sp + 1];
                    break;
                case LS:
                    --sp;
                    stack[sp] = stack[sp] < stack[sp + 1];
                    break;
                case LE:
                    --sp;
                    stack[sp] = stack[sp] <= stack[sp + 1];
                    break;
                case NT:
                    --sp;
                    stack[sp] = stack[sp] != stack[sp + 1];
                    break;
            }
        }
    ++pc;
    }    
}

intall.h

 

#ifndef INTALL_H__
#define  INTALL_H__

#define  OP_POP              1    /*give valarea to value */
#define  OP_PSHI             2    /*変数の値をスタックにプッシュする*/
#define  OP_PSHN             3    /*定数の値をスタックにプッシュする*/
#define  OP_CAL              4    /*演算子*/
#define  OP_LBL              5    /*ラベル*/
#define  OP_JMP              6    /*ラベル*/
#define  OP_JPF              7    /*ラベル*/
#define  OP_GET              8    /*scanf*/
#define  OP_PUTI             9    /*変量名IDENT,valareaの値を出力*/
#define  OP_PUTN             10  /*NUM数字定数の値*/
#define  OP_PUTS             11    /*文字列出力*/
/**/ /*演算子*/
#define  ADD                 1
#define  SUB                 2
#define  MUL                 3
#define  DIV                 4
#define  MIN                 5
#define  EQ                  6
#define  GT                  7
#define  GE                  8
#define  LS                  9
#define  LE                  10
#define  NT                  11

struct  code_t ... {
    int opcode;
    int subcode;
} ;


void  fatal( char * );
#endif

 

没有什么好说的,我是拿书上的例子在学习,这里应该注意的是中间CODE这个概念,,,先保存在出力,这在和我之前用

面向对象是一样的效果,但是代码的理解就.....