如何在JavaScript中实现调用堆栈？

如何解决如何在JavaScript中实现调用堆栈？

调用堆栈由堆栈帧（也称为激活记录或激活帧）组成。

比方说，我有一些代码（一种自定义语言）被编译成AST（使用JavaScript）。语言示例如下所示：

fun a(z):
  let x = 10
  let y = z * x
  let w = b(y,x)
  return w
fun b(a,b):
  let x = c(a,10)
  let y = c(b,20)
  let z = d(x,y)
  return z
fun c(a,b):
  let x = a + 5
  let y = b + 7
  let z = d(x,y)
  return z
fun d(a,b):
  return a * b
main:
  a(argv[0])

没有作弊，也没有说过如何静态地编译它，而是说您只是为此创建了一个解释器。

您将如何创建调用堆栈？每个激活记录的外观如何？ （在JS实现中）。

假设我们有一个简单的AST，您可以从源代码中想象得到：

{
  type: 'fun',name: 'a',params: ['z'],steps: [
    {
      type: 'let',name: 'z',value: {
        type: 'call',name: 'd',params: ['x','y']
      }
    },...
  ]
}

然后您要解释该AST：

let pointer = 'main'
let callstack = []
let stack = [funs[pointer]]
while (stack.length) {
  let current = stack.shift()
  current.steps.forEach(step => {
    if (step.type == 'call') {
      // PUSH ACTIVATION RECORD SOMEHOW
      step.params.forEach(param => {
        callstack.push(param) // how to reach value from reference?
      })
      stack.push(step)
    }
  })
}

我完全迷路了。该解释函数是什么样的？

解决方法

好吧，首先，让我们为您的示例构建正确的AST。在这种情况下，正确设置细节非常重要。它看起来应该更像这样，而且离完美的AST还差得远。

{ type: compilation_unit // this is an object that is an array of functions
  [ 
    { type: fun // this is what you will push on your 'call stack'
      name: 'a'
      params: ['z']
      locals: ['x','y','w']
      steps: [
        { type: let
          name: 'x'
          value: { type: const
                   value: 10
                 }
         },{ type: let
           name: 'y'
           value: { type: '*'
                    left: { type: var
                            name: 'z'
                          }
                     right: { type: var
                              name: 'x'
                             }
                   }
           }
    ...
    }
    { type: fun
      name: 'b'
      ...
    }
    ...
    { type: fun
      name: 'main'
      params ...
      locals ...
      steps: [
        { type: call
          name: 'a'
          args: [ 
             { type: '[]'
               name: 'argv'
               subscript: {
                  { type: const
                    value: 0
                  }
             }
           ]
        }
      ]
    } // type fun
  ]
}

因此，如果您将AST用作IR，则在到达调用“节点”时，要压入堆栈的是[AST]所调用函数的指针。这就是您需要的信息。参数，局部变量和您需要执行的步骤都在这里。您的字节码解释器（在本例中为AST步行解释器）只需要查看类型：好玩的对象，看看有多少个参数，有多少个局部变量，等等，并为其分配空间。

但是，这可能不是您想要的。您谈论3个地址代码，这通常意味着较低的IR。为此，您需要一个将AST转换为较低级别表示形式的阶段。您需要对AST进行传递，以生成“较低级别”的IR。

我个人会推荐类似LLVM IR的内容，但这将需要您进行一些研究。但是要查看类似的堆栈框架，找到一个生成LLVM IR的C编译器（或某种与您想要的语言接近的其他编译器），并查看它为调用指令和堆栈框架生成的内容。然后，您将其键入：将有趣的AST对象转换为该指令序列。