1. 技术文章
  2. C 语言开发一门编程语言 — S-表达式

C 语言开发一门编程语言 — S-表达式

由 蓝咒 提交于 2020-04-10 15:35:02

目录

文章目录

前文列表

《用 C 语言开发一门编程语言 — 交互式 Shell》
《用 C 语言开发一门编程语言 — 跨平台》
《用 C 语言开发一门编程语言 — 语法解析器》
《用 C 语言开发一门编程语言 — 基于抽象语法数的求值计算》
《C 语言开发一门编程语言 — 异常处理》



使用 S-表达式进行重构

所谓 S-表达式（Symbolic Expression，S-Expression，符号表达式）是指一种以人类可读的文本形式表达半结构化数据的约定方式。S-Expression 在 Lisp 家族的编程语言中被使用而为人所知。S-Expression 在 Lisp 中既用作代码，也用作数据，这使得它非常强大，能完成许多其他语言不能完成的事情。

为了拥有这个强大的特性，我们需要将以往实现的求值过程分为两个新的过程：

  1. 读取并存储输入
  2. 对输入进行求值

这样（先存储、再求值）的话，S-Expression 在 Lisp 中就可以既用作代码，也用作数据了。

读取并存储输入

实现 S-Expression 语法解析器

首先实现 S-Expression 的读取，我们将原有的波兰表达式解析器改造为 S-Expression 解析器。

S-Expression 的语法规则非常简单：

  • 小括号之间包含一组表达式
  • 表达式可以是数字、操作符或是其他的 S-Expression

另外，我们把 operator（操作符）规则重定义为 symbol（符号）规定，使其可以表示更多的含义，例如：操作符、变量、函数等。

实现 S-Expression 存储器

为了存储输入的 S-Expression，我们需要创建一个内部的列表结构，能够递归地表示数字、操作符号以及其他的列表。我们可以通过改造 lval 结构体来实现。

首先，我们向枚举中添加两个新的类型分别标识 Symbols 和 S-Expression：

  1. LVAL_SYM：表示操作符类型，例如 + 等
  2. LVAL_SEXPR：表示 S-表达式

然后，因为 S-Expression 是一个可变长度的列表，所以只能使用指针来表示它（结构体本身是固定大小的）。我们为 lval 结构体创建一个 cell 字段指向一个存放 lval * 列表的区域，所以 cell 的类型就应该是二重指针 lval**。因为 lval * 列表是可变长的，通过指针的方式，我们实现了在不可变长的结构体中，存储可变长的列表结构。另外，我们还需要知道 cell 列表中的元素个数，所以创建了 count 字段。

为了让 lval 结构体可以存储更加具体的错误信息了，而不只是一个错误代码，我们还增加了 ERROR 字符串用来存储错误信息，这样我们就可以删除掉之前写的错误枚举了。另外，我们还需要使用一个字符串来表示 Symbols。

实现 lval 变量的构造函数

通过上述的分析，我们知道 lval 结构体是一个大小不定的变量，处理性能的考虑，我们应该通过 lval 结构体指针来对其进行操作。尤其是在函数实参传入的时候，传递指针作为实参可以避免 C 语言对整个结构体数据的拷贝。

所以我们重写 lval 的构造函数，使其返回 lval 结构体的指针，而不是其本身。这样做会使得对 lval 变量进行跟踪更加简单。为此，我们使用 malloc 库函数以及 sizeof 运算符为 lval 结构体在堆上申请足够大的内存区域，然后使用 -> 操作符填充结构体中的相关字段。

实现 lval 变量的析构函数

当我们构造一个 lval 变量的时候，它的某些指针字段包含了在堆上申请的内存，所以当某个 lval 变量完成使命之后，我们不仅需要删除它本身所指向的堆内存，还要删除它的指针字段所指向的堆内存。这就是析构函数要处理的事情。

析构函数应该调用 free 函数来释放指针字段所指向的由 malloc 函数所申请的内存。所以我们只需按照上方介绍的构造函数，来对应释放相应字段的内存，就不会有内存的泄露了。

读取 S-Expression

读取到了用户的输入后，S-Expression 语法解析器会将输入的字符串解析为 S-Expression 抽象语法树，我们可以递归的查看语法分析树中的每个节点，并根据节点的 tag 和 contents 字段构造出不同类型的 lval 结构体变量，再以指针的形式返回。然后我们对这个变量进行遍历求值来得到最终的运行结果。

  • S-Expression：(* 2 (+ 3 4)) 的 AST示例
    在这里插入图片描述

所以在进行实际的运算之前，我们还需要对 S-Expression AST 进行处理：

  • 如果给定节点的被标记为 number 或 symbol，则我们可以调用对应的构造函数直接返回一个 lval *。
  • 如果给定的节点被标记为 root 或 sexpr，则我们应该构造一个空的 S-Expression 类型的 lval *，并逐一将它的子节点加入。

为了更加方便的向一个 S-Expression 中添加元素，我们可以创建一个函数 lval_add，这个函数将 S-Expression 的子表达式 count + 1，然后使用 realloc 函数为 v->cell 字段重新扩大申请内存，用于存储刚刚加入的子表达式 lval *x。

我们还需要修改打印函数使其能够打印出 S-Expression。通过将 S-Expression 打印出来便于与输入进行对比，可以进一步检查读入模块是否正确工作。为了打印 S-Expression，我们创建一个新函数，遍历所有的子表达式，并将它们单独打印出来，以空格隔开，正如输入的时候一样。

void lval_expr_print(lval* v, char open, char close) {
  putchar(open);
  for (int i = 0; i < v->count; i++) {

    /* Print Value contained within */
    lval_print(v->cell[i]);

    /* Don't print trailing space if last element */
    if (i != (v->count-1)) {
      putchar(' ');
    }
  }
  putchar(close);
}

void lval_print(lval* v) {
  switch (v->type) {
    case LVAL_NUM:   printf("%li", v->num); break;
    case LVAL_ERR:   printf("Error: %s", v->err); break;
    case LVAL_SYM:   printf("%s", v->sym); break;
    case LVAL_SEXPR: lval_expr_print(v, '(', ')'); break;
  }
}

void lval_println(lval* v) { lval_print(v); putchar('\n'); }

注意，lval_expr_print 函数和 lval_print 函数互相调用了。C 语言提供了前置声明来解决这个问题。前置声明就是告诉编译器：“我保证有这个函数，你放心调用就是了”。所以，前置声明只定义了函数的形式，而没有函数体。它允许其他函数调用它，而具体的函数定义则在后面。函数声明只要将函数定义的函数体换成 ; 即可。在我们的程序中，应该将前置声明语句 void lval_print(lval* v); 放在一个比 lval_expr_print 函数靠前的地方。

在主循环中，我们可以将求值部分移除了，替换为新写就的读取和打印函数。

lval* x = lval_read(r.output);
lval_println(x);
lval_del(x);

对输入进行求值

S-Expression 求值的运算过程：

  1. 首先取列表第一个元素为操作符
  2. 然后遍历所有剩下的元素，将它们作为操作数

求值函数的具体行为和之前的并无太大变化。我们需要将其适配本章定义的 lval * 以及更加灵活的表达式定义。

其实可以把求值函数想象成某种转换器－－它读取 lva l* 作为输入，通过某种方式将其转化为新的 lval * 并输出。在有些时候，求值函数不对输入做任何修改，原封不动的将其返回；有些时候，它会对输入的做一些改动；而在大多数情况下，它会将输入的 lval * 删除，返回完全不同的东西。如果要返回新的东西，一定要记得将原有的作为输入的 lval * 删除。

对于 S-表达式，我们首先遍历它所有的子节点，如果子节点有任何错误，我们就使用稍后定义的函数 lval_take 将遇到的第一个错误返回。

对于没有子节点的 S-表达式直接将其返回就可以了，这是为了处理空表达式 {} 的情况。另外，我们还需要检查只有一个子节点的表达式，例如 {5}，这种情况我们应该将其包含的表达式返回。

如果以上情况都不成立，那我们就知道这是一个合法的表达式，有个多于一个的子节点。对于此种情况，我们使用稍后定义的函数 lval_pop 将第一个元素从表达式中分离开来，然后检查确保它是一个 symbol。然后根据它的具体类型，将它和参数一起传入 builtin_op 函数计算求值。如果它不是 symbol，我们就将它以及传进来的其它参数删除，然后返回一个错误。

对于其它的非 S-表达式类型，我们就直接将其返回。

