varproc.c.bak

一个小型C语言编译器

#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>

#include "token.h"
#include "string.h"
//#include "self_def.h"
#include "datatypedef.h"
#include "input.h"


void vardefproc(void);
void ouputvardef(void);
void _vardefproc(void);

void VarInsert(VAR_USE_REC var_use_rec);

VARDEFNODE* first = NULL;
VARDEFNODE* last  = NULL;

VARDEFNODE* first_u = NULL;
VARDEFNODE* last_u  = NULL;


VAR_LVL_RECORD  GlobalVarRec = {0, NULL, NULL, NULL};
VAR_LVL_RECORD* CurVarRec = & GlobalVarRec;
VAR_LVL_RECORD* ParentVarRec = CurVarRec->parent;



void vardefproc()
{
    int l_token = 0;
    VARDEFNODE temp  = {NULL, NULL};

    while(9) {
        l_token = gettok();

        if(l_token == EOI) {
            return ;
        }

        if(l_token >= 1 && l_token <= 7) { //变量定义，声明
            printf("[file:%s][line:%d] var define\r\n", __FILE__, __LINE__);
            _vardefproc();
        }
    }
}


//#define debug


#ifdef  debug
#define trace printf
#else
#define trace 
#endif

static void proc_1();
static void proc_2();
static void proc_3();
static void proc_4();
void varlist_insert(VARDEFNODE temp);
void uselist_insert(VARDEFNODE temp);







/* 
状态转换
                                                  
                                                  operator
                                              /--------------------\
                                              |                    |
                                              |                    |
                            *                 \/      ID           |
                        ------\              [3]----------------->[4]
                        \     |               /\                   |  
                         \    |               |                    |;
                          \   |               |                    |
               type        \  \/   ID         |        ;           \/
        [S]---------------->[1]------------->[2]----------------->[F]
                             /\               |
                             |                |
                             \----------------/
                                   ,

[1]  :  proc_1();
[2]  :  proc_2();
[3]  :  proc_3();
[4]  :  proc_4();
                                   
                                   
*/



void _vardefproc()
{
    proc_1();
}

void proc_1()
{
    int tok = -1;

    trace("proc_1()\n");
	tok = gettok();
    trace("%d\n", tok);
    if( tok == EOI ) {
        return ;
    }

	if(tok == ID)
	{
        //VARDEFNODE temp = {NULL, NULL};

        //temp.name = token;
        //temp.next = NULL;
        //varlist_insert(temp);

        VAR_USE_REC temp = {0};

        temp.line = lineno;
        temp.name = token;
        temp.use_type = DEFINE_STATE;

        VarInsert(temp);

        proc_2();
	}

    if(tok == '*') {
        proc_1();
    }
}

void proc_2()
{
    int tok = -1;

    trace("proc_2()\n");

	tok=gettok();
    if( tok == EOI ) {
        return ;
    }

	if(tok == ';')
		return ;

	else if(tok==',')
		proc_1();

	else if(tok == '=')
		proc_3();
}

void proc_3()
{
    int tok = -1;

    trace("proc_3()\n");
	tok=gettok();
    if( tok == EOI) {
        return ;
    }

	if(tok == ID || tok == FCON || tok == ICON)
	{
        if(tok == ID) {

            VAR_USE_REC temp = {0};

            temp.line = lineno;
            temp.name = token;
            temp.use_type = USE_STATE;

            VarInsert(temp);
        }
		
		proc_4();
	}
    //proc_4();
}

void proc_4()
{
    int tok = -1;

    trace("proc_4()\n");
	
    tok=gettok();
    if( tok == EOI ) {
        return ;
    }

	if(tok == ';')
		return;

	else if(tok == '+' || tok == '-' || tok == '*' || tok == '/'|| tok == '=')
		proc_3();

	else if(tok == ',')
		proc_1();
}

VAR_LIST_NODE* _find(char* name, VAR_LIST_NODE* start)
{
    if(start == NULL) 
        return NULL;

    while(start) {
        if( !strcmp (name, start->varname) ){//变量名称相同，认为是同一个变量
            return start;
        }
    }

    return NULL;
}

