interpreter.java

A very smaller script interpretor that java based system. Can work on j2se / j2me / win C++ platform

        return instruct.charAt(i);
      }
    }
    return 0;
  }

  /**
   * 是符号
   *
   * @param ch String
   * @return boolean
   */
  private boolean isSymbol(char ch) {
    if (STR_SYMBOL.indexOf(ch) >= 0) {
      return true;
    }
    return false;
  }

  /**
   * 是数字
   * @param ch char
   * @return boolean
   */
  private boolean isNumeric(char ch) {
    if (STR_NUMERIC.indexOf(ch) >= 0) {
      return true;
    }
    return false;
  }

  /**
   * 是字母
   * @param ch char
   * @return boolean
   */
  private boolean isLetter(char ch) {
    if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') {
      return true;
    }
    return false;
  }

  /**
   * 解析指令
   *
   * @param s String
   * @return Vector
   * @throws Exception
   */

  private Vector parseInstruct(String s) {
    Vector stack = new Vector();

    int len = s.length();

    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < s.length(); i++) {
      char ch = s.charAt(i);
      if (ch == ' ') { //无用空格
        continue;
      }
      else
      if (ch == '\'') { //去掉注释
        break;
      }
      else
      if (ch == '"') { //是字符串
        sb.append(ch);
        i++;
        for (; i < s.length(); i++) { //找到全部串
          ch = s.charAt(i);
          sb.append(ch);
          if (ch == '"') {
            break;
          }
        }
      }
      else
      if (isSymbol(ch)) { //是其他运算符号
        sb.append(ch);
        if (ch == '>') { //可能的>=
          if (i + 1 < len) {
            if (s.charAt(i + 1) == '=') {
              sb.append(s.charAt(i + 1));
              i++;
            }
          }
        }
        else if (ch == '<') { //可能的<=,  <>
          if (i + 1 < len) {
            if (s.charAt(i + 1) == '=' || s.charAt(i + 1) == '>') {
              sb.append(s.charAt(i + 1));
              i++;
            }
          }
        }

      }
      else
      if (isLetter(ch)) { //字母开头号的是变量或过程调用，后面可能是( [
        for (; i < s.length(); i++) { //找到变量名
          ch = s.charAt(i);
          if (isSymbol(ch)) {
            break;
          }
          sb.append(ch);
        }
        //去掉空格
        for (; i < s.length(); i++) {
          if ( (ch = s.charAt(i)) != ' ') {
            break;
          }
        }
        //看单词后是什么符号

        if (ch == '[') { //是数组变量
          int leftQ = 0;
          do {
            if (ch == '[') {
              leftQ++;
            }
            if (ch == ']') {
              leftQ--;
            }
            sb.append(ch);
            i++;
          }
          while (i < s.length() && ("+-*/,)=:><".indexOf(ch = s.charAt(i)) < 0 || leftQ > 0)); //end while
        }
        else
        if (ch == '(') { //是过程调用
          int leftQ = 0;
          do {
            ch = s.charAt(i);
            if (ch == '(') {
              leftQ++;
            }
            if (ch == ')') {
              leftQ--;
            }
            sb.append(ch);
            i++;
          }
          while (leftQ > 0 && i < s.length()); //end while
        }

        i--;
      }
      else
      if (isNumeric(ch)) { //数字开头常数
        for (; i < s.length(); i++) { //找到变量名
          ch = s.charAt(i);
          if (isSymbol(ch)) {
            i--;
            break;
          }
          sb.append(ch);
        }
      }
      //添加项目到栈中
      vPushBack(stack, sb.toString());
      sb.setLength(0);
    }

    return stack;
  }

  /**
   * 输出
   *
   * @param ip int
   * @param s String
   */
  private void errout(int ip, String s) {
    System.out.println( (ip + 1) + " : " + s);
  }

  /**
   *
   * @param s String
   */
  private void print(String s) {
    System.out.println("DEBUG : " + s);
  }

  /**
   * 此对象是否是String
   * @param o Object
   * @return boolean
   */
  private boolean isStr(Object o) {
    if (o instanceof Str) {
      return true;
    }
    else {
      return false;
    }
  }

  /**
   * 此对象是否是Integer
   * @param o Object
   * @return boolean
   */
  private boolean isInt(Object o) {
    if (o instanceof Int) {
      return true;
    }
    else {
      return false;
    }
  }

  private boolean isArr(Object o) {
    if (o instanceof Array) {
      return true;
    }
    else {
      return false;
    }
  }

  private boolean isBool(Object o) {
    if (o instanceof Bool) {
      return true;
    }
    else {
      return false;
    }
  }

  private boolean isSymb(Object o) {
    if (o instanceof Symb) {
      return true;
    }
    else {
      return false;
    }
  }

  static public final Object vPopFront(Vector v) {
    if (v.size() <= 0) {
      return null;
    }
    Object o = v.firstElement();
    if (v.size() > 0) {
      v.removeElementAt(0);
    }
    return o;
  }

  static public final Object vPopBack(Vector v) {
    if (v.size() <= 0) {
      return null;
    }
    Object o = v.lastElement();
    if (v.size() > 0) {
      v.removeElementAt(v.size() - 1);
    }
    return o;
  }

  static public final void vPushFront(Vector v, Object o) {
    v.insertElementAt(o, 0);
  }

  static public final void vPushBack(Vector v, Object o) {
    v.addElement(o);
  }

  /**
   * 在变量列表v中查找变量
   *
   * @param name String
   * @param localVar Stack
   * @return Object
   */
  private Object _getVar(String name, Hashtable localVar) {
    name = name.toLowerCase();
    Object value = localVar.get(name);
    if (value == null) {
      value = golbleVar.get(name);
    }
    if (value != null) { //找到
      return value;
    }

    return null;
  }

  /**
   * 赋值操作
   *
   * @param instruct String
   * @param varList Stack
   * @throws Exception
   */
  private void _setVar(String instruct, Hashtable varList) throws Exception {
    //格式化表达式
    String exprStr = instruct.substring(instruct.indexOf('=') + 1);

    Vector expr = parseInstruct(instruct);
    String varName = (String) vPopFront(expr);
    varName = varName.toLowerCase();
    Object varValue = _getVar(varName, varList);

    String symb = (String) vPopFront(expr);
    if (symb.charAt(0) == '=') { //简单变量

      Object newVarValue = calcExpr(exprStr, varList); ; //弹出结果值
      if (newVarValue != null) { //新结果正确
        if (varValue == null) { //原有变量不存在
          varList.put(varName, newVarValue);
        }
        else {
          if (isStr(newVarValue) && isStr(varValue) //同类型
              || isInt(newVarValue) && isInt(varValue) //同类型
              ) {
            varList.put(varName, newVarValue);
          }
          else {
            throw new Exception(STRS_ERR[ERR_TYPE_INVALID]);
          }
        }
      }
    }

    else {
      throw new Exception(STRS_ERR[ERR_VAR]);
    }

  }

//---------------------------表达式求值------------------------------

  Object calcExpr(String exprStr, Hashtable varList) throws Exception {

    Vector expr = parseInstruct(exprStr); //分解表达式
    expr = preCalc(expr, varList); //求变量和过程调用的值

    //运算类型
    final int
        T_NUM = 1 //数值
        , T_STR = 2
        , T_LOG = 4 //布尔值
        , T_ARR = 8 //数组指针，非数组
        , T_LOGSYM = 16; //逻辑符号
    int cType = 0, cType1 = 0; //默认为算术运算

    for (int i = 0; i < expr.size(); i++) {
      Object o = expr.elementAt(i);
      //串类型
      if (isStr(o)) {
        cType |= T_STR;
      }
      else if (isSymb(o)) { //逻辑类型
        if ( ( (Symb) o).isLogicOp()) {
          cType |= T_LOGSYM;
        }
      }
      else if (isBool(o)) {
        cType |= T_LOG;
      }
      else if (isArr(o)) {
        cType |= T_ARR;
      }
      else if (isInt(o)) {
        cType |= T_NUM;
      }
    }

    //下面将判别是否运算正常
    if ( ( (cType & T_NUM) != 0) && ( (cType & T_STR) == 0) && ( (cType & T_ARR) == 0) && (cType & T_LOG) == 0 && (cType & T_LOGSYM) == 0) { //数值运算，只要有数值
      cType1 = T_NUM;
    }
    else if ( (cType & T_STR) != 0 && (cType & T_LOGSYM) == 0) { //字符串，除不许逻辑符号外都可
      cType1 = T_STR;
    }
    else if ( ( (cType & T_LOG) != 0 || (cType & T_LOGSYM) != 0) && (cType & T_STR) == 0 && (cType & T_ARR) == 0) { //逻辑运算，只要有逻辑符号或逻辑值均可，但需无串，无数组
      cType1 = T_LOG;
    }
    else if ( (cType & T_ARR) != 0 && (cType & T_STR) == 0 && (cType & T_NUM) == 0 && (cType & T_LOG) == 0 && (cType & T_LOGSYM) == 0) { //数组指针，其他均无
      cType1 = T_ARR;
    }
    else {
      //出错，需处理
      throw new Exception(STRS_ERR[ERR_ILLEGAL]);
    }

    Object resultDt = null;

    switch (cType1) {
      case T_NUM:

        //左递归运算
        while (expr.size() > 1) { //当只一个单元时停止
          calcExprNumImpl(expr);
        }
        resultDt = vPopBack(expr);
        break;
      case T_STR:
        calcExprStrImpl(expr);
        resultDt = vPopBack(expr);

        break;
      case T_LOG:
      //分解逻辑表达式与算术表达式，主要是把算术表达式先于逻辑运算求值
      {
        //下两个变量用于逻辑表达式求值过程
        Vector log_dElem = new Vector(); //逻辑
        Vector ari_dElem = new Vector(); //算术

        while (expr.size() > 0) {
          Object pdt = vPopFront(expr);

          ari_dElem.removeAllElements();
          if (isSymb(pdt)) {
            Symb pst = (Symb) pdt;
            if (pst.isCompOp()) { //以比较逻辑运算符进行拆分

              //把刚加入log_dElem中的算术部分拿出来，算出结果再放回去
              //从后向前找,如：3-(1+4)<>0  从<>处找到3-(1+4)
              int rightQ = 0; //右括号计数
              while (log_dElem.size() > 0) {
                Object pdt2 = vPopBack(log_dElem);
                if (isSymb(pdt2)) {

                  if ( ( (Symb) pdt2).getVal() == Symb.RP) {
                    rightQ++; //右括号+1

                  }
                  if ( ( (Symb) pdt2).isLogicOp() //如果遇另一个
                      || ( ( (Symb) pdt2).getVal() == Symb.LP && rightQ == 0) //当遇到左括号且括号计数为0时
                      ) {
                    vPushBack(log_dElem, pdt2); //放回去
                    break;
                  }
                  if ( ( (Symb) pdt2).getVal() == Symb.LP) {
                    rightQ--; //右括号-1
                  }
                }
                vPushFront(ari_dElem, pdt2);
              } //end while
              //运算出算术表达式
              while (ari_dElem.size() > 1) {
                calcExprNumImpl(ari_dElem);
                //放入逻辑表达式中
              }
              if (ari_dElem.size() > 0) {
                vPushBack(log_dElem, vPopFront(ari_dElem));
              }
            }
          } //end if是符号

          //插入表达式元素
          vPushBack(log_dElem, pdt);

          //再找比较逻辑运算符后面的元素
          ari_dElem.removeAllElements();
          if (isSymb(pdt)) {

            if ( ( (Symb) pdt).isCompOp()) { //以比较逻辑运算符进行拆分

              //把刚加入log_dElem中的算术部分拿出来，算出结果再放回去
              //从后向前找,如：3-(1+4)<>0  从<>处找到3-(1+4)
              int leftQ = 0; //左括号计数
              while (expr.size() > 0) {
                Object pdt2 = vPopFront(expr);
                if (isSymb(pdt2)) {

                  Symb pst2 = (Symb) pdt2;
                  byte opType = pst2.getVal();
                  if (opType == Symb.LP) {
                    leftQ++; //左括号+1

                  }
                  if (pst2.isLogicOp() //如果遇另一个
                      || (opType == Symb.RP && leftQ == 0) //当遇到左括号且括号计数为0时
                      ) {
                    vPushFront(expr, pdt2); //放回去
                    break;
                  }
                  if (opType == Symb.RP) {
                    leftQ--; //左括号-1
                  }
                }
                vPushBack(ari_dElem, pdt2);
              } //end while
              //运算出算术表达式
              while (ari_dElem.size() > 1) {
                calcExprNumImpl(ari_dElem);
                //放入逻辑表达式中
              }
              if (ari_dElem.size() > 0) {
                vPushBack(log_dElem, vPopFront(ari_dElem));
              }
            }
          } //end if是符号
        } //end while

        //逻辑表达式求值
        while (log_dElem.size() > 1) {
          calcExprLgcImpl(log_dElem);
        }
        resultDt = vPopBack(log_dElem);

      }
      break;
      case T_ARR:
        resultDt = vPopBack(expr);

        break;
      default: