public string GenFormatFactoid(string subject, string relation, object value, XmlNode templateNode)
{
string subj = Entify(subject);
var dictionary = TheBot.GetDictionary(subj) as SettingsDictionary;
bool noValue = Unifiable.IsNullOrEmpty(value);
Unifiable formatter;
{
if (noValue)
{
// query mode
formatter = GetDictValue(dictionary, relation, "format-query");
}
else
{
// assert mode
formatter = GetDictValue(dictionary, relation, "format-assert");
}
}
var formatterUpper = Unifiable.ToUpper(formatter);
if (Unifiable.IsNullOrEmpty(formatter) || Unifiable.IsTrueOrYes(formatterUpper) || formatter == "default")
{
formatter = " {0} {1} is {2} ";
}
if (Unifiable.IsFalseOrNo(formatterUpper))
{
return("false");
}
return(ExpandFormat(subj, relation, value, noValue, dictionary, formatter, templateNode));
}
public override Unifiable CheckValue(Unifiable value)
{
if (ReferenceEquals(value, Unifiable.EmptyRef))
{
return(value);
}
if (value == null)
{
writeToLogWarn("ChackValue NULL");
return(null);
}
else
{
if (Unifiable.IsNullOrEmpty(value))
{
writeToLogWarn("CheckValue EMPTY = '" + value + "'");
return(Unifiable.Empty);
}
if (CompleteEvaluation(value, this, out value))
{
//RecurseResult = vv;
return(value);
}
return(value);
}
}
private void SetTopicInt(T obj)
{
if (Object.Equals(obj, EmptyResult()))
{
list.Clear();
return;
}
if (Unifiable.IsNullOrEmpty(obj))
{
if (Unifiable.IsNullOrEmpty(_lastSetTopic))
{
list.RemoveAt(0);
return;
}
int removeTopicInt = RemoveTopicInt(_lastSetTopic);
}
int indexOf = list.IndexOf(obj);
if (indexOf == 0)
{
return;
}
if (indexOf > 0)
{
list.RemoveAt(indexOf);
}
list.Insert(0, obj);
}
public Unifiable EvalSubL(Unifiable cmd, Unifiable filter)
{
Unifiable result = "(EVAL-SUBL " + cmd + ")";
CycAccess access = GetCycAccess;
if (!UseCyc)
{
writeToLog("NOT USE CYC " + result);
return(null);// "NIL";
}
try
{
string str = "(list " + cmd + ")";
Object oresult = access.converseList(str).first();
DLRConsole.DebugWriteLine(str + " => " + oresult);
result = "" + oresult;
if (oresult is CycObject)
{
result = ((CycObject)oresult).cyclifyWithEscapeChars();
}
if (!Unifiable.IsNullOrEmpty(filter) && filter == "paraphrase")
{
return(this.Paraphrase(result));
}
}
catch (Exception e)
{
DLRConsole.DebugWriteLine(result);
TheBot.writeToLog(e);
DLRConsole.DebugWriteLine("\n" + e);
DLRConsole.SystemFlush();
return(null);
}
return(result);
}
static private string StarNulls(string startGraphName)
{
if (Unifiable.IsNullOrEmpty(startGraphName))
{
return("*");
}
return(startGraphName);
}
static MasterResult GetSubResult(String prefix, Request prevRequest, User user, AltBot mybot, Request subRequest, bool showDebug, out Unifiable subResultOutput, out string subQueryRawOutput1, OutputDelegate writeToLog)
{
var prev = subRequest.GraphsAcceptingUserInput;
var prevSO = user.SuspendAddResultToUser;
MasterResult subResult = subRequest.CreateResult(subRequest);
try
{
Dictionary <Unifiable, Unifiable> sraiMark = null;
var originalSalientRequest = Request.GetOriginalSalientRequest(prevRequest);
if (ChatOptions.UseSraiLimitersBasedOnTextContent)
{
sraiMark = originalSalientRequest.CreateSRAIMark();
}
subRequest.GraphsAcceptingUserInput = true;
//var newresult = new AIMLbot.Result(request.user, Proc, request);
//subRequest.result = newresult;
user.SuspendAddResultToUser = true;
if (prevRequest.IsTraced)
{
subRequest.IsTraced = !showDebug;
}
subRequest.IsTraced = true;
subResult = (MasterResult)mybot.ChatWithToplevelResults(subRequest, subResult, false,
RequestKind.TagHandler | RequestKind.SraiTag);
subResultOutput = subResult.RawOutput;
int resultCount = subResult.OutputSentences.Count;
if (AltBot.BE_COMPLETE_NOT_FAST && resultCount == 0)
{
subRequest.ResetValues(false);
if (ChatOptions.UseSraiLimitersBasedOnTextContent)
{
originalSalientRequest.ResetSRAIResults(sraiMark);
}
if (Unifiable.IsNullOrEmpty(subResultOutput))
{
subResult = (MasterResult)mybot.ChatFor1Result(subRequest, subResult, RequestKind.TagHandler | RequestKind.SraiTag);
subResultOutput = subResult.Output;
if (!IsNullOrEmpty(subResultOutput))
{
writeToLog(prefix + "RESCUED RETURN " + subResultOutput);
// subQueryRawOutput = "" + subResultOutput;
}
}
}
}
finally
{
user.SuspendAddResultToUser = prevSO;
subRequest.GraphsAcceptingUserInput = prev;
}
subQueryRawOutput1 = subResultOutput;//.Trim();
return(subResult);
}
public bool Lookup1(Unifiable textIn, Unifiable filter, out Unifiable term, SubQuery subquery)
{
if (Unifiable.IsNullOrEmpty(textIn))
{
term = null;
return(false);
}
if (textIn.AsString().Contains("#$"))
{
term = textIn;
if (!Unifiable.IsNullOrEmpty(term))
{
if (!IsaFilter(term, filter))
{
return(false);
}
}
return(true);
}
lock (stringTOResult)
{
string key = "" + textIn + "=" + filter;
if (stringTOResult.TryGetValue(key, out term))
{
if (term == NILTerm)
{
return(false);
}
return(true);
}
bool t = lookup0(textIn, filter, out term, subquery);
bool meansFalse = Unifiable.IsFalse(term);
if (t != meansFalse)
{
if (meansFalse)
{
writeToLog("NILTerm true=" + t + " term=" + term + " textIn" + textIn);
term = NILTerm;
}
else
{
string paraphrase = Paraphrase(term);
writeToLog("true={0} term={1} textIn{2} paraPhrase={3}", t, term, textIn, paraphrase);
}
}
stringTOResult[key] = term;
return(t);
}
}
private int RemoveTopicInt(T obj)
{
if (Unifiable.IsNullOrEmpty(obj))
{
return(-1);
}
int indexOf = list.IndexOf(obj);
if (indexOf == -1)
{
return(-1);
}
list.RemoveAt(indexOf);
return(indexOf);
}
public override Unifiable RecurseChildren()
{
if (RecurseResultValid)
{
return(RecurseResult);
}
var vv = base.Recurse();
if (!Unifiable.IsNullOrEmpty(vv))
{
RecurseResult = vv;
return(vv);
}
RecurseResult = vv;
return(vv);
}
internal string FixPronouns(string englishIn, Func <string, string> whoAmI)
{
var pns = new[]
{
"him", "he", "she", "her", "them", "they", "it", "this",
"i", "you", "me", "my", "your", "our", "their",
};
string english = " " + englishIn.Trim() + " ";
string englishToLower = english.ToLower();
{
foreach (var pronoun in pns)
{
if (englishToLower.Contains(" " + pronoun + " "))
{
if (whoAmI == null)
{
writeToLog("FixPronouns: DONT KNOW THE USER TO RESOLVE '" + pronoun + "'");
return(english);
}
Unifiable v = Unifiable.Create(whoAmI(pronoun));
bool goodReplacement = !Unifiable.IsIncomplete(v) && !Unifiable.IsNullOrEmpty(v) &&
!Unifiable.IsMissing(v);
if (!goodReplacement)
{
writeToLog("FixPronouns: BAD REPLACEMENT '" + pronoun + "' => '" + v + "'");
continue;
}
english = ReplaceWord(english, pronoun, v);
if (pronoun != pronoun.Trim())
{
english = ReplaceWord(english, pronoun + "s", v + "s");
}
}
}
englishToLower = english.ToLower();
foreach (var pronoun in pns)
{
if (englishToLower.Contains(" " + pronoun + " "))
{
Unifiable v = Unifiable.Create(whoAmI(pronoun));
writeToLog("FixPronouns: BAD REPLACEMENT '" + pronoun + "' => '" + v + "'");
}
continue;
}
return(english);
}
}
public string ExpandFormat(string subj, string relation, object value, bool isQuery, SettingsDictionary dictionary, Unifiable formatter, XmlNode templateNode)
{
string pred = Entify(relation);
string botName = !IsBotRobot(subj) ? Entify(TheBot.BotUserID) : Entify(TheBot.LastUser.UserID);
{
var whword = GetDictValue(dictionary, relation, "format-whword");
if (!Unifiable.IsNullOrEmpty(whword) && isQuery)
{
value = whword;
}
var formatterUpper = Unifiable.ToUpper(formatter);
if (Unifiable.IsFalseOrNo(formatterUpper))
{
return("false");
}
formatter = ReplaceWord(formatter, "$subject", "{0}");
formatter = ReplaceWord(formatter, "$verb", "{1}");
formatter = ReplaceWord(formatter, "$object", "{2}");
formatter = ReplaceWord(formatter, "$user", "{0}");
formatter = ReplaceWord(formatter, "$relation", "{1}");
formatter = ReplaceWord(formatter, "$value", "{2}");
formatter = ReplaceWord(formatter, "$predicate", pred);
formatter = ReplaceWord(formatter, "$set-return",
TheBot.RelationMetaProps.grabSetting(relation + "." + "set-return"));
formatter = ReplaceWord(formatter, "$default", TheBot.DefaultPredicates.grabSetting(relation));
formatter = ReplaceWord(formatter, "$botname", botName);
formatter = ReplaceWord(formatter, "$bot", botName);
}
string english = " " + String.Format(formatter, subj, pred, Entify(value)).Trim() + " ";
english = ReplaceWord(english, "I", subj);
english = ReplaceWord(english, "you", botName);
english = english.Trim();
User user = TheBot.FindUser(subj);
english = FixPronouns(english, user.grabSettingNoDebug);
return(english);
}
protected override Unifiable ProcessChangeU()
{
if (templateNode.Name.ToLower() == "guard")
{
string language = GetAttribValue("lang", "cycl");
templateNodeInnerText = ((AIMLTagHandler)this).Recurse();
if (!IsNullOrEmpty(templateNodeInnerText))
{
Unifiable res = Proc.SystemExecute(templateNodeInnerText, language, request);
if (!Unifiable.IsNullOrEmpty(res))
{
return(res);
}
}
}
return(Unifiable.Empty);
}
internal bool IsaFilter(Unifiable term, Unifiable filter)
{
if (!Unifiable.IsValue(term))
{
return(false);
}
if (term == "NIL")
{
return(false);
}
if (!Unifiable.IsNullOrEmpty(filter))
{
if (Unifiable.IsFalse(filter))
{
return(true);
}
if (this.EvalSubL(TextPatternUtils.SafeFormat("(ask-template 'T `(#$isa {0} {1}) #$EverythingPSC)", Cyclify(term), Cyclify(filter)), null) == "NIL")
{
return(false);
}
}
return(true);
}
protected override Unifiable ProcessChangeU()
{
if (base.CheckNode("cycterm"))
{
Unifiable filter = base.GetAttribValue("filter", GetAttribValue("isa", "Thing"));
Unifiable pos = base.GetAttribValue("pos", null);
int maxWords = int.Parse(base.GetAttribValue("maxwords", "1"));
Unifiable r = Recurse();
if (Unifiable.IsNullOrEmpty(r))
{
QueryHasFailed = true;
return(FAIL);
}
string s = r.ToValue(query);
if (s.Split(' ').Length > maxWords)
{
QueryHasFailed = true;
return(FAIL);
}
Unifiable term;
if (Proc.TheCyc.Lookup(r, filter, out term, query))
{
s = term.AsString();
if (s.Length < 2)
{
writeToLog("CYCTERM: " + r + "=>" + s);
}
return(term);
}
else
{
QueryHasFailed = true;
return(FAIL);
}
}
return(Unifiable.Empty);
}
protected override Unifiable ProcessChangeU()
{
try
{
int d = request.GetCurrentDepth();
object prefix = string.Format("{0}: SRAI({1}/{2})", request.Graph, depth, d);
if (d > request.SraiDepth.Max)
{
writeToLog(prefix + "WARNING Depth pretty deep " + templateNode + " returning empty");
return(Unifiable.Empty);
}
if (depth > 30)
{
writeToLog(prefix + "WARNING Depth pretty deep " + templateNode + " returning empty");
return(Unifiable.Empty);
}
if (this.templateNode.Name.ToLower() == "srai")
{
Unifiable templateNodeInnerValue = Recurse();
if (!templateNodeInnerValue.IsEmpty)
{
AIMLbot.Request subRequest = request.CreateSubRequest(templateNodeInnerValue, this.user,
this.Proc, (AIMLbot.Request)request);
subRequest.Graph = request.Graph.Srai;
var ti = query.CurrentTemplate;
if (ti != null)
{
subRequest.UsedTemplates.Add(ti);
}
// make sure we don't keep adding time to the request
bool showDebug = true;
string subRequestrawInput = subRequest.rawInput;
if (subRequestrawInput.Contains("SYSTEMANIM") || subRequestrawInput.Contains("HANSANIM"))
{
showDebug = false;
}
if (showDebug)
{
writeToLog(prefix + " CALLING '" + subRequestrawInput + "'");
}
if (mybot.chatTrace)
{
// mybot.bot.writeChatTrace("\"L{0}\" -> \"S{1}\" ;\n", depth - 1, depth-1);
// mybot.bot.writeChatTrace("\"L{0}\" -> \"S{1}\" ;\n", depth, depth);
//mybot.bot.writeChatTrace("\"S{0}\" -> \"SRC:{1}\" ;\n", depth, CatTextInfo());
//mybot.bot.writeChatTrace("\"S{0}\" -> \"S{1}\" ;\n", depth - 1, depth);
//mybot.bot.writeChatTrace("\"S{0}\" -> \"SIN:{1}\" ;\n", depth, subRequestrawInput);
//mybot.bot.writeChatTrace("\"SIN:{0}\" -> \"LN:{1}\" ;\n", subRequestrawInput, CatTextInfo());
}
if (depth > 200)
{
writeToLog(prefix + " FAILING TOOOO DEEEEP '" + subRequestrawInput + "'");
return(Unifiable.Empty);
}
AIMLbot.Result subResult;
var prev = subRequest.GraphsAcceptingUserInput;
var prevSO = user.SuspendAdd;
try
{
subRequest.GraphsAcceptingUserInput = true;
//var newresult = new AIMLbot.Result(request.user, Proc, request);
//subRequest.result = newresult;
user.SuspendAdd = true;
if (request.IsTraced)
{
subRequest.IsTraced = !showDebug;
}
subResult = this.Proc.Chat0(subRequest, subRequest.Graph);
}
finally
{
user.SuspendAdd = prevSO;
subRequest.GraphsAcceptingUserInput = prev;
}
this.request.hasTimedOut = subRequest.hasTimedOut;
var subQueryRawOutput = subResult.RawOutput.Trim();
if (Unifiable.IsNullOrEmpty(subQueryRawOutput))
{
if (showDebug)
{
writeToLog(prefix + " MISSING RETURN ");
}
if (mybot.chatTrace)
{
mybot.writeChatTrace("\"L{0}\" -> \"S{1}\" ;\n", depth, depth);
mybot.writeChatTrace("\"S{0}\" -> \"SIN:{1}\" ;\n", depth, subRequestrawInput);
//mybot.writeChatTrace("\"SIN:{0}\" -> \"LN:{1}\" ;\n", subRequestrawInput, CatTextInfo());
mybot.writeChatTrace("\"SIN:{0}\" -> \"PATH:{1}\" [label=\"{2}\"] ;\n",
subRequestrawInput, depth, subResult.NormalizedPaths);
mybot.writeChatTrace("\"PATH:{0}\" -> \"LN:{1}\" [label=\"{2}\"] ;\n", depth, depth,
LineNumberTextInfo());
mybot.writeChatTrace("\"LN:{0}\" -> \"RPY:MISSING({1})\" ;\n", depth, depth);
}
return(Unifiable.Empty);
}
else
{
string sss = result.ToString();
if (showDebug)
{
writeToLog("{0} SUCCESS RETURN {1} {2} '{3}'", prefix, subRequestrawInput,
subResult.Score, subQueryRawOutput);
if (query != null)
{
if (query.CurrentTemplate != null)
{
writeToLog("SCORE {0}*{1}->{2} ",
subResult.Score, query.CurrentTemplate.Rating,
query.CurrentTemplate.Rating *= subResult.Score);
}
}
}
this.request.AddSubResult(result);
this.request.AddSubResult(subResult);
}
if (mybot.chatTrace)
{
mybot.writeChatTrace("\"L{0}\" -> \"S{1}\" ;\n", depth, depth);
mybot.writeChatTrace("\"S{0}\" -> \"SIN:{1}\" ;\n", depth, subRequestrawInput);
mybot.writeChatTrace("\"SIN:{0}\" -> \"PATH:{1}\" [label=\"{2}\"] ;\n", subRequestrawInput,
depth, subResult.NormalizedPaths);
mybot.writeChatTrace("\"PATH:{0}\" -> \"LN:{1}\" [label=\"{2}\"] ;\n", depth, depth,
LineNumberTextInfo());
mybot.writeChatTrace("\"LN:{0}\" -> \"RPY:{1}\" ;\n", depth, subQueryRawOutput);
}
return(subResult.Output);
}
else
{
if (templateNodeInnerValue.IsEmpty)
{
writeToLog("InnerValue.IsEmpty! " + initialString);
return(templateNodeInnerValue);
}
}
}
return(Unifiable.Empty);
}
finally
{
depth--;
}
}
private static bool ShouldSet(XmlNode templateNode, ISettingsDictionary dictionary, string name, object newValue, Unifiable oldValue, SubQuery query)
{
if (templateNode == null)
{
return(true);
}
bool canSet = query.UseDictionaryForSet(dictionary);
;
bool onlyIfUnknown;
if (StaticXMLUtils.TryParseBool(templateNode, "ifUnknown", out onlyIfUnknown))
{
if (onlyIfUnknown)
{
return((Unifiable.IsMissing(oldValue) || IsIncomplete(oldValue)) && canSet);
}
}
bool overwriteExisting;
if (StaticXMLUtils.TryParseBool(templateNode, "overwriteExisting", out overwriteExisting))
{
if (!overwriteExisting)
{
return((Unifiable.IsNullOrEmpty(oldValue) || IsIncomplete(oldValue)) && canSet);
}
//if (overwriteExisting)
return(true);
}
string oldMatch = StaticXMLUtils.GetAttribValue(templateNode, "existing", null);
bool shouldSet = true;
if (oldMatch != null)
{
if (!StaticAIMLUtils.IsPredMatch(oldMatch, oldValue, null))
{
shouldSet = false;
}
}
var newValueU = Unifiable.Create(newValue);
string newMatch = StaticXMLUtils.GetAttribValue(templateNode, "matches", null);
if (newMatch != null)
{
if (!StaticAIMLUtils.IsPredMatch(newMatch, newValueU, null))
{
shouldSet = false;
}
}
string wontvalue = StaticXMLUtils.GetAttribValue(templateNode, "wontvalue", null);
if (wontvalue != null)
{
if (StaticAIMLUtils.IsPredMatch(wontvalue, newValueU, null))
{
shouldSet = false;
}
}
return(shouldSet && canSet);
}
static public Unifiable GetSettingForType(string subject, SubQuery query, ISettingsDictionary dict, string name, out string realName, string gName, Unifiable defaultVal, out bool succeed, XmlNode node)
{
Request request = query.Request;
OutputDelegate writeToLog = request.writeToLog ?? TextPatternUtils.DEVNULL;
AltBot TargetBot = request.TargetBot;
ISettingsDictionary udict;
string dictName = AIMLTagHandler.GetNameOfDict(query, subject ?? dict.NameSpace, node, out udict);
// try to use a global blackboard predicate
User gUser = TargetBot.ExemplarUser;
defaultVal = StaticXMLUtils.GetAttribValue(node, "default,defaultValue", defaultVal);
gName = StaticXMLUtils.GetAttribValue(node, "global_name", gName);
string realName0;
var vv = ScriptManager.GetGroup(query.TargetBot.ObjectRequester, dictName, name);
{
if (vv != null)
{
if (vv.Count == 0)
{
succeed = true;
realName = name;
return("");
}
succeed = true;
realName = name;
foreach (var e in vv)
{
return(Unifiable.Create(e));
}
}
}
Unifiable resultGet = SettingsDictionaryReal.grabSettingDefaultDict(udict, name, out realName0);
if (ReferenceEquals(resultGet, null))
{
realName = null;
resultGet = Unifiable.NULL;
}
// if ((!String.IsNullOrEmpty(result)) && (!result.IsWildCard())) return result; // we have a local one
String realNameG;
// try to use a global blackboard predicate
Unifiable gResult = SettingsDictionaryReal.grabSettingDefaultDict(gUser.Predicates, gName, out realNameG);
if ((Unifiable.IsMissing(resultGet)) && (!Unifiable.IsMissing(gResult)))
{
// result=nothing, gResult=something => return gResult
writeToLog("SETTINGS OVERRIDE " + gResult);
succeed = true;
realName = realNameG;
// return gResult;
}
string sresultGet = resultGet.ToValue(query);
// if Unknown or empty
if (UseLuceneForGet && Unifiable.IsMissing(sresultGet))
{
Unifiable userName = udict.grabSetting("id");
if (Unifiable.IsNullOrEmpty(userName))
{
writeToLog("ERROR IsNullOrEmpty id in " + udict.NameSpace);
}
ITripleStore userbotLuceneIndexer = (ITripleStore)query.Request.TargetBot.TripleStore;
string resultLucene = userbotLuceneIndexer.queryTriple(userName, name, node);
if (!string.IsNullOrEmpty(resultLucene))
{
succeed = true;
realName = name;
return(resultLucene);
}
}
if (sresultGet != null)
{
if (sresultGet.ToUpper() == "UNKNOWN")
{
succeed = false;
realName = null;
return(sresultGet + " " + name);
}
else if (Unifiable.IsEMPTY(resultGet))
{
succeed = true;
realName = name;
return(resultGet);
}
else if (Unifiable.IsUnknown(resultGet))
{
succeed = false;
realName = name;
return(resultGet);
}
}
if (!String.IsNullOrEmpty(sresultGet))
{
succeed = true;
realName = realName0;
query.GetDictValue++;
if (!IsNullOrEmpty(gResult))
{
if (resultGet.IsWildCard)
{
realName = realNameG;
// result=*, gResult=something => return gResult
return(gResult);
}
// result=something, gResult=something => return result
return(resultGet);
}
else
{
// result=something, gResult=nothing => return result
return(resultGet);
}
}
if (defaultVal == null)
{
succeed = false;
realName = null;
return(defaultVal);
}
// default => return defaultVal
succeed = true;
realName = realName0;
return(ReturnSetSetting(udict, name, defaultVal));
//return defaultVal;
}
/// <summary>
/// Recursively evaluates the template nodes returned from the Proccessor
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced targetBot node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output Unifiable</returns>
public string processNodeVV(XmlNode node, SubQuery query,
Request request, Result result, User user,
AIMLTagHandler parentHandlerU, bool protectChild, bool copyParent,
AIMLTagHandler tagHandlerU, out bool childSuccess)
{
AltBot TargetBot = tagHandlerU.bot;
if (request != null)
{
TargetBot = request.TargetBot;
}
childSuccess = true;
if (node == null)
{
string whyError = "ERROR null NODE " + tagHandlerU;
writeToLog(whyError);
throw new ChatSignalOverBudget(request, whyError);
}
if (node.NodeType == XmlNodeType.Text)
{
childSuccess = true;
if (tagHandlerU != null)
{
tagHandlerU.QueryHasSuceeded = true;
}
string s = StaticAIMLUtils.Trim(StaticAIMLUtils.TextNodeValue(node));
if (!String.IsNullOrEmpty(s))
{
return(StaticAIMLUtils.ValueText(s));
}
//return s;
}
if (tagHandlerU == null)
{
string whyError = "ERROR null THND " + node;
childSuccess = false;
writeToLog(whyError);
}
bool isTraced = (request != null && (request.IsTraced || !request.GraphsAcceptingUserInput)) ||
(query != null && query.IsTraced);
// check for timeout (to avoid infinite loops)
bool overBudget = false;
if (request != null && request.IsComplete(result))
{
object gn = request.Graph;
if (query != null)
{
gn = query.Graph;
}
string s = StaticAIMLUtils.SafeFormat("WARNING! Request " + request.WhyComplete +
". User: {0} raw input: {3} \"{1}\" processing {2} templates: \"{4}\"",
request.Requester.UserID, Unifiable.DescribeUnifiable(request.rawInput),
(query == null ? "-NOQUERY-" : query.Templates.Count.ToString()), gn, node);
if (isTraced)
{
request.writeToLog(s);
}
overBudget = true;
if (!request.IsToplevelRequest)
{
throw new ChatSignalOverBudget(request, s);
}
}
// process the node
if (ReferenceEquals(null, tagHandlerU))
{
childSuccess = true;
if (node.NodeType == XmlNodeType.Comment)
{
return(Unifiable.Empty);
}
if (node.NodeType == XmlNodeType.Text)
{
string s = StaticAIMLUtils.Trim(StaticAIMLUtils.TextNodeValue(node));
if (String.IsNullOrEmpty(s))
{
return(Unifiable.Empty);
}
return(s);
}
// ReSharper disable ConditionIsAlwaysTrueOrFalse
OutputDelegate del = (request != null) ? request.writeToLog : writeToLog;
// ReSharper restore ConditionIsAlwaysTrueOrFalse
if (overBudget)
{
return(Unifiable.Empty);
}
string nodeInner = node.InnerXml;
TargetBot.EvalAiml(node, request, del ?? TextPatternUtils.DEVNULL);
return(node.InnerXml);
}
XmlNode oldNode = node;
bool wasReadonlyNode = oldNode.IsReadOnly;
// copy the node!?!
if (protectChild)
{
copyParent = true;
LineInfoElementImpl newnode = StaticAIMLUtils.CopyNode(node, copyParent);
newnode.ReadOnly = false;
node = newnode;
}
if (overBudget)
{
tagHandlerU.Dispose();
tagHandlerU = null;
childSuccess = true;
return(Unifiable.Empty);
}
tagHandlerU.SetParent(parentHandlerU);
//if (parent!=null) parent.AddChild(tagHandler);
Unifiable cp = tagHandlerU.Transform();
if (Unifiable.IsNullOrEmpty(cp) && (!tagHandlerU.QueryHasSuceeded || tagHandlerU.QueryHasFailed))
{
bool needsOneMoreTry = !request.SuspendSearchLimits &&
(request.IsToplevelRequest /*|| result.ParentRequest.IsToplevelRequest*/);
if (isTraced || needsOneMoreTry)
{
//writeDebugLine("ERROR: Try Again since NULL " + tagHandler);
bool wsl = request.SuspendSearchLimits;
try
{
request.SuspendSearchLimits = true;
cp = tagHandlerU.Transform();
if (Unifiable.IsNull(cp))
{
childSuccess = false;
return(tagHandlerU.GetTemplateNodeInnerText());
}
if (false && Unifiable.IsNullOrEmpty(cp))
{
// trace the next line to see why
AIMLTagHandler handlerU = tagHandlerU;
TargetBot.TraceTest("ERROR: Try Again since NULL " + handlerU,
() => { cp = handlerU.Transform(); });
}
}
finally
{
request.SuspendSearchLimits = wsl;
}
}
}
if (tagHandlerU.QueryHasFailed)
{
childSuccess = false;
return(tagHandlerU.FAIL);
}
childSuccess = !tagHandlerU.QueryHasFailed;
if (!childSuccess)
{
}
var st = StaticAIMLUtils.IsSilentTag(node);
var ine = Unifiable.IsNullOrEmpty(cp);
if (!ine || st)
{
childSuccess = true;
return(cp);
}
if (Unifiable.IsNull(cp))
{
cp = tagHandlerU.GetTemplateNodeInnerText();
if (tagHandlerU.QueryHasSuceeded)
{
childSuccess = true;
return(cp);
}
return(cp);
}
return(cp);
}
/// <summary>
/// Recursively evaluates the template nodes returned from the Proccessor
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced targetBot node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output Unifiable</returns>
public string processNode(XmlNode node, SubQuery query,
Request request, Result result, User user,
AIMLTagHandler parentHandlerU, bool protectChild, bool copyParent,
AIMLTagHandler nodeHandlerU, bool suspendLimits, out bool templateSucceeded)
{
Request originalSalientRequest = Request.GetOriginalSalientRequest(request);
bool osrExists = originalSalientRequest != null;
var wasSuspendRestrati = request == null || request.SuspendSearchLimits;
templateSucceeded = true;
if (request != null)
{
request.SuspendSearchLimits = suspendLimits;
}
Dictionary <Unifiable, Unifiable> sraiMark = null;
if (osrExists && ChatOptions.UseSraiLimitersBasedOnTextContent)
{
sraiMark = originalSalientRequest.CreateSRAIMark();
}
try
{
bool childSuccess;
string outputSentence = processNodeVV(node, query,
request, result, user, parentHandlerU,
protectChild, copyParent, nodeHandlerU, out childSuccess);
if (!childSuccess)
{
templateSucceeded = false;
}
if (Unifiable.IsNull(outputSentence))
{
//outputSentence = tagHandler.GetTemplateNodeInnerText();
templateSucceeded = false;
return(outputSentence);
}
if (!Unifiable.IsNullOrEmpty(outputSentence))
{
return(outputSentence);
}
if (StaticAIMLUtils.IsSilentTag(node) && !Unifiable.IsEMPTY(outputSentence))
{
return("");
}
if (nodeHandlerU.FinalResultValid)
{
return(nodeHandlerU.FinalResult);
}
return(outputSentence);
}
finally
{
if (osrExists && ChatOptions.UseSraiLimitersBasedOnTextContent)
{
originalSalientRequest.ResetSRAIResults(sraiMark);
}
if (request != null)
{
request.SuspendSearchLimits = wasSuspendRestrati;
}
}
}
/// <summary>
/// Checks to see if a setting of a particular name exists
/// </summary>
/// <param name="name">The setting name to check</param>
/// <returns>Existential truth value</returns>
public bool containsSettingCalled(string name)
{
Unifiable value = grabSetting(name);
return(!Unifiable.IsNullOrEmpty(value));
}
protected Unifiable ProcessChangeSraiPre(Unifiable templateNodeInnerValue)
{
throw bot.RaiseError("wrong SRAI!");
{
try
{
{ if (false && IsNull(templateNodeInnerValue))
{
templateNodeInnerValue = Recurse();
}
TemplateInfo queryTemplate = query.CurrentTemplate;
if (queryTemplate != null)
{
if (!result.CanResultUseTemplate(queryTemplate))
{
writeToLogWarn("!result.CanResultUseTemplate " + queryTemplate);
return(Unifiable.INCOMPLETE);
}
if (!request.CanUseRequestTemplate(queryTemplate))
{
writeToLogWarn("!request.CanUseRequestTemplate " + queryTemplate);
return(Unifiable.INCOMPLETE);
}
}
templateNodeInnerValue = AltBot.CleanupCyc(templateNodeInnerValue);
var vv = ProcessChangeSrai(templateNodeInnerValue);
if (!Unifiable.IsNullOrEmpty(vv))
{
return(vv);
}
if (Unifiable.IsNull(vv))
{
writeToLogWarn("NULL SRAI!?!");
}
else
{
if (IsSilentTag(templateNode.ChildNodes))
{
return(Unifiable.Empty);
}
return(vv); // Empty
}
if (ProcessChange12)
{
writeToLogWarn("ProcessChange12 cant get result");
return(null);
}
if (Unifiable.IsNull(vv))
{
vv = GetTemplateNodeInnerText();
return(FAIL);
}
return(vv); }
}
catch (ChatSignal ex)
{
throw;
}
catch (Exception e)
{
writeToLog("ERROR: " + e);
throw;
}
}
}