VAR_LIST_NODE* find(char* name)
{
    VAR_LVL_RECORD* curvarrec = CurVarRec;
    VAR_LIST_NODE*  result = NULL;
    while(curvarrec){
        result = _find(name, curvarrec->varlist);
        if(result)
            return result;
        else 
            curvarrec = curvarrec->parent;
    }

    return NULL;
}

void VarInsert(VAR_USE_REC var_use_rec)
{
    VAR_LIST_NODE* current = NULL;

    assert(CurVarRec);              //确保当前变量记录不能为空
    current = CurVarRec->varlist;

        
     //查找当前变量使用记录中是否有相关变量的记录
        VAR_LIST_NODE* var_node = NULL;

        var_node = find(var_use_rec.name);

        if(var_node) {//该变量以前有定义
            VAR_USE_STATE* temp = var_node->usestate;
            VAR_USE_STATE* use_state = NULL;

            use_state = (VAR_USE_STATE*) malloc(sizeof(VAR_USE_STATE));
            if(use_state == NULL) {
                printf("mem alloc fail!");
                exit(0);
            }
            use_state->line = var_use_rec.line;
            use_state->use_type = var_use_rec.use_type;
            use_state->next = NULL;

            if(temp == NULL) {//该变量未曾定义，使用
                var_node->usestate = use_state;
                return;
            } else {//该变量已经有使用定义记录
                while(temp->use_type){
                    temp = temp->next;
                }
                temp->next = use_state;
            }
        } else {
            VAR_LIST_NODE* temp = NULL;
            VAR_USE_STATE* stemp = NULL;

            temp = (VAR_LIST_NODE*) malloc(sizeof (VAR_LIST_NODE));
            if(temp == NULL) {
                printf("mem alloc fail!");
                exit(0);
            }

            stemp = (VAR_USE_STATE*) malloc(sizeof(VAR_USE_STATE));
            if(stemp == NULL){
                printf("mem alloc fail!");
                exit(0);                        //使用EXIT退出程序，暂时不考虑内存释放
            }

            stemp->line = var_use_rec.line ;
            stemp->use_type = var_use_rec.use_type ;
            stemp->next = NULL;

            temp->varname = var_use_rec.name;
            temp->next    = CurVarRec->varlist;
            temp->usestate = stemp;
            
            CurVarRec->varlist = temp;
            return ;
        }

}



void varlist_insert(VARDEFNODE temp)
{
    //debug
    //printf("%s\n", temp.name);

    VARDEFNODE * node;

    printf("varlist_insert\n");
    node = (VARDEFNODE*) malloc(sizeof(VARDEFNODE));
    if (node == NULL) {
        printf("mem alloc fail!\n");
        exit(0);
    }

    memcpy((void*)node, (void*)&temp, sizeof(VARDEFNODE));

    if (first == NULL) {
        first = node;
        last  = node;
        return ;
    }

    last->next = node;
    last = node;
}

void uselist_insert(VARDEFNODE temp)
{
    //debug
    //printf("%s\n", temp.name);

    VARDEFNODE * node;

    printf("uselist_insert\n");
    node = (VARDEFNODE*) malloc(sizeof(VARDEFNODE));
    if (node == NULL) {
        printf("mem alloc fail!\n");
        exit(0);
    }

    memcpy((void*)node, (void*)&temp, sizeof(VARDEFNODE));

    if (first_u == NULL) {
        first_u = node;
        last_u  = node;
        return ;
    }

    last_u -> next = node;
    last_u         = node;
}



void dispvar()
{
    VARDEFNODE* curr = NULL;

    printf("****************************************************************\n");
    printf("**************************define var list***********************\n");
    printf("****************************************************************\n");

    curr = first;
    if(curr) {
        while(curr){
            printf("%s ", curr->name);
            curr = curr->next;
        }
    }

    printf("\n****************************************************************\n");
    printf("************************** use var list ************************\n");
    printf("****************************************************************\n");

    curr = first_u;
    if(curr) {
        while(curr){
            printf("%s ", curr->name);
            curr = curr->next;
        }
    }
}

void dispvar_(VAR_LVL_RECORD* curr)
{
    VAR_LIST_NODE* varnode;

    assert(curr);

    varnode = curr->varlist;
    while(varnode) {
        printf("%s\n", varnode->varname);
    }
}

void ouputvardef(void)
{
    //dispvar();
    dispvar_(&GlobalVarRec);
}