WriteToString() 공개 정적인 메소드

public static WriteToString ( object o ) : string
o object
리턴 string
예제 #1
0
파일: ELProlog.cs 프로젝트: mantoun/MKULTRA
        public static bool TryQueryStructure(
            Structure term,
            PrologContext context,
            out ELNode foundNode,
            out ELNodeEnumerator enumerator)
        {
            //
            // Dispatch based on the functor and arity.
            //

            // Handle root queries, i.e. /Key
            if (term.IsFunctor(Symbol.Slash, 1))
                return TryRootQuery(term, context, out foundNode, out enumerator);

            if (!IsELTerm(term))
                throw new Exception("Malformed EL query: " + ISOPrologWriter.WriteToString(term));

            if (term.IsFunctor(SBindNodeOperator, 2))
            {
                var variableToBind = term.Argument(1) as LogicVariable;
                if (variableToBind == null)
                    throw new ArgumentException("RHS of >> must be an uninstantiated variable: "+ ISOPrologWriter.WriteToString(term.Argument(1)));
                foundNode = null;
                return TryNodeBindingQuery(out enumerator, term.Argument(0), variableToBind, context);
            }

            return TryChildQuery(
                out foundNode,
                out enumerator,
                term.Argument(0),
                term.Argument(1),
                term.Functor == Symbol.Colon,
                context);
        }
예제 #2
0
        public static object EvalMemberExpression(object obj, object memberExpression, PrologContext context)
        {
            obj = Eval(obj, context);
            memberExpression = Term.Deref(memberExpression);
            var methodCall = memberExpression as Structure;

            if (methodCall != null)
            {
                // Method call
                var args = new object[methodCall.Arity];
                for (var i = 0; i < args.Length; i++)
                {
                    args[i] = Eval(methodCall.Argument(i), context);
                }
                return(obj.InvokeMethod(methodCall.Functor.Name, args));
            }
            var propName = memberExpression as Symbol;

            if (propName != null)
            {
                // Field or property reference
                return(obj.GetPropertyOrField(propName.Name));
            }
            throw new ArgumentException(
                      "Invalid member expression: " + ISOPrologWriter.WriteToString(new Structure(Symbol.Dot, obj, memberExpression)));
        }
예제 #3
0
파일: ELProlog.cs 프로젝트: mantoun/MKULTRA
        public static bool TryQuery(object term, PrologContext context, out ELNode foundNode, out ELNodeEnumerator enumerator)
        {
            // Dereference any top-level variables.
            var t = Term.Deref(term);

            // Dereference indexicals
            var i = t as Indexical;
            if (i != null)
                t = i.GetValue(context);

            // A game object means the gameobject's EL KB.
            var g = t as GameObject;
            if (g != null)
                t = g.KnowledgeBase().ELRoot;

            // If it's already an ELNode, use that.
            var n = t as ELNode;
            if (n != null)
            {
                foundNode = n;
                enumerator = null;
                return true;
            }

            // Otherwise, it's an expression, so evaluate it.
            var s = t as Structure;
            if (s != null)
                return TryQueryStructure(s, context, out foundNode, out enumerator);

            var v = t as LogicVariable;
            if (v != null && !v.IsBound)
                throw new Exception("EL query root is an unbound variable: " + v);
            throw new Exception("Malformed EL query: " + ISOPrologWriter.WriteToString(term));
        }
 /// <summary>
 /// Thrown when attempting to write a non-exclusive value to an exclusive value or vice-versa.
 /// </summary>
 public ELNodeExclusionException(string message, ELNode node, object key)
     : base(string.Format("{0}: {1}{2}{3}",
                          message,
                          node,
                          node.IsExclusive?ELProlog.ExclusiveOperator:ELProlog.NonExclusiveOperator,
                          ISOPrologWriter.WriteToString(key)))
 {
 }
예제 #5
0
 internal void PrintWarning(string formatString, params object[] formatArgs)
 {
     //Repl.StartWarnings();
     Debug.LogException(
         new PrologWarning(string.Format(formatString, formatArgs),
                           string.Format("{0} (at {1}:{2})\n", ISOPrologWriter.WriteToString(this.Head), this.SourceFile, this.SourceLineNumber))
         );
     //Console.Write(" in predicate {0}:{1}/{2}.", kb.Name, HeadFunctor, HeadArity);
 }
