pythongrammar24.java

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

/* Generated By:JJTree&JavaCC: Do not edit this line. PythonGrammar24.java */
package org.python.pydev.parser.grammar24;
import org.python.pydev.parser.jython.ast.modType;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import org.python.pydev.parser.jython.ast.Call;
import org.python.pydev.parser.jython.ast.Str;
import org.python.pydev.parser.jython.ast.Import;
import org.python.pydev.parser.jython.ast.Num;
import org.python.pydev.parser.jython.ast.Yield;
import org.python.pydev.parser.jython.ast.Tuple;
import org.python.pydev.parser.jython.ast.ImportFrom;
import org.python.pydev.core.IPythonNature;
import org.python.pydev.parser.jython.IParserHost;
import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.Node;
import org.python.pydev.parser.jython.Token;
import org.python.pydev.parser.jython.ParseException;
import org.python.pydev.parser.jython.SpecialStr;
import org.python.pydev.parser.jython.TokenMgrError;
import org.python.pydev.parser.jython.CharStream;
import org.python.pydev.parser.IGrammar;

public class PythonGrammar24 implements/*@bgen(jjtree)*/ PythonGrammar24TreeConstants,IGrammar, PythonGrammar24Constants {/*@bgen(jjtree)*/
  protected JJTPythonGrammar24State jjtree = new JJTPythonGrammar24State();
    public IParserHost hostLiteralMkr;
    private SimpleNode prev;
    private static boolean DEBUG = false;
    private final static boolean DEFAULT_SEARCH_ON_LAST = false;

    void jjtreeOpenNodeScope(Node n) {
        if(DEBUG){
            System.out.println("opening scope:"+n);
        }
        Token t = getToken(1);
        jjtree.pushNodePos(t.beginLine, t.beginColumn);
    }

    void addToPeek(Object t, boolean after) {
        addToPeek(t, after, null);
    }

    void addToPeekCallFunc(Object t, boolean after) {
        Call n = (Call) jjtree.peekNode();
        n.func.addSpecial(t, after);
    }

    void addToPeek(Object t, boolean after, Class class_) {
        SimpleNode peeked = (SimpleNode) jjtree.peekNode();
        addToPeek(peeked, t, after, class_);
    }

    void addToPeek(SimpleNode peeked, Object t, boolean after, Class class_) {
        if (class_ != null) {
            // just check if it is the class we were expecting.
            if (peeked.getClass().equals(class_) == false) {
                throw new RuntimeException("Error, expecting another class.");
            }
        }
        t = convertStringToSpecialStr(t);
        peeked.addSpecial(t, after);
    }

    void jjtreeCloseNodeScope(Node n) {
        if (DEBUG) {
            System.out.println("closing scope:" + n);
        }
        SimpleNode peeked = jjtree.setNodePos();
        List specialTokens = token_source.specialTokens;
        boolean after = true;
        if (n instanceof SimpleNode) {
            if (specialTokens.size() > 0) {
                if (prev == null) {
                    // it was not previously set, let's get the current and add it before that token
                    after = false;
                    prev = peeked;
                }
                if (DEBUG) {
                    System.out.println("closing scope " + peeked.getClass());
                }

                for (Iterator iter = specialTokens.iterator(); iter.hasNext();) {
                    Object next = iter.next();
                    int strategy = STRATEGY_ADD_AFTER_PREV; // default strategy
                    if (next instanceof Object[]) {
                        strategy = (Integer) ((Object[]) next)[1];
                        next = ((Object[]) next)[0];
                    }

                    if (strategy == STRATEGY_BEFORE_NEXT) { // try to set 'before the next' and not after prev token
                        addToPeek(peeked, next, false, null);
                    } else {
                        // may still add before the next, if there was no prev (we can check that by the 'after' variable)
                        // in this case, we'll do some checks to see if it is really correct (checking for the line and column)

                        if (next instanceof Token) {
                            findTokenToAdd((Token) next).addSpecial(next, after);
                        } else {
                            prev.addSpecial(next, after);
                        }
                    }
                }
                specialTokens.clear();
            }
            prev = (SimpleNode) peeked;
        }
    }


    /**
     * Default: add after the previous found token
     */
    public static final int STRATEGY_ADD_AFTER_PREV = 0;

    /**
     * Add before the 'next token' strategy
     */
    public static final int STRATEGY_BEFORE_NEXT = 1;

