calc_yacc.y

绘制一元函数曲线的工具 输入C语言语法的函数公式, 即可绘制函数的二维曲线 采用内置编译器和虚拟机(这是调整OK的版本)

%{

#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 *);

void cc_exp_for(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> loop_stmt
%type  <n_point> ctrl_stmt
%type  <n_point> goxx_stmt

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

%token    IF
%nonassoc IFX
%nonassoc ELSE

%token DO
%token FOR
%token WHILE
%token BREAK
%token CONTI

%token GOTO
%token LABEL

%token CALL
%token INCB INCA
%token DECB DECA

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

%left  OOR
%left  AND

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

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

%left  SHL SHR

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

%right INC DEC '!' '~' 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_item ';'             { $$ = exp_op(';', 2, $1,  0); }
    |     ifxx_stmt                 { $$ = $1; }
    |     loop_stmt                 { $$ = $1; }
    |     ctrl_stmt                 { $$ = $1; }
    |     goxx_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); }
    ;

loop_stmt
    : DO        stmt_item WHILE '(' expr_item ')' ';'               { $$ = exp_op(DO   , 2, $2, $5); }
    | WHILE '(' expr_item ')'       stmt_item                       { $$ = exp_op(WHILE, 2, $3, $5); }
    | FOR   '(' expr_list ';' expr_item ';' expr_list ')' stmt_item { $$ = exp_op(FOR  , 4, $3, $5, $7, $9); }
    | FOR   '(' expr_list ';' expr_item ';'           ')' stmt_item { $$ = exp_op(FOR  , 4, $3, $5,  0, $8); }
    | FOR   '(' expr_list ';'           ';' expr_list ')' stmt_item { $$ = exp_op(FOR  , 4, $3,  0, $6, $8); }
    | FOR   '(' expr_list ';'           ';'           ')' stmt_item { $$ = exp_op(FOR  , 4, $3,  0,  0, $7); }
    | FOR   '('           ';' expr_item ';' expr_list ')' stmt_item { $$ = exp_op(FOR  , 4,  0, $4, $6, $8); }
    | FOR   '('           ';' expr_item ';'           ')' stmt_item { $$ = exp_op(FOR  , 4,  0, $4,  0, $7); }
    | FOR   '('           ';'           ';' expr_list ')' stmt_item { $$ = exp_op(FOR  , 4,  0,  0, $5, $7); }
    | FOR   '('           ';'           ';'           ')' stmt_item { $$ = exp_op(FOR  , 4,  0,  0,  0, $6); }
    ;

ctrl_stmt
    : BREAK ';' { $$ = exp_op(BREAK, 0); }
    | CONTI ';' { $$ = exp_op(CONTI, 0); }
    ;

goxx_stmt
    : GOTO IDENTIFIER ';'           { $$ = ass_op( GOTO, $2,  0); }
    |      IDENTIFIER ':' stmt_item { $$ = ass_op(LABEL, $1, $3); }
    ;

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('<', 2, $1, $3); }
    | expr_item  '>' expr_item      { $$ = exp_op('>', 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); }
    | INC IDENTIFIER                { $$ = ass_op(INCB, $2,  0); }
    | DEC IDENTIFIER                { $$ = ass_op(DECB, $2,  0); }
    | IDENTIFIER INC                { $$ = ass_op(INCA, $1,  0); }
    | IDENTIFIER DEC                { $$ = ass_op(DECA, $1,  0); }
    | 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)
            {
            case IFX:
                if(p_node->node_data.op.op_n > 2)
                {
                    char  m_LabStrA[8];
                    char  m_LabStrB[8];

                    zzlabel(m_LabStrA);
                    zzlabel(m_LabStrB);

                    /*if else*/
                    cc_builder(p_node->node_data.op.op_s[0]);

                    fprintf(asout, "jmp_ez %s\n", m_LabStrA);

                    cc_builder(p_node->node_data.op.op_s[1]);

                    fprintf(asout, "jmp_to %s\n", m_LabStrB);

                    fprintf(asout, "label: %s\n", m_LabStrA);

                    cc_builder(p_node->node_data.op.op_s[2]);

                    fprintf(asout, "label: %s\n", m_LabStrB);
                }
                else
                {
                    char  m_LabStrA[8];

                    zzlabel(m_LabStrA);

                    /*if then*/
                    cc_builder(p_node->node_data.op.op_s[0]);

                    fprintf(asout, "jmp_ez %s\n", m_LabStrA);

                    cc_builder(p_node->node_data.op.op_s[1]);

                    fprintf(asout, "label: %s\n", m_LabStrA);
                }
                break;

            case DO:    /* do ... while(...); */
                {
                    char  m_LabStrB[8]; /*break*/
                    char  m_LabStrC[8]; /*conti*/

                    char *m_OldLabB;
                    char *m_OldLabC;

                    zzlabel(m_LabStrB);
                    zzlabel(m_LabStrC);

                    m_OldLabB = g_label_break;
                    m_OldLabC = g_label_conti;

                    g_label_break = m_LabStrB;
                    g_label_conti = m_LabStrC;