options {
	JDK_VERSION = "1.5";
	USER_CHAR_STREAM = true;
	STATIC = false;
	MULTI = true;
}

PARSER_BEGIN(FramclipseNonScriptParser)

package com.framsticks.framclipse.internal.parser;

import java.io.StringReader;

public class FramclipseNonScriptParser {

  private CharStreamWithOffset charStream = null;
  
  public java.util.Collection<Exception> exceptions = new java.util.ArrayList<Exception>();
  
  public FramclipseNonScriptParser(String input) 
  {
	this(new CharStreamWithOffset(new StringReader(input)));
  }
	
  private FramclipseNonScriptParser(CharStreamWithOffset charStream)
  {
	this((CharStream)charStream);
	this.charStream = charStream;
  }
  
  public static void main(String args[]) {
    String s = "expdef: \n name: urnohorl \n id: horla \n code:~ function kupa(a,b) { yeah \n } \n~\n\n\n";
    
    FramclipseNonScriptParser t = new FramclipseNonScriptParser(s);
    try {
      SimpleNode n = t.FramclipseFile();
      n.dump("");
      System.out.println("Thank you.");
    } catch (Exception e) {
      System.out.println("Oops.");
      System.out.println(e.getMessage());
      //e.printStackTrace();
    }
  }
}

PARSER_END(FramclipseNonScriptParser)

TOKEN_MGR_DECLS : {

    int blockNestingDepth ; 

}

<CodeSection, Block> SKIP :
{  
< "/*"(~["*"])* "*"(~["/"] (~["*"])* "*")* "/" >
| <"//"(~["\r","\n"])*["\r"]"\n">
}

<CodeSection, GlobalInclude> SKIP : /* WHITE SPACE */
{
  " "
| "\t"
| "\r"
| "\n"
| "\f"
} 

<DEFAULT,SingleSect, MultiSect> SKIP : /* WHITE SPACE */
{
  " "
| "\t"
} 

<DEFAULT> TOKEN : /* IDENTIFIERS */
{
  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|
  < #LETTER: ["_","a"-"z","A"-"Z"] >
|
  < #DIGIT: ["0"-"9"] >
}

<DEFAULT> TOKEN :
{
  < EOL: ("\r")?"\n" >
}

 

<DEFAULT> TOKEN : { <CODE_SECTION_START : "code:~" > : CodeSection }

<DEFAULT> TOKEN : { < MULTI_SECT_START : ":~" >  : MultiSect }

<DEFAULT> TOKEN : { <SINGLE_SECT_START : ":" > : SingleSect }

<DEFAULT> TOKEN : { <GLOBAL_INCLUDE_KWD : "#include" > : GlobalInclude }
 
<DEFAULT> SKIP :
{
 <"# "(~["\r","\n"])*["\r"]"\n">
}


