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; } } }