resources.VP.VerbGroups.jape Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of tools Show documentation
A selection of processing resources commonly used to extend ANNIE
The newest version!
// Finite Verb Groups

Phase: FiniteVerbGroup
Input: Token
Options: control = appelt

//////////////////////////////////////////////
// MACROS

Macro: MODALS

(
{Token.string == "can"}
|
{Token.string == "could"}
|
{Token.string == "may"}
|
{Token.string == "might"}
|
{Token.string == "must"}
|
({Token.string == "ought"} {Token.string == "to"}) 
|
{Token.string == "should"}
|
{Token.string == "would"}
)

Macro: MODAL_NEG
(
 {Token.string == "cannot"}
 )
 

Macro: TO
(
({Token.string == "to"})?
)



Macro: ADVS
(
({Token.category == RB})[1,3]
)

Macro: DO
({Token.string == "do"}|{Token.string == "does"} | {Token.string == "did"})

Macro: NEGATION
(
 (DO)?
({Token.string == "not"}) |
({Token.string == "n't"}) |
({Token.string == "never"})
)

//////////////////////////////////////////////////////

// fvgnegative.jape

// Negative Verb Groups (i.e. 'not' and other adverbials)

Rule: FVGSimPreActNeg
// Simple Present Active: does not eat

(
(DO)
(NEGATION)
(
{Token.category == "VB"}
)
):annotate 
--> :annotate.VG = 
{ type = "FVG",
  tense = "SimPre",
  voice = "active",
  neg = "yes",
  rule = "FVGSimPreActNeg"}

  

Rule: FVGSimPrePasNeg
// Simple Present Passive: is not eaten
// (is | are) VBN

(

({Token.string == "is" } | { Token.string == "are" })

(NEGATION) (ADVS)?

{Token.category == "VBN"}



):annotate --> :annotate.VG = 

{ type = "FVG",
  tense = "SimPre",
  voice = "passive",
  neg = "yes",
  rule = "FVGSimPrePasNeg"
}


Rule: FVGPreConActNeg
// Present Continuous Active: is not eating
// (is | are) VBG

(

({Token.string == "is"} | {Token.string == "are"})

(NEGATION) (ADVS)?

{Token.category == "VBG"}


):annotate -->
:annotate.VG  = 
{ type = "FVG",
  tense = "PreCon",
  voice = "active",
  neg = "yes" ,
  rule  = "FVGPreConActNeg"
  }


Rule: FVGPreConPasNeg
// Present Continuous Passive: is not being  eaten
// (is | are) being  VBN

(

({Token.string == "is"} | {Token.string == "are"})

(NEGATION) (ADVS)?
{Token.string == "being"}


{Token.string == "been"}

{Token.category == "VBN"}


):annotate -->
:annotate.VG = 
{ type = "FVG",
  tense = "PreCon",
  voice = "active",
  neg = "yes" ,
  rule = "FVGPreConPasNeg"}

Rule: FVGPrePerActNeg
// Present Perfect Active: has not eaten
// (has | have) VBN

