xmlschema.jjt

/* -*-Java-*- */

/* 
 * Copyright (C) 2007,2008,2009  Anders Nilsson <anders.nilsson@cs.lth.se>
 *
 * This file is part of XMLSchemaCompiler.
 *
 * XMLSchemaCompiler is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * XMLSchemaCompiler is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with XMLSchemaCompiler.  If not, see <http://www.gnu.org/licenses/>.
*/

options {
    MULTI                       = true;
    VISITOR                     = true;
    NODE_DEFAULT_VOID           = true;
    NODE_SCOPE_HOOK             = false;
    NODE_PREFIX                 = "";
    JAVA_UNICODE_ESCAPE         = true;
    STATIC                      = false;
//    	DEBUG_PARSER                = true;
//    	DEBUG_TOKEN_MANAGER         = true;
//   	DEBUG_LOOKAHEAD             = true;
} // options


PARSER_BEGIN(SchemaParser)
package AST;
public class SchemaParser {
}
PARSER_END(SchemaParser)


//--------------------------------------------------------------------//
//                           LEXICAL TOKENS                           //
//--------------------------------------------------------------------//

// <DEFAULT, BOUNDS> SKIP : /* WHITE SPACE */
SPECIAL_TOKEN : /* WHITE SPACE */
{
    " "
    |
    "\t"
    |
    "\n"
    |
    "\r"
    |
    "\f"
}// WHITE SPACE


// <DEFAULT,BOUNDS> SPECIAL_TOKEN : /* COMMENTS */
// {
//     <SLASH_SLASH_COMMENT :  "//" (~["\n","\r"])* >
// }

SPECIAL_TOKEN : /* COMMENTS */
{
//     <SLASH_STAR_COMMENT  :  "/*" (~["*"])* "*" ("*" | (~["*","/"] (~["*"])* "*"))* "/"  >
< "<!--" ( ~["-"] | ( "-" ~["-"] ) )* "-->">
// 	| < "<rdfs:comment" ( ~["<"] | ( "<" ~["/"] ) )* "</rdfs:comment>" >
//     <XML_COMMENT  :  "<!--" (~["-","-",">"])* "-->"  >
}// COMMENTS


// <BOUNDS> TOKEN: {
//     < BEGINCOMMENT : "<!--"     >
//   | < ENDCOMMENT   : "-->"     >
// }

