// ** This class was generated with DemFGen (vers:06/04/2009)

options{ STATIC = false;  }
PARSER_BEGIN(TheParser)
package gen;

import edu.neu.ccs.demeterf.demfgen.lib.*;
import edu.neu.ccs.demeterf.*;
import edu.neu.ccs.demeterf.control.Fields;
import edu.neu.ccs.demeterf.demfgen.lib.ident;
import edu.neu.ccs.demeterf.demfgen.lib.verbatim;

  class TheParser{

    static char unescapeChar(String s){
        s = s.substring(1,s.length()-1);        char c = s.charAt(0);
        if (c == '\\'){
            switch (s.charAt(1)) {
            case 'n': return '\n';  case 't': return '\t';
            case 'b': return '\b';  case 'r': return '\r';
            case 'f': return '\f';  case '\\': return '\\';
            case '\'': return '\''; case '\"': return '\"';
            default: return (char)Integer.parseInt(s.substring(1, s.length()), 8);
            }
        }
        return c;
    }
  }
PARSER_END(TheParser)

byte parse_byte():{ int i; }{
    i = parse_int() { return (byte)i; }
}
Byte parse_Byte():{ byte b; }{
    b = parse_byte() { return b; }
}
short parse_short():{ int i; }{
    i = parse_int() { return (short)i; }
}
Short parse_Short():{ short s; }{
    s = parse_short() { return s; }
}
int parse_int():{ Token t; }{
    t = <INT>
    { return Integer.parseInt(t.image); }
}
Integer parse_Integer():{ int i; }{
    i = parse_int() { return i; }
}
long parse_long():{ Token t; }{
    t = <INT>
    { return Long.parseLong(t.image); }
}
Long parse_Long():{ long l; }{
    l = parse_long() { return l; }
}
double parse_double():{ Token t; }{
    t = <DOUBLE>
    { return Double.parseDouble(t.image); }
}
Double parse_Double():{ double d; }{
    d = parse_double() { return d; }
}
float parse_float():{ Token t; }{
    t = <DOUBLE>
    { return Float.parseFloat(t.image); }
}
Float parse_Float():{ float f; }{
    f = parse_float() { return f; }
}
String parse_String():{ Token t; }{
    t = <STRING>
    { return t.image.substring(1,t.image.length()-1); }
}
boolean parse_boolean():{ Token t; }{
    t = <TRUE> { return true; } |
    t = <FALSE> { return false; }
}
Boolean parse_Boolean():{ boolean b; }{
    b = parse_boolean() { return b; }
}
char parse_char():{ Token t; }{
    t = <CHAR>
    { return unescapeChar(t.image); }
}
Character parse_Character():{ char c; }{
    c = parse_char() { return c; }
}
ident parse_ident():{ Token t; }{
    t = <IDENT>
    { return new ident(t.image); }
}
verbatim parse_verbatim():{ Token t; }{
    t = <TEXT>
    { return new verbatim(t.image.substring(2,t.image.length()-2)); }
}




public Start parse_Start():{
     RandomGenerationAspect r;
}{
    r = parse_RandomGenerationAspect()
    <EOF>
    { return new Start(r); }
}

public RandomGenerationAspect parse_RandomGenerationAspect():{
     ClassDictionary cd;
     List<AdvisedField> advisedFields;
}{
    cd = parse_ClassDictionary()
    "advised"
    advisedFields = parse_List$AdvisedField$()
    { return new RandomGenerationAspect(cd,advisedFields); }
}

public AdvisedField parse_AdvisedField():{
     QualIdent f;
     FieldKind k;
}{
    f = parse_QualIdent()
    k = parse_FieldKind()
    { return new AdvisedField(f,k); }
}

public FieldKind parse_FieldKind():{
    FieldKind sup = null;
}{
(   sup = parse_ListField() { return sup; } | 
    sup = parse_NumericalField() { return sup; } | 
    sup = parse_ConstrainedField() { return sup; } )
}

public ClassDictionary parse_ClassDictionary():{
}{
    "cd"
    { return new ClassDictionary(); }
}

public ListField parse_ListField():{
     NumberConstraint<Integer> length;
     List<ElementConstraint> element;
}{
    "list"
    "length"
    length = parse_NumberConstraint$Integer$()
    "element"
    element = parse_List$ElementConstraint$()
    { return new ListField(length,element); }
}

