gate.plugins.Lang_French.grammar.name.jape Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of gate-extraction Show documentation
Gate based component, that can process the Text units to extract informations using Gate's tools (such as grammars, gazetteers, tokenizer or POS Taggers). This project contains two versions, a simple component and webservice one.
There is a newer version: 2.0
Show newest version
/*
*  name.jape
*
* Copyright (c) 1998-2004, The University of Sheffield.
*
*  This file is part of GATE (see http://gate.ac.uk/), and is free
*  software, licenced under the GNU Library General Public License,
*  Version 2, June 1991 (in the distribution as file licence.html,
*  and also available at http://gate.ac.uk/gate/licence.html).
*
*  Diana Maynard, 10 Sep 2001
* 
*  $Id: name.jape 11883 2009-11-03 16:27:32Z markagreenwood $
*/


Phase:	Name
Input: Token Lookup Title FirstPerson TreeTaggerToken
Options: control = appelt debug = false

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

// Person Rules

/////////////////////////////////////////////////////////////////
Macro: TITLE
(
 {Title}
 ({Token.string == "."})?
)
Macro: INITIALS
(
  ({Token.orth == upperInitial, Token.length =="1"}
  ({Token.string == "."})?
  )+
)

Macro: INITIALS2

(
 {Token.orth == allCaps, Token.length == "2"} |
 {Token.orth == allCaps, Token.length == "3"}
)


Macro: FIRSTNAME
(
 ({FirstPerson.gender == male} |
  {FirstPerson.gender == female})
 |
 (INITIALS)
)

Macro: FIRSTNAMEAMBIG
(
 {Lookup.majorType == person_first, Lookup.minorType == ambig}
)



Macro: UPPERTAG
(
 ({TreeTaggerToken.category == NAM}
)
 ({Token.string == "-"}
  {TreeTaggerToken.category == NAM}
 )?
)

Macro: UPPER
(
 ({Token.orth == upperInitial}
)
 ({Token.string == "-"}
  {Token.orth == upperInitial}
 )?
)


Macro: PERSONENDING
(
 {Lookup.majorType == person_ending}
)

Macro: PREFIX
(
 ({Lookup.majorType == surname, Lookup.minorType == prefix}
 )|
 (({Token.string == "O"}|{Token.string == "D"})
  {Token.string == "'"}
 )
)




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


// Person Rules

Rule: Pronoun
Priority: 1000
//stops personal pronouns being recognised as Initials
(
 {TreeTaggerToken.category == PP}|
 {TreeTaggerToken.category == PRP}|
 {TreeTaggerToken.category == RB}
):pro
-->
{}

 

Rule:	GazPerson
Priority: 50
(
 {Lookup.majorType == person_full, Lookup.minorType == normal}
)
:person -->
{
gate.AnnotationSet person = (gate.AnnotationSet)bindings.get("person");
gate.Annotation personAnn = (gate.Annotation)person.iterator().next();
gate.FeatureMap features = Factory.newFeatureMap();
features.put("kind", "personName");
features.put("rule", "GazPerson");
outputAS.add(person.firstNode(), person.lastNode(), "TempPerson",
features);
}

Rule:	TheGazPersonFirst
Priority: 200
(
 {TreeTaggerToken.category == DT}|
 {TreeTaggerToken.category == PRP}|
 {TreeTaggerToken.category == RB}
)
(
 {FirstPerson}
)
:person 
( 
 {Token.orth == upperInitial, Token.length == "1"}
)?
-->
{
gate.AnnotationSet person = (gate.AnnotationSet)bindings.get("person");
gate.Annotation personAnn = (gate.Annotation)person.iterator().next();
gate.FeatureMap features = Factory.newFeatureMap();
features.put("gender", personAnn.getFeatures().get("gender"));
features.put("kind", "personName");
features.put("rule", "GazPersonFirst");
outputAS.add(person.firstNode(), person.lastNode(), "TempPerson",
features);
//outputAS.removeAll(person);
}