예제 #6
0
파일: ELProlog.cs 프로젝트: mantoun/MKULTRA
        //
        // these write a single nodes, so they don't need to loop like queries do.
        //

        /// <summary>
        /// Write TERM to EL KB, creating any nodes that need to be cerated.
        /// </summary>
        /// <param name="term">Prolog-format term to store into KB</param>
        /// <param name="knowledgeBase">KB in which to assert the term.</param>
        /// <returns></returns>
        public static ELNode Update(object term, KnowledgeBase knowledgeBase)
        {
            term = Term.Deref(term);
            var s = term as Structure;
            if (s != null)
                return UpdateStructure(s, knowledgeBase);
            var n = term as ELNode;
            if (n != null)
                return n;

            throw new Exception("Malformed EL assertion: " + ISOPrologWriter.WriteToString(term));
        }
예제 #7
0
 /// <summary>
 /// Prints to the console the disassembled bytecode for all rules in this predicate.
 /// </summary>
 public void Disassemble()
 {
     foreach (var knowledgeBaseEntry in Entries)
     {
         var rule = (ByteCompiledRule)knowledgeBaseEntry;
         Console.WriteLine("");
         Console.Write(ISOPrologWriter.WriteToString(rule.Head));
         Console.Write(" :- \n    ");
         Console.Write(ISOPrologWriter.WriteToString(rule.Body));
         Console.WriteLine(".");
         rule.Disassemble();
     }
 }
예제 #8
0
파일: ELProlog.cs 프로젝트: mantoun/MKULTRA
 public static ELNode UpdateStructure(Structure term, KnowledgeBase knowledgeBase)
 {
     if (term.Functor == Symbol.Slash)
     {
         if (term.Arity == 1)
             return knowledgeBase.ELRoot.StoreNonExclusive(Term.CopyInstantiation(term.Argument(0)));
         return Update(term.Argument(0), knowledgeBase).StoreNonExclusive(Term.CopyInstantiation(term.Argument(1)));
     }
     if (term.Functor == Symbol.Colon)
     {
         return Update(term.Argument(0), knowledgeBase).StoreExclusive(Term.CopyInstantiation(term.Argument(1)), true); 
     }
     throw new Exception("Malformed EL assertion: "+ISOPrologWriter.WriteToString(term));
 }
        internal void PrintWarning(string formatString, params object[] formatArgs)
        {
#if DisableUnity
            Console.Write("{0} (at {1}:{2}): ",
                          ISOPrologWriter.WriteToString(this.Head), this.SourceFile, this.SourceLineNumber);
            Console.WriteLine(formatString, formatArgs);
#else
            //Repl.StartWarnings();
            Debug.LogException(
                new PrologWarning(string.Format(formatString, formatArgs),
                                  string.Format("{0} (at {1}:{2})\n", ISOPrologWriter.WriteToString(this.Head), this.SourceFile, this.SourceLineNumber))
                );
#endif
        }
        public override string ToString()
        {
            switch (Type)
            {
            case IndexerType.Structure:
                return(string.Format("{0}/{1}", ((Symbol)Functor).Name, Arity));

            case IndexerType.Atom:
                return(ISOPrologWriter.WriteToString(Functor));

            case IndexerType.Variable:
                return("Var");

            case IndexerType.Null:
                return("NullIndexer");
            }
            return("<PredicateArgumentIndexer with invalid type>");
        }
예제 #11
0
        /// <summary>
        /// Testing jig for byte compiler
        /// </summary>
        public void Test(string call)
        {
            var term = (Structure)(new ISOPrologReader(call).ReadTerm());

            if (term.Arity != predicate.Arity)
            {
                throw new Exception("Wrong number of arguments");
            }
            using (var c = PrologContext.Allocate(KnowledgeBase.Global, null))
            {
                c.PushArguments(term.Arguments);
                int solutions = 0;
                foreach (var x in StackCall(c))
                {
                    foreach (var arg in term.Arguments)
                    {
                        if (arg is LogicVariable)
                        {
                            var l = arg as LogicVariable;
                            Console.WriteLine("{0}={1}", l.Name, ISOPrologWriter.WriteToString(l.Value));
                        }
                    }
                    Console.WriteLine(x);
                    if (solutions++ > 10)
                    {
                        Console.WriteLine("Max solutions found; terminating search");
                        c.PopFrame(0);
                        goto abort;
                    }
                }
                Console.WriteLine("fail");
abort:
                int tos = c.MakeFrame(0);
                if (tos != 0)
                {
                    Console.WriteLine("Error: tos is " + tos);
                }
            }
        }
예제 #12
0
 public GoalException(object goal, string message) : base(string.Format("{0}: {1}", message, ISOPrologWriter.WriteToString(goal)))
 {
     Goal = goal;
 }
 public override string ToString()
 {
     return(ISOPrologWriter.WriteToString(new Structure(":-", head, Body)));
 }
