calc_yacc.y

利用flex和bison做的简易C语言编译器核心 支持C语言的大部分运算操作和语法,但是没有 变量声明和函数声明 适合制作虚拟机之类的 输出结果是伪汇编代码 我会继续更新

%{

#include "ucvm_type.h"
#include "calc_yacc.h"

Node * var_id(char *);
Node * con_cs(char *);
Node * con_cc(char );
Node * con_ci(long );
Node * con_cr(Real );

Node * ass_op(long, char *, Node *);
Node * exp_op(long, long  ,  ...  );

long cc_builder(Node *);
void cc_cleanup(Node *);

%}

%union
{
    char  c_value;
    long  i_value;
    Real  r_value;
    char *s_value;
    Node *n_point;
}

%token <s_value> IDENTIFIER
%token <s_value> CONSTANT_S
%token <c_value> CONSTANT_C
%token <i_value> CONSTANT_I
%token <r_value> CONSTANT_R

%right <i_value> ASS

%type  <n_point> stmt_item
%type  <n_point> stmt_list

%type  <n_point> ifxx_stmt
%type  <n_point> goto_stmt
%type  <n_point> labe_stmt
%type  <n_point> loop_stmt

%type  <n_point> expr_stmt
%type  <n_point> expr_item
%type  <n_point> expr_list

%token    IF
%nonassoc IFX
%nonassoc ELSE

%token GOTO
%token LABE

%token DO
%token WH

%token CALL

%token ASSIGN
%token ASSADD
%token ASSSUB
%token ASSMUL
%token ASSDIV
%token ASSBAL
%token ASSAND
%token ASSXOR
%token ASSOOR
%token ASSSHL
%token ASSSHR

%left OOR
%left AND

%left '|'
%left '^'
%left '&'

%left CEQ CNE
%left CGE CLE '>' '<'

%left SHL SHR

%left '+' '-'
%left '*' '/' '%'

%nonassoc '!'
%nonassoc '~'
%nonassoc UMI

%%

procedure
    : stmt_list                     { cc_builder($1); cc_cleanup($1); }
    ;

stmt_list
    :                               { $$ = exp_op(',', 2,  0,  0); }
    | stmt_list stmt_item           { $$ = exp_op(',', 2, $1, $2); }
    ;

stmt_item
    : ';'                           { $$ = exp_op(',', 2,  0,  0); }
    |     expr_stmt                 { $$ = $1; }
    |     ifxx_stmt                 { $$ = $1; }
    |     goto_stmt                 { $$ = $1; }
    |     labe_stmt                 { $$ = $1; }
    |     loop_stmt                 { $$ = $1; }
    | '{' stmt_list '}'             { $$ = $2; }
    ;

ifxx_stmt
    : IF '(' expr_item ')' stmt_item      %prec IFX { $$ = exp_op(IFX, 2, $3, $5    ); }
    | IF '(' expr_item ')' stmt_item ELSE stmt_item { $$ = exp_op(IFX, 3, $3, $5, $7); }
    ;

goto_stmt
    : GOTO IDENTIFIER ';'           { $$ = ass_op(GOTO, $2,  0); }
    ;

labe_stmt
    : IDENTIFIER ':' stmt_item      { $$ = ass_op(LABE, $1, $3); }
    ;

loop_stmt
    : DO     stmt_item WH '(' expr_item ')' ';' { $$ = exp_op(DO, 2, $2, $5); }
    | WH '(' expr_item ')'    stmt_item         { $$ = exp_op(WH, 2, $3, $5); }
    ;

expr_stmt
    : expr_item  ';'                { $$ = exp_op(';', 1, $1); }
    ;

expr_item
    : CONSTANT_R                    { $$ = con_cr($1); }
    | CONSTANT_I                    { $$ = con_ci($1); }
    | CONSTANT_C                    { $$ = con_cc($1); }
    | CONSTANT_S                    { $$ = con_cs($1); }
    | IDENTIFIER                    { $$ = var_id($1); }
    | IDENTIFIER ASS expr_item      { $$ = ass_op($2, $1, $3); }
    | expr_item  OOR expr_item      { $$ = exp_op(OOR, 2, $1, $3); }
    | expr_item  AND expr_item      { $$ = exp_op(AND, 2, $1, $3); }
    | expr_item  '|' expr_item      { $$ = exp_op('|', 2, $1, $3); }
    | expr_item  '^' expr_item      { $$ = exp_op('^', 2, $1, $3); }
    | expr_item  '&' expr_item      { $$ = exp_op('&', 2, $1, $3); }
    | expr_item  CEQ expr_item      { $$ = exp_op(CEQ, 2, $1, $3); }
    | expr_item  CNE expr_item      { $$ = exp_op(CNE, 2, $1, $3); }
    | expr_item  CLE expr_item      { $$ = exp_op(CLE, 2, $1, $3); }
    | expr_item  CGE expr_item      { $$ = exp_op(CGE, 2, $1, $3); }
    | expr_item  '<' expr_item      { $$ = exp_op(CLE, 2, $1, $3); }
    | expr_item  '>' expr_item      { $$ = exp_op(CGE, 2, $1, $3); }
    | expr_item  SHL expr_item      { $$ = exp_op(SHL, 2, $1, $3); }
    | expr_item  SHR expr_item      { $$ = exp_op(SHR, 2, $1, $3); }
    | expr_item  '+' expr_item      { $$ = exp_op('+', 2, $1, $3); }
    | expr_item  '-' expr_item      { $$ = exp_op('-', 2, $1, $3); }
    | expr_item  '*' expr_item      { $$ = exp_op('*', 2, $1, $3); }
    | expr_item  '/' expr_item      { $$ = exp_op('/', 2, $1, $3); }
    | expr_item  '%' expr_item      { $$ = exp_op('%', 2, $1, $3); }
    | '!' expr_item                 { $$ = exp_op('!', 1, $2); }
    | '~' expr_item                 { $$ = exp_op('~', 1, $2); }
    | '-' expr_item %prec UMI       { $$ = exp_op(UMI, 1, $2); }
    | IDENTIFIER '('           ')'  { $$ = ass_op(CALL, $1,  0); }
    | IDENTIFIER '(' expr_list ')'  { $$ = ass_op(CALL, $1, $3); }
    |            '(' expr_item ')'  { $$ = $2; }
    ;

