{

FACT* F = GetObjectNondeadHead(set);

while (F)

{

if (F->verb == Mmember) break; // exclusions come first, so none found

if (F->verb == Mexclude)

{

if (Meaning2Word(F->subject) == item) break;

}

F = GetObjectNondeadNext(F);

}

return (F) ? true : false;

{

if (!M || !set) return false;

// the word

WORDP D = Meaning2Word(M);

unsigned int index = Meaning2Index(M);

D->inferMark = inferMark;

FACT* F = GetSubjectNondeadHead(D);

WORDP D1 = Meaning2Word(set);

// we walk up the tree from the word and see if it runs into D1, the set.

if (depth == 0)

{

SetFactBack(D,0);

if (trace & TRACE_INFER && CheckTopicTrace("^query")) Log(USERLOG," %s ? %s ",D->word,D1->word);

}

unsigned int counter = 20000;

while (F && --counter)

{

if (index != 0 && F->subject != M); // fact doesnt apply

else if (ValidMemberFact(F))

{

// if this topic or concept has exclusions, check to see if this is a marked exclusion

bool blocked = false;

WORDP object = Meaning2Word(F->object);

FACT* G = GetObjectNondeadHead(object);

while (G && !blocked)

{

if (G->verb == Mexclude)

{

if (Meaning2Word(G->subject)->inferMark == inferMark) blocked = true;

}

else if (G->verb == Mmember) break;

G = GetObjectNondeadNext(G);

}

// since this is not a marked exclusion, we can say it is a member

if (F->object == set && !blocked)

{

if (trace & TRACE_INFER && CheckTopicTrace("^query")) // show the path from set back to word

{

Log(USERLOG,"\r\n");

Log(USERLOG,"within: %s ",D1->word);

WORDP path = Meaning2Word(F->subject);

while (path)

{

Log(USERLOG," %s ",path->word);

FACT* prior = Index2Fact(GetFactBack(path));

path = (prior) ? Meaning2Word(prior->subject) : 0;

}

Log(USERLOG,"\r\n");

Log(USERLOG,"");

}

return true;

}

if (!blocked && object->inferMark != inferMark)

{

SetFactBack(object,Fact2Index(F));

if (SetContains1(set,F->object,depth + 1)) return true;

}

}

else if (F->verb == Mis) // a link up the wordnet ontology

{

if (F->object == set) return true;

WORDP object = Meaning2Word(F->object);

if (object->inferMark != inferMark)

{

SetFactBack(object,Fact2Index(F));

if (SetContains1(set,F->object,depth + 1)) return true;

}

}

F = GetSubjectNondeadNext(F);

}

if (trace & TRACE_INFER && depth == 0 && CheckTopicTrace("^query"))

{

Log(USERLOG," not within ");

}

return false;

{

bool answer = SetContains1(set,M,0);

ClearBacktracks();

return answer;

{

if (trace & TRACE_INFER && CheckTopicTrace("^query")) TraceFact(F);

unsigned int localIndex = Meaning2Index(F->subject);

unsigned int pos = GetMeaningType(F->subject);

bool bad = false;

if (!i && pos )

{

if (pos & VERB && is & NOUN)

{

bad = true;

}

else if (pos & NOUN && is & VERB)

{

bad = true;

}

else if ((pos & ADJECTIVE || localIndex & ADVERB) && is & (NOUN|VERB))

{

bad = false;

}

}

else if (index && pos && pos != index) bad = true;

return !bad;

{

if (!D || D->inferMark == inferMark) return;

D->inferMark = inferMark;

FACT* F;

FACT* G = GetSubjectNondeadHead(D);

unsigned int count = 20000;

unsigned int restriction = 0;

if (kind) // limitation on translation of word as member of a set

{

if (!strnicmp(kind,(char*)"subject",7)) restriction = NOUN;

else if (!strnicmp(kind,(char*)"verb",4)) restriction = VERB;

else if (!strnicmp(kind,(char*)"object",7)) restriction = NOUN;

}

while (G)

{

F = G;

G = GetSubjectNondeadNext(G);

if (trace & TRACE_INFER && CheckTopicTrace("^query")) TraceFact(F);

if (!--count)

{

ReportBug((char*)"matchfacts infinite loop")

break;

}

uint64 flags = F->flags;

unsigned int fromindex = Meaning2Index(F->subject);

if (fromindex == index || !fromindex); // we allow penguins to go up to bird, then use unnamed bird to go to ~topic

else if (index ) continue; // not following this path

else if (flags & ORIGINALWORD) continue; // you must match exactly- generic not allowed to match specific wordnet meaning- hierarchy BELOW only

if (ValidMemberFact(F) && !AllowedMember(F,0,restriction,0)) continue; // POS doesn't match

if (ValidMemberFact(F) && !(flags & ORIGINALWORD))

{

WORDP object = Meaning2Word(F->object);

if (object->inferMark != inferMark)

{

if (*object->word == '~') // set, not a word association

{

if (IsExcluded(object,original)) continue; // explicitly excluded from this set

if (object->internalBits & TOPIC)

{

int topicid = FindTopicIDByName(object->word);

if (topicid && !(GetTopicFlags(topicid) & TOPIC_SYSTEM) && HasGambits(topicid)) AddFact(store,CreateFact(MakeMeaning(original,0),A,MakeMeaning(object,0),FACTTRANSIENT));

}

}

QueryFacts(original,object,0,store,kind,A);

}

}

}

{

SET_FACTSET_COUNT(store,0);

NextInferMark();

WORDP D = FindWord(word,0);

QueryFacts(D,D,0,store,kind,MakeMeaning(FindWord((char*)"a")));

if (trace & TRACE_INFER) Log(USERLOG,"QueryTopics: %s %d ",word,FACTSET_COUNT(store));

impliedSet = ALREADY_HANDLED;

return NOPROBLEM_BIT;

{

if (queueIndex >= MAX_QUEUE || !M) return false;

if (type && !(M & type) && GETTYPERESTRICTION(M)) return false; // not valid type restriction

// mark word or abandon marking

WORDP D = Meaning2Word(M);

unsigned int index = Meaning2Index(M);

if (D->inferMark == saveMark || (ignoremark && D->inferMark == ignoremark)) return false; // marked with a current mark

if (depth > FOLLOW_LIMIT)

{

ReportBug((char*)"Exceeding follow limit %s\r\n",D->word)

return false;

}

// concept set has exclusions, so if excluded is already marked, do not allow this topic to be marked

FACT* G = GetObjectNondeadHead(D);

while (G)

{

if (G->verb == Mexclude)

{

if (Meaning2Word(G->subject)->inferMark == saveMark) return false;

}

if (G->verb == Mmember) break;

G = GetObjectNondeadNext(G);

}

D->inferMark = saveMark;

if (flags & QUEUE) queue[queueIndex++] = M;

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

static char last[1000];

if (from)

{

char* mean = WriteMeaning(from);

if (stricmp(last,mean))

{

Log(USERLOG,"(%s=>) ",mean);

if (strlen(mean) > 999)

ReportBug("Scan insert > 1000")

else strcpy(last,mean);

}

}

Log(USERLOG,(flags & QUEUE) ? (char*)" %s+" : " %s. ",WriteMeaning(M));

}

// auto check all equivalences as well

FACT* F = GetSubjectNondeadHead(D);

while (F)

{

if (ValidMemberFact(F)) // can be member of an ordinary word (like USA member United_States_of_America), creates equivalence

{

WORDP E = Meaning2Word(F->object);

if (*E->word != '~') AddWord2Scan(flags,F->object,F->subject,depth+1,type); // member is not to a set, but to a word. So it's an equivalence

}

F = GetSubjectNondeadNext(F);

}

// and if item is generic, all synsets

if (index == 0 && !(flags & ORIGINALWORD))

{

unsigned int count = GetMeaningCount(D);

for (unsigned int i = 1; i <= count; ++i) AddWord2Scan(flags,GetMeaning(D,i),M,depth+1,type);

}

return true;

{

if (queueIndex >= MAX_QUEUE || !*word) return false;

// mark word or abandon marking

WORDP D = StoreWord(word,AS_IS);

if (D->inferMark == saveMark) return false; // marked with a current mark

D->inferMark = saveMark;

if (flags & QUEUE) queue[queueIndex++] = MakeMeaning(D);

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG,(flags & QUEUE) ? (char*)" %s+" : (char*)" %s. ",D->word);

return true;

{

++depth;

if (!(how & ORIGINALWORD) && *word == '~' && word[1]) // recursive on set and all its members

{

WORDP D = FindWord(word,0);

if (D)

{

if (how & NOTOPIC && D->internalBits & TOPIC) {;}

else if (AddWord2Scan(how, MakeMeaning(D,0),0,depth,0)) AddSet2Scan(how,D,depth); // mark the original name and then follow its members

}

}

else

{

if (*word == '\'')

{

// WORDP D = FindWord(word);

//if (!D)

++word; // but dont harm 'tween_decks which is natural

}

AddWord2Scan(how, ReadMeaning(word, true, true), 0, depth, 0);

}

{

++depth;

FACT* F = GetObjectNondeadHead(D);

while (F)

{

if (ValidMemberFact(F)) AddWordOrSet2Scan(how | (F->flags & ORIGINALWORD),Meaning2Word(F->subject)->word,depth);

F = GetObjectNondeadNext(F);

}

{

if (!T) return;

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG,"\r\nHierarchy: (%s=>) ",WriteMeaning(T));

if (!AddWord2Scan(flag,T,0,0,type)) return;

parentIndex = parentWalk = 0;

parents[parentIndex++] = T;

WORDP A = Meaning2Word(T);

int index = Meaning2Index(T);

int start = 1;

// find its wordnet ontological meanings, they then link synset head to synset head

// automatically store matching synset heads to this also -- THIS APPLIES ONLY TO THE ORIGINAL WORDP

MEANING* onto = GetMeaningsFromMeaning(T);

unsigned int size = GetMeaningCount(A);

if (!up || flag & BLOCKMEANING ) size = 0;// we are a specific meaning already, so are the synset head of something - or are going down

else if (index) start= size = index; // do JUST this one

else if (!size) size = 1; // even if no ontology, do it once for

for (unsigned int k = start; k <= size; ++k) // for each meaning of this word, mark its synset heads

{

MEANING T1;

if (GetMeaningCount(A))

{

T1 = (MEANING)(ulong_t)onto[k]; // this is the synset ptr.

if (T1 & SYNSET_MARKER) T1 = MakeMeaning(A,k) | SYNSET_MARKER;

else T1 = GetMaster(T1);

if (type && !(T1 & type)) continue;

if (! AddWord2Scan(flag,T1,T,0,type)) continue; // either already marked OR to be ignored

parents[parentIndex++] = T1;

}

}

while (parentWalk < parentIndex) // walk up its chains in stages

{

T = parents[parentWalk++];

if (!T) continue;

if (parentIndex > MAX_PARENTS) break; // overflow may happen. give up

WORDP D = Meaning2Word(T);

unsigned int index = Meaning2Index(T);

// now follow facts of the synset head itself or the word itself.

FACT* F = GetSubjectNondeadHead(D);

while (F)

{

WORDP verb = Meaning2Word(F->verb);

FACT* G = F;

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) TraceFact(F);

F = GetSubjectNondeadNext(F);

if (verb->inferMark != flowmark) continue;

// if the incoming ptr is generic, it can follow out any generic or pos_generic reference.

// It cannot follow out a specific reference of a particular meaning.

// An incoming non-generic ptr is always specific (never pos_generic) and can only match specific exact.

if (index && T != G->subject) continue; // generic can run all meanings out of here

MEANING x = G->object;

if (type && GETTYPERESTRICTION(G->subject ) && !(type & GETTYPERESTRICTION(G->subject ))) continue; // fact has bad type restriction on subject

if (!AddWord2Scan(flag,x,G->subject,0,type)) continue; // either already marked OR to be ignored

parents[parentIndex++] = x;

}

}

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG,"\r\n");

{// use two fields to select a third. Then look at facts of that third to find a matching verb.

FACT* F;

WORDP D1;

if (G->flags & (FACTSUBJECT|FACTOBJECT)) // we cant get here if the wrong field is a fact.

{

D1 = fact;

F = (baseFlags & USE_ORIGINAL_SUBJECT) ? Index2Fact(G->subject) : Index2Fact(G->object);

}

else

{

D1 = (baseFlags & USE_ORIGINAL_SUBJECT) ? Meaning2Word(G->subject) : Meaning2Word(G->object);

F = (baseFlags & RICCOCHET_USING_SUBJECT) ? GetSubjectNondeadHead(D1) : GetObjectNondeadHead(D1);

}

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

WORDP S = (G->flags & FACTSUBJECT) ? fact : Meaning2Word(G->subject);

WORDP V = (G->flags & FACTVERB) ? fact : Meaning2Word(G->verb);

WORDP O = (G->flags & FACTOBJECT) ? fact : Meaning2Word(G->object);

char* use = (baseFlags & RICCOCHET_USING_SUBJECT) ? (char*) "subjectfield" : (char*) "objectfield";

if (baseFlags & USE_ORIGINAL_SUBJECT) Log(USERLOG,"Riccochet incoming (%s %s %s) via subject %s using %s\r\n",S->word,V->word,O->word,D1->word,use);

else Log(USERLOG,"Riccochet incoming (%s %s %s) via object %s using %s\r\n",S->word,V->word,O->word,D1->word,use);

}

// walk all facts at node testnig for riccochet

while (F) // walk_of_S3

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) TraceFact(F);

FACT* I = F;

if (D1 == fact) F = NULL; // only the 1 main fact

else F = (baseFlags & RICCOCHET_USING_SUBJECT) ? GetSubjectNondeadNext(F) : GetObjectNondeadNext(F);

if (I->flags & FACTDEAD) continue; // cannot use this

// reasons this fact is no good

if (I->flags & MARKED_FACT) continue; // already seen this answer

if ((baseFlags & SYSTEMFACTS && I > factLocked) || (baseFlags & USERFACTS && I <= factLocked) ) continue; // restricted by owner of fact

if (rmarks && (I->flags & FACTSUBJECT || Meaning2Word(I->subject)->inferMark != rmarks)) continue; // mark must match

if (rmarkv && (I->flags & FACTVERB || Meaning2Word(I->verb)->inferMark != rmarkv)) continue; // mark must match

if (rmarko && (I->flags & FACTOBJECT || Meaning2Word(I->object)->inferMark != rmarko)) continue; // mark must match

I->flags |= MARKED_FACT;

AddFact(set,I);

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG," Found:");

TraceFact(I);

}

if (FACTSET_COUNT(set) >= limit) return false;

}

return true;

{

if (!depth)

{

NextInferMark();

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG,"\r\n ~propogate: ");

}

FACT* F = GetSubjectNondeadHead(M);

while (F)

{

if (ValidMemberFact(F) && F->subject == M)

{

MEANING O = F->object;

WORDP D = Meaning2Word(O);

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG," %d->%s ",depth,D->word);

if (D->inferMark == mark) return true; // this is what we seek

if (D->inferMark != inferMark)// not already visited this pass or is marked for current query for other use

{

if (D->inferMark < currentBaseInfer || D->inferMark >= currentFreeInfer) D->inferMark = inferMark; // safely set seen this (efficiency)

if (*D->word == '~' && ConceptPropogateTest(O,mark,depth+1)) return true; // NOT setting been here- and dont follow fake members ( word member word)

}

}

F = GetSubjectNondeadNext(F);

}

return false;

{

int store = GetSetID(toset);

if (store == ILLEGAL_FACTSET) store = 0;

WORDP C = FindWord(kind,0);

if (!C || !(C->internalBits & QUERY_KIND))

{

ReportBug((char*)"INFO: Illegal query name: %s",kind)

return 0;

}

char copy[MAX_WORD_SIZE]; // hold the actual control value, so we can overwrite it

char* control = NULL;

if (C->w.userValue && *C->w.userValue)

{

strcpy(copy,C->w.userValue);

control = copy;

}

else

{

ReportBug((char*)"INFO: query control lacks data %s",kind)

return 0;

}

// get correct forms of arguments - _ is an empty argument, but legal

char word[MAX_WORD_SIZE];

int n;

if (!strchr(subjectword,' ')) // anything with a natural space in it should be left alone

{

n = BurstWord(subjectword);

if (n > 1) strcpy(subjectword,JoinWords(n,false));

}

if (!strchr(verbword,' ')) // anything with a natural space in it should be left alone

{

n = BurstWord(verbword);

if (n > 1) strcpy(verbword,JoinWords(n,false));

}

if (!strchr(objectword,' ')) // anything with a natural space in it should be left alone

{

n = BurstWord(objectword);

if (n > 1) strcpy(objectword,JoinWords(n,false));

}

if (!strchr(match,' ')) // anything with a natural space in it should be left alone

{

n = BurstWord(match);

if (n > 1) strcpy(match,JoinWords(n,false));

}

if (!strchr(propogate,' ')) // anything with a natural space in it should be left alone

{

n = BurstWord(propogate);

if (n > 1) strcpy(propogate,JoinWords(n,false));

}

if (trace & TRACE_QUERY )

{

Log(USERLOG,"^QUERY: @%d %s %s s/v/o:[%s %s %s] count:%d ", store, kind,control,subjectword,verbword,objectword,count);

if (*fromset != '?') Log(USERLOG,"fromset:%s ",fromset);

if (*toset != '?') Log(USERLOG,"toset:%s ",toset);

if (*propogate != '?') Log(USERLOG,"propogate:%s ",propogate);

if (*match != '?') Log(USERLOG,"match:%s ",match);

Log(USERLOG,"\r\n");

Log(USERLOG,"");

}

// handle what sets are involved

if (impliedOp == 0 || impliedOp == '=') SET_FACTSET_COUNT(store,0); // auto kill content

else if (impliedOp != '+')

{

SET_FACTSET_COUNT(store,0); // we dont support other ops like -=

return 0;

}

int from = GetSetID(fromset);

if (from == ILLEGAL_FACTSET) from = 0;

unsigned int baseFlags = 0;

char myset[10];

int baseOffset = 0; // facts come from this side, and go out the verb or other side

char* choice;

choice = 0;

char* at;

int qMark = 0;

int mark = 0;

int whichset = 0;

if (!stricmp(fromset,(char*)"user")) baseFlags |= USERFACTS;

if (!stricmp(fromset,(char*)"system")) baseFlags |= SYSTEMFACTS;

queueIndex = 0;

ignoremark = 0;

unsigned int baseMark = inferMark; // offsets of this value

currentBaseInfer = baseMark + 1; // start of used marks

// process initialization

nextsearch: // can do multiple searches, thought they have the same basemark so can be used across searchs (or not) up to 9 marks

#ifdef INFORMATION

# first segment describes what to initially mark and initially queue for processing (sources of facts)

# Values:

# 1..9 = set global tag to this label - 0 means turn off global tag

# i = use argument tag on words to ignore during a tag or queue operation

# Next char is tag label. 0 means no ignoremark

# s/v/o/p/m/~set/tick-word = use subject/verb/object/progogate/match/factset argument as item to process or use named set or given word

# S/V/O choice is a fact id

# This is automatically marked using the current mark and is followed by

# q = queue items (sets will follow to all members recursively and wordnet identities will propogate up)

# Q = queue this exact word only

# t = tag (no queue) items

# e = expandtag (no queue) (any set gets all things below it tagged)

# h = tag propogation from base (such propogation might be large)

# 1ST char after h is mark on verbs to propogate thru

# 2nd char is t or q (for tag or mark/queue)

# 3rd char (< >) after h is whether to propogate up from left/subject to object or down/right from object to subject when propogating

# n = implied all topics marked to ignore on object

# f = use given facts in from as items to process -- f@n means use this set

# This is followed by

# s/v/o/f = use corresponding field of fact or entire fact

# the value to process will be marked AND may or may not get stored, depending on following flag being q or m

#endif

unsigned int intersectMark = 0, propogateVerb = 0;

// ZONE 1 - mark and queue setups

fact = StoreWord((char*)"fact");// for foreign languages insure word is there

char maxmark = '0'; // deepest mark user has used

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

// convert all _ and periods to spaces for easier viewing

char* underscore;

while ((underscore = strchr(control,'_'))) *underscore = ' ';

char* colon = strchr(control,':');

if (colon) *colon = 0;

Log(USERLOG,"@@@ Control1 mark/queue: %s",control);

if (colon) *colon = ':';

}

--control;

bool facttype = false;

while (*++control && *control != ':' )

{

choice = NULL;

switch(*control)

{

case '_': case '.': case ' ': // does nothing per se

continue;

case '0': // means NO savemark

saveMark = 0;

continue;

case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': // set current marks

saveMark = baseMark + *control - '0';

if (*control > maxmark) maxmark = *control;

continue;

case 'n': // ignore all member facts involving topic as object

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG," ignore all member facts w topics as objects ");

++control;

baseFlags |= NOTOPIC;

continue;

case '~': case '\'': // use named set or named word

choice = control;

at = strchr(control,'.'); // set name ends with _ or . or space (generated)

if (!at) at = strchr(control,'_');

if (!at) at = strchr(control,' ');

if (!at)

{

ReportBug((char*)"INFO: Couldnt find end of name %s in control",control)

return 0; // couldn't find end of name

}

*at = 0;

control = at; // skip past to end

break;

case 'i':

++control;

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG," ignore #%c results ", *control);

ignoremark = (*control == '0') ? 0 : (baseMark + (*control - '0'));

break;

case 's':

choice = subjectword;

mark = 0;

break;

case 'S':

choice = subjectword;

mark = 0;

facttype = true;

break;

case 'v': // automatically quote verbs. NEVER let them wander

if (*verbword == '\'') strcpy(word,verbword);

else

{

*word = '\'';

strcpy(word+1,verbword);

}

choice = word;

mark = 1;

break;

case 'V':

choice = verbword;

mark = 1;

facttype = true;

break;

case 'o':

choice = objectword;

mark = 2;

break;

case 'O':

choice = objectword;

mark = 2;

facttype = true;

break;

case 'p':

choice = propogate;

break;

case 'm':

choice = match;

break;

case 'f': // we have incoming facts to use

whichset = (control[1] == '@') ? GetSetID(++control) : from; // only allowed sets 1-9

if (whichset == ILLEGAL_FACTSET) return 0;

sprintf(myset,"@%d",whichset);

choice = myset;

break;

default:

ReportBug((char*)"INFO: Bad control code for query init %s(%s) %s",C->word,C->w.userValue,control)

return 0;

}

if (choice) // we have something to follow

{

++control; // now see flags on the choice

unsigned int flags = baseFlags;

// dont treat 'tween_decks as an originalword request

if (choice[0] == '\'' ) // && !IsAlphaUTF8(choice[1])) //dont expand this beyond its first leve -- $$tmp would come in with its value, which if set would fan out. '$$tmp gets just its value

{

flags |= ORIGINALWORD;

++choice;

}

if (choice[0] == '^') // replace the function arg

{

strcpy(word,FNVAR(choice+1));

choice = word;

}

// dynamic choices

if (choice[0] == '_')

{

int wild = GetWildcardID(choice);

if (wild == ILLEGAL_MATCHVARIABLE){;}

else if (flags != 0)

{

choice = wildcardOriginalText[wild];

if (*choice != '~') flags = 0; // '_0 treated as normal word unquoted (original meaning) unless its a set, then it must not expand instead

}

else choice = wildcardCanonicalText[wild];

}

else if (choice[0] == USERVAR_PREFIX && choice[1]) choice = GetUserVariable(choice, false, true);

else if (choice[0] == SYSVAR_PREFIX && choice[1]) choice = SystemVariable(choice,NULL);

else if (choice[0] == '@' && GetSetID(choice) != ILLEGAL_FACTSET )

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG,"FactField: %c(%d) ",saveMark-baseMark+'0',saveMark);

}