<GlobalInclude> TOKEN : 
{
		< INCLUDE_STRING:
      "\""
      (   (~["\"","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\"","_"]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )*
      "\"" 
  > : DEFAULT
}

<MultiSect> TOKEN : { <
 MULTI_SECT_END : "~" (" ")* ("\r")?"\n" > : DEFAULT }

<MultiSect> TOKEN : 
{
  <MULTILINE_PROP_VALUE : (~["~"] | "\\~")* > 
}

<CodeSection> TOKEN : 
{
	< STRING_LITERAL:
      "\""
      (   (~["\"","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\"","_"]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )*
      "\""
  >
|
  < UNTERM_STRING_LITERAL:
      "\""
      (   (~["\"","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\"","_"]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )* ["\r"] "\n"
  >
  
} 

<CodeSection> TOKEN : { < CODE_SECTION_END : "~" (" ")* ("\r")?"\n" > : DEFAULT }

<CodeSection> TOKEN : 
{ 
  <GLOBAL_KWD : "global" >
  |
  <FUNCTION_KWD : "function" >
  |
  <INCLUDE_KWD : "@include" >  
  
 /*
  |
  <FOR_KWD : "for" >
  |
  <WHILE_KWD : "while" >
  |
  <VAR_KWD : "VAR" >
  |
  <TYPEOF_KWD : "typeof" >
  |
  <DO_KWD : "do" >
  |
  <BREAK_KWD : "break" >
  |
  <SWITCH_KWD : "switch" >
  |
  <CASE_KWD : "case" >
  |
  <GOTO_KWD : "goto" >
  |
  <DEFAULT_KWD : "default" >
  |
  <RETURN_KWD : "return" >
  |
  <ASM_KWD : "asm" >
  */
}

<CodeSection> TOKEN : /* SEPARATORS */
{
  < LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE : "{" > { blockNestingDepth = 1 ; } : Block  
| "}" 
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
}

<CodeSection> TOKEN : /* IDENTIFIERS */
{
  < IDENT: <LETTER> (<LETTER>|<DIGIT>)* >
}

<Block> TOKEN : 
{
	< NESTED_LBRACE : "{" > { blockNestingDepth += 1 ; }
	|
	< RBRACE : "}" > { 
    	blockNestingDepth --;
    	SwitchTo( blockNestingDepth==0 ? CodeSection : Block ) ; 
    }
}

<Block> SKIP : 
{
    <~[]> 
}

<SingleSect> TOKEN :
{
	< SINGLE_SECT_END : ("\r")?"\n" > : DEFAULT 
} 

<SingleSect> TOKEN : 
{
  < PROP_VALUE : (~["\r","\n"])* >
}

ASTFramclipseFile FramclipseFile() : {}
{
   /* FObject() (LOOKAHEAD ((<EOL>)+ FObject()) (<EOL>)+ FObject())* (<EOL>)* */  
  (((FObject()|GlobalInclude()) (<EOL>|<EOF>))|<EOL>)*  
  
  { return jjtThis; }
} 

void FObject() : { }
{
   {jjtThis.setBeginOffset(charStream.getBeginOffset());}
   
   <IDENTIFIER> {
    jjtThis.setClassName(token.image);
  }  
   <SINGLE_SECT_START> (<SINGLE_SECT_END>|<EOF>)
   
   	(Property() | CodeSection() )*
   
   { jjtThis.setEndOffset(charStream.getBeginOffset() - 1); }
}

void CodeSection() : {}
{
	{ jjtThis.setBeginOffset(charStream.getBeginOffset()); }
	<CODE_SECTION_START> (GlobalDecl() | Function() | IncludeStmt())* <CODE_SECTION_END>
	
	{ jjtThis.setEndOffset(charStream.getBeginOffset()); }
}

void Function() : {}
{
	
	try{
	<FUNCTION_KWD> { jjtThis.setBeginOffset(charStream.getBeginOffset()); } IdentList() 
	<LPAREN> [ IdentList() ] <RPAREN> <LBRACE> (CodeBlock())* <RBRACE>
	}
	catch(ParseException e)
	{
		token_source.SwitchTo(DEFAULT);
		//error_skipto(new int[] { EOF });
	} 
	
	{ jjtThis.setEndOffset(charStream.getBeginOffset()); }
}

void GlobalDecl() : {}
{
	{ jjtThis.setBeginOffset(charStream.getBeginOffset()); }
	<GLOBAL_KWD> IdentList() <SEMICOLON>
	{ jjtThis.setEndOffset(charStream.getBeginOffset()); }
}

void IncludeStmt() : {}
{
	{ jjtThis.setBeginOffset(charStream.getBeginOffset()); }
	<INCLUDE_KWD>  <STRING_LITERAL> { jjtThis.setFileName(token.image); }
	{ jjtThis.setEndOffset(charStream.getOffset()); } 
}

void GlobalInclude() : {}
{
	{ jjtThis.setBeginOffset(charStream.getBeginOffset()); }
	<GLOBAL_INCLUDE_KWD>  <INCLUDE_STRING> { jjtThis.setFileName(token.image); }
	{ jjtThis.setEndOffset(charStream.getOffset()); } 
}

void IdentList() : {}
{
	<IDENT> { jjtThis.addIdent(token.image); } (<COMMA> <IDENT> { jjtThis.addIdent(token.image); } )* 
}

void Property() : {}
{
	{ jjtThis.setBeginOffset(charStream.getBeginOffset()); }
	
  <IDENTIFIER> { jjtThis.setName(token.image); }
    
  ( SingleLinePropertyValue() { jjtThis.setEndOffset(charStream.getBeginOffset() - 1); } | MultiLinePropertyValue() { jjtThis.setEndOffset(charStream.getBeginOffset()); } )
  
}

void SingleLinePropertyValue()   : {}
{
	<SINGLE_SECT_START> <PROP_VALUE>{ jjtThis.setValue(token.image); } (<SINGLE_SECT_END>| <EOF>)
}

void CodeBlock() #void : {}
{
	<NESTED_LBRACE> (CodeBlock())* <RBRACE> 
}

void MultiLinePropertyValue()  : {}
{
	<MULTI_SECT_START> <MULTILINE_PROP_VALUE> <MULTI_SECT_END>
}

JAVACODE
void error_skipto(int[] kinds) #void {
  //ParseException e = generateParseException();  // generate the exception object.
  //System.out.println(e.toString());  // print the error message
  Token t;
  if(kinds.length > 0)
  {
    java.util.Arrays.sort(kinds);
    
  	do {
    	t = getNextToken();
  	} while (java.util.Arrays.binarySearch(kinds, t.kind) < 0);
   
  }
}