写给小白的开源编译器

(add 2 (subtract 4 2))

[
  { type: 'paren',  value: '('        },
  { type: 'name',   value: 'add'      },
  { type: 'number', value: '2'        },
  { type: 'paren',  value: '('        },
  { type: 'name',   value: 'subtract' },
  { type: 'number', value: '4'        },
  { type: 'number', value: '2'        },
  { type: 'paren',  value: ')'        },
  { type: 'paren',  value: ')'        },
]

// `current` 变量就像一个指光标一样让我们可以在代码中追踪我们的位置
let current = 0;
  
// `tokens` 数组用来存我们的标记
let tokens = [];

// 在循环里面我们可以将`current`变量增加为我们想要的值
while (current < input.length) {
  // 我们还将在 `input` 中存储 `current` 字符
  let char = input[current];
}

var char = str[0]

// 检查是否有一个左括号:
if (char === '(') {
  
  // 如果有，我们会存一个类型为 `paren` 的新标记到数组，并将值设置为一个左括号。
  tokens.push({
    type: 'paren',
    value: '(',
  });
  
  // `current`自增
  current++;
  
  // 然后继续进入下一次循环。
  continue;
}

// 接下去检查右括号， 像上面一样
if (char === ')') {
  tokens.push({
    type: 'paren',
    value: ')',
  });
  current++;
  continue;
}

// 接下去我们检查空格，这对于我们来说就是为了知道字符的分割，但是并不需要存储为标记。

// 所以我们来检查是否有空格的存在，如果存在，就继续下一次循环，做除了存储到标记数组之外的其他操作即可
let WHITESPACE = /\s/;
if (WHITESPACE.test(char)) {
  current++;
  continue;
}

//   (add 123 456)
//        ^^^ ^^^
//        只有两个单独的标记
//
// 因此，当我们遇到序列中的第一个数字时，我们就开始了
let NUMBERS = /[0-9]/;
if (NUMBERS.test(char)) {
  
  // 我们将创建一个`value`字符串，并把字符推送给他
  let value = '';
  
  // 然后我们将遍历序列中的每个字符，直到遇到一个不是数字的字符
  // 将每个作为数字的字符推到我们的 `value` 并随着我们去增加 `current`
  // 这样我们就能拿到一个完整的数字字符串，例如上面的 123 和 456，而不是单独的 1 2 3 4 5 6
  while (NUMBERS.test(char)) {
    value += char;
    char = input[++current];
  }
  
  // 接着我们把数字放到标记数组中，用数字类型来描述区分它
  tokens.push({ type: 'number', value });
  
  // 继续外层的下一次循环
  continue;
}

// 从检查开头的双引号开始:
if (char === '"') {
  // 保留一个 `value` 变量来构建我们的字符串标记。
  let value = '';
  
  // 我们将跳过编辑中开头的双引号
  char = input[++current];
  
  // 然后我们将遍历每个字符，直到我们到达另一个双引号
  while (char !== '"') {
    value += char;
    char = input[++current];
  }
  
  // 跳过相对应闭合的双引号.
  char = input[++current];
  
  // 把我们的字符串标记添加到标记数组中
  tokens.push({ type: 'string', value });
  
  continue;
}

//   (add 2 4)
//    ^^^
//    名称标记
//
let LETTERS = /[a-z]/i;
if (LETTERS.test(char)) {
  let value = '';

  // 同样，我们遍历所有，并将它们完整的存到`value`变量中
  while (LETTERS.test(char)) {
    value += char;
    char = input[++current];
  }

  // 并把这种名称类型的标记存到标记数组中，继续循环
  tokens.push({ type: 'name', value });

  continue;
}

{
  type: 'Program',
  body: [{
    type: 'CallExpression',
    name: 'add',
    params: [{
      type: 'NumberLiteral',
      value: '2',
    }, {
      type: 'CallExpression',
      name: 'subtract',
      params: [{
        type: 'NumberLiteral',
        value: '4',
      }, {
        type: 'NumberLiteral',
        value: '2',
      }]
    }]
  }]
}

[
  { type: 'paren',  value: '('        },
  { type: 'name',   value: 'add'      },
  { type: 'number', value: '2'        },
  { type: 'paren',  value: '('        },
  { type: 'name',   value: 'subtract' },
  { type: 'number', value: '4'        },
  { type: 'number', value: '2'        },
  { type: 'paren',  value: ')'        },
  { type: 'paren',  value: ')'        },
]

