build your own lisp

Chapter 7

Trees

这个内部结构是我们在前一章中看到的程序打印出来的，称为抽象语法树。树上的叶子是数字和运算符即要处理的实际数据。在分枝处是用于生成树的一部分规则，如何遍历和获得它的信息。

他的数据结构如下

typedef struct mpc_ast_t{
    char* tag;
    char* contents;
    mpc_state_t state;
    int children_num;
    struct mpc_ast_t** children;
}mpc_ast_t;

tag--包含用于解析该特定项的所有规则的列表。

contents--包含真实的数据，在分枝上是空的，在叶子节点可用来寻找操作类型和数字。

state--包含有关解析器发现该结点时所处状态的信息，如行号和列号。

children_num--节点的孩子数

child--孩子构成的一个结构体数组

用number标记一个节点时，他没有子节点，我们仅仅是将内容转换成整型。

用expr标记一个节点时，关注其第二个孩子节点，也就是其操作符（第一个孩子总是'('）。然后去用操作符去计算剩余节点。

从得到的计算函数

long eval(mpc_ast_t* t){
    if(strstr(t->tag,"number")){
        return atoi(t->contents);
    }
    //操作符总是在第二孩子节点
    char* op=t->children[1]->contents;
    
    long x=eval(t->children[2]);

    int i=3;
    while(strstr(t->children[i]->tag,"expr")){
        x=eval_op(x,op,eval(t->children[i]));
        i++;
    }
    return x;
}

根据不同的操作类型进行操作

long eval_op(long x,char* op,long y){
    if(strcmp(op,"+")==0){return x+y;}
    if(strcmp(op,"-")==0){return x-y;}
    if(strcmp(op,"*")==0){return x*y;}
    if(strcmp(op,"/")==0){return x/y;}
    return 0;
}

chart8 错误处理

为了应对错误输入，定义数据结构

typedef struct{
    int type;
    long num;
    int err;
}lval;

type：type为0代表这个结构是数字，type是1代表这个结构是错误。

在这里用enum来表示：

enum{LVAL_NUM,LVAL_ERR};

为错误类型声明一个枚举，包含被零除、位置运算符、传递的数字太大三种情况。

enum{LERR_DIV_ZERO,LERR_BAD_OP,LERR_BAD_NUM};

声明两个函数来构造错误类型或数字类型的lval

lval lval_num(long x) {
  lval v;
  v.type = LVAL_NUM;
  v.num = x;
  return v;
}

/* Create a new error type lval */
lval lval_err(int x) {
  lval v;
  v.type = LVAL_ERR;
  v.err = x;
  return v;
}

从而需要重新构造输出打印函数

void lval_print(lval v){
    switch(v.type){
        case LVAL_NUM: printf("%li",v.num);break;
        
        case LVAL_ERR:
            if(v.err==LERR_DIV_ZERO){
                printf("Error:Divison By Zero!");
            }
            if(v.err=LERR_BAD_OP){
                printf("Error: Invalid Operator!");
            }
            if(v.err=LERR_BAD_NUM){
                printf("Error: Invalid Number!");
            }
            break;
    }
}
void lval_println(lval v){
    lval_print(v);
    putchar('\n');
}

将数据结构更改后，需要将我们的操作函数进行更改其返回类型及传入的参数都需要从long型转换成自定义的lval，其定义如下

lval eval_op(lval x,char* op,lval y){
        if(x.type==LVAL_ERR){return x;}
        if(y.type==LVAL_ERR){return y;}

        if(strcmp(op,"+")==0){return lval_num(x.num+y.num);}
        if(strcmp(op,"-")==0){return lval_num(x.num-y.num);}
        if(strcmp(op,"*")==0){return lval_num(x.num*y.num);}
        if(strcmp(op,"/")==0){return y==0
                ?lval_err(LERR_DIV_ZERO)
                :lval_num(x.num/y.num);
        }
        if(strcmp(op,"%")==0){return x%y;}
        if(strcmp(op,"^")==0){return pow(x,y);}
        if(strcmp(op,"min")==0){return x>=y?y:x;}
        if(strcmp(op,"max")==0){return x>=y?x:y;}
        return lval_err(LERR_BAD_OP);
}

同样需要对eval函数进行类似的处理

lval eval(mpc_ast_t* t) {

  if (strstr(t->tag, "number")) {
    /* Check if there is some error in conversion */
    errno = 0;
    long x = strtol(t->contents, NULL, 10);
    return errno != ERANGE ? lval_num(x) : lval_err(LERR_BAD_NUM);
  }

  char* op = t->children[1]->contents;
  lval x = eval(t->children[2]);

  int i = 3;
  while (strstr(t->children[i]->tag, "expr")) {
    x = eval_op(x, op, eval(t->children[i]));
    i++;
  }

  return x;
}

S-Expression