Rule:	GazPersonFirst
Priority: 70
(
 {FirstPerson}
)
:person 
( 
 {Token.orth == upperInitial, Token.length == "1"}
)?
-->
{
gate.AnnotationSet person = (gate.AnnotationSet)bindings.get("person");
gate.Annotation personAnn = (gate.Annotation)person.iterator().next();
gate.FeatureMap features = Factory.newFeatureMap();
features.put("gender", personAnn.getFeatures().get("gender"));
features.put("kind", "personName");
features.put("rule", "GazPersonFirst");
outputAS.add(person.firstNode(), person.lastNode(), "TempPerson",
features);
//outputAS.removeAll(person);
}





Rule: PersonFirstContext
Priority: 30
// Anne and Kenton

(
 {FirstPerson}
):person1
(
 {Token.string == "and"}
)
({Token.orth == upperInitial})
:person2
 -->
{
//first deal with person1
 gate.FeatureMap features1 = Factory.newFeatureMap();
gate.AnnotationSet person1Set = (gate.AnnotationSet)bindings.get("person1");
gate.AnnotationSet firstPerson = (gate.AnnotationSet)person1Set.get("FirstPerson");
if (firstPerson != null && firstPerson.size()>0)
{
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features1.put("gender", personAnn.getFeatures().get("gender"));
}
  features1.put("kind", "personName");
  features1.put("rule", "PersonFirstContext");
outputAS.add(person1Set.firstNode(), person1Set.lastNode(), "TempPerson",
features1);
//now deal with person2
gate.FeatureMap features2 = Factory.newFeatureMap();
gate.AnnotationSet person2Set = (gate.AnnotationSet)bindings.get("person2");
  features2.put("kind", "personName");
  features2.put("rule", "PersonFirstContext");
outputAS.add(person2Set.firstNode(), person2Set.lastNode(), "TempPerson",
features2);
}


Rule: PersonFirstContext2
Priority: 40
// Anne and I

(
 {FirstPerson}
):person
(
 {Token.string == "and"}
 {Token.length == "1"}
)
 -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
gate.AnnotationSet firstPerson = (gate.AnnotationSet)personSet.get("FirstPerson");
if (firstPerson != null && firstPerson.size()>0)
{
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
  features.put("kind", "personName");
  features.put("rule", "PersonFirstContext2");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}


Rule:	PersonTitle
Priority: 35
// Mr. Jones
// Mr Fred Jones
// note we only allow one first and surname, 
// but we can add more in a final phase if we find adjacent unknowns

( 
 {TreeTaggerToken.category == DT}|
 {TreeTaggerToken.category == PRP}|
 {TreeTaggerToken.category == RB}
)?
(
 (TITLE)+
 ((FIRSTNAME | FIRSTNAMEAMBIG | INITIALS2)
 )?
  (PREFIX)* 
  (UPPER)
 (PERSONENDING)?
)
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
  
 // get all Title annotations that have a gender feature
 HashSet fNames = new HashSet();
    fNames.add("gender");
    gate.AnnotationSet personTitle = personSet.get("Title", fNames);

// if the gender feature exists
 if (personTitle != null && personTitle.size()>0)
{
  //Out.prln("Titles found " +  personTitle);
  gate.Annotation personAnn = (gate.Annotation)personTitle.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
else
{
  //get all firstPerson annotations that have a gender feature
  //  HashSet fNames = new HashSet();
   // fNames.add("gender");
    gate.AnnotationSet firstPerson = personSet.get("FirstPerson", fNames);

  if (firstPerson != null && firstPerson.size()>0)
 {
    //Out.prln("First persons found " +  firstPerson);
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
 }
}
  features.put("kind", "personName");
  features.put("rule", "PersonTitle");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}


Rule:	PersonFirstTitleGender
Priority: 55
// use this rule when we know what gender the title indicates
// Mr Fred

(
 ({Title.gender == male} | {Title.gender == female})
 ((FIRSTNAME | FIRSTNAMEAMBIG | INITIALS2)
 )
)
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
gate.AnnotationSet title = (gate.AnnotationSet)personSet.get("Title");
if (title != null && title.size()>0)
{
  gate.Annotation personAnn = (gate.Annotation)title.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
  features.put("kind", "personName");
  features.put("rule", "PersonFirstTitleGender");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}


