/// <summary>
/// Trace meronyms.
/// </summary>
/// <param name="pbase"></param>
/// <param name="fpos"></param>
/// <param name="depth"></param>
void traceInherit(PointerType pbase, PartOfSpeech fpos, int depth)
{
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
if (pt.ptp.ident == HYPERPTR && (pt.sce == 0 || pt.sce == whichword))
{
spaces("TRACEI", depth);
SynSet cursyn = new SynSet(pt.off, pt.pos, this);
search.wordsFrom(cursyn);
cursyn.str("=> ", "\n", 1, 0, 0, 1);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (this.senses == null)
{
this.senses = new SynSetList();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
// TODO: This is adding senses incorrectly
this.senses.Add(cursyn);
cursyn.tracePtrs(pbase, PartOfSpeech.of("noun"), depth);
cursyn.tracePtrs(pbase + 1, PartOfSpeech.of("noun"), depth);
cursyn.tracePtrs(pbase + 2, PartOfSpeech.of("noun"), depth);
if (depth > 0)
{
depth = depthcheck(depth);
cursyn.traceInherit(pbase, cursyn.pos, depth + 1);
}
}
}
search.trunc();
}
/// <summary>
/// Trace nominalizations.
/// </summary>
/// <param name="ptp"></param>
internal void tracenomins(PointerType ptp) //,PartOfSpeech fpos)
{
/*
* int j;
* int idx = 0;
* ArrayList prlist = new ArrayList();
*/
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
// TDMS 26/8/05 changed DERIVATION to NOMINALIZATIONS - verify this
if (pt.ptp.ident == NOMINALIZATIONS && (pt.sce == 0 || pt.sce == whichword))
{
if (!search.prflag)
{
strsns(sense + 1);
search.prflag = true;
}
spaces("TRACEP", 0);
SynSet cursyn = new SynSet(pt.off, pt.pos, this);
search.wordsFrom(cursyn);
cursyn.str("RELATED TO-> ", "\n", 0, 0, 0, 0);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (this.senses == null)
{
this.senses = new SynSetList();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
this.senses.Add(cursyn);
cursyn.tracePtrs(ptp, cursyn.pos, 0);
/*
* for (j = 0; j < idx; j++)
* {
* //#ifdef FOOP
* // if (synptr->ptroff[i] == prlist[j])
* // {
* // break;
* // }
* //#endif
* }
*
* if (j == idx)
* {
* prlist.Add(pt.off);
* spaces("TRACEP",2);
* cursyn.str("=> ","\n",1,0,0,1);
* }
*/
}
}
}
/// <summary>
/// Trace coordinate terms.
/// </summary>
/// <param name="ptp"></param>
/// <param name="fpos"></param>
/// <param name="depth"></param>
internal void traceCoords(PointerType ptp, PartOfSpeech fpos, int depth)
{
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
/* WN2.0
* if (pt.ptp.mnemonic=="HYPERPTR" &&
* (pt.sce==0 ||
* pt.sce==whichword))
*/
// WN2.1 if statement change - TDMS
if ((pt.ptp.ident == HYPERPTR || pt.ptp.ident == INSTANCE) &&
((pt.sce == 0) ||
(pt.sce == whichword)))
{
if (!search.prflag)
{
strsns(sense + 1);
search.prflag = true;
}
spaces("TRACEC", depth);
SynSet cursyn = new SynSet(pt.off, pt.pos, this);
search.wordsFrom(cursyn);
cursyn.str("-> ", "\n", 1, 0, 0, 1);
cursyn.tracePtrs(ptp, cursyn.pos, depth);
// TDMS 6 Oct 2005 - build hierarchical results
if (this.senses == null)
{
this.senses = new SynSetList();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
this.senses.Add(cursyn);
if (depth > 0)
{
depth = depthcheck(depth);
cursyn.traceCoords(ptp, cursyn.pos, depth + 1);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (this.senses == null)
{
this.senses = new SynSetList();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
this.senses.Add(cursyn);
}
}
}
}
void WNOverview()
{
Index idx;
//senses = new ArrayList();
senses = new SynSetList();
Indexes ixs = new Indexes(word, pos);
while ((idx = ixs.next()) != null)
{
buf += "\n";
/* Print synset for each sense. If requested, precede
* synset with synset offset and/or lexical file information.*/
for (int sens = 0; sens < idx.offs.Length; sens++)
{
for (int j = 0; j < senses.Count; j++)
{
SynSet ss = (SynSet)senses[j];
if (ss.hereiam == idx.offs[sens])
{
goto skipit;
}
}
SynSet cursyn = new SynSet(idx, sens, this);
bool svdflag = WNOpt.opt("-g").flag;
WNOpt.opt("-g").flag = true;
bool svaflag = WNOpt.opt("-a").flag;
WNOpt.opt("-a").flag = WNOpt.opt("-A").flag;
bool svoflag = WNOpt.opt("-o").flag;
WNOpt.opt("-o").flag = WNOpt.opt("-O").flag;
cursyn.str("" + (sens + 1) + ". ", "\n", 1, 0, 0, 0);
WNOpt.opt("-g").flag = svdflag;
WNOpt.opt("-a").flag = svaflag;
WNOpt.opt("-o").flag = svoflag;
wordsFrom(cursyn);
cursyn.frames.Clear(); // TDMS 03 Jul 2006 - frames get added in wordnet.cs after filtering
senses.Add(cursyn);
skipit :;
}
/* Print sense summary message */
if (senses.Count > 0)
{
taggedSenses = 0;
if (senses.Count == 1)
{
buf += "\nThe " + pos.name + " " + idx.wd + " has 1 sense";
}
else
{
buf += "\nThe " + pos.name + " " + idx.wd + " has " + senses.Count + " senses";
}
if (idx.tagsense_cnt > 0)
{
taggedSenses = idx.tagsense_cnt;
buf += " (first " + idx.tagsense_cnt + " from tagged texts)\n";
}
else
{
buf += " (no senses from tagged texts)\n";
}
}
}
}
// From the WordNet Manual (http://wordnet.princeton.edu/man/wnsearch.3WN.html)
// findtheinfo() is the primary search algorithm for use with database interface
// applications. Search results are automatically formatted, and a pointer to the
// text buffer is returned. All searches listed in WNHOME/include/wnconsts.h can be
// done by findtheinfo().
void findtheinfo()
{
SynSet cursyn = null;
Indexes ixs = new Indexes(word, pos);
Index idx = null;
int depth = sch.rec ? 1 : 0;
senses = new SynSetList();
switch (sch.ptp.mnemonic)
{
case "OVERVIEW":
WNOverview();
break;
case "FREQ":
if (countSenses == null)
{
countSenses = new ArrayList();
}
while ((idx = ixs.next()) != null)
{
countSenses.Add(idx.offs.Length);
buf += "Sense " + countSenses.Count + ": " +
idx.offs.Length;
}
break;
case "WNGREP":
strings = WNDB.wngrep(word, pos);
for (int wi = 0; wi < strings.Count; wi++)
{
buf += (string)strings[wi] + "\n";
}
break;
case "VERBGROUP":
goto case "RELATIVES";
case "RELATIVES":
while ((idx = ixs.next()) != null)
{
relatives(idx);
}
break;
default:
/* look at all spellings of word */
while ((idx = ixs.next()) != null)
{
/* Print extra sense msgs if looking at all senses */
if (whichsense == ALLSENSES)
{
buf += "\n";
}
/* Go through all of the searchword's senses in the
* database and perform the search requested. */
for (int sense = 0; sense < idx.offs.Length; sense++)
{
if (whichsense == ALLSENSES || whichsense == sense + 1)
{
prflag = false;
/* Determine if this synset has already been done
* with a different spelling. If so, skip it. */
for (int j = 0; j < senses.Count; j++)
{
SynSet ss = (SynSet)senses[j];
if (ss.hereiam == idx.offs[sense])
{
goto skipit;
}
}
cursyn = new SynSet(idx, sense, this);
//TODO: moved senses.add(cursyn) from here to each case and handled it differently according to search - this handling needs to be verified to ensure the filter is not to limiting
switch (sch.ptp.mnemonic)
{
case "ANTPTR":
if (pos.name == "adj")
{
cursyn.traceAdjAnt();
}
else
{
cursyn.tracePtrs(sch.ptp, pos, depth);
}
if (cursyn.isDirty)
{ // TDMS 25 Oct 2005 - restrict to relevant values
cursyn.frames.Clear(); // TDMS 03 Jul 2006 - frames get added in wordnet.cs after filtering
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty)
* { // TDMS 25 Oct 2005 - restrict to relevant values
* cursyn.frames.Clear(); // TDMS 03 Jul 2006 - frames get added in wordnet.cs after filtering
* senses.Add(cursyn);
* }
*/
// perform the senses restrictions based upon pos
/*
* switch(pos.name) {
* case "verb":
* if (cursyn.senses != null) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
* break;
*
* default:
* if (cursyn.senses != null && cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
* break;
* }
*/
break;
case "COORDS":
//eg. search for 'car', select Noun -> 'Coordinate Terms'
cursyn.traceCoords(PointerType.of("HYPOPTR"), pos, depth);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "FRAMES":
//eg. search for 'right', select Verb -> 'Sample Sentences'
cursyn.strFrame(true);
// TDMS 03 JUL 2006 fixed relevancy check if (cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
if (cursyn.isDirty)
{
senses.Add(cursyn);
}
/*
* if (cursyn.frames.Count != 0) // TDMS 03 Jul 2006 - only add frame if there are any retrieved
* senses.Add(cursyn);
*/
break;
case "MERONYM":
//eg. search for 'car', select Noun -> 'Meronym'
senses.isDirty = false;
cursyn.tracePtrs(PointerType.of("HASMEMBERPTR"), pos, depth);
cursyn.tracePtrs(PointerType.of("HASSTUFFPTR"), pos, depth);
cursyn.tracePtrs(PointerType.of("HASPARTPTR"), pos, depth);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "HOLONYM":
//eg. search for 'car', select Noun -> 'Holonyms'
cursyn.tracePtrs(PointerType.of("ISMEMBERPTR"), pos, depth);
cursyn.tracePtrs(PointerType.of("ISSTUFFPTR"), pos, depth);
cursyn.tracePtrs(PointerType.of("ISPARTPTR"), pos, depth);
// if (cursyn.senses != null && cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
// senses.Add(cursyn);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "HMERONYM":
//eg. search for 'car', select Noun -> 'Meronyms Tree'
cursyn.partsAll(sch.ptp);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
// senses.Add(SearchTrack.ssParent);
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
// if (cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
// senses.Add(cursyn);
break;
case "HHOLONYM":
cursyn.partsAll(sch.ptp);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null) // && cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "SEEALSOPTR":
cursyn.seealso();
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "SIMPTR":
goto case "HYPERPTR";
case "SYNS":
goto case "HYPERPTR";
case "HYPERPTR":
//eg. search for 'car', select Noun -> 'Synonyms/Hypernyms, ordered by estimated frequency'
wordsFrom(cursyn);
cursyn.strsns(sense + 1);
prflag = true;
cursyn.tracePtrs(sch.ptp, pos, depth);
if (pos.name == "adj")
{
cursyn.tracePtrs(PointerType.of("PERTPTR"), pos, depth);
cursyn.tracePtrs(PointerType.of("PPLPTR"), pos, depth);
}
else if (pos.name == "adv")
{
cursyn.tracePtrs(PointerType.of("PERTPTR"), pos, depth);
}
if (pos.name == "verb")
{
cursyn.strFrame(false);
}
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
// senses.Add(cursyn);
break;
case "NOMINALIZATIONS": // 26/8/05 - changed "DERIVATION" to "NOMINALIZATIONS" - this needs to be verified
// derivation - TDMS
cursyn.tracenomins(sch.ptp);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.sense != 0) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "CLASSIFICATION":
goto case "CLASS";
case "CLASS":
//eg. search for 'car', select Noun -> 'Domain Terms'
cursyn.traceclassif(sch.ptp, new SearchType(false, sch.ptp));
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
case "HYPOPTR":
//eg. search for 'car', select Noun -> 'Hyponyms'
cursyn.tracePtrs(sch.ptp, pos, depth);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty)
* { // TDMS 25 Oct 2005 - restrict to relevant values
* cursyn.frames.Clear(); // TDMS 03 Jul 2006 - frames get added in wordnet.cs after filtering
* senses.Add(cursyn);
* }
*/
break;
default:
cursyn.tracePtrs(sch.ptp, pos, depth);
if (cursyn.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
{
senses.Add(cursyn);
}
/*
* if (cursyn.senses != null )
* if (cursyn.senses.isDirty) // TDMS 25 Oct 2005 - restrict to relevant values
* senses.Add(cursyn);
*/
break;
}
skipit :;
}
}
}
break;
}
}
/// <summary>
/// Trace adjective antonyms.
/// </summary>
internal void traceAdjAnt()
{
SynSet newsynptr;
int i, j;
AdjSynSetType anttype = AdjSynSetType.DirectAnt;
SynSet simptr, antptr;
string similar = " => ";
/* This search is only applicable for ADJ synsets which have
* either direct or indirect antonyms (not valid for pertainyms). */
if (sstype == AdjSynSetType.DirectAnt || sstype == AdjSynSetType.IndirectAnt)
{
strsns(sense + 1);
search.buf += "\n";
/* if indirect, get cluster head */
if (sstype == AdjSynSetType.IndirectAnt)
{
anttype = AdjSynSetType.IndirectAnt;
i = 0;
while (ptrs[i].ptp.ident != SIMPTR)
{
i++;
}
newsynptr = new SynSet(ptrs[i].off, PartOfSpeech.of("adj"), this);
}
else
{
newsynptr = this;
}
/* find antonyms - if direct, make sure that the antonym
* ptr we're looking at is from this word */
for (i = 0; i < newsynptr.ptrs.Length; i++)
{
if (newsynptr.ptrs[i].ptp.ident == ANTPTR && // TDMS 11 JUL 2006 // mnemonic=="ANTPTR" &&
((anttype == AdjSynSetType.DirectAnt &&
newsynptr.ptrs[i].sce == newsynptr.whichword) ||
anttype == AdjSynSetType.IndirectAnt))
{
/* read the antonym's synset and print it. if a
* direct antonym, print it's satellites. */
antptr = new SynSet(newsynptr.ptrs[i].off, PartOfSpeech.of("adj"), this);
search.wordsFrom(antptr);
// TDMS 6 Oct 2005 - build hierarchical results
if (this.senses == null)
{
this.senses = new SynSetList();
}
//TODO: check the ptrs reference
antptr.thisptr = newsynptr.ptrs[i]; // TDMS 17 Nov 2005 - add this pointer type
this.senses.Add(antptr);
if (anttype == AdjSynSetType.DirectAnt)
{
antptr.str("", "\n", 1, 0, 1, 1);
for (j = 0; j < antptr.ptrs.Length; j++)
{
if (antptr.ptrs[j].ptp.ident == SIMPTR) // TDMS 11 JUL 2006 - changed to INT //.mnemonic=="SIMPTR")
{
simptr = new SynSet(antptr.ptrs[j].off, PartOfSpeech.of("adj"), this);
search.wordsFrom(simptr);
simptr.str(similar, "\n", 1, 0, 0, 1);
// TDMS 6 Oct 2005 - build hierarchical results
if (antptr.senses == null)
{
antptr.senses = new SynSetList();
}
antptr.senses.Add(simptr);
}
}
}
else
{
antptr.strAnt("\n", anttype, 1);
}
}
}
}
}
/// <summary>
/// Trace classification.
/// </summary>
/// <param name="ptp"></param>
/// <param name="stp"></param>
internal void traceclassif(PointerType ptp, SearchType stp) //,PartOfSpeech fpos)
{
int j;
int idx = 0;
//int svwnsnsflag;
string head = "";
int LASTTYPE = PointerType.of("CLASS").ident;
int OVERVIEW = (LASTTYPE + 9);
int MAXSEARCH = OVERVIEW;
int CLASSIF_START = (MAXSEARCH + 1);
int CLASSIF_CATEGORY = (CLASSIF_START); /* ;c */
int CLASSIF_USAGE = (CLASSIF_START + 1); /* ;u */
int CLASSIF_REGIONAL = (CLASSIF_START + 2); /* ;r */
int CLASSIF_END = CLASSIF_REGIONAL;
int CLASS_START = (CLASSIF_END + 1);
int CLASS_CATEGORY = (CLASS_START); /* -c */
int CLASS_USAGE = (CLASS_START + 1); /* -u */
int CLASS_REGIONAL = (CLASS_START + 2); /* -r */
int CLASS_END = CLASS_REGIONAL;
//long prlist[1024];
ArrayList prlist = new ArrayList();
for (int i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
if (((pt.ptp.ident >= CLASSIF_START) &&
(pt.ptp.ident <= CLASSIF_END) && stp.ptp.ident == PointerType.of("CLASSIFICATION").ident) ||
((pt.ptp.ident >= CLASS_START) &&
(pt.ptp.ident <= CLASS_END) && stp.ptp.ident == PointerType.of("CLASS").ident))
{
if (!search.prflag)
{
strsns(sense + 1);
search.prflag = true;
}
SynSet cursyn = new SynSet(pt.off, pt.pos, this);
// TDMS 6 Oct 2005 - build hierarchical results
// TODO: verify this
if (this.senses == null)
{
this.senses = new SynSetList();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
this.senses.Add(cursyn);
for (j = 0; j < idx; j++)
{
if (pt.off == Convert.ToInt16(prlist[j]))
{
break;
}
}
if (j == idx)
{
prlist.Add(pt.off);
spaces("TRACEP", 0);
if (pt.ptp.ident == CLASSIF_CATEGORY)
{
head = "TOPIC->("; // WN2.1 - TDMS
}
// head = "CATEGORY->(";
else if (pt.ptp.ident == CLASSIF_USAGE)
{
head = "USAGE->(";
}
else if (pt.ptp.ident == CLASSIF_REGIONAL)
{
head = "REGION->(";
}
else if (pt.ptp.ident == CLASS_CATEGORY)
{
head = "TOPIC_TERM->("; // WN2.1 - TDMS
}
// head = "CATEGORY_TERM->(";
else if (pt.ptp.ident == CLASS_USAGE)
{
head = "USAGE_TERM->(";
}
else if (pt.ptp.ident == CLASS_REGIONAL)
{
head = "REGION_TERM->(";
}
head += pt.pos.name;
head += ") ";
//svwnsnsflag = wnsnsflag;
//wnsnsflag = 1;
// printsynset(head, cursyn, "\n", DEFOFF, ALLWORDS,
// SKIP_ANTS, SKIP_MARKER);
cursyn.str(head, "\n", 0, 0, 0, 0);
//wnsnsflag = svwnsnsflag;
}
}
}
}
/// <summary>
/// Traces pointer hierarchy.
/// </summary>
/// <param name="stp"></param>
/// <param name="fpos"></param>
/// <param name="depth"></param>
internal void tracePtrs(SearchType stp, PartOfSpeech fpos, int depth)
{
int i;
SynSet cursyn;
PointerType ptp = stp.ptp;
string prefix;
int realptr; // WN2.1
for (i = 0; i < ptrs.Length; i++)
{
Pointer pt = ptrs[i];
// following if statement is WN2.1 - TDMS
if ((ptp.ident == HYPERPTR && (pt.ptp.ident == HYPERPTR ||
pt.ptp.ident == INSTANCE)) ||
(ptp.ident == HYPOPTR && (pt.ptp.ident == HYPOPTR ||
pt.ptp.ident == INSTANCES)) ||
((pt.ptp == ptp) &&
((pt.sce == 0) ||
(pt.sce == whichword))))
{
realptr = pt.ptp.ident; /* WN2.1 deal with INSTANCE */
if (!search.prflag) // print sense number and synset
{
strsns(sense + 1);
}
search.prflag = true;
spaces("TRACEP", depth + (stp.rec?2:0));
// switch (ptp.mnemonic)
// TDMS 11 JUL 2006 - changed switch to ident switch (pt.ptp.mnemonic) // TDMS - WN2.1 MOD
switch (pt.ptp.ident) // TDMS 11 JUL 2006 - changed switch to ident
{
case PERTPTR:
if (fpos.name == "adv") // TDMS "adverb")
{
prefix = "Derived from " + pt.pos.name + " ";
}
else
{
prefix = "Pertains to " + pt.pos.name + " ";
}
break;
case ANTPTR: // TDMS 26/8/05
if (fpos.name == "adj") //TODO: which adjective will fall into the below?
{
prefix = "Antonym of ";
}
else
{
prefix = "";
}
break;
case PPLPTR:
prefix = "Participle of verb";
break;
case INSTANCE:
prefix = "INSTANCE OF=> ";
break;
case INSTANCES:
prefix = "HAS INSTANCE=> ";
break;
case HASMEMBERPTR:
prefix = " HAS MEMBER: "; break;
case HASSTUFFPTR:
prefix = " HAS SUBSTANCE: "; break;
case HASPARTPTR:
prefix = " HAS PART: "; break;
case ISMEMBERPTR:
prefix = " MEMBER OF: "; break;
case ISSTUFFPTR: // TDMS 26/8/05
prefix = " SUBSTANCE OF: ";
break;
case ISPARTPTR: // TDMS 26/8/05
prefix = " PART OF: ";
break;
default:
prefix = "=> "; break;
}
/* Read synset pointed to */
cursyn = new SynSet(pt.off, pt.pos, this);
search.wordsFrom(cursyn);
// TDMS 6 Oct 2005 - build hierarchical results
if (this.senses == null)
{
this.senses = new SynSetList();
}
cursyn.thisptr = pt; // TDMS 17 Nov 2005 - add this pointer type
this.senses.Add(cursyn);
/* For Pertainyms and Participles pointing to a specific
* sense, indicate the sense then retrieve the synset
* pointed to and other info as determined by type.
* Otherwise, just print the synset pointed to. */
if ((ptp.ident == PERTPTR || ptp.ident == PPLPTR) &&
pt.dst != 0)
{
string tbuf = " (Sense " + cursyn.getsearchsense(pt.dst) + ")";
cursyn.str(prefix, tbuf, 0, pt.dst, 0, 1);
if (ptp.ident == PPLPTR) // adj pointing to verb
{
cursyn.str(" =>", "\n", 1, 0, 1, 1);
cursyn.tracePtrs(PointerType.of("HYPERPTR"), cursyn.pos, 0);
}
else if (fpos.name == "adverb") // adverb pointing to adjective
{
cursyn.str(" =>", "\n", 0, 0, (pos.clss == "SATELLITE")?0:1, 1);
// cursyn.traceptrs(HYPERPTR,pos,0);
}
else // adjective pointing to noun
{
cursyn.str(" =>", "\n", 1, 0, 1, 1);
cursyn.tracePtrs(PointerType.of("HYPERPTR"), pos, 0);
}
}
else
{
cursyn.str(prefix, "\n", 1, 0, 1, 1);
}
/* For HOLONYMS and MERONYMS, keep track of last one
* printed in buffer so results can be truncated later. */
if (ptp.ident >= PointerType.of("ISMEMBERPTR").ident&&
ptp.ident <= PointerType.of("HASPARTPTR").ident)
{
search.mark();
}
if (depth > 0)
{
depth = cursyn.depthcheck(depth);
cursyn.tracePtrs(ptp, cursyn.pos, depth + 1);
}
}
}
}