little c解释器分析[二]

/* ------------------------------------------------------------------------------------- */
/* 递归下降分析算法：little c解释器是采用递归下降来进行表达式分析的                      */
/* ------------------------------------------------------------------------------------- */
exp_x递归的描述
--------------------
因为涉及到优先级的问题，所以从exp_1开始的递归子程序，都是越后递归所要完成的任务的优先级越高
，exp_1开始执行后，并不完成其本身的任务，而是向下递归，只到最下面一个子程序，然后返回，在返回的
过程中根据优先级来先后完成当前的任务。
首先从exp_0开始，其检查是否是空表达式,以及处理变量。在处理变量过程中又递归运行，使变量赋值。
exp_1主要完成的任务是计算布尔表达式，其计算过程中需要在次递归调用得到第2个值好和第一个值进行布尔
计算。
exp_2主要完成的任务是计算处理加法和减法运算。其运算过程中需要查看其后的运算时候是乘法或除法，
如果是需要先进行计算，所以在while内部需要调用exp_3，如果是4+28*2这样的，那么当exp_3返回时就会返回
56，然后才进行加法运算。此程序还需要处理7+1+2+1这样的连加或连减.
exp_3主要完成的任务是计算除法和取摸。其功能类似加减。
exp_4处理一元加或减。
exp_5最高优先级别，是()运算，
atom负责内部函数和用户定义的函数调用，并返回值给全局变量value，和返回常量值以及数字值。
----------------------
/* Entry point into parser. */
/* 分析部分程序开始执行 */
/* 程序的入口是eval_exp()函数 */
void eval_exp(int *value)
{
/* 首先取得一个符号 */
 get_token();
/* 判断是否有符号，如果没有返回错误，没有表达式 */
 if(!*token) {
   sntx_err(NO_EXP);
   return;
 }
/* 如果“单词”为 ";" 的话，那么表示是一个空表达式，空表达式的值为0,表示假 */
 if(*token == ';') {
   *value = 0; /* empty expression */
   return;
 }
/* 如果不是上面2种情况，那么表达式递归分析开始执行 */
 eval_exp0(value);
 putback(); /* return last token read to input stream */
}

/* Process an assignment expression */
void eval_exp0(int *value)
{
 char temp[ID_LEN];  /* holds name of var receiving
                        the assignment */
 register int temp_tok;

 if(token_type == IDENTIFIER) {
 /* 通过变量is_var查看这个“标示符”是否已经在全局或局部变量表中 */
   if(is_var(token)) {  /* if a var, see if assignment */
/* 如果在的话，那么把token复制到temp变量中 */
     strcpy(temp, token);

//如果不在话那么将先把token内存放的值copy到temp里,因为确定是赋值语句，那么就可能是表达式，由于token是全局变量，所以要在这里保

存。

     temp_tok = token_type;//缓冲标记类型设置为token_type
     get_token();//取得下一个符号，根据这个变量名字还没定义，那就说明他应该是有个赋值的语句
     if(*token == '=') {  /* is an assignment */ //如果是一个=符号的话，那就说明他是赋值语句
       get_token();//取得符号
       eval_exp0(value);  //递归计算表达式
       assign_var(temp, *value);  //给变量赋值
       return;
     }
     else {  //
       putback();  //否则恢复token以前指针的位置
       strcpy(token, temp); //把temp的值给token
       token_type = temp_tok;//类型为temp_tok类型
     }
   }
 }
 eval_exp1(value);//递归进入下一层
}

/* Process relational operators. */
void eval_exp1(int *value)
{
 int partial_value;//另一个需要计算的表达式中的值
 register char op; //此变量是操作符变量
 char relops[7] = {//操作符表
   LT, LE, GT, GE, EQ, NE, 0
 };

 eval_exp2(value);//进入下一层
 op = *token; //操作符
 if(strchr(relops, op)) {//如果属于操作符
   get_token();//取得下一个符号
   eval_exp2(&partial_value);//取得partial_value的值
   switch(op) {  /* perform the relational operation */
     case LT://处理LT的情况 小于号
       *value = *value < partial_value;//处理的真假值放到values里，values此时只可能是1或0
       break;//推出switch语句
     case LE://处理LE的情况 小于等于号
       *value = *value <= partial_value;
       break;
     case GT://处理GT的情况 大于号
       *value = *value > partial_value;
       break;
     case GE://处理GE的情况 大于等于号
       *value = *value >= partial_value;
       break;
     case EQ://处理EQ符号 测试是否相等符号
       *value = *value == partial_value;
       break;
     case NE://处理NE符号 测试不等符号
       *value = *value != partial_value;
       break;
   }
 }
}