Rule: PersonTitleGender
Priority: 18
// use this rule if the title has a feature gender
// Miss F Smith
(
 ({Title.gender == male}|
  {Title.gender == female}
 ) 
 ((FIRSTNAME | FIRSTNAMEAMBIG | INITIALS2)
 )*
 (UPPER)
 (PERSONENDING)?
)
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
gate.AnnotationSet title = (gate.AnnotationSet)personSet.get("Title");
// if the annotation type title doesn't exist, do nothing
if (title != null && title.size()>0)
{
// if it does exist, take the first element in the set
  gate.Annotation personAnn = (gate.Annotation)title.iterator().next();
//propagate gender feature (and value) from title
  features.put("gender", personAnn.getFeatures().get("gender"));
}
// create some new features
  features.put("kind", "personName");
  features.put("rule", "PersonTitleGender");
// create a TempPerson annotation and add the features we've created
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}


Rule: PersonJobTitle
Priority: 20
// note we include titles but not jobtitles in markup

(
 {Lookup.majorType == jobtitle}
):jobtitle
(
 (TITLE)?
 ((FIRSTNAME | FIRSTNAMEAMBIG | INITIALS2)
 )
 (PREFIX)* 
 (UPPER)
 (PERSONENDING)?
)
:person 
-->
    :person.TempPerson = {kind = "personName", rule = "PersonJobTitle"},
   :jobtitle.JobTitle = {rule = "PersonJobTitle"} 




Rule: NotFirstPersonStop
Priority: 50
// ambig first name and surname is stop word
// e.g. Will And

(
 ((FIRSTNAMEAMBIG)+ | 
  {Token.category == PRP}|
  {Token.category == DT}
 )
 ({Lookup.majorType == stop}
 )
)
:person -->
  {}
Rule: FirstPersonStop
Priority: 50
// John And

(
 {FirstPerson}
):person
(
 {Token.category == DT}|
 {Token.category == PRP}|
 {Token.category == RB}|
 {Token.category == IN}
)
-->
{
gate.AnnotationSet person = (gate.AnnotationSet)bindings.get("person");
gate.Annotation personAnn = (gate.Annotation)person.iterator().next();
gate.FeatureMap features = Factory.newFeatureMap();
features.put("gender", personAnn.getFeatures().get("gender"));
features.put("kind", "personName");
features.put("rule", "GazPersonFirst");
outputAS.add(person.firstNode(), person.lastNode(), "TempPerson",
features);
}





Rule: NotPersonFull
Priority: 50
// do not allow Det + Surname
(
 {Token.category == DT}|
 {Token.category == PRP}|
 {Token.category == RB}
)
(
 (PREFIX)* 
 (UPPER)
 (PERSONENDING)?
):foo
-->
{}




Rule: LocPersonAmbig
Priority: 50
// Location + Surname
(
 {Lookup.majorType == location}
):loc
(
 (PREFIX)* 
 (UPPER)
 (PERSONENDING)?
):foo
-->
:loc.TempLocation = {kind = "locName", rule = LocPersonAmbig}


Rule: 	PersonFull
Priority: 10
// F.W. Jones
// Fred Jones
(
 {Token.category == DT}
)?
(
 ((FIRSTNAME | FIRSTNAMEAMBIG) )+
 (PREFIX)*
 (UPPER)
 (PERSONENDING)?
)
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
  
  //get all firstPerson annotations that have a gender feature
    HashSet fNames = new HashSet();
    fNames.add("gender");
    gate.AnnotationSet firstPerson = personSet.get("FirstPerson", fNames);

  if (firstPerson != null && firstPerson.size()>0)
 {
    //Out.prln("First persons found " +  firstPerson);
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
  features.put("kind", "personName");
  features.put("rule", "PersonFull");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}

Rule: PersonFullStop
Priority: 50
// G.Wilson Fri

(
 ((FIRSTNAME | FIRSTNAMEAMBIG) )
 (PREFIX)* 
 (UPPER)
):person
(
 {Lookup.majorType == date}
)
-->
 :person.TempPerson = {kind = "personName", rule = "PersonFullStop"}


Rule: NotPersonFullReverse
Priority: 20
// XYZ, I
(
 (UPPER)
 {Token.string == ","}
 {Token.category == PRP}
 (PERSONENDING)?
)
:unknown 
-->
{}

Rule: 	PersonFullReverse
Priority: 5
// Jones, F.W.
// don't allow Jones, Fred because too ambiguous
// Smith, TF

(
 {Token.category ==NNP}
 {Token.string == ","}
 (INITIALS )+ 
 (PERSONENDING)?
)
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
gate.AnnotationSet firstPerson = (gate.AnnotationSet)personSet.get("FirstPerson");
if (firstPerson != null && firstPerson.size()>0)
{
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
  features.put("kind", "personName");
  features.put("rule", "PersonFullReverse");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}


Rule:  PersonSaint
Priority: 50
// Note: ensure that it's not a Saints Day first
(
 ({Token.string == "St"} ({Token.string == "."})? |
 {Token.string == "Saint"})
 (FIRSTNAME)
 )
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
gate.AnnotationSet firstPerson = (gate.AnnotationSet)personSet.get("FirstPerson");
if (firstPerson != null && firstPerson.size()>0)
{
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
  features.put("kind", "personName");
  features.put("rule", "PersonSaint");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}


Rule: PersonLocAmbig
Priority: 40
// Ken London
// Susan Hampshire

// Christian name + Location --> Person's Name
(
 ({Lookup.majorType == person_first} |
  (INITIALS
   {Token.string == "."})
 )
  {Lookup.majorType == location}
)
:person -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
gate.AnnotationSet personSet = (gate.AnnotationSet)bindings.get("person");
gate.AnnotationSet firstPerson = (gate.AnnotationSet)personSet.get("FirstPerson");
if (firstPerson != null && firstPerson.size()>0)
{
  gate.Annotation personAnn = (gate.Annotation)firstPerson.iterator().next();
  features.put("gender", personAnn.getFeatures().get("gender"));
}
  features.put("kind", "personName");
  features.put("rule", "PersonLocAmbig");
outputAS.add(personSet.firstNode(), personSet.lastNode(), "TempPerson",
features);
}

///////////////////////////////////////////////////////////////////
// Organisation Rules

Macro:  CDG
// cdg is something like "Ltd."
 (
  ({Lookup.majorType == cdg})|
  ({Token.string == ","} 
  {Lookup.majorType == cdg})
 )


Macro: SAINT
(
 ({Token.string == "St"} ({Token.string == "."})? |
 {Token.string == "Saint"})
)

Macro: CHURCH
(
{Token.string == "Church"}|{Token.string == "church"}|
{Token.string == "Cathedral"}|{Token.string == "cathedral"}|
{Token.string == "Chapel"}|{Token.string == "chapel"}
)

/////////////////////////////////////////////////////////////
Rule:	TheGazOrganization
Priority: 245
(
 {Token.category == DT}|
 {Token.category == RB}
)
(
{Lookup.majorType == organization}
)
:orgName -->  
 {
 gate.FeatureMap features = Factory.newFeatureMap();
// create an annotation set consisting of all the annotations for org 
gate.AnnotationSet orgSet = (gate.AnnotationSet)bindings.get("orgName");
// create an annotation set consisting of the annotation matching Lookup
gate.AnnotationSet org = (gate.AnnotationSet)orgSet.get("Lookup");
// if the annotation type Lookup doesn't exist, do nothing
if (org != null && org.size()>0)
{
// if it does exist, take the first element in the set
  gate.Annotation orgAnn = (gate.Annotation)org.iterator().next();
//propagate minorType feature (and value) from org
  features.put("orgType", orgAnn.getFeatures().get("minorType"));
}
// create some new features
  features.put("rule", "GazOrganization");
// create a TempOrg annotation and add the features we've created
outputAS.add(orgSet.firstNode(), orgSet.lastNode(), "TempOrganization",
features);
}


Rule:	GazOrganization
Priority: 145
(
{Lookup.majorType == organization}
)
:orgName -->  
 {
 gate.FeatureMap features = Factory.newFeatureMap();
// create an annotation set consisting of all the annotations for org 
gate.AnnotationSet orgSet = (gate.AnnotationSet)bindings.get("orgName");
// create an annotation set consisting of the annotation matching Lookup
gate.AnnotationSet org = (gate.AnnotationSet)orgSet.get("Lookup");
// if the annotation type Lookup doesn't exist, do nothing
if (org != null && org.size()>0)
{
// if it does exist, take the first element in the set
  gate.Annotation orgAnn = (gate.Annotation)org.iterator().next();
//propagate minorType feature (and value) from org
  features.put("orgType", orgAnn.getFeatures().get("minorType"));
}
// create some new features
  features.put("rule", "GazOrganization");
// create a TempOrg annotation and add the features we've created
outputAS.add(orgSet.firstNode(), orgSet.lastNode(), "TempOrganization",
features);
}

