Наследование: IComparable
Пример #1
0
 public TermSet(Term list)
 {
     while (list.Arity == 2)
       {
     Add(list.Arg(0));
     list = list.Arg(1);
       }
 }
Пример #2
0
        public Term ToList()
        {
            Term t;

              t = Term.NULLLIST; // []
              for (int i = Count - 1; i >= 0; i--)
            t = new Term(Parser.DOT, (Term)this[i], t, FType.comp, OType.xfy, 100); // [a1, a2, ...]

              return t;
        }
Пример #3
0
        public void Insert(Term termToInsert)
        {
            int i = BinarySearch(termToInsert);

              if (i >= 0) // found
              {
            if (dupMode == DupMode.dupAccept) Insert(i, termToInsert);
              }
              else
            Insert(~i, termToInsert);
        }
Пример #4
0
 private void ClauseSequence(TerminalSet _TS)
 {
     Monitor.Enter(PrologEngine.TermMonitor);
       do
       {
     ClauseNode(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                        ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString));
     Monitor.Pulse(PrologEngine.TermMonitor);
     Monitor.Wait(PrologEngine.TermMonitor);
     GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                       ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString), false, true);
       } while (!(_TS.Contains(symbol.Terminal)));
       readTerm = new Term(EOF);
       Monitor.Pulse(PrologEngine.TermMonitor);
       Monitor.Exit(PrologEngine.TermMonitor);
 }
Пример #5
0
 internal abstract IEnumerable<bool> UnifyWithTerm(Term term);
Пример #6
0
    public bool RetractAll(Term t, VarStack varStack) // should *always* return true ?????
    {
      // remark: first-argument indexing is not affected by deleting clauses

      string key = t.KbKey;

      if (predefineds.Contains(key))
        PrologIO.Error("retract of predefined predicate {0} not allowed", key);

      PredicateDescr pd = this[key];

      if (pd == null) return true;

#if persistent
      if (pd is PersistentPredDescr)
      {
        ((PersistentPredDescr)pd).Retract (t, varStack, null);

        return true;  /////////////JPO persistent retract always to succeed ????
      }
#endif

      ClauseNode c = pd.GetClauseList(null, null);
      ClauseNode prevc = null;
      bool match = false;

      while (c != null)
      {
        Term cleanTerm = c.Term.CleanCopy();

        if (cleanTerm.Unifiable(t, varStack)) // match found -- remove this term from the chain
        {
          match = true; // to indicate that at least one term was found

          if (prevc == null) // remove first clause
          {
            if (c.NextClause == null) // we are about to remove the last remaining clause for this predicate
            {
              predTable.Remove(key);        // ... so remove its PredicateDescr as well

              break;
            }
            else
              pd.SetClauseListHead(c.NextClause);
          }
          else // not the first
          {
            prevc.NextClause = c.NextClause;
            prevc = c;
          }
        }
        else
          prevc = c;

        c = c.NextClause;
      }

      if (match)
      {
#if arg1index
        pd.DestroyFirstArgIndex (); // rebuild by ResolveIndices()
#endif
        pd.AdjustClauseListEnd();
        ResolveIndices();
      }

      return true;
    }
Пример #7
0
    public void Assert(Term assertion, bool asserta)
    {
      assertion = assertion.CleanCopy(); // make a fresh copy

      Term head;
      TermNode body = null;

      if (assertion.Functor == Parser.IMPLIES)
      {
        head = assertion.Arg(0);
        body = assertion.Arg(1).ToGoalList();
      }
      else
        head = assertion;

      if (head.IsVar) PrologIO.Error("Cannot assert a variable as predicate head");

      string key = head.KbKey;

      // A predefined predicate (which may also be defined as operator) may not be redefined.
      // Operators ':-', ',', ';', '-->', '->' (precedence >= 1000) may also not be redefined.

      if (predefineds.Contains(key) || (head.Precedence >= 1000))
        PrologIO.Error("assert cannot be applied to predefined predicate or system operator {0}", assertion.Index);

      PredicateDescr pd = (PredicateDescr)predTable[key];

#if persistent
      if (pd != null && pd is PersistentPredDescr)
      {
        ((PersistentPredDescr)pd).Assert (head);

        return;
      }
#endif

      ClauseNode newC = new ClauseNode(head, body);

      if (pd == null) // first head
      {
        SetClauseList(PredEnum.session, head.Functor, head.Arity, newC);
        ResolveIndices();
      }
      else if (asserta) // at beginning
      {
        newC.NextClause = pd.ClauseNode; // pd.ClauseNode may be null
        SetClauseList(PredEnum.session, head.Functor, head.Arity, newC);
#if arg1index
        pd.CreateFirstArgIndex (); // re-create
#endif
      }
      else // at end
      {
        pd.AppendToClauseList(newC);
#if arg1index
        pd.CreateFirstArgIndex (); // re-create
#endif
      }
    }