function walk() {
 // 在 walk 函数里面，我们首先获取`current`标记
 let token = tokens[current];
}

while (current < tokens.length) {
  ast.body.push(walk());
}

// 首先先检查一下是否有`number`标签.
if (token.type === 'number') {

  // 如果找到一个,就增加`current`.
  current++;

  // 然后我们就能返回一个新的叫做`NumberLiteral`的 AST 节点，并赋值
  return {
    type: 'NumberLiteral',
    value: token.value,
  };
}

// 对于字符串来说，也是和上面数字一样的操作。新增一个`StringLiteral`节点
if (token.type === 'string') {
  current++;

  return {
    type: 'StringLiteral',
    value: token.value,
  };
}

if (
  token.type === 'paren' &&
  token.value === '('
) {

  // 我们将增加`current`来跳过这个插入语，因为在 AST 树中我们并不关心这个括号
  token = tokens[++current];

  // 我们创建一个类型为“CallExpression”的基本节点，并把当前标记的值设置到 name 字段上
  // 因为左括号的下一个标记就是这个函数的名字
  let node = {
    type: 'CallExpression',
    name: token.value,
    params: [],
  };

  // 继续增加`current`来跳过这个名称标记
  token = tokens[++current];

  // 现在我们要遍历每一个标记，找出其中是`CallExpression`的`params`，直到遇到右括号
  // 我们将依赖嵌套的`walk`函数来增加我们的`current`变量来超过任何嵌套的`CallExpression`
  // 所以我们创建一个`while`循环持续到遇到一个`type`是'paren'并且`value`是右括号的标记
  while (
    (token.type !== 'paren') ||
    (token.type === 'paren' && token.value !== ')')
  ) {
    // 我们把这个节点存到我们的`node.params`中去
    node.params.push(walk());
    token = tokens[current];
  }

  // 我们最后一次增加`current`变量来跳过右括号
  current++;

  // 返回node节点
  return node;
}

// 我们可以有一个“NumberLiteral”的节点：
{
  type: 'NumberLiteral',
  value: '2',
}

// 或者可能是“CallExpression”的一个节点：
{
  type: 'CallExpression',
  name: 'subtract',
  params: [...嵌套节点放在这里...],
}

var visitor = {
      NumberLiteral() {},
      CallExpression() {},
 };

var visitor = {
      NumberLiteral(node, parent) {},
      CallExpression(node, parent) {},
};

var visitor = {
    Program: {
      enter(node, parent) {},
      exit(node, parent) {},
    },
    NumberLiteral: {
      enter(node, parent) {},
      exit(node, parent) {},
    },
    CallExpression: {
       enter(node, parent) {},
       exit(node, parent) {},
    },
    ...
  };

function traverser(ast, visitor) {
  // traverseNode 函数将接受两个参数：node 节点和他的 parent 节点
  // 这样他就可以将两者都传递给我们的访问者方法（visitor）
  function traverseNode(node, parent) {

    // 我们首先从匹配`type`开始，来检测访问者方法是否存在。访问者方法就是（enter 和 exit）
    let methods = visitor[node.type];

    // 如果这个节点类型有`enter`方法，我们将调用这个函数，并且传入当前节点和他的父节点
    if (methods && methods.enter) {
      methods.enter(node, parent);
    }

    // 接下去我们将按当前节点类型来进行拆分，以便于对子节点数组进行遍历，处理到每一个子节点
    switch (node.type) {
      // 首先从最高的`Program`层开始。因为 Program 节点有一个名叫 body 的属性，里面包含了节点数组
      // 我们调用`traverseArray`来向下遍历它们
      //
      // 请记住，`traverseArray`会依次调用`traverseNode`，所以这棵树将会被递归遍历
      case 'Program':
        traverseArray(node.body, node);
        break;

      // 接下去我们对`CallExpression`做相同的事情，然后遍历`params`属性
      case 'CallExpression':
        traverseArray(node.params, node);
        break;

      // 对于`NumberLiteral`和`StringLiteral`的情况，由于没有子节点，所以直接 break 即可
      case 'NumberLiteral':
      case 'StringLiteral':
        break;

      // 接着，如果我们没有匹配到上面的节点类型，就抛出一个异常错误
      default:
        throw new TypeError(node.type);
    }

    // 如果这个节点类型里面有一个`exit`方法，我们就调用它，并且传入当前节点和他的父节点
    if (methods && methods.exit) {
      methods.exit(node, parent);
    }
  }

  // 调用`traverseNode`来启动遍历，传入之前的 AST 树，由于 AST 树最开始
  // 的点没有父节点，所以我们直接传入 null 就好
  traverseNode(ast, null);
}

