python.jjt

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

void begin_for_else_stmt(): {}
{ <ELSE> {this.addSpecialToken("else",STRATEGY_BEFORE_NEXT);} {this.addSpecialToken(":",STRATEGY_BEFORE_NEXT);} <COLON>  
}
//try_stmt: ('try' ':' suite (except_clause ':' suite)+ #diagram:break
//           ['else' ':' suite] | 'try' ':' suite 'finally' ':' suite)
void try_stmt() #void: {SimpleNode tryNode;}
{ 
    begin_try_stmt() {tryNode = (SimpleNode)jjtree.peekNode();}  suite() (
    ((except_clause(tryNode))+ 
    
    [begin_try_else_stmt()  suite()])
        #try_stmt(jjtree.nodeArity()+1)
        
    | begin_finally_stmt() suite()
        #tryfinally_stmt(jjtree.nodeArity()+1))
}

//this is the 'try' ':'  it is needed because we need that scope closing for getting the specials.
void begin_try_stmt(): {}
{ <TRY> {this.addSpecialToken("try", STRATEGY_BEFORE_NEXT);} {this.addSpecialToken(":", STRATEGY_BEFORE_NEXT);} <COLON> 
}
void begin_try_else_stmt(): {}
{ <ELSE> {this.addSpecialToken("else", STRATEGY_BEFORE_NEXT);}{this.addSpecialToken(":", STRATEGY_BEFORE_NEXT);}<COLON>
}

void begin_finally_stmt(): {}
{ <FINALLY> {this.addSpecialToken("finally", STRATEGY_BEFORE_NEXT);} {this.addSpecialToken(":", STRATEGY_BEFORE_NEXT);} <COLON> 
}

//except_clause: 'except' [test [',' test]]
void except_clause(SimpleNode tryNode): {}
{ begin_except_clause() {this.addToPeek("except",false);} [test() [{this.addSpecialToken(",");} <COMMA> test()]] <COLON> { this.addSpecialToken(":");} suite() }

void begin_except_clause(): {}
{ <EXCEPT> }


//suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
void suite(): {}
{ simple_stmt() |  <NEWLINE>
                   { token_source.expect_indent = true; } <INDENT> { token_source.expect_indent = false; } (stmt())+ <DEDENT> }


//test: and_test ('or' and_test)* | lambdef
void test() #or_boolean(>1): {}
{ lambdef() | and_test() (<OR_BOOL> and_test())* }

//and_test: not_test ('and' not_test)*
void and_test() #and_boolean(>1): {}
{ not_test() (<AND_BOOL> not_test())* }

//not_test: 'not' not_test | comparison
void not_test() #void: {}
{ <NOT_BOOL> not_test() #not_1op(1) | comparison() }

//comparison: expr (comp_op expr)*
void comparison() #void: {}
{ (expr() (comp_op() expr())*) #comparision(>1) }


//comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
void comp_op() #void: {}
{
    <LESS> #less_cmp(0)
|   <GREATER> #greater_cmp(0)
|   <EQEQUAL> #equal_cmp(0)
|   <EQGREATER> #greater_equal_cmp(0)
|   <EQLESS> #less_equal_cmp(0)
|   <LESSGREATER> #notequal_cmp(0)
|   <NOTEQUAL> #notequal_cmp(0)
|   <IN> #in_cmp(0)
|   <NOT_BOOL> <IN> #not_in_cmp(0)
|   LOOKAHEAD(2) <IS> <NOT_BOOL> #is_not_cmp(0)
|   <IS> #is_cmp(0)
}

//expr: xor_expr ('|' xor_expr)*
void expr() #void : {}
{ xor_expr() (<OR> xor_expr() #or_2op(2))* }

//xor_expr: and_expr ('^' and_expr)*
void xor_expr() #void : {}
{ and_expr() (<XOR> and_expr() #xor_2op(2))* }

//and_expr: shift_expr ('&' shift_expr)*
void and_expr() #void : {}
{ shift_expr() (<AND> shift_expr() #and_2op(2))* }

//shift_expr: arith_expr (('<<'|'>>') arith_expr)*
void shift_expr() #void : {}
{
    arith_expr() (<LSHIFT> arith_expr() #lshift_2op(2)
|   <RSHIFT> arith_expr() #rshift_2op(2) )*
}

//arith_expr: term (('+'|'-') term)*
void arith_expr() #void : {}
{
    term() (<PLUS> term() #add_2op(2)
|   <MINUS> term() #sub_2op(2) )*
}

//term: factor (('*'|'/'|'%') factor)*
void term() #void : {}
{
    factor()  ( <MULTIPLY> factor() #mul_2op(2)
|   <DIVIDE> factor() #div_2op(2)
|   <FLOORDIVIDE> factor() #floordiv_2op(2)
|   <MODULO> factor() #mod_2op(2) )*
}

//factor: ('+'|'-'|'~') factor | power
void factor() #void: {}
{
    <PLUS> factor() #pos_1op(1)
|   <MINUS> factor() #neg_1op(1)
|   <NOT> factor() #invert_1op(1)
|   power()
} /*Modified, no recursion*/

//power: atom trailer* ('**' factor)*
void power() #void: {}
{ atomtrailer() (LOOKAHEAD(2) <POWER> factor() #pow_2op(2))* }

//trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
void atomtrailer() #void: {Object spStr;Object spStr2;}
{
atom() 
(
    LOOKAHEAD(2) (  
    {spStr  = createSpecialStr("(", false);} <LPAREN>  
    {spStr2 = createSpecialStr(")", false);} <RPAREN> 
    )#Call_Op(1) {addToPeekCallFunc(spStr, true); addToPeek(spStr2, true);}

|   LOOKAHEAD(2) (  
    {spStr  = createSpecialStr("(", false);} <LPAREN>  
    insidetuporcall() 
    {spStr2 = createSpecialStr(")", false);} <RPAREN> 
    ) #Call_Op(jjtree.nodeArity()+1) {addToPeekCallFunc(spStr, true); addToPeek(spStr2, true);}


|   {spStr = createSpecialStr("[", false);} <LBRACKET> 
    subscriptlist()
    {spStr2 = createSpecialStr("]", false);} <RBRACKET>  
    #Index_Op(2) {addToPeek(spStr, false); addToPeek(spStr2, true);}

|   <DOT> AnyName() #Dot_Op(2) 
)*
}


//atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
void atom() #void: {Object spStr;Object spStr2;}
{
    LOOKAHEAD(2) (  
      {spStr  = createSpecialStr("(", false);} <LPAREN>  
      {spStr2 = createSpecialStr(")", false);} <RPAREN> 
    ) #tuple {addToPeek(spStr, false); addToPeek(spStr2, true);}

|   LOOKAHEAD(2) (  
      {spStr  = createSpecialStr("(", false);} <LPAREN>  
      insidetuporcall() 
      {spStr2 = createSpecialStr(")", false);} <RPAREN> 
    ) #tuple {addToPeek(spStr, false); addToPeek(spStr2, true);}


|   ( <LPAREN>  {this.addSpecialToken("(",STRATEGY_BEFORE_NEXT);}   [SmartTestList()] <RPAREN>  {this.findTokenAndAdd(")");}  )

|   ( {spStr = createSpecialStr("[", false);} <LBRACKET> 
      [listmaker()] 
      {spStr2 = createSpecialStr("]", false);} <RBRACKET>  
    ) #list {addToPeek(spStr, false); addToPeek(spStr2, true);}
      
      
|   ( {spStr  = createSpecialStr("{", false);}<LBRACE> 
      [dictmaker()] 
      {spStr2  = createSpecialStr("}", false);} <RBRACE> 
    ) #dictionary {addToPeek(spStr, false); addToPeek(spStr2, true);}
    
|   "`" SmartTestList() "`" #str_1op(1)
|   Name() 
|   Number()
|   String() (String() #strjoin(2))*
}

//we can be inside a tuple or a call, and we may have list comprehension in it. (fabioz)
void insidetuporcall() #void: {}
{
    arglist() (list_for())*
}

//lambdef: 'lambda' [varargslist] ':' test
//we add the colon to the args if there is some argument... otherwise, we add it to the first token that appears on the test
void lambdef():{boolean hasArgs=false;}
{ <LAMBDA> [varargslist(){hasArgs=true;}] <COLON> {if(hasArgs)this.addSpecialToken(":");else this.addSpecialToken(":",STRATEGY_BEFORE_NEXT);} test() }

//subscriptlist: subscript (',' subscript)* [',']
void subscriptlist() #void: {}
{ (subscript() (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> subscript())* [Comma()]) #subscriptlist(>1) }

//subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
void subscript() #void: {}
{
    <DOT> <DOT> <DOT> #Ellipses
|   (test() (slice())?) #Slice
|   slice() #Slice(>0)
}

//sliceop: ':' [test]
void slice() #void: {}
{ Colon() [test()] (Colon() [test()])? }

void Colon(): {} {{this.addSpecialToken(createSpecialStr(":", false), STRATEGY_BEFORE_NEXT);} <COLON> }
void Comma(): {} {{this.addSpecialToken(",");} <COMMA>}

//exprlist: expr (',' expr)* [',']
void exprlist() #void: {}
{ (expr() (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> expr())* [Comma()]) #tuple(>1) }

//testlist: test (',' test)* [',']
void SmartTestList() #void: {}
{ (test() (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> test())* [Comma()]) #tuple(>1) }

//testlist: test (',' test)* [',']
void testlist() #void: {}
{ test() (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> test())* [{this.addSpecialToken(",");} <COMMA>]}

//dictmaker: test ':' test (',' test ':' test)* [',']
void dictmaker() #void: {}
{test() <COLON> {this.addSpecialToken(":");} test() (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> test() <COLON> {this.addSpecialToken(":");} test())* [{this.addSpecialToken(",");} <COMMA>]}

//listmaker: test ( list_for | (',' test)* [','] )
void listmaker() #void: {}
{ test() ( (list_for())+ | (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> test())* [Comma()] #tuple(>1)) }

void complistmaker() #void: {}
{ test() list_for()  
}

//list_iter: [list_for | list_if]
//void list_iter() #void: {}
//{ [ (list_for() | list_if()) ] }

//list_for: 'for' exprlist 'in' testlist list_iter
void list_for(): {}
{ <FOR> {this.addSpecialToken(" for ");} exprlist() <IN> {this.addSpecialToken(" in ");} SmartTestList() (<IF>  {this.addSpecialToken(" if ");} test())* }



//classdef: 'class' NAME ['(' testlist ')'] ':' suite
void classdef(): {}
{<CLASS> Name() [<LPAREN>  {this.addSpecialToken("(",STRATEGY_BEFORE_NEXT);}   testlist() <RPAREN>  {this.findTokenAndAdd(")");} ] <COLON> {this.addSpecialToken(":");} suite()}

//arglist: (argument ',')*
//              (argument [',']| '*' test [',' '**' test] | '**' test)
void arglist() #void: {}
{
    normalargs() [{this.addSpecialToken(",");} <COMMA>
    [LOOKAHEAD(2) ExtraArgValueList()
    [ {this.addSpecialToken(",");} <COMMA> ExtraKeywordValueList() ] | ExtraKeywordValueList()]]
|   [LOOKAHEAD(2) ExtraArgValueList()
    [ {this.addSpecialToken(",");} <COMMA> ExtraKeywordValueList() ] | ExtraKeywordValueList()]
}

void normalargs() #void: {}
{ argument() (LOOKAHEAD(2) {this.addSpecialToken(",");} <COMMA> argument())* }

void ExtraArgValueList(): {}
{ {this.addSpecialToken(createSpecialStr("*", false));} <MULTIPLY> test() }

void ExtraKeywordValueList(): {}
{ ({this.addSpecialToken(createSpecialStr("**", false));} <POWER>
  |{this.addSpecialToken(createSpecialStr("**", false));} <MULTIPLY> <MULTIPLY>)
  test() }


//argument: [test '='] test     # Really [keyword '='] test
void argument() #void: {}
{ ([LOOKAHEAD(2) AnyName() <EQUAL>{this.addSpecialToken("=");}] test()) #Keyword(>1) }


void Number() #Num :
{
    Token t;
}
{
    (
        t=<HEXNUMBER> {
            String s = t.image.substring(2, t.image.length());
            jjtThis.setImage(makeInt(s, 16, t.image));
        } {}
    )
|   (
        t=<OCTNUMBER> { jjtThis.setImage(makeInt(t.image, 8, t.image)); } {}
    )
|   (
        t=<DECNUMBER> { jjtThis.setImage(makeInt(t.image, 10, t.image)); } {}
    )
|   (
        t=<FLOAT> { jjtThis.setImage(makeFloat(t.image)); } {}
    )
|   (
        t=<COMPLEX> { jjtThis.setImage(makeComplex(t.image)); } {}
    )
}

void Complex(): {}
{ <FLOAT>   }

void Name() #Name:
{
    Token t;
}
{
    t = <NAME> { jjtThis.setImage(t.image); } {}
|   t = <AS> { jjtThis.setImage(t.image); } {}
}

void String() #void :
{
    Token t;
}
{
    ( t=<SINGLE_STRING> { jjtThis.setImage(makeString(t.image, 1)); } {} )#String
|   ( t=<SINGLE_STRING2> { jjtThis.setImage(makeString(t.image, 1)); } {} )#String
|   ( t=<TRIPLE_STRING> { jjtThis.setImage(makeString(t.image, 3)); } {} )#String
|   ( t=<TRIPLE_STRING2> { jjtThis.setImage(makeString(t.image, 3)); } {} )#String
|   ( t=<SINGLE_USTRING> { jjtThis.setImage(makeString(t.image, 1)); } {} )#Unicode
|   ( t=<SINGLE_USTRING2> { jjtThis.setImage(makeString(t.image, 1)); } {} )#Unicode
|   ( t=<TRIPLE_USTRING> { jjtThis.setImage(makeString(t.image, 3)); } {} )#Unicode
|   ( t=<TRIPLE_USTRING2> { jjtThis.setImage(makeString(t.image, 3)); } {} )#Unicode
}

Token AnyName() #void:
{
    Token t;
}
{
    ( t= <NAME> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <OR_BOOL> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <AND_BOOL> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <NOT_BOOL> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <IS> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <IN> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <LAMBDA> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <IF> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <ELSE> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <ELIF> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <WHILE> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <FOR> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <TRY> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <EXCEPT> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <DEF> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <CLASS> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <FINALLY> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <PRINT> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <PASS> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <BREAK> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <CONTINUE> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <RETURN> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <YIELD> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <IMPORT> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <FROM> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <DEL> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <RAISE> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <GLOBAL> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <EXEC> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <ASSERT> { jjtThis.setImage(t.image); return t; } {} )#Name
|   ( t = <AS> { jjtThis.setImage(t.image); return t; } {} )#Name
}