Пример #8
0
 internal override IEnumerable<bool> UnifyWithTerm(Term value)
 {
     return value.UnifyWithAtomicConstant(this);
 }
Пример #9
0
 public void Clear()
 {
     term = null;
       nextNode = null;
       nextClause = null;
       level = 0;
 }
Пример #10
0
 internal override IEnumerable <bool> UnifyWithTerm(Term term)
 {
     return(UnifyWithCanonicalValue(term));
 }
Пример #11
0
 internal override bool UnifyWithTerm(Term term, PrologContext context)
 {
     return(UnifyWithCanonicalValue(term, context));
 }
Пример #12
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));
            }
        }
Пример #13
0
        public void Consult(TextReader inStream)
        {
            sourceFiles.NoteFile(Prolog.CurrentSourceFile);
            var reader = new ISOPrologReader(inStream);
            reader.SkipLayout();
            int lastLine = reader.LineNumber;
            using (var context = PrologContext.Allocate(this, this))
            {
                try
                {
                    object unexpanded;
                    Prolog.CurrentSourceLineNumber = lastLine;
                    while ((unexpanded = reader.ReadTerm()) != Symbol.EndOfFile)
                    {
                        // Perform user-level macroexpansion.
                        object assertion = TermExpansion(unexpanded);
                        if (ELProlog.IsELTerm(assertion))
                            // It's an EL term.
                            ELProlog.Update(assertion, this);
                        else
                        {
                            // It's a normal Prolog term
                            var t = Term.Structurify(
                                assertion,
                                "Assertions in prolog files must be valid propositions or predicates.");

                            // Perform built-in macroexpansion.
                            t = t.Expand();

                            if (t.IsFunctor(Symbol.Implication, 1))
                            {
                                context.Reset();
                                var goal = Term.Structurify(
                                    t.Argument(0),
                                    "Argument to a :- directive must be an atom or structure.");
                                // Run t once, but don't backtrack for a second solution (since it's presumably an imperative anyway).
                                Prove(goal.Functor, goal.Arguments, context, 0).GetEnumerator().MoveNext();
                            }
                            else
                                Assert(t, true, true);
                        }
                        reader.SkipLayout();
                        lastLine = reader.LineNumber;
                        Prolog.CurrentSourceLineNumber = lastLine;
                    }
                }
                catch (InferenceStepsExceededException e)
                {
                    Repl.RecordExceptionSourceLocation(e, lastLine);
                    throw;
                }
                catch (Exception e)
                {
                    Debug.LogException(e);
                    Repl.RecordExceptionSourceLocation(e, lastLine);
                    throw new PrologError(
                        e,
                        context.StackTrace(Prolog.CurrentSourceFile, Prolog.CurrentSourceLineNumber, "consult/1", false));
                }
            }
        }
Пример #14
0
 // ReSharper disable once InconsistentNaming
 void LoadCSVRow(int rowNumber, Structure row)
 {
     if (!this.IsTrue(new Structure("load_csv_row", rowNumber, row)))
         throw new Exception(string.Format("Failed to load CSV row number {0} : {1}", rowNumber, Term.ToStringInPrologFormat(row)));
 }
Пример #15
0
 private void List(TerminalSet _TS, out Term term)
 {
     Term beforeBar;
       Term afterBar = null;
       ArrayList elements = null;
       terminalTable[DOT] = Atom;
       terminalTable[OP] = Atom;
       GetSymbol(new TerminalSet(LSqBracket), true, true);
       GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
                           CutSym, LSqBracket, RSqBracket, LCuBracket, PrologString), false, true);
       if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                      LSqBracket, LCuBracket, PrologString))
       {
     PrologTerm(new TerminalSet(RSqBracket, VBar), out beforeBar);
     elements = beforeBar.ArgumentsToArrayList(false);
     GetSymbol(new TerminalSet(RSqBracket, VBar), false, true);
     if (symbol.Terminal == VBar)
     {
       symbol.SetProcessed();
       PrologTerm(new TerminalSet(RSqBracket), out afterBar);
     }
       }
       terminalTable[DOT] = Dot;
       terminalTable[OP] = OpSym;
       GetSymbol(new TerminalSet(RSqBracket), true, true);
       if (afterBar == null) term = Term.NULLLIST; else term = afterBar;
       if (elements != null)
     for (int i = elements.Count - 1; i >= 0; i--) term = new ListTerm((Term)elements[i], term);
 }