public ElementConstraint parse_ElementConstraint():{
    ElementConstraint sup = null;
}{
(   sup = parse_Distinct() { return sup; } | 
    sup = parse_Subset() { return sup; } )
}

public Subset parse_Subset():{
     NumberConstraint<Integer> r;
}{
    "subset"
    r = parse_NumberConstraint$Integer$()
    { return new Subset(r); }
}

public Distinct parse_Distinct():{
}{
    "distinct"
    { return new Distinct(); }
}





public Ref parse_Ref():{
     QualIdent v;
}{
    "ref"
    v = parse_QualIdent()
    { return new Ref(v); }
}

public QualIdent parse_QualIdent():{
     ident first;
     List<DField> rest;
}{
    first = parse_ident()
    rest = parse_List$DField$()
    { return new QualIdent(first,rest); }
}

public DField parse_DField():{
     Field f;
}{
    "."
    f = parse_Field()
    { return new DField(f); }
}

public Field parse_Field():{
     ident v;
}{
    v = parse_ident()
    { return new Field(v); }
}

public NumericalField parse_NumericalField():{
     NumberConstraint<Integer> nc;
}{
    "numerical"
    nc = parse_NumberConstraint$Integer$()
    { return new NumericalField(nc); }
}

public ConstrainedField parse_ConstrainedField():{
     QualIdent v;
}{
    "in"
    v = parse_QualIdent()
    { return new ConstrainedField(v); }
}

public B parse_B():{
     List<Basket> xyz;
}{
    xyz = parse_List$Basket$()
    { return new B(xyz); }
}

public Basket parse_Basket():{
     Z z;
     List<Item> items;
}{
    "basket"
    z = parse_Z()
    "("
    items = parse_List$Item$()
    ")"
    { return new Basket(z,items); }
}

public Item parse_Item():{
    Item sup = null;
}{
(   sup = parse_Fruit() { return sup; } | 
    sup = parse_Pencil() { return sup; } | 
    sup = parse_Basket() { return sup; } )
}

public Pencil parse_Pencil():{
}{
    "p"
    { return new Pencil(); }
}

public Fruit parse_Fruit():{
    Fruit sup = null;
}{
(   sup = parse_Apple() { return sup; } | 
    sup = parse_Orange() { return sup; } )
}

public Apple parse_Apple():{
}{
    "a"
    { return new Apple(); }
}

public Orange parse_Orange():{
}{
    "o"
    { return new Orange(); }
}

public Z parse_Z():{
}{

    { return new Z(); }
}

