// ** This class was generated with DemFGen !!

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

import edu.neu.ccs.demeterf.demfgen.lib.*;
import edu.neu.ccs.demeterf.demfgen.lib.*;
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)

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 RawMaterialInstance parse_RawMaterialInstance():{
     List<Constraint> constraints;
}{
    constraints = parse_List$Constraint$()
    { return new RawMaterialInstance(constraints); }
}

public IntermediateProduct parse_IntermediateProduct():{
     Assignment assignment;
}{
    assignment = parse_Assignment()
    { return new IntermediateProduct(assignment); }
}

public TypeInstance parse_TypeInstance():{
     Relation rel;
}{
    
    rel = parse_Relation()
    { return new TypeInstance(rel); }
}








public Variable parse_Variable():{
     String v;
}{
    v = parse_String()
    { return new Variable(v); }
}

public Weight parse_Weight():{
     int val;
}{
    val = parse_int()
    { return new Weight(val); }
}

public Price parse_Price():{
     double val;
}{
    val = parse_double()
    { return new Price(val); }
}

public Quality parse_Quality():{
     double val;
}{
    val = parse_double()
    { return new Quality(val); }
}

public PlayerID parse_PlayerID():{
     int id;
}{
    id = parse_int()
    { return new PlayerID(id); }
}

public Relation parse_Relation():{
     int num;
}{
    num = parse_int()
    { return new Relation(num); }
}

public Pos parse_Pos():{

}{
    "+"
    { return new Pos(); }
}

public Neg parse_Neg():{

}{
    "-"
    { return new Neg(); }
}

public Constraint parse_Constraint():{
     Weight weight;
     Relation relation;
     List<Variable> variables;
}{
    
    weight = parse_Weight()
    
    relation = parse_Relation()
    
    variables = parse_List$Variable$()
    
    { return new Constraint(weight,relation,variables); }
}

public Assignment parse_Assignment():{
     List<Literal> literals;
}{
    "assign"
    "["
    literals = parse_List$Literal$()
    "]"
    { return new Assignment(literals); }
}

public Literal parse_Literal():{
     Sign sign;
     Variable var;
}{
    
    sign = parse_Sign()
    
    var = parse_Variable()
    
    { return new Literal(sign,var); }
}

public Sign parse_Sign():{
    Sign sup;
}{
 (  sup = parse_Pos()  { return sup; } | 
    sup = parse_Neg()  { return sup; } )

}

public Player parse_Player():{
     PlayerID id;
     String name;
}{
    "player"
    
    id = parse_PlayerID()
    
    name = parse_String()
    { return new Player(id,name); }
}

public Type parse_Type():{
     List<TypeInstance> instances;
}{
    "type"
    "["
    instances = parse_List$TypeInstance$()
    "]"
    { return new Type(instances); }
}

public Derivative parse_Derivative():{
     String name;
     PlayerID seller;
     Option<PlayerID> optbuyer;
     Price price;
     Type type;
     Option<RawMaterial> optraw;
     Option<FinishedProduct> optfinished;
}{
    "deriv"
    "["
    name = parse_String()
    
    seller = parse_PlayerID()
    
    optbuyer = parse_Option$PlayerID$()
    
    price = parse_Price()
    
    type = parse_Type()
    
    optraw = parse_Option$RawMaterial$()
    
    optfinished = parse_Option$FinishedProduct$()
    "]"
    { return new Derivative(name,seller,optbuyer,price,type,optraw,optfinished); }
}

public RawMaterial parse_RawMaterial():{
     RawMaterialInstance instance;
}{
    "rm"
    "["
    instance = parse_RawMaterialInstance()
    "]"
    { return new RawMaterial(instance); }
}

public FinishedProduct parse_FinishedProduct():{
     IntermediateProduct ip;
     Quality quality;
}{
    "finish"
    "["
    ip = parse_IntermediateProduct()
    
    quality = parse_Quality()
    "]"
    { return new FinishedProduct(ip,quality); }
}