Пример #16
0
 internal override bool UnifyWithTerm(Term term, PrologContext context)
 {
     return UnifyWithCanonicalValue(term, context);
 }
Пример #17
0
        // whereTerm != null : for persistent predicates only
        // put the predicate definition (if found) into the TermNode if it is not already there
        public bool FindPredicateDefinition(PredicateStorage predicateStorage, Term whereTerm)
        {
            if (predDescr == null) predDescr = predicateStorage[term.KbKey];

              if (predDescr == null) return false;

            #if arg1index
              Term arg;

              if (predDescr.IsFirstArgIndexed)
              {
            if ((arg = term.Arg (0)).IsVar)
              nextClause = predDescr.FirstArgVarClause ();
            else // not a variable
            {
              nextClause = predDescr.FirstArgNonvarClause (arg.Functor);
              // check whether there is an indexed var clause
              if (nextClause == null) nextClause = predDescr.FirstArgVarClause ();
              // if the above failed, the entire predicate fails (no unification possible)
              if (nextClause == null) nextClause = ClauseNode.FAIL; // "fail."
            }

            if (nextClause == null)
              nextClause = predDescr.GetClauseList (term, whereTerm); // GetClauseList: in PredicateStorage
              }
              else // not indexed
            #endif
              nextClause = predDescr.GetClauseList(term, whereTerm); // GetClauseList: in PredicateStorage

              return true;
        }
Пример #18
0
 /// <summary>
 /// Remove a term from the KB.
 /// </summary>
 public void RetractAll(object term)
 {
     if (term == null)
         throw new ArgumentNullException("term", "Term to retract cannot be null.");
     RetractAll(Term.Structurify(term, "Fact is not a valid proposition or predicate."));
 }
Пример #19
0
 public ClauseNode(Term t, TermNode body, double p)
     : this(t, body)
 {
     timestamp = DateTime.Now.Ticks;
     prob = p;
 }
Пример #20
0
    public bool Retract(Term t, VarStack varStack, Term where)
    {
      string key = t.KbKey;

      if (predefineds.Contains(key))
        PrologIO.Error("retract of predefined predicate {0} not allowed", key);

      PredicateDescr pd = this[key];

      if (pd == null) return false;

#if persistent
      if (pd is PersistentPredDescr)
      {
        ((PersistentPredDescr)pd).Retract (t, varStack, where);

        return true;
      }
#endif

      ClauseNode c = pd.GetClauseList(null, null);
      ClauseNode prevc = null;
      Term cleanTerm;
      int top;

      while (c != null)
      {
        cleanTerm = c.Term.CleanCopy();

        top = varStack.Count;

        if (cleanTerm.Unify(t, varStack)) // match found -- remove this term from the chain
        {
          if (prevc == null) // remove first clause
          {
            if (c.NextClause == null) // we are about to remove the last remaining clause for this predicate
            {
              predTable.Remove(key);        // ... so remove its PredicateDescr as well
#if arg1index
              pd.CreateFirstArgIndex (); // re-create
#endif
              ResolveIndices();
            }
            else
              pd.SetClauseListHead(c.NextClause);
          }
          else // not the first
          {
            prevc.NextClause = c.NextClause;
            prevc = c;
            pd.AdjustClauseListEnd();
#if arg1index
            pd.CreateFirstArgIndex (); // re-create
#endif
          }

          return true; // possible bindings must stay intact (e.g. if p(a) then retract(p(X)) yields X=a)
        }

        Term s;
        for (int i = varStack.Count - top; i > 0; i--) // unbind all vars that got bound by the above Unification
        {
          s = (Term)varStack.Pop();
          s.Unbind();
        }

        prevc = c;
        c = c.NextClause;
      }

      ResolveIndices();

      return false;
    }
Пример #21
0
        private Term DataRowAsTerm(int rowNo)
        {
            DataRow row = dataRowCollection [rowNo];

              // caching does not work !!!!!!!!!!!!!!!!! (Conversion to Term fails for unknown reason)
              //if (row [0] != DBNull.Value) return (Term)row [0.Value]; // return cached value, else construct value into row[0]

              PersistentPredDescr ppd = (PersistentPredDescr)predDescr;
              DbMetaDataCollection mdc = ppd.MetaDataCollection;

              // construct the term, by inspecting each argument of the input term.
              // If it is a Var: take the corresponding value from the result set row, otherwise: simply copy the argument
              int colNo = 0;
              int nCols = ppd.Query.Arity;
              Term[] args = new Term [nCols];

              for (int i = 0; i < nCols; i++)
              {
            Term a = ppd.Query.Args [i];

            if (a.IsVar)
              args [i] = DbAccess.DbScalarToTerm (row[1+colNo++], mdc [i].DbType, a.FType, ppd.DbEntity);
            else
              args [i] = a;
              }

              Term rowTerm = new Term (ppd.Name, args);
              row [0] = rowTerm; // cache /// BUT DOES NOT WORK

              return rowTerm;
        }
