-- JunoSyntaxImpl.mesa
-- June 6, 1983 2:06 pm
-- GNelson
-- Last Edited by: Gnelson, December 10, 1983 11:19 pm

DIRECTORY JunoSyntax, Rope, Atom, Lisp;

JunoSyntaxImpl: PROGRAM IMPORTS Atom, Lisp EXPORTS JunoSyntax =

BEGIN OPEN JunoSyntax, Lisp;

Gensym: PUBLIC PROC RETURNS [Lisp.Value] = {RETURN[Atom.Gensym[]]};

IsVar: PUBLIC PROC[v: Lisp.Value] RETURNS [BOOL] = 
 {RETURN[ISTYPE[v, ATOM]]};

foo: PUBLIC ATOM _ Atom.Gensym[];

IsProcDef: PUBLIC PROC[v:Lisp.Value] RETURNS [BOOL] =
  {RETURN [Car[v] = proc]};
BodyOfProcDef: PUBLIC PROC[v:ProcDef] RETURNS [Command] =
  {RETURN [Caddr[Cadr[v]]]};
ProcOfProcDef: PUBLIC PROC[v:ProcDef] RETURNS [ProcName] =
  {v _ Cadr[v]; -- Now v is a ProcDef
   v _ Cadr[v]; -- Now v is a ProcDef1
   IF Pair[v] AND Car[v] = colon THEN v _ Cadr[v]; -- Now v is a ProcDef2
   IF Pair[v] AND Car[v] = leftpren THEN RETURN[Cadr[v]] ELSE RETURN [v]};
Varlist1OfProcDef: PUBLIC PROC[v:ProcDef] RETURNS [Varlist] =
   {v _ Cadr[v]; -- Now v is a ProcDef
    v _ Cadr[v]; -- Now v is a ProcDef1
    IF Pair[v] AND Car[v] = colon 
    THEN RETURN[Linearize[Cadr[v], comma]]
    ELSE RETURN [NIL]};
Varlist2OfProcDef: PUBLIC PROC[v:ProcDef] RETURNS [Varlist] =
  {v _ Cadr[v]; -- Now v is a ProcDef
   v _ Cadr[v]; -- Now v is a ProcDef1
   IF Pair[v] AND Car[v] = colon THEN v _ Cadr[v]; -- Now v is a ProcDef2
   IF Pair[v] THEN RETURN[Linearize[Caddr[v], comma]]
   ELSE RETURN[NIL]};

IsFunDef: PUBLIC PROC[v:Value] RETURNS [BOOL] =
  {RETURN [Car[v] = func]};
BodyOfFunDef: PUBLIC PROC[v:FunDef] RETURNS [Formula] =
  {RETURN [Caddr[Cadr[v]]]};
FunOfFunDef: PUBLIC PROC[v:FunDef] RETURNS [FunName] =
   {v _ Cadr[v]; -- Now v is a FunDef
    v _ Cadr[v]; -- Now v is a FunDef1
    v _ Cadr[v]; -- Now v is a FunDef2
    IF Pair[v] THEN RETURN [Cadr[v]] ELSE RETURN[v]};
VarlistOfFunDef: PUBLIC PROC[v:FunDef] RETURNS [Varlist] =
   {v _ Cadr[v]; -- Now v is a FunDef
    v _ Cadr[v]; -- Now v is a FunDef1
    v _ Cadr[v]; -- Now v is a FunDef2
    IF Pair[v] THEN RETURN [Linearize[Caddr[v], comma]] ELSE RETURN[NIL]};
ResultnameOfFunDef: PUBLIC PROC[v:FunDef] RETURNS [Variable] =
   {RETURN [Caddr[Cadr[Cadr[v]]]]};

IsPredDef: PUBLIC PROC[v:Value] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = pred]};
BodyOfPredDef: PUBLIC PROC[v:PredDef] RETURNS [Formula] =
   {RETURN [Caddr[Cadr[v]]]};
PredOfPredDef: PUBLIC PROC[v:PredDef] RETURNS [PredName] =
   {RETURN [Cadr[Cadr[Cadr[v]]]]};
VarlistOfPredDef: PUBLIC PROC[v:PredDef] RETURNS [Varlist] =
   {RETURN [Linearize[Caddr[Cadr[Cadr[v]]], comma]]};

IsConjunction: PUBLIC PROC[v:Formula] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = and]};
LHSOfConjunction: PUBLIC PROC[v:Formula] RETURNS [Formula] =
   {RETURN [Cadr[v]]};
RHSOfConjunction: PUBLIC PROC[v:Formula] RETURNS [Formula] =
   {RETURN [Caddr[v]]};

IsParenthesized: PUBLIC PROC[v:Value] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = leftpren AND Cdr[Cdr[v]] = NIL]};
ContentsOfParentheses: PUBLIC PROC[v:Value] RETURNS [Value] =
   {RETURN [Cadr[v]]};