    private SimpleNode findTokenToAdd(Token next) {
        SimpleNode curr = (SimpleNode) jjtree.peekNode();
        if(curr != prev){
            //let's see which one is better suited
            if(prev.beginLine == next.beginLine){
                return prev;
            }
            if(curr.beginLine == next.beginLine){
                return curr;
            }
            //if it was found later than both, let's get the current
            if(next.beginLine > prev.beginLine && next.beginLine > curr.beginLine){
                return curr;
            }

        }
        return prev;

    }

    private void addSpecialToken(Object o, int strategy) {
        o = convertStringToSpecialStr(o);
        token_source.specialTokens.add(new Object[]{o, strategy});
    }

        private Object convertStringToSpecialStr(Object o) {
                if (o instanceof String) {
                        try {
                                o = createSpecialStr((String) o);
                        } catch (ParseException e) {
                        }
                }
                return o;
        }

    private void addSpecialToken(Object o) {
        //the default is adding after the previous token
        token_source.specialTokens.add(new Object[]{o, STRATEGY_ADD_AFTER_PREV});
    }


    private boolean findTokenAndAdd(String token) throws ParseException {
        return findTokenAndAdd(token, token, DEFAULT_SEARCH_ON_LAST);
    }

    private Object createSpecialStr(String token) throws ParseException {
        return createSpecialStr(token, token);
    }
    private Object createSpecialStr(String token, boolean searchOnLast) throws ParseException {
        return createSpecialStr(token, token, searchOnLast);
    }

    private Object createSpecialStr(String token, String put) throws ParseException {
        return createSpecialStr(token, put, DEFAULT_SEARCH_ON_LAST);
    }
    private Object createSpecialStr(String token, String put, boolean searchOnLast) throws ParseException {
        Token t;
        if(searchOnLast){
                t = jj_lastpos;
        }else{
                t = this.token;
        }
        while(t != null && t.image != null && t.image.equals(token) == false){
                t = t.next;
        }
        if(t != null){
                return new SpecialStr(put,t.beginLine, t.beginColumn);
        }
        //return put;
        if(this.token != null){
            throw new ParseException("Expected:"+token, this.token);
        }else if(jj_lastpos != null){
            throw new ParseException("Expected:"+token, jj_lastpos);
        }else{
            throw new ParseException("Expected:"+token);
        }
    }

    /**
     * This is so that we add the String with the beginLine and beginColumn
     * @throws ParseException 
     */
    private boolean findTokenAndAdd(String token, String put, boolean searchOnLast) throws ParseException {
        Object s = createSpecialStr(token, put, searchOnLast);
        token_source.specialTokens.add(new Object[]{s, STRATEGY_ADD_AFTER_PREV});
        return s instanceof SpecialStr;
    }



    Object[] makeInt(String s, int radix, String token) {
        if (s.endsWith("L") || s.endsWith("l")) {
            s = s.substring(0, s.length()-1);
            return new Object[]{hostLiteralMkr.newLong(new java.math.BigInteger(s, radix)), Num.Long, token};
        }
        int ndigits = s.length();
        int i=0;
        while (i < ndigits && s.charAt(i) == '0')
            i++;
        if ((ndigits - i) > 11) {
            return new Object[]{hostLiteralMkr.newLong(new java.math.BigInteger(s, radix)), Num.Long, token};
        }

        long l = Long.valueOf(s, radix).longValue();
        if (l > 0xffffffffl || (radix == 10 && l > Integer.MAX_VALUE)) {
            return new Object[]{hostLiteralMkr.newLong(new java.math.BigInteger(s, radix)), Num.Long, token};
        }
        return new Object[]{hostLiteralMkr.newInteger((int) l), Num.Int, token};
    }

    Object[] makeFloat(String s) {
        return new Object[]{hostLiteralMkr.newFloat(Double.valueOf(s).doubleValue()), Num.Float, s};
    }

    Object[] makeLong(String s) {
        return new Object[]{hostLiteralMkr.newLong(s), Num.Long, s};
    }

    Object[] makeComplex(String s) {
        String compNumber = s.substring(0, s.length() - 1);
        return new Object[]{hostLiteralMkr.newImaginary(Double.valueOf(compNumber).doubleValue()), Num.Comp, s};
    }