public History parse_History():{
     List<Round> rounds;
}{
    "history"
    "["
    rounds = parse_List$Round$()
    "]"
    { return new History(rounds); }
}

public Round parse_Round():{
     int num;
     List<PlayerTransaction> ptransactions;
}{
    "round"
    
    num = parse_int()
    
    "["
    ptransactions = parse_List$PlayerTransaction$()
    "]"
    { return new Round(num,ptransactions); }
}

public PlayerTransaction parse_PlayerTransaction():{
     Player player;
     List<Transaction> transactions;
}{
    "ptrans"
    "["
    player = parse_Player()
    
    transactions = parse_List$Transaction$()
    "]"
    { return new PlayerTransaction(player,transactions); }
}

public Transaction parse_Transaction():{
     TransactionType ttype;
     Derivative deriv;
}{
    "trans"
    "["
    ttype = parse_TransactionType()
    
    deriv = parse_Derivative()
    "]"
    { return new Transaction(ttype,deriv); }
}

public TransactionType parse_TransactionType():{
    TransactionType sup;
}{
 (  sup = parse_Buy()  { return sup; } | 
    sup = parse_Create()  { return sup; } | 
    sup = parse_Reoffer()  { return sup; } | 
    sup = parse_Deliver()  { return sup; } | 
    sup = parse_Finish()  { return sup; } )

}

public Buy parse_Buy():{

}{
    "BUY"
    { return new Buy(); }
}

public Create parse_Create():{

}{
    "CREATE"
    { return new Create(); }
}

public Reoffer parse_Reoffer():{

}{
    "REOFFER"
    { return new Reoffer(); }
}

public Deliver parse_Deliver():{

}{
    "DELIVER"
    { return new Deliver(); }
}

public Finish parse_Finish():{

}{
    "FINISH"
    { return new Finish(); }
}

public Players parse_Players():{
     List<Player> players;
}{
    "players"
    "["
    players = parse_List$Player$()
    "]"
    { return new Players(players); }
}

public Accounts parse_Accounts():{
     List<Pair<PlayerID,Double>> accounts;
}{
    "accounts"
    "["
    accounts = parse_List$Pair$PlayerID$Double$$()
    "]"
    { return new Accounts(accounts); }
}

public Store parse_Store():{
     List<Pair<PlayerID,PlayerStore>> stores;
}{
    "store"
    "["
    stores = parse_List$Pair$PlayerID$PlayerStore$$()
    "]"
    { return new Store(stores); }
}

public PlayerStore parse_PlayerStore():{
     List<Derivative> forSale;
     List<Derivative> bought;
}{
    "pstore"
    
    "forsale"
    
    forSale = parse_List$Derivative$()
    
    "bought"
    
    bought = parse_List$Derivative$()
    { return new PlayerStore(forSale,bought); }
}

public Config parse_Config():{
     double init;
     int maxRounds;
     int timeslot;
     double mindec;
}{
    init = parse_double()
    
    maxRounds = parse_int()
    
    timeslot = parse_int()
    
    mindec = parse_double()
    { return new Config(init,maxRounds,timeslot,mindec); }
}

