protected final void addSpecials(SimpleNode from, SimpleNode to) {
   if (from.specialsBefore != null && from.specialsBefore.size() > 0) {
     to.getSpecialsBefore().addAll(from.specialsBefore);
   }
   if (from.specialsAfter != null && from.specialsAfter.size() > 0) {
     to.getSpecialsAfter().addAll(from.specialsAfter);
   }
 }
Beispiel #2
0
  public final SimpleNode onCloseNode(SimpleNode n, int arity) throws Exception {
    exprType value;
    exprType[] exprs;
    Suite orelseSuite;
    stmtType[] body;
    Suite suite;

    int l;
    switch (n.getId()) {
      case JJTEXPR_STMT:
        value = (exprType) stack.popNode();
        if (arity > 1) {
          exprs = makeExprs(arity - 1);
          ctx.setStore(exprs);
          return new Assign(exprs, value);
        } else {
          return new Expr(value);
        }
      case JJTINDEX_OP:
        sliceType slice = (sliceType) stack.popNode();
        value = (exprType) stack.popNode();
        return new Subscript(value, slice, Subscript.Load);

      case JJTPRINT_STMT:
        boolean nl = true;
        if (stack.nodeArity() == 0) {
          Print p = new Print(null, null, true);
          return p;
        }

        if (stack.peekNode().getId() == JJTCOMMA) {
          stack.popNode();
          nl = false;
        }
        Print p = new Print(null, makeExprs(), nl);
        return p;
      case JJTPRINTEXT_STMT:
        nl = true;
        if (stack.peekNode().getId() == JJTCOMMA) {
          stack.popNode();
          nl = false;
        }
        exprs = makeExprs(stack.nodeArity() - 1);
        p = new Print(((exprType) stack.popNode()), exprs, nl);
        return p;
      case JJTBEGIN_FOR_ELSE_STMT:
        return new Suite(null);
      case JJTBEGIN_ELSE_STMT:
        return new Suite(null);
      case JJTBEGIN_WHILE_STMT:
        return new While(null, null, null);
      case JJTWHILE_STMT:
        orelseSuite = null;
        if (stack.nodeArity() == 5) {
          orelseSuite = popSuiteAndSuiteType();
        }

        body = popSuite();
        exprType test = (exprType) stack.popNode();
        While w = (While) stack.popNode();
        w.test = test;
        w.body = body;
        w.orelse = orelseSuite;
        return w;
      case JJTDECORATED:
        if (stack.nodeArity() != 2) {
          throw new RuntimeException("Expected 2 nodes at this context, found: " + arity);
        }
        SimpleNode def = stack.popNode();
        Decorators decorators = (Decorators) stack.popNode();
        if (def instanceof ClassDef) {
          ClassDef classDef = (ClassDef) def;
          classDef.decs = decorators.exp;
        } else {
          FunctionDef fDef = (FunctionDef) def;
          fDef.decs = decorators.exp;
        }
        return def;
      case JJTCALL_OP:
        exprType starargs = null;
        exprType kwargs = null;

        java.util.List<exprType> args = new ArrayList<exprType>();
        java.util.List<keywordType> keywords = new ArrayList<keywordType>();

        for (int i = arity - 2; i >= 0; i--) {
          SimpleNode node = stack.popNode();
          if (node instanceof keywordType) {
            keywords.add(0, (keywordType) node);

          } else if (node.getId() == JJTEXTRAARGVALUELIST) {
            ExtraArgValue nstarargs = (ExtraArgValue) node;
            starargs = nstarargs.value;
            this.addSpecialsAndClearOriginal(nstarargs, starargs);

          } else if (node.getId() == JJTEXTRAKEYWORDVALUELIST) {
            ExtraArgValue nkwargs = (ExtraArgValue) node;
            kwargs = nkwargs.value;
            this.addSpecialsAndClearOriginal(nkwargs, kwargs);

          } else if (node instanceof ComprehensionCollection) {
            // what can happen is something like print sum(x for x in y), where we have already
            // passed x in the args, and then get 'for x in y'
            args.add(
                0,
                new ListComp(
                    (exprType) stack.popNode(),
                    ((ComprehensionCollection) node).getGenerators(),
                    ListComp.EmptyCtx));
            i--; // popped node

          } else {
            args.add(0, (exprType) node);
          }
        }

        exprType func = (exprType) stack.popNode();
        Call c =
            new Call(
                func,
                args.toArray(new exprType[args.size()]),
                keywords.toArray(new keywordType[keywords.size()]),
                starargs,
                kwargs);
        addSpecialsAndClearOriginal(n, c);
        return c;
      case JJTFUNCDEF:
        suite = (Suite) stack.popNode();
        body = suite.body;

        argumentsType arguments = makeArguments(stack.nodeArity() - 1);
        NameTok nameTok = makeName(NameTok.FunctionName);
        // decorator is always null at this point... it's decorated later on
        FunctionDef funcDef = new FunctionDef(nameTok, arguments, body, null, null);
        addSpecialsAndClearOriginal(suite, funcDef);
        setParentForFuncOrClass(body, funcDef);
        return funcDef;
      case JJTDEFAULTARG:
        value = (arity == 1) ? null : ((exprType) stack.popNode());
        return new DefaultArg(((exprType) stack.popNode()), value, n.getId());
      case JJTEXTRAARGLIST:
        return new ExtraArg(makeName(NameTok.VarArg), JJTEXTRAARGLIST);
      case JJTEXTRAKEYWORDLIST:
        return new ExtraArg(makeName(NameTok.KwArg), JJTEXTRAKEYWORDLIST);
      case JJTCLASSDEF:
        suite = (Suite) stack.popNode();
        body = suite.body;
        exprType[] bases = makeExprs(stack.nodeArity() - 1);
        nameTok = makeName(NameTok.ClassName);
        ClassDef classDef = new ClassDef(nameTok, bases, body, null, null, null, null);
        addSpecialsAndClearOriginal(suite, classDef);
        setParentForFuncOrClass(body, classDef);
        return classDef;
      case JJTBEGIN_RETURN_STMT:
        return new Return(null);
      case JJTRETURN_STMT:
        value = arity == 2 ? ((exprType) stack.popNode()) : null;
        Return ret = (Return) stack.popNode();
        ret.value = value;
        return ret;
      case JJTYIELD_STMT:
        return stack.popNode();
      case JJTYIELD_EXPR:
        exprType yieldExpr = null;
        if (arity > 0) {
          // we may have an empty yield, so, we have to check it before
          yieldExpr = (exprType) stack.popNode();
        }
        return new Yield(yieldExpr, false);
      case JJTRAISE_STMT:
        exprType tback = arity >= 3 ? ((exprType) stack.popNode()) : null;
        exprType inst = arity >= 2 ? ((exprType) stack.popNode()) : null;
        exprType type = arity >= 1 ? ((exprType) stack.popNode()) : null;
        return new Raise(type, inst, tback, null);
      case JJTGLOBAL_STMT:
        Global global = new Global(makeIdentifiers(NameTok.GlobalName), null);
        return global;
      case JJTASSERT_STMT:
        exprType msg = arity == 2 ? ((exprType) stack.popNode()) : null;
        test = (exprType) stack.popNode();
        return new Assert(test, msg);
      case JJTBEGIN_TRY_STMT:
        // we do that just to get the specials
        return new TryExcept(null, null, null);
      case JJTTRYELSE_STMT:
        orelseSuite = popSuiteAndSuiteType();
        return orelseSuite;
      case JJTTRYFINALLY_OUTER_STMT:
        orelseSuite = popSuiteAndSuiteType();
        return new TryFinally(
            null,
            orelseSuite); // it does not have a body at this time... it will be filled with the
                          // inner try..except
      case JJTTRY_STMT:
        TryFinally outer = null;
        if (stack.peekNode() instanceof TryFinally) {
          outer = (TryFinally) stack.popNode();
          arity--;
        }
        orelseSuite = null;
        if (stack.peekNode() instanceof suiteType) {
          orelseSuite = (Suite) stack.popNode();
          arity--;
        }

        l = arity;
        excepthandlerType[] handlers = new excepthandlerType[l];
        for (int i = l - 1; i >= 0; i--) {
          handlers[i] = (excepthandlerType) stack.popNode();
        }
        suite = (Suite) stack.popNode();
        TryExcept tryExc = (TryExcept) stack.popNode();
        if (outer != null) {
          outer.beginLine = tryExc.beginLine;
        }
        tryExc.body = suite.body;
        tryExc.handlers = handlers;
        tryExc.orelse = orelseSuite;
        addSpecials(suite, tryExc);
        if (outer == null) {
          return tryExc;
        } else {
          if (outer.body != null) {
            throw new RuntimeException(
                "Error. Expecting null body to be filled on try..except..finally");
          }
          outer.body = new stmtType[] {tryExc};
          return outer;
        }
      case JJTBEGIN_TRY_ELSE_STMT:
        // we do that just to get the specials
        return new Suite(null);
      case JJTBEGIN_EXCEPT_CLAUSE:
        return new excepthandlerType(null, null, null);
      case JJTEXCEPT_CLAUSE:
        suite = (Suite) stack.popNode();
        body = suite.body;
        exprType excname = arity == 4 ? ((exprType) stack.popNode()) : null;
        if (excname != null) {
          ctx.setStore(excname);
        }
        type = arity >= 3 ? ((exprType) stack.popNode()) : null;
        excepthandlerType handler = (excepthandlerType) stack.popNode();
        handler.type = type;
        handler.name = excname;
        handler.body = body;
        addSpecials(suite, handler);
        return handler;
      case JJTBEGIN_FINALLY_STMT:
        // we do that just to get the specials
        return new Suite(null);
      case JJTTRYFINALLY_STMT:
        suiteType finalBody = popSuiteAndSuiteType();
        body = popSuite();
        // We have a try..except in the stack, but we will change it for a try..finally
        // This is because we recognize a try..except in the 'try:' token, but actually end up with
        // a try..finally
        TryExcept tryExcept = (TryExcept) stack.popNode();
        TryFinally tryFinally = new TryFinally(body, finalBody);
        tryFinally.beginLine = tryExcept.beginLine;
        tryFinally.beginColumn = tryExcept.beginColumn;
        addSpecialsAndClearOriginal(tryExcept, tryFinally);
        return tryFinally;

      case JJTWITH_STMT:
        return makeWithStmt(arity);
      case JJTWITH_ITEM:
        return makeWithItem(arity);
      case JJTEXTRAKEYWORDVALUELIST:
        return new ExtraArgValue(((exprType) stack.popNode()), JJTEXTRAKEYWORDVALUELIST);
      case JJTEXTRAARGVALUELIST:
        return new ExtraArgValue(((exprType) stack.popNode()), JJTEXTRAARGVALUELIST);
      case JJTKEYWORD:
        value = (exprType) stack.popNode();
        nameTok = makeName(NameTok.KeywordName);
        return new keywordType(nameTok, value, false);
      case JJTTUPLE:
        if (stack.nodeArity() > 0) {
          SimpleNode peeked = stack.peekNode();
          if (peeked instanceof ComprehensionCollection) {
            ComprehensionCollection col = (ComprehensionCollection) stack.popNode();
            return new ListComp(
                ((exprType) stack.popNode()), col.getGenerators(), ListComp.TupleCtx);
          }
        }
        return makeTuple(n);
      case JJTLIST:
        if (stack.nodeArity() > 0 && stack.peekNode() instanceof ComprehensionCollection) {
          ComprehensionCollection col = (ComprehensionCollection) stack.popNode();
          return new ListComp(((exprType) stack.popNode()), col.getGenerators(), ListComp.ListCtx);
        }
        return new List(makeExprs(), List.Load);
      case JJTSET:
        return new Set(null);
      case JJTDICTIONARY:
        return makeDictionaryOrSet(arity);
      case JJTSTR_1OP:
        return new Repr(((exprType) stack.popNode()));
      case JJTTEST:
        if (arity == 2) {
          IfExp node = (IfExp) stack.popNode();
          node.body = (exprType) stack.popNode();
          return node;
        } else {
          return stack.popNode();
        }
      case JJTIF_EXP:
        exprType ifExprOrelse = (exprType) stack.popNode();
        exprType ifExprTest = (exprType) stack.popNode();
        return new IfExp(ifExprTest, null, ifExprOrelse);
      case JJTOLD_LAMBDEF:
      case JJTLAMBDEF:
        test = (exprType) stack.popNode();
        arguments = makeArguments(arity - 1);
        Lambda lambda = new Lambda(arguments, test);
        //            if(arguments == null || arguments.args == null || arguments.args.length == 0){
        //                lambda.getSpecialsBefore().add("lambda");
        //            }else{
        //                lambda.getSpecialsBefore().add("lambda ");
        //            }
        return lambda;
      case JJTELLIPSIS:
        return new Ellipsis();
      case JJTSLICE:
        SimpleNode[] arr = new SimpleNode[arity];
        for (int i = arity - 1; i >= 0; i--) {
          arr[i] = stack.popNode();
        }

        exprType[] values = new exprType[3];
        int k = 0;
        java.util.List<Object> specialsBefore = new ArrayList<Object>();
        java.util.List<Object> specialsAfter = new ArrayList<Object>();
        for (int j = 0; j < arity; j++) {
          if (arr[j].getId() == JJTCOLON) {
            if (arr[j].specialsBefore != null) {
              specialsBefore.addAll(arr[j].specialsBefore);
              arr[j].specialsBefore
                  .clear(); // this nodes may be reused among parses, so, we have to erase the
                            // specials
            }
            if (arr[j].specialsAfter != null) {
              specialsAfter.addAll(arr[j].specialsAfter);
              arr[j].specialsAfter.clear();
            }
            k++;
          } else {
            values[k] = (exprType) arr[j];
            if (specialsBefore.size() > 0) {
              values[k].getSpecialsBefore().addAll(specialsBefore);
              specialsBefore.clear();
            }
            if (specialsAfter.size() > 0) {
              values[k].getSpecialsBefore().addAll(specialsAfter);
              specialsAfter.clear();
            }
          }
        }
        SimpleNode sliceRet;
        if (k == 0) {
          sliceRet = new Index(values[0]);
        } else {
          sliceRet = new Slice(values[0], values[1], values[2]);
        }
        // this may happen if we have no values
        sliceRet.getSpecialsBefore().addAll(specialsBefore);
        sliceRet.getSpecialsAfter().addAll(specialsAfter);
        specialsBefore.clear();
        specialsAfter.clear();
        return sliceRet;
      case JJTCOMP_FOR:
        return makeCompFor(arity);

      case JJTIMPORTFROM:
        return makeImportFrom25Onwards(arity);

      default:
        Log.log(("Error at TreeBuilder: default not treated:" + n.getId()));
        return null;
    }
  }