Пример #22
0
    public bool IsPersistent (Term t)
    {
      PredicateDescr pd = (PredicateDescr)predTable [t.KbKey];

      return (pd == null) ? false : pd is PersistentPredDescr;
    }
Пример #23
0
 public ClauseNode(Term t, TermNode body, double p, long ts)
     : this(t, body)
 {
     timestamp = ts;
     prob = p;
 }
Пример #24
0
 public ClauseNode(Term t, TermNode body)
     : base(t, body)
 {
 }
Пример #25
0
    public bool SetSpy(bool enabled, string functor, int arity, Term list)
    {
      SpyPort ports;

      if (list == null)
        ports = SpyPort.full;
      else
      {
        ports = SpyPort.none;
        string s;

        while (list.Arity == 2)
        {
          s = list.Arg(0).Functor;

          try
          {
            ports |= (SpyPort)Enum.Parse(typeof(SpyPort), s);
          }
          catch
          {
            PrologIO.Error("Illegal value '{0}'", s);
          }
          list = list.Arg(1);
        }
      }

      PredicateDescr pd;

      if (arity == -1)
      {
        bool found = false;

        foreach (DictionaryEntry de in predTable)
          if ((pd = (PredicateDescr)de.Value).Name == functor)
          {
            found = true;
            pd.SetSpy(enabled, pd.Name, pd.Arity, ports, !enabled);
          }

        if (!found) PrologIO.Error("Predicate does not exist: {0}", functor);

        return found;
      }
      else
      {
        if ((pd = (PredicateDescr)predTable[Term.Key(functor, arity)]) == null)
        {
          PrologIO.Error("Predicate does not exist: {0}/{1}", functor, arity);

          return false;
        }
        pd.SetSpy(enabled, functor, arity, ports, !enabled);
      }

      return true;
    }
Пример #26
0
 internal abstract bool UnifyWithTerm(Term term, PrologContext context);
Пример #27
0
    public void SetDiscontiguous(Term t)
    {
      if (t == null || t.Functor != SLASH || !t.Arg(0).IsAtom || !t.Arg(1).IsInteger)
        PrologIO.Error("Illegal or missing argument '{0}' for discontiguous/1", t);

      // The predicate descriptor does not yet exist (and may even not come at all!)
      string key = Term.Key(t.Arg(0).Functor, t.Arg(1).Functor);

      //Console.WriteLine ("--- Setting discontiguous for {0} in definingFile {1}", key, Globals.ConsultFileName);
      isDiscontiguous[key] = "true";
    }