// traverseArray 函数来迭代数组，并且调用 traverseNode 函数
function traverseArray(array, parent) {
  array.forEach(child => {
    traverseNode(child, parent);
  });
}

function transformer(ast) {

  let newAst = {
    type: 'Program',
    body: [],
  };
  
  // 这里有个 hack 技巧：这个上下文（context）属性只是用来对比新旧 ast 的
  // 通常你会有比这个更好的抽象方法，但是为了我们的目标能实现，这个方法相对简单些
  ast._context = newAst.body;
  
  // 在这里调用遍历器函数并传入我们的旧的 AST 树和访问者方法(visitor)
  traverser(ast, {...}};
  
  // 在转换器方法的最后，我们就能返回我们刚创建的新的 AST 树了
  return newAst;
}

{
  // 第一个访问者方法是 NumberLiteral 
  NumberLiteral: {
    enter(node, parent) {
      // 我们将创建一个也叫做`NumberLiteral`的新节点，并放到父节点的上下文中去
      parent._context.push({
        type: 'NumberLiteral',
        value: node.value,
      });
    },
  },
  
  // 接下去是 `StringLiteral`
  StringLiteral: {
    enter(node, parent) {
      parent._context.push({
        type: 'StringLiteral',
        value: node.value,
      });
    },
  },
  
  CallExpression: {...}
}

CallExpression: {
  enter(node, parent) {

    // 首先我们创建一个叫`CallExpression`的节点，它带有表示嵌套的标识符“Identifier”
    let expression = {
      type: 'CallExpression',
      callee: {
        type: 'Identifier',
        name: node.name,
      },
      arguments: [],
    };

    // 下面我们在原来的 `CallExpression` 节点上定义一个新的 context，
    // 它是 expression 中 arguments 这个数组的引用，我们可以向其中放入参数。
    node._context = expression.arguments;

    // 之后我们将检查父节点是否是`CallExpression`类型
    // 如果不是的话
    if (parent.type !== 'CallExpression') {

      // 我们将用`ExpressionStatement`来包裹`CallExpression`节点
      // 这么做是因为单独存在的 `CallExpressions` 在 JavaScript 中也可以被当做是声明语句。
      //
      // 比如 `var a = foo()` 与 `foo()`，后者既可以当作表达式给某个变量赋值，
      // 也可以作为一个独立的语句存在
      expression = {
        type: 'ExpressionStatement',
        expression: expression,
      };
    }

    // 最后我们把我们的`CallExpression`(可能有包裹)放到父节点的上下文中去
    parent._context.push(expression);
  },
}

function codeGenerator(node) {

  // 还是按照节点的类型来进行分解操作
  switch (node.type) {

    // 如果我们有`Program`节点，我们将映射`body`中的每个节点
    // 并且通过代码生成器来运行他们，用换行符将他们连接起来
    case 'Program':
      return node.body.map(codeGenerator)
        .join('\n');

    // 对于`ExpressionStatement`，我们将在嵌套表达式上调用代码生成器，并添加一个分号
    case 'ExpressionStatement':
      return (
        codeGenerator(node.expression) +
        ';' // << 这是因为保持代码的统一性（用正确的方式编写代码）
      );

    // 对于`CallExpression`我们将打印`callee`, 新增一个左括号
    // 然后映射每一个`arguments`数组的节点，并用代码生成器执行，每一个节点运行完之后加上逗号
    // 最后增加一个右括号
    case 'CallExpression':
      return (
        codeGenerator(node.callee) +
        '(' +
        node.arguments.map(codeGenerator)
          .join(', ') +
        ')'
      );

    // 对于`Identifier`直接返回`node`的名字就好.
    case 'Identifier':
      return node.name;

    // 对于`NumberLiteral`直接返回`node`的值就好.
    case 'NumberLiteral':
      return node.value;

    // 对于`StringLiteral`，在`node`的值的周围添加双引号.
    case 'StringLiteral':
      return '"' + node.value + '"';

    // 如果没有匹配到节点的类型，就抛出异常
    default:
      throw new TypeError(node.type);
  }
}