// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="termbaseSet"></param>
/// <returns></returns>
/// <created>UPh,25.10.2015</created>
/// <changed>UPh,25.10.2015</changed>
// ********************************************************************************
internal TermBaseQueryWorker(TermBaseQuery termbaseQuery, TermBases termbases)
{
_TermbaseQuery = termbaseQuery;
_TermBases = termbases;
_Index = new TermIndex();
_Index2 = new TermIndex();
}
public void TestRead()
{
Stream stream = new MemoryStream();
// FileIndex should support a stream starting at any point
stream.Seek(100, SeekOrigin.Begin);
PerformWrite(stream);
TermIndex index =
new TermIndex(stream);
Assert.AreEqual(100, stream.Position);
Assert.AreEqual(2, index.EntryCount);
IList<Posting> postings;
index.TryGet("aTerm", out postings);
Assert.IsNotNull(postings);
Assert.AreEqual(2, postings.Count);
Assert.AreEqual(new Posting(DocA, 1), postings[0]);
Assert.AreEqual(new Posting(DocB, 1), postings[1]);
index.TryGet("bTerm", out postings);
Assert.IsNotNull(postings);
Assert.AreEqual(3, postings.Count);
Assert.AreEqual(new Posting(DocA, 1), postings[0]);
Assert.AreEqual(new Posting(DocZ, 1), postings[1]);
Assert.AreEqual(new Posting(DocT, 1), postings[2]);
}
public TypeEmbedder(
TermIndex index,
Z3Context context,
Map <BaseSortKind, uint> baseSortCosts)
{
Contract.Requires(index != null && context != null);
Index = index;
Context = context;
//// Build base sorts
Register(new RealEmbedding(this, baseSortCosts[BaseSortKind.Real]));
Register(new IntegerEmbedding(this, baseSortCosts[BaseSortKind.Integer]));
Register(new NaturalEmbedding(this, baseSortCosts[BaseSortKind.Natural]));
Register(new PosIntegerEmbedding(this, baseSortCosts[BaseSortKind.PosInteger]));
Register(new NegIntegerEmbedding(this, baseSortCosts[BaseSortKind.NegInteger]));
Register(new StringEmbedding(this, baseSortCosts[BaseSortKind.String]));
//// Build finite enumerations
var sortToIndex = new Map <Term, Tuple <uint, UserSymbol> >(Term.Compare);
MkEnumTypes(Index.SymbolTable.Root, sortToIndex);
MkConUnnTypes(sortToIndex);
SetDefaultValues();
RegisterEmbeddingAtoms();
}
public BM25Scorer(TermIndex index, IndexMetadata indexMetadata)
{
this.index = index;
this.indexMetadata = indexMetadata;
this.Lavg = indexMetadata.TokenCount / indexMetadata.CollectionLengthInDocuments;
}
private static bool IsPermitted(TermIndex index, bool onlyNewKinds, Term t)
{
Contract.Assert(t.Groundness != Groundness.Variable);
Contract.Assert(t.Symbol.Kind == SymbolKind.BaseCnstSymb ||
t.Symbol.Kind == SymbolKind.BaseOpSymb ||
t.Symbol.Kind == SymbolKind.BaseSortSymb ||
t.Symbol.Kind == SymbolKind.UserCnstSymb ||
t.Symbol.Kind == SymbolKind.UserSortSymb);
Contract.Assert(t.Symbol.Kind != SymbolKind.BaseOpSymb || t.Symbol == index.RangeSymbol);
if (onlyNewKinds)
{
if (t.Symbol.IsDerivedConstant)
{
return(false);
}
else if (t.Symbol.Kind == SymbolKind.UserSortSymb)
{
var conSymb = ((UserSortSymb)t.Symbol).DataSymbol as ConSymb;
return(conSymb == null || conSymb.IsNew);
}
}
return(true);
}
internal ApplyResult(
ModuleData transform,
Map <string, FactSet> modelInputs,
Map <string, Term> valueInputs,
ImmutableCollection <Id> outputNames,
TermIndex index,
ExecuterStatistics stats,
bool keepDers,
CancellationToken cancel)
{
Contract.Requires(transform != null);
Contract.Requires(transform.Reduced.Node.NodeKind == NodeKind.Transform || transform.Reduced.Node.NodeKind == NodeKind.TSystem);
Contract.Requires(modelInputs != null && valueInputs != null && outputNames != null);
Contract.Requires(index != null);
this.cancel = cancel;
this.stats = stats;
this.index = index;
this.modelInputs = modelInputs;
this.valueInputs = valueInputs;
applyTarget = transform;
KeepDerivations = keepDers;
OutputNames = outputNames;
}
public void before()
{
MemoryStream termIndexStream = new MemoryStream();
using (FileIndexWriter<string, IList<Posting>> indexWriter = new FileIndexWriter<string, IList<Posting>>(
new StringEncoder(), new PostingListEncoder(), termIndexStream))
{
this.postingsWithBar = new List<Posting>();
postingsWithBar.Add(new Posting(0, 1));
postingsWithBar.Add(new Posting(1, 2));
indexWriter.Add("bar", postingsWithBar);
this.postingsWithFoo = new List<Posting>();
postingsWithFoo.Add(new Posting(0, 4));
indexWriter.Add("foo", postingsWithFoo);
indexWriter.WriteOut();
}
this.index = new TermIndex(termIndexStream);
MemoryStream metadataStream = new MemoryStream();
using (CollectionMetadataWriter metadataWriter = new CollectionMetadataWriter(metadataStream))
{
metadataWriter.AddDocumentInfo(0, new DocumentInfo("http://www.example.com/index.html", "Example", 100, "", null));
metadataWriter.AddDocumentInfo(1, new DocumentInfo("http://www.example.com/menu.html", "Example", 300, "", null));
metadataWriter.WriteOut();
}
this.metadata = new IndexMetadata(metadataStream);
}
/// <summary>
/// Create a type term from this union. An optional renaming may be applied
/// to its elements.
/// </summary>
internal Term MkTypeTerm(TermIndex index)
{
Contract.Assert(elements.Count > 0 || intervals.Count > 0);
Term t = null;
var tunSymb = index.SymbolTable.GetOpSymbol(ReservedOpKind.TypeUnn);
var noArgs = new Term[0];
bool wasAdded;
//// Step 1. Create an enum of all non-integral constants.
foreach (var e in elements)
{
t = t == null?index.MkApply(e, noArgs, out wasAdded)
: index.MkApply(tunSymb, new Term[] { index.MkApply(e, noArgs, out wasAdded), t }, out wasAdded);
}
//// Step 2. Create an enum of all integer intervals
var rngSymb = index.SymbolTable.GetOpSymbol(ReservedOpKind.Range);
Term beg, end;
foreach (var kv in intervals.CanonicalForm)
{
beg = index.MkCnst(new Rational(kv.Key, BigInteger.One), out wasAdded);
end = index.MkCnst(new Rational(kv.Value, BigInteger.One), out wasAdded);
t = t == null?index.MkApply(rngSymb, new Term[] { beg, end }, out wasAdded)
: index.MkApply(tunSymb, new Term[] { index.MkApply(rngSymb, new Term[] { beg, end }, out wasAdded), t }, out wasAdded);
}
return(t);
}
public static void Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: Spimi <folderpath> <DestinationIndexFilePath> <metadatafilepath");
Console.ReadLine();
return;
}
string directory = args[0];
string indexFilePath = args[1];
string metadataFilePath = args[2];
Console.WriteLine("Welcome to Spimi!");
DirectoryInfo directoryInfo = new DirectoryInfo(directory);
if (!directoryInfo.Exists)
{
Console.WriteLine("Directory could not be found");
return;
}
using (FileStream indexFileStream = File.Open(indexFilePath, FileMode.Create))
{
using (FileStream metadataFileStream = File.Open(metadataFilePath, FileMode.Create))
{
// Index the corpus
Console.WriteLine("Parsing corpus and creating index blocks...");
SpimiIndexer indexer = new SpimiIndexer(
new BasicLexer(),
new HtmlParser(),
indexFileStream,
metadataFileStream);
WebCrawler crawler = new WebCrawler(directoryInfo);
foreach (WebDocument doc in crawler.GetDocuments())
{
Stream stream = doc.Open();
indexer.Index(doc.Uri, stream);
stream.Close();
}
// 2- Build the final index
Console.WriteLine("Merging blocks into one index...");
indexer.WriteOut();
IndexMetadata indexMetadata = new IndexMetadata(metadataFileStream);
TermIndex index = new TermIndex(indexFileStream);
QueryEngine queryEngine = new QueryEngine(index, indexMetadata);
// 3- Query the index
Console.WriteLine("Done! Please use one of the following commands: \n/query <term1> <term2>\n/cluster <k>\n");
QueryCli cli = new QueryCli(indexMetadata, index);
cli.Run();
}
}
}
public Optimizer(
TermIndex index,
IEnumerable <Term> constraints,
Map <Term, Tuple <Term, Term> > findPatterns)
{
Contract.Requires(index != null && findPatterns != null && constraints != null);
this.index = index;
this.findPatterns = findPatterns;
this.constraints = new Set <Term>(Term.Compare, constraints);
}
public ActionSet(AST <Node> ast, TermIndex index)
{
Contract.Requires(index != null && ast != null);
Contract.Requires(ast.Node.NodeKind == NodeKind.Rule || ast.Node.NodeKind == NodeKind.ContractItem);
//// TODO: Accept contract specifications too.
AST = ast;
Index = index;
myComprData = null;
TypeEnvironment = new TypeEnvironment(ast.Node, index);
IsCompiled = LiftedBool.Unknown;
}
/// <summary>
/// Private constructor for building intersections.
/// </summary>
private BinnedUnion(TermIndex index)
{
Contract.Requires(index != null);
unnSymb = index.SymbolTable.GetOpSymbol(ReservedOpKind.TypeUnn);
rngSymb = index.SymbolTable.GetOpSymbol(ReservedOpKind.Range);
realSymb = index.SymbolTable.GetSortSymbol(BaseSortKind.Real);
stringSymb = index.SymbolTable.GetSortSymbol(BaseSortKind.String);
trueSymb = (UserSymbol)index.TrueValue.Symbol;
sourceTerm = null;
this.index = index;
}
private Set <Term> MkSolutionTerms(int solNum, TermIndex index)
{
Contract.Requires(modelOutputs != null && solNum < modelOutputs.Count);
int end;
var facts = new Set <Term>(Term.Compare);
foreach (var s in modelOutputs[solNum])
{
facts.Add(Parse(s, 0, index, out end));
}
return(facts);
}
public BinnedUnion(Term t)
{
Contract.Requires(t != null && t.Groundness != Groundness.Variable);
unnSymb = t.Owner.SymbolTable.GetOpSymbol(ReservedOpKind.TypeUnn);
rngSymb = t.Owner.SymbolTable.GetOpSymbol(ReservedOpKind.Range);
realSymb = t.Owner.SymbolTable.GetSortSymbol(BaseSortKind.Real);
stringSymb = t.Owner.SymbolTable.GetSortSymbol(BaseSortKind.String);
trueSymb = (UserSymbol)t.Owner.TrueValue.Symbol;
index = t.Owner;
sourceTerm = t;
t.Visit(ExpandUnions, Add);
}
public Term MkFindTerm(TermIndex index)
{
if (IsNull)
{
return(index.FalseValue);
}
else if (Binding.Symbol.IsReservedOperation)
{
//// In this case, do not create a find(...) term.
return(Binding);
}
bool wasAdded;
return(index.MkApply(
index.SymbolTable.GetOpSymbol(ReservedOpKind.Find),
new Term[] { Binding, Pattern, index.MkApply(index.TypeRelSymbol, new Term[] { Pattern, Type }, out wasAdded) },
out wasAdded));
}
public IList<ClusterResult> Cluster(int k)
{
using (FileStream indexFileStream = File.Open(indexFilePath, FileMode.Open))
{
using (FileStream metadataFileStream = File.Open(metadataFilePath, FileMode.Open))
{
IndexMetadata indexMetadata = new IndexMetadata(metadataFileStream);
TermIndex index = new TermIndex(indexFileStream);
QueryEngine queryEngine = new QueryEngine(index, indexMetadata);
KMeansClusterFinder clusterFinder = new KMeansClusterFinder(indexMetadata, index);
IList<long> allDocIds = indexMetadata.GetDocumentIds();
long[][] clusters = clusterFinder.Cluster(allDocIds, k);
IList<ClusterResult> clusterResults = new List<ClusterResult>();
foreach (long[] cluster in clusters)
{
// Get the term frequencies in the collection
IEnumerable<DocumentInfo> clusterDocuments = indexMetadata.GetDocuments(cluster);
TermVector sum = new TermVector();
foreach (TermVector vector in clusterDocuments.Select(d => d.TermVector))
{
sum += vector;
}
IEnumerable<string> topTerms =
TermVector.GetCentroid(indexMetadata.GetDocuments(cluster)
.Select(docInfo => docInfo.TermVector))
.GetNonZeroDimensions()
.OrderByDescending(term => sum.GetDimensionLength(term) * this.GetIdf(index, indexMetadata, term))
.Take(6);
clusterResults.Add(new ClusterResult(topTerms.ToList(),
clusterDocuments.Select(docInfo => docInfo.Uri).ToList()));
}
return clusterResults;
}
}
}
internal ApplyResult(
FactSet copy,
ImmutableCollection <Id> outputNames,
TermIndex index,
ExecuterStatistics stats,
bool keepDers,
CancellationToken cancel)
{
Contract.Requires(copy != null && outputNames != null && index != null);
this.cancel = cancel;
this.stats = stats;
this.index = index;
applyTarget = (ModuleData)copy.Model.Node.CompilerData;
KeepDerivations = keepDers;
OutputNames = outputNames;
valueInputs = new Map <string, Term>(string.Compare);
modelInputs = new Map <string, FactSet>(string.Compare);
modelInputs.Add(string.Empty, copy);
}
public override CoreRule Clone(int ruleId, Predicate <Symbol> isCompr, TermIndex index, Map <Term, Term> bindingReificationCache, Map <UserSymbol, UserSymbol> symbolTransfer, string renaming)
{
Contract.Assert(isCompr == null && index != null && bindingReificationCache == null && string.IsNullOrEmpty(renaming));
bool wasAdded;
var newHeadArgs = new Term[Head.Symbol.Arity];
var newHeadCon = symbolTransfer[(UserSymbol)Head.Symbol];
for (int i = 0; i < newHeadArgs.Length; ++i)
{
newHeadArgs[i] = index.MkVar(((UserSymbol)Head.Args[i].Symbol).Name, true, out wasAdded);
}
var newHead = index.MkApply(newHeadCon, newHeadArgs, out wasAdded);
return(new CoreSubRule(
ruleId,
newHead,
index.MkVar(((UserSymbol)Find1.Binding.Symbol).Name, true, out wasAdded),
Matcher.Clone(index)));
}
public SubtermMatcher Clone(TermIndex index)
{
var srcIndex = pattern[0].Owner;
var clone = new SubtermMatcher();
clone.IsMatchOnlyNewKinds = IsMatchOnlyNewKinds;
clone.Trigger = Trigger == null ? null : index.MkClone(Trigger);
clone.IsSatisfiable = IsSatisfiable;
clone.IsTriggerable = IsTriggerable;
Map <Term, Set <int> > levelMatches, clonedLevelMatches;
clone.pattern = new Term[pattern.Length];
clone.matchingUnions = new AppFreeCanUnn[pattern.Length];
for (int i = 0; i < pattern.Length; ++i)
{
clone.pattern[i] = index.MkClone(pattern[i]);
if (matchingUnions[i] != null)
{
clone.matchingUnions[i] = new AppFreeCanUnn(index.MkClone(matchingUnions[i].MkTypeTerm(srcIndex)));
}
if (matcher.TryFindValue(i, out levelMatches))
{
clonedLevelMatches = new Map <Term, Set <int> >(Term.Compare);
foreach (var kv in levelMatches)
{
clonedLevelMatches.Add(index.MkClone(kv.Key), kv.Value);
}
clone.matcher.Add(i, clonedLevelMatches);
}
}
return(clone);
}
internal Term(Symbol symbol, Term[] args, TermIndex owner)
{
Contract.Requires(args != null && args.Length == symbol.Arity);
Owner = owner;
Symbol = symbol;
Args = new ImmutableArray <Term>(args);
if (symbol.Arity == 0)
{
switch (symbol.Kind)
{
case SymbolKind.BaseCnstSymb:
Groundness = Groundness.Ground;
break;
case SymbolKind.BaseSortSymb:
case SymbolKind.UnnSymb:
case SymbolKind.UserSortSymb:
Groundness = Groundness.Type;
break;
case SymbolKind.UserCnstSymb:
Groundness = symbol.IsVariable ? Groundness.Variable : Groundness.Ground;
break;
case SymbolKind.ConSymb:
case SymbolKind.MapSymb:
throw new InvalidOperationException();
default:
throw new NotImplementedException();
}
}
else if (symbol == owner.TypeRelSymbol)
{
Contract.Assert(args[0].Groundness != Groundness.Type);
Contract.Assert(args[1].Groundness != Terms.Groundness.Variable);
Groundness = args[0].Groundness;
}
else
{
Groundness = Groundness.Ground;
foreach (var a in args)
{
if (a.Groundness == Groundness.Variable)
{
Contract.Assert(Groundness != Groundness.Type);
Groundness = Groundness.Variable;
}
else if (a.Groundness == Groundness.Type)
{
Contract.Assert(Groundness != Groundness.Variable);
Groundness = Groundness.Type;
}
}
if (symbol == owner.RangeSymbol || symbol == owner.TypeUnionSymbol)
{
Contract.Assert(Groundness != Groundness.Variable);
Groundness = Groundness.Type;
}
}
}
public BestMatchRanker(TermIndex index, IndexMetadata indexMetadata)
{
this.index = index;
this.indexMetadata = indexMetadata;
this.scorer = new BM25Scorer(index, indexMetadata);
}
public TfIdfScorer(TermIndex index, IndexMetadata indexMetadata)
{
this.index = index;
this.indexMetadata = indexMetadata;
}
public QueryCli(IndexMetadata metadata, TermIndex index)
{
this.metadata = metadata;
this.index = index;
this.queryEngine = new QueryEngine(index, metadata);
}
/// <summary>
/// Create a derivation for facts
/// </summary>
public Derivation(TermIndex index)
{
Rule = null;
Binding1 = Binding2 = index.FalseValue;
}
public KMeansClusterFinder(IndexMetadata metadata, TermIndex index)
{
this.metadata = metadata;
this.index = index;
}
private double GetIdf(TermIndex index, IndexMetadata metadata, string term)
{
double idf = Math.Log(((double)metadata.CollectionLengthInDocuments) / index[term].Count);
return idf;
}
public IList<QueryResult> Query(string query, RankingMode rankingMode)
{
using (FileStream indexFileStream = File.Open(indexFilePath, FileMode.Open))
{
using (FileStream metadataFileStream = File.Open(metadataFilePath, FileMode.Open))
{
IndexMetadata indexMetadata = new IndexMetadata(metadataFileStream);
TermIndex index = new TermIndex(indexFileStream);
QueryEngine queryEngine = new QueryEngine(index, indexMetadata);
IList<long> results = queryEngine.Query(query.ToLower(), rankingMode);
IList<QueryResult> queryResults = new List<QueryResult>();
int i = 1;
Console.WriteLine("rank\tscore\ttitle");
foreach (long docId in results.Take(500))
{
DocumentInfo docInfo;
if (indexMetadata.TryGetDocumentInfo(docId, out docInfo))
{
QueryResult res = new QueryResult()
{
Title = docInfo.Title,
Uri = docInfo.Uri,
Score = queryEngine.Scores[docId]
};
queryResults.Add(res);
}
else
{
Console.WriteLine("Found document id in posting list that wasn't indexed in metadata: " + docId);
}
}
return queryResults;
}
}
}
private Term MkNormalizedVar(TermIndex index, int i)
{
bool wasAdded;
return(index.MkVar("~pv~" + i.ToString(), true, out wasAdded));
}
internal TypeEnvironment(Node node, TermIndex index)
{
Contract.Requires(node != null && index != null);
Node = node;
Index = index;
}
public SubtermMatcher(TermIndex index, bool onlyNewKinds, Term[] pattern)
{
Contract.Requires(pattern != null && pattern.Length > 0);
//// Appears that Requires is triggering bug in Code Contracts 1.9.10714.2
Contract.Assert(index != null);
this.pattern = pattern;
IsMatchOnlyNewKinds = onlyNewKinds;
matchingUnions = new AppFreeCanUnn[pattern.Length];
bool wasAdded;
Term type, intr;
Term levelTypes = null;
IsSatisfiable = true;
IsTriggerable = false;
Stack <Term> pending = new Stack <Term>();
Set <Term> pendingOrVisited = new Set <Term>(Term.Compare);
for (int i = pattern.Length - 1; i >= 0; --i)
{
if (!IsSatisfiable)
{
return;
}
if (i == pattern.Length - 1)
{
intr = pattern[pattern.Length - 1];
}
else if (!index.MkIntersection(pattern[i], levelTypes, out intr))
{
IsSatisfiable = false;
return;
}
levelTypes = null;
IsSatisfiable = false;
pendingOrVisited.Clear();
foreach (var t in intr.Enumerate(x => x.Symbol == index.TypeUnionSymbol ? x.Args : null))
{
if (t.Symbol == index.TypeUnionSymbol)
{
continue;
}
else if (IsPermitted(index, onlyNewKinds, t))
{
IsSatisfiable = true;
GetMatchingSet(i, t).Add(CanMatch);
pending.Push(t);
pendingOrVisited.Add(t);
levelTypes = levelTypes == null ? t : index.MkApply(index.TypeUnionSymbol, new Term[] { t, levelTypes }, out wasAdded);
if (i == 0 && (t.Symbol.Kind == SymbolKind.UserSortSymb || t.Symbol.IsDerivedConstant))
{
IsTriggerable = true;
}
}
}
if (!IsSatisfiable)
{
return;
}
else
{
matchingUnions[i] = new AppFreeCanUnn(levelTypes);
}
while (pending.Count > 0)
{
type = pending.Pop();
foreach (var tup in index.GetTypeUses(type))
{
if (tup.Item1.Kind == SymbolKind.ConSymb)
{
type = index.MkApply(((ConSymb)tup.Item1).SortSymbol, TermIndex.EmptyArgs, out wasAdded);
}
else if (tup.Item1.Kind == SymbolKind.MapSymb)
{
type = index.MkApply(((MapSymb)tup.Item1).SortSymbol, TermIndex.EmptyArgs, out wasAdded);
}
else
{
throw new NotImplementedException();
}
if (IsPermitted(index, onlyNewKinds, type))
{
GetMatchingSet(i, type).Add(tup.Item2);
if (!pendingOrVisited.Contains(type))
{
pending.Push(type);
pendingOrVisited.Add(type);
levelTypes = levelTypes == null ? type : index.MkApply(index.TypeUnionSymbol, new Term[] { type, levelTypes }, out wasAdded);
if (i == 0 && (type.Symbol.Kind == SymbolKind.UserSortSymb || type.Symbol.IsDerivedConstant))
{
IsTriggerable = true;
}
}
}
}
}
}
if (IsTriggerable)
{
var level0 = matcher[0];
levelTypes = null;
foreach (var kv in level0)
{
if (kv.Key.Symbol.Kind == SymbolKind.UserSortSymb || kv.Key.Symbol.IsDerivedConstant)
{
levelTypes = levelTypes == null ? kv.Key : index.MkApply(index.TypeUnionSymbol, new Term[] { kv.Key, levelTypes }, out wasAdded);
}
}
Trigger = levelTypes;
}
}
public TfIdfRanker(TermIndex index, IndexMetadata indexMetadata)
{
this.index = index;
this.indexMetadata = indexMetadata;
this.scorer = new TfIdfScorer(index, indexMetadata);
}
private static Term Parse(string t, int start, TermIndex index, out int end)
{
Contract.Requires(!string.IsNullOrEmpty(t) && start < t.Length);
end = -1;
bool wasAdded, result;
var tstart = t[start];
while (char.IsWhiteSpace(tstart))
{
++start;
tstart = t[start];
}
if (tstart == '\"')
{
end = start;
do
{
end = t.IndexOf('\"', end + 1);
Contract.Assert(end >= 0);
}while (t[end - 1] == '\\');
if (end == start + 1)
{
return(index.MkCnst(string.Empty, out wasAdded));
}
else
{
return(index.MkCnst(t.Substring(start + 1, end - start - 1).Replace("\\\"", "\""), out wasAdded));
}
}
else if (char.IsDigit(tstart) || tstart == '+' || tstart == '-' || tstart == '.')
{
var end1 = t.IndexOf(',', start);
var end2 = t.IndexOf(')', start);
end = (end1 >= 0 && end2 >= 0) ? Math.Min(end1, end2) : Math.Max(end1, end2);
Rational r;
if (end < 0)
{
result = Rational.TryParseDecimal(t.Substring(start).Trim(), out r);
Contract.Assert(result);
end = t.Length - 1;
}
else
{
--end;
result = Rational.TryParseDecimal(t.Substring(start, end - start + 1).Trim(), out r);
Contract.Assert(result);
}
return(index.MkCnst(r, out wasAdded));
}
else
{
Contract.Assert(char.IsLetter(tstart) || tstart == '_');
UserSymbol us, other;
var end1 = t.IndexOf(',', start);
var end2 = t.IndexOf(')', start);
var end3 = t.IndexOf('(', start);
end = (end1 >= 0 && end2 >= 0) ? Math.Min(end1, end2) : Math.Max(end1, end2);
end = (end >= 0 && end3 >= 0) ? Math.Min(end, end3) : Math.Max(end, end3);
if (end < 0)
{
us = index.SymbolTable.Resolve(t.Substring(start).Trim(), out other);
Contract.Assert(us != null && other == null && us.Kind == SymbolKind.UserCnstSymb);
end = t.Length - 1;
return(index.MkApply(us, TermIndex.EmptyArgs, out wasAdded));
}
else if (end == end1 || end == end2)
{
--end;
us = index.SymbolTable.Resolve(t.Substring(start, end - start + 1).Trim(), out other);
Contract.Assert(us != null && other == null && us.Kind == SymbolKind.UserCnstSymb);
return(index.MkApply(us, TermIndex.EmptyArgs, out wasAdded));
}
else
{
us = index.SymbolTable.Resolve(t.Substring(start, end - start).Trim(), out other);
Contract.Assert(us != null && other == null && us.IsDataConstructor);
var args = new Term[us.Arity];
for (int i = 0; i < us.Arity; ++i)
{
++end;
args[i] = Parse(t, end, index, out end);
if (i < us.Arity - 1)
{
end = t.IndexOf(',', end + 1);
}
else
{
end = t.IndexOf(')', end + 1);
}
Contract.Assert(end >= 0);
}
return(index.MkApply(us, args, out wasAdded));
}
}
}
private IEnumerable <Tuple <RelKind, Term, Term> > EmptyConstrainer(TermIndex index, Term[] args)
{
yield break;
}
public void Start()
{
var mod = (ModuleData)((Location)step.Rhs.Module.CompilerData).AST.Node.CompilerData;
if (mod.Reduced.Node.NodeKind == NodeKind.Model)
{
var facts = ((FactSet)mod.FinalOutput).Facts;
var copy = new Set <Term>(Term.Compare);
var index = new TermIndex(mod.SymbolTable);
foreach (var f in facts)
{
copy.Add(index.MkClone(f));
}
resultMap.SetResult(step.Lhs.First().Name, new FactSet(index, copy));
}
else if (mod.Reduced.Node.NodeKind == NodeKind.Transform)
{
var transform = (Transform)mod.Reduced.Node;
var index = new TermIndex(mod.SymbolTable);
var copyRules = ((RuleTable)mod.FinalOutput).CloneTransformTable(index);
var valParams = tsystem.InstantiateValueParams(step, index, valueParams);
var modParams = tsystem.InstantiateModelParams(step, resultMap);
var exe = new Executer(copyRules, modParams, valParams, null, false, cancel);
exe.Execute();
Namespace outNS;
using (var lhsIt = step.Lhs.GetEnumerator())
{
using (var outIt = transform.Outputs.GetEnumerator())
{
while (lhsIt.MoveNext() && outIt.MoveNext())
{
index.SymbolTable.Root.TryGetChild(((ModRef)outIt.Current.Type).Rename, out outNS);
resultMap.SetResult(lhsIt.Current.Name, outNS, exe.Fixpoint.Keys);
}
}
}
}
else if (mod.Reduced.Node.NodeKind == NodeKind.TSystem)
{
var transform = (TSystem)mod.Reduced.Node;
var index = new TermIndex(mod.SymbolTable);
var valParams = tsystem.InstantiateValueParams(step, index, valueParams);
var modParams = tsystem.InstantiateModelParams(step, resultMap);
var task = ((CoreTSystem)mod.FinalOutput).Execute(modParams, valParams, cancel);
task.Wait();
var subResults = task.Result.resultMap;
using (var lhsIt = step.Lhs.GetEnumerator())
{
using (var outIt = transform.Outputs.GetEnumerator())
{
while (lhsIt.MoveNext() && outIt.MoveNext())
{
resultMap.SetResult(lhsIt.Current.Name, subResults[((ModRef)outIt.Current.Type).Rename]);
}
}
}
subResults.Dispose();
}
else
{
throw new NotImplementedException();
}
}