Пример #28
0
 private void ClauseNode(TerminalSet _TS)
 {
     Term head;
       TermNode body = null;
       ClauseNode c;
       if (parseMode != ParseMode.Reading) Globals.EraseVariables();
       GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
                           CutSym, ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString), false, true);
       if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                      LSqBracket, LCuBracket, PrologString))
       {
     PrologTerm(new TerminalSet(Dot, ImpliesSym, DCGArrowSym), out head);
     if (!head.IsGoal)
       PrologIO.Error("Illegal predicate head: {0}", head.ToString());
     GetSymbol(new TerminalSet(Dot, ImpliesSym, DCGArrowSym), false, true);
     if (symbol.IsMemberOf(ImpliesSym, DCGArrowSym))
     {
       GetSymbol(new TerminalSet(ImpliesSym, DCGArrowSym), false, true);
       if (symbol.Terminal == ImpliesSym)
       {
     symbol.SetProcessed();
     Query(new TerminalSet(Dot), out body);
       }
       else
       {
     symbol.SetProcessed();
     Term t;
     PrologTerm(new TerminalSet(Dot), out t);
     body = t.ToDCG(ref head);
       }
     }
     c = new ClauseNode(head, body);
     if (parseMode == ParseMode.Reading) readTerm = new Term(c).CleanUp(); else ps.AddClause(c);
       }
       else if (symbol.Terminal == PromptSym)
       {
     symbol.SetProcessed();
     bool m = inQueryMode;
     bool o = is1000OperatorSetting;
     int k = terminalTable[DOT];
     try
     {
       parseMode = ParseMode.Query;
       inQueryMode = true;
       terminalTable[DOT] = Dot;
       Set1000Operators(true);
       Query(new TerminalSet(Dot), out queryNode);
       PrologIO.Error("'?-' querymode in file not yet supported");
     }
     finally
     {
       inQueryMode = m;
       terminalTable[DOT] = k;
       Set1000Operators(o);
     }
       }
       else
       {
     symbol.SetProcessed();
     terminalTable.Add(Persistent, "Persistent", "persistent");
     terminalTable.Add(Module, "Module", "module");
     terminalTable.Add(UndefPredAction, "UndefPredAction", "undef_pred_action");
     try
     {
       GetSymbol(new TerminalSet(LSqBracket, OpSym, EnsureLoaded, Discontiguous, AllDiscontiguous, Dynamic, Persistent,
                               Module, UndefPredAction), false, true);
       if (symbol.Terminal == OpSym)
       {
     OperatorDefinition(new TerminalSet(Dot), true);
       }
       else if (symbol.Terminal == EnsureLoaded)
       {
     symbol.SetProcessed();
     GetSymbol(new TerminalSet(LeftParen), true, true);
     GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
     if (symbol.Terminal == Atom)
     {
       symbol.SetProcessed();
     }
     else
     {
       symbol.SetProcessed();
     }
     string fileName = Utils.ExtendedFileName(symbol.ToString().ToLower(), ".pl");
     if (Globals.ConsultedFiles[fileName] == null)
     {
       ps.Consult(fileName);
       Globals.ConsultedFiles[fileName] = true;
     }
     GetSymbol(new TerminalSet(RightParen), true, true);
       }
       else if (symbol.Terminal == Discontiguous)
       {
     symbol.SetProcessed();
     Term t;
     PrologTerm(new TerminalSet(Dot), out t);
     ps.SetDiscontiguous(t);
       }
       else if (symbol.Terminal == AllDiscontiguous)
       {
     symbol.SetProcessed();
     ps.SetDiscontiguous(true);
       }
       else if (symbol.Terminal == UndefPredAction)
       {
     symbol.SetProcessed();
     Term t;
     PrologTerm(new TerminalSet(Dot), out t);
     ps.SetUndefPredAction(t, true);
       }
       else if (symbol.Terminal == Dynamic)
       {
     symbol.SetProcessed();
     Term t;
     PrologTerm(new TerminalSet(Dot), out t);
       }
       else if (symbol.Terminal == Persistent)
       {
     PersistentDeclaration(new TerminalSet(Dot));
       }
       else if (symbol.Terminal == Module)
       {
     symbol.SetProcessed();
     GetSymbol(new TerminalSet(LeftParen), true, true);
     try
     {
       terminalTable[COMMA] = Comma;
       GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
       if (symbol.Terminal == Atom)
       {
         symbol.SetProcessed();
       }
       else
       {
         symbol.SetProcessed();
       }
       ps.SetModuleName(symbol.ToString());
       GetSymbol(new TerminalSet(Comma), true, true);
     }
     finally
     {
       terminalTable[COMMA] = Operator;
     }
     Term t;
     PrologTerm(new TerminalSet(RightParen), out t);
     GetSymbol(new TerminalSet(RightParen), true, true);
       }
       else
       {
     symbol.SetProcessed();
     int lines = 0;
     int files = 0;
     try
     {
       while (true)
       {
         GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
         if (symbol.Terminal == Atom)
         {
           symbol.SetProcessed();
         }
         else
         {
           symbol.SetProcessed();
         }
         string fileName = Utils.FileNameFromSymbol(symbol.ToString(), ".pl");
         terminalTable[COMMA] = Operator;
         lines += ps.Consult(fileName);
         files++;
         terminalTable[COMMA] = Comma;
         GetSymbol(new TerminalSet(Comma, RSqBracket), false, true);
         if (symbol.Terminal == Comma)
         {
           symbol.SetProcessed();
         }
         else
           break;
       }
       if (files > 1) PrologIO.Message("Grand total is {0} lines", lines);
     }
     finally
     {
       terminalTable[COMMA] = Operator;
     }
     GetSymbol(new TerminalSet(RSqBracket), true, true);
       }
     }
     finally
     {
       terminalTable.Remove("module");
       terminalTable.Remove("persistent");
       terminalTable.Remove("undef_pred_action");
     }
       }
       GetSymbol(new TerminalSet(Dot), true, true);
 }
