/* Sentences */

sentence(S) --> declarative(S), terminator(.) .
sentence(S) --> wh_question(S), terminator(?) .
sentence(S) --> yn_question(S), terminator(?) .
sentence(S) --> imperative(S), terminator(!) .

/* Declarative sentence */

declarative(decl(S)) --> s(S,_).

/* Wh-questions */

wh_question(whq(X,S)) -->
   variable_q(X,_,QCase,NPCase),
   question(QCase,NPCase,S).

variable_q(X,Agmt,QCase,NPCase) ...
      np(NP,Agmt,NPCase,_,_,Set,Mask) -->
   whq(X,Agmt,NP,QCase),
   {trace(Set,Mask)}.
variable_q(X,Agmt,compl,CCase) ...
 pp(pp(Prep,NP),compl,Set,Mask) -->
   prep(Prep),
   whq(X,Agmt,NP,_),
   {trace(Set,Mask), compl_case(CCase)}.
variable_q(X,Agmt,compl,VCase) ...
      adv_phrase(pp(Prep,
                  np(Agmt,
                   np_head(
                    int_det(X),[],Noun),[])),
                 Set,Mask) -->
   context_pron(Prep,Noun),
   {trace(Set,Mask), verb_case(VCase)}.
variable_q(X,_,compl,VCase) ... 
      pred(adj,value(Adj,wh(X)),Mask) -->
   [how],
   adj(quant,Adj),
   {empty(Mask), verb_case(VCase)}.

whq(X,Agmt,NP,undef) -->
   int_det(X,Agmt),
   {s_all(SAll)},
   np(NP,Agmt,_,_,subj,SAll,_).
whq(X,3+No,np(3+No,wh(X),[]),Case) --> int_pron(Case).

int_det(X,3+Agmt) --> whose(X,Agmt).
int_det(X,3+Agmt) --> int_art(X,Agmt).

whose(X,Agmt), np_head0(wh(X),Agmt,proper), gen_marker --> [whose].

question(QCase,NPCase,S) -->
   {subj_question(QCase), role(subj,_,NPCase)},
   s(S,_).
question(QCase,NPCase,S) -->
   fronted_verb(QCase,NPCase),
   s(S,_).

int_art(X,Agmt), det(DX,Agmt,def) --> int_art(X,Agmt,DX).

subj_qustion(subj).
subj_question(undef).

/* Yes-no questions */

yn_question(q(S)) -->
   fronted_verb(nil,_),
   s(S,_).

fronted_verb(QCase,NPCase) ... 
      verb_form(Root,Tense,Agmt,Role), neg(_,Neg) -->
   verb_form(Root,Tense,Agmt,_),
   {verb_type(Root,aux+_),
    role(QCase,Role,NPCase)},
   neg(_,Neg).

/* Imperative sentences */

imperative(imp(S)) -->
   imperative_verb,
   s(S,_).

imperative_verb,
   [you],
   verb_form(Root,imp+fin,2+sin,main) -->
   verb_form(Root,inf,_,_).

/* Basic sentence (actually, declarative sentence) */

s(s(Subj,Verb,Args,Mods),Mask) -->
   subj(Subj,Agmt,Type),
   verb(Verb,Agmt,Type,Voice),
   {empty(Nil), s_all(SAll)},
   verb_args(Type,Voice,Args,Nil,Mask0),
   {minus(SAll,Mask0,Set), plus(SAll,Mask0,Mask1)},
   verb_mods(Mods,Set,Mask1,Mask).

subj(there,Agmt,_+be) --> [there].
subj(Subj,Agmt,_) -->
   {s_all(SAll), subj_case(Case)},
   np(Subj,Agmt,Case,_,subj,SAll,_).

/* Noun Phrase */

np(np(Agmt,Pronoun,[]),Agmt,NPCase,def,_,Set,Nil) -->
   {is_pp(Set)},
   pers_pron(Pronoun,Agmt,Case),
   {empty(Nil), role(Case,decl,NPCase)}.
np(np(Agmt,Kernel,Mods),Agmt,Case,Def,Role,Set,Mask) -->
   {is_pp(Set)},
   np_head(Kernel,Agmt,Def+Type,PostMods,Mods),
   {np_all(NPAll)},
   np_compls(Type,Agmt,Role,PostMods,NPAll,Mask).
np(part(Det,NP),3+Number,_,indef,Role,Set,Mask) -->
   {is_pp(Set)},
   determiner(Det,Number,indef),
   [of],
   {s_all(SAll), prep_case(Case)},
   np(NP,3+plu,Case,def,Role,SAll,Mask).

np_head(Kernel,Agmt,Type,PostMods,Mods) -->
   np_head0(Kernel0,Agmt0,Type0),
   possessive(Kernel0,Agmt0,Type0,Mods0,Mods0,
              Kernel,Agmt,Type,PostMods,Mods).