choice = NULL;

for (unsigned int j = 1; j <= FACTSET_COUNT(whichset); ++j)

{

FACT* F = factSet[whichset][j];

if (F->flags & FACTDEAD) continue; // cannot use this

MEANING M;

if (*control == 'f') // whole fact can be queued. It cannot be marked as on the queue

{

queue[queueIndex++] = Fact2Index(F);

continue;

}

else if (*control == 's') M = F->subject;

else if (*control == 'v') M = F->verb;

else if (*control == 'o') M = F->object;

else

{

ReportBug((char*)"INFO: bad control for choice[0] == '@' query %s(%s) %s",C->word,C->w.userValue,control)

return 0;

}

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG," %s ",WriteMeaning(M));

AddWord2Scan((control[1] == 'q') ? (QUEUE|flags) : flags,M,0,0,0);

}

continue;

}

else if (facttype) // choice is a fact

{

if (!IsDigit(*choice)) return 0; // illegal fact reference

unsigned int f = atoi(choice);

if (atoi(choice) > (int) Fact2Index(lastFactUsed)) return 0; // beyond legal range

// we can q it but we dont mark it....

queue[queueIndex++] = f;

baseFlags |= FACTTYPE;

facttype = false;

continue;

}

if (choice[0] == '\\') // accept this unchanged

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) Log(USERLOG," raw ");