/*  Add or subtract two terms. */
void eval_exp2(int *value)
{
 register char  op;
 int partial_value;

 eval_exp3(value);//进入递归
 while((op = *token) == '+' || op == '-') {//处理多个加号或减号
   get_token();//取得一个符号
   eval_exp3(&partial_value);//得到一个数字。这个值可能是来自乘法或除法或表达式传回来的值
   switch(op) { //选择一个符号
     case '-'://处理减号
       *value = *value - partial_value;
       break;
     case '+'://处理加号
       *value = *value + partial_value;
       break;
   }
 }
}

/* Multiply or divide two factors. */
void eval_exp3(int *value)
{
 register char  op;
 int partial_value, t;

 eval_exp4(value);//进入下一层递归
 while((op = *token) == '*' || op == '/' || op == '%') {//处理连乘或连除
   get_token();//取得下一个符号
   eval_exp4(&partial_value);//得到一个数字
   switch(op) { /* mul, div, or modulus */
     case '*'://处理乘法
       *value = *value * partial_value;
       break;
     case '/'://处理除法
       if(partial_value == 0) sntx_err(DIV_BY_ZERO);      
       *value = (*value) / partial_value;
       break;
     case '%'://处理取摸运算.余数放在value里
       t = (*value) / partial_value;
       *value = *value-(t * partial_value);
       break;
   }
 }
}
//eval_exp4处理一元加或减
/* Is a unary + or -. */
void eval_exp4(int *value)
{
 register char  op;

 op = '/0';
 if(*token == '+' || *token == '-') {
   op = *token;
   get_token();
 }
 eval_exp5(value);
 if(op)
   if(op == '-') *value = -(*value);
}

/* Process parenthesized expression. */
void eval_exp5(int *value)
{
 if((*token == '(')) {//处理(，()具有最高优先级
   get_token();
   eval_exp0(value);   /* get subexpression */
   if(*token != ')') sntx_err(PAREN_EXPECTED);//如果没有)说明语法错误
   get_token();
 }
 else
   atom(value);//取得一个值
}
void atom(int *value)
{
 int i;

 switch(token_type) {
 /*  选择token类型 */
 case IDENTIFIER:
/* 如果是变量或函数 */
   i = internal_func(token);
/* 从内部结构中查找函数名是否存在 */
   if(i!= -1) {  /* call "standard library" function */
    /* 如果不是-1的话，那么表示是内部函数 */
*value = (*intern_func .p)();
    /* 通过结构中的函数指针调用内部函数,返回的值放到 value指向地址里 */
   }
   else if(find_func(token)) { /* call user-defined function */
     /* 否则通过函数find_func查找是否是用户定义的函数，如果是的话 */
     call();
     /* 通过call函数调用用户定义的函数 */
     *value = ret_value;
     /* 函数的返回值放到value指向的地址里 */
   }
   else *value = find_var(token); /* get var's value */
   /* 否则就认为他是一个变量的名字，通过find_var函数找到token里存放到变量值，然后放到value里 */
   get_token();
  /* 返回 */
  return;
 
 case NUMBER: /* is numeric constant */
   /* 如果是一个数字的话 那么通过标准库函数中的atoi(在stdio.h中定义了此函数) 把字符转化为数字类型，以方便表达式计算 */
*value = atoi(token);
   get_token();
   /* 返回 */
   return;
 case DELIMITER: /* see if character constant */
  /* 如果是一个字符常量的话 */
   if(*token == '/'') {
  /* 如果是'字符，那么把当前的值放到value里 */
     *value = *prog;
     prog++;
     if(*prog!='/'') sntx_err(QUOTE_EXPECTED);
     /* 如果不是以'符号结尾，就抛出语法错误 */
     prog++;
     get_token();
     return ;
   }
   if(*token==')') return; /* process empty expression */
   else sntx_err(SYNTAX); /* syntax error */
 default:
   sntx_err(SYNTAX); /* syntax error */
 }
}