Rubyでの新しいプログラミング言語の構築：インタープリター

#interpret_nodesに戻る 、私たちの親友#interpret_node AST::Programの次の直接の子を解釈するために再度呼び出されます 。

def interpret_nodes(nodes)
  last_value = nil

  nodes.each do |node|
    last_value = interpret_node(node)
  end

  last_value
end

AST::Conditionalの解釈を担当するメソッド #interpret_conditionalです 。ただし、それを見る前に、AST::Conditionalの実装を確認して、思い出をリフレッシュしましょう。 それ自体：

class Stoffle::AST::Conditional < Stoffle::AST::Expression
  attr_accessor :condition, :when_true, :when_false

  def initialize(cond_expr = nil, true_block = nil, false_block = nil)
    @condition = cond_expr
    @when_true = true_block
    @when_false = false_block
  end

  def ==(other)
    children == other&.children
  end

  def children
    [condition, when_true, when_false]
  end
end

では、@condition 真実または虚偽のいずれかになる表現を保持します。 @when_true @conditionの場合に実行される1つ以上の式を含むブロックを保持します 真実であり、@when_false （ELSE 句）は、@conditionの場合に実行されるブロックを保持します たまたま間違っています。

それでは、#interpret_conditionを見てみましょう。 ：

def interpret_conditional(conditional)
  evaluated_cond = interpret_node(conditional.condition)

  # We could implement the line below in a shorter way, but better to be explicit about truthiness in Stoffle.
  if evaluated_cond == nil || evaluated_cond == false
    return nil if conditional.when_false.nil?

    interpret_nodes(conditional.when_false.expressions)
  else
    interpret_nodes(conditional.when_true.expressions)
  end
end

Stoffleの真実性はRubyの場合と同じです。つまり、Stoffleでは、nilのみです。 およびfalse 偽りです。条件への他の入力はすべて真実です。

まず、conditional.conditionが保持している式を解釈して、条件を評価します。 。プログラムのASTをもう一度見て、処理しているノードを特定しましょう。

AST::BinaryOperatorがあることがわかりました （> num > 0で使用 ）。さて、これも同じパスです。最初の#interpret_node 、#interpret_binary_operatorを呼び出します 今回：

def interpret_binary_operator(binary_op)
  case binary_op.operator
  when :and
    interpret_node(binary_op.left) && interpret_node(binary_op.right)
  when :or
    interpret_node(binary_op.left) || interpret_node(binary_op.right)
  else
    interpret_node(binary_op.left).send(binary_op.operator, interpret_node(binary_op.right))
  end
end

論理演算子（and およびor ）は二項演算子と見なすことができるため、ここでもそれらを処理します。それらのセマンティクスはRubyの&&と同等であるため および|| 、上記のように、実装は単純な航海です。

次は、私たちが最も関心を持っている方法のセクションです。このセクションでは、他のすべての二項演算子（>を含む）を扱います ）。ここでは、Rubyのダイナミズムを活用して、非常に簡潔なソリューションを考え出すことができます。 Rubyでは、操作に参加するオブジェクトのメソッドとして2項演算子を使用できます。

-2 > 0           # is equivalent to
-2.send(:'>', 0) # this
# and the following line would be a general solution,
# very similar to what we have in the interpreter
operand_1.send(binary_operator, operand_2)

二項演算子の詳細な実装

ご覧のとおり、二項演算子の実装は非常に簡潔です。 Rubyがそのような動的言語ではなかった場合、または演算子のセマンティクスがRubyとStoffleで異なる場合、この方法でソリューションをコーディングすることはできませんでした。

言語設計者/実装者のような立場にいることに気付いた場合は、スイッチ構造を使用するという単純な（ただしそれほどエレガントではない）ソリューションにいつでも頼ることができます。この場合、実装は次のようになります。

# ... inside #interpret_binary_operator ...

case binary_op.operator
when :'+'
  interpret_node(binary_op.left) + interpret_node(binary_op.right)