++choice;

}

// for non-factset values of choice

char buf[1000];

if (trace & TRACE_QUERY && CheckTopicTrace("^query")) sprintf(buf,(char*)"%s #%c(%u)",choice,saveMark-baseMark+'0',saveMark);

if (*control == ' ') continue;

if (*control == 'q')

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG,"Tag+Queue: %s ",buf);

}

qMark = saveMark; // if we q more later, use this mark by default

if (*choice) AddWordOrSet2Scan(QUEUE|flags,choice,0); // mark and queue items

}

else if (*control == 'Q')

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG,"Tag+QueueWord: %s ",buf);

}

qMark = saveMark; // if we q more later, use this mark by default

if (*choice) AddWordOnly(QUEUE|flags,choice,0); // mark and queue item

}

else if (*control == 't')

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG,"Tag: %s ",buf);

if (flags & ORIGINALWORD) Log(USERLOG," don't expand ");

}

if (!*choice);

else if (*choice == '\'') AddWord2Scan(flags, ReadMeaning(choice+1,true,true),0,0,0); // ignore unneeded quote

else AddWord2Scan(flags, ReadMeaning(choice,true,true),0,0,0);

}

else if (*control == 'T') // tag and dont follow

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG,"Tag: %s ",buf);

if (flags & ORIGINALWORD) Log(USERLOG," don't expand ");

}