예제 #14
0
        // This ought to get refactored so that it's shared with the render code in the main class.
        private void AddItem(object data)
        {
            var op = data as Structure;

            if (op != null)
            {
                switch (op.Functor.Name)
                {
                case "cons":
                    AddItem(op.Argument(0));
                    AddItem(op.Argument(1));
                    break;

                case "line":
                    foreach (var arg in op.Arguments)
                    {
                        AddItem(arg);
                    }
                    textBuilder.AppendLine();
                    break;

                case "color":
                    textBuilder.AppendFormat("<color={0}>", op.Argument(0));
                    for (int i = 1; i < op.Arity; i++)
                    {
                        AddItem(op.Argument(i));
                    }
                    textBuilder.Append("</color>");
                    break;

                case "size":
                    textBuilder.AppendFormat("<size={0}>", op.Argument(0));
                    for (int i = 1; i < op.Arity; i++)
                    {
                        AddItem(op.Argument(i));
                    }
                    textBuilder.Append("</size>");
                    break;

                case "bold":
                    textBuilder.AppendFormat("<b>");
                    for (int i = 0; i < op.Arity; i++)
                    {
                        AddItem(op.Argument(i));
                    }
                    textBuilder.Append("</b>");
                    break;

                case "italic":
                    textBuilder.AppendFormat("<i>");
                    for (int i = 0; i < op.Arity; i++)
                    {
                        AddItem(op.Argument(i));
                    }
                    textBuilder.Append("</i>");
                    break;

                case "term":
                    textBuilder.Append(ISOPrologWriter.WriteToString(op.Argument(0)));
                    break;

                default:
                    textBuilder.Append(ISOPrologWriter.WriteToString(op));
                    break;
                }
            }
            else
            {
                var str = data as string;
                textBuilder.Append(str ?? ISOPrologWriter.WriteToString(data));
            }
        }
예제 #15
0
        private void Render(object renderingOperation)
        {
            renderingOperation = Term.Deref(renderingOperation);
            if (renderingOperation == null)
            {
                return;
            }

            var op = renderingOperation as Structure;

            if (op != null)
            {
                switch (op.Functor.Name)
                {
                case "cons":
                    Render(op.Argument(0));
                    Render(op.Argument(1));
                    break;

                case "line":
                    foreach (var arg in op.Arguments)
                    {
                        Render(arg);
                    }
                    textBuilder.AppendLine();
                    break;

                case "color":
                    textBuilder.AppendFormat("<color={0}>", op.Argument(0));
                    for (int i = 1; i < op.Arity; i++)
                    {
                        Render(op.Argument(i));
                    }
                    textBuilder.Append("</color>");
                    break;

                case "size":
                    textBuilder.AppendFormat("<size={0}>", op.Argument(0));
                    for (int i = 1; i < op.Arity; i++)
                    {
                        Render(op.Argument(i));
                    }
                    textBuilder.Append("</size>");
                    break;

                case "bold":
                    textBuilder.AppendFormat("<b>");
                    for (int i = 0; i < op.Arity; i++)
                    {
                        Render(op.Argument(i));
                    }
                    textBuilder.Append("</b>");
                    break;

                case "italic":
                    textBuilder.AppendFormat("<i>");
                    for (int i = 0; i < op.Arity; i++)
                    {
                        Render(op.Argument(i));
                    }
                    textBuilder.Append("</i>");
                    break;

                case "term":
                    textBuilder.Append(ISOPrologWriter.WriteToString(op.Argument(0)));
                    break;

                case "table":
                    MakeTable(op.Argument(0));
                    break;

                default:
                    textBuilder.Append(ISOPrologWriter.WriteToString(op));
                    break;
                }
            }
            else
            {
                var str = renderingOperation as string;
                textBuilder.Append(str ?? ISOPrologWriter.WriteToString(renderingOperation));
            }
        }
예제 #16
0
 /// <summary>
 /// Converts an arbitrary object to a string in Prolog format.
 /// </summary>
 public static string ToStringInPrologFormat(object value)
 {
     return(ISOPrologWriter.WriteToString(value));
 }
예제 #17
0
 /// <summary>
 /// Renders term in Prolog format
 /// </summary>
 public override string ToString()
 {
     return(ISOPrologWriter.WriteToString(this));
 }
예제 #18
0
        public static PredicateIndicator FromExpression(object expression)
        {
            var s = Term.Deref(expression) as Structure;

            if (s == null ||
                (!s.IsFunctor(Symbol.Slash, 2) && !s.IsFunctor(Symbol.SlashSlash, 2)) ||
                !(s.Argument(0) is Symbol) ||
                !(s.Argument(1) is int))
            {
                throw new ArgumentException("Predicate indicator should be of the form functor/arity, but got " + ISOPrologWriter.WriteToString(expression));
            }
            return(new PredicateIndicator((Symbol)s.Argument(0), (int)s.Argument(1)));
        }