np_compls(proper,_,_,[],_,Nil) --> {empty(Nil)}.
np_compls(common,Agmt,Case,Mods,Set0,Mask) -->
   {np_all(NPAll)},
   np_mods(Agmt,Case,Rel,Mods,Set0,Set,NPAll,Mask0),
   relative(Agmt,Rel,Set,Mask0,Mask).

/* Nuclear noun phrase */

np_head0(name(Name),3+sin,def+proper) --> name(Name).
np_head0(np_head(Det,Adjs,Head),3+Number,Def+common) -->
   determiner(Det,Number,Def),
   adjs(Adjs),
   noun(Head,Number).
np_head0(Pronoun,Agmt,def+proper), gen_marker -->
   poss_pron(Pronoun,Agmt).
np_head0(np_head(Det,[],Noun),3+sin,indef+common) -->
   quantifier_pron(Det,Noun).

/* Possessive construction */

possessive(Kernel0,Agmt0,_,[],Mods0,
           Kernel,Agmt,Type,PostMods,Mods) -->
   gen_case,
   np_head0(Kernel1,Agmt1,Type1),
   possessive(Kernel1,Agmt1,Type1,PostMods1,
              [pp(poss,np(Agmt0,Kernel0,Mods0))|PostMods1],
              Kernel,Agmt,Type,PostMods,Mods).
possessive(Kernel,Agmt,Type,PostMods,Mods,
           Kernel,Agmt,Type,PostMods,Mods) --> [].

gen_case, [the] --> gen_marker.