public List<Derivative> parse_List$Derivative$():{
    List<Derivative> sup;
}{
 (  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 List<Pair<PlayerID,PlayerStore>> parse_List$Pair$PlayerID$PlayerStore$$():{
    List<Pair<PlayerID,PlayerStore>> sup;
}{
 (  sup = parse_Cons$Pair$PlayerID$PlayerStore$$()  { return sup; } | 
    sup = parse_Empty$Pair$PlayerID$PlayerStore$$()  { return sup; } )

}
public Empty<Pair<PlayerID,PlayerStore>> parse_Empty$Pair$PlayerID$PlayerStore$$():{

}{

    { return new Empty<Pair<PlayerID,PlayerStore>>(); }
}
public Cons<Pair<PlayerID,PlayerStore>> parse_Cons$Pair$PlayerID$PlayerStore$$():{
     Pair<PlayerID,PlayerStore> first;
     List<Pair<PlayerID,PlayerStore>> rest;
}{
    first = parse_Pair$PlayerID$PlayerStore$()
    rest = parse_List$Pair$PlayerID$PlayerStore$$()
    { return new Cons<Pair<PlayerID,PlayerStore>>(first,rest); }
}
public Pair<PlayerID,PlayerStore> parse_Pair$PlayerID$PlayerStore$():{
     PlayerID a;
     PlayerStore b;
}{
    
    a = parse_PlayerID()
    
    b = parse_PlayerStore()
    
    { return new Pair<PlayerID,PlayerStore>(a,b); }
}
public List<Pair<PlayerID,Double>> parse_List$Pair$PlayerID$Double$$():{
    List<Pair<PlayerID,Double>> sup;
}{
 (  sup = parse_Cons$Pair$PlayerID$Double$$()  { return sup; } | 
    sup = parse_Empty$Pair$PlayerID$Double$$()  { return sup; } )

}
public Empty<Pair<PlayerID,Double>> parse_Empty$Pair$PlayerID$Double$$():{

}{

    { return new Empty<Pair<PlayerID,Double>>(); }
}
public Cons<Pair<PlayerID,Double>> parse_Cons$Pair$PlayerID$Double$$():{
     Pair<PlayerID,Double> first;
     List<Pair<PlayerID,Double>> rest;
}{
    first = parse_Pair$PlayerID$Double$()
    rest = parse_List$Pair$PlayerID$Double$$()
    { return new Cons<Pair<PlayerID,Double>>(first,rest); }
}
public Pair<PlayerID,Double> parse_Pair$PlayerID$Double$():{
     PlayerID a;
     Double b;
}{
    
    a = parse_PlayerID()
    
    b = parse_Double()
    
    { return new Pair<PlayerID,Double>(a,b); }
}
public List<Player> parse_List$Player$():{
    List<Player> sup;
}{
 (  sup = parse_Cons$Player$()  { return sup; } | 
    sup = parse_Empty$Player$()  { return sup; } )

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

}{

    { return new Empty<Player>(); }
}
public Cons<Player> parse_Cons$Player$():{
     Player first;
     List<Player> rest;
}{
    first = parse_Player()
    rest = parse_List$Player$()
    { return new Cons<Player>(first,rest); }
}
public List<Transaction> parse_List$Transaction$():{
    List<Transaction> sup;
}{
 (  sup = parse_Cons$Transaction$()  { return sup; } | 
    sup = parse_Empty$Transaction$()  { return sup; } )

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

}{

    { return new Empty<Transaction>(); }
}
public Cons<Transaction> parse_Cons$Transaction$():{
     Transaction first;
     List<Transaction> rest;
}{
    first = parse_Transaction()
    rest = parse_List$Transaction$()
    { return new Cons<Transaction>(first,rest); }
}
public List<PlayerTransaction> parse_List$PlayerTransaction$():{
    List<PlayerTransaction> sup;
}{
 (  sup = parse_Cons$PlayerTransaction$()  { return sup; } | 
    sup = parse_Empty$PlayerTransaction$()  { return sup; } )

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

}{

    { return new Empty<PlayerTransaction>(); }
}
public Cons<PlayerTransaction> parse_Cons$PlayerTransaction$():{
     PlayerTransaction first;
     List<PlayerTransaction> rest;
}{
    first = parse_PlayerTransaction()
    rest = parse_List$PlayerTransaction$()
    { return new Cons<PlayerTransaction>(first,rest); }
}
public List<Round> parse_List$Round$():{
    List<Round> sup;
}{
 (  sup = parse_Cons$Round$()  { return sup; } | 
    sup = parse_Empty$Round$()  { return sup; } )

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

}{

    { return new Empty<Round>(); }
}
public Cons<Round> parse_Cons$Round$():{
     Round first;
     List<Round> rest;
}{
    first = parse_Round()
    rest = parse_List$Round$()
    { return new Cons<Round>(first,rest); }
}
public Option<FinishedProduct> parse_Option$FinishedProduct$():{
    Option<FinishedProduct> sup;
}{
 (  sup = parse_Some$FinishedProduct$()  { return sup; } | 
    sup = parse_None$FinishedProduct$()  { return sup; } )

}
public None<FinishedProduct> parse_None$FinishedProduct$():{

}{

    { return new None<FinishedProduct>(); }
}
public Some<FinishedProduct> parse_Some$FinishedProduct$():{
     FinishedProduct just;
}{
    just = parse_FinishedProduct()
    { return new Some<FinishedProduct>(just); }
}
public Option<RawMaterial> parse_Option$RawMaterial$():{
    Option<RawMaterial> sup;
}{
 (  sup = parse_Some$RawMaterial$()  { return sup; } | 
    sup = parse_None$RawMaterial$()  { return sup; } )

}
public None<RawMaterial> parse_None$RawMaterial$():{

}{

    { return new None<RawMaterial>(); }
}
public Some<RawMaterial> parse_Some$RawMaterial$():{
     RawMaterial just;
}{
    just = parse_RawMaterial()
    { return new Some<RawMaterial>(just); }
}
public Option<PlayerID> parse_Option$PlayerID$():{
    Option<PlayerID> sup;
}{
 (  sup = parse_Some$PlayerID$()  { return sup; } | 
    sup = parse_None$PlayerID$()  { return sup; } )

}
public None<PlayerID> parse_None$PlayerID$():{

}{

    { return new None<PlayerID>(); }
}
public Some<PlayerID> parse_Some$PlayerID$():{
     PlayerID just;
}{
    just = parse_PlayerID()
    { return new Some<PlayerID>(just); }
}
public List<TypeInstance> parse_List$TypeInstance$():{
    List<TypeInstance> sup;
}{
 (  sup = parse_Cons$TypeInstance$()  { return sup; } | 
    sup = parse_Empty$TypeInstance$()  { return sup; } )

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

}{

    { return new Empty<TypeInstance>(); }
}
public Cons<TypeInstance> parse_Cons$TypeInstance$():{
     TypeInstance first;
     List<TypeInstance> rest;
}{
    first = parse_TypeInstance()
    rest = parse_List$TypeInstance$()
    { return new Cons<TypeInstance>(first,rest); }
}
public List<Literal> parse_List$Literal$():{
    List<Literal> sup;
}{
 (  sup = parse_Cons$Literal$()  { return sup; } | 
    sup = parse_Empty$Literal$()  { return sup; } )

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

}{

    { return new Empty<Literal>(); }
}
public Cons<Literal> parse_Cons$Literal$():{
     Literal first;
     List<Literal> rest;
}{
    first = parse_Literal()
    rest = parse_List$Literal$()
    { return new Cons<Literal>(first,rest); }
}
public List<Variable> parse_List$Variable$():{
    List<Variable> sup;
}{
 (  sup = parse_Cons$Variable$()  { return sup; } | 
    sup = parse_Empty$Variable$()  { return sup; } )

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

}{

    { return new Empty<Variable>(); }
}
public Cons<Variable> parse_Cons$Variable$():{
     Variable first;
     List<Variable> rest;
}{
    first = parse_Variable()
    rest = parse_List$Variable$()
    { return new Cons<Variable>(first,rest); }
}
public List<Constraint> parse_List$Constraint$():{
    List<Constraint> sup;
}{
 (  sup = parse_Cons$Constraint$()  { return sup; } | 
    sup = parse_Empty$Constraint$()  { return sup; } )

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

}{

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