<DEFAULT, BOUNDS> TOKEN : /* RESERVED WORDS AND LITERALS */
{
    < XS_ANNOTATION            : "xs:annotation" >
  | < XS_ANY                   : "xs:any" >
  | < XS_ANYATTRIBUTE          : "xs:anyAttribute" >
  | < XS_APPINFO               : "xs:appinfo" >
  | < XS_ATTRIBUTE             : "xs:attribute" >
  | < XS_ATTRIBUTEGROUP        : "xs:attributeGroup" >
  | < XS_CHOICE                : "xs:choice" >
  | < XS_COMPLEXCONTENT        : "xs:complexContent" >
  | < XS_COMPLEXTYPE           : "xs:complexType" >
  | < XS_DOCUMENTATION         : "xs:documentation" >
  | < XS_ELEMENT               : "xs:element" >
  | < XS_ENUMERATION           : "xs:enumeration" >
  | < XS_EXTENSION             : "xs:extension" >
  | < XS_GROUP                 : "xs:group" >
  | < XS_INCLUDE               : "xs:include" >
  | < XS_LIST                  : "xs:list" >
  | < XS_MAXINCLUSIVE          : "xs:maxInclusive" >
  | < XS_MININCLUSIVE          : "xs:minInclusive" >
  | < XS_MINEXCLUSIVE          : "xs:minExclusive" >
  | < XS_MINLENGTH             : "xs:minLength" >
  | < XS_PATTERN               : "xs:pattern" >
  | < XS_RESTRICTION           : "xs:restriction" >
  | < XS_SEQUENCE              : "xs:sequence" >
  | < XS_SCHEMA                : "xs:schema" >
  | < XS_SIMPLECONTENT         : "xs:simpleContent" >
  | < XS_SIMPLETYPE            : "xs:simpleType" >
  | < XS_WHITESPACE            : "xs:whiteSpace" >
  | < ABSTRACT                 : "abstract" >
  | < ATTRIBUTEFORMDEFAULT     : "attributeFormDefault" >
  | < BASE                     : "base" >
  | < DEFAULT_ATTR             : "default" >
  | < ELEMENTFORMDEFAULT       : "elementFormDefault" >
  | < ENCODING                 : "encoding" >
  | < FIXED                    : "fixed" >
  | < ITEMTYPE                 : "itemType" >
  | < MINOCCURS                : "minOccurs" >
  | < MAXOCCURS                : "maxOccurs" >
  | < MIXED                    : "mixed" >
  | < NAME                     : "name" >
  | < NAMESPACE                : "namespace" >
  | < PROCESSCONTENTS          : "processContents" >
  | < REF                      : "ref" >
  | < SCHEMALOCATION           : "schemaLocation" >
  | < SOURCE                   : "source" >
  | < TARGETNAMESPACE          : "targetNamespace" >
  | < TYPE                     : "type" >
  | < USE                      : "use" >
  | < VALUE                    : "value" >
  | < VERSION                  : "version" >
  | < XML                      : "xml"          >
  | < XMLNS_XS                 : "xmlns:xs" >
  | < XMLNS_SCXML              : "xmlns:scxml" >

}// RESERVED WORDS AND LITERALS
<DEFAULT, BOUNDS> TOKEN : /* LITERALS */
{
    < INTEGER_LITERAL:
        <DECIMAL_LITERAL> (["l","L"])?
        |
        <HEX_LITERAL> (["l","L"])?
        |
        <OCTAL_LITERAL> (["l","L"])?
    >
    |
    < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >
    |
    < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >
    |
    < #OCTAL_LITERAL: "0" (["0"-"7"])* >
    |
    < FLOAT_LITERAL:
        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)? (["f","F","d","D"])?
        |
        "." (["0"-"9"])+ (<EXPONENT>)? (["f","F","d","D"])?
        |
        (["0"-"9"])+ <EXPONENT> (["f","F","d","D"])?
        |
        (["0"-"9"])+ (<EXPONENT>)? ["f","F","d","D"]
    >
    |
    < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
//     |
//     < CHARACTER_LITERAL:
//         "'"
//         (   (~["'","\\","\n","\r"])
//             |
//             ("\\"
//                 (   ["n","t","b","r","f","\\","'","\""]
//                     |
//                     ["0"-"7"] ( ["0"-"7"] )?
//                     |
//                     ["0"-"3"] ["0"-"7"] ["0"-"7"]
//                 )
//             )
//         )
//         "'"
//     >
    |
    < STRING_LITERAL:
        "\""
        (   (~["\""])
        )*
        "\""
		|
        "\'"
        (   (~["\'","\n","\r"])
        )*
        "\'"
    >
//     < STRING_LITERAL:
//         "\""
//         (   (~["\"","\\","\n","\r"])
//             |
//             ("\\"
//                 (    ["n","t","b","r","f","\\","'","\""]
//                      |
//                      ["0"-"7"] ( ["0"-"7"] )?
//                      |
//                      ["0"-"3"] ["0"-"7"] ["0"-"7"]
//                 )
//             )
//         )*
//         "\""
//     >
}// LITERALS