qMark = saveMark; // if we q more later, use this mark by default

if (*choice) AddWordOnly(flags,choice,0); // mark and queue item

}

else if (*control == 'e')

{

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG," ExpandTag: %s ",buf);

}

if (*choice) AddWordOrSet2Scan(flags,choice,0); // tag but dont queue

}

else if (*control == '<' || *control == '>') // chase hierarchy (exclude VERB hierarchy-- we infer on nouns)

{ // callArgumentList are: flowverbs, queue or mark,

char kind = *control; //< or >

int flows = baseMark + *++control - '0'; // mark for flow

unsigned int flag = (*++control == 'q') ? QUEUE : 0;

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

if (flag) Log(USERLOG," Tag+Queue Propogate %c ",kind);

else Log(USERLOG," Tag Propogate %c ",kind);

}

// if (flag & QUEUE) flag |= BLOCKMEANING;

// mark subject 0 and object 2 are nouns, 1 is verb

if (*choice) ScanHierarchy(ReadMeaning(choice,true,true),saveMark,flows,kind == '<',flag, (mark != 1) ? NOUN : VERB);

}

else

{

ReportBug((char*)"INFO: bad follow argument of %s %s",kind,control)

return 0;

}

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

Log(USERLOG,"\r\n");

Log(USERLOG,"");

}

}

