/* Initialize temporary goal variables in the dictionary */
private void InitializeGoalTemporaryVariables(PrologCodeTerm goal)
{
/* Free all registers */
PrologRegisterTable.Instance.FreeAllRegisters();
int reg = 0;
if (goal is PrologCodePredicate)
{
PrologCodePredicate g = (PrologCodePredicate)goal;
if (g.Arity > 0)
{
foreach (PrologCodeTerm var in g.Arguments)
{
if (var is PrologCodeVariable)
{
PrologVariableDictionaryEntry entry = _dictionary.GetVariable(((PrologCodeVariable)var).Name);
if (entry != null)
{
if (entry.IsTemporary && entry.TemporaryIndex == -1)
{
_dictionary.AllocateTemporaryVariable(entry, reg);
}
}
reg++;
}
}
}
}
}
private void CompileClauseHead(PrologCodeTerm head, ArrayList instructions)
{
if (head is PrologCodePredicate)
{
PrologCodePredicate headPredicate = (PrologCodePredicate)head;
if (headPredicate.Arity == 0)
{
/* Do nothing */
}
else
{
CompileHeadArguments(((PrologCodePredicate)head).Arguments);
}
}
else if (head is PrologCodeNonEmptyList)
{
ArrayList headListArguments = new ArrayList();
PrologCodeNonEmptyList NEList = (PrologCodeNonEmptyList)head;
headListArguments.Add(NEList.Head);
headListArguments.Add(NEList.Tail);
CompileHeadArguments(headListArguments);
}
else if (head is PrologCodeVariable)
{
throw new PrologCompilerException("Clause head cannot be a variable.");
}
else if (head is PrologCodeIntegerAtom || head is PrologCodeFloatAtom)
{
throw new PrologCompilerException("Clause head cannot be a number.");
}
}
public PrologCodeUnit Parse(TextReader input)
{
_scanner = new PrologScanner(input);
_errors.Clear();
PrologCodeTerm term = null;
while (true)
{
term = ReadTerm(1200);
if (_scanner.Next().Kind != PrologToken.DOT)
{
_errors.Add(new PrologCompilerError("P0001", "Unexpected end of term", "", false, _scanner.Current.Line, _scanner.Current.Column));
break;
}
if (term is PrologCodeHeadlessClause)
{
ProcessHeadlessClause(term);
}
else
{
_codeUnit.Terms.Add(term);
}
if (_scanner.Lookahead.Kind == PrologToken.EOF)
{
break;
}
}
return(_codeUnit);
}
private bool ResolveConflicts(PrologCodeTerm term, int index)
{
PrologVariableDictionaryEntry entry = _dictionary.GetVariable(index);
if (_dictionary.CurrentGoalIndex != 1 || entry == null || entry.LastGoalArgument < index)
{
PrologRegisterTable.Instance.AllocateRegister(index);
return(false);
}
if (term is PrologCodePredicate)
{
PrologCodePredicate predicate = (PrologCodePredicate)term;
for (int i = index + 1; i < entry.LastGoalArgument; i++)
{
if (predicate.Name == entry.Name &&
(_dictionary.GetVariable(i) == null || ResolveConflicts(term, i)))
{
entry.TemporaryIndex = i;
_generator.Emit(OpCodes.Put_Value, X(index), X(i));
return(true);
}
}
// I WAS HERE
}
//return true; THIS WAS THERE
entry.TemporaryIndex = PrologRegisterTable.Instance.FindRegister();
_generator.Emit(OpCodes.Put_Value, X(index), X(entry.TemporaryIndex));
return(true);
}
private void AddGoalStructArgumentVariables(PrologCodeTerm term)
{
if (PrologCodeTerm.IsAtom(term))
{
return;
}
else if (PrologCodeTerm.IsVariable(term))
{
this.Add(((PrologCodeVariable)term).Name, null);
}
else if (PrologCodeTerm.IsList(term))
{
if (term is PrologCodeNonEmptyList)
{
PrologCodeNonEmptyList list = (PrologCodeNonEmptyList)term;
AddGoalStructArgumentVariables(list.Head);
if (list.Tail is PrologCodeNonEmptyList)
{
AddGoalStructArgumentVariables(list.Tail);
}
else
{
AddGoalStructArgumentVariables(list.Tail);
}
}
}
else if (PrologCodeTerm.IsStruct(term))
{
PrologCodePredicate structure = (PrologCodePredicate)term;
foreach (PrologCodeTerm argument in structure.Arguments)
{
AddGoalStructArgumentVariables(argument);
}
}
}
private void CompileGoal(PrologCodeTerm goal, ArrayList instructions)
{
if (goal is PrologCodePredicate && ((PrologCodePredicate)goal).Arity == 0)
{
PrologCodePredicate goalPredicate = (PrologCodePredicate)goal;
if (goalPredicate.Arity == 0)
{
if (goalPredicate.Name == "!")
{
_generator.Emit(OpCodes.Cut);
if (_dictionary.InLastGoal)
{
_generator.Emit(OpCodes.Deallocate);
_generator.EndProcedure();
}
return;
}
if (goalPredicate.Name == "fail")
{
_generator.Emit(OpCodes.Fail);
_generator.EndProcedure();
return;
}
// TODO: handle methods here...
CompileCall(goalPredicate);
}
}
else if (goal is PrologCodeVariable)
{
CompileGoalVariable((PrologCodeVariable)goal, 0);
if (_dictionary.InLastGoal)
{
if (_dictionary.CurrentGoalIndex > 1)
{
_generator.Emit(OpCodes.Deallocate);
}
_generator.EmitExecuteVar(((PrologCodeVariable)goal).Name, 0);
}
else
{
_generator.EmitCallVar(((PrologCodeVariable)goal).Name, 0);
}
}
else if (goal is PrologCodeNonEmptyList)
{
// TODO: compile list arguments, then call ./2
}
else if (goal is PrologCodeIntegerAtom || goal is PrologCodeFloatAtom)
{
throw new PrologCompilerException("Clause goal cannot be a number.");
}
else if (goal is PrologCodePredicate)
{
CompileGoalArguments(((PrologCodePredicate)goal).Arguments);
CompileCall(goal);
}
}
public void TailTest()
{
PrologCodeAtom head = new PrologCodeAtom();
PrologCodeNonEmptyList tail = new PrologCodeNonEmptyList(head);
PrologCodeNonEmptyList prologCodeNonEmptyList = new PrologCodeNonEmptyList(head, tail);
PrologCodeTerm result = prologCodeNonEmptyList.Tail;
Assert.AreEqual(tail, result);
}
private string GetAtomOrStringValue(PrologCodeTerm term)
{
if (term is PrologCodeConstantAtom)
{
return(((PrologCodeConstantAtom)term).Value);
}
else if (term is PrologCodeStringAtom)
{
return(((PrologCodeStringAtom)term).Value.Replace("'", ""));
}
return(null);
}
private void ProcessHeadlessClause(PrologCodeTerm term)
{
PrologCodeHeadlessClause clause = (PrologCodeHeadlessClause)term;
foreach (PrologCodeTerm t in clause.Goals)
{
if (t is PrologCodePredicate)
{
PrologCodePredicate pred = (PrologCodePredicate)t;
switch (pred.Name)
{
case "op":
ProcessOperator(pred);
break;
case "class":
PrologCodeTerm arg = (PrologCodeTerm)pred.Arguments[0];
if (arg is PrologCodeConstantAtom)
{
PrologCodeConstantAtom atom = (PrologCodeConstantAtom)arg;
_codeUnit.Class = atom.Value;
}
else if (arg is PrologCodeStringAtom)
{
PrologCodeStringAtom atom = (PrologCodeStringAtom)arg;
_codeUnit.Class = atom.Value.Replace("'", "");
}
else
{
_errors.Add(new PrologCompilerError("P0002", "Illegal class name.", "", false, _scanner.Current.Line, _scanner.Current.Column));
}
break;
case "foreign":
ProcessForeignMethod(pred);
break;
case "load_assembly":
ProcessAssemblyDirective(pred);
break;
case "using":
ProcessUsingDirective(pred);
break;
}
}
else if (t is PrologCodeList)
{
}
}
}
private void AddGoalVariables(PrologCodeTerm term)
{
// no variables to add: predicate/0
if (PrologCodeTerm.IsAtom(term) || PrologCodeTerm.IsAtomicPredicate(term))
{
return;
}
// goal is a variable X
else if (PrologCodeTerm.IsVariable(term))
{
_currentArgumentIndex = 0;
this.Add(((PrologCodeVariable)term).Name, null);
return;
}
// goal is a list, [Term|Term]
else if (PrologCodeTerm.IsList(term))
{
_currentArgumentIndex = 0;
if (term is PrologCodeNonEmptyList)
{
PrologCodeNonEmptyList list = (PrologCodeNonEmptyList)term;
AddGoalArgumentVariables(list.Head);
_currentArgumentIndex = 1;
if (list.Tail != null)
{
if (list.Tail is PrologCodeNonEmptyList)
{
AddGoalArgumentVariables(list.Tail);
}
else
{
AddGoalArgumentVariables(list.Tail);
}
}
}
}
// Goal is a predicate, term(term,...)
else if (PrologCodeTerm.IsStruct(term))
{
_currentArgumentIndex = 0;
PrologCodePredicate goal = (PrologCodePredicate)term;
foreach (PrologCodeTerm argument in goal.Arguments)
{
AddGoalArgumentVariables(argument);
_currentArgumentIndex++;
}
}
}
private ArrayList GetListOperators(PrologCodeNonEmptyList list)
{
ArrayList listMembers = new ArrayList();
for (PrologCodeTerm l = list.Head; !(l is PrologCodeEmptyList); l = list.Tail)
{
if (l is PrologCodeAtom)
{
listMembers.Add(l);
}
else
{
_errors.Add(new PrologCompilerError("P0011", "Invalid operator definition.", "", false, _scanner.Current.Line, _scanner.Current.Column));
}
}
return(listMembers);
}
private void CompileGoalArguments(ArrayList arguments)
{
for (int i = 0; i < arguments.Count; i++)
{
PrologCodeTerm term = (PrologCodeTerm)arguments[i];
// TODO: check it's a nil atom then handle put conflicts
if (term is PrologCodeEmptyList)
{
ResolveConflicts(term, i);
_generator.Emit(OpCodes.Put_Constant, "[]", X(i));
}
else if (term is PrologCodeAtom)
{
// Handle put conflicts here...
ResolveConflicts(term, i);
if (term is PrologCodeConstantAtom)
{
_generator.Emit(OpCodes.Put_Constant, ((PrologCodeConstantAtom)term).Value, X(i));
}
else if (term is PrologCodeStringAtom)
{
_generator.Emit(OpCodes.Put_Constant, ((PrologCodeStringAtom)term).Value, X(i));
}
else if (term is PrologCodeIntegerAtom)
{
_generator.Emit(OpCodes.Put_Constant, ((PrologCodeIntegerAtom)term).Value.ToString(), X(i));
}
else if (term is PrologCodeFloatAtom)
{
_generator.Emit(OpCodes.Put_Constant, ((PrologCodeFloatAtom)term).Value.ToString(), X(i));
}
}
else if (term is PrologCodeVariable)
{
CompileGoalVariable((PrologCodeVariable)term, i);
}
else if (term is PrologCodePredicate || term is PrologCodeNonEmptyList)
{
ResolveConflicts(term, i);
CompileGoalRecord(term, i);
}
}
}
private void CompileCall(PrologCodeTerm p)
{
AMPredicateSet builtins = AMPredicateSet.Instance;
PrologCodePredicate predicate = (PrologCodePredicate)p;
if (builtins.IsBuiltin(predicate.Name, predicate.Arity))
{
CompileBuiltinPredicateCall(predicate);
}
else if (predicate.IsMethod)
{
CompileMethod(predicate);
}
else
{
CompilePrologPredicateCall(predicate);
}
}
private void CompileMethod(PrologCodeTerm method)
{
PrologCodePredicate predicate = (PrologCodePredicate)method;
_generator.EmitFCall(predicate.MethodInfo.PredicateName,
predicate.MethodInfo.MethodName,
predicate.MethodInfo.AssemblyName,
predicate.MethodInfo.Class);
if (_dictionary.InLastGoal)
{
if (_dictionary.GoalCount > 2)
{
_generator.Emit(OpCodes.Deallocate);
}
// Emit 'proceed'
_generator.EndProcedure();
}
}
private void DefineNewOperator(int pri, string assoc, PrologCodeTerm op)
{
// Check operator name
string opValue = "";
if (op is PrologCodeConstantAtom)
{
opValue = ((PrologCodeConstantAtom)op).Value;
}
else if (op is PrologCodeStringAtom)
{
opValue = ((PrologCodeStringAtom)op).Value;
}
else
{
_errors.Add(new PrologCompilerError("P0011", "Invalid operator definition.", "", false, _scanner.Current.Line, _scanner.Current.Column));
return;
}
if (opValue == "," || opValue == "','")
{
_errors.Add(new PrologCompilerError("P0011", "Invalid operator definition.", "", false, _scanner.Current.Line, _scanner.Current.Column));
return;
}
// Check operator priority
if (pri > 0 && pri < 1200)
{
UpdateOperatorTable(pri, assoc, opValue);
}
else if (pri == 0)
{
// Remove an operator
_operators.RemoveOperator(opValue);
}
else
{
// Error
}
}
private void GetFile(string filename, ref string expected, ref string result)
{
StreamReader sr = new StreamReader(filename);
PrologCodeParser parser = new PrologCodeParser();
parser.Scanner = new PrologScanner(sr);
PrologCodeTerm term = parser.ConvertBinaryTreeToCodeDOM(parser.Term(1200));
sr.Close();
StreamReader codefile = new StreamReader(filename);
string originalCode = codefile.ReadLine();
codefile.Close();
string exp = originalCode.Replace(" ", "").Replace(".", "");
string res = term.ToString().Replace(" ", "").Replace(".", "");
expected = exp;
result = res;
}
public Record()
{
Term = null;
TemporaryIndex = -1;
}
private void CompileHeadArguments(ArrayList arguments)
{
for (int i = 0; i < arguments.Count; i++)
{
_currArgN = i;
PrologCodeTerm arg = (PrologCodeTerm)arguments[i];
if (arg is PrologCodeNilAtom || arg is PrologCodeEmptyList)
{
_generator.Emit(OpCodes.Get_Constant, "[]", X(i));
}
else if (arg is PrologCodeAtom)
{
if (arg is PrologCodeConstantAtom)
{
_generator.Emit(OpCodes.Get_Constant, ((PrologCodeConstantAtom)arg).Value, X(i));
}
else if (arg is PrologCodeIntegerAtom)
{
_generator.Emit(OpCodes.Get_Constant, ((PrologCodeIntegerAtom)arg).Value.ToString(), X(i));
}
else if (arg is PrologCodeFloatAtom)
{
_generator.Emit(OpCodes.Get_Constant, ((PrologCodeFloatAtom)arg).Value.ToString(), X(i));
}
else if (arg is PrologCodeStringAtom)
{
_generator.Emit(OpCodes.Get_Constant, ((PrologCodeStringAtom)arg).Value, X(i));
}
}
else if (arg is PrologCodeVariable)
{
if (_dictionary.GoalCount == 0)
{
// warning: singleton variable
}
PrologVariableDictionaryEntry entry = _dictionary.GetVariable(((PrologCodeVariable)arg).Name);
if (entry.IsTemporary)
{
if (entry.IsReferenced && entry.TemporaryIndex != i)
{
_generator.Emit(OpCodes.Get_Value, X(entry.TemporaryIndex), X(i));
}
}
else
{
if (entry.IsReferenced)
{
_generator.Emit(OpCodes.Get_Value, Y(entry.PermanentIndex), X(i));
}
else
{
_generator.Emit(OpCodes.Get_Variable, Y(entry.PermanentIndex), X(i));
}
}
}
else if (arg is PrologCodeNonEmptyList)
{
_generator.Emit(OpCodes.Get_List, X(i));
ArrayList listArguments = new ArrayList();
PrologCodeNonEmptyList NEList = (PrologCodeNonEmptyList)arg;
listArguments.Add(NEList.Head);
listArguments.Add(NEList.Tail);
CompileStructArguments(listArguments);
}
else if (arg is PrologCodePredicate)
{
PrologCodePredicate structure = (PrologCodePredicate)arg;
_generator.Emit(OpCodes.Get_Structure, structure.Name + "/" + structure.Arity, X(i));
CompileStructArguments(structure.Arguments);
}
else
{
throw new PrologCompilerException("Unknown argument type (" + arg.GetType().ToString() + ") in head arguments");
}
}
}
public void GenerateCodeFromClause(PrologCodeClause clause, ArrayList instructions)
{
/* Do we need to allocate an environment? */
bool hasEnvironment = clause.Goals.Count > 1;
/* Initialize variable dictionary */
_dictionary = new PrologVariableDictionary();
/* Build the variable dictionary for this clause */
_dictionary.Build(clause);
/* Free all registers */
PrologRegisterTable registers = PrologRegisterTable.Instance;
registers.FreeAllRegisters();
/* Prepare head variables for code generation */
int reg = 0;
if (clause.Head.Arity > 0)
{
headArity = clause.Head.Arity;
foreach (PrologCodeTerm argument in clause.Head.Arguments)
{
if (argument is PrologCodeVariable)
{
PrologCodeVariable var = (PrologCodeVariable)argument;
PrologVariableDictionaryEntry entry = _dictionary.GetVariable(var.Name);
if (entry != null)
{
if (entry.IsTemporary && entry.TemporaryIndex == -1)
{
entry.IsReferenced = true;
_dictionary.AllocateTemporaryVariable(entry, reg);
}
}
//BUG: reg++;
}
reg++;
}
}
/* Prepare first goal variables */
int xreg = 0;
PrologCodeTerm fg = null;
if (clause.Goals.Count > 0)
{
fg = (PrologCodeTerm)clause.Goals[0];
}
if (fg is PrologCodePredicate)
{
PrologCodePredicate firstGoal = (PrologCodePredicate)fg;
if (firstGoal.Name == "!")
{
hasEnvironment = true;
}
if (firstGoal.Arity > 0)
{
foreach (PrologCodeTerm variable in firstGoal.Arguments)
{
if (variable is PrologCodeVariable)
{
PrologVariableDictionaryEntry entry = _dictionary.GetVariable(((PrologCodeVariable)variable).Name);
if (entry != null)
{
if (entry.IsTemporary && entry.TemporaryIndex == -1)
{
if (!registers.InUse(xreg))
{
_dictionary.AllocateTemporaryVariable(entry, xreg);
}
}
}
}
xreg++;
}
}
}
/* Reserve required registers */
for (int i = 0; i < Math.Max(reg, xreg); i++)
{
registers.AllocateRegister(i);
}
/* Emit predicate label */
_generator.DeclareProcedure(clause.Head.Name, clause.Head.Arity);
/* Allocate an environment if needed */
if (hasEnvironment)
{
_generator.Emit(OpCodes.Allocate);
}
/* Compile clause head */
CompileClauseHead(clause.Head, instructions);
/* Set current goal to 1 */
_dictionary.CurrentGoalIndex = 1;
if (clause.Goals.Count == 0)
{
_generator.EndProcedure();
/* Reset variable dictionary */
_dictionary.Reset();
instructions = _generator.Instructions;
return;
}
/* Compile first goal */
CompileGoal(fg, instructions);
_dictionary.CurrentGoalIndex++;
/* Compile the rest of the goals */
for (int goalIndex = 1; goalIndex < clause.Goals.Count; goalIndex++)
{
PrologCodeTerm goal = (PrologCodeTerm)clause.Goals[goalIndex];
InitializeGoalTemporaryVariables(goal);
/* reserve registers */
for (int i = 0; i < reg; i++)
{
registers.AllocateRegister(i);
}
/* Clear temporary index of permanent variables */
_dictionary.ClearTempIndexOfPermanentVariables();
/* Compile goal */
CompileGoal(goal, instructions);
/* Advance to next goal */
_dictionary.CurrentGoalIndex += 1;
}
/* Reset instruction set, code pointer, and variable
* dictionary.
*/
_dictionary.Reset();
}
private void CompileStructArguments(ArrayList arguments)
{
ArrayList records = new ArrayList();
// TODO: Why is it 20 here? was there a maximum number of records originally.
for (int i = 0; i < 20; i++)
{
records.Add(new Record());
}
int nRecs = 0;
for (int i = 0; i < arguments.Count; i++)
{
PrologCodeTerm term = (PrologCodeTerm)arguments[i];
if (term is PrologCodeNilAtom)
{
_generator.Emit(OpCodes.Unify_Constant, "[]");
}
else if (term is PrologCodeAtom)
{
if (term is PrologCodeConstantAtom)
{
_generator.Emit(OpCodes.Unify_Constant, ((PrologCodeConstantAtom)term).Value);
}
else if (term is PrologCodeIntegerAtom)
{
_generator.Emit(OpCodes.Unify_Constant, ((PrologCodeIntegerAtom)term).Value.ToString());
}
else if (term is PrologCodeFloatAtom)
{
_generator.Emit(OpCodes.Unify_Constant, ((PrologCodeFloatAtom)term).Value.ToString());
}
else if (term is PrologCodeStringAtom)
{
_generator.Emit(OpCodes.Unify_Constant, ((PrologCodeStringAtom)term).Value);
}
}
else if (term is PrologCodeVariable)
{
PrologVariableDictionaryEntry entry = _dictionary.GetVariable(((PrologCodeVariable)term).Name);
if (entry.IsReferenced)
{
if (entry.IsTemporary)
{
if (entry.IsGlobal)
{
_generator.Emit(OpCodes.Unify_Value, X(entry.TemporaryIndex));
}
else
{
// TODO: maybe this should be unify_variable
_generator.Emit(OpCodes.Unify_Local_Value, X(entry.TemporaryIndex));
entry.IsGlobal = true;
}
}
else
{
if (entry.IsGlobal)
{
_generator.Emit(OpCodes.Unify_Value, Y(entry.PermanentIndex));
}
else
{
_generator.Emit(OpCodes.Unify_Local_Value, Y(entry.PermanentIndex));
}
}
}
// not referenced
else
{
if (entry.IsTemporary)
{
if (entry.Occurrences == 1)
{
_generator.Emit(OpCodes.Unify_Void, "1");
}
else
{ // used to be i < entry.TemporaryIndex
if (_currArgN < entry.TemporaryIndex && entry.TemporaryIndex < headArity)
{
entry.TemporaryIndex = PrologRegisterTable.Instance.FindRegister();
}
_generator.Emit(OpCodes.Unify_Variable, X(entry.TemporaryIndex));
}
}
else
{
_generator.Emit(OpCodes.Unify_Variable, Y(entry.PermanentIndex));
}
entry.IsGlobal = true;
}
}
else if (term is PrologCodeEmptyList)
{
_generator.Emit(OpCodes.Unify_Constant, "[]");
}
else
{
((Record)records[nRecs]).Term = term;
((Record)records[nRecs]).TemporaryIndex = PrologRegisterTable.Instance.FindRegister();
_generator.Emit(OpCodes.Unify_Variable, X(((Record)records[nRecs]).TemporaryIndex));
nRecs++;
}
}
for (int i = 0; i < nRecs; i++)
{
Record r = (Record)records[i];
if (r.Term is PrologCodeNonEmptyList)
{
_generator.Emit(OpCodes.Get_List, X(r.TemporaryIndex));
PrologRegisterTable.Instance.FreeRegister(r.TemporaryIndex);
ArrayList listArguments = new ArrayList();
PrologCodeNonEmptyList NEList = (PrologCodeNonEmptyList)r.Term;
listArguments.Add(NEList.Head);
listArguments.Add(NEList.Tail);
CompileStructArguments(listArguments);
}
else if (r.Term is PrologCodePredicate)
{
PrologCodePredicate structure = (PrologCodePredicate)r.Term;
_generator.Emit(OpCodes.Get_Structure, structure.Name + "/" + structure.Arity, X(r.TemporaryIndex));
CompileStructArguments(structure.Arguments);
}
else
{
throw new PrologCompilerException("Unknown argument type (" + r.Term.GetType().ToString() + ") in structure arguments");
}
}
}
private int CompileGoalRecord(PrologCodeTerm term, int index)
{
ArrayList recs = new ArrayList();
int nRecs = 0;
ArrayList arguments = new ArrayList();
if (term is PrologCodeNonEmptyList)
{
PrologCodeNonEmptyList NEList = (PrologCodeNonEmptyList)term;
arguments.Add(NEList.Head);
arguments.Add(NEList.Tail);
}
else if (term is PrologCodePredicate)
{
arguments = ((PrologCodePredicate)term).Arguments;
}
for (int i = 0; i < arguments.Count; i++)
{
PrologCodeTerm r = (PrologCodeTerm)arguments[i];
if (r is PrologCodeNonEmptyList || r is PrologCodePredicate)
{
nRecs = recs.Add(CompileGoalRecord(r, -1));
}
}
if (index == -1)
{
index = PrologRegisterTable.Instance.FindRegister();
}
if (term is PrologCodeNonEmptyList)
{
_generator.Emit(OpCodes.Put_List, X(index));
}
else if (term is PrologCodePredicate)
{
PrologCodePredicate s = (PrologCodePredicate)term;
_generator.Emit(OpCodes.Put_Structure, s.Name + "/" + s.Arity, X(index));
}
nRecs = 0;
for (int i = 0; i < arguments.Count; i++)
{
PrologCodeTerm t = (PrologCodeTerm)arguments[i];
if (t is PrologCodeNilAtom || t is PrologCodeEmptyList)
{
_generator.Emit(OpCodes.Set_Constant, "[]");
}
else if (t is PrologCodeAtom)
{
if (t is PrologCodeConstantAtom)
{
_generator.Emit(OpCodes.Set_Constant, ((PrologCodeConstantAtom)t).Value);
}
else if (t is PrologCodeStringAtom)
{
_generator.Emit(OpCodes.Set_Constant, ((PrologCodeStringAtom)t).Value);
}
else if (t is PrologCodeIntegerAtom)
{
_generator.Emit(OpCodes.Set_Constant, ((PrologCodeIntegerAtom)t).Value.ToString());
}
else if (t is PrologCodeFloatAtom)
{
_generator.Emit(OpCodes.Set_Constant, ((PrologCodeFloatAtom)t).Value.ToString());
}
}
else if (t is PrologCodeVariable)
{
/* Compile Goal record variable */
CompileGoalRecordVariable((PrologCodeVariable)t);
}
else if (t is PrologCodePredicate || t is PrologCodeNonEmptyList)
{
_generator.Emit(OpCodes.Set_Value, X((int)recs[nRecs]));
PrologRegisterTable.Instance.FreeRegister((int)recs[nRecs]);
nRecs++;
}
}
return(index);
}