Пример #29
0
    public bool SetUndefPredAction(Term t, bool err)
    {
      Term pred = null;
      Term action = null;
      ArrayList args = null;
      string msg;
      bool result = true;

      t.IsPacked = false;
      if (t != null) args = t.ArgumentsToArrayList(false);

      bool OK =
        t != null &&
        (args.Count == 2) &&
        (pred = (Term)args[0]).Arity == 2 &&
        pred.Functor == SLASH &&
        pred.Arg(0).IsAtom &&
        pred.Arg(1).IsInteger;

      if (!OK)
      {
        result = false;
        msg = string.Format("Bad first argument '{0}' for undef_pred_action( <predicate>/<arity>, ...)", t.Arg(0));

        if (err) PrologIO.Error(msg); else PrologIO.Warning(msg);
      }

      OK =
        (action = (Term)args[1]) != null &&
        (action.Functor == "fail" ||
        //          action.Functor == "succeed" ||
          action.Functor == "error" ||
          action.Functor == "warning");

      if (!OK)
      {
        result = false;
        msg = string.Format("Bad second argument '{0}' for undef_pred_action( ..., fail/succeed/warning)", action);

        if (err) PrologIO.Error(msg); else PrologIO.Warning(msg);
      }

      if (result)
      {
        string key = Term.Key(pred.Arg(0).Functor, pred.Arg(1).Functor);
        actionWhenUndefined[key] = (UndefAction)Enum.Parse(typeof(UndefAction), action.Functor, false);
      }

      return result;
    }
Пример #30
0
 private void DCGBracketList(TerminalSet _TS, out Term term)
 {
     Term head;
       ArrayList elements = null;
       GetSymbol(new TerminalSet(LCuBracket), true, true);
       GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
                           CutSym, LSqBracket, LCuBracket, RCuBracket, PrologString), false, true);
       if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                      LSqBracket, LCuBracket, PrologString))
       {
     PrologTerm(new TerminalSet(RCuBracket), out head);
     elements = head.ArgumentsToArrayList(true);
       }
       GetSymbol(new TerminalSet(RCuBracket), true, true);
       term = new DCGTerm();
       if (elements != null)
     for (int i = elements.Count - 1; i >= 0; i--) term = new DCGTerm((Term)elements[i], term);
 }
Пример #31
0
    private enum PredEnum { session, table, execproc, selproc } // table and view are treated identically

#if persistent
    public void SetPersistent (Term t)
    {
      Term pred       = null;
      Term db_info    = null;  // table( <name>) or procedure( <name>, <executable/selectable>)
      bool isTable    = false;
      bool isExec     = false; // executable stored procedure (as opposed to selectable)
      Term dbEntity   = null;
      DbLogin dbLogin = null;
      ArrayList args  = null;
      PredEnum predType;

      t.IsPacked = false;
      if (t != null) args = t.ArgumentsToArrayList (false);
      //for (int i = 0; i < args.Count; i++) Console.WriteLine ("args [{0}] = {1}", i, args [i]);

      bool OK =
        t != null &&
        (args.Count == 2 || args.Count == 5) &&
        (pred = (Term)args [0]).Arity == 2 &&
        pred.Functor == SLASH &&
        pred.Arg (0).IsAtom &&
        pred.Arg (1).IsInteger;

      if (!OK)
        IO.Error ("Bad first argument '{0}' for persistent( <predicate>/<arity>, ...)", t.Arg (0));

      OK =
        (db_info = (Term)args [1]) != null &&
        ( (isTable = (db_info.Functor == "table" || db_info.Functor == "view")) ||
          db_info.Functor == "procedure" ||
          db_info.Functor == "proc") &&
          db_info.Arity > 0 &&
        ( (dbEntity = db_info.Arg (0)).IsAtom || dbEntity.IsString );

      if (!OK)
        IO.Error ("Bad second argument '{0}' for persistent( ..., table/view/procedure(...))", db_info);

      if (isTable)
      {
        if (db_info.Arity != 1)
          IO.Error ("Bad second argument '{0}' for persistent( ..., table/view( <db_entity_name>))", db_info);

        predType = PredEnum.table;
      }
      else
      {
        string invocation;

        OK = (db_info.Arity == 2) &&  // procedure( <name>, <executable/selectable>)
             ( (isExec = ((invocation = db_info.Arg (1).Functor) == "executable" || invocation == "exec")) ||
               invocation == "selectable" || invocation == "select" );

        if (!OK)
          IO.Error ("Bad second argument '{0}' for persistent( ..., procedure( <db_entity_name>, [selectable|executable]))", t.Arg (1));

        predType = isExec ? PredEnum.execproc : PredEnum.selproc;
      }

      string functor = pred.Arg (0).Functor;
      int    arity   = Convert.ToInt32 (pred.Arg (1).Functor);
      string index   = Term.Key (functor, arity);

      if (predefineds [index] != null)
        IO.Error ("Predefined predicate '{0}/{1}' cannot be declared as persistent", functor, arity);

      if (args.Count == 5)
      {
        for (int i = 2; i <= 4; i++)
          if (!(((Term)args [i]).IsAtom || ((Term)args [i]).IsString))
            IO.Error ("Argument '{0}' not an atom or string", (Term)args [i]);

        dbLogin = new DbLogin (((Term)args [2]).Functor, ((Term)args [3]).Functor, ((Term)args [4]).Functor);
      }

      PredicateDescr pd = this [index];

      if (pd != null) // apparently already defined
      {
        string definingFile = (pd.DefiningFile == Globals.ConsultFileName) ? "this file" : pd.DefiningFile;

        if (!(pd is PersistentPredDescr))
          IO.Error ("Predicate '{0}/{1}' cannot be declared as persistent (predicate defined in {2})", functor, arity, definingFile);
      }

      pd = SetClauseList (predType, functor, arity, null);

      ((PersistentPredDescr)pd).DbEntity = dbEntity.Functor;
      ((PersistentPredDescr)pd).DbLogin  = dbLogin;
    }
