// ** This file was generated with DemFGen (vers:12/15/2010)

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

import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.*;
import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.*;
import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.*;
import java.lang.Integer;
import edu.neu.ccs.demeterf.Fields;
import edu.neu.ccs.demeterf.lib.ident;
import edu.neu.ccs.demeterf.lib.verbatim;

  public class TheParser{

   public static String unescape(String str){
      String retval = "";
      int index = 0;
      char ch, ch1;
      int ordinal = 0;
      while (index < str.length()) {
         if(str.charAt(index) != '\\') { retval += str.charAt(index++); continue; }
         ch = str.charAt(++index);
         if(ch == 'b') { retval += '\b'; index++; continue; }
         if(ch == 't') { retval += '\t'; index++; continue; }
         if(ch == 'n') { retval += '\n'; index++; continue; }
         if(ch == 'f') { retval += '\f'; index++; continue; }
         if(ch == 'r') { retval += '\r'; index++; continue; }
         if(ch == '"') { retval += '\"'; index++; continue; }
         if(ch == '\'') { retval += '\''; index++; continue; }
         if(ch == '\\') { retval += '\\'; index++; continue; }
         if(ch >= '0' && ch <= '7'){
            ordinal = ((int)ch) - ((int)'0'); index++;
            ch1 = str.charAt(index);
            if(ch1 >= '0' && ch1 <= '7'){
               ordinal = ordinal*8 + ((int)ch1) - ((int)'0'); index++;
               ch1 = str.charAt(index);
               if(ch <= '3' && ch1 >= '0' && ch1 <= '7'){
                  ordinal = ordinal*8 + ((int)ch1) - ((int)'0'); index++;
               }
            }
            retval += (char)ordinal;
            continue;
         }
         if(ch == 'u'){
            ordinal = 0;
            for(int i = 0; i < 4; i++){
               index++; ch = str.charAt(index);
               ordinal = ordinal*16+hexval(ch);
            }
            index++;
            retval += (char)ordinal;
            continue;
         }
      }
      return retval;
   }
   static int hexval(char c){
      int r = "0123456789ABCDEF".indexOf(Character.toUpperCase(c));
      if(r >= 0)return r;
      throw new RuntimeException(" ** Bad Escaped Character");
   }
  }
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>
    { if(t.image.length() > 1 && Character.toLowerCase(t.image.charAt(1)) == 'x')
          return Integer.parseInt(t.image.substring(2), 16);
      return Integer.parseInt(t.image); }
}
Integer parse_Integer():{ int i; }{
    i = parse_int() { return i; }
}
long parse_long():{ Token t; }{
    t = <INT>
    { if(t.image.length() > 1 && Character.toLowerCase(t.image.charAt(1)) == 'x')
          return Long.parseLong(t.image.substring(2), 16);
    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 unescape(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 unescape(t.image.substring(1,t.image.length()-1)).charAt(0); }
}
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 PG_Instance parse_PG_Instance():{
     int n;
     int k;
}{
    n = parse_int()
    k = parse_int()
    { return new PG_Instance(n,k); }
}

public PG_Solution parse_PG_Solution():{
     PG_DecisionTree d;
}{
    d = parse_PG_DecisionTree()
    { return new PG_Solution(d); }
}

public PG_DecisionTree parse_PG_DecisionTree():{
}{

    { return new PG_DecisionTree(); }
}

public PG_InstancePredicate parse_PG_InstancePredicate():{
}{

    { return new PG_InstancePredicate(); }
}

public PG_InstancePredicateInterface parse_PG_InstancePredicateInterface():{
    PG_InstancePredicateInterface sup = null;
}{
(  { return sup; } )
}

public PG_ClaimInterface parse_PG_ClaimInterface():{
    PG_ClaimInterface sup = null;
}{
(  { return sup; } )
}

public PG_ValidInterface parse_PG_ValidInterface():{
    PG_ValidInterface sup = null;
}{
(  { return sup; } )
}

public PG_Claim parse_PG_Claim():{
     int n;
     int k;
     int q;
}{
    "HSR"
    n = parse_int()
    k = parse_int()
    "<="
    q = parse_int()
    { return new PG_Claim(n,k,q); }
}

public PG_ValidFunction parse_PG_ValidFunction():{
}{

    { return new PG_ValidFunction(); }
}

public PG_Test parse_PG_Test():{
     PG_Instance i;
     PG_Solution s;
     PG_Claim c;
     ProtocolTest p;
}{
    i = parse_PG_Instance()
    s = parse_PG_Solution()
    c = parse_PG_Claim()
    p = parse_ProtocolTest()
    <EOF>
    { return new PG_Test(i,s,c,p); }
}







public SCG_Playground parse_SCG_Playground():{
     SCG_Domain d;
     SCG_Protocol p;
     SCG_Claim claim;
}{
    d = parse_SCG_Domain()
    p = parse_SCG_Protocol()
    claim = parse_SCG_Claim()
    { return new SCG_Playground(d,p,claim); }
}

public SCG_Domain parse_SCG_Domain():{
     SCG_Instance i;
     SCG_Solution s;
     SCG_ValidFunction valid;
     SCG_QualityFunction quality;
}{
    i = parse_SCG_Instance()
    s = parse_SCG_Solution()
    valid = parse_SCG_ValidFunction()
    quality = parse_SCG_QualityFunction()
    { return new SCG_Domain(i,s,valid,quality); }
}

public SCG_Instance parse_SCG_Instance():{
}{
    "in"
    "pg.cd:"
    "PG_Instance"
    { return new SCG_Instance(); }
}

public SCG_Solution parse_SCG_Solution():{
}{
    "in"
    "pg.cd:"
    "PG_Solution"
    { return new SCG_Solution(); }
}

public SCG_Claim parse_SCG_Claim():{
     SCG_ProtocolName protocol;
     SCG_IntExt setOfInstances;
}{
    protocol = parse_SCG_ProtocolName()
    setOfInstances = parse_SCG_IntExt()
    "in"
    "pg.cd:"
    "PG_Claim"
    { return new SCG_Claim(protocol,setOfInstances); }
}

public SCG_ProtocolName parse_SCG_ProtocolName():{
     ident v;
}{
    v = parse_ident()
    { return new SCG_ProtocolName(v); }
}

public SCG_IntExt parse_SCG_IntExt():{
    SCG_IntExt sup = null;
}{
(   sup = parse_SCG_Intensional() { return sup; } | 
    sup = parse_SCG_Extensional() { return sup; } )
}

public SCG_Intensional parse_SCG_Intensional():{
     SCG_InstancePredicate p;
}{
    p = parse_SCG_InstancePredicate()
    { return new SCG_Intensional(p); }
}

public SCG_Extensional parse_SCG_Extensional():{
     List<PG_Instance> is;
}{
    is = parse_List$PG_Instance$()
    { return new SCG_Extensional(is); }
}

public ProtocolTest parse_ProtocolTest():{
     List<SCG_Protocol> ps;
}{
    ps = parse_List$SCG_Protocol$()
    <EOF>
    { return new ProtocolTest(ps); }
}

public SCG_Protocol parse_SCG_Protocol():{
     SCG_ProtocolName pn;
     Option<ClaimSetName> claimSetName;
     List<VariableDeclaration> variableDeclarations;
     List<ProtocolStep> protocolSteps;
     Predicate predicate;
}{
    "protocol"
    pn = parse_SCG_ProtocolName()
    claimSetName = parse_Option$ClaimSetName$()
    "variables"
    variableDeclarations = parse_List$VariableDeclaration$()
    protocolSteps = parse_List$ProtocolStep$()
    "predicate"
    predicate = parse_Predicate()
    { return new SCG_Protocol(pn,claimSetName,variableDeclarations,protocolSteps,predicate); }
}

public ProtocolStep parse_ProtocolStep():{
     StepName stepName;
     ScholarName scholar;
     List<VariableBinding> variableBindings;
}{
    "step"
    stepName = parse_StepName()
    scholar = parse_ScholarName()
    variableBindings = parse_List$VariableBinding$()
    { return new ProtocolStep(stepName,scholar,variableBindings); }
}

public VariableBinding parse_VariableBinding():{
    VariableBinding sup = null;
}{
(   sup = parse_SecretBinding() { return sup; } | 
    sup = parse_RegularBinding() { return sup; } )
}

public VariableDeclaration parse_VariableDeclaration():{
     VariableType variableType;
     VariableName variableName;
}{
    "declare"
    variableType = parse_VariableType()
    variableName = parse_VariableName()
    { return new VariableDeclaration(variableType,variableName); }
}

public Predicate parse_Predicate():{
     List<VariableName> args;
     JavaCode code;
}{
    args = parse_List$VariableName$()
    code = parse_JavaCode()
    { return new Predicate(args,code); }
}

public SecretBinding parse_SecretBinding():{
     StepName sn;
     VariableName varName;
}{
    "secret"
    "until"
    sn = parse_StepName()
    varName = parse_VariableName()
    { return new SecretBinding(sn,varName); }
}

public RegularBinding parse_RegularBinding():{
     VariableName varName;
}{
    varName = parse_VariableName()
    { return new RegularBinding(varName); }
}

public ProtocolName parse_ProtocolName():{
     ident v;
}{
    v = parse_ident()
    { return new ProtocolName(v); }
}

public StepName parse_StepName():{
     ident v;
}{
    v = parse_ident()
    { return new StepName(v); }
}

public VariableName parse_VariableName():{
     ident v;
}{
    v = parse_ident()
    { return new VariableName(v); }
}

public VariableType parse_VariableType():{
     ident v;
}{
    v = parse_ident()
    { return new VariableType(v); }
}

public JavaCode parse_JavaCode():{
     verbatim v;
}{
    v = parse_verbatim()
    { return new JavaCode(v); }
}

public ScholarName parse_ScholarName():{
     ident v;
}{
    v = parse_ident()
    { return new ScholarName(v); }
}

public ClaimSetName parse_ClaimSetName():{
     ident v;
}{
    "claim"
    "set"
    "name"
    v = parse_ident()
    { return new ClaimSetName(v); }
}

public SCG_InstancePredicate parse_SCG_InstancePredicate():{
     PG_InstancePredicate belongs;
}{
    belongs = parse_PG_InstancePredicate()
    { return new SCG_InstancePredicate(belongs); }
}

public SCG_ValidFunction parse_SCG_ValidFunction():{
    SCG_ValidFunction sup = null;
}{
(  { return sup; } )
}

public SCG_QualityFunction parse_SCG_QualityFunction():{
    SCG_QualityFunction sup = null;
}{
(  { return sup; } )
}

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

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

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

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

    { return new Empty<VariableDeclaration>(); }
}
public Cons<VariableDeclaration> parse_Cons$VariableDeclaration$():{
     VariableDeclaration first;
     List<VariableDeclaration> rest;
}{
    first = parse_VariableDeclaration()
    rest = parse_List$VariableDeclaration$()
    { return new Cons<VariableDeclaration>(first,rest); }
}
public Option<ClaimSetName> parse_Option$ClaimSetName$():{
    Option<ClaimSetName> sup = null;
}{
(   sup = parse_Some$ClaimSetName$() { return sup; } | 
    sup = parse_None$ClaimSetName$() { return sup; } )
}
public None<ClaimSetName> parse_None$ClaimSetName$():{
}{

    { return new None<ClaimSetName>(); }
}
public Some<ClaimSetName> parse_Some$ClaimSetName$():{
     ClaimSetName just;
}{
    just = parse_ClaimSetName()
    { return new Some<ClaimSetName>(just); }
}
public List<SCG_Protocol> parse_List$SCG_Protocol$():{
    List<SCG_Protocol> sup = null;
}{
(   sup = parse_Cons$SCG_Protocol$() { return sup; } | 
    sup = parse_Empty$SCG_Protocol$() { return sup; } )
}
public Empty<SCG_Protocol> parse_Empty$SCG_Protocol$():{
}{

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

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