<DEFAULT, BOUNDS> TOKEN : /* IDENTIFIERS */
{
    < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>|"-")* >
    |
    < #LETTER:
        [
        "\u0024",
        "\u0041"-"\u005a",
        "\u005f",
        "\u0061"-"\u007a",
        "\u00c0"-"\u00d6",
		"\u00d7",
        "\u00d8"-"\u00f6",
        "\u00f8"-"\u00ff",
        "\u0100"-"\u1fff",
        "\u3040"-"\u318f",
        "\u3300"-"\u337f",
        "\u3400"-"\u3d2d",
        "\u4e00"-"\u9fff",
        "\uf900"-"\ufaff"
        ]
    >
    |
    < #DIGIT:
        [
        "\u0030"-"\u0039",
        "\u0660"-"\u0669",
        "\u06f0"-"\u06f9",
        "\u0966"-"\u096f",
        "\u09e6"-"\u09ef",
        "\u0a66"-"\u0a6f",
        "\u0ae6"-"\u0aef",
        "\u0b66"-"\u0b6f",
        "\u0be7"-"\u0bef",
        "\u0c66"-"\u0c6f",
        "\u0ce6"-"\u0cef",
        "\u0d66"-"\u0d6f",
        "\u0e50"-"\u0e59",
        "\u0ed0"-"\u0ed9",
        "\u1040"-"\u1049"
        ]
    >
}// IDENTIFIERS

<DEFAULT,BOUNDS> TOKEN : /* SEPARATORS */
{
      < LPAREN               : "("    >
    | < RPAREN               : ")"    >
     | < CDATA_START         : "<![CDATA["    >
     | < CDATA_END           : "]]>"    >
    | < LBRACE               : "{"    >
    | < RBRACE               : "}"    >
    | < LBRACKET             : "["    >
    | < RBRACKET             : "]"    >
    | < SEMICOLON            : ";"    >
    | < COMMA                : ","    >
    | < DOT                  : "."    >
    | < SQUOTE               : "'"    >
         | < AT                   : "@"  >
}// SEPARATORS


<DEFAULT,BOUNDS> TOKEN : /* OPERATORS */
{
      < ASSIGN               : "="    >
     | < GT                  : ">"    >
     | < END_TAG             : "</"    >
     | < LT                   : "<"    >
//     | < BANG                 : "!"    >
//     | < TILDE                : "~"    >
//     | < HOOK                 : "?"    >
     | < COLON                : ":"    >
     | < HASH                 : "#"    >
//     | < EQ                   : "=="   >
//     | < LE                   : "<="   >
//     | < GE                   : ">="   >
//     | < NE                   : "!="   >
//     | < SC_OR                : "||"   >
//     | < SC_AND               : "&&"   >
//     | < INCR                 : "++"   >
//     | < DECR                 : "--"   >
     | < PLUS                 : "+"    >
     | < MINUS                : "-"    >
     | < STAR                 : "*"    >
     | < SLASH                : "/"    >
     | < BACKSLASH            : "\\"    >
//     | < BIT_AND              : "&"    >
     | < VBAR                 : "|"    >
//     | < XOR                  : "^"    >
//     | < REM                  : "%"    >
//     | < LSHIFT               : "<<"   >
//     | < RSIGNEDSHIFT         : ">>"   >
//     | < RUNSIGNEDSHIFT       : ">>>"  >
//     | < PLUSASSIGN           : "+="   >
//     | < MINUSASSIGN          : "-="   >
//     | < STARASSIGN           : "*="   >
//     | < SLASHASSIGN          : "/="   >
//     | < ANDASSIGN            : "&="   >
//     | < ORASSIGN             : "|="   >
//     | < XORASSIGN            : "^="   >
//     | < REMASSIGN            : "%="   >
//     | < LSHIFTASSIGN         : "<<="  >
//     | < RSIGNEDSHIFTASSIGN   : ">>="  >
//     | < RUNSIGNEDSHIFTASSIGN : ">>>=" >
}// OPERATORS


// <DEFAULT,BOUNDS> TOKEN : /* TEXT */
// {
//     < TEXT : <LETTER> (~["<",">"])*    >
// }// TEXT


//--------------------------------------------------------------------//
//                      THE XMLSCHEMA GRAMMAR                         //
//--------------------------------------------------------------------//

Start Start() #Start : {}
{
    Specification()
  { return jjtThis; }
}

void Specification() #Specification : {}
{
    XmlHeader()
 	XsSchema()
}

void XmlHeader() #XmlHeader : {}
{
    "<?" <XML> AttributeList() "?>"
}

void XsSchema() #XsSchema : {}
{
    "<"  <XS_SCHEMA> AttributeList() ">"
	ElementList()
    "</" <XS_SCHEMA> ">"
}

