treebuilder24.java

Python Development Environment (Python IDE plugin for Eclipse). Features editor, code completion, re

            return new ExtraArgValue(((exprType) stack.popNode()), JJTEXTRAARGVALUELIST);
        case JJTKEYWORD:
            value = (exprType) stack.popNode();
            nameTok = makeName(NameTok.KeywordName);
            return new keywordType(nameTok, value);
        case JJTTUPLE:
            if (stack.nodeArity() > 0 && stack.peekNode() instanceof comprehensionType) {
                comprehensionType[] generators = new comprehensionType[arity-1];
                for (int i = arity-2; i >= 0; i--) {
                    generators[i] = (comprehensionType) stack.popNode();
                }
                return new ListComp(((exprType) stack.popNode()), generators);
            }
            try {
                exprType[] exp = makeExprs();
                Tuple t = new Tuple(exp, Tuple.Load);
                addSpecialsAndClearOriginal(n, t);
                return t;
            } catch (ClassCastException e) {
                if(e.getMessage().equals(ExtraArgValue.class.getName())){
                    throw new ParseException("Token: '*' is not expected inside tuples.", lastPop);
                }
                throw new ParseException("Syntax error while detecting tuple.", lastPop);
            }
        case JJTLIST:
            if (stack.nodeArity() > 0 && stack.peekNode() instanceof comprehensionType) {
                comprehensionType[] generators = new comprehensionType[arity-1];
                for (int i = arity-2; i >= 0; i--) {
                    generators[i] = (comprehensionType) stack.popNode();
                }
                return new ListComp(((exprType) stack.popNode()), generators);
            }
            return new List(makeExprs(), List.Load);
        case JJTDICTIONARY:
            l = arity / 2;
            exprType[] keys = new exprType[l];
            exprType[] vals = new exprType[l];
            for (int i = l - 1; i >= 0; i--) {
                vals[i] = (exprType) stack.popNode();
                keys[i] = (exprType) stack.popNode();
            }
            return new Dict(keys, vals);
        case JJTSTR_1OP:
            return new Repr(((exprType) stack.popNode()));
        case JJTSTRJOIN:
            Str str2 = (Str) stack.popNode();
            Object o = stack.popNode();
            if(o instanceof Str){
                Str str1 = (Str) o;
                return new StrJoin(new exprType[]{str1, str2});
            }else{
                StrJoin strJ = (StrJoin) o;
                exprType[] newStrs = new exprType[strJ.strs.length +1];
                System.arraycopy(strJ.strs, 0, newStrs, 0, strJ.strs.length);
                newStrs[strJ.strs.length] = str2;
                strJ.strs = newStrs;
                return strJ;
            }
        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 JJTELLIPSES:
            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 JJTSUBSCRIPTLIST:
            sliceType[] dims = new sliceType[arity];
            for (int i = arity - 1; i >= 0; i--) {
                SimpleNode sliceNode = stack.popNode();
                if(sliceNode instanceof sliceType){
                    dims[i] = (sliceType) sliceNode;
                    
                }else if(sliceNode instanceof IdentityNode){
                    //this should be ignored...
                    //this happens when parsing something like a[1,], whereas a[1,2] would not have this.
                    
                }else{
                    throw new RuntimeException("Expected a sliceType or an IdentityNode. Received :"+sliceNode.getClass());
                }
            }
            return new ExtSlice(dims);
        case JJTAUG_PLUS:     
            return makeAugAssign(AugAssign.Add);
        case JJTAUG_MINUS:   
            return makeAugAssign(AugAssign.Sub);
        case JJTAUG_MULTIPLY:  
            return makeAugAssign(AugAssign.Mult);
        case JJTAUG_DIVIDE:   
            return makeAugAssign(AugAssign.Div);
        case JJTAUG_MODULO:  
            return makeAugAssign(AugAssign.Mod);
        case JJTAUG_AND:    
            return makeAugAssign(AugAssign.BitAnd);
        case JJTAUG_OR:    
            return makeAugAssign(AugAssign.BitOr);
        case JJTAUG_XOR:  
            return makeAugAssign(AugAssign.BitXor);
        case JJTAUG_LSHIFT:   
            return makeAugAssign(AugAssign.LShift);
        case JJTAUG_RSHIFT:  
            return makeAugAssign(AugAssign.RShift);
        case JJTAUG_POWER:  
            return makeAugAssign(AugAssign.Pow);
        case JJTAUG_FLOORDIVIDE:  
            return makeAugAssign(AugAssign.FloorDiv);
        case JJTLIST_FOR:
            exprType[] ifs = new exprType[arity-2];
            for (int i = arity-3; i >= 0; i--) {
                ifs[i] = (exprType) stack.popNode();
            }
            iter = (exprType) stack.popNode();
            target = (exprType) stack.popNode();
            ctx.setStore(target);
            return new Comprehension(target, iter, ifs);
        case JJTIMPORTFROM:
            aliasType[] aliases = makeAliases(arity - 1);
            return new ImportFrom(makeName(NameTok.ImportModule), aliases, 0); //relative import is always level 0 here (only actually added on version 25)
        case JJTIMPORT:
            return new Import(makeAliases());
    
        case JJTDOTTED_NAME:
            name = new Name(null, Name.Load);
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < arity; i++) {
                if (i > 0){
                    sb.insert(0, '.');
                }
                Name name0 = (Name) stack.popNode();
                sb.insert(0, name0.id);
                addSpecials(name0, name);
                //we have to set that, because if we later add things to the previous Name, we will now want it to be added to
                //the new name (comments will only appear later and may be added to the previous name -- so, we replace the previous
                //name specials list).
                name0.specialsBefore = name.getSpecialsBefore();
                name0.specialsAfter = name.getSpecialsAfter();
            }
            name.id = sb.toString();
            return name;

        case JJTDOTTED_AS_NAME:
            NameTok asname = null;
            if (arity > 1){
                asname = makeName(NameTok.ImportName);
            }
            return new aliasType(makeName(NameTok.ImportName), asname);

        case JJTIMPORT_AS_NAME:
            asname = null;
            if (arity > 1){
                asname = makeName(NameTok.ImportName);
            }
            return new aliasType(makeName(NameTok.ImportName), asname);
        case JJTCOMMA:
        case JJTCOLON:
            return n;
        default:
            System.out.println("Error at TreeBuilder: default not treated:"+n.getId());
            return null;
        }
    }

	private void setParentForFuncOrClass(stmtType[] body, SimpleNode classDef) {
		for(stmtType b:body){
			if(b instanceof ClassDef || b instanceof FunctionDef){
				b.parent = classDef;
			}
		}
	}

    private suiteType popSuiteAndSuiteType() {
        Suite s = (Suite) stack.popNode();
        suiteType orelseSuite = (suiteType) stack.popNode();
        orelseSuite.body = s.body;
        addSpecialsAndClearOriginal(s, orelseSuite);
        return orelseSuite;
    }

    private void addSpecialsAndClearOriginal(SimpleNode from, SimpleNode to) {
        addSpecials(from, to);
        if(from.specialsBefore != null){
            from.specialsBefore.clear();
        }
        if(from.specialsAfter != null){
            from.specialsAfter.clear();
        }
    }

    private 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);
        }
    }
    
    private void addSpecialsBefore(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.getSpecialsBefore().addAll(from.specialsAfter);
        }
    }

    /**
     * @param suite
     * @return
     */
    private stmtType[] getBodyAndSpecials() {
        Suite suite = (Suite)stack.popNode();
        stmtType[] body;
        body = suite.body;
        if(suite.specialsBefore != null && suite.specialsBefore.size() > 0){
            body[0].getSpecialsBefore().addAll(suite.specialsBefore);
        }
        
        if(suite.specialsAfter != null && suite.specialsAfter.size() > 0){
            body[body.length-1].getSpecialsAfter().addAll(suite.specialsAfter);
        }
        return body;
    }

    
    SimpleNode makeDecorator(java.util.List<SimpleNode> nodes){
        exprType starargs = null;
        exprType kwargs = null;

        exprType func = null;
        ArrayList<SimpleNode> keywordsl = new ArrayList<SimpleNode>();
        ArrayList<SimpleNode> argsl = new ArrayList<SimpleNode>();
        for (Iterator<SimpleNode> iter = nodes.iterator(); iter.hasNext();) {
            SimpleNode node = iter.next();
            
        
            if (node.getId() == JJTEXTRAKEYWORDVALUELIST) {
                final ExtraArgValue extraArg = (ExtraArgValue) node;
                kwargs = (extraArg).value;
                this.addSpecialsAndClearOriginal(extraArg, kwargs);
                extraArg.specialsBefore = kwargs.getSpecialsBefore();
                extraArg.specialsAfter = kwargs.getSpecialsAfter();
                
            } else if (node.getId() == JJTEXTRAARGVALUELIST) {
                final ExtraArgValue extraArg = (ExtraArgValue) node;
                starargs = extraArg.value;