lval* lval_eval_sexpr(lval* v) {

  /* Evaluate Children */
  for (int i = 0; i < v->count; i++) {
    v->cell[i] = lval_eval(v->cell[i]);
  }

  /* Error Checking */
  for (int i = 0; i < v->count; i++) {
    if (v->cell[i]->type == LVAL_ERR) { return lval_take(v, i); }
  }

  /* Empty Expression */
  if (v->count == 0) { return v; }

  /* Single Expression */
  if (v->count == 1) { return lval_take(v, 0); }

  /* Ensure First Element is Symbol */
  lval* f = lval_pop(v, 0);
  if (f->type != LVAL_SYM) {
    lval_del(f); lval_del(v);
    return lval_err("S-expression Does not start with symbol!");
  }

  /* Call builtin with operator */
  lval* result = builtin_op(v, f->sym);
  lval_del(f);
  return result;
}

lval* lval_eval(lval* v) {
  /* Evaluate Sexpressions */
  if (v->type == LVAL_SEXPR) { return lval_eval_sexpr(v); }
  /* All other lval types remain the same */
  return v;
}

上面的代码中用到了两个我们还没有定义的函数：lval_pop 和 lval_take，这两个都是用于操作 lval 类型的通用型函数。

  • lval_pop 函数将所操作的 S-表达式的第 i 个元素取出，并将在其后面的元素向前移动填补空缺，使得这个 S-表达式不再包含这个元素。然后将取出的元素返回。需要注意的是，这个函数并不会将这个 S-表达式删除。它只是从中取出某个元素，剩下的元素都保持原样。这意味着这两部分最终都需要在某个地方使用 lval_del 函数删除。
  • lval_take 和 lval_pop 函数类似，不过它将取出元素之后剩下的列表删除了。它利用了 lval_pop 函数并做了一点小小的改变，却使得我们的代码可读性更高了一些。所以，不同于 lval_pop，你只需负责使用 lval_del 删除取出的元素即可。
lval* lval_pop(lval* v, int i) {
  /* Find the item at "i" */
  lval* x = v->cell[i];

  /* Shift memory after the item at "i" over the top */
  memmove(&v->cell[i], &v->cell[i+1],
    sizeof(lval*) * (v->count-i-1));

  /* Decrease the count of items in the list */
  v->count--;

  /* Reallocate the memory used */
  v->cell = realloc(v->cell, sizeof(lval*) * v->count);
  return x;
}

lval* lval_take(lval* v, int i) {
  lval* x = lval_pop(v, i);
  lval_del(v);
  return x;
}

我们还需要定义求值函数 builtin_op，它和我们在之前章节定义的 eval_op 函数类似，改成了接受一个 lval * 来代表一系列的参数。该函数应该对参数做更加严格的检查，如果有任何参数不是数字类型的 lval *，都应该返回一个错误。

首先，它确保所有的输入参数的类型都为数字。然后将第一个数字弹出开始计算。如果后面没有其它的子表达式，并且操作符为减号时，它会对第一个数字进行取反操作。这确保了类似于 (- 5) 这种表达式能够正确工作。

如果还有更多的参数，它就不断地从列表中取出，将其和之前的计算结果一起进行相应的数学运算。如果做除法时遇到被除数为零的情况，就将临时变量 x 和 y 以及参数列表删除，并返回一个错误。

如果没有错误，参数列表最终会被删除，并返回一个新的表达式。

lval* builtin_op(lval* a, char* op) {

  /* Ensure all arguments are numbers */
  for (int i = 0; i < a->count; i++) {
    if (a->cell[i]->type != LVAL_NUM) {
      lval_del(a);
      return lval_err("Cannot operate on non-number!");
    }
  }

  /* Pop the first element */
  lval* x = lval_pop(a, 0);

  /* If no arguments and sub then perform unary negation */
  if ((strcmp(op, "-") == 0) && a->count == 0) {
    x->num = -x->num;
  }

  /* While there are still elements remaining */
  while (a->count > 0) {

    /* Pop the next element */
    lval* y = lval_pop(a, 0);

    if (strcmp(op, "+") == 0) { x->num += y->num; }
    if (strcmp(op, "-") == 0) { x->num -= y->num; }
    if (strcmp(op, "*") == 0) { x->num *= y->num; }
    if (strcmp(op, "/") == 0) {
      if (y->num == 0) {
        lval_del(x); lval_del(y);
        x = lval_err("Division By Zero!"); break;
      }
      x->num /= y->num;
    }

    lval_del(y);
  }

  lval_del(a); return x;
}

到此我们的求值函数就完成了。我们只需要再次更新一下 main 函数，在其打印表达式之前，先将输入经由求值函数处理即可。

lval* x = lval_eval(lval_read(r.output));
lval_println(x);
lval_del(x);
标签
prism
Sym
Amp
element
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!