(

({Token.string == "has"} | {Token.string == "have"})

(NEGATION) (ADVS)?

{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "FVG",
tense = "PrePer",
voice = "active",
neg = "yes",
rule = "FVGPrePerActNeg"
}

Rule: FVGPrePerPasNeg
// Present Perfect Active: has not been eaten
// (has | have) been VBN

(

({Token.string == "has"} | {Token.string == "have"})
(NEGATION) (ADVS)?
{Token.string == "been"}

{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "FVG",
tense = "PrePer",
voice = "passive",
neg = "yes",
rule = "FVGPrePerPasNeg"
}

Rule: FVGPrePerConActNeg
// Present Perfect Continuous Active: has not been eating
// (has | have) been VBG

(
({Token.string == "has"} | {Token.string == "have"})


(NEGATION) (ADVS)?
{Token.string == "been"}
{Token.category == VBG}
):annotate
-->
:annotate.VG = {
type = "FVG",
tense = "PrePerCon",
voice = "active",
neg = "yes",
rule = "FVGPrePerConActNeg"
}

Rule: FVGPrePerConPasNeg
// Present Perfect Continuous Active: (very rare) has not been being eaten
// (has | have) been being VBN

(
({Token.string == "has"} | {Token.string == "have"})
(NEGATION) (ADVS)?
{Token.string == "been"}
{Token.string == "being"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PrePerCon",
voice = "passive",
neg = "yes",
rule = "FVGPrePerConPasNeg"
}



Rule: FVGSimPasPasNeg
// Simple Past Pasive: was not eaten
// (was | were) VBN

(
({Token.string == "was"} | {Token.string == "were"})
(NEGATION) (ADVS)?
{Token.category == VBN}
):annotate -->
:annotate.VG = {
type = "FVG",
tense = "SimPas",
voice = "passive",
neg = "yes",
rule = "FVGSimPasPasNeg"
}


Rule: FVGPasConActNeg
// Past Continuous Active: was not eating
// (was | were) VBG

(
({Token.string == "was"} | {Token.string == "were"})
(NEGATION) (ADVS)?
{Token.category == VBG}
):annotate -->
:annotate.VG = {
type = "FVG",
tense = "PasCon",
voice = "active",
neg = "yes",
rule = "FVGPasConActNeg"
}


Rule: FVGPasConPasNeg
// Past Continuous Passive: was not eating
// (was | were) being VBN

(
({Token.string == "was"} | {Token.string == "were"})
(NEGATION) (ADVS)?
{Token.string == "being"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasCon",
voice = "passive",
neg = "yes",
rule = "FVGPasConPasNeg"

}

Rule: FVGPasPerActNeg
// Past Perfect Active: had not eaten
//  had VBN

(
{Token.string == "had"}
(NEGATION) (ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasPer",
voice = "active",
neg = "yes",
rule = "FVGPasPerActNeg"
}


Rule: FVGPasPerPasNeg
// Past Perfect Passive: had not been eaten
//  had been VBN

(
{Token.string == "had"}

(NEGATION) (ADVS)?
{Token.string == "been"}

{Token.category == VBN}
):annotate
-->
:annotate.VG = {
type = "FVG",
tense = "PasPer",
voice = "passive",
neg = "yes",
rule = "FVGPasPerPasNeg"
}

Rule: FVGPasPerConActNeg
// Past Perfect Continuous Active: had not been eating
//  had been VBG

(
{Token.string == "had"}
(NEGATION) (ADVS)?
{Token.string == "been"}
{Token.category == VBG}
):annotate
-->
:annotate.VG = {
type = "FVG",
tense = "PasPerCon",
voice = "active",
neg = "yes",
rule = "FVGPasPerConActNeg"
}

Rule: FVGPasPerConPasNeg
// Past Perfect Continuous Passive: had not been being eaten
//  had been VBG

(
{Token.string == "had"}
(NEGATION) (ADVS)?
{Token.string == "been"}
{Token.string == "being"}

{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasPerCon",
voice = "passive",
neg = "yes",
rule = "FVGPasPerConPasNeg"
}


Rule: FVGSimFutActNeg
// Simple Future Active: will not eat
// (will | shall) VB

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"})
(NEGATION) (ADVS)?
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "SimFut",
voice = "active",
neg = "yes",
rule = "FVGSimFutActNeg"
}


Rule: FVGSimFutPasNeg
// Simple Future Active: will not be eaten
// (will | shall) be  VBN

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(NEGATION) (ADVS)?
{Token.string == "be"}
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "SimFut",
voice = "passive",
neg = "yes",
rule = "FVGSimFutPasNeg"
}


Rule: FVGFutConActNeg
// Future Continuous Active: will not be eating
// (will | shall) be VBG

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)


(NEGATION) (ADVS)?
{Token.string == "be"}
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutCon",
voice = "active",
neg = "yes",
rule = "FVGFutConActNeg"

}

Rule: FVGFutConPasNeg
// Future Continuous Pasive: will not be being  eaten
// (will | shall) be being VBN

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(NEGATION) (ADVS)?
{Token.string == "be"}
{Token.string == "being"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutCon",
voice = "passive",
neg = "yes",
rule = "FVGFutConPasNeg"

}


Rule: FVGFutPerActNeg
// Future Pefect Active: will not have eaten
// (will | shall) have  VBN

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(NEGATION) (ADVS)?
{Token.string == "have"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPer",
voice = "active",
neg = "yes",
rule = "FVGFutPerActNeg"

}

Rule: FVGFutPerPasNeg
// Future Pefect Active: will not have been eaten
// (will | shall) have  been VBN

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(NEGATION) (ADVS)?
{Token.string == "have"}
{Token.string == "been"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPer",
voice = "passive",
neg = "yes",
rule = "FVGFutPerPasNeg"
}


Rule: FVGFutPerConActNeg
// Future Pefect Continuous Active: will not have been eating
// (will | shall) have been VBG

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(NEGATION) (ADVS)?
{Token.string == "have"}
{Token.string == "been"}
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPerCon",
voice = "active",
neg = "yes",
rule = "FVGFutPerConActNeg"
}



Rule: FVGFutPerConPasNeg
// Future Pefect Continuous Passive: will not have been being eaten
// (will | shall) have been being VBN

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(NEGATION) (ADVS)?
{Token.string == "have"}
{Token.string == "been"}
{Token.string == "being"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPerCon",
voice = "passive",
neg = "yes",
rule = "FVGFutPerConPasNeg"
}


Rule: FVGSimPreActNeg

(
(NEGATION) (ADVS)?
({Token.category == "VB"})
)
:annotate 
-->
:annotate.VG = 
{ type = "FVG",
  tense = "SimPre",
  voice = "active",
neg = "yes",
rule = "FVGSimPreActNeg"
}


Rule: FVGSimPasActNeg

(
({ Token.string == "did"})
(NEGATION) (ADVS)?
({Token.category == "VB"})
)
:annotate
--> 
:annotate.VG = 
{ type = "FVG",
  tense = "SimPas",
  voice = "active",
neg = "yes",
rule = "FVGSimPasActNeg"
}


Rule: FVGSimPreActNeg
// Simple Present Active: is not
// VB not

(
(
({ Token.string == "is"})
|
({ Token.string == "are"})
|
({ Token.string == "be"})
|
({ Token.string == "am"})
|
({ Token.string == "have"})
|
({ Token.string == "has"})
)
(NEGATION) 
)
:annotate --> :annotate.VG = 

{ type = "FVG",
  tense = "SimPre",
  voice = "active",
neg = "yes",
rule = "FVGSimPreActNeg"}


Rule: FVGSimPasActNeg
// Simple Passive Active: was not

(
(
({ Token.string == "was"})
|
({ Token.string == "were"})
|
({ Token.string == "had"})
)
(NEGATION) 
):annotate 
--> 
:annotate.VG = 
{ type = "FVG",
  tense = "SimPas",
  voice = "active",
neg = "yes",
rule = "FVGSimPasActNeg"}

Rule: FVGPreConActNeg
// Present Continuous Active: 

(
(NEGATION) (ADVS)?
{Token.category == "VBG"}
):annotate 
-->
:annotate.VG  = 
{ type = "FVG",
  tense = "PreCon",
  voice = "active" ,
neg = "yes",
rule = "FVGPreConActNeg"}


////////////////////////////////////////////////////////////
// fvg.jape

// Finite Verb Groups


Rule: FVGSimPreAct
// Simple Present Active: eats or eat

(
(
{Token.category == "VBP"}
|
{Token.category == "VBZ"}
)
):annotate 
--> :annotate.VG = 
{ type = "FVG",
  tense = "SimPre",
  voice = "active",
  rule = "FVGSimPreAct"}

 

Rule: FVGPreConAct
// Present Continuous Active: is eating or are eating
// (is | are) VBG

(
({Token.string == "is"} | {Token.string == "are"})
(ADVS)?
{Token.category == "VBG"}
):annotate
-->
:annotate.VG  = 
{ type = "FVG",
  tense = "PreCon",
  voice = "active",
  rule = "FVGPreConAct"}


Rule: FVGPreConPas
// Present Continuous Passive: is being  eaten or are being  eaten
// (is | are) being  VBN

(
({Token.string == "is"} | {Token.string == "are"})?
{Token.string == "being"}
(ADVS)?
{Token.category == "VBN"}
):annotate 
-->
:annotate.VG = 
{ type = "FVG",
  tense = "PreCon",
  voice = "active" ,
 rule =  "FVGPreConPas"}

Rule: FVGPrePerAct
// Present Perfect Active: has eaten


(
({Token.string == "has"} | {Token.string == "have"})
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PrePer",
voice = "active",
rule = "FVGPrePerAct"
}

Rule: FVGPrePerPas
// Present Perfect Active: has been eaten

(
({Token.string == "has"} | {Token.string == "have"})
{Token.string == "been"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PrePer",
voice = "passive",
rule = "FVGPrePerPas"
}

Rule: FVGPrePerConAct
// Present Perfect Continuous Active: has been eating

(
({Token.string == "has"} | {Token.string == "have"})
{Token.string == "been"}
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PrePerCon",
voice = "active",
rule = "FVGPrePerConAct"
}

Rule: FVGPrePerConPas
// Present Perfect Continuous Active: (very rare) has been being eaten

(
({Token.string == "has"} | {Token.string == "have"})
{Token.string == "been"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PrePerCon",
voice = "passive",
rule = "FVGPrePerConPas"
}

Rule: FVGSimPasAct
// Simple Past Active: ate

(
//(ADVS)?
{Token.category == VBD}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "SimPas",
voice = "active",
rule = "FVGSimPasAct"
}


Rule: FVGSimPasPas
// Simple Past Passive: was eaten

(
({Token.string == "was"} | {Token.string == "were"})
(ADVS)?
{Token.category == VBN}
):annotate
-->
:annotate.VG = {
type = "FVG",
tense = "SimPas",
voice = "passive",
rule = "FVGSimPasPas"
}


Rule: FVGPasConAct
// Past Continuous Active: was eating

(
({Token.string == "was"} | {Token.string == "were"})
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasCon",
voice = "active",
rule = "FVGPasConAct"
}


Rule: FVGPasConPas
// Past Continuous Passive: was eating

(
({Token.string == "was"} | {Token.string == "were"})
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasCon",
voice = "passive",
rule = "FVGPasConAct"
}

Rule: FVGPasPerAct
// Past Perfect Active: had eaten

(
{Token.string == "had"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasPer",
voice = "active",
rule = "FVGPasPerAct"
}


Rule: FVGPasPerPas
// Past Perfect Passive: had been eaten

(
{Token.string == "had"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasPer",
voice = "passive",
rule = "FVGPasPerPas"
}

Rule: FVGPasPerConAct
// Past Perfect Continuous Active: had been eating

(
{Token.string == "had"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasPerCon",
voice = "active",
rule = "FVGPasPerPas"
}

Rule: FVGPasPerConPas
// Past Perfect Continuous Passive: had been being eaten

(
{Token.string == "had"}
{Token.string == "been"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "PasPerCon",
voice = "passive",
rule = "FVGPasPerConPas"
}


Rule: FVGSimFutAct
// Simple Future Active: will eat

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
(ADVS)?
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "SimFut",
voice = "active",
rule = "FVGSimFutAct"
}


Rule: FVGSimFutPas
// Simple Future Active: will be eaten

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
{Token.string == "be"}
(ADVS)?
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "SimFut",
voice = "passive",
rule = "FVGSimFutPas"
}


Rule: FVGFutConAct
// Future Continuous Active: will be eating

(
({Token.string == "will"} | {Token.string == "shall"}

| {Token.string == "wo"} | {Token.string == "'ll"}
)

{Token.string == "be"}
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutCon",
voice = "active",
rule = "FVGFutConAct"
}

Rule: FVGFutConPas
// Future Continuous Pasive: will be being  eaten

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
{Token.string == "be"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutCon",
voice = "passive",
rule = "FVGFutConPas"
}


Rule: FVGFutPerAct
// Future Pefect Active: will have eaten

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
{Token.string == "have"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPer",
voice = "active",
rule = "FVGFutPerAct"
}

Rule: FVGFutPerPas
// Future Pefect Passive: will have being eaten

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
{Token.string == "have"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPer",
voice = "passive",
rule = "FVGFutPerPas"
}


Rule: FVGFutPerConAct
// Future Pefect Continuous Active: will have been eating

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
{Token.string == "have"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPerCon",
voice = "active",
rule = "FVGFutPerConAct"
}



Rule: FVGFutPerConPas
// Future Pefect Continuous Passive: will have been being eaten

(
({Token.string == "will"} | {Token.string == "shall"}
| {Token.string == "wo"} | {Token.string == "'ll"}
)
{Token.string == "have"}
{Token.string == "been"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "FVG",
tense = "FutPerCon",
voice = "passive",
rule = "FVGFutPerConPas"
}

/////////////////////////////////////////////////
// nfvg.jape

// Non-Finite Verb Groups



Rule: NFVGInfAct
// Simple Infinitive Active: to eat

(
(TO)
(ADVS)?
{Token.category == VB}
):annotate
-->
:annotate.VG = {
type = "NFVG",
tense = "Inf",
voice = "active",
rule = "NFVGInfAct"
}

Rule: NFVGInfActBis
// Simple Infinitive Active: eat

(
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "Inf",
voice = "active",
rule = "NFVGInfActBis"
}

Rule: NFVGInfPas
// Simple Infinitive Passive: to be eaten

(
(TO)
{Token.string == "be"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "Inf",
voice = "passive",
rule = "NFVGInfPas"
}


Rule: NFVGPreConAct
// Infinitive Present Continuous: to be eating

(
(TO)
{Token.string == "be"}
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "PreCon",
voice = "active",
rule = "NFVGPreConAct"
}


Rule: NFVGPreConPas
// Infinitive Present Continuous: to be being eaten

(
(TO)
{Token.string == "be"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "PreCon",
voice = "passive",
rule = "NFVGPreConPas"
}


Rule: NFVGPerAct
// Infinitive Perfect Active:  to have eaten

(
(TO)
{Token.string == "have"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "Per",
voice = "active",
rule = "NFVGPerAct"
}

Rule: NFVGPerPas
// Infinitive Perfect Passive:  to have been eaten

(
(TO)
{Token.string == "have"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "Per",
voice = "passive",
rule = "NFVGPerPas"
}

Rule: NFVGPerConAct
// Infinitive Perfect Continuous Active:  to have been eating

(
(TO)
{Token.string == "have"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "PerCon",
voice = "active",
rule = "NFVGPerConAct"
}

Rule: NFVGPerConPas
// Infinitive Perfect Continuous Passive:  to have been being eaten

(
(TO)
{Token.string == "have"}
{Token.string == "been"}
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "NFVG",
tense = "PerCon",
voice = "passive",
rule = "NFVGPerConPas"
}


////////////////////////////////////////////////////////////////
// modals

Rule: Modal1Neg
// cannot walk

(
(MODAL_NEG) | ((MODALS) (NEGATION))
(ADVS)?
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "none",
voice = "active",
neg = "yes",
rule = "Modal1Neg"
}

Rule: Modal1
// can walk
(
(MODALS)
(ADVS)?
{Token.category == VB}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "none",
voice = "active",
rule = "Modal1"

}

Rule: Modal2Neg
// might not be walking

(
(MODAL_NEG) | ((MODALS) (NEGATION))
(ADVS)?
{Token.string == "be"}
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "BeVBG",
voice = "active",
neg = "yes",
rule = "Modal2Neg"
}


Rule: Modal2
// might be walking

(
(MODALS)
(ADVS)?
{Token.string == "be"}
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "BeVBG",
voice = "active",
rule = "Modal2"
}


Rule: Modal3Neg
// might not have walked

(
(MODAL_NEG) | ((MODALS) (NEGATION))
(ADVS)?
{Token.string == "have"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "HaveVBN",
voice = "active",
neg = "yes",
rule = "Modal3Neg"
}

Rule: Modal3
// might have walked

(
(MODALS)
(ADVS)?
{Token.string == "have"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "HaveVBN",
voice = "active",
rule = "Modal3"
}


Rule: Modal4Neg
// might not be walked

(
(MODALS)
(ADVS)?
{Token.string == "be"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "BeVBN",
voice = "passive",
neg = "yes",
rule = "Modal4Neg"
}

Rule: Modal4
// might be walked

(
(MODALS)
(ADVS)?
{Token.string == "be"}
{Token.category == VBN}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "BeVBN",
voice = "passive",
rule = "Modal4"
}

Rule: Modal5Neg
// might not have been walking

(
(MODALS)
(ADVS)?
{Token.string == "have"}
{Token.string == "been"}
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "HaveBeenVBG",
voice = "active",
neg = "yes",
rule = "Modal5"
}

Rule: Modal5
// might have been walking

(
(MODALS)
(ADVS)?
{Token.string == "have"}
{Token.string == "been"}
{Token.category == VBG}
):annotate 
-->
:annotate.VG = {
type = "MODAL",
tense = "HaveBeenVBG",
voice = "active",
rule = "Modal5"
}

/////////////////////////////////////////////////


// participles.jape

// participles -ing, -ed, -n


// present participles (i.e. INGs)

Rule: PARTPreAct
// Participle Present: eating
// VBG

(

{Token.category == VBG}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "Pre",
voice = "active"

}

Rule: PARTPrePas
// Participle Present Passive: being  eaten
// being VBN

(
{Token.string == "being"}
(ADVS)?
{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "Pre",
voice = "passive"

}


Rule: PARTPrePerAct
// Participle Present Perfect Active: having eaten
// having VBN

(
{Token.string == "having"}
(ADVS)?
{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "PrePer",
voice = "active"

}

Rule: PARTPrePerPas
// Participle Present Perfect Passive: having been eaten
// having been VBN

(
{Token.string == "having"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "PrePer",
voice = "passive"

}

Rule: PARTPrePerConAct
// Participle Present Perfect Cont.  Active: having been eating
// having VBN

(
{Token.string == "having"}
{Token.string == "been"}
(ADVS)?
{Token.category == VBG}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "PrePerCon",
voice = "active"

}

Rule: PARTPrePerConPas
// Participle Present Perfect Cont.  Passive: having been being eaten
// having been being VBN

(
{Token.string == "having"}
{Token.string == "been"}
{Token.string == "being"}
(ADVS)?
{Token.category == VB}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "PrePerCon",
voice = "passive"

}

// present participles (i.e. -ed or irregulars)


Rule: PARTPas
// Past Participle: eaten
// VBN


(

{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "Pas",
voice = "none"

}

Rule: PARTPasPer
// Past Participle: eaten
// VBN


(
{Token.string == "been"}
(ADVS)?
{Token.category == VBN}

):annotate -->

:annotate.VG = {
type = "PART",
tense = "PasPer",
voice = "none"

}

// special_vg.jape


// Some special verbs

Macro: TOBE

(
{Token.string == "be"}
|
{Token.string == "is"}
|
{Token.string == "am"}
|
{Token.string == "'s"}
|
{Token.string == "m"}
|
{Token.string == "are"}
|
{Token.string == "was"}
|
{Token.string == "were"}

)

Macro: TOHAVE

(
{Token.string == "have"}
|
{Token.string == "has"}
|
{Token.string == "'s"}
|
{Token.string == "had"}
)

Macro: SPECIALS

(

({Token.string == "had"} {Token.string == "better"})

|

(
(TOBE)
{Token.string == "supposed"} {Token.string == "to"}
)

|

(
(TOBE)
{Token.string == "to"}
)

|


(
(TOHAVE)
{Token.string == "to"}
)


|

(
(TOHAVE)
{Token.string == "got"}
{Token.string == "to"}

)

|


(
(TOBE)
{Token.string == "going"}
{Token.string == "to"}
)

|

(
(TOBE)
{Token.string == "able"}
{Token.string == "to"}

)

|

(
{Token.string == "used"}
{Token.string == "to"}

)


)

Rule: Special1
// SPECIAL + VB

(
(SPECIALS)
(ADVS)?
{Token.category == VB}

):annotate -->
:annotate.VG = {
type = "SPECIAL",
tense = "Pre",
voice = "none"

}


Rule: Special2
// SPECIAL + VBN

(
(SPECIALS)
(ADVS)?
{Token.category == VBN}

):annotate -->
:annotate.VG = {
type = "SPECIAL",
tense = "Pas",
voice = "none"

}