// ** This class was generated with DemFGen (vers:11/03/2008)

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

import java.io.FileInputStream;
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)

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 Outcome parse_Outcome():{
     String name;
}{
    name = parse_String()
    { return new Outcome(name); }
}

public Value parse_Value():{

}{
    "VAL"
    { return new Value(); }
}

public Predicate parse_Predicate():{
     String pred;
}{
    "pred"
    pred = parse_String()
    { return new Predicate(pred); }
}

public Derivative parse_Derivative():{
     String name;
     Price price;
     Predicate predicate;
     Option<RawMaterial> optraw;
     Option<FinishedProduct> optfinished;
}{
    "deriv"
    "["
    name = parse_String()
    price = parse_Price()
    predicate = parse_Predicate()
    optraw = parse_Option$RawMaterial$()
    optfinished = parse_Option$FinishedProduct$()
    "]"
    { return new Derivative(name,price,predicate,optraw,optfinished); }
}

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

public RawMaterialInstance parse_RawMaterialInstance():{
     String name;
}{
    name = parse_String()
    { return new RawMaterialInstance(name); }
}

public FinishedProduct parse_FinishedProduct():{
     RawMaterial rm;
     Outcome ip;
     Quality quality;
}{
    "finish"
    "["
    rm = parse_RawMaterial()
    ip = parse_Outcome()
    quality = parse_Quality()
    "]"
    { return new FinishedProduct(rm,ip,quality); }
}

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 History parse_History():{
     List<Round> rounds;
}{
    "history"
    "["
    rounds = parse_List$Round$()
    "]"
    { return new History(rounds); }
}

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

public PlayerTransaction parse_PlayerTransaction():{
     String playerName;
     List<Transaction> transactions;
}{
    playerName = parse_String()
    transactions = parse_List$Transaction$()
    { return new PlayerTransaction(playerName,transactions); }
}

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

public TransactionType parse_TransactionType():{
    TransactionType sup = null;
}{
 (  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 SDG parse_SDG():{
     List<Player> players;
     List<Pair<PlayerID,Double>> account;
     List<Pair<PlayerID,PlayerStore>> store;
     Config config;
}{
    "SDG"
    "players"
    players = parse_List$Player$()
    "accounts"
    account = parse_List$Pair$PlayerID$Double$$()
    "store"
    store = parse_List$Pair$PlayerID$PlayerStore$$()
    "config"
    config = parse_Config()
    { return new SDG(players,account,store,config); }
}

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

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

public BoughtDeriv parse_BoughtDeriv():{
     Derivative d;
     PlayerID seller;
     Option<RawMaterial> r;
     Option<FinishedProduct> f;
}{
    "bought"
    d = parse_Derivative()
    seller = parse_PlayerID()
    r = parse_Option$RawMaterial$()
    f = parse_Option$FinishedProduct$()
    { return new BoughtDeriv(d,seller,r,f); }
}

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


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

public Option<FinishedProduct> parse_Option$FinishedProduct$():{
    Option<FinishedProduct> sup = null;
}{
 (  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 = null;
}{
 (  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 List<BoughtDeriv> parse_List$BoughtDeriv$():{
    List<BoughtDeriv> sup = null;
}{
 (  sup = parse_Cons$BoughtDeriv$()  { return sup; } | 
    sup = parse_Empty$BoughtDeriv$()  { return sup; } )

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

}{

    { return new Empty<BoughtDeriv>(); }
}
public Cons<BoughtDeriv> parse_Cons$BoughtDeriv$():{
     BoughtDeriv first;
     List<BoughtDeriv> rest;
}{
    first = parse_BoughtDeriv()
    rest = parse_List$BoughtDeriv$()
    { return new Cons<BoughtDeriv>(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 List<Pair<PlayerID,PlayerStore>> parse_List$Pair$PlayerID$PlayerStore$$():{
    List<Pair<PlayerID,PlayerStore>> sup = null;
}{
 (  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 = null;
}{
 (  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 = null;
}{
 (  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 = null;
}{
 (  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 = null;
}{
 (  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 = null;
}{
 (  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); }
}
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"] ) ) )
              "\'" > }