void ElementList() #List : {}
{
    (Element())*    
}

void Element() : {}
{
    ( "<" (XsAnnotation()
	| XsAny()
	| XsAnyAttribute()
	| XsAppinfo()
	| XsAttribute()
	| XsAttributeGroup()
	| XsChoice()
	| XsComplexContent()
	| XsComplexType()
        | XsDocumentation()
        | XsElement()
        | XsEnumeration()
        | XsExtension()
        | XsGroup()
        | XsInclude()
        | XsList()
        | XsMaxInclusive()
        | XsMinInclusive()
        | XsMinExclusive()
        | XsMinLength()
        | XsPattern()
        | XsRestriction()
        | XsSequence()
        | XsSimpleContent()
        | XsSimpleType()
        | XsWhiteSpace()
    ))
	| SimpleElement()
}

void XsAnnotation() #XsAnnotation : {}
{
    <XS_ANNOTATION> AttributeList() 
		 (">" ElementList() "</" <XS_ANNOTATION> ">" | ElementList() "/>")
}

void XsAny() #XsAny : {}
{
    <XS_ANY> AttributeList() 
		 (">" ElementList() "</" <XS_ANY> ">" | ElementList() "/>")
}

void XsAnyAttribute() #XsAnyAttribute : {}
{
    <XS_ANYATTRIBUTE> AttributeList() 
		 (">" ElementList() "</" <XS_ANYATTRIBUTE> ">" | ElementList() "/>")
}

void XsAppinfo() #XsAppinfo : {}
{
    <XS_APPINFO> AttributeList() 
		 (">" ElementList() "</" <XS_APPINFO> ">" | ElementList() "/>")
}

void XsAttribute() #XsAttribute : {}
{
    <XS_ATTRIBUTE> AttributeList() 
		 (">" ElementList() "</" <XS_ATTRIBUTE> ">" | ElementList() "/>")
}

void XsAttributeGroup() #XsAttributeGroup : {}
{
    <XS_ATTRIBUTEGROUP> AttributeList() 
		 (">" ElementList() "</" <XS_ATTRIBUTEGROUP> ">" | ElementList() "/>")
}

void XsChoice() #XsChoice : {}
{
    <XS_CHOICE> AttributeList() 
		 (">" ElementList() "</" <XS_CHOICE> ">" | ElementList() "/>")
}

void XsComplexContent() #XsComplexContent : {}
{
    <XS_COMPLEXCONTENT> AttributeList() 
		 (">" ElementList() "</" <XS_COMPLEXCONTENT> ">" | ElementList() "/>")
}

void XsComplexType() #XsComplexType : {}
{
    <XS_COMPLEXTYPE> AttributeList() 
		 (">" ElementList() "</" <XS_COMPLEXTYPE> ">" | ElementList() "/>")
}

void XsDocumentation() #XsDocumentation : {}
{
    <XS_DOCUMENTATION> AttributeList() 
		 (">" ElementList() "</" <XS_DOCUMENTATION> ">" | ElementList() "/>")
}

void XsElement() #XsElement : {}
{
    <XS_ELEMENT> AttributeList() 
		 (">" ElementList() "</" <XS_ELEMENT> ">" | ElementList() "/>")
}

void XsEnumeration() #XsEnumeration : {}
{
    <XS_ENUMERATION> AttributeList() 
		 (">" ElementList() "</" <XS_ENUMERATION> ">" | ElementList() "/>")
}

void XsExtension() #XsExtension : {}
{
    <XS_EXTENSION> AttributeList() 
		 (">" ElementList() "</" <XS_EXTENSION> ">" | ElementList() "/>")
}

void XsGroup() #XsGroup : {}
{
    <XS_GROUP> AttributeList() 
		 (">" ElementList() "</" <XS_GROUP> ">" | ElementList() "/>")
}

void XsInclude() #XsInclude : {}
{
    <XS_INCLUDE> AttributeList() 
		 (">" ElementList() "</" <XS_INCLUDE> ">" | ElementList() "/>")
}