IsQuantification: PUBLIC PROC[v:Formula] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = ex]};
QuantifierOfQuantification: PUBLIC PROC[v:Formula] RETURNS [Value] =
   {RETURN [Car[v]]};  -- someday there may be "for all".
QuantifieeOfQuantification: PUBLIC PROC[v:Formula] RETURNS [Formula] =
   {RETURN [Caddr[Cadr[v]]]};
QuantifierVarlistOfQuantification: PUBLIC PROC[v:Formula] RETURNS [Varlist] =
   {RETURN [Linearize[Cadr[Cadr[v]], comma]]};

IsAtomicFormula: PUBLIC PROC[v:Formula] RETURNS [BOOL] =
   {RETURN [TRUE]};
PredOfAtomicFormula: PUBLIC PROC[v:Formula] RETURNS [PredName] =
   {RETURN [SELECT TRUE FROM 
                  v = true OR v = false => v,
                  Pair[Car[v]] => Car[v],
                  Car[v] = leftpren => Cadr[v],
                  Car[v] = ltop => lt,
                  Car[v] = gtop => gt,
                  Car[v] = leop => le,
                  Car[v] = geop => ge,
                  Car[v] = eq => eq,
                  Car[v] = neq => neq,
                ENDCASE => ERROR]};
TermlistOfAtomicFormula: PUBLIC PROC[v:Formula] RETURNS [Termlist] =
   {RETURN  [SELECT TRUE FROM 
                  v = true OR v = false => NIL,
                  Pair[Car[v]] => Cdr[v],
                  Car[v] = leftpren => Linearize[Caddr[v], comma],
                  Memq[Car[v], LIST[ltop, gtop, leop, geop, eq, neq]] => Cdr[v]
                ENDCASE => ERROR]};
MakeAtomicFormula: PUBLIC PROC[p: PredName, tl: Termlist] RETURNS [Formula] =
   {RETURN [Cons[leftpren, Cons[p, Cons[Unlinearize[tl, comma], NIL]]]]};

IsTerm: PUBLIC PROC[v:Value] RETURNS [BOOL] =
   {RETURN [TRUE]};
FunctionOfTerm: PUBLIC PROC[v:Term] RETURNS [FunName] =
   {RETURN [SELECT TRUE FROM
   			   NOT Pair[v] => v,
   			   Car[v] = leftpren AND Cddr[v] # NIL => Cadr[v],
   			   Car[v] = plusop => plus,
   			   Car[v] = minusop => minus,
   			   Car[v] = timesop => times,
   			   Car[v] = divideop => divide,
   			   Car[v] = div => div,
   			   Car[v] = cons => cons,
      			 -- cons is needed because of Fix below
   			   Car[v] = leftpren AND Cddr[v] = NIL AND Pair[Caddr[v]]
   			   AND Car[Caddr[v]] = comma => cons,
   			   Car[v] = leftpren AND Cddr[v] = NIL => FunctionOfTerm[Cadr[v]],
   			   Car[v] = leftbracket => cons,
                ENDCASE => Car[v]]};
TermlistOfTerm: PUBLIC PROC[v:Term] RETURNS [Termlist] =
   {RETURN [SELECT TRUE FROM
   			   NOT Pair[v] => NIL,
   			   Car[v] = leftpren AND Cddr[v] # NIL => Linearize[Caddr[v], comma],
                  Car[v] = minus AND Cddr[v] = NIL => LIST[NEW[INT _ 0], Cadr[v]],
   			   Memq[Car[v], LIST[plusop, minusop, timesop, divideop, div, cons]] => Cdr[v],
   			   Car[v] = leftpren AND Cddr[v] = NIL AND Pair[Caddr[v]]
   			   AND Car[Caddr[v]] = comma => Linearize[Caddr[v], comma],
   			   Car[v] = leftpren AND Cddr[v] = NIL => TermlistOfTerm[Cadr[v]],
   			   Car[v] = leftbracket => Fix[Linearize[Cadr[v], comma]]
      		 ENDCASE => Cdr[v]]};

Fix: PROC[l: REF] RETURNS [Termlist] = {
  IF Cdr[l] = NIL THEN RETURN [LIST[Car[l], NIL]]
  ELSE RETURN [LIST[Car[l], Cons[cons, Fix[Cdr[l]]]]]};

IsConstant: PUBLIC PROC[v:Value] RETURNS [BOOL] =
  {RETURN[ISTYPE[v, REF INT] OR ISTYPE[v, REF REAL] 
          OR ISTYPE[v, ATOM] OR ISTYPE[v, Rope.ROPE] OR ISTYPE[v, REF TEXT]]};

