// ** This class was generated with DemFGen (vers:01/05/2008)

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():{
     List<SymmetricMegaMove> moves;
}{
    moves = parse_List$SymmetricMegaMove$()
    <EOF>
    { return new Start(moves); }
}


public SymmetricMegaMove parse_SymmetricMegaMove():{
     MegaMove<White,Black> m1;
     MegaMove<Black,White> m2;
}{
    m1 = parse_MegaMove$White$Black$()
    m2 = parse_MegaMove$Black$White$()
    { return new SymmetricMegaMove(m1,m2); }
}

public White parse_White():{

}{
    "white"
    { return new White(); }
}

public Black parse_Black():{

}{
    "black"
    { return new Black(); }
}

public Derivative parse_Derivative():{
     DerivativeName n;
}{
    n = parse_DerivativeName()
    { return new Derivative(n); }
}

public RawMaterial parse_RawMaterial():{
     DerivativeName for;
     RawMaterialName n;
}{
    "for"
    for = parse_DerivativeName()
    "raw"
    "material"
    n = parse_RawMaterialName()
    { return new RawMaterial(for,n); }
}

public FinishedProduct parse_FinishedProduct():{
     RawMaterialName for;
     FinishedProductName n;
}{
    "for"
    for = parse_RawMaterialName()
    "finished"
    "product"
    n = parse_FinishedProductName()
    { return new FinishedProduct(for,n); }
}

public DerivativeName parse_DerivativeName():{
     ident v;
}{
    v = parse_ident()
    { return new DerivativeName(v); }
}

public RawMaterialName parse_RawMaterialName():{
     ident v;
}{
    v = parse_ident()
    { return new RawMaterialName(v); }
}

public FinishedProductName parse_FinishedProductName():{
     ident v;
}{
    v = parse_ident()
    { return new FinishedProductName(v); }
}

public Main parse_Main():{

}{

    { return new Main(); }
}

public MegaMove<Black,White> parse_MegaMove$Black$White$():{
     Black whoOffers;
     List<Derivative> offers;
     White whoBuys;
     List<Derivative> buys;
     Black whoDelivers;
     List<RawMaterial> rawmaterials;
     White whoFinishes;
     List<FinishedProduct> finished;
}{
    whoOffers = parse_Black()
    offers = parse_List$Derivative$()
    whoBuys = parse_White()
    buys = parse_List$Derivative$()
    whoDelivers = parse_Black()
    rawmaterials = parse_List$RawMaterial$()
    whoFinishes = parse_White()
    finished = parse_List$FinishedProduct$()
    { return new MegaMove<Black,White>(whoOffers,offers,whoBuys,buys,whoDelivers,rawmaterials,whoFinishes,finished); }
}
public List<FinishedProduct> parse_List$FinishedProduct$():{
    List<FinishedProduct> sup = null;
}{
 (  sup = parse_Cons$FinishedProduct$()  { return sup; } | 
    sup = parse_Empty$FinishedProduct$()  { return sup; } )

}
public Empty<FinishedProduct> parse_Empty$FinishedProduct$():{

}{

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

}
public Empty<RawMaterial> parse_Empty$RawMaterial$():{

}{

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

}
public Empty<Derivative> parse_Empty$Derivative$():{

}{

    { return new Empty<Derivative>(); }
}
public Cons<Derivative> parse_Cons$Derivative$():{
     Derivative first;
     List<Derivative> rest;
}{
    first = parse_Derivative()
    rest = parse_List$Derivative$()
    { return new Cons<Derivative>(first,rest); }
}
public MegaMove<White,Black> parse_MegaMove$White$Black$():{
     White whoOffers;
     List<Derivative> offers;
     Black whoBuys;
     List<Derivative> buys;
     White whoDelivers;
     List<RawMaterial> rawmaterials;
     Black whoFinishes;
     List<FinishedProduct> finished;
}{
    whoOffers = parse_White()
    offers = parse_List$Derivative$()
    whoBuys = parse_Black()
    buys = parse_List$Derivative$()
    whoDelivers = parse_White()
    rawmaterials = parse_List$RawMaterial$()
    whoFinishes = parse_Black()
    finished = parse_List$FinishedProduct$()
    { return new MegaMove<White,Black>(whoOffers,offers,whoBuys,buys,whoDelivers,rawmaterials,whoFinishes,finished); }
}
public List<SymmetricMegaMove> parse_List$SymmetricMegaMove$():{
    List<SymmetricMegaMove> sup = null;
}{
 (  sup = parse_Cons$SymmetricMegaMove$()  { return sup; } | 
    sup = parse_Empty$SymmetricMegaMove$()  { return sup; } )

}
public Empty<SymmetricMegaMove> parse_Empty$SymmetricMegaMove$():{

}{

    { return new Empty<SymmetricMegaMove>(); }
}
public Cons<SymmetricMegaMove> parse_Cons$SymmetricMegaMove$():{
     SymmetricMegaMove first;
     List<SymmetricMegaMove> rest;
}{
    first = parse_SymmetricMegaMove()
    rest = parse_List$SymmetricMegaMove$()
    { return new Cons<SymmetricMegaMove>(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"] ) ) )
              "\'" > }