Пример #32
0
 private void PrologTerm(TerminalSet _TS, out Term t)
 {
     Term lastInfix = null;
       string s;
       ArrayList termInfixArr = new ArrayList();
       termInfixArr.Add(null);
       do
       {
     GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
                             CutSym, LSqBracket, LCuBracket, PrologString), false, true);
     if (symbol.Terminal == Operator)
     {
       symbol.SetProcessed();
       t = new Term((OperatorDescr)symbol.OValue);
     }
     else if (symbol.IsMemberOf(StringLiteral, Atom))
     {
       GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
       if (symbol.Terminal == Atom)
       {
     symbol.SetProcessed();
     s = symbol.ToString();
       }
       else
       {
     symbol.SetProcessed();
     s = Utils.UnquoteIfUnnecessary(symbol.ToString());
       }
       Term[] terms = null;
       bool b = is1000OperatorSetting;
       GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
                         CutSym, LSqBracket, LCuBracket, PrologString), false, true);
       if (symbol.Terminal == LeftParen)
       {
     symbol.SetProcessed();
     Set1000Operators(true);
     terminalTable[DOT] = Atom;
     terminalTable[OP] = Atom;
     PrologTerm(new TerminalSet(RightParen), out t);
     terminalTable[DOT] = Dot;
     terminalTable[OP] = OpSym;
     terms = t.ArgumentsToTermArray();
     Set1000Operators(b);
     GetSymbol(new TerminalSet(RightParen), true, true);
       }
       if (terms == null) t = new Term(s); else t = new Term(s, terms);
     }
     else if (symbol.Terminal == Identifier)
     {
       symbol.SetProcessed();
       s = symbol.ToString();
       t = Globals.GetVariable(s);
       if (t == null)
       {
     t = new NamedVar(s);
     Globals.SetVariable(t, s);
       }
     }
     else if (symbol.Terminal == Anonymous)
     {
       symbol.SetProcessed();
       t = new Term();
     }
     else if (symbol.IsMemberOf(IntLiteral, RealLiteral))
     {
       GetSymbol(new TerminalSet(IntLiteral, RealLiteral), false, true);
       if (symbol.Terminal == IntLiteral)
       {
     symbol.SetProcessed();
       }
       else
       {
     symbol.SetProcessed();
       }
       t = new Term(symbol.ToString(), FType.number);
     }
     else if (symbol.Terminal == LSqBracket)
     {
       List(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                    LSqBracket, LCuBracket, PrologString), out t);
     }
     else if (symbol.Terminal == LCuBracket)
     {
       DCGBracketList(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
                              CutSym, LSqBracket, LCuBracket, PrologString), out t);
     }
     else if (symbol.Terminal == PrologString)
     {
       symbol.SetProcessed();
       t = new Term(symbol.ToUnquoted(), FType.text);
     }
     else if (symbol.Terminal == CutSym)
     {
       symbol.SetProcessed();
       t = new Cut(0);
     }
     else
     {
       symbol.SetProcessed();
       PrologTerm(new TerminalSet(RightParen), out t);
       GetSymbol(new TerminalSet(RightParen), true, true);
       t.IsPacked = true;
     }
     termInfixArr.Add(t);
     Term.AnalyzeInput(ref termInfixArr, ref lastInfix);
     GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
                       LSqBracket, LCuBracket, PrologString), false, true);
       } while (!(_TS.Contains(symbol.Terminal)));
       termInfixArr.Add(null);
       Term.AnalyzeInput(ref termInfixArr, ref lastInfix);
       t = Term.InfixToPrefix(termInfixArr);
 }