IsSkip: PUBLIC PROC[v:Value] RETURNS [BOOL] =
   {RETURN [v = $Skip]};

IsAbort: PUBLIC PROC[v:Value] RETURNS [BOOL] =
   {RETURN [v = $Abort]};

IsComposition: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = semicolon]};
LHSOfComposition: PUBLIC PROC[v:GuardedCommand] RETURNS [Command] =
   {RETURN [Cadr[v]]};
RHSOfComposition: PUBLIC PROC[v:GuardedCommand] RETURNS [Command] =
   {RETURN [Caddr[v]]};

IsSuchthatCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = st]};
VarlistOfSuchthatCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [Varlist] =
   {RETURN [Linearize[Cadr[v], comma]]};
PredOfSuchthatCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [Formula] =
   {RETURN [Caddr[v]]};

IsAssignmentCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = assign]};
VarlistOfAssignmentCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [Varlist] =
   {RETURN [Linearize[Cadr[v], comma]]};
TermlistOfAssignmentCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [Termlist] =
   {RETURN [Linearize[Caddr[v], comma]]};

IsProcCall: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [NOT Pair[v] OR Car[v] = colon OR Car[v] = leftpren]};
ProcOfProcCall: PUBLIC PROC[v:GuardedCommand] RETURNS [ProcName] =
   {SELECT TRUE FROM
     NOT Pair[v] => RETURN[v];
     Car[v] = colon AND Pair[Caddr[v]] => RETURN[Cadr[Caddr[v]]];
     Car[v] = colon => RETURN[Caddr[v]];
     Car[v] = leftpren => RETURN[Cadr[v]];
    ENDCASE => ERROR};
VarlistOfProcCall: PUBLIC PROC[v:GuardedCommand] RETURNS [Varlist] =
   {SELECT TRUE FROM
     NOT Pair[v] => RETURN[NIL];
     Car[v] = colon AND Pair[Caddr[v]] => RETURN[Linearize[Cadr[v], comma]];
     Car[v] = colon => RETURN[Linearize[Cadr[v], comma]];
     Car[v] = leftpren => RETURN[NIL];
    ENDCASE => ERROR};
TermlistOfProcCall: PUBLIC PROC[v:GuardedCommand] RETURNS [Termlist] =
   {SELECT TRUE FROM
     NOT Pair[v] => RETURN[NIL];
     Car[v] = colon AND Pair[Caddr[v]] => RETURN[Linearize[Caddr[Caddr[v]], comma]];
     Car[v] = colon => RETURN[NIL];
     Car[v] = leftpren => RETURN[Linearize[Caddr[v], comma]];
   ENDCASE => ERROR};

IsAlternatingCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = if]};
BodyOfAlternatingCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [GuardedCommand] =
   {RETURN [Cadr[v]]};

IsIterativeCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = do]};
BodyOfIterativeCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [GuardedCommand] =
   {RETURN [Cadr[v]]};

IsCompoundGuardedCommand: 
  PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND Car[v] = elseif]};
LHSOfCompoundGuardedCommand: 
  PUBLIC PROC[v:GuardedCommand] RETURNS [GuardedCommand] =
   {RETURN [Cadr[v]]};
RHSOfCompoundGuardedCommand: 
  PUBLIC PROC[v:GuardedCommand] RETURNS [GuardedCommand] =
   {RETURN [Caddr[v]]};

IsSimpleGuardedCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [BOOL] =
   {RETURN [Pair[v] AND NOT Car[v] = elseif]};
PredOfSimpleGuardedCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [PredName] =
   {RETURN [IF Pair[Cadr[v]] AND Car[Cadr[v]] = colon 
                THEN Caddr[Cadr[v]]
                ELSE Cadr[v]]};
CommandOfSimpleCommand: PUBLIC PROC[v:GuardedCommand] RETURNS [Command] =
   {RETURN [Caddr[v]]};
VarlistOfSimpleGuardedCommand: PUBLIC PROC[v:GuardedCommand] RETURNS  [Varlist] =
   {RETURN [IF Pair[Cadr[v]] AND Car[Cadr[v]] = colon 
                THEN Linearize[Cadr[Cadr[v]], comma]
                ELSE NIL]};

KernelPredicate: PUBLIC PROC [p: PredName] RETURNS [BOOLEAN] 
 = {-- IF ISTYPE[p, REF INT] OR ISTYPE[p, REF REAL] THEN RETURN[TRUE];
    IF p = $T OR  p = $F THEN RETURN [TRUE];
    IF Pair[p] AND Car[p] = constant THEN RETURN[TRUE];
    SELECT p FROM
     eq, neq, PairOf, isPositive, isSumOf, isProductOf => RETURN[TRUE]
    ENDCASE => RETURN[FALSE]};

