// ** 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.demfgen.lib.*;
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)

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 Type parse_Type():{
     Kind kind;
     List<TypeInstance> instances;
}{
    "type"
    kind = parse_Kind()
    "["
    instances = parse_List$TypeInstance$()
    "]"
    { return new Type(kind,instances); }
}

public Kind parse_Kind():{
    Kind sup = null;
}{
(   sup = parse_Classic() { return sup; } | 
    sup = parse_Secret() { return sup; } )
}

public Classic parse_Classic():{
}{
    "classic"
    { return new Classic(); }
}

public Secret parse_Secret():{
}{
    "secret"
    { return new Secret(); }
}

public TypeInstance parse_TypeInstance():{
     RelationNr r;
}{
    r = parse_RelationNr()
    { return new TypeInstance(r); }
}

public Solution parse_Solution():{
     Assignment assignment;
}{
    "(assignment:"
    assignment = parse_Assignment()
    ")"
    { return new Solution(assignment); }
}

public ChallengeInstance parse_ChallengeInstance():{
     List<Constraint> cs;
     Option<SecretOfChallenge> secret;
}{
    cs = parse_List$Constraint$()
    secret = parse_Option$SecretOfChallenge$()
    { return new ChallengeInstance(cs,secret); }
}

public SecretOfChallenge parse_SecretOfChallenge():{
     Option<Assignment> assign;
     Quality quality;
}{
    assign = parse_Option$Assignment$()
    quality = parse_Quality()
    { return new SecretOfChallenge(assign,quality); }
}

public Constraint parse_Constraint():{
     Weight w;
     RelationNr r;
     List<Variable> vs;
}{
    w = parse_Weight()
    r = parse_RelationNr()
    vs = parse_List$Variable$()
    { return new Constraint(w,r,vs); }
}

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

public RelationNr parse_RelationNr():{
     int v;
}{
    v = parse_int()
    { return new RelationNr(v); }
}

public Variable parse_Variable():{
     ident v;
}{
    v = parse_ident()
    { return new Variable(v); }
}

public Predicate parse_Predicate():{
     List<RelationNr> pred;
}{
    pred = parse_List$RelationNr$()
    { return new Predicate(pred); }
}

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

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

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

public Pos parse_Pos():{
}{

    { return new Pos(); }
}

public Neg parse_Neg():{
}{
    "!"
    { return new Neg(); }
}

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 Player parse_Player():{
     PlayerID id;
     String name;
}{
    "player"
    id = parse_PlayerID()
    name = parse_String()
    { return new Player(id,name); }
}

public Challenge parse_Challenge():{
     String name;
     PlayerID seller;
     Option<PlayerID> optbuyer;
     Price price;
     Type type;
     Option<ChallengeInstance> optraw;
     Option<Solution> optfinished;
}{
    "challenge["
    name = parse_String()
    seller = parse_PlayerID()
    optbuyer = parse_Option$PlayerID$()
    price = parse_Price()
    type = parse_Type()
    optraw = parse_Option$ChallengeInstance$()
    optfinished = parse_Option$Solution$()
    "]"
    { return new Challenge(name,seller,optbuyer,price,type,optraw,optfinished); }
}

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;
     Challenge deriv;
}{
    "trans["
    ttype = parse_TransactionType()
    deriv = parse_Challenge()
    "]"
    { 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 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<Challenge> forSale;
     List<Challenge> bought;
}{
    "pstore"
    "forsale"
    forSale = parse_List$Challenge$()
    "bought"
    bought = parse_List$Challenge$()
    { return new PlayerStore(forSale,bought); }
}

public Config parse_Config():{
     double Money;
     int Rounds;
     int Time;
     double MPD;
     int MaxCreates;
     int MaxRawMaterialLen;
}{
    "Money:"
    Money = parse_double()
    "Rounds:"
    Rounds = parse_int()
    "Time:"
    Time = parse_int()
    "MinPriceDecrement:"
    MPD = parse_double()
    "MaxCreates:"
    MaxCreates = parse_int()
    "MaxRawMaterialLen:"
    MaxRawMaterialLen = parse_int()
    { return new Config(Money,Rounds,Time,MPD,MaxCreates,MaxRawMaterialLen); }
}







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

    { return new Empty<Challenge>(); }
}
public Cons<Challenge> parse_Cons$Challenge$():{
     Challenge first;
     List<Challenge> rest;
}{
    first = parse_Challenge()
    rest = parse_List$Challenge$()
    { return new Cons<Challenge>(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); }
}
public Option<Solution> parse_Option$Solution$():{
    Option<Solution> sup = null;
}{
(   sup = parse_Some$Solution$() { return sup; } | 
    sup = parse_None$Solution$() { return sup; } )
}
public None<Solution> parse_None$Solution$():{
}{

    { return new None<Solution>(); }
}
public Some<Solution> parse_Some$Solution$():{
     Solution just;
}{
    just = parse_Solution()
    { return new Some<Solution>(just); }
}
public Option<ChallengeInstance> parse_Option$ChallengeInstance$():{
    Option<ChallengeInstance> sup = null;
}{
(   sup = parse_Some$ChallengeInstance$() { return sup; } | 
    sup = parse_None$ChallengeInstance$() { return sup; } )
}
public None<ChallengeInstance> parse_None$ChallengeInstance$():{
}{

    { return new None<ChallengeInstance>(); }
}
public Some<ChallengeInstance> parse_Some$ChallengeInstance$():{
     ChallengeInstance just;
}{
    just = parse_ChallengeInstance()
    { return new Some<ChallengeInstance>(just); }
}
public Option<PlayerID> parse_Option$PlayerID$():{
    Option<PlayerID> sup = null;
}{
(   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<Literal> parse_List$Literal$():{
    List<Literal> sup = null;
}{
(   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<RelationNr> parse_List$RelationNr$():{
    List<RelationNr> sup = null;
}{
(   sup = parse_Cons$RelationNr$() { return sup; } | 
    sup = parse_Empty$RelationNr$() { return sup; } )
}
public Empty<RelationNr> parse_Empty$RelationNr$():{
}{

    { return new Empty<RelationNr>(); }
}
public Cons<RelationNr> parse_Cons$RelationNr$():{
     RelationNr first;
     List<RelationNr> rest;
}{
    first = parse_RelationNr()
    rest = parse_List$RelationNr$()
    { return new Cons<RelationNr>(first,rest); }
}
public List<Variable> parse_List$Variable$():{
    List<Variable> sup = null;
}{
(   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 Option<Assignment> parse_Option$Assignment$():{
    Option<Assignment> sup = null;
}{
(   sup = parse_Some$Assignment$() { return sup; } | 
    sup = parse_None$Assignment$() { return sup; } )
}
public None<Assignment> parse_None$Assignment$():{
}{

    { return new None<Assignment>(); }
}
public Some<Assignment> parse_Some$Assignment$():{
     Assignment just;
}{
    just = parse_Assignment()
    { return new Some<Assignment>(just); }
}
public Option<SecretOfChallenge> parse_Option$SecretOfChallenge$():{
    Option<SecretOfChallenge> sup = null;
}{
(   sup = parse_Some$SecretOfChallenge$() { return sup; } | 
    sup = parse_None$SecretOfChallenge$() { return sup; } )
}
public None<SecretOfChallenge> parse_None$SecretOfChallenge$():{
}{

    { return new None<SecretOfChallenge>(); }
}
public Some<SecretOfChallenge> parse_Some$SecretOfChallenge$():{
     SecretOfChallenge just;
}{
    just = parse_SecretOfChallenge()
    { return new Some<SecretOfChallenge>(just); }
}
public List<Constraint> parse_List$Constraint$():{
    List<Constraint> sup = null;
}{
(   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); }
}
public List<TypeInstance> parse_List$TypeInstance$():{
    List<TypeInstance> sup = null;
}{
(   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); }
}
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"] ) ) )
              "\'" > }