void XsMaxInclusive() #XsMaxInclusive : {}
{
    <XS_MAXINCLUSIVE> AttributeList() 
		 (">" ElementList() "</" <XS_MAXINCLUSIVE> ">" | ElementList() "/>")
}

void XsMinInclusive() #XsMinInclusive : {}
{
    <XS_MININCLUSIVE> AttributeList() 
		 (">" ElementList() "</" <XS_MININCLUSIVE> ">" | ElementList() "/>")
}

void XsMinExclusive() #XsMinExclusive : {}
{
    <XS_MINEXCLUSIVE> AttributeList() 
		 (">" ElementList() "</" <XS_MINEXCLUSIVE> ">" | ElementList() "/>")
}

void XsList() #XsList : {}
{
    <XS_LIST> AttributeList() 
		 (">" ElementList() "</" <XS_LIST> ">" | ElementList() "/>")
}

void XsMinLength() #XsMinLength : {}
{
    <XS_MINLENGTH> AttributeList() 
		 (">" ElementList() "</" <XS_MINLENGTH> ">" | ElementList() "/>")
}

void XsPattern() #XsPattern : {}
{
    <XS_PATTERN> AttributeList() 
		 (">" ElementList() "</" <XS_PATTERN> ">" | ElementList() "/>")
}

void XsRestriction() #XsRestriction : {}
{
    <XS_RESTRICTION> AttributeList() 
		 (">" ElementList() "</" <XS_RESTRICTION> ">" | ElementList() "/>")
}

void XsSequence() #XsSequence : {}
{
    <XS_SEQUENCE> AttributeList() 
		 (">" ElementList() "</" <XS_SEQUENCE> ">" | ElementList() "/>")
}

void XsSimpleContent() #XsSimpleContent : {}
{
    <XS_SIMPLECONTENT> AttributeList() 
		 (">" ElementList() "</" <XS_SIMPLECONTENT> ">" | ElementList() "/>")
}

void XsSimpleType() #XsSimpleType : {}
{
    <XS_SIMPLETYPE> AttributeList() 
		 (">" ElementList() "</" <XS_SIMPLETYPE> ">" | ElementList() "/>")
}

void XsWhiteSpace() #XsWhiteSpace : {}
{
    <XS_WHITESPACE> AttributeList() 
		 (">" ElementList() "</" <XS_WHITESPACE> ">" | ElementList() "/>")
}

void SimpleElement() : {}
{
    IntElement()
  | FloatElement()
  | StringElement()
  | CDataElement()
}

void IntElement() #IntElement : { Token t; }
{
    t = <INTEGER_LITERAL>
        {jjtThis.setINTEGER_LITERAL(t.image);}
}

void FloatElement() #FloatElement : { Token t; }
{
    t = <FLOAT_LITERAL>
        {jjtThis.setFLOAT_LITERAL(t.image);}
}

void StringElement() #StringElement : { Token t;String s; }
{
	t = <IDENTIFIER>
	{
		s = t.image;
		if (getToken(1).kind != LT ) {
		s += getData();
	}
	}
        {jjtThis.setSTRING(s);}
}

JAVACODE
String getData() {
	StringBuffer s = new StringBuffer();
//     jjtThis.someData = true;
	while ((getToken(1)).kind != LT && (getToken(1)).kind != END_TAG) {
	    Token t = getNextToken();
	    if (t.specialToken != null) {
		Token tmp_t = t.specialToken;
		while (tmp_t.specialToken != null) {
		    tmp_t = tmp_t.specialToken;
		}
		while (tmp_t != null) {
		    s.append(tmp_t.image);
		    tmp_t = tmp_t.next;
		}
	    }
	    s.append(t.image);
	}
	return s.toString();
}

void CDataElement() #CDataElement : {String s; }
{
	<CDATA_START>
	{
	    s = new String();
	    if (getToken(1).kind != CDATA_END ) {
		s += getCData();
	}
	}
	<CDATA_END>
        {jjtThis.setSTRING(s);}
}

