Java 如何计算此树中的表达式？

下面是我正在使用的一个解析xml文件的示例，它将xml文件标记为树形

commandList

  assign
    variable
      #text[a]
    expression-int
      #text[1]

  assign
    variable
      #text[b]
    expression-int
      #text[2]

  assign
    variable
      #text[c]
    expression-operation
      operator
        #text[OP_SET]
      arguments
        expression-variable
          variable
            #text[a]
        expression-variable
          variable
            #text[b]

  assign
    variable
      #text[d]
    expression-operation
      operator
        #text[OP_SET]
      arguments
        expression-operation
          operator
            #text[OP_TUPLE]
          arguments
            expression-int
              #text[1]
            expression-int
              #text[2]
        expression-operation
          operator
            #text[OP_TUPLE]
          arguments
            expression-int
              #text[3]
            expression-int
              #text[4]

我希望这个输入不难理解。以下是不从XML文件解析时的正常情况：

a := 1;
b := 2;
c := {1,2};
d := {(1,2),(3,4)};

等等

所有赋值对（即一个值和一个变量）都将存储在hashmap中，以便该值可以由其变量查找并在以后的表达式中使用。我将使用递归下降求值器（我想是吧？）根据语法来解析表达式

在过去的24小时里，我已经在谷歌上搜索了各种各样的东西，看到了很多基本算法的树评估器（例如2+3*8等），但还没有看到这对我的特定树是如何起作用的

到目前为止，我编写的代码只找到变量名（a、b、c、d、e等），但我无法开始考虑如何对递归进行编码，从而为哈希映射提供正确的值

public void evaluate(Node node){
    HashMap<String, String> assignments = new HashMap<String, String>();
    NodeList assignment = node.getChildNodes();
    for (int i=0; i < assignment.getLength(); i++){ //1 to 13
        Node assign = assignment.item(i);
        Node variable = this.getChild(assign, 0);
        Node varValNode = this.getChild(variable, 0);
        String varVal = varValNode.getNodeValue();

        Node expression = this.getChild(assign, 1);

---

假设所有值都是整数类型，则应创建一个

HashMap

来存储变量值，并将其传递给

evaluate

方法：

public static void main(String[] args) {
    NodeList commandList = ... // get your XML from somewhere
    Map<string,Integer> vars = new HashMap<string,Integer>();
    for (Node node : commandList) {
        evaluate(node, vars);
    }
    // At this point, vars contains values of all variables assigned in commands
    // from the command list
}

publicstaticvoidmain（字符串[]args）{
NodeList commandList=…//从某处获取XML
Map vars=newhashmap（）；
用于（节点：commandList）{
评估（节点、变量）；
}
//此时，vars包含命令中指定的所有变量的值
//从命令列表中
}

评估应该变得相对简单：

private static Integer evaluate(Node node, Map<string,Integer> vars) {
    if (node is an assignment) {
        String varName = ... // get variable name from node
        Node expr = ... // get the node representing expression being assigned
        Integer value = evaluate(expr, vars);
        vars.put(varName, value);
        return value;
    }
    if (node is a variable reference) {
        String varName = ... // get variable name from node
        return vars.get(varName);
    }
    if (node is an integer constant) {
        String constVal = ... // Get the representation from XML
        return Integer.decode(constVal);
    }
    if (node is a binary expression) {
        Node lhs = ... // Get the left-hand side expression from the node
        Node rhs = ... // Get the right-hand side expression from the node
        Integer lhsVal = evaluate(lhs, vars); 
        Integer rhsVal = evaluate(rhs, vars);
        if (operator is plus) {
            return new Integer(((int)lhsVal) + ((int)rhsVal));
        }
        if (operator is minus) {
            return new Integer(((int)lhsVal) - ((int)rhsVal));
        }
        if (operator is multiply) {
            return new Integer(((int)lhsVal) * ((int)rhsVal));
        }
        if (operator is divide) {
            return new Integer(((int)lhsVal) / ((int)rhsVal));
        }
        // ... and so on
    }
    // ... and so on
}

私有静态整数求值（节点，映射变量）{
if（节点是一个赋值）{
字符串varName=…//从节点获取变量名
Node expr=…//获取表示要分配的表达式的节点
整数值=评估（expr，vars）；
vars.put（varName，value）；
返回值；
}
if（节点是变量引用）{
字符串varName=…//从节点获取变量名
返回vars.get（varName）；
}
if（节点为整数常量）{
String constVal=…//从XML获取表示形式
返回整数。解码（consval）；
}
if（节点是二进制表达式）{
Node lhs=…//从节点获取左侧表达式
Node rhs=…//从节点获取右侧表达式
整数lhsVal=evaluate（lhs，vars）；
整数rhsVal=评估（rhs，vars）；
如果（操作员为加号）{
返回新整数（（（int）lhsVal）+（（int）rhsVal））；
}
if（运算符为负）{
返回新整数（（（int）lhsVal）-（int）rhsVal））；
}
if（运算符为乘法）{
返回新整数（（（int）lhsVal）*（（int）rhsVal））；
}
if（运算符为divide）{
返回新整数（（（int）lhsVal）/（（int）rhsVal））；
}
//……等等
}
//……等等
}

我应该说，当涉及函数时，a、b、c和d后面的行确实会变得更复杂一些，如集合、元组等。不过，我会试试你给我的，它看起来是一个很好的布局！

private static Integer evaluate(Node node, Map<string,Integer> vars) {
    if (node is an assignment) {
        String varName = ... // get variable name from node
        Node expr = ... // get the node representing expression being assigned
        Integer value = evaluate(expr, vars);
        vars.put(varName, value);
        return value;
    }
    if (node is a variable reference) {
        String varName = ... // get variable name from node
        return vars.get(varName);
    }
    if (node is an integer constant) {
        String constVal = ... // Get the representation from XML
        return Integer.decode(constVal);
    }
    if (node is a binary expression) {
        Node lhs = ... // Get the left-hand side expression from the node
        Node rhs = ... // Get the right-hand side expression from the node
        Integer lhsVal = evaluate(lhs, vars); 
        Integer rhsVal = evaluate(rhs, vars);
        if (operator is plus) {
            return new Integer(((int)lhsVal) + ((int)rhsVal));
        }
        if (operator is minus) {
            return new Integer(((int)lhsVal) - ((int)rhsVal));
        }
        if (operator is multiply) {
            return new Integer(((int)lhsVal) * ((int)rhsVal));
        }
        if (operator is divide) {
            return new Integer(((int)lhsVal) / ((int)rhsVal));
        }
        // ... and so on
    }
    // ... and so on
}