public List<Item> parse_List$Item$():{
    List<Item> sup = null;
}{
(   sup = parse_Cons$Item$() { return sup; } | 
    sup = parse_Empty$Item$() { return sup; } )
}
public Empty<Item> parse_Empty$Item$():{
}{

    { return new Empty<Item>(); }
}
public Cons<Item> parse_Cons$Item$():{
     Item first;
     List<Item> rest;
}{
    first = parse_Item()
    rest = parse_List$Item$()
    { return new Cons<Item>(first,rest); }
}
public List<Basket> parse_List$Basket$():{
    List<Basket> sup = null;
}{
(   sup = parse_Cons$Basket$() { return sup; } | 
    sup = parse_Empty$Basket$() { return sup; } )
}
public Empty<Basket> parse_Empty$Basket$():{
}{

    { return new Empty<Basket>(); }
}
public Cons<Basket> parse_Cons$Basket$():{
     Basket first;
     List<Basket> rest;
}{
    first = parse_Basket()
    rest = parse_List$Basket$()
    { return new Cons<Basket>(first,rest); }
}
public NumberConstraint<Integer> parse_NumberConstraint$Integer$():{
    NumberConstraint<Integer> sup = null;
}{
(   sup = parse_Single$Integer$() { return sup; } | 
    sup = parse_Range$Integer$() { return sup; } | 
    sup = parse_Enumeration$Integer$() { return sup; } | 
    sup = parse_Ref() { return sup; } )
}
public Enumeration<Integer> parse_Enumeration$Integer$():{
     List<Integer> l;
}{
    "enum"
    l = parse_List$Integer$()
    { return new Enumeration<Integer>(l); }
}
public List<Integer> parse_List$Integer$():{
    List<Integer> sup = null;
}{
(   sup = parse_Cons$Integer$() { return sup; } | 
    sup = parse_Empty$Integer$() { return sup; } )
}
public Empty<Integer> parse_Empty$Integer$():{
}{

    { return new Empty<Integer>(); }
}
public Cons<Integer> parse_Cons$Integer$():{
     Integer first;
     List<Integer> rest;
}{
    first = parse_Integer()
    rest = parse_List$Integer$()
    { return new Cons<Integer>(first,rest); }
}
public Range<Integer> parse_Range$Integer$():{
     Integer low;
     Integer high;
}{
    "range"
    low = parse_Integer()
    ".."
    high = parse_Integer()
    { return new Range<Integer>(low,high); }
}
public Single<Integer> parse_Single$Integer$():{
     Integer v;
}{
    v = parse_Integer()
    { return new Single<Integer>(v); }
}
public List<DField> parse_List$DField$():{
    List<DField> sup = null;
}{
(   sup = parse_Cons$DField$() { return sup; } | 
    sup = parse_Empty$DField$() { return sup; } )
}
public Empty<DField> parse_Empty$DField$():{
}{

    { return new Empty<DField>(); }
}
public Cons<DField> parse_Cons$DField$():{
     DField first;
     List<DField> rest;
}{
    first = parse_DField()
    rest = parse_List$DField$()
    { return new Cons<DField>(first,rest); }
}
public List<ElementConstraint> parse_List$ElementConstraint$():{
    List<ElementConstraint> sup = null;
}{
(   sup = parse_Cons$ElementConstraint$() { return sup; } | 
    sup = parse_Empty$ElementConstraint$() { return sup; } )
}
public Empty<ElementConstraint> parse_Empty$ElementConstraint$():{
}{

    { return new Empty<ElementConstraint>(); }
}
public Cons<ElementConstraint> parse_Cons$ElementConstraint$():{
     ElementConstraint first;
     List<ElementConstraint> rest;
}{
    first = parse_ElementConstraint()
    rest = parse_List$ElementConstraint$()
    { return new Cons<ElementConstraint>(first,rest); }
}
public List<AdvisedField> parse_List$AdvisedField$():{
    List<AdvisedField> sup = null;
}{
(   sup = parse_Cons$AdvisedField$() { return sup; } | 
    sup = parse_Empty$AdvisedField$() { return sup; } )
}
public Empty<AdvisedField> parse_Empty$AdvisedField$():{
}{

    { return new Empty<AdvisedField>(); }
}
public Cons<AdvisedField> parse_Cons$AdvisedField$():{
     AdvisedField first;
     List<AdvisedField> rest;
}{
    first = parse_AdvisedField()
    rest = parse_List$AdvisedField$()
    { return new Cons<AdvisedField>(first,rest); }
}
SKIP : { " " | "\t" | "\n" | "\r" | "\r\n" }
SKIP : { <"//" (~["\n","\r"])* ("\n"|"\r\n")> }
SKIP : { <"/*" (~["*"])* "*" (~["/"] (~["*"])* "*")* "/">}
TOKEN: { < INT : ("+" | "-")?(["0"-"9"])+ > }
TOKEN: { < STRING : "\"" (~["\""])* "\"" > }
TOKEN: { < TRUE : "true" > }
TOKEN: { < FALSE : "false" > }
TOKEN: { < DOUBLE : ("-")?(["0"-"9"])+ "." (["0"-"9"])+ | "." (["0"-"9"])+ > }
TOKEN: { < IDENT : ["a"-"z","A"-"Z","$","_"] (["a"-"z","A"-"Z","0"-"9","_","$"])* > }
TOKEN: { < TEXT : ( "{{" (~["}"])* ( "}" ~["}"] (~["}"])* )* "}}" ) > }
TOKEN: { < CHAR: "\'" 
              ( (~["\'","\\","\n","\r"]) | 
                ("\\" ( ["n","t","b","r","f","\\","\'","\""] |
                            ["0"-"7"] ( ["0"-"7"] )? |
                            ["0"-"3"] ["0"-"7"] ["0"-"7"] ) ) )
              "\'" > }