1. 第零九章 • S-表达式

因为现在我们考虑的是 S-表达式，而不是之前的波兰表达式了，我们需要更新一下语法分析器。S-表达式的语法非常简单。只是小括号之间包含一组表达式而已。而这些表达式可以是数字、操作符或是其他的 S-表达式。只需修改一下之前写的就可以了。另外，我们还需把 operator 规则重命名为 symbol 。为之后添加更多的操作符以及变量、函数等做准备。

mpc_parser_t* Number = mpc_new("number");
mpc_parser_t* Symbol = mpc_new("symbol");
mpc_parser_t* Sexpr  = mpc_new("sexpr");
mpc_parser_t* Expr   = mpc_new("expr");
mpc_parser_t* Lispy  = mpc_new("lispy");
mpca_lang(MPCA_LANG_DEFAULT,
  "                                          \
    number : /-?[0-9]+/ ;                    \
    symbol : '+' | '-' | '*' | '/' ;         \
    sexpr  : '(' <expr>* ')' ;               \
    expr   : <number> | <symbol> | <sexpr> ; \
    lispy  : /^/ <expr>* /$/ ;               \
  Number, Symbol, Sexpr, Expr, Lispy);
同时，还要记得在退出之前做好清理工作：
mpc_cleanup(5, Number, Symbol, Sexpr, Expr, Lispy);
1.5. 表达式结构

首先，我们需要让 lval 能够存储 S-表达式。这意味着我们还要能存储符号(Symbols)和数字。我们向枚举中添加两个新的类型。LVAL_SYM 表示操作符类型，例如 + 等，LVAL_SEXPR 表示 S-表达式。
enum { LVAL_ERR, LVAL_NUM, LVAL_SYM, LVAL_SEXPR };
S-表达式是一个可变长度的列表。在本章的开头已经提到，我们不能创建可变长度的结构体，所以只能使用指针来表示它。我们为  lval 结构体创建一个 cell 字段，指向一个存放 lval* 列表的区域。所以 cell 的类型就应该是 lval**。指向 lval* 的指针。我们还需要知道 cell 列表中的元素个数，所以我创建了 count 字段。
我们使用字符串来表示符号(Symbols)，另外我们还增加了另一个字符串用来存储错误信息。也就是说现在 lval 可以存储更加具体的错误信息了，而不只是一个错误代码，这使得我们的错误报告系统更加灵活好用。我们也可以删除掉之前写的错误枚举了。升级过后的 lval 结构体如下所示：
typedef struct lval {
  int type;
  long num;
  /* Error and Symbol types have some string data */
  char* err;
  char* sym;
  /* Count and Pointer to a list of "lval*" */
  int count;
  struct lval** cell;
} lval;
有指向指向指针的指针的指针吗？

这里有个古老的笑话，说是可以根据 C 程序员的程序中指针后面的星星数(*)作为其水平的评分。:P
初级水平的人写的程序可能只会用到像 char* 或是奇怪的 int* 等一级指针，所以他们被称为一星程序员。而大多数中级的程序员则会用到诸如 lval** 这类的二级指针，所以他们被称为二星程序员。但据说能用三级指针的就真的很少见了，你可能会在一些伟大的作品中见到，这些代码的妙处凡夫俗子自然也是体会不到的。果真如此，三星程序员这个称号真是极大的赞誉了。
但据我所知，还没有人用到过四级指针。
1.6. 构造函数和析构函数

我们可以重写 lval 的构造函数，使其返回 lval 的指针，而不是其本身。这样做会使得对 lval 变量进行跟踪更加简单。为此，我们需要用到 malloc 库函数以及 sizeof 操作符为 lval 结构体在堆上申请足够大的内存区域，然后使用 -> 操作符填充结构体中的相关字段。
当我们构造一个 lval 时，它的某些指针字段可能会包含其他的在堆上申请的内存，所以我们应该小心行事。当某个 lval 完成使命之后，我们不仅需要删除它本身所指向的堆内存，还要删除它的字段所指向的堆内存。
/* Construct a pointer to a new Number lval */ 
lval* lval_num(long x) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_NUM;
  v->num = x;
  return v;
/* Construct a pointer to a new Error lval */ 
lval* lval_err(char* m) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_ERR;
  v->err = malloc(strlen(m) + 1);
  strcpy(v->err, m);
  return v;
/* Construct a pointer to a new Symbol lval */ 
lval* lval_sym(char* s) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_SYM;
  v->sym = malloc(strlen(s) + 1);
  strcpy(v->sym, s);
  return v;
/* A pointer to a new empty Sexpr lval */
lval* lval_sexpr(void) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_SEXPR;
  v->count = 0;
  v->cell = NULL;
  return v;
NULL 是什么？

NULL 是一个指向内存地址 0 的特殊常量。按照惯例，它通常被用来表示空值或无数据。在上面的代码中，我们使用 NULL 来表示虽然我们有一个数据指针，但它目前还没有指向任何内容。在本书的后续章节中你讲经常性地遇到这个特殊的常量，所以，请眼熟它。
为什么要使用 strlen(s) + 1？

在 C 语言中，字符串是以空字符做为终止标记的。所以，C 语言字符串的最后一个字符一定是 \0。请确保所有的字符串都是按照这个约定来存储的，不然程序就会因为莫名其妙的错误退出。strlen 函数返回的是字符串的实际长度(所以不包括结尾的 \0 终止符)。所以为了保证有足够的空间存储所有字符，我们需要在额外 +1。
现在，我们需要一个定制的函数来删除 lval*。这个函数应该调用 free 函数来释放本身所指向的由 malloc 函数所申请的内存。但更重要的是，它应该根据自身的类型，释放所有它的字段指向的内存。所以我们只需按照上方介绍的那些构造函数对应释放相应的字段，就不会有内存的泄露了。
void lval_del(lval* v) {
  switch (v->type) {
    /* Do nothing special for number type */
    case LVAL_NUM: break;
    /* For Err or Sym free the string data */
    case LVAL_ERR: free(v->err); break;
    case LVAL_SYM: free(v->sym); break;
    /* If Sexpr then delete all elements inside */
    case LVAL_SEXPR:
      for (int i = 0; i < v->count; i++) {
        lval_del(v->cell[i]);
      /* Also free the memory allocated to contain the pointers */
      free(v->cell);
    break;
  /* Free the memory allocated for the "lval" struct itself */
  free(v);
1.7. 读取表达式

首先我们会读取整个程序，并构造一个 lval* 来表示它，然后我们对这个 lval* 进行遍历求值来得到程序的运行结果。第一阶段负责把抽象语法树(abstract syntax tree)转换为一个 S-表达式，第二阶段则根据我们已由的 Lisp 规则对 S-表达式进行遍历求值。




    

为了完成第一步，我们可以递归的查看语法分析树中的每个节点，并根据节点的 tag 和 contents 字段构造出不同类型的 lval*。
如果给定节点的被标记为 number 或 symbol，则我们可以调用对应的构造函数直接返回一个 lval*。如果给定的节点被标记为 root 或 sexpr，则我们应该构造一个空的 S-表达式类型的 lval*，并逐一将它的子节点加入。
为了更加方便的像一个 S-表达式中添加元素，我们可以创建一个函数 lval_add，这个函数将表达式的子表达式计数加一，然后使用 realloc 函数为 v->cell 字段重新扩大申请内存，用于存储刚刚加入的子表达式 lval* x。
lval* lval_read_num(mpc_ast_t* t) {
  errno = 0;
  long x = strtol(t->contents, NULL, 10);
  return errno != ERANGE ?
    lval_num(x) : lval_err("invalid number");
lval* lval_read(mpc_ast_t* t) {
  /* If Symbol or Number return conversion to that type */
  if (strstr(t->tag, "number")) { return lval_read_num(t); }
  if (strstr(t->tag, "symbol")) { return lval_sym(t->contents); }
  /* If root (>) or sexpr then create empty list */
  lval* x = NULL;
  if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } 
  if (strstr(t->tag, "sexpr"))  { x = lval_sexpr(); }
  /* Fill this list with any valid expression contained within */
  for (int i = 0; i < t->children_num; i++) {
    if (strcmp(t->children[i]->contents, "(") == 0) { continue; }
    if (strcmp(t->children[i]->contents, ")") == 0) { continue; }
    if (strcmp(t->children[i]->tag,  "regex") == 0) { continue; }
    x = lval_add(x, lval_read(t->children[i]));
  return x;
lval* lval_add(lval* v, lval* x) {
  v->count++;
  v->cell = realloc(v->cell, sizeof(lval*) * v->count);
  v->cell[v->count-1] = x;
  return v;
1.8. 打印表达式

距离验证本章做的所有改变只有一步之遥了！我们还需要修改打印函数使其能够打印出 S-表达式。通过将 S-表达式打印出来和输入对比可以进一步检查读入模块是否正确工作。
为了打印 S-表达式，我们创建一个新函数，遍历所有的子表达式，并将它们单独打印出来，以空格隔开，正如输入的时候一样。
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 函数，lval_print 内部又调用了 lval_expr_print。似乎是没有办法解决依赖性的。C 语言提供了前置声明来解决这个问题。前置声明只定义了函数的形式，而没有函数体(译者注：前置声明就是告诉编译器：“我保证有这个函数，你放心调用就是了”)。它允许其他函数调用它，而具体的函数定义则在后面。函数声明只要将函数定义的函数体换成 ; 即可。在我们的程序中，应该将 void lval_print(lval* v); 语句放在一个比 lval_expr_print  函数靠前的地方。在以后的编程过程中，你一定会再次遇到这个问题，所以请记住这个解决方案！
在主循环中，我们可以将求值部分移除了，替换为新写就的读取和打印函数。
lval* x = lval_read(r.output);
lval_println(x);
lval_del(x);
正常情况下，你应该可以看到下面这样的结果。
lispy> + 2 2
(+ 2 2)
lispy> + 2 (* 7 6) (* 2 5)
(+ 2 (* 7 6) (* 2 5))
lispy> *     55     101  (+ 0 0 0)
(* 55 101 (+ 0 0 0))
lispy>
1.9. 表达式求值

求值函数的具体行为和之前的并无太大变化。我们需要将其适配本章定义的 lval* 以及更加灵活的表达式定义。其实可以把求值函数想象成某种转换器－－它读取 lval* 作为输入，通过某种方式将其转化为新的 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);
现在，你应该可以向上一章一样，正确地对表达式进行求值了。稍作休息，尝试一下新的求值过程。确保能够正常运行，运行结果正确。在下一章，我们将充分利用本章做出的改变，实现一些更加酷炫的特性。
lispy> + 1 (* 7 5) 3
lispy> (- 100)
lispy>
lispy> /
lispy> (/ ())
Error: Cannot operate on non-number!
lispy>
1.10. 彩蛋

举例说明在我们的程序中哪个变量是在栈上的。
举例说明在我们的程序中哪个变量是在堆上的。
strcpy 函数的作用是什么？
realloc 函数的作用是什么？
memmove 函数的作用是什么？
memmove 于 memcpy 有何不同？
扩展解析和求值部分使其支持求余操作符 %。
扩展解析和求值部分使其支持浮点数(double)。
1.11. 参考

s_expressions.c
#include "mpc.h"
#ifdef _WIN32
static char buffer[2048];
char* readline(char* prompt) {
  fputs(prompt, stdout);
  fgets(buffer, 2048, stdin);
  char* cpy = malloc(strlen(buffer)+1);
  strcpy(cpy, buffer);
  cpy[strlen(cpy)-1] = '\0';
  return cpy;
void add_history(char* unused) {}
#else
#include <editline/readline.h>
#include <editline/history.h>
#endif
/* Add SYM and SEXPR as possible lval types */
enum { LVAL_ERR, LVAL_NUM, LVAL_SYM, LVAL_SEXPR };
typedef struct lval {
  int type;
  long num;
  /* Error and Symbol types have some string data */
  char* err;
  char* sym;
  /* Count and Pointer to a list of "lval*"; */
  int count;
  struct lval** cell;
} lval;
/* Construct a pointer to a new Number lval */ 
lval* lval_num(long x) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_NUM;
  v->num = x;
  return v;
/* Construct a pointer to a new Error lval */ 
lval* lval_err(char* m) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_ERR;
  v->err = malloc(strlen(m) + 1);
  strcpy(v->err, m);
  return v;
/* Construct a pointer to a new Symbol lval */ 
lval* lval_sym(char* s) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_SYM;
  v->sym = malloc(strlen(s) + 1);
  strcpy(v->sym, s);
  return v;
/* A pointer to a new empty Sexpr lval */
lval* lval_sexpr(void) {
  lval* v = malloc(sizeof(lval));
  v->type = LVAL_SEXPR;
  v->count = 0;
  v->cell = NULL;
  return v;
void lval_del(lval* v) {
  switch (v->type) {
    /* Do nothing special for number type */
    case LVAL_NUM: break;
    /* For Err or Sym free the string data */
    case LVAL_ERR: free(v->err); break;
    case LVAL_SYM: free(v->sym); break;
    /* If Sexpr then delete all elements inside */
    case LVAL_SEXPR:
      for (int i = 0; i < v->count; i++) {
        lval_del(v->cell[i]);
      /* Also free the memory allocated to contain the pointers */
      free(v->cell);
    break;
  /* Free the memory allocated for the "lval" struct itself */
  free(v);
lval* lval_add(lval* v, lval* x) {
  v->count++;
  v->cell = realloc(v->cell, sizeof(lval*) * v->count);
  v->cell[v->count-1] = x;
  return v;
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;
void lval_print(lval* v);
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* 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);
    /* Perform operation */
    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;
    /* Delete element now finished with */
    lval_del(y);
  /* Delete input expression and return result */
  lval_del(a);
  return x;
lval* lval_eval(lval* v);
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* lval_read_num(mpc_ast_t* t) {
  errno = 0;
  long x = strtol(t->contents, NULL, 10);
  return errno != ERANGE ?
    lval_num(x) : lval_err("invalid number");
lval* lval_read(mpc_ast_t* t) {
  /* If Symbol or Number return conversion to that type */
  if (strstr(t->tag, "number")) { return lval_read_num(t); }
  if (strstr(t->tag, "symbol")) { return lval_sym(t->contents); }
  /* If root (>) or sexpr then create empty list */
  lval* x = NULL;
  if (strcmp(t->tag, ">") == 0) { x = lval_sexpr(); } 
  if (strstr(t->tag, "sexpr"))  { x = lval_sexpr(); }
  /* Fill this list with any valid expression contained within */
  for (int i = 0; i < t->children_num; i++) {
    if (strcmp(t->children[i]->contents, "(") == 0) { continue; }
    if (strcmp(t->children[i]->contents, ")") == 0) { continue; }
    if (strcmp(t->children[i]->contents, "}") == 0) { continue; }
    if (strcmp(t->children[i]->contents, "{") == 0) { continue; }
    if (strcmp(t->children[i]->tag,  "regex") == 0) { continue; }
    x = lval_add(x, lval_read(t->children[i]));
  return x;
int main(int argc, char** argv) {
  mpc_parser_t* Number = mpc_new("number");
  mpc_parser_t* Symbol = mpc_new("symbol");
  mpc_parser_t* Sexpr  = mpc_new("sexpr");
  mpc_parser_t* Expr   = mpc_new("expr");
  mpc_parser_t* Lispy  = mpc_new("lispy");
  mpca_lang(MPCA_LANG_DEFAULT,
    "                                          \
      number : /-?[0-9]+/ ;                    \
      symbol : '+' | '-' | '*' | '/' ;         \
      sexpr  : '(' <expr>* ')' ;               \
      expr   : <number> | <symbol> | <sexpr> ; \
      lispy  : /^/ <expr>* /$/ ;               \
    Number, Symbol, Sexpr, Expr, Lispy);
  puts("Lispy Version 0.0.0.0.5");
  puts("Press Ctrl+c to Exit\n");
  while (1) {
    char* input = readline("lispy> ");
    add_history(input);
    mpc_result_t r;
    if (mpc_parse("<stdin>", input, Lispy, &r)) {
      lval* x = lval_eval(lval_read(r.output));
      lval_println(x);
      lval_del(x);
      mpc_ast_delete(r.output);
    } else {    
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    free(input);
  mpc_cleanup(5, Number, Symbol, Sexpr, Expr, Lispy);
  return 0;