leftpren: PUBLIC ATOM _ Atom.MakeAtom["("];
colon: PUBLIC ATOM _ Atom.MakeAtom[":"];
semicolon: PUBLIC ATOM _ Atom.MakeAtom[";"];
comma: PUBLIC ATOM _ Atom.MakeAtom[","];
assign: PUBLIC ATOM _ Atom.MakeAtom[":="];
eq: PUBLIC ATOM _ Atom.MakeAtom["="];
neq: PUBLIC ATOM _ Atom.MakeAtom["neq"];
lt: PUBLIC ATOM _ Atom.MakeAtom["Less"];
gt: PUBLIC ATOM _ Atom.MakeAtom["Greater"];
le: PUBLIC ATOM _ Atom.MakeAtom["LessEq"];
ge: PUBLIC ATOM _ Atom.MakeAtom["GreaterEq"];
ltop: PUBLIC ATOM _ Atom.MakeAtom["<"];
gtop: PUBLIC ATOM _ Atom.MakeAtom[">"];
leop: PUBLIC ATOM _ Atom.MakeAtom["le"];
geop: PUBLIC ATOM _ Atom.MakeAtom["ge"];
do: PUBLIC ATOM _ Atom.MakeAtom["do"];
if: PUBLIC ATOM _ Atom.MakeAtom["if"];
abort: PUBLIC ATOM _ Atom.MakeAtom["Abort"];
skip: PUBLIC ATOM _ Atom.MakeAtom["Skip"];
st: PUBLIC ATOM _ Atom.MakeAtom["st"];
elseif: PUBLIC ATOM _ Atom.MakeAtom["elseif"];
then: PUBLIC ATOM _ Atom.MakeAtom["then"];
and: PUBLIC ATOM _ Atom.MakeAtom["and"];
ex: PUBLIC ATOM _ Atom.MakeAtom["ex"];
para: PUBLIC ATOM _ Atom.MakeAtom["para"];
cong: PUBLIC ATOM _ Atom.MakeAtom["cong"];
perp: PUBLIC ATOM _ Atom.MakeAtom["perp"];
means: PUBLIC ATOM _ Atom.MakeAtom["means"];
plusop: PUBLIC ATOM _ Atom.MakeAtom["+"];
minusop: PUBLIC ATOM _ Atom.MakeAtom["-"];
timesop: PUBLIC ATOM _ Atom.MakeAtom["*"];
divideop: PUBLIC ATOM _ Atom.MakeAtom["/"];
plus: PUBLIC ATOM _ Atom.MakeAtom["plus"];
minus: PUBLIC ATOM _ Atom.MakeAtom["minus"];
times: PUBLIC ATOM _ Atom.MakeAtom["times"];
divide: PUBLIC ATOM _ Atom.MakeAtom["divide"];
div: PUBLIC ATOM _ Atom.MakeAtom["div"];

implies: PUBLIC ATOM _ Atom.MakeAtom["implies"];
or: PUBLIC ATOM _ Atom.MakeAtom["or"];
dot: PUBLIC ATOM _ Atom.MakeAtom["."];
rel: PUBLIC ATOM _ Atom.MakeAtom["rel"];
leftbracket: PUBLIC ATOM _ Atom.MakeAtom["["];
fi: PUBLIC ATOM _ Atom.MakeAtom["fi"];
od: PUBLIC ATOM _ Atom.MakeAtom["od"];
rightpren: PUBLIC ATOM _ Atom.MakeAtom[")"];
rightbracket: PUBLIC ATOM _ Atom.MakeAtom["]"];

quote: PUBLIC ATOM _ Atom.MakeAtom["quote"];
isPositive: PUBLIC ATOM _ Atom.MakeAtom["isPositive"];
isProductOf: PUBLIC ATOM _ Atom.MakeAtom["IsProductOf"];
PairOf: PUBLIC ATOM _ Atom.MakeAtom["PairOf"];
isSumOf: PUBLIC ATOM _ Atom.MakeAtom["IsSumOf"];
constant: PUBLIC ATOM _ Atom.MakeAtom["constant"];
cons: PUBLIC ATOM _ Atom.MakeAtom["cons"];
car: PUBLIC ATOM _ Atom.MakeAtom["car"];
cdr: PUBLIC ATOM _ Atom.MakeAtom["cdr"];
proc: PUBLIC ATOM _ Atom.MakeAtom["proc"];
pred: PUBLIC ATOM _ Atom.MakeAtom["pred"];
func: PUBLIC ATOM _ Atom.MakeAtom["func"];
isPairOf: PUBLIC ATOM _ Atom.MakeAtom["isPairOf"];
true: PUBLIC ATOM _ Atom.MakeAtom["T"];
false: PUBLIC ATOM _ Atom.MakeAtom["F"];





--
: PUBLIC ATOM _ Atom.MakeAtom["
"];

END.