else if (baseFlags & USERFACTS) // transfer over user flags

{

unsigned int total = lastFactUsed - factLocked;

if (total >= MAX_QUEUE) total = MAX_QUEUE - 1;

FACT* F = lastFactUsed - total;

while (++F <= lastFactUsed) queue[queueIndex++] = Fact2Index(F);

baseFlags |= FACTTYPE;

}

}

inferMark += maxmark - '0'; // update to use up marks we have involved

currentFreeInfer = inferMark;

ignoremark = 0; // require be restated if a matching requirement

// ZONE 2 - how to use contents of the queue

// given items in queue, what field from a queued entry to use facts from

if (*control) control = SkipWhitespace(control+1); // skip over the : and past any white space

if (!strncmp(control,(char*)"queue",5)) control = SkipWhitespace(control+5); // just a label defining the field

if (trace & TRACE_QUERY && CheckTopicTrace("^query"))

{

char* colon = strchr(control+1,':');

if (colon) *colon = 0;

if (control[1])

{

Log(USERLOG,"@@@ Control2 queue use: %s",control+1);

Log(USERLOG,"");

}

if (colon) *colon = ':';

}

if (*control && --control) while (*++control && *control != ':' )

{

switch (*control)

{

case '_': case '.': case ' ': // does nothing per se

continue;

case 's':

baseOffset = 0;

break;

case 'v':

baseOffset = 1;

break;

case 'o':

baseOffset = 2;

break;

case 'f':

baseFlags |= FACTTYPE;

break; // queued items are facts instead of meaning

case 'e':

baseOffset = 3;

break;

default:

ReportBug((char*)"INFO: Bad control code for #2 (queue test) %s(%s) %s",C->word,C->w.userValue,control)

return 0;

}

}

whichset = store;

// ZONE 3 - how to detect facts we can return as answers and where they go

// set marks to compare on (test criteria for saving an answer)

/*

bool sentences = false;

bool sentencev = false;

bool sentenceo = false;

float rangelow = -20000.0;

float rangehigh = -20000.0;

char field = 0;

unsigned int marks = 0, markv = 0, marko = 0;

unsigned int markns = 0, marknv = 0, markno = 0;