gen_marker --> [''''], an_s.

an_s --> [s].
an_s --> [].

/* Determiners */

determiner(Det,Number,Def) --> det(Det,Number,Def).
determiner(Det,Number,Def) --> quant_phrase(Det,Number,Def).

quant_phrase(quant(Op,Quant),Number,Def) -->
   quant(Op,Def),
   number(Quant,Number).

quant(Op,indef) -->
   neg_adv(Op0,Op),
   comp_adv(Op0),
   [than].
quant(Op,indef) -->
   [at],
   sup_adv(Adv),
   {sup_op(Adv,Op)}.
quant(the,def) --> [the].
quant(same,indef) --> [].

neg_adv(Adv,not+Adv) --> [not].
neg_adv(Adv,Adv) --> [].

sup_op(least,not+less).
sup_op(most,not+more).

/* Noun phrase modifiers */

np_mods(Agmt,Case,Mods0,[Mod|Mods],Set0,Set,_,Mask) -->
   np_mod(Agmt,Case,Mod,Set0,Mask0),
   {trace(Trace), plus(Trace,Mask0,Mask1), minus(Set0,Mask1,Set1),
    plus(Mask0,Set0,Mask2)},
   np_mods(Agmt,Case,Mods0,Mods,Set1,Set,Mask2,Mask).
np_mods(_,_,Mods,Mods,Set,Set,Mask,Mask) --> [].

np_mod(_,Case,PP,Set,Mask) --> pp(PP,Case,Set,Mask).
np_mod(Agmt,Case,WH,Set,Mask) -->
   reduced_relative(Agmt,WH,Set,Mask).

/* Verb modifiers */

verb_mods([Mod|Mods],Set0,_,Mask) -->
   verb_mod(Mod,Set0,Mask0),
   {trace(Trace), plus(Trace,Mask0,Mask1), minus(Set0,Mask1,Set1),
    plus(Mask0,Set0,Mask2)},
   verb_mods(Mods,Set1,Mask2,Mask).
verb_mods([],_,Mask,Mask) --> [].

verb_mod(Adv,Set,Mask) --> adv_phrase(Adv,Set,Mask).
verb_mod(Adv,Set,Nil) -->
   {is_adv(Set)},
   adverb(Adv),
   {empty(Nil)}.
verb_mod(PP,Set,Mask) --> pp(PP,compl,Set,Mask).

adv_phrase(pp(Prep,NP),Set,Mask) -->
   loc_pred(Prep),
   pp(pp(prep(of),NP),compl,Set,Mask).

/* Adjectival Constructions */

adjs([Adj|Adjs]) -->
   pre_adj(Adj),
   adjs(Adjs).
adjs([]) --> [].

pre_adj(Adj) --> adj(_,Adj).
pre_adj(Adj) -->  sup_phrase(Adj).

sup_phrase(sup(most,Adj)) --> sup_adj(Adj).
sup_phrase(sup(Op,Adj)) -->
   sup_adv(Adv),
   adj(quant,Adj).

comp_phrase(comp(Comp,Adj,Arg),Mask) -->
   comp(Comp,Adj),
   {np_no_trace(NPNT), prep_case(Case)},
   np(Arg,_,Case,_,compl,NPNT,Mask).

comp(Comp,Adj) -->
   comp_adv(Comp),
   adj(quant,Adj),
   [than].
comp(more,Adj) -->
   rel_adj(Adj),
   [than].
comp(same,Adj) -->
   [as],
   adj(quant,Adj),
   [as].

/* Prepositional Phrase */

pp(pp(Prep,Arg),Case,Set,Mask) -->
   prep(Prep),
   {prep_case(NPCase)},
   np(Arg,_,NPCase,_,Case,Set,Mask).

/* Relative clause */

relative(Agmt,[Rel],Set,_,Mask) -->
   {is_pred(Set)},
   rel_conj(Agmt,Conj,Rel,Mask).
relative(_,[],_,Mask,Mask) --> [].

rel_conj(Agmt,Conj,Rel,Mask) -->
   rel(Agmt,Rel0,Mask0),
   rel_rest(Agmt,Conj,Rel0,Rel,Mask0,Mask).

rel_rest(Agmt,Conj0,Rel0,Rel,_,Mask) -->
   conj(Conj0,Conj,Rel0,Rel1,Rel),
   rel_conj(Agmt,Conj,Rel1,Mask).
rel_rest(_,_,Rel,Rel,Mask,Mask) --> [].

rel(Agmt,rel(X,S),Mask) -->
   island,
   variable(Agmt,X),
   s(S,Mask0),
   {trace(Trace), minus(Mask0,Trace,Mask)},
   dnalsi.

variable(Agmt,X) ... np(np(Agmt,wh(X),[]),Agmt,_,_,_,Set,Mask) -->
   [that],
   {trace(Set,Mask)}.
variable(Agmt0,X) ... np(NP,Agmt,NPCase,_,_,Set,Mask) -->
   wh(X,Agmt0,NP,Agmt,NPCase),
   {trace(Set,Mask)}.
variable(Agmt0,X) ... pp(pp(Prep,NP),compl,Set,Mask) -->
   prep(Prep),
   wh(X,Agmt0,NP,Agmt,Case),
   {trace(Set,Mask), compl_case(Case)}.

wh(X,Agmt,np(Agmt,wh(X),[]),Agmt,NPCase) -->
   rel_pron(Case),
   {role(Case,decl,NPCase)}.
wh(X,Agmt0,np(Agmt,Kernel,[pp(Prep,NP)]),Agmt,_) -->
   np_head0(Kernel,Agmt,_+common),
   prep(Prep),
   wh(X,Agmt0,NP,_,_).
wh(X,Agmt0,NP,Agmt,Case) -->
   whose(X,Agmt0),
   {s_all(SAll)},
   np(NP,Agmt,Case,def,subj,SAll,_).

/* Reduced relative clause */

reduced_relative(Agmt,Rel,Set,Mask) -->
   {is_pred(Set)},
   reduced_rel_conj(Agmt,Conj,Rel,Mask).

reduced_rel_conj(Agmt,Conj,Rel,Mask) -->
   reduced_rel(Agmt,Rel0,Mask0),
   reduced_rel_rest(Agmt,Conj,Rel0,Rel,Mask0,Mask).

reduced_rel_rest(Agmt,Conj0,Rel0,Rel,_,Mask) -->
   conj(Conj0,Conj,Rel0,Rel1,Rel),
   reduced_rel_conj(Agmt,Conj,Rel1,Mask).
reduced_rel_rest(_,_,Rel,Rel,Mask,Mask) --> [].

reduced_rel(Agmt,reduced_rel(X,S),Mask) -->
   island,
   reduced_wh(Agmt,X),
   s(S,Mask0),
   {trace(Trace), minus(Mask0,Trace,Mask)},
   dnalsi.

reduced_wh(Agmt,X),
   np(np(Agmt,wh(X),[]),Agmt,NPCase,_,_,Set0,Mask0),
   verb_form(be,pres+fin,Agmt,main),
   neg(_,Neg),
   pred(Neg,Pred,Mask) -->
   neg(_,Neg),
   pred(Neg,Pred,Mask),
   {trace(Set0,Mask0), subj_case(NPCase)}.
reduced_wh(Agmt,X),
   np(np(Agmt,wh(X),[]),Agmt,NPCase,_,_,Set,Mask),
   verb(Verb,_,Type,Voice) -->
   participle(Verb,Type,Voice),
   {trace(Set,Mask), subj_case(NPCase)}.
reduced_wh(AgmtX,X),
   np(Subj,Agmt,SCase,Def,_,Set0,Mask0) ...
   np(np(AgmtX,wh(X),[]),AgmtX,VCase,_,_,Set,Mask) -->
   {s_all(SAll), subj_case(SCase), verb_case(VCase)},
   np(Subj,Agmt,_,Def,subj,SAll,_),
   {trace(Set0,Mask0), trace(Set,Mask)}.

/* Verb phrase (less the complements) */

verb(verb(Root,Voice,Time+fin,Aspect,Neg),Agmt,Type,Voice) -->
   verb_form(Root0,Time+fin,Agmt,Role),
   {verb_type(Root0,Type0)},
   neg(Type0,Neg),
   rest_verb(Role,Root0,Root,Voice,Aspect),
   {verb_type(Root,Type)}.

neg(aux+_,neg) --> [not].
neg(_,pos) --> [].

rest_verb(aux,have,Root,Voice,[perf|Aspect]) -->
   verb_form(Root0,past+part,_,_),
   have(Root0,Root,Voice,Aspect).
rest_verb(aux,be,Root,Voice,Aspect) -->
   verb_form(Root0,Tense0,_,_),
   be(Tense0,Root0,Root,Voice,Aspect).
rest_verb(aux,do,Root,active,[]) -->
   verb_form(Root,inf,_,_).
rest_verb(main,Root,Root,active,[]) --> [].

have(be,Root,Voice,Aspect) -->
   verb_form(Root0,Tense0,_,_),
   be(Tense0,Root0,Root,Voice,Aspect).
have(Root,Root,active,[]) --> [].

be(past+part,Root,Root,passive,[]) --> [].
be(pres+part,Root0,Root,Voice,[prog]) -->
   passive(Root0,Root,Voice).

passive(be,Root,passive) -->
   verb_form(Root,past+part,_,_),
   {verb_type(Root,Type), passive(Type)}.
passive(Root,Root,active) --> [].

participle(verb(Root,Voice,inf,Aspect,Neg),Type,Voice) -->
   neg(_,Neg),
   verb_form(Root,Tense,_,_),
   {participle(Tense,Voice,Aspect), verb_type(Root,Type)}.

passive(_+trans).
passive(_+ditrans).

participle(pres+part,active,[prog]).
participle(past+part,passive,[]).

/* Extraposition brackets */

island ... dnalsi --> [].

/* Verb Arguments */

verb_args(_+Type,Voice,AdvArgs,Mask0,Mask) -->
   advs(AdvArgs,Args,_),
   verb_args(Type,Voice,Args,Mask0,Mask).

verb_args(trans,active,[arg(dir,Dir)],_,Mask) -->
   verb_arg(np,Dir,Mask).
verb_args(ditrans,_,[arg(Case,NP)|Obj],_,Mask) -->
   verb_arg(np,NP,Mask0),
   object(Case,Obj,Mask0,Mask).
verb_args(be,_,[void],Mask,Mask) --> [there].
verb_args(be,_,[arg(pred,P)],_,Mask) -->
   pred_conj(_,P,Mask).
verb_args(be,_,[arg(dir,P)],_,Mask) --> verb_arg(np,P,Mask).
verb_args(have,active,[arg(dir,P)],_,Mask) --> verb_arg(np,P,Mask).
verb_args(Type,_,[],Mask,Mask) --> {no_args(Type)}.

object(Case,AdvArg,Mask0,Mask) -->
   {adv(Adv), minus(Adv,Mask0,Mask1)},
   advs(AdvArg,Obj,Mask1),
   obj(Case,Obj,Mask0,Mask).

obj(ind,[arg(dir,NP)],_,Mask) --> verb_arg(np,NP,Mask).
obj(dir,[],Mask,Mask) --> [].

pred_conj(Conj,Arg,Mask) -->
   pred(_,Arg0,Mask0),
   pred_rest(Conj,Arg0,Arg,Mask0,Mask).

pred_rest(Conj0,Arg0,Arg,_,Mask) -->
   conj(Conj0,Conj,Arg0,Arg1,Arg),
   pred_conj(Conj,Arg1,Mask).
pred_rest(_,Arg,Arg,Mask,Mask) --> [].

verb_arg(np,NP,Mask) -->
   {s_all(SAll), verb_case(VCase)},
   np(NP,_,VCase,_,compl,SAll,Mask).

pred(_,Adj,Mask) --> adj_phrase(Adj,Mask).
pred(neg,PP,Mask) --> 
   {s_all(SAll)},
   pp(PP,compl,SAll,Mask).
pred(_,Adv,Mask) -->
   {s_all(SAll)},
   adv_phrase(Adv,SAll,Mask).

advs([Adv|R0],R,Set) -->
   {is_adv(Set)},
   adverb(Adv),
   advs(R0,R,Set).
advs(R,R,_) --> [].

adj_phrase(P,Nil) --> adj(_,P), { empty(Nil) }.
adj_phrase(P,Mask) -->  comp_phrase(P,Mask).

no_args(trans).
no_args(ditrans).
no_args(intrans).

/* Conjunctions */

conj(conj(Conj,Ctx0),
     conj(Conj,Ctx),Left,Right,
     conj(Conj,Left,Right)) -->
   conj(Conj,Ctx0,Ctx).