expr_list
    : expr_item                     { $$ = exp_op(',', 2,  0, $1); }
    | expr_list ',' expr_item       { $$ = exp_op(',', 2, $1, $3); }
    ;

%%

Node * var_id(char *vs)
{
    Node *p_node;

    p_node = (Node *)malloc(sizeof(Node));

    p_node->node_data.id.s_label = vs;

    p_node->node_type = TYPE_EXPR_ID;

    return(p_node);
}

Node * con_cs(char *vs)
{
    Node *p_node;

    p_node = (Node *)malloc(sizeof(Node));

    p_node->node_data.cs.s_value = vs;

    p_node->node_type = TYPE_EXPR_CS;

    return(p_node);
}

Node * con_cc(char vc)
{
    Node *p_node;

    p_node = (Node *)malloc(sizeof(Node));

    p_node->node_data.cc.c_value = vc;

    p_node->node_type = TYPE_EXPR_CC;

    return(p_node);
}

Node * con_ci(long vi)
{
    Node *p_node;

    p_node = (Node *)malloc(sizeof(Node));

    p_node->node_data.ci.i_value = vi;

    p_node->node_type = TYPE_EXPR_CI;

    return(p_node);
}

Node * con_cr(Real vr)
{
    Node *p_node;

    p_node = (Node *)malloc(sizeof(Node));

    p_node->node_data.cr.r_value = vr;

    p_node->node_type = TYPE_EXPR_CR;

    return(p_node);
}

Node * ass_op(long op, char *va, Node *ex)
{
    Node *p_node;

    p_node = (Node *)malloc(sizeof(Node));

    p_node->node_data.op.oper = op;
    p_node->node_data.op.op_n = 2;
    p_node->node_data.op.op_s[0] = var_id(va);
    p_node->node_data.op.op_s[1] = ex;

    p_node->node_type = TYPE_EXPR_OP;

    return(p_node);
}

Node * exp_op(long op, long np, ...)
{
    Node *p_node;

    va_list ap;

    int ai;

    p_node = (Node *)malloc(sizeof(Node));

    va_start(ap, np);

    for(ai = 0; ai < np && ai < 4; ai ++)
    {
        p_node->node_data.op.op_s[ai] =
                va_arg(ap, Node *);
    }

    va_end(ap);

    p_node->node_data.op.oper = op;
    p_node->node_data.op.op_n = ai;

    p_node->node_type = TYPE_EXPR_OP;

    return(p_node);
}

void cc_cleanup(Node *p_node)
{
    if(NULL != p_node)
    {
        if(TYPE_EXPR_OP == p_node->node_type)
        {
            int i;

            for(i = 0; i < p_node->node_data.op.op_n; i ++)
            {
                cc_cleanup(p_node->node_data.op.op_s[i]);
            }
        }
        else
        if(TYPE_EXPR_ID == p_node->node_type)
        {
            if(NULL != p_node->node_data.id.s_label)
                  free(p_node->node_data.id.s_label);
        }
        else
        if(TYPE_EXPR_CS == p_node->node_type)
        {
            if(NULL != p_node->node_data.cs.s_value)
                  free(p_node->node_data.cs.s_value);
        }

        free(p_node);
    }
}

long cc_builder(Node *p_node)
{
    if(NULL != p_node)
    {
        switch(p_node->node_type)
        {
        case TYPE_EXPR_ID:
            fprintf(asout,"push_v %s\n", p_node->node_data.id.s_label);
            break;

        case TYPE_EXPR_CS:
            fprintf(asout,"push_s %s\n", p_node->node_data.cs.s_value);
            break;

        case TYPE_EXPR_CC:
            fprintf(asout,"push_c %c\n", p_node->node_data.cc.c_value);
            break;

        case TYPE_EXPR_CI:
            fprintf(asout,"push_i %d\n", p_node->node_data.ci.i_value);
            break;

        case TYPE_EXPR_CR:
            fprintf(asout,"push_r %e\n", p_node->node_data.cr.r_value);
            break;

        case TYPE_EXPR_OP:
            switch(p_node->node_data.op.oper)
            {