Rule:	LocOrganization
Priority: 50
// Ealing Police
(
 ({Lookup.majorType == location} |
  {Lookup.majorType == country_adj})
{Lookup.majorType == organization}
({Lookup.majorType == organization})?
)
:orgName -->  
  :orgName.TempOrganization = {kind = "orgName", rule=LocOrganization}


Rule:	INOrgXandY
Priority: 200

// Bradford & Bingley
// Bradford & Bingley Ltd
(
 {Token.category == IN}
)

(
 ({Token.category == NNP}
  )+

 {Token.string == "&"}

 (
  {Token.orth == upperInitial}
 )+

 (CDG)?

)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXandY"}

Rule:	OrgXandY
Priority: 20

// Bradford & Bingley
// Bradford & Bingley Ltd


(
 ({Token.category == NNP}
  )+

 {Token.string == "&"}

 (
  {Token.orth == upperInitial}
 )+

 (CDG)?

)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXandY"}


Rule:OrgUni
Priority: 25
// University of Sheffield
// Sheffield University
// A Sheffield University
(
 {Token.string == "University"}
 {Token.string == "of"}
 (
 {Token.category == NNP})+
)
:orgName -->
  :orgName.TempOrganization = {kind = "org", rule = "OrgDept"}



Rule: OrgDept
Priority: 25
// Department of Pure Mathematics and Physics

(
 {Token.string == "Department"}
 
 {Token.string == "of"}
 (
 {Token.orth == upperInitial})+
 (
  {Token.string == "and"}
  ( 
   {Token.orth == upperInitial})+
 )?
)
:orgName -->
  :orgName.TempOrganization = {kind = "department", rule = "OrgDept"}

Rule:	TheOrgXKey
Priority: 500

// The Aaaa Ltd.
(
 {Token.category == DT}
)
(
  (UPPER)
  (UPPER)?
  (UPPER)?
  (UPPER)?
  (UPPER)?
 {Lookup.majorType == org_key}
 ({Lookup.majorType == org_ending})?
)
:org
-->
:org.TempOrganization = {kind = "unknown", rule = "TheOrgXKey"}

Rule:	OrgXKey
Priority: 125

// Aaaa Ltd.
(
  (UPPER)
  (UPPER)?
  (UPPER)?
  (UPPER)?
  (UPPER)?
 {Lookup.majorType == org_key}
 ({Lookup.majorType == org_ending})?
)
:org
-->
:org.TempOrganization = {kind = "unknown", rule = "TheOrgXKey"}


Rule: NotOrgXEnding
Priority: 500
// Very Limited

(
 {Token.category == DT}
)?
(
 {Token.category == RB}
 {Lookup.majorType == cdg}
)
:label
-->
{}
 
 Rule:	NotOrgXEnding2
Priority: 500

// The Coca Cola Co.