Пример #33
0
    public void SetUnpersistent (Term t)
    {
      Term s;

      if ( t == null ||
           t.Arity != 1 ||
           (s = t.Arg (0)).Arity != 2 ||
           s.Functor != SLASH ||
           !s.Arg (0).IsAtom ||
           !s.Arg (1).IsInteger )
        IO.Error ("Bad argument(s) {0} for unpersistent( <predicate>/<arity>)", t);

      string functor = t.Arg (0).Arg (0).Functor; // do not touch case
      int    arity   = Convert.ToInt32 (t.Arg (0).Arg (1).Functor);
      string key     = Term.Key (functor, arity);

      if (predefineds [key] != null)
        IO.Error ("Predefined predicate '{0}/{1}' cannot be declared as unpersistent", functor, arity);

      PredicateDescr pd = this [key];

      if (pd == null || !(pd is PersistentPredDescr))
        IO.Error ("Predicate '{0}/{1}' was not declared as persistent", functor, arity);
      else
        this [key] = null;
    }
Пример #34
0
 internal override IEnumerable<bool> UnifyWithTerm(Term term)
 {
     return UnifyWithCanonicalValue(term);
 }
Пример #35
0
 public void SetUnpersistent(Term t)
 {
   PrologIO.Error("Persistent predicates are not available in this version");
 }
Пример #36
0
 internal override bool UnifyWithTerm(Term value, PrologContext context)
 {
     return value.UnifyWithAtomicConstant(this, context);
 }
Пример #37
0
        /// <summary>
        /// Add a term (fact or rule) to the KB.
        /// </summary>
        public void Assert(Structure structure, bool atEnd, bool checkSingletons)
        {
            if (structure == null) throw new ArgumentNullException("structure", "Term to add to KB may not be null.");
            //structure = structure.Expand();

            if (structure == null) throw new ArgumentNullException("structure");

            Structure head = structure.IsFunctor(Symbol.Implication, 2)
                                 ? Term.Structurify(structure.Argument(0),
                                                    "Head of :- must be a valid proposition or predicate.")
                                 : structure;
            if (head.IsFunctor(Symbol.ColonColon, 2))
            {
                var argument = head.Argument(0);
                var kb = argument as KnowledgeBase;
                if (kb == null)
                {
                    var o = argument as GameObject;
                    if (o != null)
                        kb = o.KnowledgeBase();
                    else
                    {
                        var c = argument as Component;
                        if (c != null)
                            kb = c.KnowledgeBase();
                        else
                            throw new ArgumentTypeException(
                                "assert",
                                "knowledgebase",
                                argument,
                                typeof(KnowledgeBase));
                    }
                }
                if (structure.IsFunctor(Symbol.Implication, 2))
                    kb.Assert(
                        new Structure(Symbol.Implication, head.Argument(1), structure.Argument(1)),
                        atEnd,
                        checkSingletons);
                else
                {
                    kb.Assert(structure.Argument(1), atEnd, checkSingletons);
                }
            }
            else
            {
                if (PrologPrimitives.Implementations.ContainsKey(head.Functor))
                    throw new PrologException(
                        new Structure(
                            "error",
                            new Structure(
                                "permission_error",
                                Symbol.Intern("modify"),
                                Symbol.Intern("static_procedure"),
                                Term.PredicateIndicatorExpression(head))));

                KnowledgeBaseRule assertion = KnowledgeBaseRule.FromTerm(
                    structure,
                    checkSingletons,
                    Prolog.CurrentSourceFile,
                    Prolog.CurrentSourceLineNumber);
                PredicateInfo info = EntryForStoring(head.PredicateIndicator);
                PredicateInfo parentInfo;
                if (!info.Shadow && this.Parent != null
                    && (parentInfo = this.Parent.CheckForPredicateInfoInThisKB(head.PredicateIndicator)) != null
                    && !parentInfo.External)
                    throw new PrologException(
                        new Structure(
                            "error",
                            new Structure(
                                "permission_error",
                                Symbol.Intern("shadow"),
                                Term.PredicateIndicatorExpression(head))));

                info.Assert(assertion, atEnd);
            }
        }