# ... other operators
end

#interpret_conditionalに戻る前に 、見落とされていないことを確認するために、簡単に迂回しましょう。私たちが解釈しているプログラムを覚えているなら、num 変数は比較に使用されます（二項演算子>を使用） ）一緒に探索しました。左側のオペランド（つまり、numに格納されている値）をどのように取得しましたか その比較の変数）？その原因となるメソッドは#interpret_identifierです。 、およびその実装は簡単です-簡単です：

def interpret_identifier(identifier)
  if env.has_key?(identifier.name)
    env[identifier.name]
  else
    # Undefined variable.
    raise Stoffle::Error::Runtime::UndefinedVariable.new(identifier.name)
  end
end

ここで、#interpret_conditionalに戻ります。 。私たちの小さなプログラムの場合、条件はRuby falseに評価されました 価値。この値を使用して、条件構造のIFまたはELSEブランチを実行する必要があるかどうかを判断します。関連するコードブロックがconditional.when_falseに格納されているELSEブランチの解釈に進みます。 。ここに、AST::Blockがあります。 、これはASTのルートノード（AST::Program）と非常によく似ています。 ）。同様に、ブロックには、解釈する必要のある一連の式が含まれている可能性があります。この目的のために、#interpret_nodesも使用します 。

def interpret_conditional(conditional)
  evaluated_cond = interpret_node(conditional.condition)

  # We could implement the line below in a shorter way, but better to be explicit about truthiness in Stoffle.
  if evaluated_cond == nil || evaluated_cond == false
    return nil if conditional.when_false.nil?

    interpret_nodes(conditional.when_false.expressions)
  else
    interpret_nodes(conditional.when_true.expressions)
  end
end

次に処理する必要のあるASTノードはAST::FunctionCallです。 。関数呼び出しの解釈を担当するメソッドは、#interpret_function_callです。 ：

def interpret_function_call(fn_call)
  return if println(fn_call)
end

記事の冒頭で説明したように、関数の定義と関数の呼び出しについては、このシリーズの次の投稿で取り上げます。したがって、関数呼び出しの特殊なケースのみを実装しています。私たちの小さなおもちゃの言語では、printlnを提供しています ランタイムの一部として、ここのインタープリターに直接実装します。私たちのプロジェクトの目的と範囲を考えると、これは十分に良い解決策です。

def println(fn_call)
  return false if fn_call.function_name_as_str != 'println'

  result = interpret_node(fn_call.args.first).to_s
  output << result
  puts result
  true
end

AST::FunctionCallの最初で唯一の引数 AST::Stringです 、#interpret_stringによって処理されます ：

def interpret_string(string)
  string.value
end

#interpret_string内 、#interpret_numberとまったく同じケースがあります 。 AST::String すぐに使用できるRuby文字列値をすでに保持しているため、取得する必要があります。

ここで、#printlnに戻ります。 ：

def println(fn_call)
  return false if fn_call.function_name_as_str != 'println'

  result = interpret_node(fn_call.args.first).to_s
  output << result
  puts result
  true
end

関数の引数（Ruby文字列に変換）をresultに格納した後 、完了するにはさらに2つのステップがあります。まず、コンソールに出力しようとしているものを@outputに保存します 。前に説明したように、ここでの考え方は、何が印刷されたか（そしてどのような順序で）を簡単に検査できるようにすることです。これを手元に用意しておくと、インタプリタをデバッグまたはテストするときに私たちの生活が楽になります。最後に、コンソールへの印刷を実装するために、Rubyのputsを使用します 。

#!/usr/bin/env ruby

require_relative '../lib/stoffle'

path = ARGV[0]
source = File.read(path)
lexer = Stoffle::Lexer.new(source)
parser = Stoffle::Parser.new(lexer.start_tokenization)
interpreter = Stoffle::Interpreter.new

interpreter.interpret(parser.parse)

exit(0)