    /**
     * Return a Tuple where:
     * 0 = the string
     * 1 = boolean indicating unicode
     * 2 = boolean indicating raw
     * 3 = style
     */
    Object[] makeString(String s, int quotes) {
        //System.out.println("enter: "+s);
        char quoteChar = s.charAt(0);
        int start=0;
        boolean ustring = false;
        if (quoteChar == 'u' || quoteChar == 'U') {
            ustring = true;
            start++;
        }
        quoteChar = s.charAt(start);
        if (quoteChar == 'r' || quoteChar == 'R') {
            //raw string (does not decode slashes)
            String str = s.substring(quotes+start+1, s.length()-quotes);
            //System.out.println("out: "+str);
            return new Object[]{str,ustring, true, getType(s.charAt(start+1), quotes)};

        } else {
            int n = s.length()-quotes;
            int i=quotes+start;

            String str = hostLiteralMkr.decode_UnicodeEscape(s, i, n, "strict", ustring);
            //System.out.println("out: "+str);
            return new Object[]{str, ustring, false, getType(s.charAt(start), quotes)};
        }
    }

    private int getType(char c, int quotes){
        if(quotes == 1){
            if (c == '\''){
                return Str.SingleSingle;
            }
            if(c == '"'){
                return Str.SingleDouble;
            }
        }
        if (c == '\''){
            return Str.TripleSingle;
        }
        if(c == '"'){
            return Str.TripleDouble;
        }
        throw new RuntimeException("Unable to determine type. Char: "+c+" quotes:"+quotes );
    }

    // ! maximal currently used LOOKAHEAD is 3
    private static final int MAX_LOOKAHEAD = 3;

    public boolean partial_valid_sentence(Throwable t) {
        if (t instanceof TokenMgrError) {
           // check whether EOF condition inside multi-line string,
           // or just after newline continuation inside a string (*NLC states)
           TokenMgrError e = (TokenMgrError)t;
           switch(e.lexState) {
           case IN_STRING1NLC:
           case IN_STRING2NLC:
           case IN_STRING13:
           case IN_STRING23:
           case IN_USTRING1NLC:
           case IN_USTRING2NLC:
           case IN_USTRING13:
           case IN_USTRING23:
               return e.EOFSeen;
           default:
               return false;
           }
        }
        if (!(t instanceof ParseException))
            return false;
        try {
            ParseException e = (ParseException)t;
            int tok = getNextToken().kind;
            if (tok == EOF) return true; // all tokens eaten

            // or check whether remaing tokens partially fullfill lookahead
            // expectations

            int[][] expected = e.expectedTokenSequences;

            if (expected == null) return false;

            int[] ahead = new int[MAX_LOOKAHEAD-1];

            int i = 0;
            for(;;) {
                ahead[i] = tok;
                i++;
                tok = getNextToken().kind;
                if (tok == EOF) break;
                if (i >= MAX_LOOKAHEAD-1) return false;
            }

            int nahead = i;

        next_expected:
            for(int j = 0; j<expected.length; j++) {
                int[] cand = expected[j];

                if (cand.length <= nahead ) continue next_expected;

                for(int k = 0; k < nahead; k++)
                    if (ahead[k] != cand[k])
                        continue next_expected;
                return true;
            }

            return false;
        } catch (TokenMgrError e1) {
            return false;
        }
    }

   // constructors taking a IParserHost impl

   public PythonGrammar24(CharStream stream,IParserHost host) {
       this(stream);
       hostLiteralMkr = host;
   }

   public PythonGrammar24(PythonGrammar24TokenManager tm,
                        IParserHost host)
   {
        this(tm);
        hostLiteralMkr = host;
   }

//single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
// apparently CPython coalesces newlines, we don't
  final public modType single_input() throws ParseException {
                         /*@bgen(jjtree) single_input */
    SimpleNode jjtn000 = jjtree.builder.openNode( JJTSINGLE_INPUT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtreeOpenNodeScope(jjtn000);token_source.single_input=true;
    try {
      label_1:
      while (true) {
        if (jj_2_1(2)) {
          ;
        } else {
          break label_1;
        }
        jj_consume_token(NEWLINE);
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case PLUS:
      case MINUS:
      case NOT:
      case NOT_BOOL:
      case LAMBDA:
      case IF:
      case WHILE:
      case FOR:
      case TRY:
      case DEF:
      case CLASS:
      case PRINT:
      case PASS:
      case BREAK:
      case CONTINUE:
      case RETURN:
      case YIELD:
      case IMPORT:
      case FROM:
      case DEL:
      case RAISE:
      case GLOBAL:
      case EXEC:
      case ASSERT:
      case AS:
      case AT:
      case NAME:
      case DECNUMBER:
      case HEXNUMBER:
      case OCTNUMBER:
      case FLOAT:
      case COMPLEX: