386 lines
15 KiB
C#
386 lines
15 KiB
C#
/*
|
|
* Copyright (C) 2007-2008, Jeff Thompson
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the copyright holder nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace OpenSim.Region.ScriptEngine.DotNetEngine.Compiler.YieldProlog
|
|
{
|
|
/// <summary>
|
|
/// An IndexedAnswers holds answers to a query based on the values of index arguments.
|
|
/// </summary>
|
|
public class IndexedAnswers : YP.IClause
|
|
{
|
|
private int _arity;
|
|
// addAnswer adds the answer here and indexes it later.
|
|
private List<object[]> _allAnswers = new List<object[]>();
|
|
// The key has the arity of answers with non-null values for each indexed arg. The value
|
|
// is a list of the matching answers. The signature is implicit in the pattern on non-null index args.
|
|
private Dictionary<HashedList, List<object[]>> _indexedAnswers =
|
|
new Dictionary<HashedList, List<object[]>>();
|
|
// Keeps track of whether we have started adding entries to _indexedAnswers for the signature.
|
|
private Dictionary<int, object> _gotAnswersForSignature = new Dictionary<int, object>();
|
|
private const int MAX_INDEX_ARGS = 31;
|
|
|
|
public IndexedAnswers(int arity)
|
|
{
|
|
_arity = arity;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Append the answer to the list and update the indexes, if any.
|
|
/// Elements of answer must be ground, since arguments with unbound variables make this
|
|
/// into a dynamic rule which we don't index.
|
|
/// </summary>
|
|
/// <param name="answer"></param>
|
|
public void addAnswer(object[] answer)
|
|
{
|
|
addOrPrependAnswer(answer, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepend the answer to the list and clear the indexes so that they must be re-computed
|
|
/// on the next call to match. (Only addAnswer will maintain the indexes while adding answers.)
|
|
/// Elements of answer must be ground, since arguments with unbound variables make this
|
|
/// into a dynamic rule which we don't index.
|
|
/// </summary>
|
|
/// <param name="answer"></param>
|
|
public void prependAnswer(object[] answer)
|
|
{
|
|
addOrPrependAnswer(answer, true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Do the work of addAnswer or prependAnswer.
|
|
/// </summary>
|
|
/// <param name="answer"></param>
|
|
private void addOrPrependAnswer(object[] answer, bool prepend)
|
|
{
|
|
if (answer.Length != _arity)
|
|
return;
|
|
|
|
// Store a copy of the answer array.
|
|
object[] answerCopy = new object[answer.Length];
|
|
Variable.CopyStore copyStore = new Variable.CopyStore();
|
|
for (int i = 0; i < answer.Length; ++i)
|
|
answerCopy[i] = YP.makeCopy(answer[i], copyStore);
|
|
if (copyStore.getNUniqueVariables() > 0)
|
|
throw new InvalidOperationException
|
|
("Elements of answer must be ground, but found " + copyStore.getNUniqueVariables() +
|
|
" unbound variables");
|
|
|
|
if (prepend)
|
|
{
|
|
_allAnswers.Insert(0, answerCopy);
|
|
clearIndexes();
|
|
}
|
|
else
|
|
{
|
|
_allAnswers.Add(answerCopy);
|
|
// If match has already indexed answers for a signature, we need to add
|
|
// this to the existing indexed answers.
|
|
foreach (int signature in _gotAnswersForSignature.Keys)
|
|
indexAnswerForSignature(answerCopy, signature);
|
|
}
|
|
}
|
|
|
|
private void indexAnswerForSignature(object[] answer, int signature)
|
|
{
|
|
// First find out which of the answer values can be used as an index.
|
|
object[] indexValues = new object[answer.Length];
|
|
for (int i = 0; i < answer.Length; ++i)
|
|
{
|
|
// We limit the number of indexed args in a 32-bit signature.
|
|
if (i >= MAX_INDEX_ARGS)
|
|
indexValues[i] = null;
|
|
else
|
|
indexValues[i] = getIndexValue(YP.getValue(answer[i]));
|
|
}
|
|
|
|
// We need an entry in indexArgs from indexValues for each 1 bit in signature.
|
|
HashedList indexArgs = new HashedList(indexValues.Length);
|
|
for (int i = 0; i < indexValues.Length; ++i)
|
|
{
|
|
if ((signature & (1 << i)) == 0)
|
|
indexArgs.Add(null);
|
|
else
|
|
{
|
|
if (indexValues[i] == null)
|
|
// The signature wants an index value here, but we don't have one so
|
|
// we can't add it as an answer for this signature.
|
|
return;
|
|
else
|
|
indexArgs.Add(indexValues[i]);
|
|
}
|
|
}
|
|
|
|
// Add the answer to the answers list for indexArgs, creating the entry if needed.
|
|
List<object[]> answers;
|
|
if (!_indexedAnswers.TryGetValue(indexArgs, out answers))
|
|
{
|
|
answers = new List<object[]>();
|
|
_indexedAnswers[indexArgs] = answers;
|
|
}
|
|
answers.Add(answer);
|
|
}
|
|
|
|
public IEnumerable<bool> match(object[] arguments)
|
|
{
|
|
if (arguments.Length != _arity)
|
|
yield break;
|
|
|
|
// Set up indexArgs, up to arg position MAX_INDEX_ARGS. The signature has a 1 bit for
|
|
// each non-null index arg.
|
|
HashedList indexArgs = new HashedList(arguments.Length);
|
|
bool gotAllIndexArgs = true;
|
|
int signature = 0;
|
|
for (int i = 0; i < arguments.Length; ++i)
|
|
{
|
|
object indexValue = null;
|
|
if (i < MAX_INDEX_ARGS)
|
|
{
|
|
// We limit the number of args in a 32-bit signature.
|
|
indexValue = getIndexValue(YP.getValue(arguments[i]));
|
|
if (indexValue != null)
|
|
signature += (1 << i);
|
|
}
|
|
if (indexValue == null)
|
|
gotAllIndexArgs = false;
|
|
indexArgs.Add(indexValue);
|
|
}
|
|
|
|
List<object[]> answers;
|
|
if (signature == 0)
|
|
// No index args, so we have to match from _allAnswers.
|
|
answers = _allAnswers;
|
|
else
|
|
{
|
|
if (!_gotAnswersForSignature.ContainsKey(signature))
|
|
{
|
|
// We need to create the entry in _indexedAnswers.
|
|
foreach (object[] answer in _allAnswers)
|
|
indexAnswerForSignature(answer, signature);
|
|
// Mark that we did this signature.
|
|
_gotAnswersForSignature[signature] = null;
|
|
}
|
|
if (!_indexedAnswers.TryGetValue(indexArgs, out answers))
|
|
yield break;
|
|
}
|
|
|
|
if (gotAllIndexArgs)
|
|
{
|
|
// All the arguments were already bound, so we don't need to do bindings.
|
|
yield return false;
|
|
yield break;
|
|
}
|
|
|
|
// Find matches in answers.
|
|
IEnumerator<bool>[] iterators = new IEnumerator<bool>[arguments.Length];
|
|
// Debug: If the caller asserts another answer into this same predicate during yield, the iterator
|
|
// over clauses will be corrupted. Should we take the time to copy answers?
|
|
foreach (object[] answer in answers)
|
|
{
|
|
bool gotMatch = true;
|
|
int nIterators = 0;
|
|
// Try to bind all the arguments.
|
|
for (int i = 0; i < arguments.Length; ++i)
|
|
{
|
|
if (indexArgs[i] != null)
|
|
// We already matched this argument by looking up _indexedAnswers.
|
|
continue;
|
|
|
|
IEnumerator<bool> iterator = YP.unify(arguments[i], answer[i]).GetEnumerator();
|
|
iterators[nIterators++] = iterator;
|
|
// MoveNext() is true if YP.unify succeeds.
|
|
if (!iterator.MoveNext())
|
|
{
|
|
gotMatch = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
if (gotMatch)
|
|
yield return false;
|
|
}
|
|
finally
|
|
{
|
|
// Manually finalize all the iterators.
|
|
for (int i = 0; i < nIterators; ++i)
|
|
iterators[i].Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
public IEnumerable<bool> clause(object Head, object Body)
|
|
{
|
|
Head = YP.getValue(Head);
|
|
if (Head is Variable)
|
|
throw new PrologException("instantiation_error", "Head is an unbound variable");
|
|
object[] arguments = YP.getFunctorArgs(Head);
|
|
|
|
// We always match Head from _allAnswers, and the Body is Atom.a("true").
|
|
#pragma warning disable 0168
|
|
foreach (bool l1 in YP.unify(Body, Atom.a("true")))
|
|
{
|
|
// The caller can assert another answer into this same predicate during yield, so we have to
|
|
// make a copy of the answers.
|
|
foreach (object[] answer in _allAnswers.ToArray())
|
|
{
|
|
foreach (bool l2 in YP.unifyArrays(arguments, answer))
|
|
yield return false;
|
|
}
|
|
}
|
|
#pragma warning restore 0168
|
|
}
|
|
|
|
public IEnumerable<bool> retract(object Head, object Body)
|
|
{
|
|
Head = YP.getValue(Head);
|
|
if (Head is Variable)
|
|
throw new PrologException("instantiation_error", "Head is an unbound variable");
|
|
object[] arguments = YP.getFunctorArgs(Head);
|
|
|
|
// We always match Head from _allAnswers, and the Body is Atom.a("true").
|
|
#pragma warning disable 0168
|
|
foreach (bool l1 in YP.unify(Body, Atom.a("true")))
|
|
{
|
|
// The caller can assert another answer into this same predicate during yield, so we have to
|
|
// make a copy of the answers.
|
|
foreach (object[] answer in _allAnswers.ToArray())
|
|
{
|
|
foreach (bool l2 in YP.unifyArrays(arguments, answer))
|
|
{
|
|
_allAnswers.Remove(answer);
|
|
clearIndexes();
|
|
yield return false;
|
|
}
|
|
}
|
|
}
|
|
#pragma warning restore 0168
|
|
}
|
|
|
|
/// <summary>
|
|
/// After retracting or prepending an answer in _allAnswers, the indexes are invalid, so clear them.
|
|
/// </summary>
|
|
private void clearIndexes()
|
|
{
|
|
_indexedAnswers.Clear();
|
|
_gotAnswersForSignature.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// A HashedList extends an ArrayList with methods to get a hash and to check equality
|
|
/// based on the elements of the list.
|
|
/// </summary>
|
|
public class HashedList : ArrayList
|
|
{
|
|
private bool _gotHashCode = false;
|
|
private int _hashCode;
|
|
|
|
public HashedList()
|
|
: base()
|
|
{
|
|
}
|
|
|
|
public HashedList(int capacity)
|
|
: base(capacity)
|
|
{
|
|
}
|
|
|
|
public HashedList(ICollection c)
|
|
: base(c)
|
|
{
|
|
}
|
|
|
|
// Debug: Should override all the other methods that change this.
|
|
public override int Add(object value)
|
|
{
|
|
_gotHashCode = false;
|
|
return base.Add(value);
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
if (!_gotHashCode)
|
|
{
|
|
int hashCode = 1;
|
|
foreach (object obj in this)
|
|
hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode());
|
|
_hashCode = hashCode;
|
|
_gotHashCode = true;
|
|
}
|
|
return _hashCode;
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (!(obj is ArrayList))
|
|
return false;
|
|
|
|
ArrayList objList = (ArrayList)obj;
|
|
if (objList.Count != Count)
|
|
return false;
|
|
|
|
for (int i = 0; i < Count; ++i)
|
|
{
|
|
object value = objList[i];
|
|
if (value == null)
|
|
{
|
|
if (this[i] != null)
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (!value.Equals(this[i]))
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If we keep an index on value, return the value, or null if we don't index it.
|
|
/// </summary>
|
|
/// <param name="value">the term to examine. Assume you already called YP.getValue(value)</param>
|
|
/// <returns></returns>
|
|
public static object getIndexValue(object value)
|
|
{
|
|
if (value is Atom || value is string || value is Int32 || value is DateTime)
|
|
return value;
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
}
|