(
 {Token.category == DT}
)
(
  (UPPER)
  (UPPER)?
 {Lookup.majorType == cdg}
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXEnding"}



Rule:	OrgXEnding
Priority: 120

// Coca Cola Co.

(
  (UPPER)
  (UPPER)?
 {Lookup.majorType == cdg}
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXEnding"}

Rule:	TheOrgXandYKey
Priority: 220

(
 {Token.category == DT}
)
(
 (UPPER)
 (UPPER)?
  (({Token.string == "and"} | 
    {Token.string == "&"})
   (UPPER)?
   (UPPER)?
   (UPPER)?
  )
 {Lookup.majorType == org_key}
 ({Lookup.majorType == org_ending})?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXandYKey"}



Rule:	OrgXandYKey
Priority: 120

// Aaaa Ltd.
// Xxx Services Ltd. 
// AA and BB Services Ltd.
// but NOT A XXX Services Ltd.

(
 (UPPER)
 (UPPER)?
  (({Token.string == "and"} | 
    {Token.string == "&"})
   (UPPER)?
   (UPPER)?
   (UPPER)?
  )
 {Lookup.majorType == org_key}
 ({Lookup.majorType == org_ending})?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXandYKey"}


Rule:	OrgXsKeyBase
Priority: 120
 
// Gandy's Circus
// Queen's Ware

(
  (UPPER)?
  (UPPER)?
  ({Token.orth == upperInitial}
   {Token.string == "'"}
   ({Token.string == "s"})?
  )
 ({Lookup.majorType == org_key}|
  {Lookup.majorType == org_base})
)
:orgName -->
  :orgName.TempOrganization = {kind = "org", rule = "OrgXsKeybase"}



Rule: NotOrgXBase
Priority: 1000
// not things like British National
// or The University


(
 ({Token.category == DT} 
 )?
)
(
 ({Lookup.majorType == country_adj}|
  {Token.orth == lowercase})
 ({Lookup.majorType == org_base}|
  {Lookup.majorType == govern_key})
)
:orgName -->
  :orgName.Temp = {kind = "notorgName", rule = "NotOrgXBase"}


Rule:	TheOrgXBase
Priority: 230

(
 ({Token.category == DT}
 )
)
(
 (
  (UPPER)|
  {Lookup.majorType == organization}
 )
 (UPPER)?
 (UPPER)?
 ({Lookup.majorType == org_base}|
  {Lookup.majorType == govern_key}
 )
 (
  {Token.string == "of"}
  (UPPER)
  (UPPER)?
  (UPPER)?
 )?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "TheOrgXBase"}


Rule:	OrgXBase
Priority: 130

// same as OrgXKey but uses base instead of key
// includes govern_key e.g. academy
// Barclays Bank
// Royal Academy of Art

(
 (
  (UPPER)|
  {Lookup.majorType == organization}
 )
 (UPPER)?
 (UPPER)?
 ({Lookup.majorType == org_base}|
  {Lookup.majorType == govern_key}
 )
 (
  {Token.string == "of"}
  (UPPER)
  (UPPER)?
  (UPPER)?
 )?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgXBase"}

Rule:	TheBaseofOrg
Priority: 230

(
 {Token.category == DT}
)
(
 ({Lookup.majorType == org_base}|
  {Lookup.majorType == govern_key}
 )
 
 {Token.string == "of"}
 ( 
  {Token.category == DT}
 )?
 (UPPER)
 (UPPER)?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "BaseofOrg"}




Rule:	BaseofOrg
Priority: 130

(
 ({Lookup.majorType == org_base}|
  {Lookup.majorType == govern_key}
 )
 
 {Token.string == "of"}
 ( 
  {Token.category == DT}
 )?
 (UPPER)
 (UPPER)?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "BaseofOrg"}



Rule:	OrgPreX
Priority: 130

// Royal Tuscan

(
 {Lookup.majorType == org_pre}
 (
  {Token.orth == upperInitial})+
 ({Lookup.majorType == org_ending})?
)
:orgName -->
  :orgName.TempOrganization = {kind = "unknown", rule = "OrgPreX"}




Rule: OrgChurch
Priority: 150
// St. Andrew's Church

(
  (SAINT)
  {Token.orth == upperInitial}
  {Token.string == "'"}({Token.string == "s"})?
  (CHURCH)
)
:orgName -->
  :orgName.TempOrganization = {kind = "org", rule = "OrgChurch"}


Rule:OrgPersonAmbig
Priority: 130
// Alexandra Pottery should be org not person
// overrides PersonFull

(
 (FIRSTNAME)
 ({Lookup.majorType == org_key}|
  {Lookup.majorType == org_base})
 ({Lookup.majorType == org_ending})?
)
:org 
-->
 :org.TempOrganization= {kind = "unknown", rule = "OrgPersonAmbig"}

 

/////////////////////////////////////////////////////////////////
// Location rules


Rule: 	Location1
Priority: 75
// Lookup = city, country, province, region, water

// Western Europe
// South China sea

(
 {Token.category == DT}
)?
(
 ({Lookup.majorType == loc_key, Lookup.minorType == pre}
 )?
 {Lookup.majorType == location}
 (
  {Lookup.majorType == loc_key, Lookup.minorType == post})?
)
:locName -->
{
 gate.FeatureMap features = Factory.newFeatureMap();
// create an annotation set consisting of all the annotations for org 
gate.AnnotationSet locSet = (gate.AnnotationSet)bindings.get("locName");
// create an annotation set consisting of the annotation matching Lookup
gate.AnnotationSet loc = (gate.AnnotationSet)locSet.get("Lookup");
// if the annotation type Lookup doesn't exist, do nothing
if (loc != null && loc.size()>0)
{
// if it does exist, take the first element in the set
  gate.Annotation locAnn = (gate.Annotation)loc.iterator().next();
//propagate minorType feature (and value) from loc
  features.put("locType", locAnn.getFeatures().get("minorType"));
}
// create some new features
  features.put("rule", "Location1");
// create a TempLoc annotation and add the features we've created
outputAS.add(locSet.firstNode(), locSet.lastNode(), "TempLocation",
features);
}

Rule:	GazLocation
Priority: 70
(
 {Token.category == DT}
)?  
(
 {Lookup.majorType == location}
)
:locName
 --> 	
{
 gate.FeatureMap features = Factory.newFeatureMap();
// create an annotation set consisting of all the annotations for org 
gate.AnnotationSet locSet = (gate.AnnotationSet)bindings.get("locName");
// create an annotation set consisting of the annotation matching Lookup
gate.AnnotationSet loc = (gate.AnnotationSet)locSet.get("Lookup");
// if the annotation type Lookup doesn't exist, do nothing
if (loc != null && loc.size()>0)
{
// if it does exist, take the first element in the set
  gate.Annotation locAnn = (gate.Annotation)loc.iterator().next();
//propagate minorType feature (and value) from loc
  features.put("locType", locAnn.getFeatures().get("minorType"));
}
// create some new features
  features.put("rule", "GazLocation");
// create a TempLoc annotation and add the features we've created
outputAS.add(locSet.firstNode(), locSet.lastNode(), "TempLocation",
features);
}




Rule: LocationPost
Priority: 50
(
 {Token.category == DT}
)?
(
 {Token.category == NNP}
 {Lookup.majorType == loc_key, Lookup.minorType == post}
)
:locName
-->
 :locName.TempLocation = {kind = "locName", rule = LocationPost}

Rule:LocKey
(
 {Token.category == DT}
)?
(
 ({Lookup.majorType == loc_key, Lookup.minorType == pre}
 )
 (UPPER)
 (
  {Lookup.majorType == loc_key, Lookup.minorType == post})?
)
:locName -->
:locName.TempLocation = {kind = "locName", rule = LocKey}
/////////////////////////////////////////////////////////////////

// Context-based Rules


Rule:InLoc1
(
 {Token.string == "in"}
)
(
 {Lookup.majorType == location}
)
:locName
-->
 :locName.TempLocation = {kind = "locName", rule = InLoc1}

Rule:LocGeneralKey
Priority: 30
(
 {Lookup.majorType == loc_general_key}
 {Token.string == "of"}
)
(
 (UPPER)
)
:loc
-->
 :loc.TempLocation = {kind = "locName", rule = LocGeneralKey}


Rule:OrgContext1
Priority: 1
// company X

(
 {Token.string == "company"}
)
(
 (UPPER)
 (UPPER)?
 (UPPER)? 
)
:org
-->
 :org.TempOrganization= {kind = "orgName", rule = "OrgContext1"}

Rule: OrgContext2
Priority: 5

// Telstar laboratory
// Medici offices

(
 (UPPER)
 (UPPER)?
 (UPPER)? 
)
: org
(
 ({Token.string == "offices"} |
 {Token.string == "Offices"} |
 {Token.string == "laboratory"} | 
 {Token.string == "Laboratory"} |
 {Token.string == "laboratories"} |
 {Token.string == "Laboratories"})
)
-->
 :org.TempOrganization= {kind = "orgName", rule = "OrgContext2"}



Rule:JoinOrg
Priority: 50
// Smith joined Energis

(
 ({Token.string == "joined"}|
  {Token.string == "joining"}|
  {Token.string == "joins"}|
  {Token.string == "join"}
 )
)
(
 (UPPER)
 (UPPER)?
 (UPPER)?
)
:org
-->
 :org.TempOrganization= {kind = "orgName", rule = "joinOrg"}