JAVACODE
String getCData() {
	StringBuffer s = new StringBuffer();
//     jjtThis.someData = true;
	while ((getToken(1)).kind != CDATA_END) {
	    Token t = getNextToken();
	    if (t.specialToken != null) {
		Token tmp_t = t.specialToken;
		while (tmp_t.specialToken != null) {
		    tmp_t = tmp_t.specialToken;
		}
		while (tmp_t != null) {
		    s.append(tmp_t.image);
		    tmp_t = tmp_t.next;
		}
	    }
	    s.append(t.image);
	}
	return s.toString();
}

void AttributeList() #List : {}
{
    (Attribute())*
}

void Attribute() : {}
{
    Version()
  |	Abstract()
  |	AttributeFormDefault()
  |	Base()
  |	Default()
  |	ElementFormDefault()
  |	Encoding()
  |	Fixed()
  |	ItemType()
  |	MinOccurs()
  |	MaxOccurs()
  |	Mixed()
  |	Name()
  |	Namespace()
  |	ProcessContents()
  |	Ref()
  |	Source()
  |	SchemaLocation()
  |	TargetNamespace()
  |	Type()
  |	Use()
  |	Value()
  |	XmlnsXs()
  |	XmlnsScxml()
}

void AttributeFormDefault() #AttributeFormDefault : {}
{
    <ATTRIBUTEFORMDEFAULT> <ASSIGN> AttValue()
}

void Abstract() #Abstract : {}
{
    <ABSTRACT> <ASSIGN> AttValue()
}

void Base() #Base : {}
{
    <BASE> <ASSIGN> AttValue()
}

void Default() #Default : {}
{
    <DEFAULT_ATTR> <ASSIGN> AttValue()
}

void ElementFormDefault() #ElementFormDefault : {}
{
    <ELEMENTFORMDEFAULT> <ASSIGN> AttValue()
}

void Encoding() #Encoding : {}
{
    <ENCODING> <ASSIGN> AttValue()
}

void Fixed() #Fixed : {}
{
    <FIXED> <ASSIGN> AttValue()
}

void MaxOccurs() #MaxOccurs : {}
{
    <MAXOCCURS> <ASSIGN> AttValue()
}

void MinOccurs() #MinOccurs : {}
{
    <MINOCCURS> <ASSIGN> AttValue()
}

void Mixed() #Mixed : {}
{
    <MIXED> <ASSIGN> AttValue()
}

void Name() #Name : {}
{
    <NAME> <ASSIGN> AttValue()
}

void Namespace() #Namespace : {}
{
    <NAMESPACE> <ASSIGN> AttValue()
}

void ProcessContents() #ProcessContents : {}
{
    <PROCESSCONTENTS> <ASSIGN> AttValue()
}

void ItemType() #ItemType : {}
{
    <ITEMTYPE> <ASSIGN> AttValue()
}

void Ref() #Ref : {}
{
    <REF> <ASSIGN> AttValue()
}

void Source() #Source : {}
{
    <SOURCE> <ASSIGN> AttValue()
}

void SchemaLocation() #SchemaLocation : {}
{
    <SCHEMALOCATION> <ASSIGN> AttValue()
}

void Version() #Version : {}
{
    <VERSION> <ASSIGN> AttValue()
}

void TargetNamespace() #TargetNamespace : {}
{
    <TARGETNAMESPACE> <ASSIGN> AttValue()
}

void Type() #Type : {}
{
    <TYPE> <ASSIGN> AttValue()
}

void Use() #Use : {}
{
    <USE> <ASSIGN> AttValue()
}

void Value() #Value : {}
{
    <VALUE> <ASSIGN> AttValue()
}

void XmlnsXs() #XmlnsXs : {}
{
    <XMLNS_XS> <ASSIGN> AttValue()
}

void XmlnsScxml() #XmlnsScxml : {}
{
    <XMLNS_SCXML> <ASSIGN> AttValue()
}



void AttValue() #AttValue : { Token t; }
{
    t = <STRING_LITERAL>
	{jjtThis.setSTRING_LITERAL(t.image);}
}