diff options
Diffstat (limited to 'OpenSim')
16 files changed, 0 insertions, 15874 deletions
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs deleted file mode 100644 index 27ab04e..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Atom.cs +++ /dev/null | |||
@@ -1,218 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | using System.Text; | ||
34 | |||
35 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
36 | { | ||
37 | public class Atom : IUnifiable | ||
38 | { | ||
39 | private static Dictionary<string, Atom> _atomStore = new Dictionary<string, Atom>(); | ||
40 | public readonly string _name; | ||
41 | public readonly Atom _module; | ||
42 | |||
43 | /// <summary> | ||
44 | /// You should not call this constructor, but use Atom.a instead. | ||
45 | /// </summary> | ||
46 | /// <param name="name"></param> | ||
47 | /// <param name="module"></param> | ||
48 | private Atom(string name, Atom module) | ||
49 | { | ||
50 | _name = name; | ||
51 | _module = module; | ||
52 | } | ||
53 | |||
54 | /// <summary> | ||
55 | /// Return the unique Atom object for name where module is null. You should use this to create | ||
56 | /// an Atom instead of calling the Atom constructor. | ||
57 | /// </summary> | ||
58 | /// <param name="name"></param> | ||
59 | /// <returns></returns> | ||
60 | public static Atom a(string name) | ||
61 | { | ||
62 | Atom atom; | ||
63 | if (!_atomStore.TryGetValue(name, out atom)) | ||
64 | { | ||
65 | atom = new Atom(name, null); | ||
66 | _atomStore[name] = atom; | ||
67 | } | ||
68 | return atom; | ||
69 | } | ||
70 | |||
71 | /// <summary> | ||
72 | /// Return an Atom object with the name and module. If module is null or Atom.NIL, | ||
73 | /// this behaves like Atom.a(name) and returns the unique object where the module is null. | ||
74 | /// If module is not null or Atom.NIL, this may or may not be the same object as another Atom | ||
75 | /// with the same name and module. | ||
76 | /// </summary> | ||
77 | /// <param name="name"></param> | ||
78 | /// <param name="module"></param> | ||
79 | /// <returns></returns> | ||
80 | public static Atom a(string name, Atom module) | ||
81 | { | ||
82 | if (module == null || module == Atom.NIL) | ||
83 | return a(name); | ||
84 | return new Atom(name, module); | ||
85 | } | ||
86 | |||
87 | /// <summary> | ||
88 | /// If Obj is an Atom unify its _module with Module. If the Atom's _module is null, use Atom.NIL. | ||
89 | /// </summary> | ||
90 | /// <param name="Atom"></param> | ||
91 | /// <param name="Module"></param> | ||
92 | /// <returns></returns> | ||
93 | public static IEnumerable<bool> module(object Obj, object Module) | ||
94 | { | ||
95 | Obj = YP.getValue(Obj); | ||
96 | if (Obj is Atom) | ||
97 | { | ||
98 | if (((Atom)Obj)._module == null) | ||
99 | return YP.unify(Module, Atom.NIL); | ||
100 | else | ||
101 | return YP.unify(Module, ((Atom)Obj)._module); | ||
102 | } | ||
103 | return YP.fail(); | ||
104 | } | ||
105 | |||
106 | public static readonly Atom NIL = Atom.a("[]"); | ||
107 | public static readonly Atom DOT = Atom.a("."); | ||
108 | public static readonly Atom F = Atom.a("f"); | ||
109 | public static readonly Atom SLASH = Atom.a("/"); | ||
110 | public static readonly Atom HAT = Atom.a("^"); | ||
111 | public static readonly Atom RULE = Atom.a(":-"); | ||
112 | |||
113 | public IEnumerable<bool> unify(object arg) | ||
114 | { | ||
115 | arg = YP.getValue(arg); | ||
116 | if (arg is Atom) | ||
117 | return Equals(arg) ? YP.succeed() : YP.fail(); | ||
118 | else if (arg is Variable) | ||
119 | return ((Variable)arg).unify(this); | ||
120 | else | ||
121 | return YP.fail(); | ||
122 | } | ||
123 | |||
124 | public void addUniqueVariables(List<Variable> variableSet) | ||
125 | { | ||
126 | // Atom does not contain variables. | ||
127 | } | ||
128 | |||
129 | public object makeCopy(Variable.CopyStore copyStore) | ||
130 | { | ||
131 | // Atom does not contain variables that need to be copied. | ||
132 | return this; | ||
133 | } | ||
134 | |||
135 | public bool termEqual(object term) | ||
136 | { | ||
137 | return Equals(YP.getValue(term)); | ||
138 | } | ||
139 | |||
140 | public bool ground() | ||
141 | { | ||
142 | // Atom is always ground. | ||
143 | return true; | ||
144 | } | ||
145 | |||
146 | public override bool Equals(object obj) | ||
147 | { | ||
148 | if (obj is Atom) | ||
149 | { | ||
150 | if (_module == null && ((Atom)obj)._module == null) | ||
151 | // When _declaringClass is null, we always use an identical object from _atomStore. | ||
152 | return this == obj; | ||
153 | // Otherwise, ignore _declaringClass and do a normal string compare on the _name. | ||
154 | return _name == ((Atom)obj)._name; | ||
155 | } | ||
156 | return false; | ||
157 | } | ||
158 | |||
159 | public override string ToString() | ||
160 | { | ||
161 | return _name; | ||
162 | } | ||
163 | |||
164 | public override int GetHashCode() | ||
165 | { | ||
166 | // Debug: need to check _declaringClass. | ||
167 | return _name.GetHashCode(); | ||
168 | } | ||
169 | |||
170 | public string toQuotedString() | ||
171 | { | ||
172 | if (_name.Length == 0) | ||
173 | return "''"; | ||
174 | else if (this == Atom.NIL) | ||
175 | return "[]"; | ||
176 | |||
177 | StringBuilder result = new StringBuilder(_name.Length); | ||
178 | bool useQuotes = false; | ||
179 | foreach (char c in _name) | ||
180 | { | ||
181 | int cInt = (int)c; | ||
182 | if (c == '\'') | ||
183 | { | ||
184 | result.Append("''"); | ||
185 | useQuotes = true; | ||
186 | } | ||
187 | else if (c == '_' || cInt >= (int)'a' && cInt <= (int)'z' || | ||
188 | cInt >= (int)'A' && cInt <= (int)'Z' || cInt >= (int)'0' && cInt <= (int)'9') | ||
189 | result.Append(c); | ||
190 | else | ||
191 | { | ||
192 | // Debug: Need to handle non-printable chars. | ||
193 | result.Append(c); | ||
194 | useQuotes = true; | ||
195 | } | ||
196 | } | ||
197 | |||
198 | if (!useQuotes && (int)_name[0] >= (int)'a' && (int)_name[0] <= (int)'z') | ||
199 | return result.ToString(); | ||
200 | else | ||
201 | { | ||
202 | // Surround in single quotes. | ||
203 | result.Append('\''); | ||
204 | return "'" + result; | ||
205 | } | ||
206 | } | ||
207 | |||
208 | /// <summary> | ||
209 | /// Return true if _name is lexicographically less than atom._name. | ||
210 | /// </summary> | ||
211 | /// <param name="atom"></param> | ||
212 | /// <returns></returns> | ||
213 | public bool lessThan(Atom atom) | ||
214 | { | ||
215 | return _name.CompareTo(atom._name) < 0; | ||
216 | } | ||
217 | } | ||
218 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs deleted file mode 100644 index bbf1a5b..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/BagofAnswers.cs +++ /dev/null | |||
@@ -1,239 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections; | ||
33 | using System.Collections.Generic; | ||
34 | |||
35 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
36 | { | ||
37 | /// <summary> | ||
38 | /// A BagofAnswers holds answers for bagof and setof. | ||
39 | /// </summary> | ||
40 | public class BagofAnswers | ||
41 | { | ||
42 | private object _template; | ||
43 | private Variable[] _freeVariables; | ||
44 | private Dictionary<object[], List<object>> _bagForFreeVariables; | ||
45 | private List<object> _findallBagArray; | ||
46 | private static TermArrayEqualityComparer _termArrayEqualityComparer = | ||
47 | new TermArrayEqualityComparer(); | ||
48 | |||
49 | /// <summary> | ||
50 | /// To get the free variables, split off any existential qualifiers from Goal such as the X in | ||
51 | /// "X ^ f(Y)", get the set of unbound variables in Goal that are not qualifiers, then remove | ||
52 | /// the unbound variables that are qualifiers as well as the unbound variables in Template. | ||
53 | /// </summary> | ||
54 | /// <param name="Template"></param> | ||
55 | /// <param name="Goal"></param> | ||
56 | public BagofAnswers(object Template, object Goal) | ||
57 | { | ||
58 | _template = Template; | ||
59 | |||
60 | // First get the set of variables that are not free variables. | ||
61 | List<Variable> variableSet = new List<Variable>(); | ||
62 | YP.addUniqueVariables(Template, variableSet); | ||
63 | object UnqualifiedGoal = YP.getValue(Goal); | ||
64 | while (UnqualifiedGoal is Functor2 && ((Functor2)UnqualifiedGoal)._name == Atom.HAT) | ||
65 | { | ||
66 | YP.addUniqueVariables(((Functor2)UnqualifiedGoal)._arg1, variableSet); | ||
67 | UnqualifiedGoal = YP.getValue(((Functor2)UnqualifiedGoal)._arg2); | ||
68 | } | ||
69 | |||
70 | // Remember how many non-free variables there are so we can find the unique free variables | ||
71 | // that are added. | ||
72 | int nNonFreeVariables = variableSet.Count; | ||
73 | YP.addUniqueVariables(UnqualifiedGoal, variableSet); | ||
74 | int nFreeVariables = variableSet.Count - nNonFreeVariables; | ||
75 | if (nFreeVariables == 0) | ||
76 | { | ||
77 | // There were no free variables added, so we won't waste time with _bagForFreeVariables. | ||
78 | _freeVariables = null; | ||
79 | _findallBagArray = new List<object>(); | ||
80 | } | ||
81 | else | ||
82 | { | ||
83 | // Copy the free variables. | ||
84 | _freeVariables = new Variable[nFreeVariables]; | ||
85 | for (int i = 0; i < nFreeVariables; ++i) | ||
86 | _freeVariables[i] = variableSet[i + nNonFreeVariables]; | ||
87 | |||
88 | _bagForFreeVariables = new Dictionary<object[], List<object>>(_termArrayEqualityComparer); | ||
89 | } | ||
90 | } | ||
91 | |||
92 | public void add() | ||
93 | { | ||
94 | if (_freeVariables == null) | ||
95 | // The goal has bound the values in _template but we don't bother with _freeVariables. | ||
96 | _findallBagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); | ||
97 | else | ||
98 | { | ||
99 | // The goal has bound the values in _template and _freeVariables. | ||
100 | // Find the entry for this set of _freeVariables values. | ||
101 | object[] freeVariableValues = new object[_freeVariables.Length]; | ||
102 | for (int i = 0; i < _freeVariables.Length; ++i) | ||
103 | freeVariableValues[i] = YP.getValue(_freeVariables[i]); | ||
104 | List<object> bagArray; | ||
105 | if (!_bagForFreeVariables.TryGetValue(freeVariableValues, out bagArray)) | ||
106 | { | ||
107 | bagArray = new List<object>(); | ||
108 | _bagForFreeVariables[freeVariableValues] = bagArray; | ||
109 | } | ||
110 | |||
111 | // Now copy the template and add to the bag for the freeVariables values. | ||
112 | bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); | ||
113 | } | ||
114 | } | ||
115 | |||
116 | // disable warning on l1, don't see how we can | ||
117 | // code this differently | ||
118 | #pragma warning disable 0168, 0219 | ||
119 | |||
120 | /// <summary> | ||
121 | /// For each result, unify the _freeVariables and unify bagArrayVariable with the associated bag. | ||
122 | /// </summary> | ||
123 | /// <param name="bagArrayVariable">this is unified with the List<object> of matches for template that | ||
124 | /// corresponds to the bindings for freeVariables. Be very careful: this does not unify with a Prolog | ||
125 | /// list.</param> | ||
126 | /// <returns></returns> | ||
127 | public IEnumerable<bool> resultArray(Variable bagArrayVariable) | ||
128 | { | ||
129 | if (_freeVariables == null) | ||
130 | { | ||
131 | // No unbound free variables, so we only filled one bag. If empty, bagof fails. | ||
132 | if (_findallBagArray.Count > 0) | ||
133 | { | ||
134 | foreach (bool l1 in bagArrayVariable.unify(_findallBagArray)) | ||
135 | yield return false; | ||
136 | } | ||
137 | } | ||
138 | else | ||
139 | { | ||
140 | foreach (KeyValuePair<object[], List<object>> valuesAndBag in _bagForFreeVariables) | ||
141 | { | ||
142 | foreach (bool l1 in YP.unifyArrays(_freeVariables, valuesAndBag.Key)) | ||
143 | { | ||
144 | foreach (bool l2 in bagArrayVariable.unify(valuesAndBag.Value)) | ||
145 | yield return false; | ||
146 | } | ||
147 | // Debug: Should we free memory of the answers already returned? | ||
148 | } | ||
149 | } | ||
150 | } | ||
151 | |||
152 | /// <summary> | ||
153 | /// For each result, unify the _freeVariables and unify Bag with the associated bag. | ||
154 | /// </summary> | ||
155 | /// <param name="Bag"></param> | ||
156 | /// <returns></returns> | ||
157 | public IEnumerable<bool> result(object Bag) | ||
158 | { | ||
159 | Variable bagArrayVariable = new Variable(); | ||
160 | foreach (bool l1 in resultArray(bagArrayVariable)) | ||
161 | { | ||
162 | foreach (bool l2 in YP.unify(Bag, ListPair.make((List<object>)bagArrayVariable.getValue()))) | ||
163 | yield return false; | ||
164 | } | ||
165 | } | ||
166 | |||
167 | /// <summary> | ||
168 | /// For each result, unify the _freeVariables and unify Bag with the associated bag which is sorted | ||
169 | /// with duplicates removed, as in setof. | ||
170 | /// </summary> | ||
171 | /// <param name="Bag"></param> | ||
172 | /// <returns></returns> | ||
173 | public IEnumerable<bool> resultSet(object Bag) | ||
174 | { | ||
175 | Variable bagArrayVariable = new Variable(); | ||
176 | foreach (bool l1 in resultArray(bagArrayVariable)) | ||
177 | { | ||
178 | List<object> bagArray = (List<object>)bagArrayVariable.getValue(); | ||
179 | YP.sortArray(bagArray); | ||
180 | foreach (bool l2 in YP.unify(Bag, ListPair.makeWithoutRepeatedTerms(bagArray))) | ||
181 | yield return false; | ||
182 | } | ||
183 | } | ||
184 | |||
185 | public static IEnumerable<bool> bagofArray | ||
186 | (object Template, object Goal, IEnumerable<bool> goalIterator, Variable bagArrayVariable) | ||
187 | { | ||
188 | BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); | ||
189 | foreach (bool l1 in goalIterator) | ||
190 | bagOfAnswers.add(); | ||
191 | return bagOfAnswers.resultArray(bagArrayVariable); | ||
192 | } | ||
193 | |||
194 | public static IEnumerable<bool> bagof | ||
195 | (object Template, object Goal, IEnumerable<bool> goalIterator, object Bag) | ||
196 | { | ||
197 | BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); | ||
198 | foreach (bool l1 in goalIterator) | ||
199 | bagOfAnswers.add(); | ||
200 | return bagOfAnswers.result(Bag); | ||
201 | } | ||
202 | |||
203 | public static IEnumerable<bool> setof | ||
204 | (object Template, object Goal, IEnumerable<bool> goalIterator, object Bag) | ||
205 | { | ||
206 | BagofAnswers bagOfAnswers = new BagofAnswers(Template, Goal); | ||
207 | foreach (bool l1 in goalIterator) | ||
208 | bagOfAnswers.add(); | ||
209 | return bagOfAnswers.resultSet(Bag); | ||
210 | } | ||
211 | #pragma warning restore 0168, 0219 | ||
212 | |||
213 | /// <summary> | ||
214 | /// A TermArrayEqualityComparer implements IEqualityComparer to compare two object arrays using YP.termEqual. | ||
215 | /// </summary> | ||
216 | private class TermArrayEqualityComparer : IEqualityComparer<object[]> | ||
217 | { | ||
218 | public bool Equals(object[] array1, object[] array2) | ||
219 | { | ||
220 | if (array1.Length != array2.Length) | ||
221 | return false; | ||
222 | for (int i = 0; i < array1.Length; ++i) | ||
223 | { | ||
224 | if (!YP.termEqual(array1[i], array2[i])) | ||
225 | return false; | ||
226 | } | ||
227 | return true; | ||
228 | } | ||
229 | |||
230 | public int GetHashCode(object[] array) | ||
231 | { | ||
232 | int hashCode = 0; | ||
233 | for (int i = 0; i < array.Length; ++i) | ||
234 | hashCode ^= array[i].GetHashCode(); | ||
235 | return hashCode; | ||
236 | } | ||
237 | } | ||
238 | } | ||
239 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs deleted file mode 100644 index fb9569e..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/FindallAnswers.cs +++ /dev/null | |||
@@ -1,108 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections; | ||
33 | using System.Collections.Generic; | ||
34 | |||
35 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
36 | { | ||
37 | /// <summary> | ||
38 | /// A FindallAnswers holds answers for findall. | ||
39 | /// </summary> | ||
40 | public class FindallAnswers | ||
41 | { | ||
42 | private object _template; | ||
43 | private List<object> _bagArray; | ||
44 | |||
45 | public FindallAnswers(object Template) | ||
46 | { | ||
47 | _template = Template; | ||
48 | _bagArray = new List<object>(); | ||
49 | } | ||
50 | |||
51 | public void add() | ||
52 | { | ||
53 | _bagArray.Add(YP.makeCopy(_template, new Variable.CopyStore())); | ||
54 | } | ||
55 | |||
56 | public List<object> resultArray() | ||
57 | { | ||
58 | return _bagArray; | ||
59 | } | ||
60 | |||
61 | /// <summary> | ||
62 | /// Unify Bag with the result. This frees the internal answers, so you can only call this once. | ||
63 | /// </summary> | ||
64 | /// <param name="Bag"></param> | ||
65 | /// <returns></returns> | ||
66 | public IEnumerable<bool> result(object Bag) | ||
67 | { | ||
68 | object result = ListPair.make(_bagArray); | ||
69 | // Try to free the memory. | ||
70 | _bagArray = null; | ||
71 | return YP.unify(Bag, result); | ||
72 | } | ||
73 | |||
74 | // disable warning on l1, don't see how we can | ||
75 | // code this differently | ||
76 | #pragma warning disable 0168, 0219 | ||
77 | |||
78 | /// <summary> | ||
79 | /// This is a simplified findall when the goal is a single call. | ||
80 | /// </summary> | ||
81 | /// <param name="Template"></param> | ||
82 | /// <param name="goal"></param> | ||
83 | /// <param name="Bag"></param> | ||
84 | /// <returns></returns> | ||
85 | public static IEnumerable<bool> findall(object Template, IEnumerable<bool> goal, object Bag) | ||
86 | { | ||
87 | FindallAnswers findallAnswers = new FindallAnswers(Template); | ||
88 | foreach (bool l1 in goal) | ||
89 | findallAnswers.add(); | ||
90 | return findallAnswers.result(Bag); | ||
91 | } | ||
92 | |||
93 | /// <summary> | ||
94 | /// Like findall, except return an array of the results. | ||
95 | /// </summary> | ||
96 | /// <param name="template"></param> | ||
97 | /// <param name="goal"></param> | ||
98 | /// <returns></returns> | ||
99 | public static List<object> findallArray(object Template, IEnumerable<bool> goal) | ||
100 | { | ||
101 | FindallAnswers findallAnswers = new FindallAnswers(Template); | ||
102 | foreach (bool l1 in goal) | ||
103 | findallAnswers.add(); | ||
104 | return findallAnswers.resultArray(); | ||
105 | } | ||
106 | #pragma warning restore 0168, 0219 | ||
107 | } | ||
108 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs deleted file mode 100644 index 4d65f5b..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor.cs +++ /dev/null | |||
@@ -1,196 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | |||
34 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
35 | { | ||
36 | public class Functor : IUnifiable | ||
37 | { | ||
38 | public readonly Atom _name; | ||
39 | public readonly object[] _args; | ||
40 | |||
41 | public Functor(Atom name, object[] args) | ||
42 | { | ||
43 | if (args.Length <= 3) | ||
44 | { | ||
45 | if (args.Length == 0) | ||
46 | throw new Exception("For arity 0 functor, just use name as an Atom"); | ||
47 | else if (args.Length == 1) | ||
48 | throw new Exception("For arity 1 functor, use Functor1"); | ||
49 | else if (args.Length == 2) | ||
50 | throw new Exception("For arity 2 functor, use Functor2"); | ||
51 | else if (args.Length == 3) | ||
52 | throw new Exception("For arity 3 functor, use Functor3"); | ||
53 | else | ||
54 | // (This shouldn't happen, but include it for completeness. | ||
55 | throw new Exception("Cannot create a Functor of arity " + args.Length); | ||
56 | } | ||
57 | |||
58 | _name = name; | ||
59 | _args = args; | ||
60 | } | ||
61 | |||
62 | public Functor(string name, object[] args) | ||
63 | : this(Atom.a(name), args) | ||
64 | { | ||
65 | } | ||
66 | |||
67 | /// <summary> | ||
68 | /// Return an Atom, Functor1, Functor2, Functor3 or Functor depending on the | ||
69 | /// length of args. | ||
70 | /// Note that this is different than the Functor constructor which requires | ||
71 | /// the length of args to be greater than 3. | ||
72 | /// </summary> | ||
73 | /// <param name="name"></param> | ||
74 | /// <param name="args"></param> | ||
75 | /// <returns></returns> | ||
76 | public static object make(Atom name, object[] args) | ||
77 | { | ||
78 | if (args.Length <= 0) | ||
79 | return name; | ||
80 | else if (args.Length == 1) | ||
81 | return new Functor1(name, args[0]); | ||
82 | else if (args.Length == 2) | ||
83 | return new Functor2(name, args[0], args[1]); | ||
84 | else if (args.Length == 3) | ||
85 | return new Functor3(name, args[0], args[1], args[2]); | ||
86 | else | ||
87 | return new Functor(name, args); | ||
88 | } | ||
89 | |||
90 | /// <summary> | ||
91 | /// Call the main make, first converting name to an Atom. | ||
92 | /// </summary> | ||
93 | /// <param name="name"></param> | ||
94 | /// <param name="args"></param> | ||
95 | /// <returns></returns> | ||
96 | public static object make(string name, object[] args) | ||
97 | { | ||
98 | return make(Atom.a(name), args); | ||
99 | } | ||
100 | |||
101 | /// <summary> | ||
102 | /// If arg is another Functor, then succeed (yield once) if this and arg have the | ||
103 | /// same name and all functor args unify, otherwise fail (don't yield). | ||
104 | /// If arg is a Variable, then call its unify to unify with this. | ||
105 | /// Otherwise fail (don't yield). | ||
106 | /// </summary> | ||
107 | /// <param name="arg"></param> | ||
108 | /// <returns></returns> | ||
109 | public IEnumerable<bool> unify(object arg) | ||
110 | { | ||
111 | arg = YP.getValue(arg); | ||
112 | if (arg is Functor) | ||
113 | { | ||
114 | Functor argFunctor = (Functor)arg; | ||
115 | if (_name.Equals(argFunctor._name)) | ||
116 | return YP.unifyArrays(_args, argFunctor._args); | ||
117 | else | ||
118 | return YP.fail(); | ||
119 | } | ||
120 | else if (arg is Variable) | ||
121 | return ((Variable)arg).unify(this); | ||
122 | else | ||
123 | return YP.fail(); | ||
124 | } | ||
125 | |||
126 | public override string ToString() | ||
127 | { | ||
128 | string result = _name + "(" + YP.getValue(_args[0]); | ||
129 | for (int i = 1; i < _args.Length; ++i) | ||
130 | result += ", " + YP.getValue(_args[i]); | ||
131 | result += ")"; | ||
132 | return result; | ||
133 | } | ||
134 | |||
135 | public bool termEqual(object term) | ||
136 | { | ||
137 | term = YP.getValue(term); | ||
138 | if (term is Functor) | ||
139 | { | ||
140 | Functor termFunctor = (Functor)term; | ||
141 | if (_name.Equals(termFunctor._name) && _args.Length == termFunctor._args.Length) | ||
142 | { | ||
143 | for (int i = 0; i < _args.Length; ++i) | ||
144 | { | ||
145 | if (!YP.termEqual(_args[i], termFunctor._args[i])) | ||
146 | return false; | ||
147 | } | ||
148 | return true; | ||
149 | } | ||
150 | } | ||
151 | return false; | ||
152 | } | ||
153 | |||
154 | public bool lessThan(Functor functor) | ||
155 | { | ||
156 | // Do the equal check first since it is faster. | ||
157 | if (!_name.Equals(functor._name)) | ||
158 | return _name.lessThan(functor._name); | ||
159 | |||
160 | if (_args.Length != functor._args.Length) | ||
161 | return _args.Length < functor._args.Length; | ||
162 | |||
163 | for (int i = 0; i < _args.Length; ++i) | ||
164 | { | ||
165 | if (!YP.termEqual(_args[i], functor._args[i])) | ||
166 | return YP.termLessThan(_args[i], functor._args[i]); | ||
167 | } | ||
168 | |||
169 | return false; | ||
170 | } | ||
171 | |||
172 | public bool ground() | ||
173 | { | ||
174 | for (int i = 0; i < _args.Length; ++i) | ||
175 | { | ||
176 | if (!YP.ground(_args[i])) | ||
177 | return false; | ||
178 | } | ||
179 | return true; | ||
180 | } | ||
181 | |||
182 | public void addUniqueVariables(List<Variable> variableSet) | ||
183 | { | ||
184 | for (int i = 0; i < _args.Length; ++i) | ||
185 | YP.addUniqueVariables(_args[i], variableSet); | ||
186 | } | ||
187 | |||
188 | public object makeCopy(Variable.CopyStore copyStore) | ||
189 | { | ||
190 | object[] argsCopy = new object[_args.Length]; | ||
191 | for (int i = 0; i < _args.Length; ++i) | ||
192 | argsCopy[i] = YP.makeCopy(_args[i], copyStore); | ||
193 | return new Functor(_name, argsCopy); | ||
194 | } | ||
195 | } | ||
196 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs deleted file mode 100644 index 80d98b1..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor1.cs +++ /dev/null | |||
@@ -1,124 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | |||
34 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
35 | { | ||
36 | public class Functor1 : IUnifiable | ||
37 | { | ||
38 | public readonly Atom _name; | ||
39 | public readonly object _arg1; | ||
40 | |||
41 | public Functor1(Atom name, object arg1) | ||
42 | { | ||
43 | _name = name; | ||
44 | _arg1 = arg1; | ||
45 | } | ||
46 | |||
47 | public Functor1(string name, object arg1) | ||
48 | : this(Atom.a(name), arg1) | ||
49 | { | ||
50 | } | ||
51 | |||
52 | // disable warning on l1, don't see how we can | ||
53 | // code this differently | ||
54 | #pragma warning disable 0168, 0219 | ||
55 | /// <summary> | ||
56 | /// If arg is another Functor1, then succeed (yield once) if this and arg have the | ||
57 | /// same name and the functor args unify, otherwise fail (don't yield). | ||
58 | /// If arg is a Variable, then call its unify to unify with this. | ||
59 | /// Otherwise fail (don't yield). | ||
60 | /// </summary> | ||
61 | /// <param name="arg"></param> | ||
62 | /// <returns></returns> | ||
63 | public IEnumerable<bool> unify(object arg) | ||
64 | { | ||
65 | arg = YP.getValue(arg); | ||
66 | if (arg is Functor1) | ||
67 | { | ||
68 | Functor1 argFunctor = (Functor1)arg; | ||
69 | if (_name.Equals(argFunctor._name)) | ||
70 | { | ||
71 | foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) | ||
72 | yield return false; | ||
73 | } | ||
74 | } | ||
75 | else if (arg is Variable) | ||
76 | { | ||
77 | foreach (bool l1 in ((Variable)arg).unify(this)) | ||
78 | yield return false; | ||
79 | } | ||
80 | } | ||
81 | #pragma warning restore 0168, 0219 | ||
82 | |||
83 | |||
84 | public override string ToString() | ||
85 | { | ||
86 | return _name + "(" + YP.getValue(_arg1) + ")"; | ||
87 | } | ||
88 | |||
89 | public bool termEqual(object term) | ||
90 | { | ||
91 | term = YP.getValue(term); | ||
92 | if (term is Functor1) | ||
93 | { | ||
94 | Functor1 termFunctor = (Functor1)term; | ||
95 | return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1); | ||
96 | } | ||
97 | return false; | ||
98 | } | ||
99 | |||
100 | public bool lessThan(Functor1 functor) | ||
101 | { | ||
102 | // Do the equal check first since it is faster. | ||
103 | if (!_name.Equals(functor._name)) | ||
104 | return _name.lessThan(functor._name); | ||
105 | |||
106 | return YP.termLessThan(_arg1, functor._arg1); | ||
107 | } | ||
108 | |||
109 | public bool ground() | ||
110 | { | ||
111 | return YP.ground(_arg1); | ||
112 | } | ||
113 | |||
114 | public void addUniqueVariables(List<Variable> variableSet) | ||
115 | { | ||
116 | YP.addUniqueVariables(_arg1, variableSet); | ||
117 | } | ||
118 | |||
119 | public object makeCopy(Variable.CopyStore copyStore) | ||
120 | { | ||
121 | return new Functor1(_name, YP.makeCopy(_arg1, copyStore)); | ||
122 | } | ||
123 | } | ||
124 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs deleted file mode 100644 index 4c501d6..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor2.cs +++ /dev/null | |||
@@ -1,163 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | |||
34 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
35 | { | ||
36 | public class Functor2 : IUnifiable | ||
37 | { | ||
38 | public readonly Atom _name; | ||
39 | public readonly object _arg1; | ||
40 | public readonly object _arg2; | ||
41 | |||
42 | public Functor2(Atom name, object arg1, object arg2) | ||
43 | { | ||
44 | _name = name; | ||
45 | _arg1 = arg1; | ||
46 | _arg2 = arg2; | ||
47 | } | ||
48 | |||
49 | public Functor2(string name, object arg1, object arg2) | ||
50 | : this(Atom.a(name), arg1, arg2) | ||
51 | { | ||
52 | } | ||
53 | |||
54 | // disable warning on l1, don't see how we can | ||
55 | // code this differently | ||
56 | #pragma warning disable 0168, 0219 | ||
57 | /// If arg is another Functor2, then succeed (yield once) if this and arg have the | ||
58 | /// same name and all functor args unify, otherwise fail (don't yield). | ||
59 | /// If arg is a Variable, then call its unify to unify with this. | ||
60 | /// Otherwise fail (don't yield). | ||
61 | public IEnumerable<bool> unify(object arg) | ||
62 | { | ||
63 | arg = YP.getValue(arg); | ||
64 | if (arg is Functor2) | ||
65 | { | ||
66 | Functor2 argFunctor = (Functor2)arg; | ||
67 | if (_name.Equals(argFunctor._name)) | ||
68 | { | ||
69 | foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) | ||
70 | { | ||
71 | foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) | ||
72 | yield return false; | ||
73 | } | ||
74 | } | ||
75 | } | ||
76 | else if (arg is Variable) | ||
77 | { | ||
78 | foreach (bool l1 in ((Variable)arg).unify(this)) | ||
79 | yield return false; | ||
80 | } | ||
81 | } | ||
82 | #pragma warning restore 0168, 0219 | ||
83 | |||
84 | |||
85 | public override string ToString() | ||
86 | { | ||
87 | if (_name == Atom.DOT) | ||
88 | return listPairToString(this); | ||
89 | else | ||
90 | return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ")"; | ||
91 | } | ||
92 | |||
93 | public bool termEqual(object term) | ||
94 | { | ||
95 | term = YP.getValue(term); | ||
96 | if (term is Functor2) | ||
97 | { | ||
98 | Functor2 termFunctor = (Functor2)term; | ||
99 | return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) | ||
100 | && YP.termEqual(_arg2, termFunctor._arg2); | ||
101 | } | ||
102 | return false; | ||
103 | } | ||
104 | |||
105 | public bool lessThan(Functor2 functor) | ||
106 | { | ||
107 | // Do the equal check first since it is faster. | ||
108 | if (!_name.Equals(functor._name)) | ||
109 | return _name.lessThan(functor._name); | ||
110 | |||
111 | if (!YP.termEqual(_arg1, functor._arg1)) | ||
112 | return YP.termLessThan(_arg1, functor._arg1); | ||
113 | |||
114 | return YP.termLessThan(_arg2, functor._arg2); | ||
115 | } | ||
116 | |||
117 | public bool ground() | ||
118 | { | ||
119 | return YP.ground(_arg1) && YP.ground(_arg2); | ||
120 | } | ||
121 | |||
122 | public void addUniqueVariables(List<Variable> variableSet) | ||
123 | { | ||
124 | YP.addUniqueVariables(_arg1, variableSet); | ||
125 | YP.addUniqueVariables(_arg2, variableSet); | ||
126 | } | ||
127 | |||
128 | public object makeCopy(Variable.CopyStore copyStore) | ||
129 | { | ||
130 | return new Functor2(_name, YP.makeCopy(_arg1, copyStore), | ||
131 | YP.makeCopy(_arg2, copyStore)); | ||
132 | } | ||
133 | |||
134 | private static string listPairToString(Functor2 listPair) | ||
135 | { | ||
136 | string result = "["; | ||
137 | while (true) | ||
138 | { | ||
139 | object head = YP.getValue(listPair._arg1); | ||
140 | object tail = YP.getValue(listPair._arg2); | ||
141 | if (tail == (object)Atom.NIL) | ||
142 | { | ||
143 | result += head; | ||
144 | break; | ||
145 | } | ||
146 | else if (tail is Functor2 && ((Functor2)tail)._name == Atom.DOT) | ||
147 | { | ||
148 | result += head + ", "; | ||
149 | listPair = (Functor2)tail; | ||
150 | // Loop again. | ||
151 | } | ||
152 | else | ||
153 | { | ||
154 | // The list is not terminated with NIL. | ||
155 | result += head + "|" + tail; | ||
156 | break; | ||
157 | } | ||
158 | } | ||
159 | result += "]"; | ||
160 | return result; | ||
161 | } | ||
162 | } | ||
163 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs deleted file mode 100644 index 94e39c4..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Functor3.cs +++ /dev/null | |||
@@ -1,141 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | |||
34 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
35 | { | ||
36 | public class Functor3 : IUnifiable | ||
37 | { | ||
38 | public readonly Atom _name; | ||
39 | public readonly object _arg1; | ||
40 | public readonly object _arg2; | ||
41 | public readonly object _arg3; | ||
42 | |||
43 | public Functor3(Atom name, object arg1, object arg2, object arg3) | ||
44 | { | ||
45 | _name = name; | ||
46 | _arg1 = arg1; | ||
47 | _arg2 = arg2; | ||
48 | _arg3 = arg3; | ||
49 | } | ||
50 | |||
51 | public Functor3(string name, object arg1, object arg2, object arg3) | ||
52 | : this(Atom.a(name), arg1, arg2, arg3) | ||
53 | { | ||
54 | } | ||
55 | |||
56 | // disable warning on l1, don't see how we can | ||
57 | // code this differently | ||
58 | #pragma warning disable 0168, 0219 | ||
59 | /// If arg is another Functor3, then succeed (yield once) if this and arg have the | ||
60 | /// same name and all functor args unify, otherwise fail (don't yield). | ||
61 | /// If arg is a Variable, then call its unify to unify with this. | ||
62 | /// Otherwise fail (don't yield). | ||
63 | public IEnumerable<bool> unify(object arg) | ||
64 | { | ||
65 | arg = YP.getValue(arg); | ||
66 | if (arg is Functor3) | ||
67 | { | ||
68 | Functor3 argFunctor = (Functor3)arg; | ||
69 | if (_name.Equals(argFunctor._name)) | ||
70 | { | ||
71 | foreach (bool l1 in YP.unify(_arg1, argFunctor._arg1)) | ||
72 | { | ||
73 | foreach (bool l2 in YP.unify(_arg2, argFunctor._arg2)) | ||
74 | { | ||
75 | foreach (bool l3 in YP.unify(_arg3, argFunctor._arg3)) | ||
76 | yield return false; | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | } | ||
81 | else if (arg is Variable) | ||
82 | { | ||
83 | foreach (bool l1 in ((Variable)arg).unify(this)) | ||
84 | yield return false; | ||
85 | } | ||
86 | } | ||
87 | #pragma warning restore 0168, 0219 | ||
88 | |||
89 | public override string ToString() | ||
90 | { | ||
91 | return _name + "(" + YP.getValue(_arg1) + ", " + YP.getValue(_arg2) + ", " + | ||
92 | YP.getValue(_arg3) + ")"; | ||
93 | } | ||
94 | |||
95 | public bool termEqual(object term) | ||
96 | { | ||
97 | term = YP.getValue(term); | ||
98 | if (term is Functor3) | ||
99 | { | ||
100 | Functor3 termFunctor = (Functor3)term; | ||
101 | return _name.Equals(termFunctor._name) && YP.termEqual(_arg1, termFunctor._arg1) | ||
102 | && YP.termEqual(_arg2, termFunctor._arg2) | ||
103 | && YP.termEqual(_arg3, termFunctor._arg3); | ||
104 | } | ||
105 | return false; | ||
106 | } | ||
107 | |||
108 | public bool lessThan(Functor3 functor) | ||
109 | { | ||
110 | // Do the equal check first since it is faster. | ||
111 | if (!_name.Equals(functor._name)) | ||
112 | return _name.lessThan(functor._name); | ||
113 | |||
114 | if (!YP.termEqual(_arg1, functor._arg1)) | ||
115 | return YP.termLessThan(_arg1, functor._arg1); | ||
116 | |||
117 | if (!YP.termEqual(_arg2, functor._arg2)) | ||
118 | return YP.termLessThan(_arg2, functor._arg2); | ||
119 | |||
120 | return YP.termLessThan(_arg3, functor._arg3); | ||
121 | } | ||
122 | |||
123 | public bool ground() | ||
124 | { | ||
125 | return YP.ground(_arg1) && YP.ground(_arg2) && YP.ground(_arg3); | ||
126 | } | ||
127 | |||
128 | public void addUniqueVariables(List<Variable> variableSet) | ||
129 | { | ||
130 | YP.addUniqueVariables(_arg1, variableSet); | ||
131 | YP.addUniqueVariables(_arg2, variableSet); | ||
132 | YP.addUniqueVariables(_arg3, variableSet); | ||
133 | } | ||
134 | |||
135 | public object makeCopy(Variable.CopyStore copyStore) | ||
136 | { | ||
137 | return new Functor3(_name, YP.makeCopy(_arg1, copyStore), | ||
138 | YP.makeCopy(_arg2, copyStore), YP.makeCopy(_arg3, copyStore)); | ||
139 | } | ||
140 | } | ||
141 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs deleted file mode 100644 index 09a9a08..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/IndexedAnswers.cs +++ /dev/null | |||
@@ -1,385 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections; | ||
33 | using System.Collections.Generic; | ||
34 | |||
35 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
36 | { | ||
37 | /// <summary> | ||
38 | /// An IndexedAnswers holds answers to a query based on the values of index arguments. | ||
39 | /// </summary> | ||
40 | public class IndexedAnswers : YP.IClause | ||
41 | { | ||
42 | private int _arity; | ||
43 | // addAnswer adds the answer here and indexes it later. | ||
44 | private List<object[]> _allAnswers = new List<object[]>(); | ||
45 | // The key has the arity of answers with non-null values for each indexed arg. The value | ||
46 | // is a list of the matching answers. The signature is implicit in the pattern on non-null index args. | ||
47 | private Dictionary<HashedList, List<object[]>> _indexedAnswers = | ||
48 | new Dictionary<HashedList, List<object[]>>(); | ||
49 | // Keeps track of whether we have started adding entries to _indexedAnswers for the signature. | ||
50 | private Dictionary<int, object> _gotAnswersForSignature = new Dictionary<int, object>(); | ||
51 | private const int MAX_INDEX_ARGS = 31; | ||
52 | |||
53 | public IndexedAnswers(int arity) | ||
54 | { | ||
55 | _arity = arity; | ||
56 | } | ||
57 | |||
58 | /// <summary> | ||
59 | /// Append the answer to the list and update the indexes, if any. | ||
60 | /// Elements of answer must be ground, since arguments with unbound variables make this | ||
61 | /// into a dynamic rule which we don't index. | ||
62 | /// </summary> | ||
63 | /// <param name="answer"></param> | ||
64 | public void addAnswer(object[] answer) | ||
65 | { | ||
66 | addOrPrependAnswer(answer, false); | ||
67 | } | ||
68 | |||
69 | /// <summary> | ||
70 | /// Prepend the answer to the list and clear the indexes so that they must be re-computed | ||
71 | /// on the next call to match. (Only addAnswer will maintain the indexes while adding answers.) | ||
72 | /// Elements of answer must be ground, since arguments with unbound variables make this | ||
73 | /// into a dynamic rule which we don't index. | ||
74 | /// </summary> | ||
75 | /// <param name="answer"></param> | ||
76 | public void prependAnswer(object[] answer) | ||
77 | { | ||
78 | addOrPrependAnswer(answer, true); | ||
79 | } | ||
80 | |||
81 | /// <summary> | ||
82 | /// Do the work of addAnswer or prependAnswer. | ||
83 | /// </summary> | ||
84 | /// <param name="answer"></param> | ||
85 | private void addOrPrependAnswer(object[] answer, bool prepend) | ||
86 | { | ||
87 | if (answer.Length != _arity) | ||
88 | return; | ||
89 | |||
90 | // Store a copy of the answer array. | ||
91 | object[] answerCopy = new object[answer.Length]; | ||
92 | Variable.CopyStore copyStore = new Variable.CopyStore(); | ||
93 | for (int i = 0; i < answer.Length; ++i) | ||
94 | answerCopy[i] = YP.makeCopy(answer[i], copyStore); | ||
95 | if (copyStore.getNUniqueVariables() > 0) | ||
96 | throw new InvalidOperationException | ||
97 | ("Elements of answer must be ground, but found " + copyStore.getNUniqueVariables() + | ||
98 | " unbound variables"); | ||
99 | |||
100 | if (prepend) | ||
101 | { | ||
102 | _allAnswers.Insert(0, answerCopy); | ||
103 | clearIndexes(); | ||
104 | } | ||
105 | else | ||
106 | { | ||
107 | _allAnswers.Add(answerCopy); | ||
108 | // If match has already indexed answers for a signature, we need to add | ||
109 | // this to the existing indexed answers. | ||
110 | foreach (int signature in _gotAnswersForSignature.Keys) | ||
111 | indexAnswerForSignature(answerCopy, signature); | ||
112 | } | ||
113 | } | ||
114 | |||
115 | private void indexAnswerForSignature(object[] answer, int signature) | ||
116 | { | ||
117 | // First find out which of the answer values can be used as an index. | ||
118 | object[] indexValues = new object[answer.Length]; | ||
119 | for (int i = 0; i < answer.Length; ++i) | ||
120 | { | ||
121 | // We limit the number of indexed args in a 32-bit signature. | ||
122 | if (i >= MAX_INDEX_ARGS) | ||
123 | indexValues[i] = null; | ||
124 | else | ||
125 | indexValues[i] = getIndexValue(YP.getValue(answer[i])); | ||
126 | } | ||
127 | |||
128 | // We need an entry in indexArgs from indexValues for each 1 bit in signature. | ||
129 | HashedList indexArgs = new HashedList(indexValues.Length); | ||
130 | for (int i = 0; i < indexValues.Length; ++i) | ||
131 | { | ||
132 | if ((signature & (1 << i)) == 0) | ||
133 | indexArgs.Add(null); | ||
134 | else | ||
135 | { | ||
136 | if (indexValues[i] == null) | ||
137 | // The signature wants an index value here, but we don't have one so | ||
138 | // we can't add it as an answer for this signature. | ||
139 | return; | ||
140 | else | ||
141 | indexArgs.Add(indexValues[i]); | ||
142 | } | ||
143 | } | ||
144 | |||
145 | // Add the answer to the answers list for indexArgs, creating the entry if needed. | ||
146 | List<object[]> answers; | ||
147 | if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) | ||
148 | { | ||
149 | answers = new List<object[]>(); | ||
150 | _indexedAnswers[indexArgs] = answers; | ||
151 | } | ||
152 | answers.Add(answer); | ||
153 | } | ||
154 | |||
155 | public IEnumerable<bool> match(object[] arguments) | ||
156 | { | ||
157 | if (arguments.Length != _arity) | ||
158 | yield break; | ||
159 | |||
160 | // Set up indexArgs, up to arg position MAX_INDEX_ARGS. The signature has a 1 bit for | ||
161 | // each non-null index arg. | ||
162 | HashedList indexArgs = new HashedList(arguments.Length); | ||
163 | bool gotAllIndexArgs = true; | ||
164 | int signature = 0; | ||
165 | for (int i = 0; i < arguments.Length; ++i) | ||
166 | { | ||
167 | object indexValue = null; | ||
168 | if (i < MAX_INDEX_ARGS) | ||
169 | { | ||
170 | // We limit the number of args in a 32-bit signature. | ||
171 | indexValue = getIndexValue(YP.getValue(arguments[i])); | ||
172 | if (indexValue != null) | ||
173 | signature += (1 << i); | ||
174 | } | ||
175 | if (indexValue == null) | ||
176 | gotAllIndexArgs = false; | ||
177 | indexArgs.Add(indexValue); | ||
178 | } | ||
179 | |||
180 | List<object[]> answers; | ||
181 | if (signature == 0) | ||
182 | // No index args, so we have to match from _allAnswers. | ||
183 | answers = _allAnswers; | ||
184 | else | ||
185 | { | ||
186 | if (!_gotAnswersForSignature.ContainsKey(signature)) | ||
187 | { | ||
188 | // We need to create the entry in _indexedAnswers. | ||
189 | foreach (object[] answer in _allAnswers) | ||
190 | indexAnswerForSignature(answer, signature); | ||
191 | // Mark that we did this signature. | ||
192 | _gotAnswersForSignature[signature] = null; | ||
193 | } | ||
194 | if (!_indexedAnswers.TryGetValue(indexArgs, out answers)) | ||
195 | yield break; | ||
196 | } | ||
197 | |||
198 | if (gotAllIndexArgs) | ||
199 | { | ||
200 | // All the arguments were already bound, so we don't need to do bindings. | ||
201 | yield return false; | ||
202 | yield break; | ||
203 | } | ||
204 | |||
205 | // Find matches in answers. | ||
206 | IEnumerator<bool>[] iterators = new IEnumerator<bool>[arguments.Length]; | ||
207 | // Debug: If the caller asserts another answer into this same predicate during yield, the iterator | ||
208 | // over clauses will be corrupted. Should we take the time to copy answers? | ||
209 | foreach (object[] answer in answers) | ||
210 | { | ||
211 | bool gotMatch = true; | ||
212 | int nIterators = 0; | ||
213 | // Try to bind all the arguments. | ||
214 | for (int i = 0; i < arguments.Length; ++i) | ||
215 | { | ||
216 | if (indexArgs[i] != null) | ||
217 | // We already matched this argument by looking up _indexedAnswers. | ||
218 | continue; | ||
219 | |||
220 | IEnumerator<bool> iterator = YP.unify(arguments[i], answer[i]).GetEnumerator(); | ||
221 | iterators[nIterators++] = iterator; | ||
222 | // MoveNext() is true if YP.unify succeeds. | ||
223 | if (!iterator.MoveNext()) | ||
224 | { | ||
225 | gotMatch = false; | ||
226 | break; | ||
227 | } | ||
228 | } | ||
229 | int z = 0; | ||
230 | try | ||
231 | { | ||
232 | if (gotMatch) | ||
233 | yield return false; | ||
234 | } | ||
235 | finally | ||
236 | { | ||
237 | // Manually finalize all the iterators. | ||
238 | for (z = 0; z < nIterators; ++z) | ||
239 | iterators[z].Dispose(); | ||
240 | } | ||
241 | } | ||
242 | } | ||
243 | |||
244 | public IEnumerable<bool> clause(object Head, object Body) | ||
245 | { | ||
246 | Head = YP.getValue(Head); | ||
247 | if (Head is Variable) | ||
248 | throw new PrologException("instantiation_error", "Head is an unbound variable"); | ||
249 | object[] arguments = YP.getFunctorArgs(Head); | ||
250 | |||
251 | // We always match Head from _allAnswers, and the Body is Atom.a("true"). | ||
252 | #pragma warning disable 0168, 0219 | ||
253 | foreach (bool l1 in YP.unify(Body, Atom.a("true"))) | ||
254 | { | ||
255 | // The caller can assert another answer into this same predicate during yield, so we have to | ||
256 | // make a copy of the answers. | ||
257 | foreach (object[] answer in _allAnswers.ToArray()) | ||
258 | { | ||
259 | foreach (bool l2 in YP.unifyArrays(arguments, answer)) | ||
260 | yield return false; | ||
261 | } | ||
262 | } | ||
263 | #pragma warning restore 0168, 0219 | ||
264 | } | ||
265 | |||
266 | public IEnumerable<bool> retract(object Head, object Body) | ||
267 | { | ||
268 | Head = YP.getValue(Head); | ||
269 | if (Head is Variable) | ||
270 | throw new PrologException("instantiation_error", "Head is an unbound variable"); | ||
271 | object[] arguments = YP.getFunctorArgs(Head); | ||
272 | |||
273 | // We always match Head from _allAnswers, and the Body is Atom.a("true"). | ||
274 | #pragma warning disable 0168, 0219 | ||
275 | foreach (bool l1 in YP.unify(Body, Atom.a("true"))) | ||
276 | { | ||
277 | // The caller can assert another answer into this same predicate during yield, so we have to | ||
278 | // make a copy of the answers. | ||
279 | foreach (object[] answer in _allAnswers.ToArray()) | ||
280 | { | ||
281 | foreach (bool l2 in YP.unifyArrays(arguments, answer)) | ||
282 | { | ||
283 | _allAnswers.Remove(answer); | ||
284 | clearIndexes(); | ||
285 | yield return false; | ||
286 | } | ||
287 | } | ||
288 | } | ||
289 | #pragma warning restore 0168, 0219 | ||
290 | } | ||
291 | |||
292 | /// <summary> | ||
293 | /// After retracting or prepending an answer in _allAnswers, the indexes are invalid, so clear them. | ||
294 | /// </summary> | ||
295 | private void clearIndexes() | ||
296 | { | ||
297 | _indexedAnswers.Clear(); | ||
298 | _gotAnswersForSignature.Clear(); | ||
299 | } | ||
300 | |||
301 | /// <summary> | ||
302 | /// A HashedList extends an ArrayList with methods to get a hash and to check equality | ||
303 | /// based on the elements of the list. | ||
304 | /// </summary> | ||
305 | public class HashedList : ArrayList | ||
306 | { | ||
307 | private bool _gotHashCode = false; | ||
308 | private int _hashCode; | ||
309 | |||
310 | public HashedList() | ||
311 | : base() | ||
312 | { | ||
313 | } | ||
314 | |||
315 | public HashedList(int capacity) | ||
316 | : base(capacity) | ||
317 | { | ||
318 | } | ||
319 | |||
320 | public HashedList(ICollection c) | ||
321 | : base(c) | ||
322 | { | ||
323 | } | ||
324 | |||
325 | // Debug: Should override all the other methods that change this. | ||
326 | public override int Add(object value) | ||
327 | { | ||
328 | _gotHashCode = false; | ||
329 | return base.Add(value); | ||
330 | } | ||
331 | |||
332 | public override int GetHashCode() | ||
333 | { | ||
334 | if (!_gotHashCode) | ||
335 | { | ||
336 | int hashCode = 1; | ||
337 | foreach (object obj in this) | ||
338 | hashCode = 31 * hashCode + (obj == null ? 0 : obj.GetHashCode()); | ||
339 | _hashCode = hashCode; | ||
340 | _gotHashCode = true; | ||
341 | } | ||
342 | return _hashCode; | ||
343 | } | ||
344 | |||
345 | public override bool Equals(object obj) | ||
346 | { | ||
347 | if (!(obj is ArrayList)) | ||
348 | return false; | ||
349 | |||
350 | ArrayList objList = (ArrayList)obj; | ||
351 | if (objList.Count != Count) | ||
352 | return false; | ||
353 | |||
354 | for (int i = 0; i < Count; ++i) | ||
355 | { | ||
356 | object value = objList[i]; | ||
357 | if (value == null) | ||
358 | { | ||
359 | if (this[i] != null) | ||
360 | return false; | ||
361 | } | ||
362 | else | ||
363 | { | ||
364 | if (!value.Equals(this[i])) | ||
365 | return false; | ||
366 | } | ||
367 | } | ||
368 | return true; | ||
369 | } | ||
370 | } | ||
371 | |||
372 | /// <summary> | ||
373 | /// If we keep an index on value, return the value, or null if we don't index it. | ||
374 | /// </summary> | ||
375 | /// <param name="value">the term to examine. Assume you already called YP.getValue(value)</param> | ||
376 | /// <returns></returns> | ||
377 | public static object getIndexValue(object value) | ||
378 | { | ||
379 | if (value is Atom || value is string || value is Int32 || value is DateTime) | ||
380 | return value; | ||
381 | else | ||
382 | return null; | ||
383 | } | ||
384 | } | ||
385 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs deleted file mode 100644 index daac0ba..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/ListPair.cs +++ /dev/null | |||
@@ -1,166 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | |||
34 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
35 | { | ||
36 | public class ListPair : Functor2 | ||
37 | { | ||
38 | public ListPair(object head, object tail) : base(Atom.DOT, head, tail) | ||
39 | { | ||
40 | } | ||
41 | |||
42 | public static object make(List<object> list) | ||
43 | { | ||
44 | if (list.Count <= 0) | ||
45 | return Atom.NIL; | ||
46 | |||
47 | object result = Atom.NIL; | ||
48 | // Start from the end. | ||
49 | for (int i = list.Count - 1; i >= 0; --i) | ||
50 | result = new ListPair(list[i], result); | ||
51 | return result; | ||
52 | } | ||
53 | |||
54 | public static object make(object[] array) | ||
55 | { | ||
56 | if (array.Length <= 0) | ||
57 | return Atom.NIL; | ||
58 | |||
59 | object result = Atom.NIL; | ||
60 | // Start from the end. | ||
61 | for (int i = array.Length - 1; i >= 0; --i) | ||
62 | result = new ListPair(array[i], result); | ||
63 | return result; | ||
64 | } | ||
65 | |||
66 | /// <summary> | ||
67 | /// Return a ListPair version of array, where repeated elements | ||
68 | /// (according to YP.termEqual) are removed. | ||
69 | /// </summary> | ||
70 | /// <param name="array"></param> | ||
71 | /// <returns></returns> | ||
72 | public static object makeWithoutRepeatedTerms(object[] array) | ||
73 | { | ||
74 | if (array.Length <= 0) | ||
75 | return Atom.NIL; | ||
76 | |||
77 | // Start from the end. | ||
78 | object previousTerm = array[array.Length - 1]; | ||
79 | object result = new ListPair(previousTerm, Atom.NIL); | ||
80 | for (int i = array.Length - 2; i >= 0; --i) | ||
81 | { | ||
82 | object term = array[i]; | ||
83 | if (YP.termEqual(term, previousTerm)) | ||
84 | continue; | ||
85 | result = new ListPair(term, result); | ||
86 | previousTerm = term; | ||
87 | } | ||
88 | return result; | ||
89 | } | ||
90 | |||
91 | /// <summary> | ||
92 | /// Return a ListPair version of array, where repeated elements | ||
93 | /// (according to YP.termEqual) are removed. | ||
94 | /// </summary> | ||
95 | /// <param name="array"></param> | ||
96 | /// <returns></returns> | ||
97 | public static object makeWithoutRepeatedTerms(List<object> array) | ||
98 | { | ||
99 | if (array.Count <= 0) | ||
100 | return Atom.NIL; | ||
101 | |||
102 | // Start from the end. | ||
103 | object previousTerm = array[array.Count - 1]; | ||
104 | object result = new ListPair(previousTerm, Atom.NIL); | ||
105 | for (int i = array.Count - 2; i >= 0; --i) | ||
106 | { | ||
107 | object term = array[i]; | ||
108 | if (YP.termEqual(term, previousTerm)) | ||
109 | continue; | ||
110 | result = new ListPair(term, result); | ||
111 | previousTerm = term; | ||
112 | } | ||
113 | return result; | ||
114 | } | ||
115 | |||
116 | public static object make(object element1) | ||
117 | { | ||
118 | return new ListPair(element1, Atom.NIL); | ||
119 | } | ||
120 | |||
121 | public static object make(object element1, object element2) | ||
122 | { | ||
123 | return new ListPair(element1, new ListPair(element2, Atom.NIL)); | ||
124 | } | ||
125 | |||
126 | public static object make(object element1, object element2, object element3) | ||
127 | { | ||
128 | return new ListPair(element1, | ||
129 | new ListPair(element2, new ListPair(element3, Atom.NIL))); | ||
130 | } | ||
131 | |||
132 | /// <summary> | ||
133 | /// Return an array of the elements in list or null if it is not | ||
134 | /// a proper list. If list is Atom.NIL, return an array of zero elements. | ||
135 | /// If the list or one of the tails of the list is Variable, raise an instantiation_error. | ||
136 | /// This does not call YP.getValue on each element. | ||
137 | /// </summary> | ||
138 | /// <param name="list"></param> | ||
139 | /// <returns></returns> | ||
140 | public static object[] toArray(object list) | ||
141 | { | ||
142 | list = YP.getValue(list); | ||
143 | if (list.Equals(Atom.NIL)) | ||
144 | return new object[0]; | ||
145 | |||
146 | List<object> result = new List<object>(); | ||
147 | object element = list; | ||
148 | while (true) { | ||
149 | if (element == Atom.NIL) | ||
150 | break; | ||
151 | if (element is Variable) | ||
152 | throw new PrologException(Atom.a("instantiation_error"), | ||
153 | "List tail is an unbound variable"); | ||
154 | if (!(element is Functor2 && ((Functor2)element)._name == Atom.DOT)) | ||
155 | // Not a proper list. | ||
156 | return null; | ||
157 | result.Add(((Functor2)element)._arg1); | ||
158 | element = YP.getValue(((Functor2)element)._arg2); | ||
159 | } | ||
160 | |||
161 | if (result.Count <= 0) | ||
162 | return null; | ||
163 | return result.ToArray(); | ||
164 | } | ||
165 | } | ||
166 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs deleted file mode 100644 index 34010e7..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs +++ /dev/null | |||
@@ -1,4575 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections.Generic; | ||
33 | |||
34 | // disable warning on l1, don't see how we can | ||
35 | // code this differently | ||
36 | #pragma warning disable 0168, 0219, 0162 | ||
37 | |||
38 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
39 | { | ||
40 | public class Parser | ||
41 | { | ||
42 | public static IEnumerable<bool> read_term2(object Term, object Options) | ||
43 | { | ||
44 | Variable Answer = new Variable(); | ||
45 | Variable Variables = new Variable(); | ||
46 | foreach (bool l1 in read_termOptions(Options, Variables)) | ||
47 | { | ||
48 | foreach (bool l2 in portable_read3(Answer, Variables, new Variable())) | ||
49 | { | ||
50 | foreach (bool l3 in remove_pos(Answer, Term)) | ||
51 | yield return false; | ||
52 | } | ||
53 | } | ||
54 | } | ||
55 | |||
56 | public static IEnumerable<bool> read_term3(object Input, object Term, object Options) | ||
57 | { | ||
58 | Variable SaveInput = new Variable(); | ||
59 | Variable Answer = new Variable(); | ||
60 | Variable Variables = new Variable(); | ||
61 | foreach (bool l1 in read_termOptions(Options, Variables)) | ||
62 | { | ||
63 | foreach (bool l2 in YP.current_input(SaveInput)) | ||
64 | { | ||
65 | try | ||
66 | { | ||
67 | YP.see(Input); | ||
68 | foreach (bool l3 in portable_read3(Answer, Variables, new Variable())) | ||
69 | { | ||
70 | foreach (bool l4 in remove_pos(Answer, Term)) | ||
71 | yield return false; | ||
72 | } | ||
73 | } | ||
74 | finally | ||
75 | { | ||
76 | YP.see(SaveInput); | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | } | ||
81 | |||
82 | /// <summary> | ||
83 | /// For read_term, check if Options has variable_names(Variables). | ||
84 | /// Otherwise, ignore Options. | ||
85 | /// </summary> | ||
86 | /// <param name="Options"></param> | ||
87 | /// <param name="Variables"></param> | ||
88 | /// <returns></returns> | ||
89 | private static IEnumerable<bool> read_termOptions(object Options, object Variables) | ||
90 | { | ||
91 | Options = YP.getValue(Options); | ||
92 | if (Options is Variable) | ||
93 | throw new PrologException(Atom.a("instantiation_error"), "Options is an unbound variable"); | ||
94 | // First try to match Options = [variable_names(Variables)] | ||
95 | foreach (bool l1 in YP.unify(Options, ListPair.make(new Functor1("variable_names", Variables)))) | ||
96 | { | ||
97 | yield return false; | ||
98 | yield break; | ||
99 | } | ||
100 | // Default: Ignore Options. | ||
101 | yield return false; | ||
102 | } | ||
103 | |||
104 | public static IEnumerable<bool> read1(object Term) | ||
105 | { | ||
106 | return read_term2(Term, Atom.NIL); | ||
107 | } | ||
108 | |||
109 | public static IEnumerable<bool> read2(object Input, object Term) | ||
110 | { | ||
111 | return read_term3(Input, Term, Atom.NIL); | ||
112 | } | ||
113 | |||
114 | public static IEnumerable<bool> formatError(object Output, object Format, object Arguments) | ||
115 | { | ||
116 | // Debug: Simple implementation for now. | ||
117 | YP.write(Format); | ||
118 | YP.write(Arguments); | ||
119 | YP.nl(); | ||
120 | yield return false; | ||
121 | } | ||
122 | |||
123 | |||
124 | // Debug: Hand-modify this central predicate to do tail recursion. | ||
125 | public static IEnumerable<bool> read_tokens(object arg1, object arg2, object arg3) | ||
126 | { | ||
127 | bool repeat = true; | ||
128 | while (repeat) | ||
129 | { | ||
130 | repeat = false; | ||
131 | { | ||
132 | object C1 = arg1; | ||
133 | object Dict = arg2; | ||
134 | object Tokens = arg3; | ||
135 | Variable C2 = new Variable(); | ||
136 | if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) | ||
137 | { | ||
138 | if (YP.greaterThanOrEqual(C1, 0)) | ||
139 | { | ||
140 | foreach (bool l4 in YP.get_code(C2)) | ||
141 | { | ||
142 | #if false | ||
143 | foreach (bool l5 in read_tokens(C2, Dict, Tokens)) | ||
144 | { | ||
145 | yield return false; | ||
146 | } | ||
147 | #endif | ||
148 | arg1 = YP.getValue(C2); | ||
149 | arg2 = YP.getValue(Dict); | ||
150 | arg3 = YP.getValue(Tokens); | ||
151 | repeat = true; | ||
152 | } | ||
153 | } | ||
154 | goto cutIf1; | ||
155 | } | ||
156 | if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) | ||
157 | { | ||
158 | if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) | ||
159 | { | ||
160 | foreach (bool l4 in read_identifier(C1, Dict, Tokens)) | ||
161 | { | ||
162 | yield return false; | ||
163 | } | ||
164 | goto cutIf2; | ||
165 | } | ||
166 | } | ||
167 | if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) | ||
168 | { | ||
169 | if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) | ||
170 | { | ||
171 | foreach (bool l4 in read_variable(C1, Dict, Tokens)) | ||
172 | { | ||
173 | yield return false; | ||
174 | } | ||
175 | goto cutIf3; | ||
176 | } | ||
177 | } | ||
178 | if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) | ||
179 | { | ||
180 | if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) | ||
181 | { | ||
182 | foreach (bool l4 in read_number(C1, Dict, Tokens)) | ||
183 | { | ||
184 | yield return false; | ||
185 | } | ||
186 | goto cutIf4; | ||
187 | } | ||
188 | } | ||
189 | if (YP.lessThan(C1, 127)) | ||
190 | { | ||
191 | foreach (bool l3 in read_special(C1, Dict, Tokens)) | ||
192 | { | ||
193 | yield return false; | ||
194 | } | ||
195 | goto cutIf5; | ||
196 | } | ||
197 | if (YP.lessThanOrEqual(C1, 160)) | ||
198 | { | ||
199 | foreach (bool l3 in YP.get_code(C2)) | ||
200 | { | ||
201 | #if false | ||
202 | foreach (bool l4 in read_tokens(C2, Dict, Tokens)) | ||
203 | { | ||
204 | yield return false; | ||
205 | } | ||
206 | #endif | ||
207 | arg1 = YP.getValue(C2); | ||
208 | arg2 = YP.getValue(Dict); | ||
209 | arg3 = YP.getValue(Tokens); | ||
210 | repeat = true; | ||
211 | } | ||
212 | goto cutIf6; | ||
213 | } | ||
214 | if (YP.greaterThanOrEqual(C1, 223)) | ||
215 | { | ||
216 | if (YP.notEqual(C1, 247)) | ||
217 | { | ||
218 | foreach (bool l4 in read_identifier(C1, Dict, Tokens)) | ||
219 | { | ||
220 | yield return false; | ||
221 | } | ||
222 | goto cutIf7; | ||
223 | } | ||
224 | } | ||
225 | if (YP.greaterThanOrEqual(C1, 192)) | ||
226 | { | ||
227 | if (YP.notEqual(C1, 215)) | ||
228 | { | ||
229 | foreach (bool l4 in read_variable(C1, Dict, Tokens)) | ||
230 | { | ||
231 | yield return false; | ||
232 | } | ||
233 | goto cutIf8; | ||
234 | } | ||
235 | } | ||
236 | if (YP.notEqual(C1, 170)) | ||
237 | { | ||
238 | if (YP.notEqual(C1, 186)) | ||
239 | { | ||
240 | foreach (bool l4 in read_symbol(C1, Dict, Tokens)) | ||
241 | { | ||
242 | yield return false; | ||
243 | } | ||
244 | goto cutIf9; | ||
245 | } | ||
246 | } | ||
247 | foreach (bool l2 in read_identifier(C1, Dict, Tokens)) | ||
248 | { | ||
249 | yield return false; | ||
250 | } | ||
251 | cutIf9: | ||
252 | cutIf8: | ||
253 | cutIf7: | ||
254 | cutIf6: | ||
255 | cutIf5: | ||
256 | cutIf4: | ||
257 | cutIf3: | ||
258 | cutIf2: | ||
259 | cutIf1: | ||
260 | { } | ||
261 | } | ||
262 | } | ||
263 | } | ||
264 | |||
265 | // Compiler output follows. | ||
266 | |||
267 | class YPInnerClass { } | ||
268 | // static Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } | ||
269 | |||
270 | public static IEnumerable<bool> parseInput(object TermList) | ||
271 | { | ||
272 | { | ||
273 | Variable TermAndVariables = new Variable(); | ||
274 | FindallAnswers findallAnswers1 = new FindallAnswers(TermAndVariables); | ||
275 | foreach (bool l2 in parseInputHelper(TermAndVariables)) | ||
276 | { | ||
277 | findallAnswers1.add(); | ||
278 | } | ||
279 | foreach (bool l2 in findallAnswers1.result(TermList)) | ||
280 | { | ||
281 | yield return false; | ||
282 | } | ||
283 | } | ||
284 | } | ||
285 | |||
286 | public static IEnumerable<bool> parseInputHelper(object arg1) | ||
287 | { | ||
288 | { | ||
289 | Variable Term = new Variable(); | ||
290 | Variable Variables = new Variable(); | ||
291 | Variable Answer = new Variable(); | ||
292 | Variable x4 = new Variable(); | ||
293 | foreach (bool l2 in YP.unify(arg1, new Functor2("f", Term, Variables))) | ||
294 | { | ||
295 | foreach (bool l3 in YP.repeat()) | ||
296 | { | ||
297 | foreach (bool l4 in portable_read3(Answer, Variables, x4)) | ||
298 | { | ||
299 | foreach (bool l5 in remove_pos(Answer, Term)) | ||
300 | { | ||
301 | if (YP.termEqual(Term, Atom.a("end_of_file"))) | ||
302 | { | ||
303 | yield break; | ||
304 | goto cutIf1; | ||
305 | } | ||
306 | yield return false; | ||
307 | cutIf1: | ||
308 | { } | ||
309 | } | ||
310 | } | ||
311 | } | ||
312 | } | ||
313 | } | ||
314 | } | ||
315 | |||
316 | public static IEnumerable<bool> clear_errors() | ||
317 | { | ||
318 | { | ||
319 | yield return false; | ||
320 | } | ||
321 | } | ||
322 | |||
323 | public static IEnumerable<bool> remove_pos(object arg1, object arg2) | ||
324 | { | ||
325 | { | ||
326 | Variable X = new Variable(); | ||
327 | foreach (bool l2 in YP.unify(arg1, X)) | ||
328 | { | ||
329 | foreach (bool l3 in YP.unify(arg2, X)) | ||
330 | { | ||
331 | if (YP.var(X)) | ||
332 | { | ||
333 | yield return true; | ||
334 | yield break; | ||
335 | } | ||
336 | } | ||
337 | } | ||
338 | } | ||
339 | { | ||
340 | object X = arg2; | ||
341 | Variable _Pos = new Variable(); | ||
342 | Variable _Name = new Variable(); | ||
343 | foreach (bool l2 in YP.unify(arg1, new Functor3("$VAR", _Pos, _Name, X))) | ||
344 | { | ||
345 | if (YP.var(X)) | ||
346 | { | ||
347 | yield return true; | ||
348 | yield break; | ||
349 | } | ||
350 | } | ||
351 | } | ||
352 | { | ||
353 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
354 | { | ||
355 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
356 | { | ||
357 | yield return true; | ||
358 | yield break; | ||
359 | } | ||
360 | } | ||
361 | } | ||
362 | { | ||
363 | Variable H = new Variable(); | ||
364 | Variable T = new Variable(); | ||
365 | Variable NH = new Variable(); | ||
366 | Variable NT = new Variable(); | ||
367 | foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) | ||
368 | { | ||
369 | foreach (bool l3 in YP.unify(arg2, new ListPair(NH, NT))) | ||
370 | { | ||
371 | foreach (bool l4 in remove_pos(H, NH)) | ||
372 | { | ||
373 | foreach (bool l5 in remove_pos(T, NT)) | ||
374 | { | ||
375 | yield return false; | ||
376 | } | ||
377 | } | ||
378 | yield break; | ||
379 | } | ||
380 | } | ||
381 | } | ||
382 | { | ||
383 | Variable A = new Variable(); | ||
384 | Variable B = new Variable(); | ||
385 | Variable NA = new Variable(); | ||
386 | Variable NB = new Variable(); | ||
387 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", A, B))) | ||
388 | { | ||
389 | foreach (bool l3 in YP.unify(arg2, new Functor2(",", NA, NB))) | ||
390 | { | ||
391 | foreach (bool l4 in remove_pos(A, NA)) | ||
392 | { | ||
393 | foreach (bool l5 in remove_pos(B, NB)) | ||
394 | { | ||
395 | yield return false; | ||
396 | } | ||
397 | } | ||
398 | yield break; | ||
399 | } | ||
400 | } | ||
401 | } | ||
402 | { | ||
403 | Variable Atom_1 = new Variable(); | ||
404 | Variable _F = new Variable(); | ||
405 | foreach (bool l2 in YP.unify(arg1, Atom_1)) | ||
406 | { | ||
407 | foreach (bool l3 in YP.unify(arg2, Atom_1)) | ||
408 | { | ||
409 | foreach (bool l4 in YP.functor(Atom_1, _F, 0)) | ||
410 | { | ||
411 | yield return false; | ||
412 | } | ||
413 | } | ||
414 | } | ||
415 | } | ||
416 | { | ||
417 | object Term = arg1; | ||
418 | object NewTerm = arg2; | ||
419 | Variable Func = new Variable(); | ||
420 | Variable _Pos = new Variable(); | ||
421 | Variable Args = new Variable(); | ||
422 | Variable NArgs = new Variable(); | ||
423 | if (YP.nonvar(Term)) | ||
424 | { | ||
425 | foreach (bool l3 in YP.univ(Term, new ListPair(Func, new ListPair(_Pos, Args)))) | ||
426 | { | ||
427 | foreach (bool l4 in remove_pos(Args, NArgs)) | ||
428 | { | ||
429 | foreach (bool l5 in YP.univ(NewTerm, new ListPair(Func, NArgs))) | ||
430 | { | ||
431 | yield return false; | ||
432 | } | ||
433 | } | ||
434 | } | ||
435 | } | ||
436 | } | ||
437 | } | ||
438 | |||
439 | public static IEnumerable<bool> portable_read_position(object Term, object PosTerm, object Syntax) | ||
440 | { | ||
441 | { | ||
442 | foreach (bool l2 in portable_read(PosTerm, Syntax)) | ||
443 | { | ||
444 | foreach (bool l3 in remove_pos(PosTerm, Term)) | ||
445 | { | ||
446 | yield return false; | ||
447 | } | ||
448 | } | ||
449 | } | ||
450 | } | ||
451 | |||
452 | public static IEnumerable<bool> portable_read(object Answer, object Syntax) | ||
453 | { | ||
454 | { | ||
455 | Variable Tokens = new Variable(); | ||
456 | Variable ParseTokens = new Variable(); | ||
457 | foreach (bool l2 in read_tokens1(Tokens)) | ||
458 | { | ||
459 | foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) | ||
460 | { | ||
461 | foreach (bool l4 in parse2(ParseTokens, Answer)) | ||
462 | { | ||
463 | yield return false; | ||
464 | } | ||
465 | } | ||
466 | } | ||
467 | } | ||
468 | } | ||
469 | |||
470 | public static IEnumerable<bool> portable_read3(object Answer, object Variables, object Syntax) | ||
471 | { | ||
472 | { | ||
473 | Variable Tokens = new Variable(); | ||
474 | Variable ParseTokens = new Variable(); | ||
475 | foreach (bool l2 in read_tokens2(Tokens, Variables)) | ||
476 | { | ||
477 | foreach (bool l3 in remove_comments(Tokens, ParseTokens, Syntax)) | ||
478 | { | ||
479 | foreach (bool l4 in parse2(ParseTokens, Answer)) | ||
480 | { | ||
481 | yield return false; | ||
482 | } | ||
483 | } | ||
484 | } | ||
485 | } | ||
486 | } | ||
487 | |||
488 | public static IEnumerable<bool> remove_comments(object arg1, object arg2, object arg3) | ||
489 | { | ||
490 | { | ||
491 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
492 | { | ||
493 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
494 | { | ||
495 | foreach (bool l4 in YP.unify(arg3, Atom.NIL)) | ||
496 | { | ||
497 | yield return false; | ||
498 | } | ||
499 | } | ||
500 | } | ||
501 | } | ||
502 | { | ||
503 | object Ys = arg2; | ||
504 | Variable S = new Variable(); | ||
505 | Variable E = new Variable(); | ||
506 | Variable Xs = new Variable(); | ||
507 | Variable Zs = new Variable(); | ||
508 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("comment", S, E), Xs))) | ||
509 | { | ||
510 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("comment", S, E), Zs))) | ||
511 | { | ||
512 | foreach (bool l4 in remove_comments(Xs, Ys, Zs)) | ||
513 | { | ||
514 | yield return false; | ||
515 | } | ||
516 | yield break; | ||
517 | } | ||
518 | } | ||
519 | } | ||
520 | { | ||
521 | Variable Pos = new Variable(); | ||
522 | Variable Xs = new Variable(); | ||
523 | Variable Ys = new Variable(); | ||
524 | Variable Pos2 = new Variable(); | ||
525 | Variable Zs = new Variable(); | ||
526 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("/", Atom.a("["), Pos), Xs))) | ||
527 | { | ||
528 | foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a("["), Ys))) | ||
529 | { | ||
530 | foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2("list", Pos, Pos2), Zs))) | ||
531 | { | ||
532 | foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) | ||
533 | { | ||
534 | foreach (bool l6 in remove_comments(Xs, Ys, Zs)) | ||
535 | { | ||
536 | yield return false; | ||
537 | } | ||
538 | } | ||
539 | yield break; | ||
540 | } | ||
541 | } | ||
542 | } | ||
543 | } | ||
544 | { | ||
545 | Variable Pos = new Variable(); | ||
546 | Variable Xs = new Variable(); | ||
547 | Variable Ys = new Variable(); | ||
548 | Variable Pos2 = new Variable(); | ||
549 | Variable Zs = new Variable(); | ||
550 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("/", Atom.a("]"), Pos), Xs))) | ||
551 | { | ||
552 | foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a("]"), Ys))) | ||
553 | { | ||
554 | foreach (bool l4 in YP.unify(arg3, new ListPair(new Functor2("list", Pos, Pos2), Zs))) | ||
555 | { | ||
556 | foreach (bool l5 in YP.unify(Pos2, YP.add(Pos, 1))) | ||
557 | { | ||
558 | foreach (bool l6 in remove_comments(Xs, Ys, Zs)) | ||
559 | { | ||
560 | yield return false; | ||
561 | } | ||
562 | } | ||
563 | yield break; | ||
564 | } | ||
565 | } | ||
566 | } | ||
567 | } | ||
568 | { | ||
569 | object Zs = arg3; | ||
570 | Variable Token = new Variable(); | ||
571 | Variable Xs = new Variable(); | ||
572 | Variable Ys = new Variable(); | ||
573 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Xs))) | ||
574 | { | ||
575 | foreach (bool l3 in YP.unify(arg2, new ListPair(Token, Ys))) | ||
576 | { | ||
577 | foreach (bool l4 in remove_comments(Xs, Ys, Zs)) | ||
578 | { | ||
579 | yield return false; | ||
580 | } | ||
581 | } | ||
582 | } | ||
583 | } | ||
584 | } | ||
585 | |||
586 | public static IEnumerable<bool> expect(object Token, object arg2, object arg3) | ||
587 | { | ||
588 | { | ||
589 | object Rest = arg3; | ||
590 | foreach (bool l2 in YP.unify(arg2, new ListPair(Token, Rest))) | ||
591 | { | ||
592 | yield return true; | ||
593 | yield break; | ||
594 | } | ||
595 | } | ||
596 | { | ||
597 | object S0 = arg2; | ||
598 | object x3 = arg3; | ||
599 | foreach (bool l2 in syntax_error(ListPair.make(new object[] { Token, Atom.a("or"), Atom.a("operator"), Atom.a("expected") }), S0)) | ||
600 | { | ||
601 | yield return false; | ||
602 | } | ||
603 | } | ||
604 | } | ||
605 | |||
606 | public static IEnumerable<bool> parse2(object Tokens, object Answer) | ||
607 | { | ||
608 | { | ||
609 | Variable Term = new Variable(); | ||
610 | Variable LeftOver = new Variable(); | ||
611 | foreach (bool l2 in clear_errors()) | ||
612 | { | ||
613 | foreach (bool l3 in parse(Tokens, 1200, Term, LeftOver)) | ||
614 | { | ||
615 | foreach (bool l4 in all_read(LeftOver)) | ||
616 | { | ||
617 | foreach (bool l5 in YP.unify(Answer, Term)) | ||
618 | { | ||
619 | yield return false; | ||
620 | } | ||
621 | yield break; | ||
622 | } | ||
623 | } | ||
624 | foreach (bool l3 in syntax_error(Tokens)) | ||
625 | { | ||
626 | yield return false; | ||
627 | } | ||
628 | } | ||
629 | } | ||
630 | } | ||
631 | |||
632 | public static IEnumerable<bool> all_read(object arg1) | ||
633 | { | ||
634 | { | ||
635 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
636 | { | ||
637 | yield return false; | ||
638 | } | ||
639 | } | ||
640 | { | ||
641 | Variable Token = new Variable(); | ||
642 | Variable S = new Variable(); | ||
643 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S))) | ||
644 | { | ||
645 | foreach (bool l3 in syntax_error(ListPair.make(new object[] { Atom.a("operator"), Atom.a("expected"), Atom.a("after"), Atom.a("expression") }), new ListPair(Token, S))) | ||
646 | { | ||
647 | yield return false; | ||
648 | } | ||
649 | } | ||
650 | } | ||
651 | } | ||
652 | |||
653 | public static IEnumerable<bool> parse(object arg1, object arg2, object arg3, object arg4) | ||
654 | { | ||
655 | { | ||
656 | object x1 = arg2; | ||
657 | object x2 = arg3; | ||
658 | object x3 = arg4; | ||
659 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
660 | { | ||
661 | foreach (bool l3 in syntax_error(new ListPair(Atom.a("expression"), new ListPair(Atom.a("expected"), Atom.NIL)), Atom.NIL)) | ||
662 | { | ||
663 | yield return false; | ||
664 | } | ||
665 | } | ||
666 | } | ||
667 | { | ||
668 | object Precedence = arg2; | ||
669 | object Term = arg3; | ||
670 | object LeftOver = arg4; | ||
671 | Variable Token = new Variable(); | ||
672 | Variable RestTokens = new Variable(); | ||
673 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, RestTokens))) | ||
674 | { | ||
675 | foreach (bool l3 in parse5(Token, RestTokens, Precedence, Term, LeftOver)) | ||
676 | { | ||
677 | yield return false; | ||
678 | } | ||
679 | } | ||
680 | } | ||
681 | } | ||
682 | |||
683 | public static IEnumerable<bool> parse5(object arg1, object arg2, object arg3, object arg4, object arg5) | ||
684 | { | ||
685 | { | ||
686 | object S0 = arg2; | ||
687 | object x2 = arg3; | ||
688 | object x3 = arg4; | ||
689 | object x4 = arg5; | ||
690 | foreach (bool l2 in YP.unify(arg1, Atom.a("}"))) | ||
691 | { | ||
692 | foreach (bool l3 in cannot_start(Atom.a("}"), S0)) | ||
693 | { | ||
694 | yield return false; | ||
695 | } | ||
696 | } | ||
697 | } | ||
698 | { | ||
699 | object S0 = arg2; | ||
700 | object x2 = arg3; | ||
701 | object x3 = arg4; | ||
702 | object x4 = arg5; | ||
703 | foreach (bool l2 in YP.unify(arg1, Atom.a("]"))) | ||
704 | { | ||
705 | foreach (bool l3 in cannot_start(Atom.a("]"), S0)) | ||
706 | { | ||
707 | yield return false; | ||
708 | } | ||
709 | } | ||
710 | } | ||
711 | { | ||
712 | object S0 = arg2; | ||
713 | object x2 = arg3; | ||
714 | object x3 = arg4; | ||
715 | object x4 = arg5; | ||
716 | foreach (bool l2 in YP.unify(arg1, Atom.a(")"))) | ||
717 | { | ||
718 | foreach (bool l3 in cannot_start(Atom.a(")"), S0)) | ||
719 | { | ||
720 | yield return false; | ||
721 | } | ||
722 | } | ||
723 | } | ||
724 | { | ||
725 | object S0 = arg2; | ||
726 | object x2 = arg3; | ||
727 | object x3 = arg4; | ||
728 | object x4 = arg5; | ||
729 | foreach (bool l2 in YP.unify(arg1, Atom.a(","))) | ||
730 | { | ||
731 | foreach (bool l3 in cannot_start(Atom.a(","), S0)) | ||
732 | { | ||
733 | yield return false; | ||
734 | } | ||
735 | } | ||
736 | } | ||
737 | { | ||
738 | object S0 = arg2; | ||
739 | object x2 = arg3; | ||
740 | object x3 = arg4; | ||
741 | object x4 = arg5; | ||
742 | foreach (bool l2 in YP.unify(arg1, Atom.a("|"))) | ||
743 | { | ||
744 | foreach (bool l3 in cannot_start(Atom.a("|"), S0)) | ||
745 | { | ||
746 | yield return false; | ||
747 | } | ||
748 | } | ||
749 | } | ||
750 | { | ||
751 | object S0 = arg2; | ||
752 | object Precedence = arg3; | ||
753 | object Answer = arg4; | ||
754 | object S = arg5; | ||
755 | Variable Codes = new Variable(); | ||
756 | Variable Term = new Variable(); | ||
757 | Variable A = new Variable(); | ||
758 | foreach (bool l2 in YP.unify(arg1, new Functor1("string", Codes))) | ||
759 | { | ||
760 | foreach (bool l3 in YP.current_prolog_flag(Atom.a("double_quotes"), Atom.a("atom"))) | ||
761 | { | ||
762 | foreach (bool l4 in YP.atom_codes(Term, Codes)) | ||
763 | { | ||
764 | foreach (bool l5 in exprtl0(S0, Term, Precedence, Answer, S)) | ||
765 | { | ||
766 | yield return false; | ||
767 | } | ||
768 | } | ||
769 | goto cutIf1; | ||
770 | } | ||
771 | foreach (bool l3 in YP.current_prolog_flag(Atom.a("double_quotes"), Atom.a("chars"))) | ||
772 | { | ||
773 | foreach (bool l4 in YP.atom_codes(A, Codes)) | ||
774 | { | ||
775 | foreach (bool l5 in YP.atom_chars(A, Term)) | ||
776 | { | ||
777 | foreach (bool l6 in exprtl0(S0, Term, Precedence, Answer, S)) | ||
778 | { | ||
779 | yield return false; | ||
780 | } | ||
781 | } | ||
782 | } | ||
783 | goto cutIf2; | ||
784 | } | ||
785 | foreach (bool l3 in YP.unify(Term, Codes)) | ||
786 | { | ||
787 | foreach (bool l4 in exprtl0(S0, Term, Precedence, Answer, S)) | ||
788 | { | ||
789 | yield return false; | ||
790 | } | ||
791 | } | ||
792 | cutIf2: | ||
793 | cutIf1: | ||
794 | { } | ||
795 | } | ||
796 | } | ||
797 | { | ||
798 | object S0 = arg2; | ||
799 | object Precedence = arg3; | ||
800 | object Answer = arg4; | ||
801 | object S = arg5; | ||
802 | Variable Number = new Variable(); | ||
803 | foreach (bool l2 in YP.unify(arg1, new Functor1("number", Number))) | ||
804 | { | ||
805 | foreach (bool l3 in exprtl0(S0, Number, Precedence, Answer, S)) | ||
806 | { | ||
807 | yield return false; | ||
808 | } | ||
809 | } | ||
810 | } | ||
811 | { | ||
812 | object Precedence = arg3; | ||
813 | object Answer = arg4; | ||
814 | object S = arg5; | ||
815 | Variable S1 = new Variable(); | ||
816 | foreach (bool l2 in YP.unify(arg1, Atom.a("["))) | ||
817 | { | ||
818 | foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a("]"), S1))) | ||
819 | { | ||
820 | foreach (bool l4 in read_atom(new Functor2("/", Atom.NIL, 0), S1, Precedence, Answer, S)) | ||
821 | { | ||
822 | yield return false; | ||
823 | } | ||
824 | yield break; | ||
825 | } | ||
826 | } | ||
827 | } | ||
828 | { | ||
829 | object S1 = arg2; | ||
830 | object Precedence = arg3; | ||
831 | object Answer = arg4; | ||
832 | object S = arg5; | ||
833 | Variable Arg1 = new Variable(); | ||
834 | Variable S2 = new Variable(); | ||
835 | Variable RestArgs = new Variable(); | ||
836 | Variable S3 = new Variable(); | ||
837 | foreach (bool l2 in YP.unify(arg1, Atom.a("["))) | ||
838 | { | ||
839 | foreach (bool l3 in parse(S1, 999, Arg1, S2)) | ||
840 | { | ||
841 | foreach (bool l4 in read_list(S2, RestArgs, S3)) | ||
842 | { | ||
843 | foreach (bool l5 in exprtl0(S3, new ListPair(Arg1, RestArgs), Precedence, Answer, S)) | ||
844 | { | ||
845 | yield return false; | ||
846 | } | ||
847 | yield break; | ||
848 | } | ||
849 | } | ||
850 | } | ||
851 | } | ||
852 | { | ||
853 | object S1 = arg2; | ||
854 | object Precedence = arg3; | ||
855 | object Answer = arg4; | ||
856 | object S = arg5; | ||
857 | Variable Term = new Variable(); | ||
858 | Variable S2 = new Variable(); | ||
859 | Variable S3 = new Variable(); | ||
860 | foreach (bool l2 in YP.unify(arg1, Atom.a("("))) | ||
861 | { | ||
862 | foreach (bool l3 in parse(S1, 1200, Term, S2)) | ||
863 | { | ||
864 | foreach (bool l4 in expect(Atom.a(")"), S2, S3)) | ||
865 | { | ||
866 | foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) | ||
867 | { | ||
868 | yield return false; | ||
869 | } | ||
870 | yield break; | ||
871 | } | ||
872 | } | ||
873 | } | ||
874 | } | ||
875 | { | ||
876 | object S1 = arg2; | ||
877 | object Precedence = arg3; | ||
878 | object Answer = arg4; | ||
879 | object S = arg5; | ||
880 | Variable Term = new Variable(); | ||
881 | Variable S2 = new Variable(); | ||
882 | Variable S3 = new Variable(); | ||
883 | foreach (bool l2 in YP.unify(arg1, Atom.a(" ("))) | ||
884 | { | ||
885 | foreach (bool l3 in parse(S1, 1200, Term, S2)) | ||
886 | { | ||
887 | foreach (bool l4 in expect(Atom.a(")"), S2, S3)) | ||
888 | { | ||
889 | foreach (bool l5 in exprtl0(S3, Term, Precedence, Answer, S)) | ||
890 | { | ||
891 | yield return false; | ||
892 | } | ||
893 | yield break; | ||
894 | } | ||
895 | } | ||
896 | } | ||
897 | } | ||
898 | { | ||
899 | object Precedence = arg3; | ||
900 | object Answer = arg4; | ||
901 | object S = arg5; | ||
902 | Variable _Pos = new Variable(); | ||
903 | Variable S1 = new Variable(); | ||
904 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", Atom.a("{"), _Pos))) | ||
905 | { | ||
906 | foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a("}"), S1))) | ||
907 | { | ||
908 | foreach (bool l4 in read_atom(Atom.a("{}"), S1, Precedence, Answer, S)) | ||
909 | { | ||
910 | yield return false; | ||
911 | } | ||
912 | yield break; | ||
913 | } | ||
914 | } | ||
915 | } | ||
916 | { | ||
917 | object S1 = arg2; | ||
918 | object Precedence = arg3; | ||
919 | object Answer = arg4; | ||
920 | object S = arg5; | ||
921 | Variable Pos = new Variable(); | ||
922 | Variable Term = new Variable(); | ||
923 | Variable S2 = new Variable(); | ||
924 | Variable S3 = new Variable(); | ||
925 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", Atom.a("{"), Pos))) | ||
926 | { | ||
927 | foreach (bool l3 in parse(S1, 1200, Term, S2)) | ||
928 | { | ||
929 | foreach (bool l4 in expect(Atom.a("}"), S2, S3)) | ||
930 | { | ||
931 | foreach (bool l5 in exprtl0(S3, new Functor2("{}", Pos, Term), Precedence, Answer, S)) | ||
932 | { | ||
933 | yield return false; | ||
934 | } | ||
935 | yield break; | ||
936 | } | ||
937 | } | ||
938 | } | ||
939 | } | ||
940 | { | ||
941 | object Precedence = arg3; | ||
942 | object Answer = arg4; | ||
943 | object S = arg5; | ||
944 | Variable Variable_1 = new Variable(); | ||
945 | Variable Name = new Variable(); | ||
946 | Variable Pos = new Variable(); | ||
947 | Variable S1 = new Variable(); | ||
948 | Variable Arg1 = new Variable(); | ||
949 | Variable S2 = new Variable(); | ||
950 | Variable RestArgs = new Variable(); | ||
951 | Variable S3 = new Variable(); | ||
952 | Variable Term = new Variable(); | ||
953 | foreach (bool l2 in YP.unify(arg1, new Functor3("var", Variable_1, Name, Pos))) | ||
954 | { | ||
955 | foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a("("), S1))) | ||
956 | { | ||
957 | foreach (bool l4 in parse(S1, 999, Arg1, S2)) | ||
958 | { | ||
959 | foreach (bool l5 in read_args(S2, RestArgs, S3)) | ||
960 | { | ||
961 | foreach (bool l6 in YP.univ(Term, new ListPair(Atom.a("call"), new ListPair(new Functor3("$VAR", Pos, Name, Variable_1), new ListPair(Arg1, RestArgs))))) | ||
962 | { | ||
963 | foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) | ||
964 | { | ||
965 | yield return false; | ||
966 | } | ||
967 | } | ||
968 | yield break; | ||
969 | } | ||
970 | } | ||
971 | yield break; | ||
972 | } | ||
973 | } | ||
974 | } | ||
975 | { | ||
976 | object S0 = arg2; | ||
977 | object Precedence = arg3; | ||
978 | object Answer = arg4; | ||
979 | object S = arg5; | ||
980 | Variable Variable_1 = new Variable(); | ||
981 | Variable Name = new Variable(); | ||
982 | Variable Pos = new Variable(); | ||
983 | foreach (bool l2 in YP.unify(arg1, new Functor3("var", Variable_1, Name, Pos))) | ||
984 | { | ||
985 | foreach (bool l3 in exprtl0(S0, new Functor3("$VAR", Pos, Name, Variable_1), Precedence, Answer, S)) | ||
986 | { | ||
987 | yield return false; | ||
988 | } | ||
989 | } | ||
990 | } | ||
991 | { | ||
992 | object S0 = arg2; | ||
993 | object Precedence = arg3; | ||
994 | object Answer = arg4; | ||
995 | object S = arg5; | ||
996 | Variable Atom_1 = new Variable(); | ||
997 | Variable P = new Variable(); | ||
998 | foreach (bool l2 in YP.unify(arg1, new Functor2("atom", Atom_1, P))) | ||
999 | { | ||
1000 | foreach (bool l3 in read_atom(new Functor2("/", Atom_1, P), S0, Precedence, Answer, S)) | ||
1001 | { | ||
1002 | yield return false; | ||
1003 | } | ||
1004 | } | ||
1005 | } | ||
1006 | } | ||
1007 | |||
1008 | public static IEnumerable<bool> read_atom(object arg1, object arg2, object Precedence, object Answer, object S) | ||
1009 | { | ||
1010 | { | ||
1011 | Variable _Pos = new Variable(); | ||
1012 | Variable Number = new Variable(); | ||
1013 | Variable S1 = new Variable(); | ||
1014 | Variable Negative = new Variable(); | ||
1015 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", Atom.a("-"), _Pos))) | ||
1016 | { | ||
1017 | foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1("number", Number), S1))) | ||
1018 | { | ||
1019 | foreach (bool l4 in YP.unify(Negative, YP.negate(Number))) | ||
1020 | { | ||
1021 | foreach (bool l5 in exprtl0(S1, Negative, Precedence, Answer, S)) | ||
1022 | { | ||
1023 | yield return false; | ||
1024 | } | ||
1025 | } | ||
1026 | yield break; | ||
1027 | } | ||
1028 | } | ||
1029 | } | ||
1030 | { | ||
1031 | Variable Functor_1 = new Variable(); | ||
1032 | Variable Pos = new Variable(); | ||
1033 | Variable S1 = new Variable(); | ||
1034 | Variable Arg1 = new Variable(); | ||
1035 | Variable S2 = new Variable(); | ||
1036 | Variable RestArgs = new Variable(); | ||
1037 | Variable S3 = new Variable(); | ||
1038 | Variable Term = new Variable(); | ||
1039 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", Functor_1, Pos))) | ||
1040 | { | ||
1041 | foreach (bool l3 in YP.unify(arg2, new ListPair(Atom.a("("), S1))) | ||
1042 | { | ||
1043 | foreach (bool l4 in parse(S1, 999, Arg1, S2)) | ||
1044 | { | ||
1045 | foreach (bool l5 in read_args(S2, RestArgs, S3)) | ||
1046 | { | ||
1047 | foreach (bool l6 in YP.univ(Term, new ListPair(Functor_1, new ListPair(Pos, new ListPair(Arg1, RestArgs))))) | ||
1048 | { | ||
1049 | foreach (bool l7 in exprtl0(S3, Term, Precedence, Answer, S)) | ||
1050 | { | ||
1051 | yield return false; | ||
1052 | } | ||
1053 | } | ||
1054 | yield break; | ||
1055 | } | ||
1056 | } | ||
1057 | yield break; | ||
1058 | } | ||
1059 | } | ||
1060 | } | ||
1061 | { | ||
1062 | object S0 = arg2; | ||
1063 | Variable Op = new Variable(); | ||
1064 | Variable Pos = new Variable(); | ||
1065 | Variable Oprec = new Variable(); | ||
1066 | Variable Aprec = new Variable(); | ||
1067 | Variable Flag = new Variable(); | ||
1068 | Variable Term = new Variable(); | ||
1069 | Variable Arg = new Variable(); | ||
1070 | Variable S1 = new Variable(); | ||
1071 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", Op, Pos))) | ||
1072 | { | ||
1073 | foreach (bool l3 in prefixop(Op, Oprec, Aprec)) | ||
1074 | { | ||
1075 | foreach (bool l4 in possible_right_operand(S0, Flag)) | ||
1076 | { | ||
1077 | if (YP.lessThan(Flag, 0)) | ||
1078 | { | ||
1079 | foreach (bool l6 in YP.univ(Term, new ListPair(Op, new ListPair(Pos, Atom.NIL)))) | ||
1080 | { | ||
1081 | foreach (bool l7 in exprtl0(S0, Term, Precedence, Answer, S)) | ||
1082 | { | ||
1083 | yield return false; | ||
1084 | } | ||
1085 | } | ||
1086 | goto cutIf1; | ||
1087 | } | ||
1088 | if (YP.greaterThan(Oprec, Precedence)) | ||
1089 | { | ||
1090 | foreach (bool l6 in syntax_error(ListPair.make(new object[] { Atom.a("prefix"), Atom.a("operator"), Op, Atom.a("in"), Atom.a("context"), Atom.a("with"), Atom.a("precedence"), Precedence }), S0)) | ||
1091 | { | ||
1092 | yield return false; | ||
1093 | } | ||
1094 | goto cutIf2; | ||
1095 | } | ||
1096 | if (YP.greaterThan(Flag, 0)) | ||
1097 | { | ||
1098 | foreach (bool l6 in parse(S0, Aprec, Arg, S1)) | ||
1099 | { | ||
1100 | foreach (bool l7 in YP.univ(Term, ListPair.make(new object[] { Op, Pos, Arg }))) | ||
1101 | { | ||
1102 | foreach (bool l8 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) | ||
1103 | { | ||
1104 | yield return false; | ||
1105 | } | ||
1106 | } | ||
1107 | yield break; | ||
1108 | } | ||
1109 | goto cutIf3; | ||
1110 | } | ||
1111 | foreach (bool l5 in peepop(S0, S1)) | ||
1112 | { | ||
1113 | foreach (bool l6 in prefix_is_atom(S1, Oprec)) | ||
1114 | { | ||
1115 | foreach (bool l7 in exprtl(S1, Oprec, new Functor2("/", Op, Pos), Precedence, Answer, S)) | ||
1116 | { | ||
1117 | yield return false; | ||
1118 | } | ||
1119 | } | ||
1120 | } | ||
1121 | foreach (bool l5 in parse(S0, Aprec, Arg, S1)) | ||
1122 | { | ||
1123 | foreach (bool l6 in YP.univ(Term, ListPair.make(new object[] { Op, Pos, Arg }))) | ||
1124 | { | ||
1125 | foreach (bool l7 in exprtl(S1, Oprec, Term, Precedence, Answer, S)) | ||
1126 | { | ||
1127 | yield return false; | ||
1128 | } | ||
1129 | } | ||
1130 | yield break; | ||
1131 | } | ||
1132 | cutIf3: | ||
1133 | cutIf2: | ||
1134 | cutIf1: | ||
1135 | { } | ||
1136 | } | ||
1137 | yield break; | ||
1138 | } | ||
1139 | } | ||
1140 | } | ||
1141 | { | ||
1142 | object S0 = arg2; | ||
1143 | Variable Atom_1 = new Variable(); | ||
1144 | Variable Pos = new Variable(); | ||
1145 | Variable Term = new Variable(); | ||
1146 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", Atom_1, Pos))) | ||
1147 | { | ||
1148 | foreach (bool l3 in YP.univ(Term, new ListPair(Atom_1, new ListPair(Pos, Atom.NIL)))) | ||
1149 | { | ||
1150 | foreach (bool l4 in exprtl0(S0, Term, Precedence, Answer, S)) | ||
1151 | { | ||
1152 | yield return false; | ||
1153 | } | ||
1154 | } | ||
1155 | } | ||
1156 | } | ||
1157 | } | ||
1158 | |||
1159 | public static IEnumerable<bool> cannot_start(object Token, object S0) | ||
1160 | { | ||
1161 | { | ||
1162 | foreach (bool l2 in syntax_error(ListPair.make(new object[] { Token, Atom.a("cannot"), Atom.a("start"), Atom.a("an"), Atom.a("expression") }), S0)) | ||
1163 | { | ||
1164 | yield return false; | ||
1165 | } | ||
1166 | } | ||
1167 | } | ||
1168 | |||
1169 | public static IEnumerable<bool> read_args(object arg1, object arg2, object arg3) | ||
1170 | { | ||
1171 | { | ||
1172 | object S = arg3; | ||
1173 | Variable S1 = new Variable(); | ||
1174 | Variable Term = new Variable(); | ||
1175 | Variable Rest = new Variable(); | ||
1176 | Variable S2 = new Variable(); | ||
1177 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(","), S1))) | ||
1178 | { | ||
1179 | foreach (bool l3 in YP.unify(arg2, new ListPair(Term, Rest))) | ||
1180 | { | ||
1181 | foreach (bool l4 in parse(S1, 999, Term, S2)) | ||
1182 | { | ||
1183 | foreach (bool l5 in read_args(S2, Rest, S)) | ||
1184 | { | ||
1185 | yield return false; | ||
1186 | } | ||
1187 | yield break; | ||
1188 | } | ||
1189 | yield break; | ||
1190 | } | ||
1191 | } | ||
1192 | } | ||
1193 | { | ||
1194 | object S = arg3; | ||
1195 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a(")"), S))) | ||
1196 | { | ||
1197 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
1198 | { | ||
1199 | yield return true; | ||
1200 | yield break; | ||
1201 | } | ||
1202 | } | ||
1203 | } | ||
1204 | { | ||
1205 | object S = arg1; | ||
1206 | object x2 = arg2; | ||
1207 | object x3 = arg3; | ||
1208 | foreach (bool l2 in syntax_error(ListPair.make(new object[] { Atom.a(", or )"), Atom.a("expected"), Atom.a("in"), Atom.a("arguments") }), S)) | ||
1209 | { | ||
1210 | yield return false; | ||
1211 | } | ||
1212 | } | ||
1213 | } | ||
1214 | |||
1215 | public static IEnumerable<bool> read_list(object arg1, object arg2, object arg3) | ||
1216 | { | ||
1217 | { | ||
1218 | object x1 = arg2; | ||
1219 | object x2 = arg3; | ||
1220 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1221 | { | ||
1222 | foreach (bool l3 in syntax_error(ListPair.make(new object[] { Atom.a(", | or ]"), Atom.a("expected"), Atom.a("in"), Atom.a("list") }), Atom.NIL)) | ||
1223 | { | ||
1224 | yield return false; | ||
1225 | } | ||
1226 | } | ||
1227 | } | ||
1228 | { | ||
1229 | object Rest = arg2; | ||
1230 | object S = arg3; | ||
1231 | Variable Token = new Variable(); | ||
1232 | Variable S1 = new Variable(); | ||
1233 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) | ||
1234 | { | ||
1235 | foreach (bool l3 in read_list4(Token, S1, Rest, S)) | ||
1236 | { | ||
1237 | yield return false; | ||
1238 | } | ||
1239 | } | ||
1240 | } | ||
1241 | } | ||
1242 | |||
1243 | public static IEnumerable<bool> read_list4(object arg1, object arg2, object arg3, object arg4) | ||
1244 | { | ||
1245 | { | ||
1246 | object S1 = arg2; | ||
1247 | object S = arg4; | ||
1248 | Variable Term = new Variable(); | ||
1249 | Variable Rest = new Variable(); | ||
1250 | Variable S2 = new Variable(); | ||
1251 | foreach (bool l2 in YP.unify(arg1, Atom.a(","))) | ||
1252 | { | ||
1253 | foreach (bool l3 in YP.unify(arg3, new ListPair(Term, Rest))) | ||
1254 | { | ||
1255 | foreach (bool l4 in parse(S1, 999, Term, S2)) | ||
1256 | { | ||
1257 | foreach (bool l5 in read_list(S2, Rest, S)) | ||
1258 | { | ||
1259 | yield return false; | ||
1260 | } | ||
1261 | yield break; | ||
1262 | } | ||
1263 | yield break; | ||
1264 | } | ||
1265 | } | ||
1266 | } | ||
1267 | { | ||
1268 | object S1 = arg2; | ||
1269 | object Rest = arg3; | ||
1270 | object S = arg4; | ||
1271 | Variable S2 = new Variable(); | ||
1272 | foreach (bool l2 in YP.unify(arg1, Atom.a("|"))) | ||
1273 | { | ||
1274 | foreach (bool l3 in parse(S1, 999, Rest, S2)) | ||
1275 | { | ||
1276 | foreach (bool l4 in expect(Atom.a("]"), S2, S)) | ||
1277 | { | ||
1278 | yield return false; | ||
1279 | } | ||
1280 | yield break; | ||
1281 | } | ||
1282 | yield break; | ||
1283 | } | ||
1284 | } | ||
1285 | { | ||
1286 | Variable S1 = new Variable(); | ||
1287 | foreach (bool l2 in YP.unify(arg1, Atom.a("]"))) | ||
1288 | { | ||
1289 | foreach (bool l3 in YP.unify(arg2, S1)) | ||
1290 | { | ||
1291 | foreach (bool l4 in YP.unify(arg3, Atom.NIL)) | ||
1292 | { | ||
1293 | foreach (bool l5 in YP.unify(arg4, S1)) | ||
1294 | { | ||
1295 | yield return true; | ||
1296 | yield break; | ||
1297 | } | ||
1298 | } | ||
1299 | } | ||
1300 | } | ||
1301 | } | ||
1302 | { | ||
1303 | object Token = arg1; | ||
1304 | object S1 = arg2; | ||
1305 | object x3 = arg3; | ||
1306 | object x4 = arg4; | ||
1307 | foreach (bool l2 in syntax_error(ListPair.make(new object[] { Atom.a(", | or ]"), Atom.a("expected"), Atom.a("in"), Atom.a("list") }), new ListPair(Token, S1))) | ||
1308 | { | ||
1309 | yield return false; | ||
1310 | } | ||
1311 | } | ||
1312 | } | ||
1313 | |||
1314 | public static IEnumerable<bool> possible_right_operand(object arg1, object arg2) | ||
1315 | { | ||
1316 | { | ||
1317 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1318 | { | ||
1319 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
1320 | { | ||
1321 | yield return false; | ||
1322 | } | ||
1323 | } | ||
1324 | } | ||
1325 | { | ||
1326 | object Flag = arg2; | ||
1327 | Variable H = new Variable(); | ||
1328 | Variable T = new Variable(); | ||
1329 | foreach (bool l2 in YP.unify(arg1, new ListPair(H, T))) | ||
1330 | { | ||
1331 | foreach (bool l3 in possible_right_operand3(H, Flag, T)) | ||
1332 | { | ||
1333 | yield return false; | ||
1334 | } | ||
1335 | } | ||
1336 | } | ||
1337 | } | ||
1338 | |||
1339 | public static IEnumerable<bool> possible_right_operand3(object arg1, object arg2, object arg3) | ||
1340 | { | ||
1341 | { | ||
1342 | object x4 = arg3; | ||
1343 | Variable x1 = new Variable(); | ||
1344 | Variable x2 = new Variable(); | ||
1345 | Variable x3 = new Variable(); | ||
1346 | foreach (bool l2 in YP.unify(arg1, new Functor3("var", x1, x2, x3))) | ||
1347 | { | ||
1348 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
1349 | { | ||
1350 | yield return false; | ||
1351 | } | ||
1352 | } | ||
1353 | } | ||
1354 | { | ||
1355 | object x2 = arg3; | ||
1356 | Variable x1 = new Variable(); | ||
1357 | foreach (bool l2 in YP.unify(arg1, new Functor1("number", x1))) | ||
1358 | { | ||
1359 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
1360 | { | ||
1361 | yield return false; | ||
1362 | } | ||
1363 | } | ||
1364 | } | ||
1365 | { | ||
1366 | object x2 = arg3; | ||
1367 | Variable x1 = new Variable(); | ||
1368 | foreach (bool l2 in YP.unify(arg1, new Functor1("string", x1))) | ||
1369 | { | ||
1370 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
1371 | { | ||
1372 | yield return false; | ||
1373 | } | ||
1374 | } | ||
1375 | } | ||
1376 | { | ||
1377 | object x1 = arg3; | ||
1378 | foreach (bool l2 in YP.unify(arg1, Atom.a(" ("))) | ||
1379 | { | ||
1380 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
1381 | { | ||
1382 | yield return false; | ||
1383 | } | ||
1384 | } | ||
1385 | } | ||
1386 | { | ||
1387 | object x1 = arg3; | ||
1388 | foreach (bool l2 in YP.unify(arg1, Atom.a("("))) | ||
1389 | { | ||
1390 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
1391 | { | ||
1392 | yield return false; | ||
1393 | } | ||
1394 | } | ||
1395 | } | ||
1396 | { | ||
1397 | object x1 = arg3; | ||
1398 | foreach (bool l2 in YP.unify(arg1, Atom.a(")"))) | ||
1399 | { | ||
1400 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
1401 | { | ||
1402 | yield return false; | ||
1403 | } | ||
1404 | } | ||
1405 | } | ||
1406 | { | ||
1407 | Variable x1 = new Variable(); | ||
1408 | foreach (bool l2 in YP.unify(arg1, Atom.a("["))) | ||
1409 | { | ||
1410 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
1411 | { | ||
1412 | foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a("]"), x1))) | ||
1413 | { | ||
1414 | yield return true; | ||
1415 | yield break; | ||
1416 | } | ||
1417 | } | ||
1418 | } | ||
1419 | } | ||
1420 | { | ||
1421 | object x1 = arg3; | ||
1422 | foreach (bool l2 in YP.unify(arg1, Atom.a("["))) | ||
1423 | { | ||
1424 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
1425 | { | ||
1426 | yield return false; | ||
1427 | } | ||
1428 | } | ||
1429 | } | ||
1430 | { | ||
1431 | object x1 = arg3; | ||
1432 | foreach (bool l2 in YP.unify(arg1, Atom.a("]"))) | ||
1433 | { | ||
1434 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
1435 | { | ||
1436 | yield return false; | ||
1437 | } | ||
1438 | } | ||
1439 | } | ||
1440 | { | ||
1441 | Variable x1 = new Variable(); | ||
1442 | foreach (bool l2 in YP.unify(arg1, Atom.a("{"))) | ||
1443 | { | ||
1444 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
1445 | { | ||
1446 | foreach (bool l4 in YP.unify(arg3, new ListPair(Atom.a("}"), x1))) | ||
1447 | { | ||
1448 | yield return true; | ||
1449 | yield break; | ||
1450 | } | ||
1451 | } | ||
1452 | } | ||
1453 | } | ||
1454 | { | ||
1455 | object x1 = arg3; | ||
1456 | foreach (bool l2 in YP.unify(arg1, Atom.a("{"))) | ||
1457 | { | ||
1458 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
1459 | { | ||
1460 | yield return false; | ||
1461 | } | ||
1462 | } | ||
1463 | } | ||
1464 | { | ||
1465 | object x1 = arg3; | ||
1466 | foreach (bool l2 in YP.unify(arg1, Atom.a("}"))) | ||
1467 | { | ||
1468 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
1469 | { | ||
1470 | yield return false; | ||
1471 | } | ||
1472 | } | ||
1473 | } | ||
1474 | { | ||
1475 | object x1 = arg3; | ||
1476 | foreach (bool l2 in YP.unify(arg1, Atom.a(","))) | ||
1477 | { | ||
1478 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
1479 | { | ||
1480 | yield return false; | ||
1481 | } | ||
1482 | } | ||
1483 | } | ||
1484 | { | ||
1485 | object x1 = arg3; | ||
1486 | foreach (bool l2 in YP.unify(arg1, Atom.a("|"))) | ||
1487 | { | ||
1488 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
1489 | { | ||
1490 | yield return false; | ||
1491 | } | ||
1492 | } | ||
1493 | } | ||
1494 | { | ||
1495 | object x3 = arg3; | ||
1496 | Variable x1 = new Variable(); | ||
1497 | Variable x2 = new Variable(); | ||
1498 | foreach (bool l2 in YP.unify(arg1, new Functor2("atom", x1, x2))) | ||
1499 | { | ||
1500 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
1501 | { | ||
1502 | yield return false; | ||
1503 | } | ||
1504 | } | ||
1505 | } | ||
1506 | } | ||
1507 | |||
1508 | public static IEnumerable<bool> peepop(object arg1, object arg2) | ||
1509 | { | ||
1510 | { | ||
1511 | Variable F = new Variable(); | ||
1512 | Variable Pos = new Variable(); | ||
1513 | Variable S1 = new Variable(); | ||
1514 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("atom", F, Pos), new ListPair(Atom.a("("), S1)))) | ||
1515 | { | ||
1516 | foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor2("atom", F, Pos), new ListPair(Atom.a("("), S1)))) | ||
1517 | { | ||
1518 | yield return true; | ||
1519 | yield break; | ||
1520 | } | ||
1521 | } | ||
1522 | } | ||
1523 | { | ||
1524 | Variable F = new Variable(); | ||
1525 | Variable Pos = new Variable(); | ||
1526 | Variable S1 = new Variable(); | ||
1527 | Variable L = new Variable(); | ||
1528 | Variable P = new Variable(); | ||
1529 | Variable R = new Variable(); | ||
1530 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("atom", F, Pos), S1))) | ||
1531 | { | ||
1532 | foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor(Atom.a("infixop", Atom.a("")), new object[] { new Functor2("/", F, Pos), L, P, R }), S1))) | ||
1533 | { | ||
1534 | foreach (bool l4 in infixop(F, L, P, R)) | ||
1535 | { | ||
1536 | yield return false; | ||
1537 | } | ||
1538 | } | ||
1539 | } | ||
1540 | } | ||
1541 | { | ||
1542 | Variable F = new Variable(); | ||
1543 | Variable Pos = new Variable(); | ||
1544 | Variable S1 = new Variable(); | ||
1545 | Variable L = new Variable(); | ||
1546 | Variable P = new Variable(); | ||
1547 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("atom", F, Pos), S1))) | ||
1548 | { | ||
1549 | foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor3(Atom.a("postfixop", Atom.a("")), new Functor2("/", F, Pos), L, P), S1))) | ||
1550 | { | ||
1551 | foreach (bool l4 in postfixop(F, L, P)) | ||
1552 | { | ||
1553 | yield return false; | ||
1554 | } | ||
1555 | } | ||
1556 | } | ||
1557 | } | ||
1558 | { | ||
1559 | Variable S0 = new Variable(); | ||
1560 | foreach (bool l2 in YP.unify(arg1, S0)) | ||
1561 | { | ||
1562 | foreach (bool l3 in YP.unify(arg2, S0)) | ||
1563 | { | ||
1564 | yield return false; | ||
1565 | } | ||
1566 | } | ||
1567 | } | ||
1568 | } | ||
1569 | |||
1570 | public static IEnumerable<bool> prefix_is_atom(object arg1, object arg2) | ||
1571 | { | ||
1572 | { | ||
1573 | object Precedence = arg2; | ||
1574 | Variable Token = new Variable(); | ||
1575 | Variable x2 = new Variable(); | ||
1576 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, x2))) | ||
1577 | { | ||
1578 | foreach (bool l3 in prefix_is_atom(Token, Precedence)) | ||
1579 | { | ||
1580 | yield return false; | ||
1581 | } | ||
1582 | } | ||
1583 | } | ||
1584 | { | ||
1585 | object P = arg2; | ||
1586 | Variable x1 = new Variable(); | ||
1587 | Variable L = new Variable(); | ||
1588 | Variable x3 = new Variable(); | ||
1589 | Variable x4 = new Variable(); | ||
1590 | foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a("infixop", Atom.a("")), new object[] { x1, L, x3, x4 }))) | ||
1591 | { | ||
1592 | if (YP.greaterThanOrEqual(L, P)) | ||
1593 | { | ||
1594 | yield return false; | ||
1595 | } | ||
1596 | } | ||
1597 | } | ||
1598 | { | ||
1599 | object P = arg2; | ||
1600 | Variable x1 = new Variable(); | ||
1601 | Variable L = new Variable(); | ||
1602 | Variable x3 = new Variable(); | ||
1603 | foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a("postfixop", Atom.a("")), x1, L, x3))) | ||
1604 | { | ||
1605 | if (YP.greaterThanOrEqual(L, P)) | ||
1606 | { | ||
1607 | yield return false; | ||
1608 | } | ||
1609 | } | ||
1610 | } | ||
1611 | { | ||
1612 | object x1 = arg2; | ||
1613 | foreach (bool l2 in YP.unify(arg1, Atom.a(")"))) | ||
1614 | { | ||
1615 | yield return false; | ||
1616 | } | ||
1617 | } | ||
1618 | { | ||
1619 | object x1 = arg2; | ||
1620 | foreach (bool l2 in YP.unify(arg1, Atom.a("]"))) | ||
1621 | { | ||
1622 | yield return false; | ||
1623 | } | ||
1624 | } | ||
1625 | { | ||
1626 | object x1 = arg2; | ||
1627 | foreach (bool l2 in YP.unify(arg1, Atom.a("}"))) | ||
1628 | { | ||
1629 | yield return false; | ||
1630 | } | ||
1631 | } | ||
1632 | { | ||
1633 | object P = arg2; | ||
1634 | foreach (bool l2 in YP.unify(arg1, Atom.a("|"))) | ||
1635 | { | ||
1636 | if (YP.greaterThanOrEqual(1100, P)) | ||
1637 | { | ||
1638 | yield return false; | ||
1639 | } | ||
1640 | } | ||
1641 | } | ||
1642 | { | ||
1643 | object P = arg2; | ||
1644 | foreach (bool l2 in YP.unify(arg1, Atom.a(","))) | ||
1645 | { | ||
1646 | if (YP.greaterThanOrEqual(1000, P)) | ||
1647 | { | ||
1648 | yield return false; | ||
1649 | } | ||
1650 | } | ||
1651 | } | ||
1652 | { | ||
1653 | object x1 = arg2; | ||
1654 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1655 | { | ||
1656 | yield return false; | ||
1657 | } | ||
1658 | } | ||
1659 | } | ||
1660 | |||
1661 | public static IEnumerable<bool> exprtl0(object arg1, object arg2, object arg3, object arg4, object arg5) | ||
1662 | { | ||
1663 | { | ||
1664 | object x2 = arg3; | ||
1665 | Variable Term = new Variable(); | ||
1666 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1667 | { | ||
1668 | foreach (bool l3 in YP.unify(arg2, Term)) | ||
1669 | { | ||
1670 | foreach (bool l4 in YP.unify(arg4, Term)) | ||
1671 | { | ||
1672 | foreach (bool l5 in YP.unify(arg5, Atom.NIL)) | ||
1673 | { | ||
1674 | yield return false; | ||
1675 | } | ||
1676 | } | ||
1677 | } | ||
1678 | } | ||
1679 | } | ||
1680 | { | ||
1681 | object Term = arg2; | ||
1682 | object Precedence = arg3; | ||
1683 | object Answer = arg4; | ||
1684 | object S = arg5; | ||
1685 | Variable Token = new Variable(); | ||
1686 | Variable S1 = new Variable(); | ||
1687 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, S1))) | ||
1688 | { | ||
1689 | foreach (bool l3 in exprtl0_6(Token, Term, Precedence, Answer, S, S1)) | ||
1690 | { | ||
1691 | yield return false; | ||
1692 | } | ||
1693 | } | ||
1694 | } | ||
1695 | } | ||
1696 | |||
1697 | public static IEnumerable<bool> exprtl0_6(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) | ||
1698 | { | ||
1699 | { | ||
1700 | object x2 = arg3; | ||
1701 | object S1 = arg6; | ||
1702 | Variable Term = new Variable(); | ||
1703 | foreach (bool l2 in YP.unify(arg1, Atom.a("}"))) | ||
1704 | { | ||
1705 | foreach (bool l3 in YP.unify(arg2, Term)) | ||
1706 | { | ||
1707 | foreach (bool l4 in YP.unify(arg4, Term)) | ||
1708 | { | ||
1709 | foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a("}"), S1))) | ||
1710 | { | ||
1711 | yield return false; | ||
1712 | } | ||
1713 | } | ||
1714 | } | ||
1715 | } | ||
1716 | } | ||
1717 | { | ||
1718 | object x2 = arg3; | ||
1719 | object S1 = arg6; | ||
1720 | Variable Term = new Variable(); | ||
1721 | foreach (bool l2 in YP.unify(arg1, Atom.a("]"))) | ||
1722 | { | ||
1723 | foreach (bool l3 in YP.unify(arg2, Term)) | ||
1724 | { | ||
1725 | foreach (bool l4 in YP.unify(arg4, Term)) | ||
1726 | { | ||
1727 | foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a("]"), S1))) | ||
1728 | { | ||
1729 | yield return false; | ||
1730 | } | ||
1731 | } | ||
1732 | } | ||
1733 | } | ||
1734 | } | ||
1735 | { | ||
1736 | object x2 = arg3; | ||
1737 | object S1 = arg6; | ||
1738 | Variable Term = new Variable(); | ||
1739 | foreach (bool l2 in YP.unify(arg1, Atom.a(")"))) | ||
1740 | { | ||
1741 | foreach (bool l3 in YP.unify(arg2, Term)) | ||
1742 | { | ||
1743 | foreach (bool l4 in YP.unify(arg4, Term)) | ||
1744 | { | ||
1745 | foreach (bool l5 in YP.unify(arg5, new ListPair(Atom.a(")"), S1))) | ||
1746 | { | ||
1747 | yield return false; | ||
1748 | } | ||
1749 | } | ||
1750 | } | ||
1751 | } | ||
1752 | } | ||
1753 | { | ||
1754 | object Term = arg2; | ||
1755 | object Precedence = arg3; | ||
1756 | object Answer = arg4; | ||
1757 | object S = arg5; | ||
1758 | object S1 = arg6; | ||
1759 | Variable Next = new Variable(); | ||
1760 | Variable S2 = new Variable(); | ||
1761 | foreach (bool l2 in YP.unify(arg1, Atom.a(","))) | ||
1762 | { | ||
1763 | if (YP.greaterThanOrEqual(Precedence, 1000)) | ||
1764 | { | ||
1765 | foreach (bool l4 in parse(S1, 1000, Next, S2)) | ||
1766 | { | ||
1767 | foreach (bool l5 in exprtl(S2, 1000, new Functor2(",", Term, Next), Precedence, Answer, S)) | ||
1768 | { | ||
1769 | yield return false; | ||
1770 | } | ||
1771 | yield break; | ||
1772 | } | ||
1773 | goto cutIf1; | ||
1774 | } | ||
1775 | foreach (bool l3 in YP.unify(Answer, Term)) | ||
1776 | { | ||
1777 | foreach (bool l4 in YP.unify(S, new ListPair(Atom.a(","), S1))) | ||
1778 | { | ||
1779 | yield return false; | ||
1780 | } | ||
1781 | } | ||
1782 | cutIf1: | ||
1783 | { } | ||
1784 | } | ||
1785 | } | ||
1786 | { | ||
1787 | object Term = arg2; | ||
1788 | object Precedence = arg3; | ||
1789 | object Answer = arg4; | ||
1790 | object S = arg5; | ||
1791 | object S1 = arg6; | ||
1792 | Variable Next = new Variable(); | ||
1793 | Variable S2 = new Variable(); | ||
1794 | foreach (bool l2 in YP.unify(arg1, Atom.a("|"))) | ||
1795 | { | ||
1796 | if (YP.greaterThanOrEqual(Precedence, 1100)) | ||
1797 | { | ||
1798 | foreach (bool l4 in parse(S1, 1100, Next, S2)) | ||
1799 | { | ||
1800 | foreach (bool l5 in exprtl(S2, 1100, new Functor2(";", Term, Next), Precedence, Answer, S)) | ||
1801 | { | ||
1802 | yield return false; | ||
1803 | } | ||
1804 | yield break; | ||
1805 | } | ||
1806 | goto cutIf2; | ||
1807 | } | ||
1808 | foreach (bool l3 in YP.unify(Answer, Term)) | ||
1809 | { | ||
1810 | foreach (bool l4 in YP.unify(S, new ListPair(Atom.a("|"), S1))) | ||
1811 | { | ||
1812 | yield return false; | ||
1813 | } | ||
1814 | } | ||
1815 | cutIf2: | ||
1816 | { } | ||
1817 | } | ||
1818 | } | ||
1819 | { | ||
1820 | object x2 = arg2; | ||
1821 | object x3 = arg3; | ||
1822 | object x4 = arg4; | ||
1823 | object x5 = arg5; | ||
1824 | object S1 = arg6; | ||
1825 | Variable S = new Variable(); | ||
1826 | foreach (bool l2 in YP.unify(arg1, new Functor1("string", S))) | ||
1827 | { | ||
1828 | foreach (bool l3 in cannot_follow(Atom.a("chars"), new Functor1("string", S), S1)) | ||
1829 | { | ||
1830 | yield return false; | ||
1831 | } | ||
1832 | } | ||
1833 | } | ||
1834 | { | ||
1835 | object x2 = arg2; | ||
1836 | object x3 = arg3; | ||
1837 | object x4 = arg4; | ||
1838 | object x5 = arg5; | ||
1839 | object S1 = arg6; | ||
1840 | Variable N = new Variable(); | ||
1841 | foreach (bool l2 in YP.unify(arg1, new Functor1("number", N))) | ||
1842 | { | ||
1843 | foreach (bool l3 in cannot_follow(Atom.a("number"), new Functor1("number", N), S1)) | ||
1844 | { | ||
1845 | yield return false; | ||
1846 | } | ||
1847 | } | ||
1848 | } | ||
1849 | { | ||
1850 | object Term = arg2; | ||
1851 | object Precedence = arg3; | ||
1852 | object Answer = arg4; | ||
1853 | object S = arg5; | ||
1854 | Variable S1 = new Variable(); | ||
1855 | foreach (bool l2 in YP.unify(arg1, Atom.a("{"))) | ||
1856 | { | ||
1857 | foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a("}"), S1))) | ||
1858 | { | ||
1859 | foreach (bool l4 in exprtl0_atom(Atom.a("{}"), Term, Precedence, Answer, S, S1)) | ||
1860 | { | ||
1861 | yield return false; | ||
1862 | } | ||
1863 | yield break; | ||
1864 | } | ||
1865 | } | ||
1866 | } | ||
1867 | { | ||
1868 | object x1 = arg2; | ||
1869 | object x2 = arg3; | ||
1870 | object x3 = arg4; | ||
1871 | object x4 = arg5; | ||
1872 | object S1 = arg6; | ||
1873 | foreach (bool l2 in YP.unify(arg1, Atom.a("{"))) | ||
1874 | { | ||
1875 | foreach (bool l3 in cannot_follow(Atom.a("brace"), Atom.a("{"), S1)) | ||
1876 | { | ||
1877 | yield return false; | ||
1878 | } | ||
1879 | } | ||
1880 | } | ||
1881 | { | ||
1882 | object Term = arg2; | ||
1883 | object Precedence = arg3; | ||
1884 | object Answer = arg4; | ||
1885 | object S = arg5; | ||
1886 | Variable S1 = new Variable(); | ||
1887 | foreach (bool l2 in YP.unify(arg1, Atom.a("["))) | ||
1888 | { | ||
1889 | foreach (bool l3 in YP.unify(arg6, new ListPair(Atom.a("]"), S1))) | ||
1890 | { | ||
1891 | foreach (bool l4 in exprtl0_atom(Atom.NIL, Term, Precedence, Answer, S, S1)) | ||
1892 | { | ||
1893 | yield return false; | ||
1894 | } | ||
1895 | yield break; | ||
1896 | } | ||
1897 | } | ||
1898 | } | ||
1899 | { | ||
1900 | object x1 = arg2; | ||
1901 | object x2 = arg3; | ||
1902 | object x3 = arg4; | ||
1903 | object x4 = arg5; | ||
1904 | object S1 = arg6; | ||
1905 | foreach (bool l2 in YP.unify(arg1, Atom.a("["))) | ||
1906 | { | ||
1907 | foreach (bool l3 in cannot_follow(Atom.a("bracket"), Atom.a("["), S1)) | ||
1908 | { | ||
1909 | yield return false; | ||
1910 | } | ||
1911 | } | ||
1912 | } | ||
1913 | { | ||
1914 | object x1 = arg2; | ||
1915 | object x2 = arg3; | ||
1916 | object x3 = arg4; | ||
1917 | object x4 = arg5; | ||
1918 | object S1 = arg6; | ||
1919 | foreach (bool l2 in YP.unify(arg1, Atom.a("("))) | ||
1920 | { | ||
1921 | foreach (bool l3 in cannot_follow(Atom.a("parenthesis"), Atom.a("("), S1)) | ||
1922 | { | ||
1923 | yield return false; | ||
1924 | } | ||
1925 | } | ||
1926 | } | ||
1927 | { | ||
1928 | object x1 = arg2; | ||
1929 | object x2 = arg3; | ||
1930 | object x3 = arg4; | ||
1931 | object x4 = arg5; | ||
1932 | object S1 = arg6; | ||
1933 | foreach (bool l2 in YP.unify(arg1, Atom.a(" ("))) | ||
1934 | { | ||
1935 | foreach (bool l3 in cannot_follow(Atom.a("parenthesis"), Atom.a("("), S1)) | ||
1936 | { | ||
1937 | yield return false; | ||
1938 | } | ||
1939 | } | ||
1940 | } | ||
1941 | { | ||
1942 | object x4 = arg2; | ||
1943 | object x5 = arg3; | ||
1944 | object x6 = arg4; | ||
1945 | object x7 = arg5; | ||
1946 | object S1 = arg6; | ||
1947 | Variable A = new Variable(); | ||
1948 | Variable B = new Variable(); | ||
1949 | Variable P = new Variable(); | ||
1950 | foreach (bool l2 in YP.unify(arg1, new Functor3("var", A, B, P))) | ||
1951 | { | ||
1952 | foreach (bool l3 in cannot_follow(Atom.a("variable"), new Functor3("var", A, B, P), S1)) | ||
1953 | { | ||
1954 | yield return false; | ||
1955 | } | ||
1956 | } | ||
1957 | } | ||
1958 | { | ||
1959 | object Term = arg2; | ||
1960 | object Precedence = arg3; | ||
1961 | object Answer = arg4; | ||
1962 | object S = arg5; | ||
1963 | object S1 = arg6; | ||
1964 | Variable F = new Variable(); | ||
1965 | Variable P = new Variable(); | ||
1966 | foreach (bool l2 in YP.unify(arg1, new Functor2("atom", F, P))) | ||
1967 | { | ||
1968 | foreach (bool l3 in exprtl0_atom(new Functor2("/", F, P), Term, Precedence, Answer, S, S1)) | ||
1969 | { | ||
1970 | yield return false; | ||
1971 | } | ||
1972 | } | ||
1973 | } | ||
1974 | } | ||
1975 | |||
1976 | public static IEnumerable<bool> exprtl0_atom(object arg1, object arg2, object arg3, object arg4, object arg5, object S1) | ||
1977 | { | ||
1978 | { | ||
1979 | object Term = arg2; | ||
1980 | object Precedence = arg3; | ||
1981 | object Answer = arg4; | ||
1982 | object S = arg5; | ||
1983 | Variable F = new Variable(); | ||
1984 | Variable Pos = new Variable(); | ||
1985 | Variable L1 = new Variable(); | ||
1986 | Variable O1 = new Variable(); | ||
1987 | Variable R1 = new Variable(); | ||
1988 | Variable L2 = new Variable(); | ||
1989 | Variable O2 = new Variable(); | ||
1990 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", F, Pos))) | ||
1991 | { | ||
1992 | foreach (bool l3 in ambigop(F, Precedence, L1, O1, R1, L2, O2)) | ||
1993 | { | ||
1994 | foreach (bool l4 in prefix_is_atom(S1, Precedence)) | ||
1995 | { | ||
1996 | foreach (bool l5 in exprtl(new ListPair(new Functor3(Atom.a("postfixop", Atom.a("")), new Functor2("/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) | ||
1997 | { | ||
1998 | yield return false; | ||
1999 | } | ||
2000 | yield break; | ||
2001 | } | ||
2002 | foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a("infixop", Atom.a("")), new object[] { new Functor2("/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) | ||
2003 | { | ||
2004 | yield return false; | ||
2005 | } | ||
2006 | foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a("postfixop", Atom.a("")), new Functor2("/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) | ||
2007 | { | ||
2008 | yield return false; | ||
2009 | } | ||
2010 | yield break; | ||
2011 | } | ||
2012 | } | ||
2013 | } | ||
2014 | { | ||
2015 | object Term = arg2; | ||
2016 | object Precedence = arg3; | ||
2017 | object Answer = arg4; | ||
2018 | object S = arg5; | ||
2019 | Variable F = new Variable(); | ||
2020 | Variable Pos = new Variable(); | ||
2021 | Variable L1 = new Variable(); | ||
2022 | Variable O1 = new Variable(); | ||
2023 | Variable R1 = new Variable(); | ||
2024 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", F, Pos))) | ||
2025 | { | ||
2026 | foreach (bool l3 in infixop(F, L1, O1, R1)) | ||
2027 | { | ||
2028 | foreach (bool l4 in exprtl(new ListPair(new Functor(Atom.a("infixop", Atom.a("")), new object[] { new Functor2("/", F, Pos), L1, O1, R1 }), S1), 0, Term, Precedence, Answer, S)) | ||
2029 | { | ||
2030 | yield return false; | ||
2031 | } | ||
2032 | yield break; | ||
2033 | } | ||
2034 | } | ||
2035 | } | ||
2036 | { | ||
2037 | object Term = arg2; | ||
2038 | object Precedence = arg3; | ||
2039 | object Answer = arg4; | ||
2040 | object S = arg5; | ||
2041 | Variable F = new Variable(); | ||
2042 | Variable Pos = new Variable(); | ||
2043 | Variable L2 = new Variable(); | ||
2044 | Variable O2 = new Variable(); | ||
2045 | foreach (bool l2 in YP.unify(arg1, new Functor2("/", F, Pos))) | ||
2046 | { | ||
2047 | foreach (bool l3 in postfixop(F, L2, O2)) | ||
2048 | { | ||
2049 | foreach (bool l4 in exprtl(new ListPair(new Functor3(Atom.a("postfixop", Atom.a("")), new Functor2("/", F, Pos), L2, O2), S1), 0, Term, Precedence, Answer, S)) | ||
2050 | { | ||
2051 | yield return false; | ||
2052 | } | ||
2053 | yield break; | ||
2054 | } | ||
2055 | } | ||
2056 | } | ||
2057 | { | ||
2058 | object X = arg1; | ||
2059 | object x2 = arg2; | ||
2060 | object x3 = arg3; | ||
2061 | object x4 = arg4; | ||
2062 | object x5 = arg5; | ||
2063 | Variable x7 = new Variable(); | ||
2064 | foreach (bool l2 in syntax_error(ListPair.make(new object[] { new Functor2("-", Atom.a("non"), Atom.a("operator")), X, Atom.a("follows"), Atom.a("expression") }), new ListPair(new Functor2("atom", X, x7), S1))) | ||
2065 | { | ||
2066 | yield return false; | ||
2067 | } | ||
2068 | yield break; | ||
2069 | } | ||
2070 | } | ||
2071 | |||
2072 | public static IEnumerable<bool> cannot_follow(object Type, object Token, object Tokens) | ||
2073 | { | ||
2074 | { | ||
2075 | foreach (bool l2 in syntax_error(ListPair.make(new object[] { Type, Atom.a("follows"), Atom.a("expression") }), new ListPair(Token, Tokens))) | ||
2076 | { | ||
2077 | yield return false; | ||
2078 | } | ||
2079 | } | ||
2080 | } | ||
2081 | |||
2082 | public static IEnumerable<bool> exprtl(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) | ||
2083 | { | ||
2084 | { | ||
2085 | object x1 = arg2; | ||
2086 | object x3 = arg4; | ||
2087 | Variable Term = new Variable(); | ||
2088 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
2089 | { | ||
2090 | foreach (bool l3 in YP.unify(arg3, Term)) | ||
2091 | { | ||
2092 | foreach (bool l4 in YP.unify(arg5, Term)) | ||
2093 | { | ||
2094 | foreach (bool l5 in YP.unify(arg6, Atom.NIL)) | ||
2095 | { | ||
2096 | yield return false; | ||
2097 | } | ||
2098 | } | ||
2099 | } | ||
2100 | } | ||
2101 | } | ||
2102 | { | ||
2103 | object C = arg2; | ||
2104 | object Term = arg3; | ||
2105 | object Precedence = arg4; | ||
2106 | object Answer = arg5; | ||
2107 | object S = arg6; | ||
2108 | Variable Token = new Variable(); | ||
2109 | Variable Tokens = new Variable(); | ||
2110 | foreach (bool l2 in YP.unify(arg1, new ListPair(Token, Tokens))) | ||
2111 | { | ||
2112 | foreach (bool l3 in exprtl_7(Token, C, Term, Precedence, Answer, S, Tokens)) | ||
2113 | { | ||
2114 | yield return false; | ||
2115 | } | ||
2116 | } | ||
2117 | } | ||
2118 | } | ||
2119 | |||
2120 | public static IEnumerable<bool> exprtl_7(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6, object arg7) | ||
2121 | { | ||
2122 | { | ||
2123 | object C = arg2; | ||
2124 | object Term = arg3; | ||
2125 | object Precedence = arg4; | ||
2126 | object Answer = arg5; | ||
2127 | object S = arg6; | ||
2128 | object S1 = arg7; | ||
2129 | Variable F = new Variable(); | ||
2130 | Variable Pos = new Variable(); | ||
2131 | Variable L = new Variable(); | ||
2132 | Variable O = new Variable(); | ||
2133 | Variable R = new Variable(); | ||
2134 | Variable Other = new Variable(); | ||
2135 | Variable S2 = new Variable(); | ||
2136 | Variable Expr = new Variable(); | ||
2137 | foreach (bool l2 in YP.unify(arg1, new Functor(Atom.a("infixop", Atom.a("")), new object[] { new Functor2("/", F, Pos), L, O, R }))) | ||
2138 | { | ||
2139 | if (YP.greaterThanOrEqual(Precedence, O)) | ||
2140 | { | ||
2141 | if (YP.lessThanOrEqual(C, L)) | ||
2142 | { | ||
2143 | foreach (bool l5 in parse(S1, R, Other, S2)) | ||
2144 | { | ||
2145 | foreach (bool l6 in YP.univ(Expr, ListPair.make(new object[] { F, Pos, Term, Other }))) | ||
2146 | { | ||
2147 | foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) | ||
2148 | { | ||
2149 | yield return false; | ||
2150 | } | ||
2151 | } | ||
2152 | } | ||
2153 | yield break; | ||
2154 | } | ||
2155 | } | ||
2156 | } | ||
2157 | } | ||
2158 | { | ||
2159 | object C = arg2; | ||
2160 | object Term = arg3; | ||
2161 | object Precedence = arg4; | ||
2162 | object Answer = arg5; | ||
2163 | object S = arg6; | ||
2164 | object S1 = arg7; | ||
2165 | Variable F = new Variable(); | ||
2166 | Variable Pos = new Variable(); | ||
2167 | Variable L = new Variable(); | ||
2168 | Variable O = new Variable(); | ||
2169 | Variable Expr = new Variable(); | ||
2170 | Variable S2 = new Variable(); | ||
2171 | foreach (bool l2 in YP.unify(arg1, new Functor3(Atom.a("postfixop", Atom.a("")), new Functor2("/", F, Pos), L, O))) | ||
2172 | { | ||
2173 | if (YP.greaterThanOrEqual(Precedence, O)) | ||
2174 | { | ||
2175 | if (YP.lessThanOrEqual(C, L)) | ||
2176 | { | ||
2177 | foreach (bool l5 in YP.univ(Expr, ListPair.make(new object[] { F, Pos, Term }))) | ||
2178 | { | ||
2179 | foreach (bool l6 in peepop(S1, S2)) | ||
2180 | { | ||
2181 | foreach (bool l7 in exprtl(S2, O, Expr, Precedence, Answer, S)) | ||
2182 | { | ||
2183 | yield return false; | ||
2184 | } | ||
2185 | } | ||
2186 | } | ||
2187 | yield break; | ||
2188 | } | ||
2189 | } | ||
2190 | } | ||
2191 | } | ||
2192 | { | ||
2193 | object C = arg2; | ||
2194 | object Term = arg3; | ||
2195 | object Precedence = arg4; | ||
2196 | object Answer = arg5; | ||
2197 | object S = arg6; | ||
2198 | object S1 = arg7; | ||
2199 | Variable Next = new Variable(); | ||
2200 | Variable S2 = new Variable(); | ||
2201 | foreach (bool l2 in YP.unify(arg1, Atom.a(","))) | ||
2202 | { | ||
2203 | if (YP.greaterThanOrEqual(Precedence, 1000)) | ||
2204 | { | ||
2205 | if (YP.lessThan(C, 1000)) | ||
2206 | { | ||
2207 | foreach (bool l5 in parse(S1, 1000, Next, S2)) | ||
2208 | { | ||
2209 | foreach (bool l6 in exprtl(S2, 1000, new Functor2(",", Term, Next), Precedence, Answer, S)) | ||
2210 | { | ||
2211 | yield return false; | ||
2212 | } | ||
2213 | } | ||
2214 | yield break; | ||
2215 | } | ||
2216 | } | ||
2217 | } | ||
2218 | } | ||
2219 | { | ||
2220 | object C = arg2; | ||
2221 | object Term = arg3; | ||
2222 | object Precedence = arg4; | ||
2223 | object Answer = arg5; | ||
2224 | object S = arg6; | ||
2225 | object S1 = arg7; | ||
2226 | Variable Next = new Variable(); | ||
2227 | Variable S2 = new Variable(); | ||
2228 | foreach (bool l2 in YP.unify(arg1, Atom.a("|"))) | ||
2229 | { | ||
2230 | if (YP.greaterThanOrEqual(Precedence, 1100)) | ||
2231 | { | ||
2232 | if (YP.lessThan(C, 1100)) | ||
2233 | { | ||
2234 | foreach (bool l5 in parse(S1, 1100, Next, S2)) | ||
2235 | { | ||
2236 | foreach (bool l6 in exprtl(S2, 1100, new Functor2(";", Term, Next), Precedence, Answer, S)) | ||
2237 | { | ||
2238 | yield return false; | ||
2239 | } | ||
2240 | } | ||
2241 | yield break; | ||
2242 | } | ||
2243 | } | ||
2244 | } | ||
2245 | } | ||
2246 | { | ||
2247 | object Token = arg1; | ||
2248 | object x2 = arg2; | ||
2249 | object x4 = arg4; | ||
2250 | object Tokens = arg7; | ||
2251 | Variable Term = new Variable(); | ||
2252 | foreach (bool l2 in YP.unify(arg3, Term)) | ||
2253 | { | ||
2254 | foreach (bool l3 in YP.unify(arg5, Term)) | ||
2255 | { | ||
2256 | foreach (bool l4 in YP.unify(arg6, new ListPair(Token, Tokens))) | ||
2257 | { | ||
2258 | yield return false; | ||
2259 | } | ||
2260 | } | ||
2261 | } | ||
2262 | } | ||
2263 | } | ||
2264 | |||
2265 | public static IEnumerable<bool> syntax_error(object _Message, object _List) | ||
2266 | { | ||
2267 | { | ||
2268 | yield break; | ||
2269 | } | ||
2270 | foreach (bool l1 in YP.fail()) | ||
2271 | { | ||
2272 | yield return false; | ||
2273 | } | ||
2274 | } | ||
2275 | |||
2276 | public static IEnumerable<bool> syntax_error(object _List) | ||
2277 | { | ||
2278 | { | ||
2279 | yield break; | ||
2280 | } | ||
2281 | foreach (bool l1 in YP.fail()) | ||
2282 | { | ||
2283 | yield return false; | ||
2284 | } | ||
2285 | } | ||
2286 | |||
2287 | public static IEnumerable<bool> prefixop(object F, object O, object Q) | ||
2288 | { | ||
2289 | { | ||
2290 | foreach (bool l2 in YP.current_op(O, Atom.a("fx"), F)) | ||
2291 | { | ||
2292 | foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) | ||
2293 | { | ||
2294 | yield return false; | ||
2295 | } | ||
2296 | goto cutIf1; | ||
2297 | } | ||
2298 | foreach (bool l2 in YP.current_op(O, Atom.a("fy"), F)) | ||
2299 | { | ||
2300 | foreach (bool l3 in YP.unify(Q, O)) | ||
2301 | { | ||
2302 | yield return false; | ||
2303 | } | ||
2304 | goto cutIf2; | ||
2305 | } | ||
2306 | cutIf2: | ||
2307 | cutIf1: | ||
2308 | { } | ||
2309 | } | ||
2310 | } | ||
2311 | |||
2312 | public static IEnumerable<bool> postfixop(object F, object P, object O) | ||
2313 | { | ||
2314 | { | ||
2315 | foreach (bool l2 in YP.current_op(O, Atom.a("xf"), F)) | ||
2316 | { | ||
2317 | foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) | ||
2318 | { | ||
2319 | yield return false; | ||
2320 | } | ||
2321 | goto cutIf1; | ||
2322 | } | ||
2323 | foreach (bool l2 in YP.current_op(O, Atom.a("yf"), F)) | ||
2324 | { | ||
2325 | foreach (bool l3 in YP.unify(P, O)) | ||
2326 | { | ||
2327 | yield return false; | ||
2328 | } | ||
2329 | goto cutIf2; | ||
2330 | } | ||
2331 | cutIf2: | ||
2332 | cutIf1: | ||
2333 | { } | ||
2334 | } | ||
2335 | } | ||
2336 | |||
2337 | public static IEnumerable<bool> infixop(object F, object P, object O, object Q) | ||
2338 | { | ||
2339 | { | ||
2340 | foreach (bool l2 in YP.current_op(O, Atom.a("xfy"), F)) | ||
2341 | { | ||
2342 | foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) | ||
2343 | { | ||
2344 | foreach (bool l4 in YP.unify(Q, O)) | ||
2345 | { | ||
2346 | yield return false; | ||
2347 | } | ||
2348 | } | ||
2349 | goto cutIf1; | ||
2350 | } | ||
2351 | foreach (bool l2 in YP.current_op(O, Atom.a("xfx"), F)) | ||
2352 | { | ||
2353 | foreach (bool l3 in YP.unify(P, YP.subtract(O, 1))) | ||
2354 | { | ||
2355 | foreach (bool l4 in YP.unify(Q, P)) | ||
2356 | { | ||
2357 | yield return false; | ||
2358 | } | ||
2359 | } | ||
2360 | goto cutIf2; | ||
2361 | } | ||
2362 | foreach (bool l2 in YP.current_op(O, Atom.a("yfx"), F)) | ||
2363 | { | ||
2364 | foreach (bool l3 in YP.unify(Q, YP.subtract(O, 1))) | ||
2365 | { | ||
2366 | foreach (bool l4 in YP.unify(P, O)) | ||
2367 | { | ||
2368 | yield return false; | ||
2369 | } | ||
2370 | } | ||
2371 | goto cutIf3; | ||
2372 | } | ||
2373 | cutIf3: | ||
2374 | cutIf2: | ||
2375 | cutIf1: | ||
2376 | { } | ||
2377 | } | ||
2378 | } | ||
2379 | |||
2380 | public static IEnumerable<bool> ambigop(object F, object Precedence, object L1, object O1, object R1, object L2, object O2) | ||
2381 | { | ||
2382 | { | ||
2383 | foreach (bool l2 in postfixop(F, L2, O2)) | ||
2384 | { | ||
2385 | if (YP.lessThanOrEqual(O2, Precedence)) | ||
2386 | { | ||
2387 | foreach (bool l4 in infixop(F, L1, O1, R1)) | ||
2388 | { | ||
2389 | if (YP.lessThanOrEqual(O1, Precedence)) | ||
2390 | { | ||
2391 | yield return false; | ||
2392 | } | ||
2393 | } | ||
2394 | } | ||
2395 | } | ||
2396 | } | ||
2397 | } | ||
2398 | |||
2399 | public static IEnumerable<bool> read_tokens1(object arg1) | ||
2400 | { | ||
2401 | { | ||
2402 | object TokenList = arg1; | ||
2403 | Variable C1 = new Variable(); | ||
2404 | Variable _X = new Variable(); | ||
2405 | Variable ListOfTokens = new Variable(); | ||
2406 | foreach (bool l2 in YP.get_code(C1)) | ||
2407 | { | ||
2408 | foreach (bool l3 in read_tokens(C1, _X, ListOfTokens)) | ||
2409 | { | ||
2410 | foreach (bool l4 in YP.unify(TokenList, ListOfTokens)) | ||
2411 | { | ||
2412 | yield return false; | ||
2413 | } | ||
2414 | yield break; | ||
2415 | } | ||
2416 | } | ||
2417 | } | ||
2418 | { | ||
2419 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("atom", Atom.a("end_of_file"), 0), Atom.NIL))) | ||
2420 | { | ||
2421 | yield return false; | ||
2422 | } | ||
2423 | } | ||
2424 | } | ||
2425 | |||
2426 | public static IEnumerable<bool> read_tokens2(object arg1, object arg2) | ||
2427 | { | ||
2428 | { | ||
2429 | object TokenList = arg1; | ||
2430 | object Dictionary = arg2; | ||
2431 | Variable C1 = new Variable(); | ||
2432 | Variable Dict = new Variable(); | ||
2433 | Variable ListOfTokens = new Variable(); | ||
2434 | foreach (bool l2 in YP.get_code(C1)) | ||
2435 | { | ||
2436 | foreach (bool l3 in read_tokens(C1, Dict, ListOfTokens)) | ||
2437 | { | ||
2438 | foreach (bool l4 in terminate_list(Dict)) | ||
2439 | { | ||
2440 | foreach (bool l5 in YP.unify(Dictionary, Dict)) | ||
2441 | { | ||
2442 | foreach (bool l6 in YP.unify(TokenList, ListOfTokens)) | ||
2443 | { | ||
2444 | yield return false; | ||
2445 | } | ||
2446 | } | ||
2447 | yield break; | ||
2448 | } | ||
2449 | } | ||
2450 | } | ||
2451 | } | ||
2452 | { | ||
2453 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("atom", Atom.a("end_of_file"), 0), Atom.NIL))) | ||
2454 | { | ||
2455 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
2456 | { | ||
2457 | yield return false; | ||
2458 | } | ||
2459 | } | ||
2460 | } | ||
2461 | } | ||
2462 | |||
2463 | public static IEnumerable<bool> terminate_list(object arg1) | ||
2464 | { | ||
2465 | { | ||
2466 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
2467 | { | ||
2468 | yield return false; | ||
2469 | } | ||
2470 | } | ||
2471 | { | ||
2472 | Variable x1 = new Variable(); | ||
2473 | Variable Tail = new Variable(); | ||
2474 | foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Tail))) | ||
2475 | { | ||
2476 | foreach (bool l3 in terminate_list(Tail)) | ||
2477 | { | ||
2478 | yield return false; | ||
2479 | } | ||
2480 | } | ||
2481 | } | ||
2482 | } | ||
2483 | |||
2484 | public static IEnumerable<bool> read_special(object arg1, object Dict, object arg3) | ||
2485 | { | ||
2486 | { | ||
2487 | object Tokens = arg3; | ||
2488 | foreach (bool l2 in YP.unify(arg1, 95)) | ||
2489 | { | ||
2490 | foreach (bool l3 in read_variable(95, Dict, Tokens)) | ||
2491 | { | ||
2492 | yield return false; | ||
2493 | } | ||
2494 | } | ||
2495 | } | ||
2496 | { | ||
2497 | object Tokens = arg3; | ||
2498 | foreach (bool l2 in YP.unify(arg1, 247)) | ||
2499 | { | ||
2500 | foreach (bool l3 in read_symbol(247, Dict, Tokens)) | ||
2501 | { | ||
2502 | yield return false; | ||
2503 | } | ||
2504 | } | ||
2505 | } | ||
2506 | { | ||
2507 | object Tokens = arg3; | ||
2508 | foreach (bool l2 in YP.unify(arg1, 215)) | ||
2509 | { | ||
2510 | foreach (bool l3 in read_symbol(215, Dict, Tokens)) | ||
2511 | { | ||
2512 | yield return false; | ||
2513 | } | ||
2514 | } | ||
2515 | } | ||
2516 | { | ||
2517 | Variable StartPos = new Variable(); | ||
2518 | Variable EndPos = new Variable(); | ||
2519 | Variable Tokens = new Variable(); | ||
2520 | Variable Ch = new Variable(); | ||
2521 | Variable NextCh = new Variable(); | ||
2522 | foreach (bool l2 in YP.unify(arg1, 37)) | ||
2523 | { | ||
2524 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("comment", StartPos, EndPos), Tokens))) | ||
2525 | { | ||
2526 | foreach (bool l4 in get_current_position(StartPos)) | ||
2527 | { | ||
2528 | foreach (bool l5 in YP.repeat()) | ||
2529 | { | ||
2530 | foreach (bool l6 in YP.get_code(Ch)) | ||
2531 | { | ||
2532 | if (YP.lessThan(Ch, new ListPair(32, Atom.NIL))) | ||
2533 | { | ||
2534 | if (YP.notEqual(Ch, 9)) | ||
2535 | { | ||
2536 | if (YP.termNotEqual(Ch, -1)) | ||
2537 | { | ||
2538 | foreach (bool l10 in get_current_position(EndPos)) | ||
2539 | { | ||
2540 | foreach (bool l11 in YP.get_code(NextCh)) | ||
2541 | { | ||
2542 | foreach (bool l12 in read_tokens(NextCh, Dict, Tokens)) | ||
2543 | { | ||
2544 | yield return false; | ||
2545 | } | ||
2546 | } | ||
2547 | } | ||
2548 | } | ||
2549 | yield break; | ||
2550 | } | ||
2551 | } | ||
2552 | } | ||
2553 | } | ||
2554 | } | ||
2555 | } | ||
2556 | } | ||
2557 | } | ||
2558 | { | ||
2559 | object T = arg3; | ||
2560 | Variable C2 = new Variable(); | ||
2561 | Variable StartPos = new Variable(); | ||
2562 | Variable EndPos = new Variable(); | ||
2563 | Variable Tokens = new Variable(); | ||
2564 | Variable StartPos1 = new Variable(); | ||
2565 | Variable NextCh = new Variable(); | ||
2566 | Variable Chars = new Variable(); | ||
2567 | foreach (bool l2 in YP.unify(arg1, 47)) | ||
2568 | { | ||
2569 | foreach (bool l3 in YP.get_code(C2)) | ||
2570 | { | ||
2571 | if (YP.equal(C2, new ListPair(42, Atom.NIL))) | ||
2572 | { | ||
2573 | foreach (bool l5 in YP.unify(T, new ListPair(new Functor2("comment", StartPos, EndPos), Tokens))) | ||
2574 | { | ||
2575 | foreach (bool l6 in get_current_position(StartPos1)) | ||
2576 | { | ||
2577 | foreach (bool l7 in YP.unify(StartPos, YP.subtract(StartPos1, 1))) | ||
2578 | { | ||
2579 | foreach (bool l8 in read_solidus(32, NextCh)) | ||
2580 | { | ||
2581 | foreach (bool l9 in get_current_position(EndPos)) | ||
2582 | { | ||
2583 | foreach (bool l10 in read_tokens(NextCh, Dict, Tokens)) | ||
2584 | { | ||
2585 | yield return false; | ||
2586 | } | ||
2587 | } | ||
2588 | } | ||
2589 | } | ||
2590 | } | ||
2591 | } | ||
2592 | goto cutIf1; | ||
2593 | } | ||
2594 | foreach (bool l4 in YP.unify(T, Tokens)) | ||
2595 | { | ||
2596 | foreach (bool l5 in rest_symbol(C2, Chars, NextCh)) | ||
2597 | { | ||
2598 | foreach (bool l6 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(47, Chars))) | ||
2599 | { | ||
2600 | yield return false; | ||
2601 | } | ||
2602 | } | ||
2603 | } | ||
2604 | cutIf1: | ||
2605 | { } | ||
2606 | } | ||
2607 | } | ||
2608 | } | ||
2609 | { | ||
2610 | Variable Pos = new Variable(); | ||
2611 | Variable Tokens = new Variable(); | ||
2612 | Variable NextCh = new Variable(); | ||
2613 | foreach (bool l2 in YP.unify(arg1, 33)) | ||
2614 | { | ||
2615 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("atom", Atom.a("!"), Pos), Tokens))) | ||
2616 | { | ||
2617 | foreach (bool l4 in get_current_position(Pos)) | ||
2618 | { | ||
2619 | foreach (bool l5 in YP.get_code(NextCh)) | ||
2620 | { | ||
2621 | foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) | ||
2622 | { | ||
2623 | yield return false; | ||
2624 | } | ||
2625 | } | ||
2626 | } | ||
2627 | } | ||
2628 | } | ||
2629 | } | ||
2630 | { | ||
2631 | Variable Tokens = new Variable(); | ||
2632 | Variable NextCh = new Variable(); | ||
2633 | foreach (bool l2 in YP.unify(arg1, 40)) | ||
2634 | { | ||
2635 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(" ("), Tokens))) | ||
2636 | { | ||
2637 | foreach (bool l4 in YP.get_code(NextCh)) | ||
2638 | { | ||
2639 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
2640 | { | ||
2641 | yield return false; | ||
2642 | } | ||
2643 | } | ||
2644 | } | ||
2645 | } | ||
2646 | } | ||
2647 | { | ||
2648 | Variable Tokens = new Variable(); | ||
2649 | Variable NextCh = new Variable(); | ||
2650 | foreach (bool l2 in YP.unify(arg1, 41)) | ||
2651 | { | ||
2652 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(")"), Tokens))) | ||
2653 | { | ||
2654 | foreach (bool l4 in YP.get_code(NextCh)) | ||
2655 | { | ||
2656 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
2657 | { | ||
2658 | yield return false; | ||
2659 | } | ||
2660 | } | ||
2661 | } | ||
2662 | } | ||
2663 | } | ||
2664 | { | ||
2665 | Variable Tokens = new Variable(); | ||
2666 | Variable NextCh = new Variable(); | ||
2667 | foreach (bool l2 in YP.unify(arg1, 44)) | ||
2668 | { | ||
2669 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a(","), Tokens))) | ||
2670 | { | ||
2671 | foreach (bool l4 in YP.get_code(NextCh)) | ||
2672 | { | ||
2673 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
2674 | { | ||
2675 | yield return false; | ||
2676 | } | ||
2677 | } | ||
2678 | } | ||
2679 | } | ||
2680 | } | ||
2681 | { | ||
2682 | Variable Pos = new Variable(); | ||
2683 | Variable Tokens = new Variable(); | ||
2684 | Variable NextCh = new Variable(); | ||
2685 | foreach (bool l2 in YP.unify(arg1, 59)) | ||
2686 | { | ||
2687 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("atom", Atom.a(";"), Pos), Tokens))) | ||
2688 | { | ||
2689 | foreach (bool l4 in get_current_position(Pos)) | ||
2690 | { | ||
2691 | foreach (bool l5 in YP.get_code(NextCh)) | ||
2692 | { | ||
2693 | foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) | ||
2694 | { | ||
2695 | yield return false; | ||
2696 | } | ||
2697 | } | ||
2698 | } | ||
2699 | } | ||
2700 | } | ||
2701 | } | ||
2702 | { | ||
2703 | Variable Pos = new Variable(); | ||
2704 | Variable Tokens = new Variable(); | ||
2705 | Variable NextCh = new Variable(); | ||
2706 | foreach (bool l2 in YP.unify(arg1, 91)) | ||
2707 | { | ||
2708 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("/", Atom.a("["), Pos), Tokens))) | ||
2709 | { | ||
2710 | foreach (bool l4 in get_current_position(Pos)) | ||
2711 | { | ||
2712 | foreach (bool l5 in YP.get_code(NextCh)) | ||
2713 | { | ||
2714 | foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) | ||
2715 | { | ||
2716 | yield return false; | ||
2717 | } | ||
2718 | } | ||
2719 | } | ||
2720 | } | ||
2721 | } | ||
2722 | } | ||
2723 | { | ||
2724 | Variable Pos = new Variable(); | ||
2725 | Variable Tokens = new Variable(); | ||
2726 | Variable NextCh = new Variable(); | ||
2727 | foreach (bool l2 in YP.unify(arg1, 93)) | ||
2728 | { | ||
2729 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("/", Atom.a("]"), Pos), Tokens))) | ||
2730 | { | ||
2731 | foreach (bool l4 in get_current_position(Pos)) | ||
2732 | { | ||
2733 | foreach (bool l5 in YP.get_code(NextCh)) | ||
2734 | { | ||
2735 | foreach (bool l6 in read_after_atom(NextCh, Dict, Tokens)) | ||
2736 | { | ||
2737 | yield return false; | ||
2738 | } | ||
2739 | } | ||
2740 | } | ||
2741 | } | ||
2742 | } | ||
2743 | } | ||
2744 | { | ||
2745 | Variable Pos = new Variable(); | ||
2746 | Variable Tokens = new Variable(); | ||
2747 | Variable NextCh = new Variable(); | ||
2748 | foreach (bool l2 in YP.unify(arg1, 123)) | ||
2749 | { | ||
2750 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("/", Atom.a("{"), Pos), Tokens))) | ||
2751 | { | ||
2752 | foreach (bool l4 in get_current_position(Pos)) | ||
2753 | { | ||
2754 | foreach (bool l5 in YP.get_code(NextCh)) | ||
2755 | { | ||
2756 | foreach (bool l6 in read_tokens(NextCh, Dict, Tokens)) | ||
2757 | { | ||
2758 | yield return false; | ||
2759 | } | ||
2760 | } | ||
2761 | } | ||
2762 | } | ||
2763 | } | ||
2764 | } | ||
2765 | { | ||
2766 | Variable Tokens = new Variable(); | ||
2767 | Variable NextCh = new Variable(); | ||
2768 | foreach (bool l2 in YP.unify(arg1, 124)) | ||
2769 | { | ||
2770 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("|"), Tokens))) | ||
2771 | { | ||
2772 | foreach (bool l4 in YP.get_code(NextCh)) | ||
2773 | { | ||
2774 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
2775 | { | ||
2776 | yield return false; | ||
2777 | } | ||
2778 | } | ||
2779 | } | ||
2780 | } | ||
2781 | } | ||
2782 | { | ||
2783 | Variable Tokens = new Variable(); | ||
2784 | Variable NextCh = new Variable(); | ||
2785 | foreach (bool l2 in YP.unify(arg1, 125)) | ||
2786 | { | ||
2787 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("}"), Tokens))) | ||
2788 | { | ||
2789 | foreach (bool l4 in YP.get_code(NextCh)) | ||
2790 | { | ||
2791 | foreach (bool l5 in read_after_atom(NextCh, Dict, Tokens)) | ||
2792 | { | ||
2793 | yield return false; | ||
2794 | } | ||
2795 | } | ||
2796 | } | ||
2797 | } | ||
2798 | } | ||
2799 | { | ||
2800 | object Tokens = arg3; | ||
2801 | Variable NextCh = new Variable(); | ||
2802 | foreach (bool l2 in YP.unify(arg1, 46)) | ||
2803 | { | ||
2804 | foreach (bool l3 in YP.get_code(NextCh)) | ||
2805 | { | ||
2806 | foreach (bool l4 in read_fullstop(NextCh, Dict, Tokens)) | ||
2807 | { | ||
2808 | yield return false; | ||
2809 | } | ||
2810 | } | ||
2811 | } | ||
2812 | } | ||
2813 | { | ||
2814 | Variable Chars = new Variable(); | ||
2815 | Variable Tokens = new Variable(); | ||
2816 | Variable NextCh = new Variable(); | ||
2817 | foreach (bool l2 in YP.unify(arg1, 34)) | ||
2818 | { | ||
2819 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1("string", Chars), Tokens))) | ||
2820 | { | ||
2821 | foreach (bool l4 in read_string(Chars, 34, NextCh)) | ||
2822 | { | ||
2823 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
2824 | { | ||
2825 | yield return false; | ||
2826 | } | ||
2827 | } | ||
2828 | } | ||
2829 | } | ||
2830 | } | ||
2831 | { | ||
2832 | object Tokens = arg3; | ||
2833 | Variable Chars = new Variable(); | ||
2834 | Variable NextCh = new Variable(); | ||
2835 | foreach (bool l2 in YP.unify(arg1, 39)) | ||
2836 | { | ||
2837 | foreach (bool l3 in read_string(Chars, 39, NextCh)) | ||
2838 | { | ||
2839 | foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, Chars)) | ||
2840 | { | ||
2841 | yield return false; | ||
2842 | } | ||
2843 | } | ||
2844 | } | ||
2845 | } | ||
2846 | { | ||
2847 | object Tokens = arg3; | ||
2848 | foreach (bool l2 in YP.unify(arg1, 35)) | ||
2849 | { | ||
2850 | foreach (bool l3 in read_symbol(35, Dict, Tokens)) | ||
2851 | { | ||
2852 | yield return false; | ||
2853 | } | ||
2854 | } | ||
2855 | } | ||
2856 | { | ||
2857 | object Tokens = arg3; | ||
2858 | foreach (bool l2 in YP.unify(arg1, 36)) | ||
2859 | { | ||
2860 | foreach (bool l3 in read_symbol(36, Dict, Tokens)) | ||
2861 | { | ||
2862 | yield return false; | ||
2863 | } | ||
2864 | } | ||
2865 | } | ||
2866 | { | ||
2867 | object Tokens = arg3; | ||
2868 | foreach (bool l2 in YP.unify(arg1, 38)) | ||
2869 | { | ||
2870 | foreach (bool l3 in read_symbol(38, Dict, Tokens)) | ||
2871 | { | ||
2872 | yield return false; | ||
2873 | } | ||
2874 | } | ||
2875 | } | ||
2876 | { | ||
2877 | object Tokens = arg3; | ||
2878 | foreach (bool l2 in YP.unify(arg1, 42)) | ||
2879 | { | ||
2880 | foreach (bool l3 in read_symbol(42, Dict, Tokens)) | ||
2881 | { | ||
2882 | yield return false; | ||
2883 | } | ||
2884 | } | ||
2885 | } | ||
2886 | { | ||
2887 | object Tokens = arg3; | ||
2888 | foreach (bool l2 in YP.unify(arg1, 43)) | ||
2889 | { | ||
2890 | foreach (bool l3 in read_symbol(43, Dict, Tokens)) | ||
2891 | { | ||
2892 | yield return false; | ||
2893 | } | ||
2894 | } | ||
2895 | } | ||
2896 | { | ||
2897 | object Tokens = arg3; | ||
2898 | foreach (bool l2 in YP.unify(arg1, 45)) | ||
2899 | { | ||
2900 | foreach (bool l3 in read_symbol(45, Dict, Tokens)) | ||
2901 | { | ||
2902 | yield return false; | ||
2903 | } | ||
2904 | } | ||
2905 | } | ||
2906 | { | ||
2907 | object Tokens = arg3; | ||
2908 | foreach (bool l2 in YP.unify(arg1, 58)) | ||
2909 | { | ||
2910 | foreach (bool l3 in read_symbol(58, Dict, Tokens)) | ||
2911 | { | ||
2912 | yield return false; | ||
2913 | } | ||
2914 | } | ||
2915 | } | ||
2916 | { | ||
2917 | object Tokens = arg3; | ||
2918 | foreach (bool l2 in YP.unify(arg1, 60)) | ||
2919 | { | ||
2920 | foreach (bool l3 in read_symbol(60, Dict, Tokens)) | ||
2921 | { | ||
2922 | yield return false; | ||
2923 | } | ||
2924 | } | ||
2925 | } | ||
2926 | { | ||
2927 | object Tokens = arg3; | ||
2928 | foreach (bool l2 in YP.unify(arg1, 61)) | ||
2929 | { | ||
2930 | foreach (bool l3 in read_symbol(61, Dict, Tokens)) | ||
2931 | { | ||
2932 | yield return false; | ||
2933 | } | ||
2934 | } | ||
2935 | } | ||
2936 | { | ||
2937 | object Tokens = arg3; | ||
2938 | foreach (bool l2 in YP.unify(arg1, 62)) | ||
2939 | { | ||
2940 | foreach (bool l3 in read_symbol(62, Dict, Tokens)) | ||
2941 | { | ||
2942 | yield return false; | ||
2943 | } | ||
2944 | } | ||
2945 | } | ||
2946 | { | ||
2947 | object Tokens = arg3; | ||
2948 | foreach (bool l2 in YP.unify(arg1, 63)) | ||
2949 | { | ||
2950 | foreach (bool l3 in read_symbol(63, Dict, Tokens)) | ||
2951 | { | ||
2952 | yield return false; | ||
2953 | } | ||
2954 | } | ||
2955 | } | ||
2956 | { | ||
2957 | object Tokens = arg3; | ||
2958 | foreach (bool l2 in YP.unify(arg1, 64)) | ||
2959 | { | ||
2960 | foreach (bool l3 in read_symbol(64, Dict, Tokens)) | ||
2961 | { | ||
2962 | yield return false; | ||
2963 | } | ||
2964 | } | ||
2965 | } | ||
2966 | { | ||
2967 | object Tokens = arg3; | ||
2968 | foreach (bool l2 in YP.unify(arg1, 92)) | ||
2969 | { | ||
2970 | foreach (bool l3 in read_symbol(92, Dict, Tokens)) | ||
2971 | { | ||
2972 | yield return false; | ||
2973 | } | ||
2974 | } | ||
2975 | } | ||
2976 | { | ||
2977 | object Tokens = arg3; | ||
2978 | foreach (bool l2 in YP.unify(arg1, 94)) | ||
2979 | { | ||
2980 | foreach (bool l3 in read_symbol(94, Dict, Tokens)) | ||
2981 | { | ||
2982 | yield return false; | ||
2983 | } | ||
2984 | } | ||
2985 | } | ||
2986 | { | ||
2987 | object Tokens = arg3; | ||
2988 | foreach (bool l2 in YP.unify(arg1, 96)) | ||
2989 | { | ||
2990 | foreach (bool l3 in read_symbol(96, Dict, Tokens)) | ||
2991 | { | ||
2992 | yield return false; | ||
2993 | } | ||
2994 | } | ||
2995 | } | ||
2996 | { | ||
2997 | object Tokens = arg3; | ||
2998 | foreach (bool l2 in YP.unify(arg1, 126)) | ||
2999 | { | ||
3000 | foreach (bool l3 in read_symbol(126, Dict, Tokens)) | ||
3001 | { | ||
3002 | yield return false; | ||
3003 | } | ||
3004 | } | ||
3005 | } | ||
3006 | } | ||
3007 | |||
3008 | public static IEnumerable<bool> read_symbol(object C1, object Dict, object Tokens) | ||
3009 | { | ||
3010 | { | ||
3011 | Variable C2 = new Variable(); | ||
3012 | Variable Chars = new Variable(); | ||
3013 | Variable NextCh = new Variable(); | ||
3014 | foreach (bool l2 in YP.get_code(C2)) | ||
3015 | { | ||
3016 | foreach (bool l3 in rest_symbol(C2, Chars, NextCh)) | ||
3017 | { | ||
3018 | foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(C1, Chars))) | ||
3019 | { | ||
3020 | yield return false; | ||
3021 | } | ||
3022 | } | ||
3023 | } | ||
3024 | } | ||
3025 | } | ||
3026 | |||
3027 | public static IEnumerable<bool> rest_symbol(object arg1, object arg2, object arg3) | ||
3028 | { | ||
3029 | { | ||
3030 | object C2 = arg1; | ||
3031 | object LastCh = arg3; | ||
3032 | Variable Chars = new Variable(); | ||
3033 | Variable NextCh = new Variable(); | ||
3034 | foreach (bool l2 in YP.unify(arg2, new ListPair(C2, Chars))) | ||
3035 | { | ||
3036 | if (YP.greaterThan(C2, 160)) | ||
3037 | { | ||
3038 | if (YP.lessThan(C2, 192)) | ||
3039 | { | ||
3040 | if (YP.notEqual(C2, 186)) | ||
3041 | { | ||
3042 | if (YP.notEqual(C2, 170)) | ||
3043 | { | ||
3044 | foreach (bool l7 in YP.get_code(NextCh)) | ||
3045 | { | ||
3046 | foreach (bool l8 in rest_symbol(NextCh, Chars, LastCh)) | ||
3047 | { | ||
3048 | yield return false; | ||
3049 | } | ||
3050 | } | ||
3051 | yield break; | ||
3052 | } | ||
3053 | } | ||
3054 | } | ||
3055 | goto cutIf1; | ||
3056 | } | ||
3057 | foreach (bool l3 in symbol_char(C2)) | ||
3058 | { | ||
3059 | foreach (bool l4 in YP.get_code(NextCh)) | ||
3060 | { | ||
3061 | foreach (bool l5 in rest_symbol(NextCh, Chars, LastCh)) | ||
3062 | { | ||
3063 | yield return false; | ||
3064 | } | ||
3065 | } | ||
3066 | yield break; | ||
3067 | } | ||
3068 | cutIf1: | ||
3069 | { } | ||
3070 | } | ||
3071 | } | ||
3072 | { | ||
3073 | Variable C2 = new Variable(); | ||
3074 | foreach (bool l2 in YP.unify(arg1, C2)) | ||
3075 | { | ||
3076 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
3077 | { | ||
3078 | foreach (bool l4 in YP.unify(arg3, C2)) | ||
3079 | { | ||
3080 | yield return false; | ||
3081 | } | ||
3082 | } | ||
3083 | } | ||
3084 | } | ||
3085 | } | ||
3086 | |||
3087 | public static IEnumerable<bool> symbol_char(object arg1) | ||
3088 | { | ||
3089 | { | ||
3090 | foreach (bool l2 in YP.unify(arg1, 35)) | ||
3091 | { | ||
3092 | yield return false; | ||
3093 | } | ||
3094 | } | ||
3095 | { | ||
3096 | foreach (bool l2 in YP.unify(arg1, 36)) | ||
3097 | { | ||
3098 | yield return false; | ||
3099 | } | ||
3100 | } | ||
3101 | { | ||
3102 | foreach (bool l2 in YP.unify(arg1, 38)) | ||
3103 | { | ||
3104 | yield return false; | ||
3105 | } | ||
3106 | } | ||
3107 | { | ||
3108 | foreach (bool l2 in YP.unify(arg1, 42)) | ||
3109 | { | ||
3110 | yield return false; | ||
3111 | } | ||
3112 | } | ||
3113 | { | ||
3114 | foreach (bool l2 in YP.unify(arg1, 43)) | ||
3115 | { | ||
3116 | yield return false; | ||
3117 | } | ||
3118 | } | ||
3119 | { | ||
3120 | foreach (bool l2 in YP.unify(arg1, 45)) | ||
3121 | { | ||
3122 | yield return false; | ||
3123 | } | ||
3124 | } | ||
3125 | { | ||
3126 | foreach (bool l2 in YP.unify(arg1, 46)) | ||
3127 | { | ||
3128 | yield return false; | ||
3129 | } | ||
3130 | } | ||
3131 | { | ||
3132 | foreach (bool l2 in YP.unify(arg1, 47)) | ||
3133 | { | ||
3134 | yield return false; | ||
3135 | } | ||
3136 | } | ||
3137 | { | ||
3138 | foreach (bool l2 in YP.unify(arg1, 58)) | ||
3139 | { | ||
3140 | yield return false; | ||
3141 | } | ||
3142 | } | ||
3143 | { | ||
3144 | foreach (bool l2 in YP.unify(arg1, 60)) | ||
3145 | { | ||
3146 | yield return false; | ||
3147 | } | ||
3148 | } | ||
3149 | { | ||
3150 | foreach (bool l2 in YP.unify(arg1, 61)) | ||
3151 | { | ||
3152 | yield return false; | ||
3153 | } | ||
3154 | } | ||
3155 | { | ||
3156 | foreach (bool l2 in YP.unify(arg1, 62)) | ||
3157 | { | ||
3158 | yield return false; | ||
3159 | } | ||
3160 | } | ||
3161 | { | ||
3162 | foreach (bool l2 in YP.unify(arg1, 63)) | ||
3163 | { | ||
3164 | yield return false; | ||
3165 | } | ||
3166 | } | ||
3167 | { | ||
3168 | foreach (bool l2 in YP.unify(arg1, 64)) | ||
3169 | { | ||
3170 | yield return false; | ||
3171 | } | ||
3172 | } | ||
3173 | { | ||
3174 | foreach (bool l2 in YP.unify(arg1, 92)) | ||
3175 | { | ||
3176 | yield return false; | ||
3177 | } | ||
3178 | } | ||
3179 | { | ||
3180 | foreach (bool l2 in YP.unify(arg1, 94)) | ||
3181 | { | ||
3182 | yield return false; | ||
3183 | } | ||
3184 | } | ||
3185 | { | ||
3186 | foreach (bool l2 in YP.unify(arg1, 96)) | ||
3187 | { | ||
3188 | yield return false; | ||
3189 | } | ||
3190 | } | ||
3191 | { | ||
3192 | foreach (bool l2 in YP.unify(arg1, 126)) | ||
3193 | { | ||
3194 | yield return false; | ||
3195 | } | ||
3196 | } | ||
3197 | } | ||
3198 | |||
3199 | public static IEnumerable<bool> get_current_position(object Pos) | ||
3200 | { | ||
3201 | { | ||
3202 | foreach (bool l2 in YP.unify(Pos, 0)) | ||
3203 | { | ||
3204 | yield return false; | ||
3205 | } | ||
3206 | } | ||
3207 | } | ||
3208 | |||
3209 | public static IEnumerable<bool> read_after_atom4(object Ch, object Dict, object arg3, object Chars) | ||
3210 | { | ||
3211 | { | ||
3212 | Variable Atom_1 = new Variable(); | ||
3213 | Variable Pos = new Variable(); | ||
3214 | Variable Tokens = new Variable(); | ||
3215 | foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2("atom", Atom_1, Pos), Tokens))) | ||
3216 | { | ||
3217 | foreach (bool l3 in YP.unify(Pos, 0)) | ||
3218 | { | ||
3219 | foreach (bool l4 in YP.atom_codes(Atom_1, Chars)) | ||
3220 | { | ||
3221 | foreach (bool l5 in read_after_atom(Ch, Dict, Tokens)) | ||
3222 | { | ||
3223 | yield return false; | ||
3224 | } | ||
3225 | } | ||
3226 | } | ||
3227 | } | ||
3228 | } | ||
3229 | } | ||
3230 | |||
3231 | public static IEnumerable<bool> read_after_atom(object arg1, object Dict, object arg3) | ||
3232 | { | ||
3233 | { | ||
3234 | Variable Tokens = new Variable(); | ||
3235 | Variable NextCh = new Variable(); | ||
3236 | foreach (bool l2 in YP.unify(arg1, 40)) | ||
3237 | { | ||
3238 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("("), Tokens))) | ||
3239 | { | ||
3240 | foreach (bool l4 in YP.get_code(NextCh)) | ||
3241 | { | ||
3242 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
3243 | { | ||
3244 | yield return false; | ||
3245 | } | ||
3246 | } | ||
3247 | yield break; | ||
3248 | } | ||
3249 | } | ||
3250 | } | ||
3251 | { | ||
3252 | object Ch = arg1; | ||
3253 | object Tokens = arg3; | ||
3254 | foreach (bool l2 in read_tokens(Ch, Dict, Tokens)) | ||
3255 | { | ||
3256 | yield return false; | ||
3257 | } | ||
3258 | } | ||
3259 | } | ||
3260 | |||
3261 | public static IEnumerable<bool> read_string(object Chars, object Quote, object NextCh) | ||
3262 | { | ||
3263 | { | ||
3264 | Variable Ch = new Variable(); | ||
3265 | Variable Char = new Variable(); | ||
3266 | Variable Next = new Variable(); | ||
3267 | foreach (bool l2 in YP.get_code(Ch)) | ||
3268 | { | ||
3269 | foreach (bool l3 in read_char(Ch, Quote, Char, Next)) | ||
3270 | { | ||
3271 | foreach (bool l4 in rest_string5(Char, Next, Chars, Quote, NextCh)) | ||
3272 | { | ||
3273 | yield return false; | ||
3274 | } | ||
3275 | } | ||
3276 | } | ||
3277 | } | ||
3278 | } | ||
3279 | |||
3280 | public static IEnumerable<bool> rest_string5(object arg1, object arg2, object arg3, object arg4, object arg5) | ||
3281 | { | ||
3282 | { | ||
3283 | object _X = arg4; | ||
3284 | Variable NextCh = new Variable(); | ||
3285 | foreach (bool l2 in YP.unify(arg1, -1)) | ||
3286 | { | ||
3287 | foreach (bool l3 in YP.unify(arg2, NextCh)) | ||
3288 | { | ||
3289 | foreach (bool l4 in YP.unify(arg3, Atom.NIL)) | ||
3290 | { | ||
3291 | foreach (bool l5 in YP.unify(arg5, NextCh)) | ||
3292 | { | ||
3293 | yield return true; | ||
3294 | yield break; | ||
3295 | } | ||
3296 | } | ||
3297 | } | ||
3298 | } | ||
3299 | } | ||
3300 | { | ||
3301 | object Char = arg1; | ||
3302 | object Next = arg2; | ||
3303 | object Quote = arg4; | ||
3304 | object NextCh = arg5; | ||
3305 | Variable Chars = new Variable(); | ||
3306 | Variable Char2 = new Variable(); | ||
3307 | Variable Next2 = new Variable(); | ||
3308 | foreach (bool l2 in YP.unify(arg3, new ListPair(Char, Chars))) | ||
3309 | { | ||
3310 | foreach (bool l3 in read_char(Next, Quote, Char2, Next2)) | ||
3311 | { | ||
3312 | foreach (bool l4 in rest_string5(Char2, Next2, Chars, Quote, NextCh)) | ||
3313 | { | ||
3314 | yield return false; | ||
3315 | } | ||
3316 | } | ||
3317 | } | ||
3318 | } | ||
3319 | } | ||
3320 | |||
3321 | public static IEnumerable<bool> escape_char(object arg1, object arg2) | ||
3322 | { | ||
3323 | { | ||
3324 | foreach (bool l2 in YP.unify(arg1, 110)) | ||
3325 | { | ||
3326 | foreach (bool l3 in YP.unify(arg2, 10)) | ||
3327 | { | ||
3328 | yield return false; | ||
3329 | } | ||
3330 | } | ||
3331 | } | ||
3332 | { | ||
3333 | foreach (bool l2 in YP.unify(arg1, 78)) | ||
3334 | { | ||
3335 | foreach (bool l3 in YP.unify(arg2, 10)) | ||
3336 | { | ||
3337 | yield return false; | ||
3338 | } | ||
3339 | } | ||
3340 | } | ||
3341 | { | ||
3342 | foreach (bool l2 in YP.unify(arg1, 116)) | ||
3343 | { | ||
3344 | foreach (bool l3 in YP.unify(arg2, 9)) | ||
3345 | { | ||
3346 | yield return false; | ||
3347 | } | ||
3348 | } | ||
3349 | } | ||
3350 | { | ||
3351 | foreach (bool l2 in YP.unify(arg1, 84)) | ||
3352 | { | ||
3353 | foreach (bool l3 in YP.unify(arg2, 9)) | ||
3354 | { | ||
3355 | yield return false; | ||
3356 | } | ||
3357 | } | ||
3358 | } | ||
3359 | { | ||
3360 | foreach (bool l2 in YP.unify(arg1, 114)) | ||
3361 | { | ||
3362 | foreach (bool l3 in YP.unify(arg2, 13)) | ||
3363 | { | ||
3364 | yield return false; | ||
3365 | } | ||
3366 | } | ||
3367 | } | ||
3368 | { | ||
3369 | foreach (bool l2 in YP.unify(arg1, 82)) | ||
3370 | { | ||
3371 | foreach (bool l3 in YP.unify(arg2, 13)) | ||
3372 | { | ||
3373 | yield return false; | ||
3374 | } | ||
3375 | } | ||
3376 | } | ||
3377 | { | ||
3378 | foreach (bool l2 in YP.unify(arg1, 118)) | ||
3379 | { | ||
3380 | foreach (bool l3 in YP.unify(arg2, 11)) | ||
3381 | { | ||
3382 | yield return false; | ||
3383 | } | ||
3384 | } | ||
3385 | } | ||
3386 | { | ||
3387 | foreach (bool l2 in YP.unify(arg1, 86)) | ||
3388 | { | ||
3389 | foreach (bool l3 in YP.unify(arg2, 11)) | ||
3390 | { | ||
3391 | yield return false; | ||
3392 | } | ||
3393 | } | ||
3394 | } | ||
3395 | { | ||
3396 | foreach (bool l2 in YP.unify(arg1, 98)) | ||
3397 | { | ||
3398 | foreach (bool l3 in YP.unify(arg2, 8)) | ||
3399 | { | ||
3400 | yield return false; | ||
3401 | } | ||
3402 | } | ||
3403 | } | ||
3404 | { | ||
3405 | foreach (bool l2 in YP.unify(arg1, 66)) | ||
3406 | { | ||
3407 | foreach (bool l3 in YP.unify(arg2, 8)) | ||
3408 | { | ||
3409 | yield return false; | ||
3410 | } | ||
3411 | } | ||
3412 | } | ||
3413 | { | ||
3414 | foreach (bool l2 in YP.unify(arg1, 102)) | ||
3415 | { | ||
3416 | foreach (bool l3 in YP.unify(arg2, 12)) | ||
3417 | { | ||
3418 | yield return false; | ||
3419 | } | ||
3420 | } | ||
3421 | } | ||
3422 | { | ||
3423 | foreach (bool l2 in YP.unify(arg1, 70)) | ||
3424 | { | ||
3425 | foreach (bool l3 in YP.unify(arg2, 12)) | ||
3426 | { | ||
3427 | yield return false; | ||
3428 | } | ||
3429 | } | ||
3430 | } | ||
3431 | { | ||
3432 | foreach (bool l2 in YP.unify(arg1, 101)) | ||
3433 | { | ||
3434 | foreach (bool l3 in YP.unify(arg2, 27)) | ||
3435 | { | ||
3436 | yield return false; | ||
3437 | } | ||
3438 | } | ||
3439 | } | ||
3440 | { | ||
3441 | foreach (bool l2 in YP.unify(arg1, 69)) | ||
3442 | { | ||
3443 | foreach (bool l3 in YP.unify(arg2, 27)) | ||
3444 | { | ||
3445 | yield return false; | ||
3446 | } | ||
3447 | } | ||
3448 | } | ||
3449 | { | ||
3450 | foreach (bool l2 in YP.unify(arg1, 100)) | ||
3451 | { | ||
3452 | foreach (bool l3 in YP.unify(arg2, 127)) | ||
3453 | { | ||
3454 | yield return false; | ||
3455 | } | ||
3456 | } | ||
3457 | } | ||
3458 | { | ||
3459 | foreach (bool l2 in YP.unify(arg1, 68)) | ||
3460 | { | ||
3461 | foreach (bool l3 in YP.unify(arg2, 127)) | ||
3462 | { | ||
3463 | yield return false; | ||
3464 | } | ||
3465 | } | ||
3466 | } | ||
3467 | { | ||
3468 | foreach (bool l2 in YP.unify(arg1, 115)) | ||
3469 | { | ||
3470 | foreach (bool l3 in YP.unify(arg2, 32)) | ||
3471 | { | ||
3472 | yield return false; | ||
3473 | } | ||
3474 | } | ||
3475 | } | ||
3476 | { | ||
3477 | foreach (bool l2 in YP.unify(arg1, 83)) | ||
3478 | { | ||
3479 | foreach (bool l3 in YP.unify(arg2, 32)) | ||
3480 | { | ||
3481 | yield return false; | ||
3482 | } | ||
3483 | } | ||
3484 | } | ||
3485 | { | ||
3486 | foreach (bool l2 in YP.unify(arg1, 122)) | ||
3487 | { | ||
3488 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
3489 | { | ||
3490 | yield return false; | ||
3491 | } | ||
3492 | } | ||
3493 | } | ||
3494 | { | ||
3495 | foreach (bool l2 in YP.unify(arg1, 90)) | ||
3496 | { | ||
3497 | foreach (bool l3 in YP.unify(arg2, -1)) | ||
3498 | { | ||
3499 | yield return false; | ||
3500 | } | ||
3501 | } | ||
3502 | } | ||
3503 | } | ||
3504 | |||
3505 | public static IEnumerable<bool> read_variable(object C1, object Dict, object arg3) | ||
3506 | { | ||
3507 | { | ||
3508 | Variable Var = new Variable(); | ||
3509 | Variable Name = new Variable(); | ||
3510 | Variable StartPos = new Variable(); | ||
3511 | Variable Tokens = new Variable(); | ||
3512 | Variable Chars = new Variable(); | ||
3513 | Variable NextCh = new Variable(); | ||
3514 | foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor3("var", Var, Name, StartPos), Tokens))) | ||
3515 | { | ||
3516 | foreach (bool l3 in get_current_position(StartPos)) | ||
3517 | { | ||
3518 | foreach (bool l4 in read_name(C1, Chars, NextCh)) | ||
3519 | { | ||
3520 | foreach (bool l5 in YP.atom_codes(Name, Chars)) | ||
3521 | { | ||
3522 | if (YP.termEqual(Name, Atom.a("_"))) | ||
3523 | { | ||
3524 | foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) | ||
3525 | { | ||
3526 | yield return false; | ||
3527 | } | ||
3528 | goto cutIf1; | ||
3529 | } | ||
3530 | foreach (bool l6 in read_lookup(Dict, Name, Var)) | ||
3531 | { | ||
3532 | foreach (bool l7 in read_after_atom(NextCh, Dict, Tokens)) | ||
3533 | { | ||
3534 | yield return false; | ||
3535 | } | ||
3536 | } | ||
3537 | cutIf1: | ||
3538 | { } | ||
3539 | } | ||
3540 | } | ||
3541 | } | ||
3542 | } | ||
3543 | } | ||
3544 | } | ||
3545 | |||
3546 | public static IEnumerable<bool> read_lookup(object arg1, object Name, object Var) | ||
3547 | { | ||
3548 | { | ||
3549 | Variable N = new Variable(); | ||
3550 | Variable V = new Variable(); | ||
3551 | Variable L = new Variable(); | ||
3552 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("=", N, V), L))) | ||
3553 | { | ||
3554 | foreach (bool l3 in YP.unify(N, Name)) | ||
3555 | { | ||
3556 | foreach (bool l4 in YP.unify(V, Var)) | ||
3557 | { | ||
3558 | yield return false; | ||
3559 | } | ||
3560 | goto cutIf1; | ||
3561 | } | ||
3562 | foreach (bool l3 in read_lookup(L, Name, Var)) | ||
3563 | { | ||
3564 | yield return false; | ||
3565 | } | ||
3566 | cutIf1: | ||
3567 | { } | ||
3568 | } | ||
3569 | } | ||
3570 | } | ||
3571 | |||
3572 | public static IEnumerable<bool> read_solidus(object Ch, object LastCh) | ||
3573 | { | ||
3574 | { | ||
3575 | Variable NextCh = new Variable(); | ||
3576 | if (YP.equal(Ch, 42)) | ||
3577 | { | ||
3578 | foreach (bool l3 in YP.get_code(NextCh)) | ||
3579 | { | ||
3580 | if (YP.equal(NextCh, 47)) | ||
3581 | { | ||
3582 | foreach (bool l5 in YP.get_code(LastCh)) | ||
3583 | { | ||
3584 | yield return false; | ||
3585 | } | ||
3586 | goto cutIf2; | ||
3587 | } | ||
3588 | foreach (bool l4 in read_solidus(NextCh, LastCh)) | ||
3589 | { | ||
3590 | yield return false; | ||
3591 | } | ||
3592 | cutIf2: | ||
3593 | { } | ||
3594 | } | ||
3595 | goto cutIf1; | ||
3596 | } | ||
3597 | if (YP.notEqual(Ch, -1)) | ||
3598 | { | ||
3599 | foreach (bool l3 in YP.get_code(NextCh)) | ||
3600 | { | ||
3601 | foreach (bool l4 in read_solidus(NextCh, LastCh)) | ||
3602 | { | ||
3603 | yield return false; | ||
3604 | } | ||
3605 | } | ||
3606 | goto cutIf3; | ||
3607 | } | ||
3608 | foreach (bool l2 in YP.unify(LastCh, Ch)) | ||
3609 | { | ||
3610 | foreach (bool l3 in formatError(Atom.a("user_error"), Atom.a("~N** end of file in /*comment~n"), Atom.NIL)) | ||
3611 | { | ||
3612 | yield return false; | ||
3613 | } | ||
3614 | } | ||
3615 | cutIf3: | ||
3616 | cutIf1: | ||
3617 | { } | ||
3618 | } | ||
3619 | } | ||
3620 | |||
3621 | public static IEnumerable<bool> read_identifier(object C1, object Dict, object Tokens) | ||
3622 | { | ||
3623 | { | ||
3624 | Variable Chars = new Variable(); | ||
3625 | Variable NextCh = new Variable(); | ||
3626 | foreach (bool l2 in read_name(C1, Chars, NextCh)) | ||
3627 | { | ||
3628 | foreach (bool l3 in read_after_atom4(NextCh, Dict, Tokens, Chars)) | ||
3629 | { | ||
3630 | yield return false; | ||
3631 | } | ||
3632 | } | ||
3633 | } | ||
3634 | } | ||
3635 | |||
3636 | public static IEnumerable<bool> read_name(object C1, object arg2, object LastCh) | ||
3637 | { | ||
3638 | { | ||
3639 | Variable Chars = new Variable(); | ||
3640 | Variable C2 = new Variable(); | ||
3641 | foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) | ||
3642 | { | ||
3643 | foreach (bool l3 in YP.get_code(C2)) | ||
3644 | { | ||
3645 | if (YP.greaterThanOrEqual(C2, new ListPair(97, Atom.NIL))) | ||
3646 | { | ||
3647 | if (YP.lessThanOrEqual(C2, new ListPair(122, Atom.NIL))) | ||
3648 | { | ||
3649 | foreach (bool l6 in read_name(C2, Chars, LastCh)) | ||
3650 | { | ||
3651 | yield return false; | ||
3652 | } | ||
3653 | goto cutIf2; | ||
3654 | } | ||
3655 | if (YP.lessThan(C2, 192)) | ||
3656 | { | ||
3657 | if (YP.notEqual(YP.bitwiseOr(C2, 16), 186)) | ||
3658 | { | ||
3659 | foreach (bool l7 in YP.unify(Chars, Atom.NIL)) | ||
3660 | { | ||
3661 | foreach (bool l8 in YP.unify(LastCh, C2)) | ||
3662 | { | ||
3663 | yield return false; | ||
3664 | } | ||
3665 | } | ||
3666 | goto cutIf3; | ||
3667 | } | ||
3668 | } | ||
3669 | if (YP.equal(YP.bitwiseOr(C2, 32), 247)) | ||
3670 | { | ||
3671 | foreach (bool l6 in YP.unify(Chars, Atom.NIL)) | ||
3672 | { | ||
3673 | foreach (bool l7 in YP.unify(LastCh, C2)) | ||
3674 | { | ||
3675 | yield return false; | ||
3676 | } | ||
3677 | } | ||
3678 | goto cutIf4; | ||
3679 | } | ||
3680 | foreach (bool l5 in read_name(C2, Chars, LastCh)) | ||
3681 | { | ||
3682 | yield return false; | ||
3683 | } | ||
3684 | cutIf4: | ||
3685 | cutIf3: | ||
3686 | cutIf2: | ||
3687 | goto cutIf1; | ||
3688 | } | ||
3689 | if (YP.greaterThanOrEqual(C2, new ListPair(65, Atom.NIL))) | ||
3690 | { | ||
3691 | if (YP.greaterThan(C2, new ListPair(90, Atom.NIL))) | ||
3692 | { | ||
3693 | if (YP.notEqual(C2, new ListPair(95, Atom.NIL))) | ||
3694 | { | ||
3695 | foreach (bool l7 in YP.unify(Chars, Atom.NIL)) | ||
3696 | { | ||
3697 | foreach (bool l8 in YP.unify(LastCh, C2)) | ||
3698 | { | ||
3699 | yield return false; | ||
3700 | } | ||
3701 | } | ||
3702 | goto cutIf6; | ||
3703 | } | ||
3704 | } | ||
3705 | foreach (bool l5 in read_name(C2, Chars, LastCh)) | ||
3706 | { | ||
3707 | yield return false; | ||
3708 | } | ||
3709 | cutIf6: | ||
3710 | goto cutIf5; | ||
3711 | } | ||
3712 | if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) | ||
3713 | { | ||
3714 | if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) | ||
3715 | { | ||
3716 | foreach (bool l6 in read_name(C2, Chars, LastCh)) | ||
3717 | { | ||
3718 | yield return false; | ||
3719 | } | ||
3720 | goto cutIf7; | ||
3721 | } | ||
3722 | } | ||
3723 | foreach (bool l4 in YP.unify(Chars, Atom.NIL)) | ||
3724 | { | ||
3725 | foreach (bool l5 in YP.unify(LastCh, C2)) | ||
3726 | { | ||
3727 | yield return false; | ||
3728 | } | ||
3729 | } | ||
3730 | cutIf7: | ||
3731 | cutIf5: | ||
3732 | cutIf1: | ||
3733 | { } | ||
3734 | } | ||
3735 | } | ||
3736 | } | ||
3737 | } | ||
3738 | |||
3739 | public static IEnumerable<bool> read_fullstop(object Ch, object Dict, object Tokens) | ||
3740 | { | ||
3741 | { | ||
3742 | Variable Number = new Variable(); | ||
3743 | Variable Tokens1 = new Variable(); | ||
3744 | Variable Chars = new Variable(); | ||
3745 | Variable NextCh = new Variable(); | ||
3746 | if (YP.lessThanOrEqual(Ch, new ListPair(57, Atom.NIL))) | ||
3747 | { | ||
3748 | if (YP.greaterThanOrEqual(Ch, new ListPair(48, Atom.NIL))) | ||
3749 | { | ||
3750 | foreach (bool l4 in YP.unify(Tokens, new ListPair(new Functor1("number", Number), Tokens1))) | ||
3751 | { | ||
3752 | foreach (bool l5 in read_float(Number, Dict, Tokens1, new ListPair(48, Atom.NIL), Ch)) | ||
3753 | { | ||
3754 | yield return false; | ||
3755 | } | ||
3756 | } | ||
3757 | goto cutIf1; | ||
3758 | } | ||
3759 | } | ||
3760 | if (YP.greaterThan(Ch, new ListPair(32, Atom.NIL))) | ||
3761 | { | ||
3762 | foreach (bool l3 in rest_symbol(Ch, Chars, NextCh)) | ||
3763 | { | ||
3764 | foreach (bool l4 in read_after_atom4(NextCh, Dict, Tokens, new ListPair(46, Chars))) | ||
3765 | { | ||
3766 | yield return false; | ||
3767 | } | ||
3768 | } | ||
3769 | goto cutIf2; | ||
3770 | } | ||
3771 | if (YP.greaterThanOrEqual(Ch, 0)) | ||
3772 | { | ||
3773 | foreach (bool l3 in YP.unify(Tokens, Atom.NIL)) | ||
3774 | { | ||
3775 | yield return false; | ||
3776 | } | ||
3777 | goto cutIf3; | ||
3778 | } | ||
3779 | foreach (bool l2 in formatError(Atom.a("user_error"), Atom.a("~N** end of file just after full stop~n"), Atom.NIL)) | ||
3780 | { | ||
3781 | } | ||
3782 | cutIf3: | ||
3783 | cutIf2: | ||
3784 | cutIf1: | ||
3785 | { } | ||
3786 | } | ||
3787 | } | ||
3788 | |||
3789 | public static IEnumerable<bool> read_float(object Number, object Dict, object Tokens, object Digits, object Digit) | ||
3790 | { | ||
3791 | { | ||
3792 | Variable Chars = new Variable(); | ||
3793 | Variable Rest = new Variable(); | ||
3794 | Variable NextCh = new Variable(); | ||
3795 | foreach (bool l2 in prepend(Digits, Chars, Rest)) | ||
3796 | { | ||
3797 | foreach (bool l3 in read_float4(Digit, Rest, NextCh, Chars)) | ||
3798 | { | ||
3799 | foreach (bool l4 in YP.number_codes(Number, Chars)) | ||
3800 | { | ||
3801 | foreach (bool l5 in read_tokens(NextCh, Dict, Tokens)) | ||
3802 | { | ||
3803 | yield return false; | ||
3804 | } | ||
3805 | } | ||
3806 | } | ||
3807 | } | ||
3808 | } | ||
3809 | } | ||
3810 | |||
3811 | public static IEnumerable<bool> prepend(object arg1, object arg2, object arg3) | ||
3812 | { | ||
3813 | { | ||
3814 | object X = arg3; | ||
3815 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
3816 | { | ||
3817 | foreach (bool l3 in YP.unify(arg2, new ListPair(46, X))) | ||
3818 | { | ||
3819 | yield return false; | ||
3820 | } | ||
3821 | } | ||
3822 | } | ||
3823 | { | ||
3824 | object Y = arg3; | ||
3825 | Variable C = new Variable(); | ||
3826 | Variable Cs = new Variable(); | ||
3827 | Variable X = new Variable(); | ||
3828 | foreach (bool l2 in YP.unify(arg1, new ListPair(C, Cs))) | ||
3829 | { | ||
3830 | foreach (bool l3 in YP.unify(arg2, new ListPair(C, X))) | ||
3831 | { | ||
3832 | foreach (bool l4 in prepend(Cs, X, Y)) | ||
3833 | { | ||
3834 | yield return false; | ||
3835 | } | ||
3836 | } | ||
3837 | } | ||
3838 | } | ||
3839 | } | ||
3840 | |||
3841 | public static IEnumerable<bool> read_float4(object C1, object arg2, object NextCh, object Total) | ||
3842 | { | ||
3843 | { | ||
3844 | Variable Chars = new Variable(); | ||
3845 | Variable C2 = new Variable(); | ||
3846 | Variable C3 = new Variable(); | ||
3847 | Variable C4 = new Variable(); | ||
3848 | Variable More = new Variable(); | ||
3849 | foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) | ||
3850 | { | ||
3851 | foreach (bool l3 in YP.get_code(C2)) | ||
3852 | { | ||
3853 | if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) | ||
3854 | { | ||
3855 | if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) | ||
3856 | { | ||
3857 | foreach (bool l6 in read_float4(C2, Chars, NextCh, Total)) | ||
3858 | { | ||
3859 | yield return false; | ||
3860 | } | ||
3861 | goto cutIf1; | ||
3862 | } | ||
3863 | } | ||
3864 | if (YP.equal(YP.bitwiseOr(C2, 32), new ListPair(101, Atom.NIL))) | ||
3865 | { | ||
3866 | foreach (bool l5 in YP.get_code(C3)) | ||
3867 | { | ||
3868 | if (YP.equal(C3, new ListPair(45, Atom.NIL))) | ||
3869 | { | ||
3870 | foreach (bool l7 in YP.get_code(C4)) | ||
3871 | { | ||
3872 | foreach (bool l8 in YP.unify(Chars, new ListPair(C2, new ListPair(45, More)))) | ||
3873 | { | ||
3874 | if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) | ||
3875 | { | ||
3876 | if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) | ||
3877 | { | ||
3878 | foreach (bool l11 in read_exponent(C4, More, NextCh)) | ||
3879 | { | ||
3880 | yield return false; | ||
3881 | } | ||
3882 | goto cutIf4; | ||
3883 | } | ||
3884 | } | ||
3885 | foreach (bool l9 in YP.unify(More, Atom.NIL)) | ||
3886 | { | ||
3887 | foreach (bool l10 in formatError(Atom.a("user_error"), Atom.a("~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) | ||
3888 | { | ||
3889 | } | ||
3890 | } | ||
3891 | foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) | ||
3892 | { | ||
3893 | foreach (bool l10 in YP.unify(NextCh, C4)) | ||
3894 | { | ||
3895 | yield return false; | ||
3896 | } | ||
3897 | } | ||
3898 | cutIf4: | ||
3899 | { } | ||
3900 | } | ||
3901 | } | ||
3902 | goto cutIf3; | ||
3903 | } | ||
3904 | if (YP.equal(C3, new ListPair(43, Atom.NIL))) | ||
3905 | { | ||
3906 | foreach (bool l7 in YP.get_code(C4)) | ||
3907 | { | ||
3908 | foreach (bool l8 in YP.unify(Chars, new ListPair(C2, More))) | ||
3909 | { | ||
3910 | if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) | ||
3911 | { | ||
3912 | if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) | ||
3913 | { | ||
3914 | foreach (bool l11 in read_exponent(C4, More, NextCh)) | ||
3915 | { | ||
3916 | yield return false; | ||
3917 | } | ||
3918 | goto cutIf6; | ||
3919 | } | ||
3920 | } | ||
3921 | foreach (bool l9 in YP.unify(More, Atom.NIL)) | ||
3922 | { | ||
3923 | foreach (bool l10 in formatError(Atom.a("user_error"), Atom.a("~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) | ||
3924 | { | ||
3925 | } | ||
3926 | } | ||
3927 | foreach (bool l9 in YP.unify(More, new ListPair(48, Atom.NIL))) | ||
3928 | { | ||
3929 | foreach (bool l10 in YP.unify(NextCh, C4)) | ||
3930 | { | ||
3931 | yield return false; | ||
3932 | } | ||
3933 | } | ||
3934 | cutIf6: | ||
3935 | { } | ||
3936 | } | ||
3937 | } | ||
3938 | goto cutIf5; | ||
3939 | } | ||
3940 | foreach (bool l6 in YP.unify(C4, C3)) | ||
3941 | { | ||
3942 | foreach (bool l7 in YP.unify(Chars, new ListPair(C2, More))) | ||
3943 | { | ||
3944 | if (YP.greaterThanOrEqual(C4, new ListPair(48, Atom.NIL))) | ||
3945 | { | ||
3946 | if (YP.lessThanOrEqual(C4, new ListPair(57, Atom.NIL))) | ||
3947 | { | ||
3948 | foreach (bool l10 in read_exponent(C4, More, NextCh)) | ||
3949 | { | ||
3950 | yield return false; | ||
3951 | } | ||
3952 | goto cutIf7; | ||
3953 | } | ||
3954 | } | ||
3955 | foreach (bool l8 in YP.unify(More, Atom.NIL)) | ||
3956 | { | ||
3957 | foreach (bool l9 in formatError(Atom.a("user_error"), Atom.a("~N** Missing exponent in ~s~n"), new ListPair(Total, Atom.NIL))) | ||
3958 | { | ||
3959 | } | ||
3960 | } | ||
3961 | foreach (bool l8 in YP.unify(More, new ListPair(48, Atom.NIL))) | ||
3962 | { | ||
3963 | foreach (bool l9 in YP.unify(NextCh, C4)) | ||
3964 | { | ||
3965 | yield return false; | ||
3966 | } | ||
3967 | } | ||
3968 | cutIf7: | ||
3969 | { } | ||
3970 | } | ||
3971 | } | ||
3972 | cutIf5: | ||
3973 | cutIf3: | ||
3974 | { } | ||
3975 | } | ||
3976 | goto cutIf2; | ||
3977 | } | ||
3978 | foreach (bool l4 in YP.unify(Chars, Atom.NIL)) | ||
3979 | { | ||
3980 | foreach (bool l5 in YP.unify(NextCh, C2)) | ||
3981 | { | ||
3982 | yield return false; | ||
3983 | } | ||
3984 | } | ||
3985 | cutIf2: | ||
3986 | cutIf1: | ||
3987 | { } | ||
3988 | } | ||
3989 | } | ||
3990 | } | ||
3991 | } | ||
3992 | |||
3993 | public static IEnumerable<bool> read_exponent(object C1, object arg2, object NextCh) | ||
3994 | { | ||
3995 | { | ||
3996 | Variable Chars = new Variable(); | ||
3997 | Variable C2 = new Variable(); | ||
3998 | foreach (bool l2 in YP.unify(arg2, new ListPair(C1, Chars))) | ||
3999 | { | ||
4000 | foreach (bool l3 in YP.get_code(C2)) | ||
4001 | { | ||
4002 | if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) | ||
4003 | { | ||
4004 | if (YP.lessThanOrEqual(C2, new ListPair(57, Atom.NIL))) | ||
4005 | { | ||
4006 | foreach (bool l6 in read_exponent(C2, Chars, NextCh)) | ||
4007 | { | ||
4008 | yield return false; | ||
4009 | } | ||
4010 | goto cutIf1; | ||
4011 | } | ||
4012 | } | ||
4013 | foreach (bool l4 in YP.unify(Chars, Atom.NIL)) | ||
4014 | { | ||
4015 | foreach (bool l5 in YP.unify(NextCh, C2)) | ||
4016 | { | ||
4017 | yield return false; | ||
4018 | } | ||
4019 | } | ||
4020 | cutIf1: | ||
4021 | { } | ||
4022 | } | ||
4023 | } | ||
4024 | } | ||
4025 | } | ||
4026 | |||
4027 | public static IEnumerable<bool> read_number(object C1, object Dict, object arg3) | ||
4028 | { | ||
4029 | { | ||
4030 | Variable Number = new Variable(); | ||
4031 | Variable Tokens = new Variable(); | ||
4032 | Variable C2 = new Variable(); | ||
4033 | Variable N = new Variable(); | ||
4034 | Variable C = new Variable(); | ||
4035 | Variable C3 = new Variable(); | ||
4036 | Variable Digits = new Variable(); | ||
4037 | foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor1("number", Number), Tokens))) | ||
4038 | { | ||
4039 | foreach (bool l3 in read_number4(C1, C2, 0, N)) | ||
4040 | { | ||
4041 | if (YP.equal(C2, 39)) | ||
4042 | { | ||
4043 | if (YP.greaterThanOrEqual(N, 2)) | ||
4044 | { | ||
4045 | if (YP.lessThanOrEqual(N, 36)) | ||
4046 | { | ||
4047 | foreach (bool l7 in read_based(N, 0, Number, C)) | ||
4048 | { | ||
4049 | foreach (bool l8 in read_tokens(C, Dict, Tokens)) | ||
4050 | { | ||
4051 | yield return false; | ||
4052 | } | ||
4053 | } | ||
4054 | goto cutIf2; | ||
4055 | } | ||
4056 | } | ||
4057 | if (YP.equal(N, 0)) | ||
4058 | { | ||
4059 | foreach (bool l6 in YP.get_code(C3)) | ||
4060 | { | ||
4061 | foreach (bool l7 in read_char(C3, -1, Number, C)) | ||
4062 | { | ||
4063 | foreach (bool l8 in read_tokens(C, Dict, Tokens)) | ||
4064 | { | ||
4065 | yield return false; | ||
4066 | } | ||
4067 | } | ||
4068 | } | ||
4069 | goto cutIf3; | ||
4070 | } | ||
4071 | foreach (bool l5 in formatError(Atom.a("user_error"), Atom.a("~N** ~d' read as ~d '~n"), new ListPair(N, new ListPair(N, Atom.NIL)))) | ||
4072 | { | ||
4073 | foreach (bool l6 in YP.unify(Number, N)) | ||
4074 | { | ||
4075 | foreach (bool l7 in YP.unify(C, C2)) | ||
4076 | { | ||
4077 | foreach (bool l8 in read_tokens(C, Dict, Tokens)) | ||
4078 | { | ||
4079 | yield return false; | ||
4080 | } | ||
4081 | } | ||
4082 | } | ||
4083 | } | ||
4084 | cutIf3: | ||
4085 | cutIf2: | ||
4086 | goto cutIf1; | ||
4087 | } | ||
4088 | if (YP.equal(C2, 46)) | ||
4089 | { | ||
4090 | foreach (bool l5 in YP.get_code(C3)) | ||
4091 | { | ||
4092 | if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) | ||
4093 | { | ||
4094 | if (YP.lessThanOrEqual(C3, new ListPair(57, Atom.NIL))) | ||
4095 | { | ||
4096 | foreach (bool l8 in YP.number_codes(N, Digits)) | ||
4097 | { | ||
4098 | foreach (bool l9 in read_float(Number, Dict, Tokens, Digits, C3)) | ||
4099 | { | ||
4100 | yield return false; | ||
4101 | } | ||
4102 | } | ||
4103 | goto cutIf5; | ||
4104 | } | ||
4105 | } | ||
4106 | foreach (bool l6 in YP.unify(Number, N)) | ||
4107 | { | ||
4108 | foreach (bool l7 in read_fullstop(C3, Dict, Tokens)) | ||
4109 | { | ||
4110 | yield return false; | ||
4111 | } | ||
4112 | } | ||
4113 | cutIf5: | ||
4114 | { } | ||
4115 | } | ||
4116 | goto cutIf4; | ||
4117 | } | ||
4118 | foreach (bool l4 in YP.unify(Number, N)) | ||
4119 | { | ||
4120 | foreach (bool l5 in read_tokens(C2, Dict, Tokens)) | ||
4121 | { | ||
4122 | yield return false; | ||
4123 | } | ||
4124 | } | ||
4125 | cutIf4: | ||
4126 | cutIf1: | ||
4127 | { } | ||
4128 | } | ||
4129 | } | ||
4130 | } | ||
4131 | } | ||
4132 | |||
4133 | public static IEnumerable<bool> read_number4(object C0, object C, object N0, object N) | ||
4134 | { | ||
4135 | { | ||
4136 | Variable N1 = new Variable(); | ||
4137 | Variable C1 = new Variable(); | ||
4138 | if (YP.greaterThanOrEqual(C0, new ListPair(48, Atom.NIL))) | ||
4139 | { | ||
4140 | if (YP.lessThanOrEqual(C0, new ListPair(57, Atom.NIL))) | ||
4141 | { | ||
4142 | foreach (bool l4 in YP.unify(N1, YP.add(YP.subtract(YP.multiply(N0, 10), new ListPair(48, Atom.NIL)), C0))) | ||
4143 | { | ||
4144 | foreach (bool l5 in YP.get_code(C1)) | ||
4145 | { | ||
4146 | foreach (bool l6 in read_number4(C1, C, N1, N)) | ||
4147 | { | ||
4148 | yield return false; | ||
4149 | } | ||
4150 | } | ||
4151 | } | ||
4152 | goto cutIf1; | ||
4153 | } | ||
4154 | } | ||
4155 | if (YP.equal(C0, 95)) | ||
4156 | { | ||
4157 | foreach (bool l3 in YP.get_code(C1)) | ||
4158 | { | ||
4159 | foreach (bool l4 in read_number4(C1, C, N0, N)) | ||
4160 | { | ||
4161 | yield return false; | ||
4162 | } | ||
4163 | } | ||
4164 | goto cutIf2; | ||
4165 | } | ||
4166 | foreach (bool l2 in YP.unify(C, C0)) | ||
4167 | { | ||
4168 | foreach (bool l3 in YP.unify(N, N0)) | ||
4169 | { | ||
4170 | yield return false; | ||
4171 | } | ||
4172 | } | ||
4173 | cutIf2: | ||
4174 | cutIf1: | ||
4175 | { } | ||
4176 | } | ||
4177 | } | ||
4178 | |||
4179 | public static IEnumerable<bool> read_based(object Base, object N0, object N, object C) | ||
4180 | { | ||
4181 | { | ||
4182 | Variable C1 = new Variable(); | ||
4183 | Variable Digit = new Variable(); | ||
4184 | Variable N1 = new Variable(); | ||
4185 | foreach (bool l2 in YP.get_code(C1)) | ||
4186 | { | ||
4187 | if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) | ||
4188 | { | ||
4189 | if (YP.lessThanOrEqual(C1, new ListPair(57, Atom.NIL))) | ||
4190 | { | ||
4191 | foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, new ListPair(48, Atom.NIL)))) | ||
4192 | { | ||
4193 | if (YP.lessThan(Digit, Base)) | ||
4194 | { | ||
4195 | foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) | ||
4196 | { | ||
4197 | foreach (bool l8 in read_based(Base, N1, N, C)) | ||
4198 | { | ||
4199 | yield return false; | ||
4200 | } | ||
4201 | } | ||
4202 | goto cutIf2; | ||
4203 | } | ||
4204 | if (YP.equal(C1, new ListPair(95, Atom.NIL))) | ||
4205 | { | ||
4206 | foreach (bool l7 in read_based(Base, N0, N, C)) | ||
4207 | { | ||
4208 | yield return false; | ||
4209 | } | ||
4210 | goto cutIf3; | ||
4211 | } | ||
4212 | foreach (bool l6 in YP.unify(N, N0)) | ||
4213 | { | ||
4214 | foreach (bool l7 in YP.unify(C, C1)) | ||
4215 | { | ||
4216 | yield return false; | ||
4217 | } | ||
4218 | } | ||
4219 | cutIf3: | ||
4220 | cutIf2: | ||
4221 | { } | ||
4222 | } | ||
4223 | goto cutIf1; | ||
4224 | } | ||
4225 | } | ||
4226 | if (YP.greaterThanOrEqual(C1, new ListPair(65, Atom.NIL))) | ||
4227 | { | ||
4228 | if (YP.lessThanOrEqual(C1, new ListPair(90, Atom.NIL))) | ||
4229 | { | ||
4230 | foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(65, Atom.NIL), 10)))) | ||
4231 | { | ||
4232 | if (YP.lessThan(Digit, Base)) | ||
4233 | { | ||
4234 | foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) | ||
4235 | { | ||
4236 | foreach (bool l8 in read_based(Base, N1, N, C)) | ||
4237 | { | ||
4238 | yield return false; | ||
4239 | } | ||
4240 | } | ||
4241 | goto cutIf5; | ||
4242 | } | ||
4243 | if (YP.equal(C1, new ListPair(95, Atom.NIL))) | ||
4244 | { | ||
4245 | foreach (bool l7 in read_based(Base, N0, N, C)) | ||
4246 | { | ||
4247 | yield return false; | ||
4248 | } | ||
4249 | goto cutIf6; | ||
4250 | } | ||
4251 | foreach (bool l6 in YP.unify(N, N0)) | ||
4252 | { | ||
4253 | foreach (bool l7 in YP.unify(C, C1)) | ||
4254 | { | ||
4255 | yield return false; | ||
4256 | } | ||
4257 | } | ||
4258 | cutIf6: | ||
4259 | cutIf5: | ||
4260 | { } | ||
4261 | } | ||
4262 | goto cutIf4; | ||
4263 | } | ||
4264 | } | ||
4265 | if (YP.greaterThanOrEqual(C1, new ListPair(97, Atom.NIL))) | ||
4266 | { | ||
4267 | if (YP.lessThanOrEqual(C1, new ListPair(122, Atom.NIL))) | ||
4268 | { | ||
4269 | foreach (bool l5 in YP.unify(Digit, YP.subtract(C1, YP.subtract(new ListPair(97, Atom.NIL), 10)))) | ||
4270 | { | ||
4271 | if (YP.lessThan(Digit, Base)) | ||
4272 | { | ||
4273 | foreach (bool l7 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) | ||
4274 | { | ||
4275 | foreach (bool l8 in read_based(Base, N1, N, C)) | ||
4276 | { | ||
4277 | yield return false; | ||
4278 | } | ||
4279 | } | ||
4280 | goto cutIf8; | ||
4281 | } | ||
4282 | if (YP.equal(C1, new ListPair(95, Atom.NIL))) | ||
4283 | { | ||
4284 | foreach (bool l7 in read_based(Base, N0, N, C)) | ||
4285 | { | ||
4286 | yield return false; | ||
4287 | } | ||
4288 | goto cutIf9; | ||
4289 | } | ||
4290 | foreach (bool l6 in YP.unify(N, N0)) | ||
4291 | { | ||
4292 | foreach (bool l7 in YP.unify(C, C1)) | ||
4293 | { | ||
4294 | yield return false; | ||
4295 | } | ||
4296 | } | ||
4297 | cutIf9: | ||
4298 | cutIf8: | ||
4299 | { } | ||
4300 | } | ||
4301 | goto cutIf7; | ||
4302 | } | ||
4303 | } | ||
4304 | foreach (bool l3 in YP.unify(Digit, 99)) | ||
4305 | { | ||
4306 | if (YP.lessThan(Digit, Base)) | ||
4307 | { | ||
4308 | foreach (bool l5 in YP.unify(N1, YP.add(YP.multiply(N0, Base), Digit))) | ||
4309 | { | ||
4310 | foreach (bool l6 in read_based(Base, N1, N, C)) | ||
4311 | { | ||
4312 | yield return false; | ||
4313 | } | ||
4314 | } | ||
4315 | goto cutIf10; | ||
4316 | } | ||
4317 | if (YP.equal(C1, new ListPair(95, Atom.NIL))) | ||
4318 | { | ||
4319 | foreach (bool l5 in read_based(Base, N0, N, C)) | ||
4320 | { | ||
4321 | yield return false; | ||
4322 | } | ||
4323 | goto cutIf11; | ||
4324 | } | ||
4325 | foreach (bool l4 in YP.unify(N, N0)) | ||
4326 | { | ||
4327 | foreach (bool l5 in YP.unify(C, C1)) | ||
4328 | { | ||
4329 | yield return false; | ||
4330 | } | ||
4331 | } | ||
4332 | cutIf11: | ||
4333 | cutIf10: | ||
4334 | { } | ||
4335 | } | ||
4336 | cutIf7: | ||
4337 | cutIf4: | ||
4338 | cutIf1: | ||
4339 | { } | ||
4340 | } | ||
4341 | } | ||
4342 | } | ||
4343 | |||
4344 | public static IEnumerable<bool> read_char(object Char, object Quote, object Result, object Next) | ||
4345 | { | ||
4346 | { | ||
4347 | Variable C1 = new Variable(); | ||
4348 | Variable C2 = new Variable(); | ||
4349 | Variable C3 = new Variable(); | ||
4350 | Variable Ch = new Variable(); | ||
4351 | if (YP.equal(Char, 92)) | ||
4352 | { | ||
4353 | foreach (bool l3 in YP.get_code(C1)) | ||
4354 | { | ||
4355 | if (YP.lessThan(C1, 0)) | ||
4356 | { | ||
4357 | foreach (bool l5 in formatError(Atom.a("user_error"), Atom.a("~N** end of file in ~cquoted~c~n"), new ListPair(Quote, new ListPair(Quote, Atom.NIL)))) | ||
4358 | { | ||
4359 | foreach (bool l6 in YP.unify(Result, -1)) | ||
4360 | { | ||
4361 | foreach (bool l7 in YP.unify(Next, C1)) | ||
4362 | { | ||
4363 | yield return false; | ||
4364 | } | ||
4365 | } | ||
4366 | } | ||
4367 | goto cutIf2; | ||
4368 | } | ||
4369 | if (YP.lessThanOrEqual(C1, new ListPair(32, Atom.NIL))) | ||
4370 | { | ||
4371 | foreach (bool l5 in YP.get_code(C2)) | ||
4372 | { | ||
4373 | foreach (bool l6 in read_char(C2, Quote, Result, Next)) | ||
4374 | { | ||
4375 | yield return false; | ||
4376 | } | ||
4377 | } | ||
4378 | goto cutIf3; | ||
4379 | } | ||
4380 | if (YP.equal(YP.bitwiseOr(C1, 32), new ListPair(99, Atom.NIL))) | ||
4381 | { | ||
4382 | foreach (bool l5 in YP.get_code(C2)) | ||
4383 | { | ||
4384 | foreach (bool l6 in read_char(C2, Quote, Result, Next)) | ||
4385 | { | ||
4386 | yield return false; | ||
4387 | } | ||
4388 | } | ||
4389 | goto cutIf4; | ||
4390 | } | ||
4391 | if (YP.lessThanOrEqual(C1, new ListPair(55, Atom.NIL))) | ||
4392 | { | ||
4393 | if (YP.greaterThanOrEqual(C1, new ListPair(48, Atom.NIL))) | ||
4394 | { | ||
4395 | foreach (bool l6 in YP.get_code(C2)) | ||
4396 | { | ||
4397 | if (YP.lessThanOrEqual(C2, new ListPair(55, Atom.NIL))) | ||
4398 | { | ||
4399 | if (YP.greaterThanOrEqual(C2, new ListPair(48, Atom.NIL))) | ||
4400 | { | ||
4401 | foreach (bool l9 in YP.get_code(C3)) | ||
4402 | { | ||
4403 | if (YP.lessThanOrEqual(C3, new ListPair(55, Atom.NIL))) | ||
4404 | { | ||
4405 | if (YP.greaterThanOrEqual(C3, new ListPair(48, Atom.NIL))) | ||
4406 | { | ||
4407 | foreach (bool l12 in YP.get_code(Next)) | ||
4408 | { | ||
4409 | foreach (bool l13 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(YP.add(YP.multiply(C1, 8), C2), 8), C3), YP.multiply(73, new ListPair(48, Atom.NIL))))) | ||
4410 | { | ||
4411 | yield return false; | ||
4412 | } | ||
4413 | } | ||
4414 | goto cutIf7; | ||
4415 | } | ||
4416 | } | ||
4417 | foreach (bool l10 in YP.unify(Next, C3)) | ||
4418 | { | ||
4419 | foreach (bool l11 in YP.unify(Result, YP.subtract(YP.add(YP.multiply(C1, 8), C2), YP.multiply(9, new ListPair(48, Atom.NIL))))) | ||
4420 | { | ||
4421 | yield return false; | ||
4422 | } | ||
4423 | } | ||
4424 | cutIf7: | ||
4425 | { } | ||
4426 | } | ||
4427 | goto cutIf6; | ||
4428 | } | ||
4429 | } | ||
4430 | foreach (bool l7 in YP.unify(Next, C2)) | ||
4431 | { | ||
4432 | foreach (bool l8 in YP.unify(Result, YP.subtract(C1, new ListPair(48, Atom.NIL)))) | ||
4433 | { | ||
4434 | yield return false; | ||
4435 | } | ||
4436 | } | ||
4437 | cutIf6: | ||
4438 | { } | ||
4439 | } | ||
4440 | goto cutIf5; | ||
4441 | } | ||
4442 | } | ||
4443 | if (YP.equal(C1, new ListPair(94, Atom.NIL))) | ||
4444 | { | ||
4445 | foreach (bool l5 in YP.get_code(C2)) | ||
4446 | { | ||
4447 | if (YP.lessThan(C2, 0)) | ||
4448 | { | ||
4449 | foreach (bool l7 in formatError(Atom.a("user_error"), Atom.a("~N** end of file in ~c..~c^..~c~n"), ListPair.make(new object[] { Quote, 92, Quote }))) | ||
4450 | { | ||
4451 | foreach (bool l8 in YP.unify(Result, -1)) | ||
4452 | { | ||
4453 | foreach (bool l9 in YP.unify(Next, C2)) | ||
4454 | { | ||
4455 | yield return false; | ||
4456 | } | ||
4457 | } | ||
4458 | } | ||
4459 | goto cutIf9; | ||
4460 | } | ||
4461 | if (YP.equal(C2, new ListPair(63, Atom.NIL))) | ||
4462 | { | ||
4463 | foreach (bool l7 in YP.unify(Result, 127)) | ||
4464 | { | ||
4465 | foreach (bool l8 in YP.get_code(Next)) | ||
4466 | { | ||
4467 | yield return false; | ||
4468 | } | ||
4469 | } | ||
4470 | goto cutIf10; | ||
4471 | } | ||
4472 | foreach (bool l6 in YP.unify(Result, YP.bitwiseAnd(C2, 31))) | ||
4473 | { | ||
4474 | foreach (bool l7 in YP.get_code(Next)) | ||
4475 | { | ||
4476 | yield return false; | ||
4477 | } | ||
4478 | } | ||
4479 | cutIf10: | ||
4480 | cutIf9: | ||
4481 | { } | ||
4482 | } | ||
4483 | goto cutIf8; | ||
4484 | } | ||
4485 | foreach (bool l4 in escape_char(C1, Result)) | ||
4486 | { | ||
4487 | foreach (bool l5 in YP.get_code(Next)) | ||
4488 | { | ||
4489 | yield return false; | ||
4490 | } | ||
4491 | goto cutIf11; | ||
4492 | } | ||
4493 | foreach (bool l4 in YP.unify(Result, C1)) | ||
4494 | { | ||
4495 | foreach (bool l5 in YP.get_code(Next)) | ||
4496 | { | ||
4497 | yield return false; | ||
4498 | } | ||
4499 | } | ||
4500 | cutIf11: | ||
4501 | cutIf8: | ||
4502 | cutIf5: | ||
4503 | cutIf4: | ||
4504 | cutIf3: | ||
4505 | cutIf2: | ||
4506 | { } | ||
4507 | } | ||
4508 | goto cutIf1; | ||
4509 | } | ||
4510 | if (YP.equal(Char, Quote)) | ||
4511 | { | ||
4512 | foreach (bool l3 in YP.get_code(Ch)) | ||
4513 | { | ||
4514 | if (YP.equal(Ch, Quote)) | ||
4515 | { | ||
4516 | foreach (bool l5 in YP.unify(Result, Quote)) | ||
4517 | { | ||
4518 | foreach (bool l6 in YP.get_code(Next)) | ||
4519 | { | ||
4520 | yield return false; | ||
4521 | } | ||
4522 | } | ||
4523 | goto cutIf13; | ||
4524 | } | ||
4525 | foreach (bool l4 in YP.unify(Result, -1)) | ||
4526 | { | ||
4527 | foreach (bool l5 in YP.unify(Next, Ch)) | ||
4528 | { | ||
4529 | yield return false; | ||
4530 | } | ||
4531 | } | ||
4532 | cutIf13: | ||
4533 | { } | ||
4534 | } | ||
4535 | goto cutIf12; | ||
4536 | } | ||
4537 | if (YP.lessThan(Char, new ListPair(32, Atom.NIL))) | ||
4538 | { | ||
4539 | if (YP.notEqual(Char, 9)) | ||
4540 | { | ||
4541 | if (YP.notEqual(Char, 10)) | ||
4542 | { | ||
4543 | if (YP.notEqual(Char, 13)) | ||
4544 | { | ||
4545 | foreach (bool l6 in YP.unify(Result, -1)) | ||
4546 | { | ||
4547 | foreach (bool l7 in YP.unify(Next, Char)) | ||
4548 | { | ||
4549 | foreach (bool l8 in formatError(Atom.a("user_error"), Atom.a("~N** Strange character ~d ends ~ctoken~c~n"), ListPair.make(new object[] { Char, Quote, Quote }))) | ||
4550 | { | ||
4551 | yield return false; | ||
4552 | } | ||
4553 | } | ||
4554 | } | ||
4555 | goto cutIf14; | ||
4556 | } | ||
4557 | } | ||
4558 | } | ||
4559 | } | ||
4560 | foreach (bool l2 in YP.unify(Result, Char)) | ||
4561 | { | ||
4562 | foreach (bool l3 in YP.get_code(Next)) | ||
4563 | { | ||
4564 | yield return false; | ||
4565 | } | ||
4566 | } | ||
4567 | cutIf14: | ||
4568 | cutIf12: | ||
4569 | cutIf1: | ||
4570 | { } | ||
4571 | } | ||
4572 | } | ||
4573 | #pragma warning restore 0168, 0219, 0162 | ||
4574 | } | ||
4575 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs deleted file mode 100644 index 9f5ae3d..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/PrologException.cs +++ /dev/null | |||
@@ -1,159 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | |||
33 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
34 | { | ||
35 | /// <summary> | ||
36 | /// A PrologException is used as the exception thrown by YP.throw(Term). | ||
37 | /// </summary> | ||
38 | public class PrologException : Exception | ||
39 | { | ||
40 | public readonly object _term; | ||
41 | |||
42 | /// <summary> | ||
43 | /// Create a PrologException with the given Term. The printable exception message is the full Term. | ||
44 | /// </summary> | ||
45 | /// <param name="Term">the term of the exception</param> | ||
46 | public PrologException(object Term) | ||
47 | : base(YP.getValue(Term).ToString()) | ||
48 | { | ||
49 | _term = YP.makeCopy(Term, new Variable.CopyStore()); | ||
50 | } | ||
51 | |||
52 | /// <summary> | ||
53 | /// Create a PrologException where the Term is error(ErrorTerm, Message). | ||
54 | /// This uses YP.makeCopy to copy the ErrorTerm and Message so that they are valid after unbinding. | ||
55 | /// </summary> | ||
56 | /// <param name="ErrorTerm">the error term of the error</param> | ||
57 | /// <param name="Messsage">the message term of the error. If this is a string, it is converted to an | ||
58 | /// Atom so it can be used by Prolog code. | ||
59 | /// Message, converted to a string, is use as the printable exception message. | ||
60 | /// </param> | ||
61 | public PrologException(object ErrorTerm, object Message) | ||
62 | : base(YP.getValue(Message).ToString()) | ||
63 | { | ||
64 | if (Message is string) | ||
65 | Message = Atom.a((string)Message); | ||
66 | _term = YP.makeCopy(new Functor2(Atom.a("error"), ErrorTerm, Message), new Variable.CopyStore()); | ||
67 | } | ||
68 | |||
69 | public class TypeErrorInfo | ||
70 | { | ||
71 | public readonly Atom _Type; | ||
72 | public readonly object _Culprit; | ||
73 | public readonly object _Message; | ||
74 | |||
75 | public TypeErrorInfo(Atom Type, object Culprit, object Message) | ||
76 | { | ||
77 | _Type = Type; | ||
78 | _Culprit = Culprit; | ||
79 | _Message = Message; | ||
80 | } | ||
81 | } | ||
82 | /// <summary> | ||
83 | /// Return the TypeErrorInfo for this exception, or null if _term does not match | ||
84 | /// error(type_error(Type, Culprit), Message). | ||
85 | /// </summary> | ||
86 | /// <returns></returns> | ||
87 | public TypeErrorInfo getTypeErrorInfo() | ||
88 | { | ||
89 | if (!(_term is Functor2 && ((Functor2)_term)._name._name == "error")) | ||
90 | return null; | ||
91 | object errorTerm = ((Functor2)_term)._arg1; | ||
92 | if (!(errorTerm is Functor2 && ((Functor2)errorTerm)._name._name == "type_error")) | ||
93 | return null; | ||
94 | if (!(((Functor2)errorTerm)._arg1 is Atom)) | ||
95 | return null; | ||
96 | return new TypeErrorInfo | ||
97 | ((Atom)((Functor2)errorTerm)._arg1, ((Functor2)errorTerm)._arg2, ((Functor2)_term)._arg2); | ||
98 | } | ||
99 | |||
100 | public class ExistenceErrorInfo | ||
101 | { | ||
102 | public readonly Atom _Type; | ||
103 | public readonly object _Culprit; | ||
104 | public readonly object _Message; | ||
105 | |||
106 | public ExistenceErrorInfo(Atom Type, object Culprit, object Message) | ||
107 | { | ||
108 | _Type = Type; | ||
109 | _Culprit = Culprit; | ||
110 | _Message = Message; | ||
111 | } | ||
112 | |||
113 | /// <summary> | ||
114 | /// If _Type is procedure and _Culprit is name/artity, return the name. Otherwise return null. | ||
115 | /// </summary> | ||
116 | /// <returns></returns> | ||
117 | public object getProcedureName() | ||
118 | { | ||
119 | if (!(_Type._name == "procedure" && | ||
120 | _Culprit is Functor2 && ((Functor2)_Culprit)._name == Atom.SLASH)) | ||
121 | return null; | ||
122 | return ((Functor2)_Culprit)._arg1; | ||
123 | } | ||
124 | |||
125 | /// <summary> | ||
126 | /// If _Type is procedure and _Culprit is name/arity and arity is an integer, return the arity. | ||
127 | /// Otherwise return -1. | ||
128 | /// </summary> | ||
129 | /// <returns></returns> | ||
130 | public int getProcedureArity() | ||
131 | { | ||
132 | if (!(_Type._name == "procedure" && | ||
133 | _Culprit is Functor2 && ((Functor2)_Culprit)._name == Atom.SLASH)) | ||
134 | return -1; | ||
135 | if (!(((Functor2)_Culprit)._arg2 is int)) | ||
136 | return -1; | ||
137 | return (int)((Functor2)_Culprit)._arg2; | ||
138 | } | ||
139 | } | ||
140 | /// <summary> | ||
141 | /// Return the ExistenceErrorInfo for this exception, or null if _term does not match | ||
142 | /// error(existence_error(Type, Culprit), Message). If the returned ExistenceErrorInfo _Culprit is | ||
143 | /// procedure, you can use its getProcedureName and getProcedureArity. | ||
144 | /// </summary> | ||
145 | /// <returns></returns> | ||
146 | public ExistenceErrorInfo getExistenceErrorInfo() | ||
147 | { | ||
148 | if (!(_term is Functor2 && ((Functor2)_term)._name._name == "error")) | ||
149 | return null; | ||
150 | object errorTerm = ((Functor2)_term)._arg1; | ||
151 | if (!(errorTerm is Functor2 && ((Functor2)errorTerm)._name._name == "existence_error")) | ||
152 | return null; | ||
153 | if (!(((Functor2)errorTerm)._arg1 is Atom)) | ||
154 | return null; | ||
155 | return new ExistenceErrorInfo | ||
156 | ((Atom)((Functor2)errorTerm)._arg1, ((Functor2)errorTerm)._arg2, ((Functor2)_term)._arg2); | ||
157 | } | ||
158 | } | ||
159 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Properties/AssemblyInfo.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Properties/AssemblyInfo.cs deleted file mode 100644 index 342dbff..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Properties/AssemblyInfo.cs +++ /dev/null | |||
@@ -1,33 +0,0 @@ | |||
1 | using System.Reflection; | ||
2 | using System.Runtime.CompilerServices; | ||
3 | using System.Runtime.InteropServices; | ||
4 | |||
5 | // General Information about an assembly is controlled through the following | ||
6 | // set of attributes. Change these attribute values to modify the information | ||
7 | // associated with an assembly. | ||
8 | [assembly: AssemblyTitle("OpenSim.Region.ScriptEngine.Shared.YieldProlog")] | ||
9 | [assembly: AssemblyDescription("")] | ||
10 | [assembly: AssemblyConfiguration("")] | ||
11 | [assembly: AssemblyCompany("http://opensimulator.org")] | ||
12 | [assembly: AssemblyProduct("OpenSim")] | ||
13 | [assembly: AssemblyCopyright("OpenSimulator developers")] | ||
14 | [assembly: AssemblyTrademark("")] | ||
15 | [assembly: AssemblyCulture("")] | ||
16 | |||
17 | // Setting ComVisible to false makes the types in this assembly not visible | ||
18 | // to COM components. If you need to access a type in this assembly from | ||
19 | // COM, set the ComVisible attribute to true on that type. | ||
20 | [assembly: ComVisible(false)] | ||
21 | |||
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM | ||
23 | [assembly: Guid("8df98e6b-0425-44d6-8d91-2b3b4c56acdf")] | ||
24 | |||
25 | // Version information for an assembly consists of the following four values: | ||
26 | // | ||
27 | // Major Version | ||
28 | // Minor Version | ||
29 | // Build Number | ||
30 | // Revision | ||
31 | // | ||
32 | [assembly: AssemblyVersion("0.7.6.*")] | ||
33 | [assembly: AssemblyFileVersion("1.0.0.0")] | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs deleted file mode 100644 index 4b6112f..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/UndefinedPredicateException.cs +++ /dev/null | |||
@@ -1,62 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | |||
33 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
34 | { | ||
35 | /// <summary> | ||
36 | /// An UndefinedPredicateException extends PrologException to create an existence_error exception. | ||
37 | /// </summary> | ||
38 | public class UndefinedPredicateException : PrologException | ||
39 | { | ||
40 | private Atom _predicateName; | ||
41 | private int _arity; | ||
42 | |||
43 | public UndefinedPredicateException(object message, Atom predicateName, int arity) | ||
44 | : base(new Functor2 | ||
45 | (Atom.a("existence_error"), Atom.a("procedure"), new Functor2(Atom.a("/"), predicateName, arity)), | ||
46 | message) | ||
47 | { | ||
48 | _predicateName = predicateName; | ||
49 | _arity = arity; | ||
50 | } | ||
51 | |||
52 | public Atom PredicateName | ||
53 | { | ||
54 | get { return _predicateName; } | ||
55 | } | ||
56 | |||
57 | public int Arity | ||
58 | { | ||
59 | get { return _arity; } | ||
60 | } | ||
61 | } | ||
62 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs deleted file mode 100644 index ea5b7a6..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Variable.cs +++ /dev/null | |||
@@ -1,222 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections; | ||
33 | using System.Collections.Generic; | ||
34 | |||
35 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
36 | { | ||
37 | public interface IUnifiable | ||
38 | { | ||
39 | IEnumerable<bool> unify(object arg); | ||
40 | void addUniqueVariables(List<Variable> variableSet); | ||
41 | object makeCopy(Variable.CopyStore copyStore); | ||
42 | bool termEqual(object term); | ||
43 | bool ground(); | ||
44 | } | ||
45 | |||
46 | /// <summary> | ||
47 | /// A Variable is passed to a function so that it can be unified with | ||
48 | /// value or another Variable. See getValue and unify for details. | ||
49 | /// </summary> | ||
50 | public class Variable : IUnifiable | ||
51 | { | ||
52 | // Use _isBound separate from _value so that it can be bound to any value, | ||
53 | // including null. | ||
54 | private bool _isBound = false; | ||
55 | private object _value; | ||
56 | |||
57 | /// <summary> | ||
58 | /// If this Variable is unbound, then just return this Variable. | ||
59 | /// Otherwise, if this has been bound to a value with unify, return the value. | ||
60 | /// If the bound value is another Variable, this follows the "variable chain" | ||
61 | /// to the end and returns the final value, or the final Variable if it is unbound. | ||
62 | /// For more details, see http://yieldprolog.sourceforge.net/tutorial1.html | ||
63 | /// </summary> | ||
64 | /// <returns></returns> | ||
65 | public object getValue() | ||
66 | { | ||
67 | if (!_isBound) | ||
68 | return this; | ||
69 | |||
70 | object result = _value; | ||
71 | while (result is Variable) | ||
72 | { | ||
73 | if (!((Variable)result)._isBound) | ||
74 | return result; | ||
75 | |||
76 | // Keep following the Variable chain. | ||
77 | result = ((Variable)result)._value; | ||
78 | } | ||
79 | |||
80 | return result; | ||
81 | } | ||
82 | |||
83 | /// <summary> | ||
84 | /// If this Variable is bound, then just call YP.unify to unify this with arg. | ||
85 | /// (Note that if arg is an unbound Variable, then YP.unify will bind it to | ||
86 | /// this Variable's value.) | ||
87 | /// Otherwise, bind this Variable to YP.getValue(arg) and yield once. After the | ||
88 | /// yield, return this Variable to the unbound state. | ||
89 | /// For more details, see http://yieldprolog.sourceforge.net/tutorial1.html | ||
90 | /// </summary> | ||
91 | /// <param name="arg"></param> | ||
92 | /// <returns></returns> | ||
93 | public IEnumerable<bool> unify(object arg) | ||
94 | { | ||
95 | if (!_isBound) | ||
96 | { | ||
97 | _value = YP.getValue(arg); | ||
98 | if (_value == this) | ||
99 | // We are unifying this unbound variable with itself, so leave it unbound. | ||
100 | yield return false; | ||
101 | else | ||
102 | { | ||
103 | _isBound = true; | ||
104 | try | ||
105 | { | ||
106 | yield return false; | ||
107 | } | ||
108 | finally | ||
109 | { | ||
110 | // Remove the binding. | ||
111 | _isBound = false; | ||
112 | } | ||
113 | } | ||
114 | } | ||
115 | else | ||
116 | { | ||
117 | // disable warning on l1, don't see how we can | ||
118 | // code this differently | ||
119 | #pragma warning disable 0168, 0219 | ||
120 | foreach (bool l1 in YP.unify(this, arg)) | ||
121 | yield return false; | ||
122 | #pragma warning restore 0168, 0219 | ||
123 | } | ||
124 | } | ||
125 | |||
126 | public override string ToString() | ||
127 | { | ||
128 | object value = getValue(); | ||
129 | if (value == this) | ||
130 | return "_Variable"; | ||
131 | else | ||
132 | return getValue().ToString(); | ||
133 | } | ||
134 | |||
135 | /// <summary> | ||
136 | /// If bound, call YP.addUniqueVariables on the value. Otherwise, if this unbound | ||
137 | /// variable is not already in variableSet, add it. | ||
138 | /// </summary> | ||
139 | /// <param name="variableSet"></param> | ||
140 | public void addUniqueVariables(List<Variable> variableSet) | ||
141 | { | ||
142 | if (_isBound) | ||
143 | YP.addUniqueVariables(getValue(), variableSet); | ||
144 | else | ||
145 | { | ||
146 | if (variableSet.IndexOf(this) < 0) | ||
147 | variableSet.Add(this); | ||
148 | } | ||
149 | } | ||
150 | |||
151 | /// <summary> | ||
152 | /// If bound, return YP.makeCopy for the value, else return copyStore.getCopy(this). | ||
153 | /// However, if copyStore is null, just return this. | ||
154 | /// </summary> | ||
155 | /// <param name="copyStore"></param> | ||
156 | /// <returns></returns> | ||
157 | public object makeCopy(Variable.CopyStore copyStore) | ||
158 | { | ||
159 | if (_isBound) | ||
160 | return YP.makeCopy(getValue(), copyStore); | ||
161 | else | ||
162 | return copyStore == null ? this : copyStore.getCopy(this); | ||
163 | } | ||
164 | |||
165 | public bool termEqual(object term) | ||
166 | { | ||
167 | if (_isBound) | ||
168 | return YP.termEqual(getValue(), term); | ||
169 | else | ||
170 | return this == YP.getValue(term); | ||
171 | } | ||
172 | |||
173 | public bool ground() | ||
174 | { | ||
175 | if (_isBound) | ||
176 | // This is usually called by YP.ground which already did getValue, so this | ||
177 | // should never be reached, but check anyway. | ||
178 | return YP.ground(getValue()); | ||
179 | else | ||
180 | return false; | ||
181 | } | ||
182 | |||
183 | /// <summary> | ||
184 | /// A CopyStore is used by makeCopy to track which Variable objects have | ||
185 | /// been copied. | ||
186 | /// </summary> | ||
187 | public class CopyStore | ||
188 | { | ||
189 | private List<Variable> _inVariableSet = new List<Variable>(); | ||
190 | private List<Variable> _outVariableSet = new List<Variable>(); | ||
191 | |||
192 | /// <summary> | ||
193 | /// If inVariable has already been copied, return its copy. Otherwise, | ||
194 | /// return a fresh Variable associated with inVariable. | ||
195 | /// </summary> | ||
196 | /// <param name="inVariable"></param> | ||
197 | /// <returns></returns> | ||
198 | public Variable getCopy(Variable inVariable) | ||
199 | { | ||
200 | int index = _inVariableSet.IndexOf(inVariable); | ||
201 | if (index >= 0) | ||
202 | return _outVariableSet[index]; | ||
203 | else | ||
204 | { | ||
205 | Variable outVariable = new Variable(); | ||
206 | _inVariableSet.Add(inVariable); | ||
207 | _outVariableSet.Add(outVariable); | ||
208 | return outVariable; | ||
209 | } | ||
210 | } | ||
211 | |||
212 | /// <summary> | ||
213 | /// Return the number of unique variables that have been copied. | ||
214 | /// </summary> | ||
215 | /// <returns></returns> | ||
216 | public int getNUniqueVariables() | ||
217 | { | ||
218 | return _inVariableSet.Count; | ||
219 | } | ||
220 | } | ||
221 | } | ||
222 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs deleted file mode 100644 index f2171dd..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YP.cs +++ /dev/null | |||
@@ -1,2701 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.Collections; | ||
33 | using System.Collections.Generic; | ||
34 | using System.IO; | ||
35 | using System.Reflection; | ||
36 | using System.Net.Sockets; | ||
37 | using System.Text; | ||
38 | using System.Text.RegularExpressions; | ||
39 | using log4net; | ||
40 | |||
41 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
42 | { | ||
43 | /// <summary> | ||
44 | /// YP has static methods for general functions in Yield Prolog such as <see cref="getValue"/> | ||
45 | /// and <see cref="unify"/>. | ||
46 | /// </summary> | ||
47 | public class YP | ||
48 | { | ||
49 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
50 | private static Fail _fail = new Fail(); | ||
51 | private static Repeat _repeat = new Repeat(); | ||
52 | private static Dictionary<NameArity, List<IClause>> _predicatesStore = | ||
53 | new Dictionary<NameArity, List<IClause>>(); | ||
54 | private static TextWriter _outputStream = System.Console.Out; | ||
55 | private static TextReader _inputStream = System.Console.In; | ||
56 | private static IndexedAnswers _operatorTable = null; | ||
57 | private static Dictionary<string, object> _prologFlags = new Dictionary<string, object>(); | ||
58 | public const int MAX_ARITY = 255; | ||
59 | |||
60 | /// <summary> | ||
61 | /// An IClause is used so that dynamic predicates can call match. | ||
62 | /// </summary> | ||
63 | public interface IClause | ||
64 | { | ||
65 | IEnumerable<bool> match(object[] args); | ||
66 | IEnumerable<bool> clause(object Head, object Body); | ||
67 | } | ||
68 | |||
69 | /// <summary> | ||
70 | /// If value is a Variable, then return its getValue. Otherwise, just | ||
71 | /// return value. You should call YP.getValue on any object that | ||
72 | /// may be a Variable to get the value to pass to other functions in | ||
73 | /// your system that are not part of Yield Prolog, such as math functions | ||
74 | /// or file I/O. | ||
75 | /// For more details, see http://yieldprolog.sourceforge.net/tutorial1.html | ||
76 | /// </summary> | ||
77 | /// <param name="value"></param> | ||
78 | /// <returns></returns> | ||
79 | public static object getValue(object value) | ||
80 | { | ||
81 | if (value is Variable) | ||
82 | return ((Variable)value).getValue(); | ||
83 | else | ||
84 | return value; | ||
85 | } | ||
86 | |||
87 | /// <summary> | ||
88 | /// If arg1 or arg2 is an object with a unify method (such as Variable or | ||
89 | /// Functor) then just call its unify with the other argument. The object's | ||
90 | /// unify method will bind the values or check for equals as needed. | ||
91 | /// Otherwise, both arguments are "normal" (atomic) values so if they | ||
92 | /// are equal then succeed (yield once), else fail (don't yield). | ||
93 | /// For more details, see http://yieldprolog.sourceforge.net/tutorial1.html | ||
94 | /// </summary> | ||
95 | /// <param name="arg1"></param> | ||
96 | /// <param name="arg2"></param> | ||
97 | /// <returns></returns> | ||
98 | public static IEnumerable<bool> unify(object arg1, object arg2) | ||
99 | { | ||
100 | arg1 = getValue(arg1); | ||
101 | arg2 = getValue(arg2); | ||
102 | if (arg1 is IUnifiable) | ||
103 | return ((IUnifiable)arg1).unify(arg2); | ||
104 | else if (arg2 is IUnifiable) | ||
105 | return ((IUnifiable)arg2).unify(arg1); | ||
106 | else | ||
107 | { | ||
108 | // Arguments are "normal" types. | ||
109 | if (arg1.Equals(arg2)) | ||
110 | return new Succeed(); | ||
111 | else | ||
112 | return _fail; | ||
113 | } | ||
114 | } | ||
115 | |||
116 | /// <summary> | ||
117 | /// This is used for the lookup key in _factStore. | ||
118 | /// </summary> | ||
119 | public struct NameArity | ||
120 | { | ||
121 | public readonly Atom _name; | ||
122 | public readonly int _arity; | ||
123 | |||
124 | public NameArity(Atom name, int arity) | ||
125 | { | ||
126 | _name = name; | ||
127 | _arity = arity; | ||
128 | } | ||
129 | |||
130 | public override bool Equals(object obj) | ||
131 | { | ||
132 | if (obj is NameArity) | ||
133 | { | ||
134 | NameArity nameArity = (NameArity)obj; | ||
135 | return nameArity._name.Equals(_name) && nameArity._arity.Equals(_arity); | ||
136 | } | ||
137 | else | ||
138 | { | ||
139 | return false; | ||
140 | } | ||
141 | } | ||
142 | |||
143 | public override int GetHashCode() | ||
144 | { | ||
145 | return _name.GetHashCode() ^ _arity.GetHashCode(); | ||
146 | } | ||
147 | } | ||
148 | |||
149 | /// <summary> | ||
150 | /// Convert term to an int. | ||
151 | /// If term is a single-element List, use its first element | ||
152 | /// (to handle the char types like "a"). | ||
153 | /// If can't convert, throw a PrologException for type_error evaluable (because this is only | ||
154 | /// called from arithmetic functions). | ||
155 | /// </summary> | ||
156 | /// <param name="term"></param> | ||
157 | /// <returns></returns> | ||
158 | public static int convertInt(object term) | ||
159 | { | ||
160 | term = YP.getValue(term); | ||
161 | if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && | ||
162 | YP.getValue(((Functor2)term)._arg2) == Atom.NIL) | ||
163 | // Assume it is a char type like "a". | ||
164 | term = YP.getValue(((Functor2)term)._arg1); | ||
165 | if (term is Variable) | ||
166 | throw new PrologException(Atom.a("instantiation_error"), | ||
167 | "Expected a number but the argument is an unbound variable"); | ||
168 | |||
169 | try | ||
170 | { | ||
171 | return (int)term; | ||
172 | } | ||
173 | catch (InvalidCastException) | ||
174 | { | ||
175 | throw new PrologException | ||
176 | (new Functor2 | ||
177 | ("type_error", Atom.a("evaluable"), | ||
178 | new Functor2(Atom.SLASH, getFunctorName(term), getFunctorArgs(term).Length)), | ||
179 | "Term must be an integer"); | ||
180 | } | ||
181 | } | ||
182 | |||
183 | /// <summary> | ||
184 | /// Convert term to a double. This may convert an int to a double, etc. | ||
185 | /// If term is a single-element List, use its first element | ||
186 | /// (to handle the char types like "a"). | ||
187 | /// If can't convert, throw a PrologException for type_error evaluable (because this is only | ||
188 | /// called from arithmetic functions). | ||
189 | /// </summary> | ||
190 | /// <param name="term"></param> | ||
191 | /// <returns></returns> | ||
192 | public static double convertDouble(object term) | ||
193 | { | ||
194 | term = YP.getValue(term); | ||
195 | if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && | ||
196 | YP.getValue(((Functor2)term)._arg2) == Atom.NIL) | ||
197 | // Assume it is a char type like "a". | ||
198 | term = YP.getValue(((Functor2)term)._arg1); | ||
199 | if (term is Variable) | ||
200 | throw new PrologException(Atom.a("instantiation_error"), | ||
201 | "Expected a number but the argument is an unbound variable"); | ||
202 | |||
203 | try | ||
204 | { | ||
205 | return Convert.ToDouble(term); | ||
206 | } | ||
207 | catch (InvalidCastException) | ||
208 | { | ||
209 | throw new PrologException | ||
210 | (new Functor2 | ||
211 | ("type_error", Atom.a("evaluable"), | ||
212 | new Functor2(Atom.SLASH, getFunctorName(term), getFunctorArgs(term).Length)), | ||
213 | "Term must be an integer"); | ||
214 | } | ||
215 | } | ||
216 | |||
217 | /// <summary> | ||
218 | /// If term is an integer, set intTerm. | ||
219 | /// If term is a single-element List, use its first element | ||
220 | /// (to handle the char types like "a"). Return true for success, false if can't convert. | ||
221 | /// We use a success return value because throwing an exception is inefficient. | ||
222 | /// </summary> | ||
223 | /// <param name="term"></param> | ||
224 | /// <returns></returns> | ||
225 | public static bool getInt(object term, out int intTerm) | ||
226 | { | ||
227 | term = YP.getValue(term); | ||
228 | if (term is Functor2 && ((Functor2)term)._name == Atom.DOT && | ||
229 | YP.getValue(((Functor2)term)._arg2) == Atom.NIL) | ||
230 | // Assume it is a char type like "a". | ||
231 | term = YP.getValue(((Functor2)term)._arg1); | ||
232 | |||
233 | if (term is int) | ||
234 | { | ||
235 | intTerm = (int)term; | ||
236 | return true; | ||
237 | } | ||
238 | |||
239 | intTerm = 0; | ||
240 | return false; | ||
241 | } | ||
242 | |||
243 | public static bool equal(object x, object y) | ||
244 | { | ||
245 | x = YP.getValue(x); | ||
246 | if (x is DateTime) | ||
247 | return (DateTime)x == (DateTime)YP.getValue(y); | ||
248 | // Assume convertDouble converts an int to a double perfectly. | ||
249 | return YP.convertDouble(x) == YP.convertDouble(y); | ||
250 | } | ||
251 | |||
252 | public static bool notEqual(object x, object y) | ||
253 | { | ||
254 | x = YP.getValue(x); | ||
255 | if (x is DateTime) | ||
256 | return (DateTime)x != (DateTime)YP.getValue(y); | ||
257 | // Assume convertDouble converts an int to a double perfectly. | ||
258 | return YP.convertDouble(x) != YP.convertDouble(y); | ||
259 | } | ||
260 | |||
261 | public static bool greaterThan(object x, object y) | ||
262 | { | ||
263 | x = YP.getValue(x); | ||
264 | if (x is DateTime) | ||
265 | return (DateTime)x > (DateTime)YP.getValue(y); | ||
266 | // Assume convertDouble converts an int to a double perfectly. | ||
267 | return YP.convertDouble(x) > YP.convertDouble(y); | ||
268 | } | ||
269 | |||
270 | public static bool lessThan(object x, object y) | ||
271 | { | ||
272 | x = YP.getValue(x); | ||
273 | if (x is DateTime) | ||
274 | return (DateTime)x < (DateTime)YP.getValue(y); | ||
275 | // Assume convertDouble converts an int to a double perfectly. | ||
276 | return YP.convertDouble(x) < YP.convertDouble(y); | ||
277 | } | ||
278 | |||
279 | public static bool greaterThanOrEqual(object x, object y) | ||
280 | { | ||
281 | x = YP.getValue(x); | ||
282 | if (x is DateTime) | ||
283 | return (DateTime)x >= (DateTime)YP.getValue(y); | ||
284 | // Assume convertDouble converts an int to a double perfectly. | ||
285 | return YP.convertDouble(x) >= YP.convertDouble(y); | ||
286 | } | ||
287 | |||
288 | public static bool lessThanOrEqual(object x, object y) | ||
289 | { | ||
290 | x = YP.getValue(x); | ||
291 | if (x is DateTime) | ||
292 | return (DateTime)x <= (DateTime)YP.getValue(y); | ||
293 | // Assume convertDouble converts an int to a double perfectly. | ||
294 | return YP.convertDouble(x) <= YP.convertDouble(y); | ||
295 | } | ||
296 | |||
297 | public static object negate(object x) | ||
298 | { | ||
299 | int intX; | ||
300 | if (getInt(x, out intX)) | ||
301 | return -intX; | ||
302 | return -convertDouble(x); | ||
303 | } | ||
304 | |||
305 | public static object abs(object x) | ||
306 | { | ||
307 | int intX; | ||
308 | if (getInt(x, out intX)) | ||
309 | return Math.Abs(intX); | ||
310 | return Math.Abs(convertDouble(x)); | ||
311 | } | ||
312 | |||
313 | public static object sign(object x) | ||
314 | { | ||
315 | int intX; | ||
316 | if (getInt(x, out intX)) | ||
317 | return Math.Sign(intX); | ||
318 | return Math.Sign(convertDouble(x)); | ||
319 | } | ||
320 | |||
321 | // Use toFloat instead of float because it is a reserved keyword. | ||
322 | public static object toFloat(object x) | ||
323 | { | ||
324 | return convertDouble(x); | ||
325 | } | ||
326 | |||
327 | /// <summary> | ||
328 | /// The ISO standard returns an int. | ||
329 | /// </summary> | ||
330 | /// <param name="x"></param> | ||
331 | /// <returns></returns> | ||
332 | public static object floor(object x) | ||
333 | { | ||
334 | return (int)Math.Floor(convertDouble(x)); | ||
335 | } | ||
336 | |||
337 | /// <summary> | ||
338 | /// The ISO standard returns an int. | ||
339 | /// </summary> | ||
340 | /// <param name="x"></param> | ||
341 | /// <returns></returns> | ||
342 | public static object truncate(object x) | ||
343 | { | ||
344 | return (int)Math.Truncate(convertDouble(x)); | ||
345 | } | ||
346 | |||
347 | /// <summary> | ||
348 | /// The ISO standard returns an int. | ||
349 | /// </summary> | ||
350 | /// <param name="x"></param> | ||
351 | /// <returns></returns> | ||
352 | public static object round(object x) | ||
353 | { | ||
354 | return (int)Math.Round(convertDouble(x)); | ||
355 | } | ||
356 | |||
357 | /// <summary> | ||
358 | /// The ISO standard returns an int. | ||
359 | /// </summary> | ||
360 | /// <param name="x"></param> | ||
361 | /// <returns></returns> | ||
362 | public static object ceiling(object x) | ||
363 | { | ||
364 | return (int)Math.Ceiling(convertDouble(x)); | ||
365 | } | ||
366 | |||
367 | public static object sin(object x) | ||
368 | { | ||
369 | return Math.Sin(YP.convertDouble(x)); | ||
370 | } | ||
371 | |||
372 | public static object cos(object x) | ||
373 | { | ||
374 | return Math.Cos(YP.convertDouble(x)); | ||
375 | } | ||
376 | |||
377 | public static object atan(object x) | ||
378 | { | ||
379 | return Math.Atan(YP.convertDouble(x)); | ||
380 | } | ||
381 | |||
382 | public static object exp(object x) | ||
383 | { | ||
384 | return Math.Exp(YP.convertDouble(x)); | ||
385 | } | ||
386 | |||
387 | public static object log(object x) | ||
388 | { | ||
389 | return Math.Log(YP.convertDouble(x)); | ||
390 | } | ||
391 | |||
392 | public static object sqrt(object x) | ||
393 | { | ||
394 | return Math.Sqrt(convertDouble(x)); | ||
395 | } | ||
396 | |||
397 | public static object bitwiseComplement(object x) | ||
398 | { | ||
399 | return ~YP.convertInt(x); | ||
400 | } | ||
401 | |||
402 | public static object add(object x, object y) | ||
403 | { | ||
404 | int intX, intY; | ||
405 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
406 | return intX + intY; | ||
407 | return convertDouble(x) + convertDouble(y); | ||
408 | } | ||
409 | |||
410 | public static object subtract(object x, object y) | ||
411 | { | ||
412 | int intX, intY; | ||
413 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
414 | return intX - intY; | ||
415 | return convertDouble(x) - convertDouble(y); | ||
416 | } | ||
417 | |||
418 | public static object multiply(object x, object y) | ||
419 | { | ||
420 | int intX, intY; | ||
421 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
422 | return intX * intY; | ||
423 | return convertDouble(x) * convertDouble(y); | ||
424 | } | ||
425 | |||
426 | /// <summary> | ||
427 | /// Return floating point, even if both arguments are integer. | ||
428 | /// </summary> | ||
429 | /// <param name="x"></param> | ||
430 | /// <param name="y"></param> | ||
431 | /// <returns></returns> | ||
432 | public static object divide(object x, object y) | ||
433 | { | ||
434 | return convertDouble(x) / convertDouble(y); | ||
435 | } | ||
436 | |||
437 | public static object intDivide(object x, object y) | ||
438 | { | ||
439 | int intX, intY; | ||
440 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
441 | return intX / intY; | ||
442 | // Still allow passing a double, but treat as an int. | ||
443 | return (int)convertDouble(x) / (int)convertDouble(y); | ||
444 | } | ||
445 | |||
446 | public static object mod(object x, object y) | ||
447 | { | ||
448 | int intX, intY; | ||
449 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
450 | return intX % intY; | ||
451 | // Still allow passing a double, but treat as an int. | ||
452 | return (int)convertDouble(x) % (int)convertDouble(y); | ||
453 | } | ||
454 | |||
455 | public static object pow(object x, object y) | ||
456 | { | ||
457 | return Math.Pow(YP.convertDouble(x), YP.convertDouble(y)); | ||
458 | } | ||
459 | |||
460 | public static object bitwiseShiftRight(object x, object y) | ||
461 | { | ||
462 | return YP.convertInt(x) >> YP.convertInt(y); | ||
463 | } | ||
464 | |||
465 | public static object bitwiseShiftLeft(object x, object y) | ||
466 | { | ||
467 | return YP.convertInt(x) << YP.convertInt(y); | ||
468 | } | ||
469 | |||
470 | public static object bitwiseAnd(object x, object y) | ||
471 | { | ||
472 | return YP.convertInt(x) & YP.convertInt(y); | ||
473 | } | ||
474 | |||
475 | public static object bitwiseOr(object x, object y) | ||
476 | { | ||
477 | return YP.convertInt(x) | YP.convertInt(y); | ||
478 | } | ||
479 | |||
480 | public static object min(object x, object y) | ||
481 | { | ||
482 | int intX, intY; | ||
483 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
484 | return Math.Min(intX, intY); | ||
485 | return Math.Min(convertDouble(x), convertDouble(y)); | ||
486 | } | ||
487 | |||
488 | public static object max(object x, object y) | ||
489 | { | ||
490 | int intX, intY; | ||
491 | if (getInt(x, out intX) && getInt(y, out intY)) | ||
492 | return Math.Max(intX, intY); | ||
493 | return Math.Max(convertDouble(x), convertDouble(y)); | ||
494 | } | ||
495 | |||
496 | public static IEnumerable<bool> copy_term(object inTerm, object outTerm) | ||
497 | { | ||
498 | return YP.unify(outTerm, YP.makeCopy(inTerm, new Variable.CopyStore())); | ||
499 | } | ||
500 | |||
501 | public static void addUniqueVariables(object term, List<Variable> variableSet) | ||
502 | { | ||
503 | term = YP.getValue(term); | ||
504 | if (term is IUnifiable) | ||
505 | ((IUnifiable)term).addUniqueVariables(variableSet); | ||
506 | } | ||
507 | |||
508 | public static object makeCopy(object term, Variable.CopyStore copyStore) | ||
509 | { | ||
510 | term = YP.getValue(term); | ||
511 | if (term is IUnifiable) | ||
512 | return ((IUnifiable)term).makeCopy(copyStore); | ||
513 | else | ||
514 | // term is a "normal" type. Assume it is ground. | ||
515 | return term; | ||
516 | } | ||
517 | |||
518 | /// <summary> | ||
519 | /// Sort the array in place according to termLessThan. This does not remove duplicates | ||
520 | /// </summary> | ||
521 | /// <param name="array"></param> | ||
522 | public static void sortArray(object[] array) | ||
523 | { | ||
524 | Array.Sort(array, YP.compareTerms); | ||
525 | } | ||
526 | |||
527 | /// <summary> | ||
528 | /// Sort the array in place according to termLessThan. This does not remove duplicates | ||
529 | /// </summary> | ||
530 | /// <param name="array"></param> | ||
531 | public static void sortArray(List<object> array) | ||
532 | { | ||
533 | array.Sort(YP.compareTerms); | ||
534 | } | ||
535 | |||
536 | /// <summary> | ||
537 | /// Sort List according to termLessThan, remove duplicates and unify with Sorted. | ||
538 | /// </summary> | ||
539 | /// <param name="List"></param> | ||
540 | /// <param name="Sorted"></param> | ||
541 | /// <returns></returns> | ||
542 | public static IEnumerable<bool> sort(object List, object Sorted) | ||
543 | { | ||
544 | object[] array = ListPair.toArray(List); | ||
545 | if (array == null) | ||
546 | return YP.fail(); | ||
547 | if (array.Length > 1) | ||
548 | sortArray(array); | ||
549 | return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array)); | ||
550 | } | ||
551 | |||
552 | /// <summary> | ||
553 | /// Use YP.unify to unify each of the elements of the two arrays, and yield | ||
554 | /// once if they all unify. | ||
555 | /// </summary> | ||
556 | /// <param name="array1"></param> | ||
557 | /// <param name="array2"></param> | ||
558 | /// <returns></returns> | ||
559 | public static IEnumerable<bool> unifyArrays(object[] array1, object[] array2) | ||
560 | { | ||
561 | if (array1.Length != array2.Length) | ||
562 | yield break; | ||
563 | |||
564 | IEnumerator<bool>[] iterators = new IEnumerator<bool>[array1.Length]; | ||
565 | bool gotMatch = true; | ||
566 | int nIterators = 0; | ||
567 | // Try to bind all the arguments. | ||
568 | for (int i = 0; i < array1.Length; ++i) | ||
569 | { | ||
570 | IEnumerator<bool> iterator = YP.unify(array1[i], array2[i]).GetEnumerator(); | ||
571 | iterators[nIterators++] = iterator; | ||
572 | // MoveNext() is true if YP.unify succeeds. | ||
573 | if (!iterator.MoveNext()) | ||
574 | { | ||
575 | gotMatch = false; | ||
576 | break; | ||
577 | } | ||
578 | } | ||
579 | int z = 0; | ||
580 | try | ||
581 | { | ||
582 | if (gotMatch) | ||
583 | yield return false; | ||
584 | } | ||
585 | finally | ||
586 | { | ||
587 | // Manually finalize all the iterators. | ||
588 | for (z = 0; z < nIterators; ++z) | ||
589 | iterators[z].Dispose(); | ||
590 | } | ||
591 | } | ||
592 | |||
593 | /// <summary> | ||
594 | /// Return an iterator (which you can use in a for-in loop) which does | ||
595 | /// zero iterations. This returns a pre-existing iterator which is | ||
596 | /// more efficient than letting the compiler generate a new one. | ||
597 | /// </summary> | ||
598 | /// <returns></returns> | ||
599 | public static IEnumerable<bool> fail() | ||
600 | { | ||
601 | return _fail; | ||
602 | } | ||
603 | |||
604 | /// <summary> | ||
605 | /// Return an iterator (which you can use in a for-in loop) which does | ||
606 | /// one iteration. This returns a pre-existing iterator which is | ||
607 | /// more efficient than letting the compiler generate a new one. | ||
608 | /// </summary> | ||
609 | /// <returns></returns> | ||
610 | public static IEnumerable<bool> succeed() | ||
611 | { | ||
612 | return new Succeed(); | ||
613 | } | ||
614 | |||
615 | /// <summary> | ||
616 | /// Return an iterator (which you can use in a for-in loop) which repeats | ||
617 | /// indefinitely. This returns a pre-existing iterator which is | ||
618 | /// more efficient than letting the compiler generate a new one. | ||
619 | /// </summary> | ||
620 | /// <returns></returns> | ||
621 | public static IEnumerable<bool> repeat() | ||
622 | { | ||
623 | return _repeat; | ||
624 | } | ||
625 | |||
626 | // disable warning on l1, don't see how we can | ||
627 | // code this differently | ||
628 | #pragma warning disable 0168, 0219 | ||
629 | public static IEnumerable<bool> univ(object Term, object List) | ||
630 | { | ||
631 | Term = YP.getValue(Term); | ||
632 | List = YP.getValue(List); | ||
633 | |||
634 | if (nonvar(Term)) | ||
635 | return YP.unify(new ListPair | ||
636 | (getFunctorName(Term), ListPair.make(getFunctorArgs(Term))), List); | ||
637 | |||
638 | Variable Name = new Variable(); | ||
639 | Variable ArgList = new Variable(); | ||
640 | foreach (bool l1 in new ListPair(Name, ArgList).unify(List)) | ||
641 | { | ||
642 | object[] args = ListPair.toArray(ArgList); | ||
643 | if (args == null) | ||
644 | throw new PrologException | ||
645 | (new Functor2("type_error", Atom.a("list"), ArgList), | ||
646 | "Expected a list. Got: " + ArgList.getValue()); | ||
647 | if (args.Length == 0) | ||
648 | // Return the Name, even if it is not an Atom. | ||
649 | return YP.unify(Term, Name); | ||
650 | if (args.Length > MAX_ARITY) | ||
651 | throw new PrologException | ||
652 | (new Functor1("representation_error", Atom.a("max_arity")), | ||
653 | "Functor arity " + args.Length + " may not be greater than " + MAX_ARITY); | ||
654 | if (!atom(Name)) | ||
655 | throw new PrologException | ||
656 | (new Functor2("type_error", Atom.a("atom"), Name), | ||
657 | "Expected an atom. Got: " + Name.getValue()); | ||
658 | |||
659 | return YP.unify(Term, Functor.make((Atom)YP.getValue(Name), args)); | ||
660 | } | ||
661 | |||
662 | return YP.fail(); | ||
663 | } | ||
664 | |||
665 | public static IEnumerable<bool> functor(object Term, object FunctorName, object Arity) | ||
666 | { | ||
667 | Term = YP.getValue(Term); | ||
668 | FunctorName = YP.getValue(FunctorName); | ||
669 | Arity = YP.getValue(Arity); | ||
670 | |||
671 | if (Term is Variable) | ||
672 | { | ||
673 | if (FunctorName is Variable) | ||
674 | throw new PrologException(Atom.a("instantiation_error"), | ||
675 | "Arg 2 FunctorName is an unbound variable"); | ||
676 | if (Arity is Variable) | ||
677 | throw new PrologException(Atom.a("instantiation_error"), | ||
678 | "Arg 3 Arity is an unbound variable"); | ||
679 | if (!(Arity is int)) | ||
680 | throw new PrologException | ||
681 | (new Functor2("type_error", Atom.a("integer"), Arity), "Arity is not an integer"); | ||
682 | if (!YP.atomic(FunctorName)) | ||
683 | throw new PrologException | ||
684 | (new Functor2("type_error", Atom.a("atomic"), FunctorName), "FunctorName is not atomic"); | ||
685 | |||
686 | if ((int)Arity < 0) | ||
687 | throw new PrologException | ||
688 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), Arity), | ||
689 | "Arity may not be less than zero"); | ||
690 | else if ((int)Arity == 0) | ||
691 | { | ||
692 | // Just unify Term with the atomic FunctorName. | ||
693 | foreach (bool l1 in YP.unify(Term, FunctorName)) | ||
694 | yield return false; | ||
695 | } | ||
696 | else | ||
697 | { | ||
698 | if ((int)Arity > MAX_ARITY) | ||
699 | throw new PrologException | ||
700 | (new Functor1("representation_error", Atom.a("max_arity")), | ||
701 | "Functor arity " + Arity + " may not be greater than " + MAX_ARITY); | ||
702 | if (!(FunctorName is Atom)) | ||
703 | throw new PrologException | ||
704 | (new Functor2("type_error", Atom.a("atom"), FunctorName), "FunctorName is not an atom"); | ||
705 | // Construct a functor with unbound variables. | ||
706 | object[] args = new object[(int)Arity]; | ||
707 | for (int i = 0; i < args.Length; ++i) | ||
708 | args[i] = new Variable(); | ||
709 | foreach (bool l1 in YP.unify(Term, Functor.make((Atom)FunctorName, args))) | ||
710 | yield return false; | ||
711 | } | ||
712 | } | ||
713 | else | ||
714 | { | ||
715 | foreach (bool l1 in YP.unify(FunctorName, getFunctorName(Term))) | ||
716 | { | ||
717 | foreach (bool l2 in YP.unify(Arity, getFunctorArgs(Term).Length)) | ||
718 | yield return false; | ||
719 | } | ||
720 | } | ||
721 | } | ||
722 | |||
723 | public static IEnumerable<bool> arg(object ArgNumber, object Term, object Value) | ||
724 | { | ||
725 | if (var(ArgNumber)) | ||
726 | throw new PrologException(Atom.a("instantiation_error"), "Arg 1 ArgNumber is an unbound variable"); | ||
727 | int argNumberInt; | ||
728 | if (!getInt(ArgNumber, out argNumberInt)) | ||
729 | throw new PrologException | ||
730 | (new Functor2("type_error", Atom.a("integer"), ArgNumber), "Arg 1 ArgNumber must be integer"); | ||
731 | if (argNumberInt < 0) | ||
732 | throw new PrologException | ||
733 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), argNumberInt), | ||
734 | "ArgNumber may not be less than zero"); | ||
735 | |||
736 | if (YP.var(Term)) | ||
737 | throw new PrologException(Atom.a("instantiation_error"), | ||
738 | "Arg 2 Term is an unbound variable"); | ||
739 | if (!YP.compound(Term)) | ||
740 | throw new PrologException | ||
741 | (new Functor2("type_error", Atom.a("compound"), Term), "Arg 2 Term must be compound"); | ||
742 | |||
743 | object[] termArgs = YP.getFunctorArgs(Term); | ||
744 | // Silently fail if argNumberInt is out of range. | ||
745 | if (argNumberInt >= 1 && argNumberInt <= termArgs.Length) | ||
746 | { | ||
747 | // The first ArgNumber is at 1, not 0. | ||
748 | foreach (bool l1 in YP.unify(Value, termArgs[argNumberInt - 1])) | ||
749 | yield return false; | ||
750 | } | ||
751 | } | ||
752 | |||
753 | public static bool termEqual(object Term1, object Term2) | ||
754 | { | ||
755 | Term1 = YP.getValue(Term1); | ||
756 | if (Term1 is IUnifiable) | ||
757 | return ((IUnifiable)Term1).termEqual(Term2); | ||
758 | return Term1.Equals(YP.getValue(Term2)); | ||
759 | } | ||
760 | |||
761 | public static bool termNotEqual(object Term1, object Term2) | ||
762 | { | ||
763 | return !termEqual(Term1, Term2); | ||
764 | } | ||
765 | |||
766 | public static bool termLessThan(object Term1, object Term2) | ||
767 | { | ||
768 | Term1 = YP.getValue(Term1); | ||
769 | Term2 = YP.getValue(Term2); | ||
770 | int term1TypeCode = getTypeCode(Term1); | ||
771 | int term2TypeCode = getTypeCode(Term2); | ||
772 | if (term1TypeCode != term2TypeCode) | ||
773 | return term1TypeCode < term2TypeCode; | ||
774 | |||
775 | // The terms are the same type code. | ||
776 | if (term1TypeCode == -2) | ||
777 | { | ||
778 | // Variable. | ||
779 | // We always check for equality first because we want to be sure | ||
780 | // that less than returns false if the terms are equal, in | ||
781 | // case that the less than check really behaves like less than or equal. | ||
782 | if ((Variable)Term1 != (Variable)Term2) | ||
783 | // The hash code should be unique to a Variable object. | ||
784 | return Term1.GetHashCode() < Term2.GetHashCode(); | ||
785 | return false; | ||
786 | } | ||
787 | if (term1TypeCode == 0) | ||
788 | return ((Atom)Term1)._name.CompareTo(((Atom)Term2)._name) < 0; | ||
789 | if (term1TypeCode == 1) | ||
790 | return ((Functor1)Term1).lessThan((Functor1)Term2); | ||
791 | if (term1TypeCode == 2) | ||
792 | return ((Functor2)Term1).lessThan((Functor2)Term2); | ||
793 | if (term1TypeCode == 3) | ||
794 | return ((Functor3)Term1).lessThan((Functor3)Term2); | ||
795 | if (term1TypeCode == 4) | ||
796 | return ((Functor)Term1).lessThan((Functor)Term2); | ||
797 | |||
798 | // Type code is -1 for general objects. First compare their type names. | ||
799 | // Note that this puts Double before Int32 as required by ISO Prolog. | ||
800 | string term1TypeName = Term1.GetType().ToString(); | ||
801 | string term2TypeName = Term2.GetType().ToString(); | ||
802 | if (term1TypeName != term2TypeName) | ||
803 | return term1TypeName.CompareTo(term2TypeName) < 0; | ||
804 | |||
805 | // The terms are the same type name. | ||
806 | if (Term1 is int) | ||
807 | return (int)Term1 < (int)Term2; | ||
808 | else if (Term1 is double) | ||
809 | return (double)Term1 < (double)Term2; | ||
810 | else if (Term1 is DateTime) | ||
811 | return (DateTime)Term1 < (DateTime)Term2; | ||
812 | else if (Term1 is String) | ||
813 | return ((String)Term1).CompareTo((String)Term2) < 0; | ||
814 | // Debug: Should we try arrays, etc.? | ||
815 | |||
816 | if (!Term1.Equals(Term2)) | ||
817 | // Could be equal or greater than. | ||
818 | return Term1.GetHashCode() < Term2.GetHashCode(); | ||
819 | return false; | ||
820 | } | ||
821 | |||
822 | /// <summary> | ||
823 | /// Type code is -2 if term is a Variable, 0 if it is an Atom, | ||
824 | /// 1 if it is a Functor1, 2 if it is a Functor2, 3 if it is a Functor3, | ||
825 | /// 4 if it is Functor. | ||
826 | /// Otherwise, type code is -1. | ||
827 | /// This does not call YP.getValue(term). | ||
828 | /// </summary> | ||
829 | /// <param name="term"></param> | ||
830 | /// <returns></returns> | ||
831 | private static int getTypeCode(object term) | ||
832 | { | ||
833 | if (term is Variable) | ||
834 | return -2; | ||
835 | else if (term is Atom) | ||
836 | return 0; | ||
837 | else if (term is Functor1) | ||
838 | return 1; | ||
839 | else if (term is Functor2) | ||
840 | return 2; | ||
841 | else if (term is Functor3) | ||
842 | return 3; | ||
843 | else if (term is Functor) | ||
844 | return 4; | ||
845 | else | ||
846 | return -1; | ||
847 | } | ||
848 | |||
849 | public static bool termLessThanOrEqual(object Term1, object Term2) | ||
850 | { | ||
851 | if (YP.termEqual(Term1, Term2)) | ||
852 | return true; | ||
853 | return YP.termLessThan(Term1, Term2); | ||
854 | } | ||
855 | |||
856 | public static bool termGreaterThan(object Term1, object Term2) | ||
857 | { | ||
858 | return !YP.termLessThanOrEqual(Term1, Term2); | ||
859 | } | ||
860 | |||
861 | public static bool termGreaterThanOrEqual(object Term1, object Term2) | ||
862 | { | ||
863 | // termLessThan should ensure that it returns false if terms are equal, | ||
864 | // so that this would return true. | ||
865 | return !YP.termLessThan(Term1, Term2); | ||
866 | } | ||
867 | |||
868 | public static int compareTerms(object Term1, object Term2) | ||
869 | { | ||
870 | if (YP.termEqual(Term1, Term2)) | ||
871 | return 0; | ||
872 | else if (YP.termLessThan(Term1, Term2)) | ||
873 | return -1; | ||
874 | else | ||
875 | return 1; | ||
876 | } | ||
877 | |||
878 | public static bool ground(object Term) | ||
879 | { | ||
880 | Term = YP.getValue(Term); | ||
881 | if (Term is IUnifiable) | ||
882 | return ((IUnifiable)Term).ground(); | ||
883 | return true; | ||
884 | } | ||
885 | |||
886 | public static IEnumerable<bool> current_op | ||
887 | (object Priority, object Specifier, object Operator) | ||
888 | { | ||
889 | if (_operatorTable == null) | ||
890 | { | ||
891 | // Initialize. | ||
892 | _operatorTable = new IndexedAnswers(3); | ||
893 | _operatorTable.addAnswer(new object[] { 1200, Atom.a("xfx"), Atom.a(":-") }); | ||
894 | _operatorTable.addAnswer(new object[] { 1200, Atom.a("xfx"), Atom.a("-->") }); | ||
895 | _operatorTable.addAnswer(new object[] { 1200, Atom.a("fx"), Atom.a(":-") }); | ||
896 | _operatorTable.addAnswer(new object[] { 1200, Atom.a("fx"), Atom.a("?-") }); | ||
897 | _operatorTable.addAnswer(new object[] { 1100, Atom.a("xfy"), Atom.a(";") }); | ||
898 | _operatorTable.addAnswer(new object[] { 1050, Atom.a("xfy"), Atom.a("->") }); | ||
899 | _operatorTable.addAnswer(new object[] { 1000, Atom.a("xfy"), Atom.a(",") }); | ||
900 | _operatorTable.addAnswer(new object[] { 900, Atom.a("fy"), Atom.a("\\+") }); | ||
901 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=") }); | ||
902 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("\\=") }); | ||
903 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("==") }); | ||
904 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("\\==") }); | ||
905 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@<") }); | ||
906 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@=<") }); | ||
907 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@>") }); | ||
908 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("@>=") }); | ||
909 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=..") }); | ||
910 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("is") }); | ||
911 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=:=") }); | ||
912 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=\\=") }); | ||
913 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("<") }); | ||
914 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a("=<") }); | ||
915 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a(">") }); | ||
916 | _operatorTable.addAnswer(new object[] { 700, Atom.a("xfx"), Atom.a(">=") }); | ||
917 | _operatorTable.addAnswer(new object[] { 600, Atom.a("xfy"), Atom.a(":") }); | ||
918 | _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("+") }); | ||
919 | _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("-") }); | ||
920 | _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("/\\") }); | ||
921 | _operatorTable.addAnswer(new object[] { 500, Atom.a("yfx"), Atom.a("\\/") }); | ||
922 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("*") }); | ||
923 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("/") }); | ||
924 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("//") }); | ||
925 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("rem") }); | ||
926 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("mod") }); | ||
927 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a("<<") }); | ||
928 | _operatorTable.addAnswer(new object[] { 400, Atom.a("yfx"), Atom.a(">>") }); | ||
929 | _operatorTable.addAnswer(new object[] { 200, Atom.a("xfx"), Atom.a("**") }); | ||
930 | _operatorTable.addAnswer(new object[] { 200, Atom.a("xfy"), Atom.a("^") }); | ||
931 | _operatorTable.addAnswer(new object[] { 200, Atom.a("fy"), Atom.a("-") }); | ||
932 | _operatorTable.addAnswer(new object[] { 200, Atom.a("fy"), Atom.a("\\") }); | ||
933 | // Debug: This is hacked in to run the Prolog test suite until we implement op/3. | ||
934 | _operatorTable.addAnswer(new object[] { 20, Atom.a("xfx"), Atom.a("<--") }); | ||
935 | } | ||
936 | |||
937 | return _operatorTable.match(new object[] { Priority, Specifier, Operator }); | ||
938 | } | ||
939 | |||
940 | public static IEnumerable<bool> atom_length(object atom, object Length) | ||
941 | { | ||
942 | atom = YP.getValue(atom); | ||
943 | Length = YP.getValue(Length); | ||
944 | if (atom is Variable) | ||
945 | throw new PrologException(Atom.a("instantiation_error"), | ||
946 | "Expected atom(Arg1) but it is an unbound variable"); | ||
947 | if (!(atom is Atom)) | ||
948 | throw new PrologException | ||
949 | (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not an atom"); | ||
950 | if (!(Length is Variable)) | ||
951 | { | ||
952 | if (!(Length is int)) | ||
953 | throw new PrologException | ||
954 | (new Functor2("type_error", Atom.a("integer"), Length), "Length must be var or integer"); | ||
955 | if ((int)Length < 0) | ||
956 | throw new PrologException | ||
957 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), Length), | ||
958 | "Length must not be less than zero"); | ||
959 | } | ||
960 | return YP.unify(Length, ((Atom)atom)._name.Length); | ||
961 | } | ||
962 | |||
963 | public static IEnumerable<bool> atom_concat(object Start, object End, object Whole) | ||
964 | { | ||
965 | // Debug: Should we try to preserve the _declaringClass? | ||
966 | Start = YP.getValue(Start); | ||
967 | End = YP.getValue(End); | ||
968 | Whole = YP.getValue(Whole); | ||
969 | if (Whole is Variable) | ||
970 | { | ||
971 | if (Start is Variable) | ||
972 | throw new PrologException(Atom.a("instantiation_error"), | ||
973 | "Arg 1 Start and arg 3 Whole are both var"); | ||
974 | if (End is Variable) | ||
975 | throw new PrologException(Atom.a("instantiation_error"), | ||
976 | "Arg 2 End and arg 3 Whole are both var"); | ||
977 | if (!(Start is Atom)) | ||
978 | throw new PrologException | ||
979 | (new Functor2("type_error", Atom.a("atom"), Start), "Arg 1 Start is not an atom"); | ||
980 | if (!(End is Atom)) | ||
981 | throw new PrologException | ||
982 | (new Functor2("type_error", Atom.a("atom"), End), "Arg 2 End is not an atom"); | ||
983 | |||
984 | foreach (bool l1 in YP.unify(Whole, Atom.a(((Atom)Start)._name + ((Atom)End)._name))) | ||
985 | yield return false; | ||
986 | } | ||
987 | else | ||
988 | { | ||
989 | if (!(Whole is Atom)) | ||
990 | throw new PrologException | ||
991 | (new Functor2("type_error", Atom.a("atom"), Whole), "Arg 3 Whole is not an atom"); | ||
992 | bool gotStartLength = false; | ||
993 | int startLength = 0; | ||
994 | if (!(Start is Variable)) | ||
995 | { | ||
996 | if (!(Start is Atom)) | ||
997 | throw new PrologException | ||
998 | (new Functor2("type_error", Atom.a("atom"), Start), "Arg 1 Start is not var or atom"); | ||
999 | startLength = ((Atom)Start)._name.Length; | ||
1000 | gotStartLength = true; | ||
1001 | } | ||
1002 | |||
1003 | bool gotEndLength = false; | ||
1004 | int endLength = 0; | ||
1005 | if (!(End is Variable)) | ||
1006 | { | ||
1007 | if (!(End is Atom)) | ||
1008 | throw new PrologException | ||
1009 | (new Functor2("type_error", Atom.a("atom"), End), "Arg 2 End is not var or atom"); | ||
1010 | endLength = ((Atom)End)._name.Length; | ||
1011 | gotEndLength = true; | ||
1012 | } | ||
1013 | |||
1014 | // We are doing a search through all possible Start and End which concatenate to Whole. | ||
1015 | string wholeString = ((Atom)Whole)._name; | ||
1016 | for (int i = 0; i <= wholeString.Length; ++i) | ||
1017 | { | ||
1018 | // If we got either startLength or endLength, we know the lengths have to match so check | ||
1019 | // the lengths instead of constructing an Atom to do it. | ||
1020 | if (gotStartLength && startLength != i) | ||
1021 | continue; | ||
1022 | if (gotEndLength && endLength != wholeString.Length - i) | ||
1023 | continue; | ||
1024 | foreach (bool l1 in YP.unify(Start, Atom.a(wholeString.Substring(0, i)))) | ||
1025 | { | ||
1026 | foreach (bool l2 in YP.unify(End, Atom.a(wholeString.Substring(i, wholeString.Length - i)))) | ||
1027 | yield return false; | ||
1028 | } | ||
1029 | } | ||
1030 | } | ||
1031 | } | ||
1032 | |||
1033 | public static IEnumerable<bool> sub_atom | ||
1034 | (object atom, object Before, object Length, object After, object Sub_atom) | ||
1035 | { | ||
1036 | // Debug: Should we try to preserve the _declaringClass? | ||
1037 | atom = YP.getValue(atom); | ||
1038 | Before = YP.getValue(Before); | ||
1039 | Length = YP.getValue(Length); | ||
1040 | After = YP.getValue(After); | ||
1041 | Sub_atom = YP.getValue(Sub_atom); | ||
1042 | if (atom is Variable) | ||
1043 | throw new PrologException(Atom.a("instantiation_error"), | ||
1044 | "Expected atom(Arg1) but it is an unbound variable"); | ||
1045 | if (!(atom is Atom)) | ||
1046 | throw new PrologException | ||
1047 | (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not an atom"); | ||
1048 | if (!(Sub_atom is Variable)) | ||
1049 | { | ||
1050 | if (!(Sub_atom is Atom)) | ||
1051 | throw new PrologException | ||
1052 | (new Functor2("type_error", Atom.a("atom"), Sub_atom), "Sub_atom is not var or atom"); | ||
1053 | } | ||
1054 | |||
1055 | bool beforeIsInt = false; | ||
1056 | bool lengthIsInt = false; | ||
1057 | bool afterIsInt = false; | ||
1058 | if (!(Before is Variable)) | ||
1059 | { | ||
1060 | if (!(Before is int)) | ||
1061 | throw new PrologException | ||
1062 | (new Functor2("type_error", Atom.a("integer"), Before), "Before must be var or integer"); | ||
1063 | beforeIsInt = true; | ||
1064 | if ((int)Before < 0) | ||
1065 | throw new PrologException | ||
1066 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), Before), | ||
1067 | "Before must not be less than zero"); | ||
1068 | } | ||
1069 | if (!(Length is Variable)) | ||
1070 | { | ||
1071 | if (!(Length is int)) | ||
1072 | throw new PrologException | ||
1073 | (new Functor2("type_error", Atom.a("integer"), Length), "Length must be var or integer"); | ||
1074 | lengthIsInt = true; | ||
1075 | if ((int)Length < 0) | ||
1076 | throw new PrologException | ||
1077 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), Length), | ||
1078 | "Length must not be less than zero"); | ||
1079 | } | ||
1080 | if (!(After is Variable)) | ||
1081 | { | ||
1082 | if (!(After is int)) | ||
1083 | throw new PrologException | ||
1084 | (new Functor2("type_error", Atom.a("integer"), After), "After must be var or integer"); | ||
1085 | afterIsInt = true; | ||
1086 | if ((int)After < 0) | ||
1087 | throw new PrologException | ||
1088 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), After), | ||
1089 | "After must not be less than zero"); | ||
1090 | } | ||
1091 | |||
1092 | Atom atomAtom = (Atom)atom; | ||
1093 | int atomLength = atomAtom._name.Length; | ||
1094 | if (beforeIsInt && lengthIsInt) | ||
1095 | { | ||
1096 | // Special case: the caller is just trying to extract a substring, so do it quickly. | ||
1097 | int xAfter = atomLength - (int)Before - (int)Length; | ||
1098 | if (xAfter >= 0) | ||
1099 | { | ||
1100 | foreach (bool l1 in YP.unify(After, xAfter)) | ||
1101 | { | ||
1102 | foreach (bool l2 in YP.unify | ||
1103 | (Sub_atom, Atom.a(atomAtom._name.Substring((int)Before, (int)Length)))) | ||
1104 | yield return false; | ||
1105 | } | ||
1106 | } | ||
1107 | } | ||
1108 | else if (afterIsInt && lengthIsInt) | ||
1109 | { | ||
1110 | // Special case: the caller is just trying to extract a substring, so do it quickly. | ||
1111 | int xBefore = atomLength - (int)After - (int)Length; | ||
1112 | if (xBefore >= 0) | ||
1113 | { | ||
1114 | foreach (bool l1 in YP.unify(Before, xBefore)) | ||
1115 | { | ||
1116 | foreach (bool l2 in YP.unify | ||
1117 | (Sub_atom, Atom.a(atomAtom._name.Substring(xBefore, (int)Length)))) | ||
1118 | yield return false; | ||
1119 | } | ||
1120 | } | ||
1121 | } | ||
1122 | else | ||
1123 | { | ||
1124 | // We are underconstrained and doing a search, so go through all possibilities. | ||
1125 | for (int xBefore = 0; xBefore <= atomLength; ++xBefore) | ||
1126 | { | ||
1127 | foreach (bool l1 in YP.unify(Before, xBefore)) | ||
1128 | { | ||
1129 | for (int xLength = 0; xLength <= (atomLength - xBefore); ++xLength) | ||
1130 | { | ||
1131 | foreach (bool l2 in YP.unify(Length, xLength)) | ||
1132 | { | ||
1133 | foreach (bool l3 in YP.unify(After, atomLength - (xBefore + xLength))) | ||
1134 | { | ||
1135 | foreach (bool l4 in YP.unify | ||
1136 | (Sub_atom, Atom.a(atomAtom._name.Substring(xBefore, xLength)))) | ||
1137 | yield return false; | ||
1138 | } | ||
1139 | } | ||
1140 | } | ||
1141 | } | ||
1142 | } | ||
1143 | } | ||
1144 | } | ||
1145 | |||
1146 | public static IEnumerable<bool> atom_chars(object atom, object List) | ||
1147 | { | ||
1148 | atom = YP.getValue(atom); | ||
1149 | List = YP.getValue(List); | ||
1150 | |||
1151 | if (atom is Variable) | ||
1152 | { | ||
1153 | if (List is Variable) | ||
1154 | throw new PrologException(Atom.a("instantiation_error"), | ||
1155 | "Arg 1 Atom and arg 2 List are both unbound variables"); | ||
1156 | object[] codeArray = ListPair.toArray(List); | ||
1157 | if (codeArray == null) | ||
1158 | throw new PrologException | ||
1159 | (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); | ||
1160 | |||
1161 | char[] charArray = new char[codeArray.Length]; | ||
1162 | for (int i = 0; i < codeArray.Length; ++i) | ||
1163 | { | ||
1164 | object listAtom = YP.getValue(codeArray[i]); | ||
1165 | if (listAtom is Variable) | ||
1166 | throw new PrologException(Atom.a("instantiation_error"), | ||
1167 | "Arg 2 List has an element which is an unbound variable"); | ||
1168 | if (!(listAtom is Atom && ((Atom)listAtom)._name.Length == 1)) | ||
1169 | throw new PrologException | ||
1170 | (new Functor2("type_error", Atom.a("character"), listAtom), | ||
1171 | "Arg 2 List has an element which is not a one character atom"); | ||
1172 | charArray[i] = ((Atom)listAtom)._name[0]; | ||
1173 | } | ||
1174 | return YP.unify(atom, Atom.a(new String(charArray))); | ||
1175 | } | ||
1176 | else | ||
1177 | { | ||
1178 | if (!(atom is Atom)) | ||
1179 | throw new PrologException | ||
1180 | (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not var or atom"); | ||
1181 | |||
1182 | string atomString = ((Atom)atom)._name; | ||
1183 | object charList = Atom.NIL; | ||
1184 | // Start from the back to make the list. | ||
1185 | for (int i = atomString.Length - 1; i >= 0; --i) | ||
1186 | charList = new ListPair(Atom.a(atomString.Substring(i, 1)), charList); | ||
1187 | return YP.unify(List, charList); | ||
1188 | } | ||
1189 | } | ||
1190 | |||
1191 | public static IEnumerable<bool> atom_codes(object atom, object List) | ||
1192 | { | ||
1193 | atom = YP.getValue(atom); | ||
1194 | List = YP.getValue(List); | ||
1195 | |||
1196 | if (atom is Variable) | ||
1197 | { | ||
1198 | if (List is Variable) | ||
1199 | throw new PrologException(Atom.a("instantiation_error"), | ||
1200 | "Arg 1 Atom and arg 2 List are both unbound variables"); | ||
1201 | object[] codeArray = ListPair.toArray(List); | ||
1202 | if (codeArray == null) | ||
1203 | throw new PrologException | ||
1204 | (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); | ||
1205 | |||
1206 | char[] charArray = new char[codeArray.Length]; | ||
1207 | for (int i = 0; i < codeArray.Length; ++i) | ||
1208 | { | ||
1209 | int codeInt; | ||
1210 | if (!getInt(codeArray[i], out codeInt) || codeInt < 0) | ||
1211 | throw new PrologException | ||
1212 | (new Functor1("representation_error", Atom.a("character_code")), | ||
1213 | "Element of Arg 2 List is not a character code"); | ||
1214 | charArray[i] = (char)codeInt; | ||
1215 | } | ||
1216 | return YP.unify(atom, Atom.a(new String(charArray))); | ||
1217 | } | ||
1218 | else | ||
1219 | { | ||
1220 | if (!(atom is Atom)) | ||
1221 | throw new PrologException | ||
1222 | (new Functor2("type_error", Atom.a("atom"), atom), "Arg 1 Atom is not var or atom"); | ||
1223 | |||
1224 | string atomString = ((Atom)atom)._name; | ||
1225 | object codeList = Atom.NIL; | ||
1226 | // Start from the back to make the list. | ||
1227 | for (int i = atomString.Length - 1; i >= 0; --i) | ||
1228 | codeList = new ListPair((int)atomString[i], codeList); | ||
1229 | return YP.unify(List, codeList); | ||
1230 | } | ||
1231 | } | ||
1232 | |||
1233 | public static IEnumerable<bool> number_chars(object Number, object List) | ||
1234 | { | ||
1235 | Number = YP.getValue(Number); | ||
1236 | List = YP.getValue(List); | ||
1237 | |||
1238 | if (Number is Variable) | ||
1239 | { | ||
1240 | if (List is Variable) | ||
1241 | throw new PrologException(Atom.a("instantiation_error"), | ||
1242 | "Arg 1 Number and arg 2 List are both unbound variables"); | ||
1243 | object[] codeArray = ListPair.toArray(List); | ||
1244 | if (codeArray == null) | ||
1245 | throw new PrologException | ||
1246 | (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); | ||
1247 | |||
1248 | char[] charArray = new char[codeArray.Length]; | ||
1249 | for (int i = 0; i < codeArray.Length; ++i) | ||
1250 | { | ||
1251 | object listAtom = YP.getValue(codeArray[i]); | ||
1252 | if (listAtom is Variable) | ||
1253 | throw new PrologException(Atom.a("instantiation_error"), | ||
1254 | "Arg 2 List has an element which is an unbound variable"); | ||
1255 | if (!(listAtom is Atom && ((Atom)listAtom)._name.Length == 1)) | ||
1256 | throw new PrologException | ||
1257 | (new Functor2("type_error", Atom.a("character"), listAtom), | ||
1258 | "Arg 2 List has an element which is not a one character atom"); | ||
1259 | charArray[i] = ((Atom)listAtom)._name[0]; | ||
1260 | } | ||
1261 | return YP.unify(Number, parseNumberString(charArray)); | ||
1262 | } | ||
1263 | else | ||
1264 | { | ||
1265 | string numberString = null; | ||
1266 | // Try converting to an int first. | ||
1267 | int intNumber; | ||
1268 | if (YP.getInt(Number, out intNumber)) | ||
1269 | numberString = intNumber.ToString(); | ||
1270 | else | ||
1271 | { | ||
1272 | if (!YP.number(Number)) | ||
1273 | throw new PrologException | ||
1274 | (new Functor2("type_error", Atom.a("number"), Number), | ||
1275 | "Arg 1 Number is not var or number"); | ||
1276 | // We just checked, so convertDouble shouldn't throw an exception. | ||
1277 | numberString = YP.doubleToString(YP.convertDouble(Number)); | ||
1278 | } | ||
1279 | |||
1280 | object charList = Atom.NIL; | ||
1281 | // Start from the back to make the list. | ||
1282 | for (int i = numberString.Length - 1; i >= 0; --i) | ||
1283 | charList = new ListPair(Atom.a(numberString.Substring(i, 1)), charList); | ||
1284 | return YP.unify(List, charList); | ||
1285 | } | ||
1286 | } | ||
1287 | |||
1288 | public static IEnumerable<bool> number_codes(object Number, object List) | ||
1289 | { | ||
1290 | Number = YP.getValue(Number); | ||
1291 | List = YP.getValue(List); | ||
1292 | |||
1293 | if (Number is Variable) | ||
1294 | { | ||
1295 | if (List is Variable) | ||
1296 | throw new PrologException(Atom.a("instantiation_error"), | ||
1297 | "Arg 1 Number and arg 2 List are both unbound variables"); | ||
1298 | object[] codeArray = ListPair.toArray(List); | ||
1299 | if (codeArray == null) | ||
1300 | throw new PrologException | ||
1301 | (new Functor2("type_error", Atom.a("list"), List), "Arg 2 List is not a list"); | ||
1302 | |||
1303 | char[] charArray = new char[codeArray.Length]; | ||
1304 | for (int i = 0; i < codeArray.Length; ++i) | ||
1305 | { | ||
1306 | int codeInt; | ||
1307 | if (!getInt(codeArray[i], out codeInt) || codeInt < 0) | ||
1308 | throw new PrologException | ||
1309 | (new Functor1("representation_error", Atom.a("character_code")), | ||
1310 | "Element of Arg 2 List is not a character code"); | ||
1311 | charArray[i] = (char)codeInt; | ||
1312 | } | ||
1313 | return YP.unify(Number, parseNumberString(charArray)); | ||
1314 | } | ||
1315 | else | ||
1316 | { | ||
1317 | string numberString = null; | ||
1318 | // Try converting to an int first. | ||
1319 | int intNumber; | ||
1320 | if (YP.getInt(Number, out intNumber)) | ||
1321 | numberString = intNumber.ToString(); | ||
1322 | else | ||
1323 | { | ||
1324 | if (!YP.number(Number)) | ||
1325 | throw new PrologException | ||
1326 | (new Functor2("type_error", Atom.a("number"), Number), | ||
1327 | "Arg 1 Number is not var or number"); | ||
1328 | // We just checked, so convertDouble shouldn't throw an exception. | ||
1329 | numberString = YP.doubleToString(YP.convertDouble(Number)); | ||
1330 | } | ||
1331 | |||
1332 | object codeList = Atom.NIL; | ||
1333 | // Start from the back to make the list. | ||
1334 | for (int i = numberString.Length - 1; i >= 0; --i) | ||
1335 | codeList = new ListPair((int)numberString[i], codeList); | ||
1336 | return YP.unify(List, codeList); | ||
1337 | } | ||
1338 | } | ||
1339 | |||
1340 | /// <summary> | ||
1341 | /// Used by number_chars and number_codes. Return the number in charArray or | ||
1342 | /// throw an exception if can't parse. | ||
1343 | /// </summary> | ||
1344 | /// <param name="numberString"></param> | ||
1345 | /// <returns></returns> | ||
1346 | private static object parseNumberString(char[] charArray) | ||
1347 | { | ||
1348 | string numberString = new String(charArray); | ||
1349 | if (charArray.Length == 3 && numberString.StartsWith("0'")) | ||
1350 | // This is a char code. | ||
1351 | return (int)charArray[2]; | ||
1352 | if (numberString.StartsWith("0x")) | ||
1353 | { | ||
1354 | try | ||
1355 | { | ||
1356 | return Int32.Parse | ||
1357 | (numberString.Substring(2), System.Globalization.NumberStyles.AllowHexSpecifier); | ||
1358 | } | ||
1359 | catch (FormatException) | ||
1360 | { | ||
1361 | throw new PrologException | ||
1362 | (new Functor1("syntax_error", Atom.a("number_format: " + numberString)), | ||
1363 | "Arg 2 List is not a list for a hexadecimal number"); | ||
1364 | } | ||
1365 | } | ||
1366 | // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception? | ||
1367 | try | ||
1368 | { | ||
1369 | // Try an int first. | ||
1370 | return Convert.ToInt32(numberString); | ||
1371 | } | ||
1372 | catch (FormatException) { } | ||
1373 | try | ||
1374 | { | ||
1375 | return Convert.ToDouble(numberString); | ||
1376 | } | ||
1377 | catch (FormatException) | ||
1378 | { | ||
1379 | throw new PrologException | ||
1380 | (new Functor1("syntax_error", Atom.a("number_format: " + numberString)), | ||
1381 | "Arg 2 List is not a list for a number"); | ||
1382 | } | ||
1383 | } | ||
1384 | |||
1385 | public static IEnumerable<bool> char_code(object Char, object Code) | ||
1386 | { | ||
1387 | Char = YP.getValue(Char); | ||
1388 | Code = YP.getValue(Code); | ||
1389 | |||
1390 | int codeInt = 0; | ||
1391 | if (!(Code is Variable)) | ||
1392 | { | ||
1393 | // Get codeInt now so we type check it whether or not Char is Variable. | ||
1394 | if (!getInt(Code, out codeInt)) | ||
1395 | throw new PrologException | ||
1396 | (new Functor2("type_error", Atom.a("integer"), Code), | ||
1397 | "Arg 2 Code is not var or a character code"); | ||
1398 | if (codeInt < 0) | ||
1399 | throw new PrologException | ||
1400 | (new Functor1("representation_error", Atom.a("character_code")), | ||
1401 | "Arg 2 Code is not a character code"); | ||
1402 | } | ||
1403 | |||
1404 | if (Char is Variable) | ||
1405 | { | ||
1406 | if (Code is Variable) | ||
1407 | throw new PrologException(Atom.a("instantiation_error"), | ||
1408 | "Arg 1 Char and arg 2 Code are both unbound variables"); | ||
1409 | |||
1410 | return YP.unify(Char, Atom.a(new String(new char[] {(char)codeInt}))); | ||
1411 | } | ||
1412 | else | ||
1413 | { | ||
1414 | if (!(Char is Atom) || ((Atom)Char)._name.Length != 1) | ||
1415 | throw new PrologException | ||
1416 | (new Functor2("type_error", Atom.a("character"), Char), | ||
1417 | "Arg 1 Char is not var or one-character atom"); | ||
1418 | |||
1419 | if (Code is Variable) | ||
1420 | return YP.unify(Code, (int)((Atom)Char)._name[0]); | ||
1421 | else | ||
1422 | // Use codeInt to handle whether Code is supplied as, e.g., 97 or 0'a . | ||
1423 | return YP.unify(codeInt, (int)((Atom)Char)._name[0]); | ||
1424 | } | ||
1425 | } | ||
1426 | |||
1427 | /// <summary> | ||
1428 | /// If term is an Atom or functor type, return its name. | ||
1429 | /// Otherwise, return term. | ||
1430 | /// </summary> | ||
1431 | /// <param name="term"></param> | ||
1432 | /// <returns></returns> | ||
1433 | public static object getFunctorName(object term) | ||
1434 | { | ||
1435 | term = YP.getValue(term); | ||
1436 | if (term is Functor1) | ||
1437 | return ((Functor1)term)._name; | ||
1438 | else if (term is Functor2) | ||
1439 | return ((Functor2)term)._name; | ||
1440 | else if (term is Functor3) | ||
1441 | return ((Functor3)term)._name; | ||
1442 | else if (term is Functor) | ||
1443 | return ((Functor)term)._name; | ||
1444 | else | ||
1445 | return term; | ||
1446 | } | ||
1447 | |||
1448 | /// <summary> | ||
1449 | /// If term is an Atom or functor type, return an array of its args. | ||
1450 | /// Otherwise, return an empty array. | ||
1451 | /// </summary> | ||
1452 | /// <param name="term"></param> | ||
1453 | /// <returns></returns> | ||
1454 | public static object[] getFunctorArgs(object term) | ||
1455 | { | ||
1456 | term = YP.getValue(term); | ||
1457 | if (term is Functor1) | ||
1458 | { | ||
1459 | Functor1 functor = (Functor1)term; | ||
1460 | return new object[] { functor._arg1 }; | ||
1461 | } | ||
1462 | else if (term is Functor2) | ||
1463 | { | ||
1464 | Functor2 functor = (Functor2)term; | ||
1465 | return new object[] { functor._arg1, functor._arg2 }; | ||
1466 | } | ||
1467 | else if (term is Functor3) | ||
1468 | { | ||
1469 | Functor3 functor = (Functor3)term; | ||
1470 | return new object[] { functor._arg1, functor._arg2, functor._arg3 }; | ||
1471 | } | ||
1472 | else if (term is Functor) { | ||
1473 | Functor functor = (Functor)term; | ||
1474 | return functor._args; | ||
1475 | } | ||
1476 | else | ||
1477 | return new object[0]; | ||
1478 | } | ||
1479 | |||
1480 | public static bool var(object Term) | ||
1481 | { | ||
1482 | return YP.getValue(Term) is Variable; | ||
1483 | } | ||
1484 | |||
1485 | public static bool nonvar(object Term) | ||
1486 | { | ||
1487 | return !YP.var(Term); | ||
1488 | } | ||
1489 | |||
1490 | public static bool atom(object Term) | ||
1491 | { | ||
1492 | return YP.getValue(Term) is Atom; | ||
1493 | } | ||
1494 | |||
1495 | public static bool integer(object Term) | ||
1496 | { | ||
1497 | // Debug: Should exhaustively check for all integer types. | ||
1498 | return getValue(Term) is int; | ||
1499 | } | ||
1500 | |||
1501 | // Use isFloat instead of float because it is a reserved keyword. | ||
1502 | public static bool isFloat(object Term) | ||
1503 | { | ||
1504 | // Debug: Should exhaustively check for all float types. | ||
1505 | return getValue(Term) is double; | ||
1506 | } | ||
1507 | |||
1508 | public static bool number(object Term) | ||
1509 | { | ||
1510 | return YP.integer(Term) || YP.isFloat(Term); | ||
1511 | } | ||
1512 | |||
1513 | public static bool atomic(object Term) | ||
1514 | { | ||
1515 | return YP.atom(Term) || YP.number(Term); | ||
1516 | } | ||
1517 | |||
1518 | public static bool compound(object Term) | ||
1519 | { | ||
1520 | Term = getValue(Term); | ||
1521 | return Term is Functor1 || Term is Functor2 || Term is Functor3 || Term is Functor; | ||
1522 | } | ||
1523 | |||
1524 | /// <summary> | ||
1525 | /// If input is a TextReader, use it. If input is an Atom or String, create a StreamReader with the | ||
1526 | /// input as the filename. If input is a Prolog list, then read character codes from it. | ||
1527 | /// </summary> | ||
1528 | /// <param name="input"></param> | ||
1529 | public static void see(object input) | ||
1530 | { | ||
1531 | input = YP.getValue(input); | ||
1532 | if (input is Variable) | ||
1533 | throw new PrologException(Atom.a("instantiation_error"), "Arg is an unbound variable"); | ||
1534 | |||
1535 | if (input == null) | ||
1536 | { | ||
1537 | _inputStream = null; | ||
1538 | return; | ||
1539 | } | ||
1540 | if (input is TextReader) | ||
1541 | { | ||
1542 | _inputStream = (TextReader)input; | ||
1543 | return; | ||
1544 | } | ||
1545 | else if (input is Atom) | ||
1546 | { | ||
1547 | _inputStream = new StreamReader(((Atom)input)._name); | ||
1548 | return; | ||
1549 | } | ||
1550 | else if (input is String) | ||
1551 | { | ||
1552 | _inputStream = new StreamReader((String)input); | ||
1553 | return; | ||
1554 | } | ||
1555 | else if (input is Functor2 && ((Functor2)input)._name == Atom.DOT) | ||
1556 | { | ||
1557 | _inputStream = new CodeListReader(input); | ||
1558 | return; | ||
1559 | } | ||
1560 | else | ||
1561 | throw new PrologException | ||
1562 | (new Functor2("domain_error", Atom.a("stream_or_alias"), input), | ||
1563 | "Input stream specifier not recognized"); | ||
1564 | } | ||
1565 | |||
1566 | public static void seen() | ||
1567 | { | ||
1568 | if (_inputStream == null) | ||
1569 | return; | ||
1570 | if (_inputStream == Console.In) | ||
1571 | return; | ||
1572 | _inputStream.Close(); | ||
1573 | _inputStream = Console.In; | ||
1574 | } | ||
1575 | |||
1576 | public static IEnumerable<bool> current_input(object Stream) | ||
1577 | { | ||
1578 | return YP.unify(Stream, _inputStream); | ||
1579 | } | ||
1580 | |||
1581 | /// <summary> | ||
1582 | /// If output is a TextWriter, use it. If output is an Atom or a String, create a StreamWriter | ||
1583 | /// with the input as the filename. | ||
1584 | /// </summary> | ||
1585 | /// <param name="output"></param> | ||
1586 | public static void tell(object output) | ||
1587 | { | ||
1588 | output = YP.getValue(output); | ||
1589 | if (output is Variable) | ||
1590 | throw new PrologException(Atom.a("instantiation_error"), "Arg is an unbound variable"); | ||
1591 | |||
1592 | if (output == null) | ||
1593 | { | ||
1594 | _outputStream = null; | ||
1595 | return; | ||
1596 | } | ||
1597 | if (output is TextWriter) | ||
1598 | { | ||
1599 | _outputStream = (TextWriter)output; | ||
1600 | return; | ||
1601 | } | ||
1602 | else if (output is Atom) | ||
1603 | { | ||
1604 | _outputStream = new StreamWriter(((Atom)output)._name); | ||
1605 | return; | ||
1606 | } | ||
1607 | else if (output is String) | ||
1608 | { | ||
1609 | _outputStream = new StreamWriter((String)output); | ||
1610 | return; | ||
1611 | } | ||
1612 | else | ||
1613 | throw new PrologException | ||
1614 | (new Functor2("domain_error", Atom.a("stream_or_alias"), output), | ||
1615 | "Can't open stream for " + output); | ||
1616 | } | ||
1617 | |||
1618 | public static void told() | ||
1619 | { | ||
1620 | if (_outputStream == null) | ||
1621 | return; | ||
1622 | if (_outputStream == Console.Out) | ||
1623 | return; | ||
1624 | _outputStream.Close(); | ||
1625 | _outputStream = Console.Out; | ||
1626 | } | ||
1627 | |||
1628 | public static IEnumerable<bool> current_output(object Stream) | ||
1629 | { | ||
1630 | return YP.unify(Stream, _outputStream); | ||
1631 | } | ||
1632 | |||
1633 | public static void write(object x) | ||
1634 | { | ||
1635 | if (_outputStream == null) | ||
1636 | return; | ||
1637 | x = YP.getValue(x); | ||
1638 | if (x is double) | ||
1639 | _outputStream.Write(doubleToString((double)x)); | ||
1640 | else | ||
1641 | _outputStream.Write(x.ToString()); | ||
1642 | } | ||
1643 | |||
1644 | /// <summary> | ||
1645 | /// Format x as a string, making sure that it won't parse as an int later. I.e., for 1.0, don't just | ||
1646 | /// use "1" which will parse as an int. | ||
1647 | /// </summary> | ||
1648 | /// <param name="x"></param> | ||
1649 | /// <returns></returns> | ||
1650 | private static string doubleToString(double x) | ||
1651 | { | ||
1652 | string xString = x.ToString(); | ||
1653 | // Debug: Is there a way in C# to ask if a string parses as int without throwing an exception? | ||
1654 | try | ||
1655 | { | ||
1656 | Convert.ToInt32(xString); | ||
1657 | // The string will parse as an int, not a double, so re-format so that it does. | ||
1658 | // Use float if possible, else exponential if it would be too big. | ||
1659 | return x.ToString(x >= 100000.0 ? "E1" : "f1"); | ||
1660 | } | ||
1661 | catch (FormatException) | ||
1662 | { | ||
1663 | // Assume it will parse as a double. | ||
1664 | } | ||
1665 | return xString; | ||
1666 | } | ||
1667 | |||
1668 | public static void put_code(object x) | ||
1669 | { | ||
1670 | if (_outputStream == null) | ||
1671 | return; | ||
1672 | if (var(x)) | ||
1673 | throw new PrologException(Atom.a("instantiation_error"), "Arg 1 is an unbound variable"); | ||
1674 | int xInt; | ||
1675 | if (!getInt(x, out xInt)) | ||
1676 | throw new PrologException | ||
1677 | (new Functor2("type_error", Atom.a("integer"), x), "Arg 1 must be integer"); | ||
1678 | _outputStream.Write((char)xInt); | ||
1679 | } | ||
1680 | |||
1681 | public static void nl() | ||
1682 | { | ||
1683 | if (_outputStream == null) | ||
1684 | return; | ||
1685 | _outputStream.WriteLine(); | ||
1686 | } | ||
1687 | |||
1688 | public static IEnumerable<bool> get_code(object code) | ||
1689 | { | ||
1690 | if (_inputStream == null) | ||
1691 | return YP.unify(code, -1); | ||
1692 | else | ||
1693 | return YP.unify(code, _inputStream.Read()); | ||
1694 | } | ||
1695 | |||
1696 | public static void asserta(object Term, Type declaringClass) | ||
1697 | { | ||
1698 | assertDynamic(Term, declaringClass, true); | ||
1699 | } | ||
1700 | |||
1701 | public static void assertz(object Term, Type declaringClass) | ||
1702 | { | ||
1703 | assertDynamic(Term, declaringClass, false); | ||
1704 | } | ||
1705 | |||
1706 | public static void assertDynamic(object Term, Type declaringClass, bool prepend) | ||
1707 | { | ||
1708 | Term = getValue(Term); | ||
1709 | if (Term is Variable) | ||
1710 | throw new PrologException("instantiation_error", "Term to assert is an unbound variable"); | ||
1711 | |||
1712 | Variable.CopyStore copyStore = new Variable.CopyStore(); | ||
1713 | object TermCopy = makeCopy(Term, copyStore); | ||
1714 | object Head, Body; | ||
1715 | if (TermCopy is Functor2 && ((Functor2)TermCopy)._name == Atom.RULE) | ||
1716 | { | ||
1717 | Head = YP.getValue(((Functor2)TermCopy)._arg1); | ||
1718 | Body = YP.getValue(((Functor2)TermCopy)._arg2); | ||
1719 | if (Head is Variable) | ||
1720 | throw new PrologException("instantiation_error", "Head to assert is an unbound variable"); | ||
1721 | if (Body is Variable) | ||
1722 | throw new PrologException("instantiation_error", "Body to assert is an unbound variable"); | ||
1723 | } | ||
1724 | else | ||
1725 | { | ||
1726 | Head = TermCopy; | ||
1727 | Body = Atom.a("true"); | ||
1728 | } | ||
1729 | |||
1730 | Atom name = getFunctorName(Head) as Atom; | ||
1731 | if (name == null) | ||
1732 | // name is a non-Atom, such as a number. | ||
1733 | throw new PrologException | ||
1734 | (new Functor2("type_error", Atom.a("callable"), Head), "Term to assert is not callable"); | ||
1735 | object[] args = getFunctorArgs(Head); | ||
1736 | if (isSystemPredicate(name, args.Length)) | ||
1737 | throw new PrologException | ||
1738 | (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), | ||
1739 | new Functor2(Atom.SLASH, name, args.Length)), | ||
1740 | "Assert cannot modify static predicate " + name + "/" + args.Length); | ||
1741 | |||
1742 | if (copyStore.getNUniqueVariables() == 0 && Body == Atom.a("true")) | ||
1743 | { | ||
1744 | // This is a fact with no unbound variables | ||
1745 | // assertFact and prependFact use IndexedAnswers, so don't we don't need to compile. | ||
1746 | if (prepend) | ||
1747 | prependFact(name, args); | ||
1748 | else | ||
1749 | assertFact(name, args); | ||
1750 | |||
1751 | return; | ||
1752 | } | ||
1753 | |||
1754 | IClause clause = YPCompiler.compileAnonymousClause(Head, Body, declaringClass); | ||
1755 | // We expect clause to be a ClauseHeadAndBody (from Compiler.compileAnonymousFunction) | ||
1756 | // so we can set the Head and Body. | ||
1757 | if (clause is ClauseHeadAndBody) | ||
1758 | ((ClauseHeadAndBody)clause).setHeadAndBody(Head, Body); | ||
1759 | |||
1760 | // Add the clause to the entry in _predicatesStore. | ||
1761 | NameArity nameArity = new NameArity(name, args.Length); | ||
1762 | List<IClause> clauses; | ||
1763 | if (!_predicatesStore.TryGetValue(nameArity, out clauses)) | ||
1764 | // Create an entry for the nameArity. | ||
1765 | _predicatesStore[nameArity] = (clauses = new List<IClause>()); | ||
1766 | |||
1767 | if (prepend) | ||
1768 | clauses.Insert(0, clause); | ||
1769 | else | ||
1770 | clauses.Add(clause); | ||
1771 | } | ||
1772 | |||
1773 | private static bool isSystemPredicate(Atom name, int arity) | ||
1774 | { | ||
1775 | if (arity == 2 && (name == Atom.a(",") || name == Atom.a(";") || name == Atom.DOT)) | ||
1776 | return true; | ||
1777 | // Use the same mapping to static predicates in YP as the compiler. | ||
1778 | foreach (bool l1 in YPCompiler.functorCallYPFunctionName(name, arity, new Variable())) | ||
1779 | return true; | ||
1780 | // Debug: Do we need to check if name._module is null? | ||
1781 | return false; | ||
1782 | } | ||
1783 | |||
1784 | /// <summary> | ||
1785 | /// Assert values at the end of the set of facts for the predicate with the | ||
1786 | /// name and with arity values.Length. | ||
1787 | /// </summary> | ||
1788 | /// <param name="name">must be an Atom</param> | ||
1789 | /// <param name="values">the array of arguments to the fact predicate. | ||
1790 | /// It is an error if an value has an unbound variable.</param> | ||
1791 | public static void assertFact(Atom name, object[] values) | ||
1792 | { | ||
1793 | NameArity nameArity = new NameArity(name, values.Length); | ||
1794 | List<IClause> clauses; | ||
1795 | IndexedAnswers indexedAnswers; | ||
1796 | if (!_predicatesStore.TryGetValue(nameArity, out clauses)) | ||
1797 | { | ||
1798 | // Create an IndexedAnswers as the only clause of the predicate. | ||
1799 | _predicatesStore[nameArity] = (clauses = new List<IClause>()); | ||
1800 | clauses.Add(indexedAnswers = new IndexedAnswers(values.Length)); | ||
1801 | } | ||
1802 | else | ||
1803 | { | ||
1804 | indexedAnswers = null; | ||
1805 | if (clauses.Count >= 1) | ||
1806 | indexedAnswers = clauses[clauses.Count - 1] as IndexedAnswers; | ||
1807 | if (indexedAnswers == null) | ||
1808 | // The latest clause is not an IndexedAnswers, so add one. | ||
1809 | clauses.Add(indexedAnswers = new IndexedAnswers(values.Length)); | ||
1810 | } | ||
1811 | |||
1812 | indexedAnswers.addAnswer(values); | ||
1813 | } | ||
1814 | |||
1815 | /// <summary> | ||
1816 | /// Assert values, prepending to the front of the set of facts for the predicate with the | ||
1817 | /// name and with arity values.Length. | ||
1818 | /// </summary> | ||
1819 | /// <param name="name">must be an Atom</param> | ||
1820 | /// <param name="values">the array of arguments to the fact predicate. | ||
1821 | /// It is an error if an value has an unbound variable.</param> | ||
1822 | public static void prependFact(Atom name, object[] values) | ||
1823 | { | ||
1824 | NameArity nameArity = new NameArity(name, values.Length); | ||
1825 | List<IClause> clauses; | ||
1826 | IndexedAnswers indexedAnswers; | ||
1827 | if (!_predicatesStore.TryGetValue(nameArity, out clauses)) | ||
1828 | { | ||
1829 | // Create an IndexedAnswers as the only clause of the predicate. | ||
1830 | _predicatesStore[nameArity] = (clauses = new List<IClause>()); | ||
1831 | clauses.Add(indexedAnswers = new IndexedAnswers(values.Length)); | ||
1832 | } | ||
1833 | else | ||
1834 | { | ||
1835 | indexedAnswers = null; | ||
1836 | if (clauses.Count >= 1) | ||
1837 | indexedAnswers = clauses[0] as IndexedAnswers; | ||
1838 | if (indexedAnswers == null) | ||
1839 | // The first clause is not an IndexedAnswers, so prepend one. | ||
1840 | clauses.Insert(0, indexedAnswers = new IndexedAnswers(values.Length)); | ||
1841 | } | ||
1842 | |||
1843 | indexedAnswers.prependAnswer(values); | ||
1844 | } | ||
1845 | |||
1846 | /// <summary> | ||
1847 | /// Match all clauses of the dynamic predicate with the name and with arity | ||
1848 | /// arguments.Length. | ||
1849 | /// If the predicate is not defined, return the result of YP.unknownPredicate. | ||
1850 | /// </summary> | ||
1851 | /// <param name="name">must be an Atom</param> | ||
1852 | /// <param name="arguments">an array of arity number of arguments</param> | ||
1853 | /// <returns>an iterator which you can use in foreach</returns> | ||
1854 | public static IEnumerable<bool> matchDynamic(Atom name, object[] arguments) | ||
1855 | { | ||
1856 | List<IClause> clauses; | ||
1857 | if (!_predicatesStore.TryGetValue(new NameArity(name, arguments.Length), out clauses)) | ||
1858 | return unknownPredicate(name, arguments.Length, | ||
1859 | "Undefined dynamic predicate: " + name + "/" + arguments.Length); | ||
1860 | |||
1861 | if (clauses.Count == 1) | ||
1862 | // Usually there is only one clause, so return it without needing to wrap it in an iterator. | ||
1863 | return clauses[0].match(arguments); | ||
1864 | else | ||
1865 | return matchAllClauses(clauses, arguments); | ||
1866 | } | ||
1867 | |||
1868 | /// <summary> | ||
1869 | /// Call match(arguments) for each IClause in clauses. We make this a separate | ||
1870 | /// function so that matchDynamic itself does not need to be an iterator object. | ||
1871 | /// </summary> | ||
1872 | /// <param name="clauses"></param> | ||
1873 | /// <param name="arguments"></param> | ||
1874 | /// <returns></returns> | ||
1875 | private static IEnumerable<bool> matchAllClauses(List<IClause> clauses, object[] arguments) | ||
1876 | { | ||
1877 | // Debug: If the caller asserts another clause into this same predicate during yield, the iterator | ||
1878 | // over clauses will be corrupted. Should we take the time to copy clauses? | ||
1879 | foreach (IClause clause in clauses) | ||
1880 | { | ||
1881 | foreach (bool lastCall in clause.match(arguments)) | ||
1882 | { | ||
1883 | yield return false; | ||
1884 | if (lastCall) | ||
1885 | // This happens after a cut in a clause. | ||
1886 | yield break; | ||
1887 | } | ||
1888 | } | ||
1889 | } | ||
1890 | |||
1891 | /// <summary> | ||
1892 | /// If _prologFlags["unknown"] is fail then return fail(), else if | ||
1893 | /// _prologFlags["unknown"] is warning then write the message to YP.write and | ||
1894 | /// return fail(), else throw a PrologException for existence_error. . | ||
1895 | /// </summary> | ||
1896 | /// <param name="name"></param> | ||
1897 | /// <param name="arity"></param> | ||
1898 | /// <param name="message"></param> | ||
1899 | /// <returns></returns> | ||
1900 | public static IEnumerable<bool> unknownPredicate(Atom name, int arity, string message) | ||
1901 | { | ||
1902 | establishPrologFlags(); | ||
1903 | |||
1904 | if (_prologFlags["unknown"] == Atom.a("fail")) | ||
1905 | return fail(); | ||
1906 | else if (_prologFlags["unknown"] == Atom.a("warning")) | ||
1907 | { | ||
1908 | write(message); | ||
1909 | nl(); | ||
1910 | return fail(); | ||
1911 | } | ||
1912 | else | ||
1913 | throw new PrologException | ||
1914 | (new Functor2 | ||
1915 | (Atom.a("existence_error"), Atom.a("procedure"), | ||
1916 | new Functor2(Atom.SLASH, name, arity)), message); | ||
1917 | } | ||
1918 | |||
1919 | /// <summary> | ||
1920 | /// This is deprecated and just calls matchDynamic. This matches all clauses, | ||
1921 | /// not just the ones defined with assertFact. | ||
1922 | /// </summary> | ||
1923 | /// <param name="name"></param> | ||
1924 | /// <param name="arguments"></param> | ||
1925 | /// <returns></returns> | ||
1926 | public static IEnumerable<bool> matchFact(Atom name, object[] arguments) | ||
1927 | { | ||
1928 | return matchDynamic(name, arguments); | ||
1929 | } | ||
1930 | |||
1931 | public static IEnumerable<bool> clause(object Head, object Body) | ||
1932 | { | ||
1933 | Head = getValue(Head); | ||
1934 | Body = getValue(Body); | ||
1935 | if (Head is Variable) | ||
1936 | throw new PrologException("instantiation_error", "Head is an unbound variable"); | ||
1937 | |||
1938 | Atom name = getFunctorName(Head) as Atom; | ||
1939 | if (name == null) | ||
1940 | // name is a non-Atom, such as a number. | ||
1941 | throw new PrologException | ||
1942 | (new Functor2("type_error", Atom.a("callable"), Head), "Head is not callable"); | ||
1943 | object[] args = getFunctorArgs(Head); | ||
1944 | if (isSystemPredicate(name, args.Length)) | ||
1945 | throw new PrologException | ||
1946 | (new Functor3("permission_error", Atom.a("access"), Atom.a("private_procedure"), | ||
1947 | new Functor2(Atom.SLASH, name, args.Length)), | ||
1948 | "clause cannot access private predicate " + name + "/" + args.Length); | ||
1949 | if (!(Body is Variable) && !(YP.getFunctorName(Body) is Atom)) | ||
1950 | throw new PrologException | ||
1951 | (new Functor2("type_error", Atom.a("callable"), Body), "Body is not callable"); | ||
1952 | |||
1953 | List<IClause> clauses; | ||
1954 | if (!_predicatesStore.TryGetValue(new NameArity(name, args.Length), out clauses)) | ||
1955 | yield break; | ||
1956 | // The caller can assert another clause into this same predicate during yield, so we have to | ||
1957 | // make a copy of the clauses. | ||
1958 | foreach (IClause predicateClause in clauses.ToArray()) | ||
1959 | { | ||
1960 | foreach (bool l1 in predicateClause.clause(Head, Body)) | ||
1961 | yield return false; | ||
1962 | } | ||
1963 | } | ||
1964 | |||
1965 | public static IEnumerable<bool> retract(object Term) | ||
1966 | { | ||
1967 | Term = getValue(Term); | ||
1968 | if (Term is Variable) | ||
1969 | throw new PrologException("instantiation_error", "Term to retract is an unbound variable"); | ||
1970 | |||
1971 | object Head, Body; | ||
1972 | if (Term is Functor2 && ((Functor2)Term)._name == Atom.RULE) | ||
1973 | { | ||
1974 | Head = YP.getValue(((Functor2)Term)._arg1); | ||
1975 | Body = YP.getValue(((Functor2)Term)._arg2); | ||
1976 | } | ||
1977 | else | ||
1978 | { | ||
1979 | Head = Term; | ||
1980 | Body = Atom.a("true"); | ||
1981 | } | ||
1982 | if (Head is Variable) | ||
1983 | throw new PrologException("instantiation_error", "Head is an unbound variable"); | ||
1984 | |||
1985 | Atom name = getFunctorName(Head) as Atom; | ||
1986 | if (name == null) | ||
1987 | // name is a non-Atom, such as a number. | ||
1988 | throw new PrologException | ||
1989 | (new Functor2("type_error", Atom.a("callable"), Head), "Head is not callable"); | ||
1990 | object[] args = getFunctorArgs(Head); | ||
1991 | if (isSystemPredicate(name, args.Length)) | ||
1992 | throw new PrologException | ||
1993 | (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), | ||
1994 | new Functor2(Atom.SLASH, name, args.Length)), | ||
1995 | "clause cannot access private predicate " + name + "/" + args.Length); | ||
1996 | if (!(Body is Variable) && !(YP.getFunctorName(Body) is Atom)) | ||
1997 | throw new PrologException | ||
1998 | (new Functor2("type_error", Atom.a("callable"), Body), "Body is not callable"); | ||
1999 | |||
2000 | List<IClause> clauses; | ||
2001 | if (!_predicatesStore.TryGetValue(new NameArity(name, args.Length), out clauses)) | ||
2002 | yield break; | ||
2003 | // The caller can assert another clause into this same predicate during yield, so we have to | ||
2004 | // make a copy of the clauses. | ||
2005 | foreach (IClause predicateClause in clauses.ToArray()) | ||
2006 | { | ||
2007 | if (predicateClause is IndexedAnswers) | ||
2008 | { | ||
2009 | // IndexedAnswers handles its own retract. Even if it removes all of its | ||
2010 | // answers, it is OK to leave it empty as one of the elements in clauses. | ||
2011 | foreach (bool l1 in ((IndexedAnswers)predicateClause).retract(Head, Body)) | ||
2012 | yield return false; | ||
2013 | } | ||
2014 | else | ||
2015 | { | ||
2016 | foreach (bool l1 in predicateClause.clause(Head, Body)) | ||
2017 | { | ||
2018 | clauses.Remove(predicateClause); | ||
2019 | yield return false; | ||
2020 | } | ||
2021 | } | ||
2022 | } | ||
2023 | } | ||
2024 | |||
2025 | /// <summary> | ||
2026 | /// This is deprecated for backward compatibility. You should use retractall. | ||
2027 | /// </summary> | ||
2028 | /// <param name="name">must be an Atom</param> | ||
2029 | /// <param name="arguments">an array of arity number of arguments</param> | ||
2030 | public static void retractFact(Atom name, object[] arguments) | ||
2031 | { | ||
2032 | retractall(Functor.make(name, arguments)); | ||
2033 | } | ||
2034 | |||
2035 | /// <summary> | ||
2036 | /// Retract all dynamic clauses which unify with Head. If this matches all clauses in a predicate, | ||
2037 | /// the predicate is still defined. To completely remove the predicate, see abolish. | ||
2038 | /// </summary> | ||
2039 | /// <param name="Head"></param> | ||
2040 | public static void retractall(object Head) | ||
2041 | { | ||
2042 | object name = YP.getFunctorName(Head); | ||
2043 | object[] arguments = getFunctorArgs(Head); | ||
2044 | if (!(name is Atom)) | ||
2045 | return; | ||
2046 | NameArity nameArity = new NameArity((Atom)name, arguments.Length); | ||
2047 | List<IClause> clauses; | ||
2048 | if (!_predicatesStore.TryGetValue(nameArity, out clauses)) | ||
2049 | // Can't find, so ignore. | ||
2050 | return; | ||
2051 | |||
2052 | foreach (object arg in arguments) | ||
2053 | { | ||
2054 | if (!YP.var(arg)) | ||
2055 | throw new InvalidOperationException | ||
2056 | ("Until matching retractall is supported, all arguments must be unbound to retract all clauses"); | ||
2057 | } | ||
2058 | // Clear all clauses. | ||
2059 | _predicatesStore[nameArity] = new List<IClause>(); | ||
2060 | } | ||
2061 | |||
2062 | /// <summary> | ||
2063 | /// If NameSlashArity is var, match with all the dynamic predicates using the | ||
2064 | /// Name/Artity form. | ||
2065 | /// If NameSlashArity is not var, check if the Name/Arity exists as a static or | ||
2066 | /// dynamic predicate. | ||
2067 | /// </summary> | ||
2068 | /// <param name="NameSlashArity"></param> | ||
2069 | /// <param name="declaringClass">if not null, used to resolve references to the default | ||
2070 | /// module Atom.a("")</param> | ||
2071 | /// <returns></returns> | ||
2072 | public static IEnumerable<bool> current_predicate(object NameSlashArity, Type declaringClass) | ||
2073 | { | ||
2074 | NameSlashArity = YP.getValue(NameSlashArity); | ||
2075 | // First check if Name and Arity are nonvar so we can do a direct lookup. | ||
2076 | if (YP.ground(NameSlashArity)) | ||
2077 | { | ||
2078 | Functor2 NameArityFunctor = NameSlashArity as Functor2; | ||
2079 | if (!(NameArityFunctor != null && NameArityFunctor._name == Atom.SLASH)) | ||
2080 | throw new PrologException | ||
2081 | (new Functor2("type_error", Atom.a("predicate_indicator"), NameSlashArity), | ||
2082 | "Must be a name/arity predicate indicator"); | ||
2083 | object name = YP.getValue(NameArityFunctor._arg1); | ||
2084 | object arity = YP.getValue(NameArityFunctor._arg2); | ||
2085 | if (name is Variable || arity is Variable) | ||
2086 | throw new PrologException | ||
2087 | ("instantiation_error", "Predicate indicator name or arity is an unbound variable"); | ||
2088 | if (!(name is Atom && arity is int)) | ||
2089 | throw new PrologException | ||
2090 | (new Functor2("type_error", Atom.a("predicate_indicator"), NameSlashArity), | ||
2091 | "Must be a name/arity predicate indicator"); | ||
2092 | if ((int)arity < 0) | ||
2093 | throw new PrologException | ||
2094 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), arity), | ||
2095 | "Arity may not be less than zero"); | ||
2096 | |||
2097 | if (YPCompiler.isCurrentPredicate((Atom)name, (int)arity, declaringClass)) | ||
2098 | // The predicate is defined. | ||
2099 | yield return false; | ||
2100 | } | ||
2101 | else | ||
2102 | { | ||
2103 | foreach (NameArity key in _predicatesStore.Keys) | ||
2104 | { | ||
2105 | foreach (bool l1 in YP.unify | ||
2106 | (new Functor2(Atom.SLASH, key._name, key._arity), NameSlashArity)) | ||
2107 | yield return false; | ||
2108 | } | ||
2109 | } | ||
2110 | } | ||
2111 | |||
2112 | /// <summary> | ||
2113 | /// Return true if the dynamic predicate store has an entry for the predicate | ||
2114 | /// with name and arity. | ||
2115 | /// </summary> | ||
2116 | /// <param name="name"></param> | ||
2117 | /// <param name="arity"></param> | ||
2118 | /// <returns></returns> | ||
2119 | public static bool isDynamicCurrentPredicate(Atom name, int arity) | ||
2120 | { | ||
2121 | return _predicatesStore.ContainsKey(new NameArity(name, arity)); | ||
2122 | } | ||
2123 | |||
2124 | public static void abolish(object NameSlashArity) | ||
2125 | { | ||
2126 | NameSlashArity = YP.getValue(NameSlashArity); | ||
2127 | if (NameSlashArity is Variable) | ||
2128 | throw new PrologException | ||
2129 | ("instantiation_error", "Predicate indicator is an unbound variable"); | ||
2130 | Functor2 NameArityFunctor = NameSlashArity as Functor2; | ||
2131 | if (!(NameArityFunctor != null && NameArityFunctor._name == Atom.SLASH)) | ||
2132 | throw new PrologException | ||
2133 | (new Functor2("type_error", Atom.a("predicate_indicator"), NameSlashArity), | ||
2134 | "Must be a name/arity predicate indicator"); | ||
2135 | object name = YP.getValue(NameArityFunctor._arg1); | ||
2136 | object arity = YP.getValue(NameArityFunctor._arg2); | ||
2137 | if (name is Variable || arity is Variable) | ||
2138 | throw new PrologException | ||
2139 | ("instantiation_error", "Predicate indicator name or arity is an unbound variable"); | ||
2140 | if (!(name is Atom)) | ||
2141 | throw new PrologException | ||
2142 | (new Functor2("type_error", Atom.a("atom"), name), | ||
2143 | "Predicate indicator name must be an atom"); | ||
2144 | if (!(arity is int)) | ||
2145 | throw new PrologException | ||
2146 | (new Functor2("type_error", Atom.a("integer"), arity), | ||
2147 | "Predicate indicator arity must be an integer"); | ||
2148 | if ((int)arity < 0) | ||
2149 | throw new PrologException | ||
2150 | (new Functor2("domain_error", Atom.a("not_less_than_zero"), arity), | ||
2151 | "Arity may not be less than zero"); | ||
2152 | if ((int)arity > MAX_ARITY) | ||
2153 | throw new PrologException | ||
2154 | (new Functor1("representation_error", Atom.a("max_arity")), | ||
2155 | "Arity may not be greater than " + MAX_ARITY); | ||
2156 | |||
2157 | if (isSystemPredicate((Atom)name, (int)arity)) | ||
2158 | throw new PrologException | ||
2159 | (new Functor3("permission_error", Atom.a("modify"), Atom.a("static_procedure"), | ||
2160 | new Functor2(Atom.SLASH, name, arity)), | ||
2161 | "Abolish cannot modify static predicate " + name + "/" + arity); | ||
2162 | _predicatesStore.Remove(new NameArity((Atom)name, (int)arity)); | ||
2163 | } | ||
2164 | |||
2165 | /// <summary> | ||
2166 | /// If Goal is a simple predicate, call YP.getFunctorName(Goal) using arguments from | ||
2167 | /// YP.getFunctorArgs(Goal). If not found, this throws a PrologException for existence_error. | ||
2168 | /// Otherwise, compile the goal as a single clause predicate and invoke it. | ||
2169 | /// </summary> | ||
2170 | /// <param name="Goal"></param> | ||
2171 | /// <param name="declaringClass">if not null, used to resolve references to the default | ||
2172 | /// module Atom.a("")</param> | ||
2173 | /// <returns></returns> | ||
2174 | public static IEnumerable<bool> getIterator(object Goal, Type declaringClass) | ||
2175 | { | ||
2176 | Atom name; | ||
2177 | object[] args; | ||
2178 | while (true) | ||
2179 | { | ||
2180 | Goal = YP.getValue(Goal); | ||
2181 | if (Goal is Variable) | ||
2182 | throw new PrologException("instantiation_error", "Goal to call is an unbound variable"); | ||
2183 | name = YP.getFunctorName(Goal) as Atom; | ||
2184 | if (name == null) | ||
2185 | throw new PrologException | ||
2186 | (new Functor2("type_error", Atom.a("callable"), Goal), "Goal to call is not callable"); | ||
2187 | args = YP.getFunctorArgs(Goal); | ||
2188 | if (name == Atom.HAT && args.Length == 2) | ||
2189 | // Assume this is called from a bagof operation. Skip the leading qualifiers. | ||
2190 | Goal = YP.getValue(((Functor2)Goal)._arg2); | ||
2191 | else | ||
2192 | break; | ||
2193 | } | ||
2194 | |||
2195 | IEnumerable<bool> simpleIterator = YPCompiler.getSimpleIterator(name, args, declaringClass); | ||
2196 | if (simpleIterator != null) | ||
2197 | // We don't need to compile since the goal is a simple predicate which we call directly. | ||
2198 | return simpleIterator; | ||
2199 | |||
2200 | // Compile the goal as a clause. | ||
2201 | List<Variable> variableSetList = new List<Variable>(); | ||
2202 | addUniqueVariables(Goal, variableSetList); | ||
2203 | Variable[] variableSet = variableSetList.ToArray(); | ||
2204 | |||
2205 | // Use Atom.F since it is ignored. | ||
2206 | return YPCompiler.compileAnonymousClause | ||
2207 | (Functor.make(Atom.F, variableSet), Goal, declaringClass).match(variableSet); | ||
2208 | } | ||
2209 | |||
2210 | public static void throwException(object Term) | ||
2211 | { | ||
2212 | throw new PrologException(Term); | ||
2213 | } | ||
2214 | /// <summary> | ||
2215 | /// This must be called by any function that uses YP._prologFlags to make sure | ||
2216 | /// the initial defaults are loaded. | ||
2217 | /// </summary> | ||
2218 | private static void establishPrologFlags() | ||
2219 | { | ||
2220 | if (_prologFlags.Count > 0) | ||
2221 | // Already established. | ||
2222 | return; | ||
2223 | |||
2224 | // List these in the order they appear in the ISO standard. | ||
2225 | _prologFlags["bounded"] = Atom.a("true"); | ||
2226 | _prologFlags["max_integer"] = Int32.MaxValue; | ||
2227 | _prologFlags["min_integer"] = Int32.MinValue; | ||
2228 | _prologFlags["integer_rounding_function"] = Atom.a("toward_zero"); | ||
2229 | _prologFlags["char_conversion"] = Atom.a("off"); | ||
2230 | _prologFlags["debug"] = Atom.a("off"); | ||
2231 | _prologFlags["max_arity"] = MAX_ARITY; | ||
2232 | _prologFlags["unknown"] = Atom.a("error"); | ||
2233 | _prologFlags["double_quotes"] = Atom.a("codes"); | ||
2234 | } | ||
2235 | |||
2236 | public static IEnumerable<bool> current_prolog_flag(object Key, object Value) | ||
2237 | { | ||
2238 | establishPrologFlags(); | ||
2239 | |||
2240 | Key = YP.getValue(Key); | ||
2241 | Value = YP.getValue(Value); | ||
2242 | |||
2243 | if (Key is Variable) | ||
2244 | { | ||
2245 | // Bind all key values. | ||
2246 | foreach (string key in _prologFlags.Keys) | ||
2247 | { | ||
2248 | foreach (bool l1 in YP.unify(Key, Atom.a(key))) | ||
2249 | { | ||
2250 | foreach (bool l2 in YP.unify(Value, _prologFlags[key])) | ||
2251 | yield return false; | ||
2252 | } | ||
2253 | } | ||
2254 | } | ||
2255 | else | ||
2256 | { | ||
2257 | if (!(Key is Atom)) | ||
2258 | throw new PrologException | ||
2259 | (new Functor2("type_error", Atom.a("atom"), Key), "Arg 1 Key is not an atom"); | ||
2260 | if (!_prologFlags.ContainsKey(((Atom)Key)._name)) | ||
2261 | throw new PrologException | ||
2262 | (new Functor2("domain_error", Atom.a("prolog_flag"), Key), | ||
2263 | "Arg 1 Key is not a recognized flag"); | ||
2264 | |||
2265 | foreach (bool l1 in YP.unify(Value, _prologFlags[((Atom)Key)._name])) | ||
2266 | yield return false; | ||
2267 | } | ||
2268 | } | ||
2269 | |||
2270 | public static void set_prolog_flag(object Key, object Value) | ||
2271 | { | ||
2272 | establishPrologFlags(); | ||
2273 | |||
2274 | Key = YP.getValue(Key); | ||
2275 | Value = YP.getValue(Value); | ||
2276 | |||
2277 | if (Key is Variable) | ||
2278 | throw new PrologException(Atom.a("instantiation_error"), | ||
2279 | "Arg 1 Key is an unbound variable"); | ||
2280 | if (Value is Variable) | ||
2281 | throw new PrologException(Atom.a("instantiation_error"), | ||
2282 | "Arg 1 Key is an unbound variable"); | ||
2283 | if (!(Key is Atom)) | ||
2284 | throw new PrologException | ||
2285 | (new Functor2("type_error", Atom.a("atom"), Key), "Arg 1 Key is not an atom"); | ||
2286 | |||
2287 | string keyName = ((Atom)Key)._name; | ||
2288 | if (!_prologFlags.ContainsKey(keyName)) | ||
2289 | throw new PrologException | ||
2290 | (new Functor2("domain_error", Atom.a("prolog_flag"), Key), | ||
2291 | "Arg 1 Key " + Key + " is not a recognized flag"); | ||
2292 | |||
2293 | bool valueIsOK = false; | ||
2294 | if (keyName == "char_conversion") | ||
2295 | valueIsOK = (Value == _prologFlags[keyName]); | ||
2296 | else if (keyName == "debug") | ||
2297 | valueIsOK = (Value == _prologFlags[keyName]); | ||
2298 | else if (keyName == "unknown") | ||
2299 | valueIsOK = (Value == Atom.a("fail") || Value == Atom.a("warning") || | ||
2300 | Value == Atom.a("error")); | ||
2301 | else if (keyName == "double_quotes") | ||
2302 | valueIsOK = (Value == Atom.a("codes") || Value == Atom.a("chars") || | ||
2303 | Value == Atom.a("atom")); | ||
2304 | else | ||
2305 | throw new PrologException | ||
2306 | (new Functor3("permission_error", Atom.a("modify"), Atom.a("flag"), Key), | ||
2307 | "May not modify Prolog flag " + Key); | ||
2308 | |||
2309 | if (!valueIsOK) | ||
2310 | throw new PrologException | ||
2311 | (new Functor2("domain_error", Atom.a("flag_value"), new Functor2("+", Key, Value)), | ||
2312 | "May not set arg 1 Key " + Key + " to arg 2 Value " + Value); | ||
2313 | |||
2314 | _prologFlags[keyName] = Value; | ||
2315 | } | ||
2316 | /// <summary> | ||
2317 | /// script_event calls hosting script with events as a callback method. | ||
2318 | /// </summary> | ||
2319 | /// <param name="script_event"></param> | ||
2320 | /// <param name="script_params"></param> | ||
2321 | /// <returns></returns> | ||
2322 | public static IEnumerable<bool> script_event(object script_event, object script_params) | ||
2323 | { | ||
2324 | // string function = ((Atom)YP.getValue(script_event))._name; | ||
2325 | object[] array = ListPair.toArray(script_params); | ||
2326 | if (array == null) | ||
2327 | yield return false; // return; // YP.fail(); | ||
2328 | if (array.Length > 1) | ||
2329 | { | ||
2330 | //m_CmdManager.m_ScriptEngine.m_EventQueManager.AddToScriptQueue | ||
2331 | //(localID, itemID, function, array); | ||
2332 | // sortArray(array); | ||
2333 | } | ||
2334 | //return YP.unify(Sorted, ListPair.makeWithoutRepeatedTerms(array)); | ||
2335 | yield return false; | ||
2336 | } | ||
2337 | |||
2338 | /* Non-prolog-ish functions for inline coding */ | ||
2339 | public static string regexString(string inData, string inPattern, string presep,string postsep) | ||
2340 | { | ||
2341 | //string str=cycMessage; | ||
2342 | //string strMatch = @"\. \#\$(.*)\)"; | ||
2343 | string results = ""; | ||
2344 | for (Match m = Regex.Match(inData,inPattern); m.Success; m=m.NextMatch()) | ||
2345 | { | ||
2346 | //m_log.Debug(m); | ||
2347 | results += presep+ m + postsep; | ||
2348 | } | ||
2349 | return results; | ||
2350 | } | ||
2351 | |||
2352 | public static string cycComm(object msgobj) | ||
2353 | { | ||
2354 | string cycInputString = msgobj.ToString(); | ||
2355 | string cycOutputString=""; | ||
2356 | TcpClient socketForServer; | ||
2357 | |||
2358 | try | ||
2359 | { | ||
2360 | socketForServer = new TcpClient("localHost", 3601); | ||
2361 | } | ||
2362 | catch | ||
2363 | { | ||
2364 | m_log.Error("Failed to connect to server at localhost:999"); | ||
2365 | return ""; | ||
2366 | } | ||
2367 | |||
2368 | NetworkStream networkStream = socketForServer.GetStream(); | ||
2369 | |||
2370 | System.IO.StreamReader streamReader = new System.IO.StreamReader(networkStream); | ||
2371 | |||
2372 | System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(networkStream); | ||
2373 | |||
2374 | try | ||
2375 | { | ||
2376 | // read the data from the host and display it | ||
2377 | |||
2378 | { | ||
2379 | |||
2380 | streamWriter.WriteLine(cycInputString); | ||
2381 | streamWriter.Flush(); | ||
2382 | |||
2383 | cycOutputString = streamReader.ReadLine(); | ||
2384 | m_log.Debug("Cycoutput:" + cycOutputString); | ||
2385 | //streamWriter.WriteLine("Client Message"); | ||
2386 | //m_log.Debug("Client Message"); | ||
2387 | streamWriter.Flush(); | ||
2388 | } | ||
2389 | |||
2390 | } | ||
2391 | catch | ||
2392 | { | ||
2393 | m_log.Error("Exception reading from Server"); | ||
2394 | return ""; | ||
2395 | } | ||
2396 | // tidy up | ||
2397 | networkStream.Close(); | ||
2398 | return cycOutputString; | ||
2399 | |||
2400 | } | ||
2401 | //public static void throwException(object Term) | ||
2402 | //{ | ||
2403 | // throw new PrologException(Term); | ||
2404 | //} | ||
2405 | /// <summary> | ||
2406 | /// An enumerator that does zero loops. | ||
2407 | /// </summary> | ||
2408 | private class Fail : IEnumerator<bool>, IEnumerable<bool> | ||
2409 | { | ||
2410 | public bool MoveNext() | ||
2411 | { | ||
2412 | return false; | ||
2413 | } | ||
2414 | |||
2415 | public IEnumerator<bool> GetEnumerator() | ||
2416 | { | ||
2417 | return (IEnumerator<bool>)this; | ||
2418 | } | ||
2419 | |||
2420 | IEnumerator IEnumerable.GetEnumerator() | ||
2421 | { | ||
2422 | return GetEnumerator(); | ||
2423 | } | ||
2424 | |||
2425 | public bool Current | ||
2426 | { | ||
2427 | get { return true; } | ||
2428 | } | ||
2429 | |||
2430 | object IEnumerator.Current | ||
2431 | { | ||
2432 | get { return true; } | ||
2433 | } | ||
2434 | |||
2435 | public void Dispose() | ||
2436 | { | ||
2437 | } | ||
2438 | |||
2439 | public void Reset() | ||
2440 | { | ||
2441 | throw new NotImplementedException(); | ||
2442 | } | ||
2443 | } | ||
2444 | |||
2445 | /// <summary> | ||
2446 | /// An enumerator that does one iteration. | ||
2447 | /// </summary> | ||
2448 | private class Succeed : IEnumerator<bool>, IEnumerable<bool> | ||
2449 | { | ||
2450 | private bool _didIteration = false; | ||
2451 | |||
2452 | public bool MoveNext() | ||
2453 | { | ||
2454 | if (!_didIteration) | ||
2455 | { | ||
2456 | _didIteration = true; | ||
2457 | return true; | ||
2458 | } | ||
2459 | else | ||
2460 | return false; | ||
2461 | } | ||
2462 | |||
2463 | public IEnumerator<bool> GetEnumerator() | ||
2464 | { | ||
2465 | return (IEnumerator<bool>)this; | ||
2466 | } | ||
2467 | |||
2468 | IEnumerator IEnumerable.GetEnumerator() | ||
2469 | { | ||
2470 | return GetEnumerator(); | ||
2471 | } | ||
2472 | |||
2473 | public bool Current | ||
2474 | { | ||
2475 | get { return false; } | ||
2476 | } | ||
2477 | |||
2478 | object IEnumerator.Current | ||
2479 | { | ||
2480 | get { return false; } | ||
2481 | } | ||
2482 | |||
2483 | public void Dispose() | ||
2484 | { | ||
2485 | } | ||
2486 | |||
2487 | public void Reset() | ||
2488 | { | ||
2489 | throw new NotImplementedException(); | ||
2490 | } | ||
2491 | } | ||
2492 | |||
2493 | /// <summary> | ||
2494 | /// An enumerator that repeats forever. | ||
2495 | /// </summary> | ||
2496 | private class Repeat : IEnumerator<bool>, IEnumerable<bool> | ||
2497 | { | ||
2498 | public bool MoveNext() | ||
2499 | { | ||
2500 | return true; | ||
2501 | } | ||
2502 | |||
2503 | public IEnumerator<bool> GetEnumerator() | ||
2504 | { | ||
2505 | return (IEnumerator<bool>)this; | ||
2506 | } | ||
2507 | |||
2508 | IEnumerator IEnumerable.GetEnumerator() | ||
2509 | { | ||
2510 | return GetEnumerator(); | ||
2511 | } | ||
2512 | |||
2513 | public bool Current | ||
2514 | { | ||
2515 | get { return false; } | ||
2516 | } | ||
2517 | |||
2518 | object IEnumerator.Current | ||
2519 | { | ||
2520 | get { return false; } | ||
2521 | } | ||
2522 | |||
2523 | public void Dispose() | ||
2524 | { | ||
2525 | } | ||
2526 | |||
2527 | public void Reset() | ||
2528 | { | ||
2529 | throw new NotImplementedException(); | ||
2530 | } | ||
2531 | } | ||
2532 | |||
2533 | /// <summary> | ||
2534 | /// An enumerator that wraps another enumerator in order to catch a PrologException. | ||
2535 | /// </summary> | ||
2536 | public class Catch : IEnumerator<bool>, IEnumerable<bool> | ||
2537 | { | ||
2538 | private IEnumerator<bool> _enumerator; | ||
2539 | private PrologException _exception = null; | ||
2540 | |||
2541 | /// <summary> | ||
2542 | /// Call YP.getIterator(Goal, declaringClass) and save the returned iterator. | ||
2543 | /// If getIterator throws an exception, save it the same as MoveNext(). | ||
2544 | /// </summary> | ||
2545 | /// <param name="Goal"></param> | ||
2546 | /// <param name="declaringClass"></param> | ||
2547 | public Catch(object Goal, Type declaringClass) | ||
2548 | { | ||
2549 | try | ||
2550 | { | ||
2551 | _enumerator = getIterator(Goal, declaringClass).GetEnumerator(); | ||
2552 | } | ||
2553 | catch (PrologException exception) | ||
2554 | { | ||
2555 | // MoveNext() will check this. | ||
2556 | _exception = exception; | ||
2557 | } | ||
2558 | } | ||
2559 | |||
2560 | /// <summary> | ||
2561 | /// Call _enumerator.MoveNext(). If it throws a PrologException, set _exception | ||
2562 | /// and return false. After this returns false, call unifyExceptionOrThrow. | ||
2563 | /// </summary> | ||
2564 | /// <returns></returns> | ||
2565 | public bool MoveNext() | ||
2566 | { | ||
2567 | if (_exception != null) | ||
2568 | return false; | ||
2569 | |||
2570 | try | ||
2571 | { | ||
2572 | return _enumerator.MoveNext(); | ||
2573 | } | ||
2574 | catch (PrologException exception) | ||
2575 | { | ||
2576 | _exception = exception; | ||
2577 | return false; | ||
2578 | } | ||
2579 | } | ||
2580 | |||
2581 | /// <summary> | ||
2582 | /// Call this after MoveNext() returns false to check for an exception. If | ||
2583 | /// MoveNext did not get a PrologException, don't yield. | ||
2584 | /// Otherwise, unify the exception with Catcher and yield so the caller can | ||
2585 | /// do the handler code. However, if can't unify with Catcher then throw the exception. | ||
2586 | /// </summary> | ||
2587 | /// <param name="Catcher"></param> | ||
2588 | /// <returns></returns> | ||
2589 | public IEnumerable<bool> unifyExceptionOrThrow(object Catcher) | ||
2590 | { | ||
2591 | if (_exception != null) | ||
2592 | { | ||
2593 | bool didUnify = false; | ||
2594 | foreach (bool l1 in YP.unify(_exception._term, Catcher)) | ||
2595 | { | ||
2596 | didUnify = true; | ||
2597 | yield return false; | ||
2598 | } | ||
2599 | if (!didUnify) | ||
2600 | throw _exception; | ||
2601 | } | ||
2602 | } | ||
2603 | |||
2604 | public IEnumerator<bool> GetEnumerator() | ||
2605 | { | ||
2606 | return (IEnumerator<bool>)this; | ||
2607 | } | ||
2608 | |||
2609 | IEnumerator IEnumerable.GetEnumerator() | ||
2610 | { | ||
2611 | return GetEnumerator(); | ||
2612 | } | ||
2613 | |||
2614 | public bool Current | ||
2615 | { | ||
2616 | get { return _enumerator.Current; } | ||
2617 | } | ||
2618 | |||
2619 | object IEnumerator.Current | ||
2620 | { | ||
2621 | get { return _enumerator.Current; } | ||
2622 | } | ||
2623 | |||
2624 | public void Dispose() | ||
2625 | { | ||
2626 | if (_enumerator != null) | ||
2627 | _enumerator.Dispose(); | ||
2628 | } | ||
2629 | |||
2630 | public void Reset() | ||
2631 | { | ||
2632 | throw new NotImplementedException(); | ||
2633 | } | ||
2634 | } | ||
2635 | #pragma warning restore 0168, 0219 | ||
2636 | /// <summary> | ||
2637 | /// A ClauseHeadAndBody is used in Compiler.compileAnonymousFunction as a base class | ||
2638 | /// in order to implement YP.IClause. After creating the object, you must call setHeadAndBody. | ||
2639 | /// </summary> | ||
2640 | public class ClauseHeadAndBody | ||
2641 | { | ||
2642 | private object _Head; | ||
2643 | private object _Body; | ||
2644 | |||
2645 | public void setHeadAndBody(object Head, object Body) | ||
2646 | { | ||
2647 | _Head = Head; | ||
2648 | _Body = Body; | ||
2649 | } | ||
2650 | |||
2651 | public IEnumerable<bool> clause(object Head, object Body) | ||
2652 | { | ||
2653 | if (_Head == null || _Body == null) | ||
2654 | yield break; | ||
2655 | |||
2656 | #pragma warning disable 0168, 0219 | ||
2657 | foreach (bool l1 in YP.unify(Head, _Head)) | ||
2658 | { | ||
2659 | foreach (bool l2 in YP.unify(Body, _Body)) | ||
2660 | yield return false; | ||
2661 | } | ||
2662 | #pragma warning restore 0168, 0219 | ||
2663 | } | ||
2664 | } | ||
2665 | |||
2666 | /// <summary> | ||
2667 | /// CodeListReader extends TextReader and overrides Read to read the next code from | ||
2668 | /// the CodeList which is a Prolog list of integer character codes. | ||
2669 | /// </summary> | ||
2670 | public class CodeListReader : TextReader | ||
2671 | { | ||
2672 | private object _CodeList; | ||
2673 | |||
2674 | public CodeListReader(object CodeList) | ||
2675 | { | ||
2676 | _CodeList = YP.getValue(CodeList); | ||
2677 | } | ||
2678 | |||
2679 | /// <summary> | ||
2680 | /// If the head of _CodeList is an integer, return it and advance the list. Otherwise, | ||
2681 | /// return -1 for end of file. | ||
2682 | /// </summary> | ||
2683 | /// <returns></returns> | ||
2684 | public override int Read() | ||
2685 | { | ||
2686 | Functor2 CodeListPair = _CodeList as Functor2; | ||
2687 | int code; | ||
2688 | if (!(CodeListPair != null && CodeListPair._name == Atom.DOT && | ||
2689 | getInt(CodeListPair._arg1, out code))) | ||
2690 | { | ||
2691 | _CodeList = Atom.NIL; | ||
2692 | return -1; | ||
2693 | } | ||
2694 | |||
2695 | // Advance. | ||
2696 | _CodeList = YP.getValue(CodeListPair._arg2); | ||
2697 | return code; | ||
2698 | } | ||
2699 | } | ||
2700 | } | ||
2701 | } | ||
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs deleted file mode 100644 index c6a6748..0000000 --- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/YPCompiler.cs +++ /dev/null | |||
@@ -1,6382 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2007-2008, Jeff Thompson | ||
3 | * | ||
4 | * All rights reserved. | ||
5 | * | ||
6 | * Redistribution and use in source and binary forms, with or without | ||
7 | * modification, are permitted provided that the following conditions are met: | ||
8 | * | ||
9 | * * Redistributions of source code must retain the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer. | ||
11 | * * Redistributions in binary form must reproduce the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer in the | ||
13 | * documentation and/or other materials provided with the distribution. | ||
14 | * * Neither the name of the copyright holder nor the names of its contributors | ||
15 | * may be used to endorse or promote products derived from this software | ||
16 | * without specific prior written permission. | ||
17 | * | ||
18 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
19 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
20 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
21 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR | ||
22 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
23 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
24 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
25 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
26 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
27 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
28 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
29 | */ | ||
30 | |||
31 | using System; | ||
32 | using System.IO; | ||
33 | using System.Collections; | ||
34 | using System.Collections.Generic; | ||
35 | using System.Text; | ||
36 | using System.CodeDom.Compiler; | ||
37 | using System.Reflection; | ||
38 | |||
39 | namespace OpenSim.Region.ScriptEngine.Shared.YieldProlog | ||
40 | { | ||
41 | public class YPCompiler | ||
42 | { | ||
43 | private class CompilerState | ||
44 | { | ||
45 | public IndexedAnswers _pred = new IndexedAnswers(4); | ||
46 | public Dictionary<YP.NameArity, Atom> _moduleForNameArity = new Dictionary<YP.NameArity, Atom>(); | ||
47 | public int _gensymCounter; | ||
48 | public bool _useFinalCutCode; | ||
49 | public Variable _finalCutCode; | ||
50 | public bool _codeUsesYield; | ||
51 | public Atom _determinism; | ||
52 | // a list of '='(Name, Variable) | ||
53 | public List<object> _variableNames; | ||
54 | |||
55 | // Make these static functions that explicitly take the State so Prolog can call it. | ||
56 | |||
57 | /// <summary> | ||
58 | /// Make a new CompilerState and bind it to State. | ||
59 | /// </summary> | ||
60 | /// <param name="State"></param> | ||
61 | /// <returns></returns> | ||
62 | public static IEnumerable<bool> make(object State) | ||
63 | { | ||
64 | return YP.unify(State, new CompilerState()); | ||
65 | } | ||
66 | |||
67 | public static void assertPred(object State, object Pred, object Determinism) | ||
68 | { | ||
69 | State = YP.getValue(State); | ||
70 | object functorName = YP.getFunctorName(Pred); | ||
71 | object[] functorArgs = YP.getFunctorArgs(Pred); | ||
72 | // Debug: Should check if it's already asserted and is the same. | ||
73 | ((CompilerState)State)._pred.addAnswer | ||
74 | (new object[] { functorName, functorArgs.Length, Pred, YP.getValue(Determinism) }); | ||
75 | } | ||
76 | |||
77 | public static void assertModuleForNameArity(object State, object Name, object Arity, object Module) | ||
78 | { | ||
79 | State = YP.getValue(State); | ||
80 | Name = YP.getValue(Name); | ||
81 | Arity = YP.getValue(Arity); | ||
82 | Module = YP.getValue(Module); | ||
83 | // If the Module Atom comes from the parser, it always has null _declaringClass. | ||
84 | if (Module is Atom && ((Atom)Module)._module == null && Name is Atom && Arity is int) | ||
85 | // Replace a previous entry if it exists. | ||
86 | ((CompilerState)State)._moduleForNameArity[new YP.NameArity((Atom)Name, (int)Arity)] = | ||
87 | (Atom)Module; | ||
88 | } | ||
89 | |||
90 | public static void startFunction(object State, object Head) | ||
91 | { | ||
92 | State = YP.getValue(State); | ||
93 | ((CompilerState)State)._gensymCounter = 0; | ||
94 | ((CompilerState)State)._useFinalCutCode = false; | ||
95 | ((CompilerState)State)._finalCutCode = new Variable(); | ||
96 | ((CompilerState)State)._codeUsesYield = false; | ||
97 | if (CompilerState.isDetNoneOut(State, Head)) | ||
98 | ((CompilerState)State)._determinism = Atom.a("detNoneOut"); | ||
99 | else if (CompilerState.isSemidetNoneOut(State, Head)) | ||
100 | ((CompilerState)State)._determinism = Atom.a("semidetNoneOut"); | ||
101 | else | ||
102 | ((CompilerState)State)._determinism = Atom.a("nondet"); | ||
103 | } | ||
104 | |||
105 | public static void setCodeUsesYield(object State) | ||
106 | { | ||
107 | State = YP.getValue(State); | ||
108 | ((CompilerState)State)._codeUsesYield = true; | ||
109 | } | ||
110 | |||
111 | public static bool codeUsesYield(object State) | ||
112 | { | ||
113 | State = YP.getValue(State); | ||
114 | return ((CompilerState)State)._codeUsesYield; | ||
115 | } | ||
116 | |||
117 | public static bool determinismEquals(object State, object Term) | ||
118 | { | ||
119 | State = YP.getValue(State); | ||
120 | return YP.termEqual(((CompilerState)State)._determinism, Term); | ||
121 | } | ||
122 | |||
123 | /// <summary> | ||
124 | /// Set _variableNames to a new list of (Name = Variable) for each unique variable in rule. | ||
125 | /// If the variable is in variableNameSuggestions, use it, otherwise use x1, x2, etc. | ||
126 | /// </summary> | ||
127 | /// <param name="State"></param> | ||
128 | /// <param name="rule"></param> | ||
129 | /// <param name="variableNameSuggestions"></param> | ||
130 | public static void newVariableNames(object State, object Rule, object VariableNameSuggestions) | ||
131 | { | ||
132 | State = YP.getValue(State); | ||
133 | List<Variable> variablesSet = new List<Variable>(); | ||
134 | YP.addUniqueVariables(Rule, variablesSet); | ||
135 | |||
136 | ((CompilerState)State)._variableNames = new List<object>(); | ||
137 | int xCounter = 0; | ||
138 | foreach (Variable variable in variablesSet) | ||
139 | ((CompilerState)State)._variableNames.Add | ||
140 | (new Functor2(Atom.a("="), makeVariableName(variable, VariableNameSuggestions, ++xCounter), | ||
141 | variable)); | ||
142 | } | ||
143 | |||
144 | private static object makeVariableName(object variable, object variableNameSuggestions, int xCounter) | ||
145 | { | ||
146 | // Debug: should require named variables to start with _ or capital. Should | ||
147 | // check for duplicates and clashes with keywords. | ||
148 | for (object element = YP.getValue(variableNameSuggestions); | ||
149 | element is Functor2 && ((Functor2)element)._name == Atom.DOT; | ||
150 | element = YP.getValue(((Functor2)element)._arg2)) | ||
151 | { | ||
152 | object suggestionPair = YP.getValue(((Functor2)element)._arg1); | ||
153 | if (sameVariable(variable, ((Functor2)suggestionPair)._arg2)) | ||
154 | { | ||
155 | Atom suggestion = (Atom)YP.getValue(((Functor2)suggestionPair)._arg1); | ||
156 | if (suggestion.Equals(Atom.a("Atom"))) | ||
157 | suggestion = Atom.a("Atom_1"); | ||
158 | if (suggestion.Equals(Atom.a("Variable"))) | ||
159 | suggestion = Atom.a("Variable_1"); | ||
160 | if (suggestion.Equals(Atom.a("Functor"))) | ||
161 | suggestion = Atom.a("Functor_1"); | ||
162 | return suggestion; | ||
163 | } | ||
164 | } | ||
165 | |||
166 | return Atom.a("x" + xCounter); | ||
167 | } | ||
168 | |||
169 | /// <summary> | ||
170 | /// Unify Result with the name assigned by CompilerState.newVariableNames in State._variableNames | ||
171 | /// for variable. | ||
172 | /// </summary> | ||
173 | /// <param name="variable">a Variable</param> | ||
174 | /// <param name="State"></param> | ||
175 | /// <param name="Result">the assigned Name</param> | ||
176 | public static IEnumerable<bool> getVariableName(object State, object variable, object Result) | ||
177 | { | ||
178 | State = YP.getValue(State); | ||
179 | foreach (object variableInfo in ((CompilerState)State)._variableNames) | ||
180 | { | ||
181 | if (variableInfo is Functor2 && ((Functor2)variableInfo)._name.Equals(Atom.a("="))) | ||
182 | { | ||
183 | if (sameVariable(variable, ((Functor2)variableInfo)._arg2)) | ||
184 | return YP.unify(Result, ((Functor2)variableInfo)._arg1); | ||
185 | } | ||
186 | } | ||
187 | |||
188 | // We set up names for all unique variables, so this should never happen. | ||
189 | throw new PrologException(Atom.a("Can't find entry in _variableNames")); | ||
190 | } | ||
191 | |||
192 | public static IEnumerable<bool> variableNamesList(object State, object VariableNamesList) | ||
193 | { | ||
194 | State = YP.getValue(State); | ||
195 | return YP.unify(VariableNamesList, ListPair.make(((CompilerState)State)._variableNames)); | ||
196 | } | ||
197 | |||
198 | public static IEnumerable<bool> gensym(object State, object Base, object Symbol) | ||
199 | { | ||
200 | State = YP.getValue(State); | ||
201 | return YP.unify(Symbol, Atom.a(Base.ToString() + ++((CompilerState)State)._gensymCounter)); | ||
202 | } | ||
203 | |||
204 | // disable warning on l1, don't see how we can | ||
205 | // code this differently | ||
206 | #pragma warning disable 0168, 0164, 0162, 0219 | ||
207 | public static bool isDetNoneOut(object State, object Term) | ||
208 | { | ||
209 | State = YP.getValue(State); | ||
210 | object functorName = YP.getFunctorName(Term); | ||
211 | object[] functorArgs = YP.getFunctorArgs(Term); | ||
212 | |||
213 | Variable pred = new Variable(); | ||
214 | foreach (bool l1 in ((CompilerState)State)._pred.match | ||
215 | (new object[] { functorName, functorArgs.Length, pred, Atom.a("det") })) | ||
216 | { | ||
217 | if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) | ||
218 | { | ||
219 | return true; | ||
220 | } | ||
221 | } | ||
222 | |||
223 | return false; | ||
224 | } | ||
225 | |||
226 | public static bool isSemidetNoneOut(object State, object Term) | ||
227 | { | ||
228 | State = YP.getValue(State); | ||
229 | object functorName = YP.getFunctorName(Term); | ||
230 | object[] functorArgs = YP.getFunctorArgs(Term); | ||
231 | |||
232 | Variable pred = new Variable(); | ||
233 | foreach (bool l1 in ((CompilerState)State)._pred.match | ||
234 | (new object[] { functorName, functorArgs.Length, pred, Atom.a("semidet") })) | ||
235 | { | ||
236 | if (CompilerState.isNoneOut(YP.getFunctorArgs(pred.getValue()))) | ||
237 | { | ||
238 | return true; | ||
239 | } | ||
240 | } | ||
241 | |||
242 | return false; | ||
243 | } | ||
244 | #pragma warning restore 0168, 0164, 0162, 0219 | ||
245 | |||
246 | /// <summary> | ||
247 | /// Return false if any of args is out, otherwise true. | ||
248 | /// args is an array of ::(Type,Mode) where Mode is in or out. | ||
249 | /// </summary> | ||
250 | /// <param name="args"></param> | ||
251 | /// <returns></returns> | ||
252 | private static bool isNoneOut(object[] args) | ||
253 | { | ||
254 | foreach (object arg in args) | ||
255 | { | ||
256 | if (arg is Functor2 && ((Functor2)arg)._name == Atom.a("::") && | ||
257 | ((Functor2)arg)._arg2 == Atom.a("out")) | ||
258 | return false; | ||
259 | } | ||
260 | return true; | ||
261 | } | ||
262 | |||
263 | public static bool nameArityHasModule(object State, object Name, object Arity, object Module) | ||
264 | { | ||
265 | State = YP.getValue(State); | ||
266 | Name = YP.getValue(Name); | ||
267 | Arity = YP.getValue(Arity); | ||
268 | Module = YP.getValue(Module); | ||
269 | if (Name is Atom && Arity is int) | ||
270 | { | ||
271 | Atom FoundModule; | ||
272 | if (!((CompilerState)State)._moduleForNameArity.TryGetValue | ||
273 | (new YP.NameArity((Atom)Name, (int)Arity), out FoundModule)) | ||
274 | return false; | ||
275 | return FoundModule == Module; | ||
276 | } | ||
277 | return false; | ||
278 | } | ||
279 | } | ||
280 | |||
281 | // disable warning on l1, don't see how we can | ||
282 | // code this differently | ||
283 | #pragma warning disable 0168, 0219,0164,0162 | ||
284 | |||
285 | /// <summary> | ||
286 | /// Use makeFunctionPseudoCode, convertFunctionCSharp and compileAnonymousFunction | ||
287 | /// to return an anonymous YP.IClause for the Head and Body of a rule clause. | ||
288 | /// </summary> | ||
289 | /// <param name="Head">a prolog term such as new Functor2("test1", X, Y). | ||
290 | /// Note that the name of the head is ignored. | ||
291 | /// </param> | ||
292 | /// <param name="Body">a prolog term such as | ||
293 | /// new Functor2(",", new Functor1(Atom.a("test2", Atom.a("")), X), | ||
294 | /// new Functor2("=", Y, X)). | ||
295 | /// This may not be null. (For a head-only clause, set the Body to Atom.a("true"). | ||
296 | /// </param> | ||
297 | /// <param name="declaringClass">if not null, the code is compiled as a subclass of this class | ||
298 | /// to resolve references to the default module Atom.a("")</param> | ||
299 | /// <returns>a new YP.IClause object on which you can call match(object[] args) where | ||
300 | /// args length is the arity of the Head</returns> | ||
301 | public static YP.IClause compileAnonymousClause(object Head, object Body, Type declaringClass) | ||
302 | { | ||
303 | object[] args = YP.getFunctorArgs(Head); | ||
304 | // compileAnonymousFunction wants "function". | ||
305 | object Rule = new Functor2(Atom.RULE, Functor.make("function", args), Body); | ||
306 | object RuleList = ListPair.make(new Functor2(Atom.F, Rule, Atom.NIL)); | ||
307 | |||
308 | StringWriter functionCode = new StringWriter(); | ||
309 | Variable SaveOutputStream = new Variable(); | ||
310 | foreach (bool l1 in YP.current_output(SaveOutputStream)) | ||
311 | { | ||
312 | try | ||
313 | { | ||
314 | YP.tell(functionCode); | ||
315 | Variable PseudoCode = new Variable(); | ||
316 | foreach (bool l2 in makeFunctionPseudoCode(RuleList, PseudoCode)) | ||
317 | { | ||
318 | if (YP.termEqual(PseudoCode, Atom.a("getDeclaringClass"))) | ||
319 | // Ignore getDeclaringClass since we have access to the one passed in. | ||
320 | continue; | ||
321 | |||
322 | convertFunctionCSharp(PseudoCode); | ||
323 | } | ||
324 | YP.told(); | ||
325 | } | ||
326 | finally | ||
327 | { | ||
328 | // Restore after calling tell. | ||
329 | YP.tell(SaveOutputStream.getValue()); | ||
330 | } | ||
331 | } | ||
332 | return YPCompiler.compileAnonymousFunction | ||
333 | (functionCode.ToString(), args.Length, declaringClass); | ||
334 | } | ||
335 | |||
336 | /// <summary> | ||
337 | /// Use CodeDomProvider to compile the functionCode and return a YP.ClauseHeadAndBody | ||
338 | /// which implements YP.IClause. | ||
339 | /// The function name must be "function" and have nArgs arguments. | ||
340 | /// </summary> | ||
341 | /// <param name="functionCode">the code for the iterator, such as | ||
342 | /// "public static IEnumerable<bool> function() { yield return false; }" | ||
343 | /// </param> | ||
344 | /// <param name="nArgs">the number of args in the function</param> | ||
345 | /// <param name="declaringClass">if not null, then use the functionCode inside a class which | ||
346 | /// inherits from contextClass, so that references in functionCode to methods in declaringClass don't | ||
347 | /// have to be qualified</param> | ||
348 | /// <returns>a new YP.IClause object on which you can call match(object[] args) where | ||
349 | /// args length is nArgs</returns> | ||
350 | public static YP.IClause compileAnonymousFunction(string functionCode, int nArgs, Type declaringClass) | ||
351 | { | ||
352 | CompilerParameters parameters = new CompilerParameters(); | ||
353 | // This gets the location of the System assembly. | ||
354 | parameters.ReferencedAssemblies.Add(typeof(System.Int32).Assembly.Location); | ||
355 | // This gets the location of this assembly which also has YieldProlog.YP, etc. | ||
356 | parameters.ReferencedAssemblies.Add(typeof(YPCompiler).Assembly.Location); | ||
357 | if (declaringClass != null) | ||
358 | parameters.ReferencedAssemblies.Add(declaringClass.Assembly.Location); | ||
359 | parameters.GenerateInMemory = true; | ||
360 | |||
361 | StringBuilder sourceCode = new StringBuilder(); | ||
362 | sourceCode.Append(@" | ||
363 | using System; | ||
364 | using System.Collections.Generic; | ||
365 | using OpenSim.Region.ScriptEngine.Shared.YieldProlog; | ||
366 | |||
367 | namespace Temporary { | ||
368 | public class Temporary : YP.ClauseHeadAndBody, YP.IClause {"); | ||
369 | if (declaringClass == null) | ||
370 | // We don't extend a class with getDeclaringClass, so define it. | ||
371 | sourceCode.Append(@" | ||
372 | public class Inner { | ||
373 | public static System.Type getDeclaringClass() { return null; } | ||
374 | "); | ||
375 | else | ||
376 | sourceCode.Append(@" | ||
377 | public class Inner : " + declaringClass.FullName + @" { | ||
378 | "); | ||
379 | sourceCode.Append(functionCode); | ||
380 | // Basically, match applies the args to function. | ||
381 | sourceCode.Append(@" | ||
382 | } | ||
383 | public IEnumerable<bool> match(object[] args) { | ||
384 | return Inner.function("); | ||
385 | if (nArgs >= 1) | ||
386 | sourceCode.Append("args[0]"); | ||
387 | for (int i = 1; i < nArgs; ++i) | ||
388 | sourceCode.Append(", args[" + i + "]"); | ||
389 | sourceCode.Append(@"); | ||
390 | } | ||
391 | } | ||
392 | } | ||
393 | "); | ||
394 | |||
395 | CompilerResults results = CodeDomProvider.CreateProvider | ||
396 | ("CSharp").CompileAssemblyFromSource(parameters, sourceCode.ToString()); | ||
397 | if (results.Errors.Count > 0) | ||
398 | throw new Exception("Error evaluating code: " + results.Errors[0]); | ||
399 | |||
400 | // Return a new Temporary.Temporary object. | ||
401 | return (YP.IClause)results.CompiledAssembly.GetType | ||
402 | ("Temporary.Temporary").GetConstructor(Type.EmptyTypes).Invoke(null); | ||
403 | } | ||
404 | |||
405 | /// <summary> | ||
406 | /// If the functor with name and args can be called directly as determined by | ||
407 | /// functorCallFunctionName, then call it and return its iterator. If the predicate is | ||
408 | /// dynamic and undefined, or if static and the method cannot be found, return | ||
409 | /// the result of YP.unknownPredicate. | ||
410 | /// This returns null if the functor has a special form than needs to be compiled | ||
411 | /// (including ,/2 and ;/2). | ||
412 | /// </summary> | ||
413 | /// <param name="name"></param> | ||
414 | /// <param name="args"></param> | ||
415 | /// <param name="declaringClass">used to resolve references to the default | ||
416 | /// module Atom.a(""). If a declaringClass is needed to resolve the reference but it is | ||
417 | /// null, this throws a PrologException for existence_error</param> | ||
418 | /// <returns></returns> | ||
419 | public static IEnumerable<bool> getSimpleIterator(Atom name, object[] args, Type declaringClass) | ||
420 | { | ||
421 | CompilerState state = new CompilerState(); | ||
422 | Variable FunctionName = new Variable(); | ||
423 | foreach (bool l1 in functorCallFunctionName(state, name, args.Length, FunctionName)) | ||
424 | { | ||
425 | Atom functionNameAtom = ((Atom)FunctionName.getValue()); | ||
426 | if (functionNameAtom == Atom.NIL) | ||
427 | // name is for a dynamic predicate. | ||
428 | return YP.matchDynamic(name, args); | ||
429 | |||
430 | string methodName = functionNameAtom._name; | ||
431 | // Set the default for the method to call. | ||
432 | Type methodClass = declaringClass; | ||
433 | |||
434 | bool checkMode = false; | ||
435 | if (methodName.StartsWith("YP.")) | ||
436 | { | ||
437 | // Assume we only check mode in calls to standard Prolog predicates in YP. | ||
438 | checkMode = true; | ||
439 | |||
440 | // Use the method in class YP. | ||
441 | methodName = methodName.Substring(3); | ||
442 | methodClass = typeof(YP); | ||
443 | } | ||
444 | if (methodName.Contains(".")) | ||
445 | // We don't support calling inner classes, etc. | ||
446 | return null; | ||
447 | |||
448 | if (methodClass == null) | ||
449 | return YP.unknownPredicate | ||
450 | (name, args.Length, | ||
451 | "Cannot find predicate function for: " + name + "/" + args.Length + | ||
452 | " because declaringClass is null. Set declaringClass to the class containing " + | ||
453 | methodName); | ||
454 | try | ||
455 | { | ||
456 | if (checkMode) | ||
457 | { | ||
458 | assertYPPred(state); | ||
459 | object functor = Functor.make(name, args); | ||
460 | if (CompilerState.isDetNoneOut(state, functor)) | ||
461 | { | ||
462 | methodClass.InvokeMember | ||
463 | (methodName, BindingFlags.InvokeMethod, null, null, args); | ||
464 | return YP.succeed(); | ||
465 | } | ||
466 | if (CompilerState.isSemidetNoneOut(state, functor)) | ||
467 | { | ||
468 | if ((bool)methodClass.InvokeMember | ||
469 | (methodName, BindingFlags.InvokeMethod, null, null, args)) | ||
470 | return YP.succeed(); | ||
471 | else | ||
472 | return YP.fail(); | ||
473 | } | ||
474 | |||
475 | } | ||
476 | return (IEnumerable<bool>)methodClass.InvokeMember | ||
477 | (methodName, BindingFlags.InvokeMethod, null, null, args); | ||
478 | } | ||
479 | catch (TargetInvocationException exception) | ||
480 | { | ||
481 | throw exception.InnerException; | ||
482 | } | ||
483 | catch (MissingMethodException) | ||
484 | { | ||
485 | return YP.unknownPredicate | ||
486 | (name, args.Length, | ||
487 | "Cannot find predicate function " + methodName + " for " + name + "/" + args.Length + | ||
488 | " in " + methodClass.FullName); | ||
489 | } | ||
490 | } | ||
491 | |||
492 | return null; | ||
493 | } | ||
494 | |||
495 | /// <summary> | ||
496 | /// Return true if there is a dynamic or static predicate with name and arity. | ||
497 | /// This returns false for built-in predicates. | ||
498 | /// </summary> | ||
499 | /// <param name="name"></param> | ||
500 | /// <param name="arity"></param> | ||
501 | /// <param name="declaringClass">used to resolve references to the default | ||
502 | /// module Atom.a(""). If a declaringClass is needed to resolve the reference but it is | ||
503 | /// null, return false</param> | ||
504 | /// <returns></returns> | ||
505 | public static bool isCurrentPredicate(Atom name, int arity, Type declaringClass) | ||
506 | { | ||
507 | CompilerState state = new CompilerState(); | ||
508 | Variable FunctionName = new Variable(); | ||
509 | foreach (bool l1 in functorCallFunctionName(state, name, arity, FunctionName)) | ||
510 | { | ||
511 | Atom functionNameAtom = ((Atom)FunctionName.getValue()); | ||
512 | if (functionNameAtom == Atom.NIL) | ||
513 | // name is for a dynamic predicate. | ||
514 | return YP.isDynamicCurrentPredicate(name, arity); | ||
515 | |||
516 | string methodName = functionNameAtom._name; | ||
517 | |||
518 | if (methodName.StartsWith("YP.")) | ||
519 | // current_predicate/1 should fail for built-ins. | ||
520 | return false; | ||
521 | if (methodName.Contains(".")) | ||
522 | // We don't support calling inner classes, etc. | ||
523 | return false; | ||
524 | if (declaringClass == null) | ||
525 | return false; | ||
526 | |||
527 | foreach (MemberInfo member in declaringClass.GetMember(methodName)) | ||
528 | { | ||
529 | MethodInfo method = member as MethodInfo; | ||
530 | if (method == null) | ||
531 | continue; | ||
532 | if ((method.Attributes | MethodAttributes.Static) == 0) | ||
533 | // Not a static method. | ||
534 | continue; | ||
535 | if (method.GetParameters().Length == arity) | ||
536 | return true; | ||
537 | } | ||
538 | } | ||
539 | |||
540 | return false; | ||
541 | } | ||
542 | |||
543 | // Compiler output follows. | ||
544 | |||
545 | public class YPInnerClass { } | ||
546 | public static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; } | ||
547 | |||
548 | public static void repeatWrite(object arg1, object N) | ||
549 | { | ||
550 | { | ||
551 | object _Value = arg1; | ||
552 | if (YP.termEqual(N, 0)) | ||
553 | { | ||
554 | return; | ||
555 | } | ||
556 | } | ||
557 | { | ||
558 | object Value = arg1; | ||
559 | Variable NextN = new Variable(); | ||
560 | YP.write(Value); | ||
561 | foreach (bool l2 in YP.unify(NextN, YP.subtract(N, 1))) | ||
562 | { | ||
563 | repeatWrite(Value, NextN); | ||
564 | return; | ||
565 | } | ||
566 | } | ||
567 | } | ||
568 | |||
569 | public static bool sameVariable(object Variable1, object Variable2) | ||
570 | { | ||
571 | { | ||
572 | if (YP.var(Variable1)) | ||
573 | { | ||
574 | if (YP.var(Variable2)) | ||
575 | { | ||
576 | if (YP.termEqual(Variable1, Variable2)) | ||
577 | { | ||
578 | return true; | ||
579 | } | ||
580 | } | ||
581 | } | ||
582 | } | ||
583 | return false; | ||
584 | } | ||
585 | |||
586 | public static IEnumerable<bool> makeFunctionPseudoCode(object RuleList, object FunctionCode) | ||
587 | { | ||
588 | { | ||
589 | Variable State = new Variable(); | ||
590 | foreach (bool l2 in CompilerState.make(State)) | ||
591 | { | ||
592 | assertYPPred(State); | ||
593 | processCompilerDirectives(RuleList, State); | ||
594 | foreach (bool l3 in YP.unify(FunctionCode, Atom.a("getDeclaringClass"))) | ||
595 | { | ||
596 | yield return false; | ||
597 | } | ||
598 | foreach (bool l3 in makeFunctionPseudoCode3(RuleList, State, FunctionCode)) | ||
599 | { | ||
600 | yield return false; | ||
601 | } | ||
602 | } | ||
603 | } | ||
604 | } | ||
605 | |||
606 | public static void assertYPPred(object State) | ||
607 | { | ||
608 | { | ||
609 | CompilerState.assertPred(State, Atom.a("nl"), Atom.a("det")); | ||
610 | CompilerState.assertPred(State, new Functor1("write", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
611 | CompilerState.assertPred(State, new Functor1("put_code", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
612 | CompilerState.assertPred(State, new Functor1("see", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
613 | CompilerState.assertPred(State, Atom.a("seen"), Atom.a("det")); | ||
614 | CompilerState.assertPred(State, new Functor1("tell", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
615 | CompilerState.assertPred(State, Atom.a("told"), Atom.a("det")); | ||
616 | CompilerState.assertPred(State, new Functor1("throw", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
617 | CompilerState.assertPred(State, new Functor1("abolish", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
618 | CompilerState.assertPred(State, new Functor1("retractall", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
619 | CompilerState.assertPred(State, new Functor2("set_prolog_flag", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("det")); | ||
620 | CompilerState.assertPred(State, new Functor1("var", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
621 | CompilerState.assertPred(State, new Functor1("nonvar", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
622 | CompilerState.assertPred(State, new Functor1("atom", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
623 | CompilerState.assertPred(State, new Functor1("integer", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
624 | CompilerState.assertPred(State, new Functor1("float", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
625 | CompilerState.assertPred(State, new Functor1("number", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
626 | CompilerState.assertPred(State, new Functor1("atomic", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
627 | CompilerState.assertPred(State, new Functor1("compound", new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
628 | CompilerState.assertPred(State, new Functor2("==", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
629 | CompilerState.assertPred(State, new Functor2("\\==", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
630 | CompilerState.assertPred(State, new Functor2("@<", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
631 | CompilerState.assertPred(State, new Functor2("@=<", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
632 | CompilerState.assertPred(State, new Functor2("@>", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
633 | CompilerState.assertPred(State, new Functor2("@>=", new Functor2("::", Atom.a("univ"), Atom.a("in")), new Functor2("::", Atom.a("univ"), Atom.a("in"))), Atom.a("semidet")); | ||
634 | return; | ||
635 | } | ||
636 | } | ||
637 | |||
638 | public static void processCompilerDirectives(object arg1, object arg2) | ||
639 | { | ||
640 | { | ||
641 | object _State = arg2; | ||
642 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
643 | { | ||
644 | return; | ||
645 | } | ||
646 | } | ||
647 | { | ||
648 | object State = arg2; | ||
649 | Variable Pred = new Variable(); | ||
650 | Variable Determinism = new Variable(); | ||
651 | Variable x3 = new Variable(); | ||
652 | Variable RestRules = new Variable(); | ||
653 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", new Functor1(":-", new Functor1("pred", new Functor2("is", Pred, Determinism))), x3), RestRules))) | ||
654 | { | ||
655 | CompilerState.assertPred(State, Pred, Determinism); | ||
656 | processCompilerDirectives(RestRules, State); | ||
657 | return; | ||
658 | } | ||
659 | } | ||
660 | { | ||
661 | object State = arg2; | ||
662 | Variable Module = new Variable(); | ||
663 | Variable PredicateList = new Variable(); | ||
664 | Variable x3 = new Variable(); | ||
665 | Variable RestRules = new Variable(); | ||
666 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", new Functor1(":-", new Functor2("import", Module, PredicateList)), x3), RestRules))) | ||
667 | { | ||
668 | foreach (bool l3 in importPredicateList(State, Module, PredicateList)) | ||
669 | { | ||
670 | processCompilerDirectives(RestRules, State); | ||
671 | return; | ||
672 | } | ||
673 | } | ||
674 | } | ||
675 | { | ||
676 | object State = arg2; | ||
677 | Variable x1 = new Variable(); | ||
678 | Variable x2 = new Variable(); | ||
679 | Variable RestRules = new Variable(); | ||
680 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", new Functor1(":-", x1), x2), RestRules))) | ||
681 | { | ||
682 | processCompilerDirectives(RestRules, State); | ||
683 | return; | ||
684 | } | ||
685 | } | ||
686 | { | ||
687 | object State = arg2; | ||
688 | Variable Head = new Variable(); | ||
689 | Variable _Body = new Variable(); | ||
690 | Variable x3 = new Variable(); | ||
691 | Variable RestRules = new Variable(); | ||
692 | Variable Name = new Variable(); | ||
693 | Variable Arity = new Variable(); | ||
694 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", new Functor2(":-", Head, _Body), x3), RestRules))) | ||
695 | { | ||
696 | foreach (bool l3 in YP.functor(Head, Name, Arity)) | ||
697 | { | ||
698 | CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a("")); | ||
699 | processCompilerDirectives(RestRules, State); | ||
700 | return; | ||
701 | } | ||
702 | } | ||
703 | } | ||
704 | { | ||
705 | object State = arg2; | ||
706 | Variable Fact = new Variable(); | ||
707 | Variable x2 = new Variable(); | ||
708 | Variable RestRules = new Variable(); | ||
709 | Variable Name = new Variable(); | ||
710 | Variable Arity = new Variable(); | ||
711 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", Fact, x2), RestRules))) | ||
712 | { | ||
713 | foreach (bool l3 in YP.functor(Fact, Name, Arity)) | ||
714 | { | ||
715 | CompilerState.assertModuleForNameArity(State, Name, Arity, Atom.a("")); | ||
716 | processCompilerDirectives(RestRules, State); | ||
717 | return; | ||
718 | } | ||
719 | } | ||
720 | } | ||
721 | { | ||
722 | object State = arg2; | ||
723 | Variable x1 = new Variable(); | ||
724 | Variable RestRules = new Variable(); | ||
725 | foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestRules))) | ||
726 | { | ||
727 | processCompilerDirectives(RestRules, State); | ||
728 | return; | ||
729 | } | ||
730 | } | ||
731 | } | ||
732 | |||
733 | public static IEnumerable<bool> importPredicateList(object arg1, object arg2, object arg3) | ||
734 | { | ||
735 | { | ||
736 | object _State = arg1; | ||
737 | object _Module = arg2; | ||
738 | foreach (bool l2 in YP.unify(arg3, Atom.NIL)) | ||
739 | { | ||
740 | yield return true; | ||
741 | yield break; | ||
742 | } | ||
743 | } | ||
744 | { | ||
745 | object State = arg1; | ||
746 | object Module = arg2; | ||
747 | Variable Name = new Variable(); | ||
748 | Variable Arity = new Variable(); | ||
749 | Variable Rest = new Variable(); | ||
750 | foreach (bool l2 in YP.unify(arg3, new ListPair(new Functor2("/", Name, Arity), Rest))) | ||
751 | { | ||
752 | CompilerState.assertModuleForNameArity(State, Name, Arity, Module); | ||
753 | foreach (bool l3 in importPredicateList(State, Module, Rest)) | ||
754 | { | ||
755 | yield return true; | ||
756 | yield break; | ||
757 | } | ||
758 | } | ||
759 | } | ||
760 | { | ||
761 | object State = arg1; | ||
762 | object Module = arg2; | ||
763 | Variable x3 = new Variable(); | ||
764 | Variable Rest = new Variable(); | ||
765 | foreach (bool l2 in YP.unify(arg3, new ListPair(x3, Rest))) | ||
766 | { | ||
767 | foreach (bool l3 in importPredicateList(State, Module, Rest)) | ||
768 | { | ||
769 | yield return true; | ||
770 | yield break; | ||
771 | } | ||
772 | } | ||
773 | } | ||
774 | } | ||
775 | |||
776 | public static IEnumerable<bool> makeFunctionPseudoCode3(object RuleList, object State, object FunctionCode) | ||
777 | { | ||
778 | { | ||
779 | Variable SamePredicateRuleList = new Variable(); | ||
780 | Variable RestRules = new Variable(); | ||
781 | foreach (bool l2 in samePredicateRuleList(RuleList, SamePredicateRuleList, RestRules)) | ||
782 | { | ||
783 | if (YP.termNotEqual(SamePredicateRuleList, Atom.NIL)) | ||
784 | { | ||
785 | foreach (bool l4 in compileSamePredicateFunction(SamePredicateRuleList, State, FunctionCode)) | ||
786 | { | ||
787 | yield return false; | ||
788 | } | ||
789 | foreach (bool l4 in makeFunctionPseudoCode3(RestRules, State, FunctionCode)) | ||
790 | { | ||
791 | yield return false; | ||
792 | } | ||
793 | } | ||
794 | } | ||
795 | } | ||
796 | } | ||
797 | |||
798 | public static IEnumerable<bool> compileSamePredicateFunction(object SamePredicateRuleList, object State, object FunctionCode) | ||
799 | { | ||
800 | { | ||
801 | Variable FirstRule = new Variable(); | ||
802 | Variable x5 = new Variable(); | ||
803 | Variable x6 = new Variable(); | ||
804 | Variable x7 = new Variable(); | ||
805 | Variable Head = new Variable(); | ||
806 | Variable x9 = new Variable(); | ||
807 | Variable ArgAssignments = new Variable(); | ||
808 | Variable Calls = new Variable(); | ||
809 | Variable Rule = new Variable(); | ||
810 | Variable VariableNameSuggestions = new Variable(); | ||
811 | Variable ClauseBag = new Variable(); | ||
812 | Variable Name = new Variable(); | ||
813 | Variable ArgsList = new Variable(); | ||
814 | Variable FunctionArgNames = new Variable(); | ||
815 | Variable MergedArgName = new Variable(); | ||
816 | Variable ArgName = new Variable(); | ||
817 | Variable MergedArgNames = new Variable(); | ||
818 | Variable FunctionArgs = new Variable(); | ||
819 | Variable BodyCode = new Variable(); | ||
820 | Variable ReturnType = new Variable(); | ||
821 | Variable BodyWithReturn = new Variable(); | ||
822 | foreach (bool l2 in YP.unify(new ListPair(new Functor2("f", FirstRule, x5), x6), SamePredicateRuleList)) | ||
823 | { | ||
824 | foreach (bool l3 in YP.unify(FirstRule, new Functor1(":-", x7))) | ||
825 | { | ||
826 | goto cutIf1; | ||
827 | } | ||
828 | foreach (bool l3 in YP.unify(new Functor2(":-", Head, x9), FirstRule)) | ||
829 | { | ||
830 | CompilerState.startFunction(State, Head); | ||
831 | FindallAnswers findallAnswers3 = new FindallAnswers(new Functor2("f", ArgAssignments, Calls)); | ||
832 | foreach (bool l4 in member(new Functor2("f", Rule, VariableNameSuggestions), SamePredicateRuleList)) | ||
833 | { | ||
834 | foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) | ||
835 | { | ||
836 | findallAnswers3.add(); | ||
837 | } | ||
838 | } | ||
839 | foreach (bool l4 in findallAnswers3.result(ClauseBag)) | ||
840 | { | ||
841 | foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) | ||
842 | { | ||
843 | foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) | ||
844 | { | ||
845 | FindallAnswers findallAnswers4 = new FindallAnswers(MergedArgName); | ||
846 | foreach (bool l7 in member(ArgName, FunctionArgNames)) | ||
847 | { | ||
848 | foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) | ||
849 | { | ||
850 | findallAnswers4.add(); | ||
851 | goto cutIf5; | ||
852 | } | ||
853 | foreach (bool l8 in YP.unify(MergedArgName, ArgName)) | ||
854 | { | ||
855 | findallAnswers4.add(); | ||
856 | } | ||
857 | cutIf5: | ||
858 | { } | ||
859 | } | ||
860 | foreach (bool l7 in findallAnswers4.result(MergedArgNames)) | ||
861 | { | ||
862 | foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) | ||
863 | { | ||
864 | foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) | ||
865 | { | ||
866 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
867 | { | ||
868 | foreach (bool l11 in YP.unify(ReturnType, Atom.a("void"))) | ||
869 | { | ||
870 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
871 | { | ||
872 | foreach (bool l13 in append(BodyCode, new ListPair(Atom.a("returnfalse"), Atom.NIL), BodyWithReturn)) | ||
873 | { | ||
874 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
875 | { | ||
876 | yield return false; | ||
877 | } | ||
878 | } | ||
879 | goto cutIf7; | ||
880 | } | ||
881 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
882 | { | ||
883 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
884 | { | ||
885 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
886 | { | ||
887 | yield return false; | ||
888 | } | ||
889 | } | ||
890 | goto cutIf8; | ||
891 | } | ||
892 | if (CompilerState.codeUsesYield(State)) | ||
893 | { | ||
894 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
895 | { | ||
896 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
897 | { | ||
898 | yield return false; | ||
899 | } | ||
900 | } | ||
901 | goto cutIf9; | ||
902 | } | ||
903 | foreach (bool l12 in append(BodyCode, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.fail"), Atom.NIL), new ListPair(Atom.a("yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) | ||
904 | { | ||
905 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
906 | { | ||
907 | yield return false; | ||
908 | } | ||
909 | } | ||
910 | cutIf9: | ||
911 | cutIf8: | ||
912 | cutIf7: | ||
913 | { } | ||
914 | } | ||
915 | goto cutIf6; | ||
916 | } | ||
917 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
918 | { | ||
919 | foreach (bool l11 in YP.unify(ReturnType, Atom.a("bool"))) | ||
920 | { | ||
921 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
922 | { | ||
923 | foreach (bool l13 in append(BodyCode, new ListPair(Atom.a("returnfalse"), Atom.NIL), BodyWithReturn)) | ||
924 | { | ||
925 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
926 | { | ||
927 | yield return false; | ||
928 | } | ||
929 | } | ||
930 | goto cutIf11; | ||
931 | } | ||
932 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
933 | { | ||
934 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
935 | { | ||
936 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
937 | { | ||
938 | yield return false; | ||
939 | } | ||
940 | } | ||
941 | goto cutIf12; | ||
942 | } | ||
943 | if (CompilerState.codeUsesYield(State)) | ||
944 | { | ||
945 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
946 | { | ||
947 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
948 | { | ||
949 | yield return false; | ||
950 | } | ||
951 | } | ||
952 | goto cutIf13; | ||
953 | } | ||
954 | foreach (bool l12 in append(BodyCode, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.fail"), Atom.NIL), new ListPair(Atom.a("yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) | ||
955 | { | ||
956 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
957 | { | ||
958 | yield return false; | ||
959 | } | ||
960 | } | ||
961 | cutIf13: | ||
962 | cutIf12: | ||
963 | cutIf11: | ||
964 | { } | ||
965 | } | ||
966 | goto cutIf10; | ||
967 | } | ||
968 | foreach (bool l10 in YP.unify(ReturnType, Atom.a("IEnumerable<bool>"))) | ||
969 | { | ||
970 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
971 | { | ||
972 | foreach (bool l12 in append(BodyCode, new ListPair(Atom.a("returnfalse"), Atom.NIL), BodyWithReturn)) | ||
973 | { | ||
974 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
975 | { | ||
976 | yield return false; | ||
977 | } | ||
978 | } | ||
979 | goto cutIf14; | ||
980 | } | ||
981 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
982 | { | ||
983 | foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) | ||
984 | { | ||
985 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
986 | { | ||
987 | yield return false; | ||
988 | } | ||
989 | } | ||
990 | goto cutIf15; | ||
991 | } | ||
992 | if (CompilerState.codeUsesYield(State)) | ||
993 | { | ||
994 | foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) | ||
995 | { | ||
996 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
997 | { | ||
998 | yield return false; | ||
999 | } | ||
1000 | } | ||
1001 | goto cutIf16; | ||
1002 | } | ||
1003 | foreach (bool l11 in append(BodyCode, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.fail"), Atom.NIL), new ListPair(Atom.a("yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) | ||
1004 | { | ||
1005 | foreach (bool l12 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1006 | { | ||
1007 | yield return false; | ||
1008 | } | ||
1009 | } | ||
1010 | cutIf16: | ||
1011 | cutIf15: | ||
1012 | cutIf14: | ||
1013 | { } | ||
1014 | } | ||
1015 | cutIf10: | ||
1016 | cutIf6: | ||
1017 | { } | ||
1018 | } | ||
1019 | } | ||
1020 | } | ||
1021 | } | ||
1022 | } | ||
1023 | } | ||
1024 | goto cutIf2; | ||
1025 | } | ||
1026 | foreach (bool l3 in YP.unify(Head, FirstRule)) | ||
1027 | { | ||
1028 | CompilerState.startFunction(State, Head); | ||
1029 | FindallAnswers findallAnswers17 = new FindallAnswers(new Functor2("f", ArgAssignments, Calls)); | ||
1030 | foreach (bool l4 in member(new Functor2("f", Rule, VariableNameSuggestions), SamePredicateRuleList)) | ||
1031 | { | ||
1032 | foreach (bool l5 in compileBodyWithHeadBindings(Rule, VariableNameSuggestions, State, ArgAssignments, Calls)) | ||
1033 | { | ||
1034 | findallAnswers17.add(); | ||
1035 | } | ||
1036 | } | ||
1037 | foreach (bool l4 in findallAnswers17.result(ClauseBag)) | ||
1038 | { | ||
1039 | foreach (bool l5 in YP.univ(Head, new ListPair(Name, ArgsList))) | ||
1040 | { | ||
1041 | foreach (bool l6 in getFunctionArgNames(ArgsList, 1, FunctionArgNames)) | ||
1042 | { | ||
1043 | FindallAnswers findallAnswers18 = new FindallAnswers(MergedArgName); | ||
1044 | foreach (bool l7 in member(ArgName, FunctionArgNames)) | ||
1045 | { | ||
1046 | foreach (bool l8 in argAssignedAll(ArgName, ClauseBag, MergedArgName)) | ||
1047 | { | ||
1048 | findallAnswers18.add(); | ||
1049 | goto cutIf19; | ||
1050 | } | ||
1051 | foreach (bool l8 in YP.unify(MergedArgName, ArgName)) | ||
1052 | { | ||
1053 | findallAnswers18.add(); | ||
1054 | } | ||
1055 | cutIf19: | ||
1056 | { } | ||
1057 | } | ||
1058 | foreach (bool l7 in findallAnswers18.result(MergedArgNames)) | ||
1059 | { | ||
1060 | foreach (bool l8 in maplist_arg(MergedArgNames, FunctionArgs)) | ||
1061 | { | ||
1062 | foreach (bool l9 in maplist_compileClause(ClauseBag, MergedArgNames, BodyCode)) | ||
1063 | { | ||
1064 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
1065 | { | ||
1066 | foreach (bool l11 in YP.unify(ReturnType, Atom.a("void"))) | ||
1067 | { | ||
1068 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
1069 | { | ||
1070 | foreach (bool l13 in append(BodyCode, new ListPair(Atom.a("returnfalse"), Atom.NIL), BodyWithReturn)) | ||
1071 | { | ||
1072 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1073 | { | ||
1074 | yield return false; | ||
1075 | } | ||
1076 | } | ||
1077 | goto cutIf21; | ||
1078 | } | ||
1079 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
1080 | { | ||
1081 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
1082 | { | ||
1083 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1084 | { | ||
1085 | yield return false; | ||
1086 | } | ||
1087 | } | ||
1088 | goto cutIf22; | ||
1089 | } | ||
1090 | if (CompilerState.codeUsesYield(State)) | ||
1091 | { | ||
1092 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
1093 | { | ||
1094 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1095 | { | ||
1096 | yield return false; | ||
1097 | } | ||
1098 | } | ||
1099 | goto cutIf23; | ||
1100 | } | ||
1101 | foreach (bool l12 in append(BodyCode, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.fail"), Atom.NIL), new ListPair(Atom.a("yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) | ||
1102 | { | ||
1103 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1104 | { | ||
1105 | yield return false; | ||
1106 | } | ||
1107 | } | ||
1108 | cutIf23: | ||
1109 | cutIf22: | ||
1110 | cutIf21: | ||
1111 | { } | ||
1112 | } | ||
1113 | goto cutIf20; | ||
1114 | } | ||
1115 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
1116 | { | ||
1117 | foreach (bool l11 in YP.unify(ReturnType, Atom.a("bool"))) | ||
1118 | { | ||
1119 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
1120 | { | ||
1121 | foreach (bool l13 in append(BodyCode, new ListPair(Atom.a("returnfalse"), Atom.NIL), BodyWithReturn)) | ||
1122 | { | ||
1123 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1124 | { | ||
1125 | yield return false; | ||
1126 | } | ||
1127 | } | ||
1128 | goto cutIf25; | ||
1129 | } | ||
1130 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
1131 | { | ||
1132 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
1133 | { | ||
1134 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1135 | { | ||
1136 | yield return false; | ||
1137 | } | ||
1138 | } | ||
1139 | goto cutIf26; | ||
1140 | } | ||
1141 | if (CompilerState.codeUsesYield(State)) | ||
1142 | { | ||
1143 | foreach (bool l13 in YP.unify(BodyWithReturn, BodyCode)) | ||
1144 | { | ||
1145 | foreach (bool l14 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1146 | { | ||
1147 | yield return false; | ||
1148 | } | ||
1149 | } | ||
1150 | goto cutIf27; | ||
1151 | } | ||
1152 | foreach (bool l12 in append(BodyCode, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.fail"), Atom.NIL), new ListPair(Atom.a("yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) | ||
1153 | { | ||
1154 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1155 | { | ||
1156 | yield return false; | ||
1157 | } | ||
1158 | } | ||
1159 | cutIf27: | ||
1160 | cutIf26: | ||
1161 | cutIf25: | ||
1162 | { } | ||
1163 | } | ||
1164 | goto cutIf24; | ||
1165 | } | ||
1166 | foreach (bool l10 in YP.unify(ReturnType, Atom.a("IEnumerable<bool>"))) | ||
1167 | { | ||
1168 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
1169 | { | ||
1170 | foreach (bool l12 in append(BodyCode, new ListPair(Atom.a("returnfalse"), Atom.NIL), BodyWithReturn)) | ||
1171 | { | ||
1172 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1173 | { | ||
1174 | yield return false; | ||
1175 | } | ||
1176 | } | ||
1177 | goto cutIf28; | ||
1178 | } | ||
1179 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
1180 | { | ||
1181 | foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) | ||
1182 | { | ||
1183 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1184 | { | ||
1185 | yield return false; | ||
1186 | } | ||
1187 | } | ||
1188 | goto cutIf29; | ||
1189 | } | ||
1190 | if (CompilerState.codeUsesYield(State)) | ||
1191 | { | ||
1192 | foreach (bool l12 in YP.unify(BodyWithReturn, BodyCode)) | ||
1193 | { | ||
1194 | foreach (bool l13 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1195 | { | ||
1196 | yield return false; | ||
1197 | } | ||
1198 | } | ||
1199 | goto cutIf30; | ||
1200 | } | ||
1201 | foreach (bool l11 in append(BodyCode, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.fail"), Atom.NIL), new ListPair(Atom.a("yieldfalse"), Atom.NIL)), Atom.NIL), BodyWithReturn)) | ||
1202 | { | ||
1203 | foreach (bool l12 in YP.unify(FunctionCode, new Functor("function", new object[] { ReturnType, Name, FunctionArgs, BodyWithReturn }))) | ||
1204 | { | ||
1205 | yield return false; | ||
1206 | } | ||
1207 | } | ||
1208 | cutIf30: | ||
1209 | cutIf29: | ||
1210 | cutIf28: | ||
1211 | { } | ||
1212 | } | ||
1213 | cutIf24: | ||
1214 | cutIf20: | ||
1215 | { } | ||
1216 | } | ||
1217 | } | ||
1218 | } | ||
1219 | } | ||
1220 | } | ||
1221 | } | ||
1222 | } | ||
1223 | cutIf2: | ||
1224 | cutIf1: | ||
1225 | { } | ||
1226 | } | ||
1227 | } | ||
1228 | } | ||
1229 | |||
1230 | public static IEnumerable<bool> samePredicateRuleList(object arg1, object arg2, object arg3) | ||
1231 | { | ||
1232 | { | ||
1233 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1234 | { | ||
1235 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
1236 | { | ||
1237 | foreach (bool l4 in YP.unify(arg3, Atom.NIL)) | ||
1238 | { | ||
1239 | yield return true; | ||
1240 | yield break; | ||
1241 | } | ||
1242 | } | ||
1243 | } | ||
1244 | } | ||
1245 | { | ||
1246 | Variable First = new Variable(); | ||
1247 | foreach (bool l2 in YP.unify(arg1, new ListPair(First, Atom.NIL))) | ||
1248 | { | ||
1249 | foreach (bool l3 in YP.unify(arg2, new ListPair(First, Atom.NIL))) | ||
1250 | { | ||
1251 | foreach (bool l4 in YP.unify(arg3, Atom.NIL)) | ||
1252 | { | ||
1253 | yield return true; | ||
1254 | yield break; | ||
1255 | } | ||
1256 | } | ||
1257 | } | ||
1258 | } | ||
1259 | { | ||
1260 | object SamePredicateRuleList = arg2; | ||
1261 | object RestRules = arg3; | ||
1262 | Variable First = new Variable(); | ||
1263 | Variable Rest = new Variable(); | ||
1264 | Variable FirstRule = new Variable(); | ||
1265 | Variable x6 = new Variable(); | ||
1266 | Variable SecondRule = new Variable(); | ||
1267 | Variable x8 = new Variable(); | ||
1268 | Variable x9 = new Variable(); | ||
1269 | Variable FirstHead = new Variable(); | ||
1270 | Variable x11 = new Variable(); | ||
1271 | Variable SecondHead = new Variable(); | ||
1272 | Variable x13 = new Variable(); | ||
1273 | Variable Name = new Variable(); | ||
1274 | Variable Arity = new Variable(); | ||
1275 | Variable RestSamePredicates = new Variable(); | ||
1276 | foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) | ||
1277 | { | ||
1278 | foreach (bool l3 in YP.unify(new Functor2("f", FirstRule, x6), First)) | ||
1279 | { | ||
1280 | foreach (bool l4 in YP.unify(new ListPair(new Functor2("f", SecondRule, x8), x9), Rest)) | ||
1281 | { | ||
1282 | foreach (bool l5 in YP.unify(new Functor2(":-", FirstHead, x11), FirstRule)) | ||
1283 | { | ||
1284 | foreach (bool l6 in YP.unify(new Functor2(":-", SecondHead, x13), SecondRule)) | ||
1285 | { | ||
1286 | foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) | ||
1287 | { | ||
1288 | foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) | ||
1289 | { | ||
1290 | foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) | ||
1291 | { | ||
1292 | foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) | ||
1293 | { | ||
1294 | yield return true; | ||
1295 | yield break; | ||
1296 | } | ||
1297 | } | ||
1298 | goto cutIf3; | ||
1299 | } | ||
1300 | foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) | ||
1301 | { | ||
1302 | foreach (bool l9 in YP.unify(RestRules, Rest)) | ||
1303 | { | ||
1304 | yield return true; | ||
1305 | yield break; | ||
1306 | } | ||
1307 | } | ||
1308 | cutIf3: | ||
1309 | { } | ||
1310 | } | ||
1311 | goto cutIf2; | ||
1312 | } | ||
1313 | foreach (bool l6 in YP.unify(SecondHead, SecondRule)) | ||
1314 | { | ||
1315 | foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) | ||
1316 | { | ||
1317 | foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) | ||
1318 | { | ||
1319 | foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) | ||
1320 | { | ||
1321 | foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) | ||
1322 | { | ||
1323 | yield return true; | ||
1324 | yield break; | ||
1325 | } | ||
1326 | } | ||
1327 | goto cutIf4; | ||
1328 | } | ||
1329 | foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) | ||
1330 | { | ||
1331 | foreach (bool l9 in YP.unify(RestRules, Rest)) | ||
1332 | { | ||
1333 | yield return true; | ||
1334 | yield break; | ||
1335 | } | ||
1336 | } | ||
1337 | cutIf4: | ||
1338 | { } | ||
1339 | } | ||
1340 | } | ||
1341 | cutIf2: | ||
1342 | goto cutIf1; | ||
1343 | } | ||
1344 | foreach (bool l5 in YP.unify(FirstHead, FirstRule)) | ||
1345 | { | ||
1346 | foreach (bool l6 in YP.unify(new Functor2(":-", SecondHead, x13), SecondRule)) | ||
1347 | { | ||
1348 | foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) | ||
1349 | { | ||
1350 | foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) | ||
1351 | { | ||
1352 | foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) | ||
1353 | { | ||
1354 | foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) | ||
1355 | { | ||
1356 | yield return true; | ||
1357 | yield break; | ||
1358 | } | ||
1359 | } | ||
1360 | goto cutIf6; | ||
1361 | } | ||
1362 | foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) | ||
1363 | { | ||
1364 | foreach (bool l9 in YP.unify(RestRules, Rest)) | ||
1365 | { | ||
1366 | yield return true; | ||
1367 | yield break; | ||
1368 | } | ||
1369 | } | ||
1370 | cutIf6: | ||
1371 | { } | ||
1372 | } | ||
1373 | goto cutIf5; | ||
1374 | } | ||
1375 | foreach (bool l6 in YP.unify(SecondHead, SecondRule)) | ||
1376 | { | ||
1377 | foreach (bool l7 in YP.functor(FirstHead, Name, Arity)) | ||
1378 | { | ||
1379 | foreach (bool l8 in YP.functor(SecondHead, Name, Arity)) | ||
1380 | { | ||
1381 | foreach (bool l9 in samePredicateRuleList(Rest, RestSamePredicates, RestRules)) | ||
1382 | { | ||
1383 | foreach (bool l10 in YP.unify(SamePredicateRuleList, new ListPair(First, RestSamePredicates))) | ||
1384 | { | ||
1385 | yield return true; | ||
1386 | yield break; | ||
1387 | } | ||
1388 | } | ||
1389 | goto cutIf7; | ||
1390 | } | ||
1391 | foreach (bool l8 in YP.unify(SamePredicateRuleList, new ListPair(First, Atom.NIL))) | ||
1392 | { | ||
1393 | foreach (bool l9 in YP.unify(RestRules, Rest)) | ||
1394 | { | ||
1395 | yield return true; | ||
1396 | yield break; | ||
1397 | } | ||
1398 | } | ||
1399 | cutIf7: | ||
1400 | { } | ||
1401 | } | ||
1402 | } | ||
1403 | cutIf5: | ||
1404 | { } | ||
1405 | } | ||
1406 | cutIf1: | ||
1407 | { } | ||
1408 | } | ||
1409 | } | ||
1410 | } | ||
1411 | } | ||
1412 | } | ||
1413 | |||
1414 | public static IEnumerable<bool> maplist_compileClause(object arg1, object arg2, object arg3) | ||
1415 | { | ||
1416 | { | ||
1417 | object _MergedArgNames = arg2; | ||
1418 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1419 | { | ||
1420 | foreach (bool l3 in YP.unify(arg3, Atom.NIL)) | ||
1421 | { | ||
1422 | yield return true; | ||
1423 | yield break; | ||
1424 | } | ||
1425 | } | ||
1426 | } | ||
1427 | { | ||
1428 | object MergedArgNames = arg2; | ||
1429 | Variable ArgAssignments = new Variable(); | ||
1430 | Variable Calls = new Variable(); | ||
1431 | Variable Rest = new Variable(); | ||
1432 | Variable ClauseCode = new Variable(); | ||
1433 | Variable RestResults = new Variable(); | ||
1434 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", ArgAssignments, Calls), Rest))) | ||
1435 | { | ||
1436 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1("blockScope", ClauseCode), RestResults))) | ||
1437 | { | ||
1438 | foreach (bool l4 in prependArgAssignments(ArgAssignments, Calls, MergedArgNames, ClauseCode)) | ||
1439 | { | ||
1440 | foreach (bool l5 in maplist_compileClause(Rest, MergedArgNames, RestResults)) | ||
1441 | { | ||
1442 | yield return true; | ||
1443 | yield break; | ||
1444 | } | ||
1445 | } | ||
1446 | } | ||
1447 | } | ||
1448 | } | ||
1449 | } | ||
1450 | |||
1451 | public static IEnumerable<bool> prependArgAssignments(object arg1, object arg2, object arg3, object arg4) | ||
1452 | { | ||
1453 | { | ||
1454 | object _MergedArgNames = arg3; | ||
1455 | Variable In = new Variable(); | ||
1456 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1457 | { | ||
1458 | foreach (bool l3 in YP.unify(arg2, In)) | ||
1459 | { | ||
1460 | foreach (bool l4 in YP.unify(arg4, In)) | ||
1461 | { | ||
1462 | yield return true; | ||
1463 | yield break; | ||
1464 | } | ||
1465 | } | ||
1466 | } | ||
1467 | } | ||
1468 | { | ||
1469 | object In = arg2; | ||
1470 | object MergedArgNames = arg3; | ||
1471 | object ClauseCode = arg4; | ||
1472 | Variable VariableName = new Variable(); | ||
1473 | Variable ArgName = new Variable(); | ||
1474 | Variable RestArgAssignments = new Variable(); | ||
1475 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("f", VariableName, ArgName), RestArgAssignments))) | ||
1476 | { | ||
1477 | foreach (bool l3 in member(VariableName, MergedArgNames)) | ||
1478 | { | ||
1479 | foreach (bool l4 in prependArgAssignments(RestArgAssignments, In, MergedArgNames, ClauseCode)) | ||
1480 | { | ||
1481 | yield return true; | ||
1482 | yield break; | ||
1483 | } | ||
1484 | goto cutIf1; | ||
1485 | } | ||
1486 | foreach (bool l3 in prependArgAssignments(RestArgAssignments, new ListPair(new Functor3("declare", Atom.a("object"), VariableName, new Functor1("var", ArgName)), In), MergedArgNames, ClauseCode)) | ||
1487 | { | ||
1488 | yield return true; | ||
1489 | yield break; | ||
1490 | } | ||
1491 | cutIf1: | ||
1492 | { } | ||
1493 | } | ||
1494 | } | ||
1495 | } | ||
1496 | |||
1497 | public static IEnumerable<bool> argAssignedAll(object arg1, object arg2, object VariableName) | ||
1498 | { | ||
1499 | { | ||
1500 | object _ArgName = arg1; | ||
1501 | foreach (bool l2 in YP.unify(arg2, Atom.NIL)) | ||
1502 | { | ||
1503 | if (YP.nonvar(VariableName)) | ||
1504 | { | ||
1505 | yield return true; | ||
1506 | yield break; | ||
1507 | } | ||
1508 | } | ||
1509 | } | ||
1510 | { | ||
1511 | object ArgName = arg1; | ||
1512 | Variable ArgAssignments = new Variable(); | ||
1513 | Variable _Calls = new Variable(); | ||
1514 | Variable RestClauseBag = new Variable(); | ||
1515 | foreach (bool l2 in YP.unify(arg2, new ListPair(new Functor2("f", ArgAssignments, _Calls), RestClauseBag))) | ||
1516 | { | ||
1517 | foreach (bool l3 in member(new Functor2("f", VariableName, ArgName), ArgAssignments)) | ||
1518 | { | ||
1519 | foreach (bool l4 in argAssignedAll(ArgName, RestClauseBag, VariableName)) | ||
1520 | { | ||
1521 | yield return false; | ||
1522 | } | ||
1523 | } | ||
1524 | } | ||
1525 | } | ||
1526 | } | ||
1527 | |||
1528 | public static IEnumerable<bool> maplist_arg(object arg1, object arg2) | ||
1529 | { | ||
1530 | { | ||
1531 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1532 | { | ||
1533 | foreach (bool l3 in YP.unify(arg2, Atom.NIL)) | ||
1534 | { | ||
1535 | yield return true; | ||
1536 | yield break; | ||
1537 | } | ||
1538 | } | ||
1539 | } | ||
1540 | { | ||
1541 | Variable First = new Variable(); | ||
1542 | Variable Rest = new Variable(); | ||
1543 | Variable RestResults = new Variable(); | ||
1544 | foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) | ||
1545 | { | ||
1546 | foreach (bool l3 in YP.unify(arg2, new ListPair(new Functor1("arg", First), RestResults))) | ||
1547 | { | ||
1548 | foreach (bool l4 in maplist_arg(Rest, RestResults)) | ||
1549 | { | ||
1550 | yield return true; | ||
1551 | yield break; | ||
1552 | } | ||
1553 | } | ||
1554 | } | ||
1555 | } | ||
1556 | } | ||
1557 | |||
1558 | public static IEnumerable<bool> getFunctionArgNames(object arg1, object arg2, object arg3) | ||
1559 | { | ||
1560 | { | ||
1561 | object _StartArgNumber = arg2; | ||
1562 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1563 | { | ||
1564 | foreach (bool l3 in YP.unify(arg3, Atom.NIL)) | ||
1565 | { | ||
1566 | yield return true; | ||
1567 | yield break; | ||
1568 | } | ||
1569 | } | ||
1570 | } | ||
1571 | { | ||
1572 | object StartArgNumber = arg2; | ||
1573 | Variable x1 = new Variable(); | ||
1574 | Variable Rest = new Variable(); | ||
1575 | Variable ArgName = new Variable(); | ||
1576 | Variable RestFunctionArgs = new Variable(); | ||
1577 | Variable NumberCodes = new Variable(); | ||
1578 | Variable NumberAtom = new Variable(); | ||
1579 | Variable NextArgNumber = new Variable(); | ||
1580 | foreach (bool l2 in YP.unify(arg1, new ListPair(x1, Rest))) | ||
1581 | { | ||
1582 | foreach (bool l3 in YP.unify(arg3, new ListPair(ArgName, RestFunctionArgs))) | ||
1583 | { | ||
1584 | foreach (bool l4 in YP.number_codes(StartArgNumber, NumberCodes)) | ||
1585 | { | ||
1586 | foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) | ||
1587 | { | ||
1588 | foreach (bool l6 in YP.atom_concat(Atom.a("arg"), NumberAtom, ArgName)) | ||
1589 | { | ||
1590 | foreach (bool l7 in YP.unify(NextArgNumber, YP.add(StartArgNumber, 1))) | ||
1591 | { | ||
1592 | foreach (bool l8 in getFunctionArgNames(Rest, NextArgNumber, RestFunctionArgs)) | ||
1593 | { | ||
1594 | yield return true; | ||
1595 | yield break; | ||
1596 | } | ||
1597 | } | ||
1598 | } | ||
1599 | } | ||
1600 | } | ||
1601 | } | ||
1602 | } | ||
1603 | } | ||
1604 | } | ||
1605 | |||
1606 | public static IEnumerable<bool> compileBodyWithHeadBindings(object Rule, object VariableNameSuggestions, object State, object ArgAssignments, object Calls) | ||
1607 | { | ||
1608 | { | ||
1609 | Variable Head = new Variable(); | ||
1610 | Variable Body = new Variable(); | ||
1611 | Variable x8 = new Variable(); | ||
1612 | Variable HeadArgs = new Variable(); | ||
1613 | Variable CompiledHeadArgs = new Variable(); | ||
1614 | Variable BodyCode = new Variable(); | ||
1615 | Variable VariableNamesList = new Variable(); | ||
1616 | Variable ArgUnifications = new Variable(); | ||
1617 | foreach (bool l2 in YP.unify(new Functor2(":-", Head, Body), Rule)) | ||
1618 | { | ||
1619 | CompilerState.newVariableNames(State, Rule, VariableNameSuggestions); | ||
1620 | foreach (bool l3 in YP.univ(Head, new ListPair(x8, HeadArgs))) | ||
1621 | { | ||
1622 | foreach (bool l4 in maplist_compileTerm(HeadArgs, State, CompiledHeadArgs)) | ||
1623 | { | ||
1624 | foreach (bool l5 in compileRuleBody(Body, State, BodyCode)) | ||
1625 | { | ||
1626 | foreach (bool l6 in CompilerState.variableNamesList(State, VariableNamesList)) | ||
1627 | { | ||
1628 | foreach (bool l7 in compileArgUnifications(HeadArgs, CompiledHeadArgs, 1, HeadArgs, BodyCode, ArgUnifications)) | ||
1629 | { | ||
1630 | foreach (bool l8 in compileDeclarations(VariableNamesList, HeadArgs, Atom.NIL, ArgAssignments, ArgUnifications, Calls)) | ||
1631 | { | ||
1632 | yield return true; | ||
1633 | yield break; | ||
1634 | } | ||
1635 | } | ||
1636 | } | ||
1637 | } | ||
1638 | } | ||
1639 | } | ||
1640 | } | ||
1641 | } | ||
1642 | { | ||
1643 | foreach (bool l2 in compileBodyWithHeadBindings(new Functor2(":-", Rule, Atom.a("true")), VariableNameSuggestions, State, ArgAssignments, Calls)) | ||
1644 | { | ||
1645 | yield return true; | ||
1646 | yield break; | ||
1647 | } | ||
1648 | } | ||
1649 | } | ||
1650 | |||
1651 | public static IEnumerable<bool> compileArgUnifications(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) | ||
1652 | { | ||
1653 | { | ||
1654 | object x1 = arg2; | ||
1655 | object x2 = arg3; | ||
1656 | object x3 = arg4; | ||
1657 | Variable BodyCode = new Variable(); | ||
1658 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1659 | { | ||
1660 | foreach (bool l3 in YP.unify(arg5, BodyCode)) | ||
1661 | { | ||
1662 | foreach (bool l4 in YP.unify(arg6, BodyCode)) | ||
1663 | { | ||
1664 | yield return true; | ||
1665 | yield break; | ||
1666 | } | ||
1667 | } | ||
1668 | } | ||
1669 | } | ||
1670 | { | ||
1671 | object Index = arg3; | ||
1672 | object AllHeadArgs = arg4; | ||
1673 | object BodyCode = arg5; | ||
1674 | object ArgUnifications = arg6; | ||
1675 | Variable HeadArg = new Variable(); | ||
1676 | Variable RestHeadArgs = new Variable(); | ||
1677 | Variable x3 = new Variable(); | ||
1678 | Variable RestCompiledHeadArgs = new Variable(); | ||
1679 | Variable _ArgIndex1 = new Variable(); | ||
1680 | Variable NextIndex = new Variable(); | ||
1681 | foreach (bool l2 in YP.unify(arg1, new ListPair(HeadArg, RestHeadArgs))) | ||
1682 | { | ||
1683 | foreach (bool l3 in YP.unify(arg2, new ListPair(x3, RestCompiledHeadArgs))) | ||
1684 | { | ||
1685 | foreach (bool l4 in getVariableArgIndex1(HeadArg, AllHeadArgs, _ArgIndex1)) | ||
1686 | { | ||
1687 | foreach (bool l5 in YP.unify(NextIndex, YP.add(Index, 1))) | ||
1688 | { | ||
1689 | foreach (bool l6 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, ArgUnifications)) | ||
1690 | { | ||
1691 | yield return true; | ||
1692 | yield break; | ||
1693 | } | ||
1694 | } | ||
1695 | } | ||
1696 | } | ||
1697 | } | ||
1698 | } | ||
1699 | { | ||
1700 | object Index = arg3; | ||
1701 | object AllHeadArgs = arg4; | ||
1702 | object BodyCode = arg5; | ||
1703 | Variable _HeadArg = new Variable(); | ||
1704 | Variable RestHeadArgs = new Variable(); | ||
1705 | Variable CompiledHeadArg = new Variable(); | ||
1706 | Variable RestCompiledHeadArgs = new Variable(); | ||
1707 | Variable ArgName = new Variable(); | ||
1708 | Variable RestArgUnifications = new Variable(); | ||
1709 | Variable NumberCodes = new Variable(); | ||
1710 | Variable NumberAtom = new Variable(); | ||
1711 | Variable NextIndex = new Variable(); | ||
1712 | foreach (bool l2 in YP.unify(arg1, new ListPair(_HeadArg, RestHeadArgs))) | ||
1713 | { | ||
1714 | foreach (bool l3 in YP.unify(arg2, new ListPair(CompiledHeadArg, RestCompiledHeadArgs))) | ||
1715 | { | ||
1716 | foreach (bool l4 in YP.unify(arg6, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.unify"), new ListPair(new Functor1("var", ArgName), new ListPair(CompiledHeadArg, Atom.NIL))), RestArgUnifications), Atom.NIL))) | ||
1717 | { | ||
1718 | foreach (bool l5 in YP.number_codes(Index, NumberCodes)) | ||
1719 | { | ||
1720 | foreach (bool l6 in YP.atom_codes(NumberAtom, NumberCodes)) | ||
1721 | { | ||
1722 | foreach (bool l7 in YP.atom_concat(Atom.a("arg"), NumberAtom, ArgName)) | ||
1723 | { | ||
1724 | foreach (bool l8 in YP.unify(NextIndex, YP.add(Index, 1))) | ||
1725 | { | ||
1726 | foreach (bool l9 in compileArgUnifications(RestHeadArgs, RestCompiledHeadArgs, NextIndex, AllHeadArgs, BodyCode, RestArgUnifications)) | ||
1727 | { | ||
1728 | yield return true; | ||
1729 | yield break; | ||
1730 | } | ||
1731 | } | ||
1732 | } | ||
1733 | } | ||
1734 | } | ||
1735 | } | ||
1736 | } | ||
1737 | } | ||
1738 | } | ||
1739 | } | ||
1740 | |||
1741 | public static IEnumerable<bool> compileDeclarations(object arg1, object arg2, object arg3, object arg4, object arg5, object arg6) | ||
1742 | { | ||
1743 | { | ||
1744 | object _HeadArgs = arg2; | ||
1745 | Variable ArgAssignmentsIn = new Variable(); | ||
1746 | Variable DeclarationsIn = new Variable(); | ||
1747 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
1748 | { | ||
1749 | foreach (bool l3 in YP.unify(arg3, ArgAssignmentsIn)) | ||
1750 | { | ||
1751 | foreach (bool l4 in YP.unify(arg4, ArgAssignmentsIn)) | ||
1752 | { | ||
1753 | foreach (bool l5 in YP.unify(arg5, DeclarationsIn)) | ||
1754 | { | ||
1755 | foreach (bool l6 in YP.unify(arg6, DeclarationsIn)) | ||
1756 | { | ||
1757 | yield return true; | ||
1758 | yield break; | ||
1759 | } | ||
1760 | } | ||
1761 | } | ||
1762 | } | ||
1763 | } | ||
1764 | } | ||
1765 | { | ||
1766 | object HeadArgs = arg2; | ||
1767 | object ArgAssignmentsIn = arg3; | ||
1768 | object ArgAssignmentsOut = arg4; | ||
1769 | object DeclarationsIn = arg5; | ||
1770 | object DeclarationsOut = arg6; | ||
1771 | Variable VariableName = new Variable(); | ||
1772 | Variable Var = new Variable(); | ||
1773 | Variable RestVariableNames = new Variable(); | ||
1774 | Variable ArgIndex1 = new Variable(); | ||
1775 | Variable NumberCodes = new Variable(); | ||
1776 | Variable NumberAtom = new Variable(); | ||
1777 | Variable ArgName = new Variable(); | ||
1778 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("=", VariableName, Var), RestVariableNames))) | ||
1779 | { | ||
1780 | foreach (bool l3 in getVariableArgIndex1(Var, HeadArgs, ArgIndex1)) | ||
1781 | { | ||
1782 | foreach (bool l4 in YP.number_codes(ArgIndex1, NumberCodes)) | ||
1783 | { | ||
1784 | foreach (bool l5 in YP.atom_codes(NumberAtom, NumberCodes)) | ||
1785 | { | ||
1786 | foreach (bool l6 in YP.atom_concat(Atom.a("arg"), NumberAtom, ArgName)) | ||
1787 | { | ||
1788 | foreach (bool l7 in compileDeclarations(RestVariableNames, HeadArgs, new ListPair(new Functor2("f", VariableName, ArgName), ArgAssignmentsIn), ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) | ||
1789 | { | ||
1790 | yield return true; | ||
1791 | yield break; | ||
1792 | } | ||
1793 | } | ||
1794 | } | ||
1795 | } | ||
1796 | } | ||
1797 | } | ||
1798 | } | ||
1799 | { | ||
1800 | object HeadArgs = arg2; | ||
1801 | object ArgAssignmentsIn = arg3; | ||
1802 | object ArgAssignmentsOut = arg4; | ||
1803 | object DeclarationsIn = arg5; | ||
1804 | Variable VariableName = new Variable(); | ||
1805 | Variable _Var = new Variable(); | ||
1806 | Variable RestVariableNames = new Variable(); | ||
1807 | Variable DeclarationsOut = new Variable(); | ||
1808 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("=", VariableName, _Var), RestVariableNames))) | ||
1809 | { | ||
1810 | foreach (bool l3 in YP.unify(arg6, new ListPair(new Functor3("declare", Atom.a("Variable"), VariableName, new Functor2("new", Atom.a("Variable"), Atom.NIL)), DeclarationsOut))) | ||
1811 | { | ||
1812 | foreach (bool l4 in compileDeclarations(RestVariableNames, HeadArgs, ArgAssignmentsIn, ArgAssignmentsOut, DeclarationsIn, DeclarationsOut)) | ||
1813 | { | ||
1814 | yield return true; | ||
1815 | yield break; | ||
1816 | } | ||
1817 | } | ||
1818 | } | ||
1819 | } | ||
1820 | } | ||
1821 | |||
1822 | public static IEnumerable<bool> getVariableArgIndex1(object Var, object arg2, object arg3) | ||
1823 | { | ||
1824 | { | ||
1825 | Variable FirstHeadArgs = new Variable(); | ||
1826 | Variable RestHeadArgs = new Variable(); | ||
1827 | Variable x4 = new Variable(); | ||
1828 | foreach (bool l2 in YP.unify(arg2, new ListPair(FirstHeadArgs, RestHeadArgs))) | ||
1829 | { | ||
1830 | foreach (bool l3 in YP.unify(arg3, 1)) | ||
1831 | { | ||
1832 | if (sameVariable(Var, FirstHeadArgs)) | ||
1833 | { | ||
1834 | foreach (bool l5 in getVariableArgIndex1(Var, RestHeadArgs, x4)) | ||
1835 | { | ||
1836 | goto cutIf1; | ||
1837 | } | ||
1838 | yield return false; | ||
1839 | cutIf1: | ||
1840 | yield break; | ||
1841 | } | ||
1842 | } | ||
1843 | } | ||
1844 | } | ||
1845 | { | ||
1846 | object Index = arg3; | ||
1847 | Variable x2 = new Variable(); | ||
1848 | Variable RestHeadArgs = new Variable(); | ||
1849 | Variable RestIndex = new Variable(); | ||
1850 | foreach (bool l2 in YP.unify(arg2, new ListPair(x2, RestHeadArgs))) | ||
1851 | { | ||
1852 | foreach (bool l3 in getVariableArgIndex1(Var, RestHeadArgs, RestIndex)) | ||
1853 | { | ||
1854 | foreach (bool l4 in YP.unify(Index, YP.add(1, RestIndex))) | ||
1855 | { | ||
1856 | yield return true; | ||
1857 | yield break; | ||
1858 | } | ||
1859 | } | ||
1860 | } | ||
1861 | } | ||
1862 | } | ||
1863 | |||
1864 | public static IEnumerable<bool> compileRuleBody(object arg1, object arg2, object arg3) | ||
1865 | { | ||
1866 | { | ||
1867 | object A = arg1; | ||
1868 | object State = arg2; | ||
1869 | object PseudoCode = arg3; | ||
1870 | if (YP.var(A)) | ||
1871 | { | ||
1872 | foreach (bool l3 in compileRuleBody(new Functor2(",", new Functor1("call", A), Atom.a("true")), State, PseudoCode)) | ||
1873 | { | ||
1874 | yield return true; | ||
1875 | yield break; | ||
1876 | } | ||
1877 | } | ||
1878 | } | ||
1879 | { | ||
1880 | object State = arg2; | ||
1881 | object PseudoCode = arg3; | ||
1882 | Variable A = new Variable(); | ||
1883 | Variable B = new Variable(); | ||
1884 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", A, B))) | ||
1885 | { | ||
1886 | if (YP.var(A)) | ||
1887 | { | ||
1888 | foreach (bool l4 in compileRuleBody(new Functor2(",", new Functor1("call", A), B), State, PseudoCode)) | ||
1889 | { | ||
1890 | yield return true; | ||
1891 | yield break; | ||
1892 | } | ||
1893 | } | ||
1894 | } | ||
1895 | } | ||
1896 | { | ||
1897 | object State = arg2; | ||
1898 | object PseudoCode = arg3; | ||
1899 | Variable A = new Variable(); | ||
1900 | Variable B = new Variable(); | ||
1901 | Variable ACode = new Variable(); | ||
1902 | Variable BCode = new Variable(); | ||
1903 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", A, B))) | ||
1904 | { | ||
1905 | foreach (bool l3 in compileFunctorCall(A, State, ACode)) | ||
1906 | { | ||
1907 | if (CompilerState.isDetNoneOut(State, A)) | ||
1908 | { | ||
1909 | foreach (bool l5 in compileRuleBody(B, State, BCode)) | ||
1910 | { | ||
1911 | foreach (bool l6 in YP.unify(PseudoCode, new ListPair(ACode, BCode))) | ||
1912 | { | ||
1913 | yield return true; | ||
1914 | yield break; | ||
1915 | } | ||
1916 | } | ||
1917 | } | ||
1918 | if (CompilerState.isSemidetNoneOut(State, A)) | ||
1919 | { | ||
1920 | foreach (bool l5 in compileRuleBody(B, State, BCode)) | ||
1921 | { | ||
1922 | foreach (bool l6 in YP.unify(PseudoCode, new ListPair(new Functor2("if", ACode, BCode), Atom.NIL))) | ||
1923 | { | ||
1924 | yield return true; | ||
1925 | yield break; | ||
1926 | } | ||
1927 | } | ||
1928 | } | ||
1929 | foreach (bool l4 in compileRuleBody(B, State, BCode)) | ||
1930 | { | ||
1931 | foreach (bool l5 in YP.unify(PseudoCode, new ListPair(new Functor2("foreach", ACode, BCode), Atom.NIL))) | ||
1932 | { | ||
1933 | yield return true; | ||
1934 | yield break; | ||
1935 | } | ||
1936 | } | ||
1937 | } | ||
1938 | } | ||
1939 | } | ||
1940 | { | ||
1941 | object State = arg2; | ||
1942 | object PseudoCode = arg3; | ||
1943 | Variable A = new Variable(); | ||
1944 | Variable T = new Variable(); | ||
1945 | Variable B = new Variable(); | ||
1946 | Variable C = new Variable(); | ||
1947 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor2(";", new Functor2("->", A, T), B), C))) | ||
1948 | { | ||
1949 | foreach (bool l3 in compileRuleBody(new Functor2(";", new Functor2("->", A, new Functor2(",", T, C)), new Functor2(",", B, C)), State, PseudoCode)) | ||
1950 | { | ||
1951 | yield return true; | ||
1952 | yield break; | ||
1953 | } | ||
1954 | } | ||
1955 | } | ||
1956 | { | ||
1957 | object State = arg2; | ||
1958 | object PseudoCode = arg3; | ||
1959 | Variable A = new Variable(); | ||
1960 | Variable B = new Variable(); | ||
1961 | Variable C = new Variable(); | ||
1962 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor2(";", A, B), C))) | ||
1963 | { | ||
1964 | foreach (bool l3 in compileRuleBody(new Functor2(";", new Functor2(",", A, C), new Functor2(",", B, C)), State, PseudoCode)) | ||
1965 | { | ||
1966 | yield return true; | ||
1967 | yield break; | ||
1968 | } | ||
1969 | } | ||
1970 | } | ||
1971 | { | ||
1972 | object State = arg2; | ||
1973 | Variable A = new Variable(); | ||
1974 | Variable B = new Variable(); | ||
1975 | Variable ACode = new Variable(); | ||
1976 | Variable BCode = new Variable(); | ||
1977 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("\\+", A), B))) | ||
1978 | { | ||
1979 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("if", new Functor1("not", ACode), BCode), Atom.NIL))) | ||
1980 | { | ||
1981 | if (CompilerState.isSemidetNoneOut(State, A)) | ||
1982 | { | ||
1983 | foreach (bool l5 in compileFunctorCall(A, State, ACode)) | ||
1984 | { | ||
1985 | foreach (bool l6 in compileRuleBody(B, State, BCode)) | ||
1986 | { | ||
1987 | yield return true; | ||
1988 | yield break; | ||
1989 | } | ||
1990 | } | ||
1991 | } | ||
1992 | } | ||
1993 | } | ||
1994 | } | ||
1995 | { | ||
1996 | object State = arg2; | ||
1997 | object PseudoCode = arg3; | ||
1998 | Variable A = new Variable(); | ||
1999 | Variable B = new Variable(); | ||
2000 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("\\+", A), B))) | ||
2001 | { | ||
2002 | foreach (bool l3 in compileRuleBody(new Functor2(",", new Functor2(";", new Functor2("->", A, Atom.a("fail")), Atom.a("true")), B), State, PseudoCode)) | ||
2003 | { | ||
2004 | yield return true; | ||
2005 | yield break; | ||
2006 | } | ||
2007 | } | ||
2008 | } | ||
2009 | { | ||
2010 | object State = arg2; | ||
2011 | object PseudoCode = arg3; | ||
2012 | Variable A = new Variable(); | ||
2013 | Variable B = new Variable(); | ||
2014 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("once", A), B))) | ||
2015 | { | ||
2016 | foreach (bool l3 in compileRuleBody(new Functor2(",", new Functor2(";", new Functor2("->", A, Atom.a("true")), Atom.a("fail")), B), State, PseudoCode)) | ||
2017 | { | ||
2018 | yield return true; | ||
2019 | yield break; | ||
2020 | } | ||
2021 | } | ||
2022 | } | ||
2023 | { | ||
2024 | object State = arg2; | ||
2025 | object PseudoCode = arg3; | ||
2026 | Variable A = new Variable(); | ||
2027 | Variable T = new Variable(); | ||
2028 | Variable B = new Variable(); | ||
2029 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor2("->", A, T), B))) | ||
2030 | { | ||
2031 | foreach (bool l3 in compileRuleBody(new Functor2(",", new Functor2(";", new Functor2("->", A, T), Atom.a("fail")), B), State, PseudoCode)) | ||
2032 | { | ||
2033 | yield return true; | ||
2034 | yield break; | ||
2035 | } | ||
2036 | } | ||
2037 | } | ||
2038 | { | ||
2039 | object State = arg2; | ||
2040 | object PseudoCode = arg3; | ||
2041 | Variable A = new Variable(); | ||
2042 | Variable B = new Variable(); | ||
2043 | Variable C = new Variable(); | ||
2044 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor2("\\=", A, B), C))) | ||
2045 | { | ||
2046 | foreach (bool l3 in compileRuleBody(new Functor2(",", new Functor1("\\+", new Functor2("=", A, B)), C), State, PseudoCode)) | ||
2047 | { | ||
2048 | yield return true; | ||
2049 | yield break; | ||
2050 | } | ||
2051 | } | ||
2052 | } | ||
2053 | { | ||
2054 | object State = arg2; | ||
2055 | object PseudoCode = arg3; | ||
2056 | Variable A = new Variable(); | ||
2057 | Variable ACode = new Variable(); | ||
2058 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", Atom.a("!"), A))) | ||
2059 | { | ||
2060 | foreach (bool l3 in compileRuleBody(A, State, ACode)) | ||
2061 | { | ||
2062 | foreach (bool l4 in append(ACode, new ListPair(Atom.a("yieldbreak"), Atom.NIL), PseudoCode)) | ||
2063 | { | ||
2064 | yield return true; | ||
2065 | yield break; | ||
2066 | } | ||
2067 | } | ||
2068 | } | ||
2069 | } | ||
2070 | { | ||
2071 | object State = arg2; | ||
2072 | object PseudoCode = arg3; | ||
2073 | Variable Name = new Variable(); | ||
2074 | Variable A = new Variable(); | ||
2075 | Variable ACode = new Variable(); | ||
2076 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("$CUTIF", Name), A))) | ||
2077 | { | ||
2078 | foreach (bool l3 in compileRuleBody(A, State, ACode)) | ||
2079 | { | ||
2080 | foreach (bool l4 in append(ACode, new ListPair(new Functor1("breakBlock", Name), Atom.NIL), PseudoCode)) | ||
2081 | { | ||
2082 | yield return true; | ||
2083 | yield break; | ||
2084 | } | ||
2085 | } | ||
2086 | } | ||
2087 | } | ||
2088 | { | ||
2089 | object _State = arg2; | ||
2090 | Variable x1 = new Variable(); | ||
2091 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", Atom.a("fail"), x1))) | ||
2092 | { | ||
2093 | foreach (bool l3 in YP.unify(arg3, Atom.NIL)) | ||
2094 | { | ||
2095 | yield return true; | ||
2096 | yield break; | ||
2097 | } | ||
2098 | } | ||
2099 | } | ||
2100 | { | ||
2101 | object State = arg2; | ||
2102 | object PseudoCode = arg3; | ||
2103 | Variable A = new Variable(); | ||
2104 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", Atom.a("true"), A))) | ||
2105 | { | ||
2106 | foreach (bool l3 in compileRuleBody(A, State, PseudoCode)) | ||
2107 | { | ||
2108 | yield return true; | ||
2109 | yield break; | ||
2110 | } | ||
2111 | } | ||
2112 | } | ||
2113 | { | ||
2114 | object State = arg2; | ||
2115 | Variable A = new Variable(); | ||
2116 | Variable Term = new Variable(); | ||
2117 | Variable B = new Variable(); | ||
2118 | Variable ACode = new Variable(); | ||
2119 | Variable TermCode = new Variable(); | ||
2120 | Variable BCode = new Variable(); | ||
2121 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor2("is", A, Term), B))) | ||
2122 | { | ||
2123 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.unify"), new ListPair(ACode, new ListPair(TermCode, Atom.NIL))), BCode), Atom.NIL))) | ||
2124 | { | ||
2125 | foreach (bool l4 in compileTerm(A, State, ACode)) | ||
2126 | { | ||
2127 | foreach (bool l5 in compileExpression(Term, State, TermCode)) | ||
2128 | { | ||
2129 | foreach (bool l6 in compileRuleBody(B, State, BCode)) | ||
2130 | { | ||
2131 | yield return true; | ||
2132 | yield break; | ||
2133 | } | ||
2134 | } | ||
2135 | } | ||
2136 | } | ||
2137 | } | ||
2138 | } | ||
2139 | { | ||
2140 | object State = arg2; | ||
2141 | Variable ACode = new Variable(); | ||
2142 | Variable B = new Variable(); | ||
2143 | Variable BCode = new Variable(); | ||
2144 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("$DET_NONE_OUT", ACode), B))) | ||
2145 | { | ||
2146 | foreach (bool l3 in YP.unify(arg3, new ListPair(ACode, BCode))) | ||
2147 | { | ||
2148 | foreach (bool l4 in compileRuleBody(B, State, BCode)) | ||
2149 | { | ||
2150 | yield return true; | ||
2151 | yield break; | ||
2152 | } | ||
2153 | } | ||
2154 | } | ||
2155 | } | ||
2156 | { | ||
2157 | object State = arg2; | ||
2158 | Variable A = new Variable(); | ||
2159 | Variable B = new Variable(); | ||
2160 | Variable FunctionName = new Variable(); | ||
2161 | Variable X1Code = new Variable(); | ||
2162 | Variable X2Code = new Variable(); | ||
2163 | Variable BCode = new Variable(); | ||
2164 | Variable Name = new Variable(); | ||
2165 | Variable X1 = new Variable(); | ||
2166 | Variable X2 = new Variable(); | ||
2167 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", A, B))) | ||
2168 | { | ||
2169 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("if", new Functor2("call", FunctionName, new ListPair(X1Code, new ListPair(X2Code, Atom.NIL))), BCode), Atom.NIL))) | ||
2170 | { | ||
2171 | foreach (bool l4 in YP.univ(A, ListPair.make(new object[] { Name, X1, X2 }))) | ||
2172 | { | ||
2173 | foreach (bool l5 in binaryExpressionConditional(Name, FunctionName)) | ||
2174 | { | ||
2175 | foreach (bool l6 in compileExpression(X1, State, X1Code)) | ||
2176 | { | ||
2177 | foreach (bool l7 in compileExpression(X2, State, X2Code)) | ||
2178 | { | ||
2179 | foreach (bool l8 in compileRuleBody(B, State, BCode)) | ||
2180 | { | ||
2181 | yield return true; | ||
2182 | yield break; | ||
2183 | } | ||
2184 | } | ||
2185 | } | ||
2186 | } | ||
2187 | } | ||
2188 | } | ||
2189 | } | ||
2190 | } | ||
2191 | { | ||
2192 | object State = arg2; | ||
2193 | object PseudoCode = arg3; | ||
2194 | Variable Template = new Variable(); | ||
2195 | Variable Goal = new Variable(); | ||
2196 | Variable Bag = new Variable(); | ||
2197 | Variable B = new Variable(); | ||
2198 | Variable TemplateCode = new Variable(); | ||
2199 | Variable FindallAnswers = new Variable(); | ||
2200 | Variable GoalAndAddCode = new Variable(); | ||
2201 | Variable BagCode = new Variable(); | ||
2202 | Variable BCode = new Variable(); | ||
2203 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor3("findall", Template, Goal, Bag), B))) | ||
2204 | { | ||
2205 | foreach (bool l3 in compileTerm(Template, State, TemplateCode)) | ||
2206 | { | ||
2207 | foreach (bool l4 in CompilerState.gensym(State, Atom.a("findallAnswers"), FindallAnswers)) | ||
2208 | { | ||
2209 | foreach (bool l5 in compileRuleBody(new Functor2(",", Goal, new Functor2(",", new Functor1("$DET_NONE_OUT", new Functor3("callMember", new Functor1("var", FindallAnswers), Atom.a("add"), Atom.NIL)), Atom.a("fail"))), State, GoalAndAddCode)) | ||
2210 | { | ||
2211 | foreach (bool l6 in compileTerm(Bag, State, BagCode)) | ||
2212 | { | ||
2213 | foreach (bool l7 in compileRuleBody(B, State, BCode)) | ||
2214 | { | ||
2215 | foreach (bool l8 in append(new ListPair(new Functor3("declare", Atom.a("FindallAnswers"), FindallAnswers, new Functor2("new", Atom.a("FindallAnswers"), new ListPair(TemplateCode, Atom.NIL))), GoalAndAddCode), new ListPair(new Functor2("foreach", new Functor3("callMember", new Functor1("var", FindallAnswers), Atom.a("result"), new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) | ||
2216 | { | ||
2217 | yield return true; | ||
2218 | yield break; | ||
2219 | } | ||
2220 | } | ||
2221 | } | ||
2222 | } | ||
2223 | } | ||
2224 | } | ||
2225 | } | ||
2226 | } | ||
2227 | { | ||
2228 | object State = arg2; | ||
2229 | object PseudoCode = arg3; | ||
2230 | Variable Template = new Variable(); | ||
2231 | Variable Goal = new Variable(); | ||
2232 | Variable Bag = new Variable(); | ||
2233 | Variable B = new Variable(); | ||
2234 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor3("bagof", Template, Goal, Bag), B))) | ||
2235 | { | ||
2236 | foreach (bool l3 in compileBagof(Atom.a("result"), Template, Goal, Bag, B, State, PseudoCode)) | ||
2237 | { | ||
2238 | yield return true; | ||
2239 | yield break; | ||
2240 | } | ||
2241 | } | ||
2242 | } | ||
2243 | { | ||
2244 | object State = arg2; | ||
2245 | object PseudoCode = arg3; | ||
2246 | Variable Template = new Variable(); | ||
2247 | Variable Goal = new Variable(); | ||
2248 | Variable Bag = new Variable(); | ||
2249 | Variable B = new Variable(); | ||
2250 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor3("setof", Template, Goal, Bag), B))) | ||
2251 | { | ||
2252 | foreach (bool l3 in compileBagof(Atom.a("resultSet"), Template, Goal, Bag, B, State, PseudoCode)) | ||
2253 | { | ||
2254 | yield return true; | ||
2255 | yield break; | ||
2256 | } | ||
2257 | } | ||
2258 | } | ||
2259 | { | ||
2260 | object State = arg2; | ||
2261 | Variable A = new Variable(); | ||
2262 | Variable B = new Variable(); | ||
2263 | Variable ATermCode = new Variable(); | ||
2264 | Variable BCode = new Variable(); | ||
2265 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("call", A), B))) | ||
2266 | { | ||
2267 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.getIterator"), new ListPair(ATermCode, new ListPair(new Functor2("call", Atom.a("getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode), Atom.NIL))) | ||
2268 | { | ||
2269 | foreach (bool l4 in compileTerm(A, State, ATermCode)) | ||
2270 | { | ||
2271 | foreach (bool l5 in compileRuleBody(B, State, BCode)) | ||
2272 | { | ||
2273 | yield return true; | ||
2274 | yield break; | ||
2275 | } | ||
2276 | } | ||
2277 | } | ||
2278 | } | ||
2279 | } | ||
2280 | { | ||
2281 | object State = arg2; | ||
2282 | Variable A = new Variable(); | ||
2283 | Variable B = new Variable(); | ||
2284 | Variable ATermCode = new Variable(); | ||
2285 | Variable BCode = new Variable(); | ||
2286 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("current_predicate", A), B))) | ||
2287 | { | ||
2288 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("foreach", new Functor2("call", Atom.a("YP.current_predicate"), new ListPair(ATermCode, new ListPair(new Functor2("call", Atom.a("getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode), Atom.NIL))) | ||
2289 | { | ||
2290 | foreach (bool l4 in compileTerm(A, State, ATermCode)) | ||
2291 | { | ||
2292 | foreach (bool l5 in compileRuleBody(B, State, BCode)) | ||
2293 | { | ||
2294 | yield return true; | ||
2295 | yield break; | ||
2296 | } | ||
2297 | } | ||
2298 | } | ||
2299 | } | ||
2300 | } | ||
2301 | { | ||
2302 | object State = arg2; | ||
2303 | Variable A = new Variable(); | ||
2304 | Variable B = new Variable(); | ||
2305 | Variable ATermCode = new Variable(); | ||
2306 | Variable BCode = new Variable(); | ||
2307 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("asserta", A), B))) | ||
2308 | { | ||
2309 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("call", Atom.a("YP.asserta"), new ListPair(ATermCode, new ListPair(new Functor2("call", Atom.a("getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode))) | ||
2310 | { | ||
2311 | foreach (bool l4 in compileTerm(A, State, ATermCode)) | ||
2312 | { | ||
2313 | foreach (bool l5 in compileRuleBody(B, State, BCode)) | ||
2314 | { | ||
2315 | yield return true; | ||
2316 | yield break; | ||
2317 | } | ||
2318 | } | ||
2319 | } | ||
2320 | } | ||
2321 | } | ||
2322 | { | ||
2323 | object State = arg2; | ||
2324 | Variable A = new Variable(); | ||
2325 | Variable B = new Variable(); | ||
2326 | Variable ATermCode = new Variable(); | ||
2327 | Variable BCode = new Variable(); | ||
2328 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("assertz", A), B))) | ||
2329 | { | ||
2330 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("call", Atom.a("YP.assertz"), new ListPair(ATermCode, new ListPair(new Functor2("call", Atom.a("getDeclaringClass"), Atom.NIL), Atom.NIL))), BCode))) | ||
2331 | { | ||
2332 | foreach (bool l4 in compileTerm(A, State, ATermCode)) | ||
2333 | { | ||
2334 | foreach (bool l5 in compileRuleBody(B, State, BCode)) | ||
2335 | { | ||
2336 | yield return true; | ||
2337 | yield break; | ||
2338 | } | ||
2339 | } | ||
2340 | } | ||
2341 | } | ||
2342 | } | ||
2343 | { | ||
2344 | object State = arg2; | ||
2345 | object PseudoCode = arg3; | ||
2346 | Variable A = new Variable(); | ||
2347 | Variable B = new Variable(); | ||
2348 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor1("assert", A), B))) | ||
2349 | { | ||
2350 | foreach (bool l3 in compileRuleBody(new Functor2(",", new Functor1("assertz", A), B), State, PseudoCode)) | ||
2351 | { | ||
2352 | yield return true; | ||
2353 | yield break; | ||
2354 | } | ||
2355 | } | ||
2356 | } | ||
2357 | { | ||
2358 | object State = arg2; | ||
2359 | Variable Goal = new Variable(); | ||
2360 | Variable Catcher = new Variable(); | ||
2361 | Variable Handler = new Variable(); | ||
2362 | Variable B = new Variable(); | ||
2363 | Variable CatchGoal = new Variable(); | ||
2364 | Variable GoalTermCode = new Variable(); | ||
2365 | Variable BCode = new Variable(); | ||
2366 | Variable CatcherTermCode = new Variable(); | ||
2367 | Variable HandlerAndBCode = new Variable(); | ||
2368 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor3("catch", Goal, Catcher, Handler), B))) | ||
2369 | { | ||
2370 | foreach (bool l3 in YP.unify(arg3, ListPair.make(new object[] { new Functor3("declare", Atom.a("YP.Catch"), CatchGoal, new Functor2("new", Atom.a("YP.Catch"), new ListPair(GoalTermCode, new ListPair(new Functor2("call", Atom.a("getDeclaringClass"), Atom.NIL), Atom.NIL)))), new Functor2("foreach", new Functor1("var", CatchGoal), BCode), new Functor2("foreach", new Functor3("callMember", new Functor1("var", CatchGoal), Atom.a("unifyExceptionOrThrow"), new ListPair(CatcherTermCode, Atom.NIL)), HandlerAndBCode) }))) | ||
2371 | { | ||
2372 | foreach (bool l4 in CompilerState.gensym(State, Atom.a("catchGoal"), CatchGoal)) | ||
2373 | { | ||
2374 | foreach (bool l5 in compileTerm(Goal, State, GoalTermCode)) | ||
2375 | { | ||
2376 | foreach (bool l6 in compileTerm(Catcher, State, CatcherTermCode)) | ||
2377 | { | ||
2378 | foreach (bool l7 in compileRuleBody(B, State, BCode)) | ||
2379 | { | ||
2380 | foreach (bool l8 in compileRuleBody(new Functor2(",", Handler, B), State, HandlerAndBCode)) | ||
2381 | { | ||
2382 | yield return true; | ||
2383 | yield break; | ||
2384 | } | ||
2385 | } | ||
2386 | } | ||
2387 | } | ||
2388 | } | ||
2389 | } | ||
2390 | } | ||
2391 | } | ||
2392 | { | ||
2393 | object State = arg2; | ||
2394 | object PseudoCode = arg3; | ||
2395 | Variable A = new Variable(); | ||
2396 | Variable B = new Variable(); | ||
2397 | Variable C = new Variable(); | ||
2398 | foreach (bool l2 in YP.unify(arg1, new Functor2(",", new Functor2(",", A, B), C))) | ||
2399 | { | ||
2400 | foreach (bool l3 in compileRuleBody(new Functor2(",", A, new Functor2(",", B, C)), State, PseudoCode)) | ||
2401 | { | ||
2402 | yield return true; | ||
2403 | yield break; | ||
2404 | } | ||
2405 | } | ||
2406 | } | ||
2407 | { | ||
2408 | object State = arg2; | ||
2409 | object PseudoCode = arg3; | ||
2410 | Variable A = new Variable(); | ||
2411 | Variable B = new Variable(); | ||
2412 | foreach (bool l2 in YP.unify(arg1, new Functor2(";", A, B))) | ||
2413 | { | ||
2414 | if (YP.var(A)) | ||
2415 | { | ||
2416 | foreach (bool l4 in compileRuleBody(new Functor2(";", new Functor1("call", A), B), State, PseudoCode)) | ||
2417 | { | ||
2418 | yield return true; | ||
2419 | yield break; | ||
2420 | } | ||
2421 | } | ||
2422 | } | ||
2423 | } | ||
2424 | { | ||
2425 | object State = arg2; | ||
2426 | Variable A = new Variable(); | ||
2427 | Variable T = new Variable(); | ||
2428 | Variable B = new Variable(); | ||
2429 | Variable CutIfLabel = new Variable(); | ||
2430 | Variable Code = new Variable(); | ||
2431 | foreach (bool l2 in YP.unify(arg1, new Functor2(";", new Functor2("->", A, T), B))) | ||
2432 | { | ||
2433 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor2("breakableBlock", CutIfLabel, Code), Atom.NIL))) | ||
2434 | { | ||
2435 | foreach (bool l4 in CompilerState.gensym(State, Atom.a("cutIf"), CutIfLabel)) | ||
2436 | { | ||
2437 | foreach (bool l5 in compileRuleBody(new Functor2(";", new Functor2(",", A, new Functor2(",", new Functor1("$CUTIF", CutIfLabel), T)), B), State, Code)) | ||
2438 | { | ||
2439 | yield return true; | ||
2440 | yield break; | ||
2441 | } | ||
2442 | } | ||
2443 | } | ||
2444 | } | ||
2445 | } | ||
2446 | { | ||
2447 | object State = arg2; | ||
2448 | object PseudoCode = arg3; | ||
2449 | Variable _B = new Variable(); | ||
2450 | foreach (bool l2 in YP.unify(arg1, new Functor2(";", Atom.a("!"), _B))) | ||
2451 | { | ||
2452 | foreach (bool l3 in compileRuleBody(Atom.a("!"), State, PseudoCode)) | ||
2453 | { | ||
2454 | yield return true; | ||
2455 | yield break; | ||
2456 | } | ||
2457 | } | ||
2458 | } | ||
2459 | { | ||
2460 | object State = arg2; | ||
2461 | object PseudoCode = arg3; | ||
2462 | Variable A = new Variable(); | ||
2463 | Variable B = new Variable(); | ||
2464 | Variable ACode = new Variable(); | ||
2465 | Variable BCode = new Variable(); | ||
2466 | foreach (bool l2 in YP.unify(arg1, new Functor2(";", A, B))) | ||
2467 | { | ||
2468 | foreach (bool l3 in compileRuleBody(A, State, ACode)) | ||
2469 | { | ||
2470 | foreach (bool l4 in compileRuleBody(B, State, BCode)) | ||
2471 | { | ||
2472 | foreach (bool l5 in append(ACode, BCode, PseudoCode)) | ||
2473 | { | ||
2474 | yield return true; | ||
2475 | yield break; | ||
2476 | } | ||
2477 | } | ||
2478 | } | ||
2479 | } | ||
2480 | } | ||
2481 | { | ||
2482 | object State = arg2; | ||
2483 | foreach (bool l2 in YP.unify(arg1, Atom.a("!"))) | ||
2484 | { | ||
2485 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("return"), Atom.NIL))) | ||
2486 | { | ||
2487 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
2488 | { | ||
2489 | yield return true; | ||
2490 | yield break; | ||
2491 | } | ||
2492 | } | ||
2493 | } | ||
2494 | } | ||
2495 | { | ||
2496 | object State = arg2; | ||
2497 | foreach (bool l2 in YP.unify(arg1, Atom.a("!"))) | ||
2498 | { | ||
2499 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("returntrue"), Atom.NIL))) | ||
2500 | { | ||
2501 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
2502 | { | ||
2503 | yield return true; | ||
2504 | yield break; | ||
2505 | } | ||
2506 | } | ||
2507 | } | ||
2508 | } | ||
2509 | { | ||
2510 | object State = arg2; | ||
2511 | foreach (bool l2 in YP.unify(arg1, Atom.a("!"))) | ||
2512 | { | ||
2513 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("yieldtrue"), new ListPair(Atom.a("yieldbreak"), Atom.NIL)))) | ||
2514 | { | ||
2515 | CompilerState.setCodeUsesYield(State); | ||
2516 | yield return true; | ||
2517 | yield break; | ||
2518 | } | ||
2519 | } | ||
2520 | } | ||
2521 | { | ||
2522 | object _State = arg2; | ||
2523 | Variable Name = new Variable(); | ||
2524 | foreach (bool l2 in YP.unify(arg1, new Functor1("$CUTIF", Name))) | ||
2525 | { | ||
2526 | foreach (bool l3 in YP.unify(arg3, new ListPair(new Functor1("breakBlock", Name), Atom.NIL))) | ||
2527 | { | ||
2528 | yield return true; | ||
2529 | yield break; | ||
2530 | } | ||
2531 | } | ||
2532 | } | ||
2533 | { | ||
2534 | object State = arg2; | ||
2535 | foreach (bool l2 in YP.unify(arg1, Atom.a("true"))) | ||
2536 | { | ||
2537 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("return"), Atom.NIL))) | ||
2538 | { | ||
2539 | if (CompilerState.determinismEquals(State, Atom.a("detNoneOut"))) | ||
2540 | { | ||
2541 | yield return true; | ||
2542 | yield break; | ||
2543 | } | ||
2544 | } | ||
2545 | } | ||
2546 | } | ||
2547 | { | ||
2548 | object State = arg2; | ||
2549 | foreach (bool l2 in YP.unify(arg1, Atom.a("true"))) | ||
2550 | { | ||
2551 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("returntrue"), Atom.NIL))) | ||
2552 | { | ||
2553 | if (CompilerState.determinismEquals(State, Atom.a("semidetNoneOut"))) | ||
2554 | { | ||
2555 | yield return true; | ||
2556 | yield break; | ||
2557 | } | ||
2558 | } | ||
2559 | } | ||
2560 | } | ||
2561 | { | ||
2562 | object State = arg2; | ||
2563 | foreach (bool l2 in YP.unify(arg1, Atom.a("true"))) | ||
2564 | { | ||
2565 | foreach (bool l3 in YP.unify(arg3, new ListPair(Atom.a("yieldfalse"), Atom.NIL))) | ||
2566 | { | ||
2567 | CompilerState.setCodeUsesYield(State); | ||
2568 | yield return true; | ||
2569 | yield break; | ||
2570 | } | ||
2571 | } | ||
2572 | } | ||
2573 | { | ||
2574 | object A = arg1; | ||
2575 | object State = arg2; | ||
2576 | object PseudoCode = arg3; | ||
2577 | foreach (bool l2 in compileRuleBody(new Functor2(",", A, Atom.a("true")), State, PseudoCode)) | ||
2578 | { | ||
2579 | yield return true; | ||
2580 | yield break; | ||
2581 | } | ||
2582 | } | ||
2583 | } | ||
2584 | |||
2585 | public static IEnumerable<bool> compileBagof(object ResultMethod, object Template, object Goal, object Bag, object B, object State, object PseudoCode) | ||
2586 | { | ||
2587 | { | ||
2588 | Variable TemplateCode = new Variable(); | ||
2589 | Variable GoalTermCode = new Variable(); | ||
2590 | Variable UnqualifiedGoal = new Variable(); | ||
2591 | Variable BagofAnswers = new Variable(); | ||
2592 | Variable GoalAndAddCode = new Variable(); | ||
2593 | Variable BagCode = new Variable(); | ||
2594 | Variable BCode = new Variable(); | ||
2595 | foreach (bool l2 in compileTerm(Template, State, TemplateCode)) | ||
2596 | { | ||
2597 | foreach (bool l3 in compileTerm(Goal, State, GoalTermCode)) | ||
2598 | { | ||
2599 | foreach (bool l4 in unqualifiedGoal(Goal, UnqualifiedGoal)) | ||
2600 | { | ||
2601 | foreach (bool l5 in CompilerState.gensym(State, Atom.a("bagofAnswers"), BagofAnswers)) | ||
2602 | { | ||
2603 | foreach (bool l6 in compileRuleBody(new Functor2(",", UnqualifiedGoal, new Functor2(",", new Functor1("$DET_NONE_OUT", new Functor3("callMember", new Functor1("var", BagofAnswers), Atom.a("add"), Atom.NIL)), Atom.a("fail"))), State, GoalAndAddCode)) | ||
2604 | { | ||
2605 | foreach (bool l7 in compileTerm(Bag, State, BagCode)) | ||
2606 | { | ||
2607 | foreach (bool l8 in compileRuleBody(B, State, BCode)) | ||
2608 | { | ||
2609 | foreach (bool l9 in append(new ListPair(new Functor3("declare", Atom.a("BagofAnswers"), BagofAnswers, new Functor2("new", Atom.a("BagofAnswers"), new ListPair(TemplateCode, new ListPair(GoalTermCode, Atom.NIL)))), GoalAndAddCode), new ListPair(new Functor2("foreach", new Functor3("callMember", new Functor1("var", BagofAnswers), ResultMethod, new ListPair(BagCode, Atom.NIL)), BCode), Atom.NIL), PseudoCode)) | ||
2610 | { | ||
2611 | yield return true; | ||
2612 | yield break; | ||
2613 | } | ||
2614 | } | ||
2615 | } | ||
2616 | } | ||
2617 | } | ||
2618 | } | ||
2619 | } | ||
2620 | } | ||
2621 | } | ||
2622 | } | ||
2623 | |||
2624 | public static IEnumerable<bool> unqualifiedGoal(object arg1, object arg2) | ||
2625 | { | ||
2626 | { | ||
2627 | object Goal = arg1; | ||
2628 | foreach (bool l2 in YP.unify(arg2, new Functor1("call", Goal))) | ||
2629 | { | ||
2630 | if (YP.var(Goal)) | ||
2631 | { | ||
2632 | yield return true; | ||
2633 | yield break; | ||
2634 | } | ||
2635 | } | ||
2636 | } | ||
2637 | { | ||
2638 | object UnqualifiedGoal = arg2; | ||
2639 | Variable x1 = new Variable(); | ||
2640 | Variable Goal = new Variable(); | ||
2641 | foreach (bool l2 in YP.unify(arg1, new Functor2("^", x1, Goal))) | ||
2642 | { | ||
2643 | foreach (bool l3 in unqualifiedGoal(Goal, UnqualifiedGoal)) | ||
2644 | { | ||
2645 | yield return true; | ||
2646 | yield break; | ||
2647 | } | ||
2648 | } | ||
2649 | } | ||
2650 | { | ||
2651 | Variable UnqualifiedGoal = new Variable(); | ||
2652 | foreach (bool l2 in YP.unify(arg1, UnqualifiedGoal)) | ||
2653 | { | ||
2654 | foreach (bool l3 in YP.unify(arg2, UnqualifiedGoal)) | ||
2655 | { | ||
2656 | yield return true; | ||
2657 | yield break; | ||
2658 | } | ||
2659 | } | ||
2660 | } | ||
2661 | } | ||
2662 | |||
2663 | public static IEnumerable<bool> binaryExpressionConditional(object arg1, object arg2) | ||
2664 | { | ||
2665 | { | ||
2666 | foreach (bool l2 in YP.unify(arg1, Atom.a("=:="))) | ||
2667 | { | ||
2668 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.equal"))) | ||
2669 | { | ||
2670 | yield return true; | ||
2671 | yield break; | ||
2672 | } | ||
2673 | } | ||
2674 | } | ||
2675 | { | ||
2676 | foreach (bool l2 in YP.unify(arg1, Atom.a("=\\="))) | ||
2677 | { | ||
2678 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.notEqual"))) | ||
2679 | { | ||
2680 | yield return true; | ||
2681 | yield break; | ||
2682 | } | ||
2683 | } | ||
2684 | } | ||
2685 | { | ||
2686 | foreach (bool l2 in YP.unify(arg1, Atom.a(">"))) | ||
2687 | { | ||
2688 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.greaterThan"))) | ||
2689 | { | ||
2690 | yield return true; | ||
2691 | yield break; | ||
2692 | } | ||
2693 | } | ||
2694 | } | ||
2695 | { | ||
2696 | foreach (bool l2 in YP.unify(arg1, Atom.a("<"))) | ||
2697 | { | ||
2698 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.lessThan"))) | ||
2699 | { | ||
2700 | yield return true; | ||
2701 | yield break; | ||
2702 | } | ||
2703 | } | ||
2704 | } | ||
2705 | { | ||
2706 | foreach (bool l2 in YP.unify(arg1, Atom.a(">="))) | ||
2707 | { | ||
2708 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.greaterThanOrEqual"))) | ||
2709 | { | ||
2710 | yield return true; | ||
2711 | yield break; | ||
2712 | } | ||
2713 | } | ||
2714 | } | ||
2715 | { | ||
2716 | foreach (bool l2 in YP.unify(arg1, Atom.a("=<"))) | ||
2717 | { | ||
2718 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.lessThanOrEqual"))) | ||
2719 | { | ||
2720 | yield return true; | ||
2721 | yield break; | ||
2722 | } | ||
2723 | } | ||
2724 | } | ||
2725 | } | ||
2726 | |||
2727 | public static IEnumerable<bool> compileFunctorCall(object Functor_1, object State, object PseudoCode) | ||
2728 | { | ||
2729 | { | ||
2730 | Variable FunctorName = new Variable(); | ||
2731 | Variable FunctorArgs = new Variable(); | ||
2732 | Variable x6 = new Variable(); | ||
2733 | Variable Arity = new Variable(); | ||
2734 | Variable FunctionName = new Variable(); | ||
2735 | Variable CompiledArgs = new Variable(); | ||
2736 | foreach (bool l2 in YP.univ(Functor_1, new ListPair(FunctorName, FunctorArgs))) | ||
2737 | { | ||
2738 | foreach (bool l3 in YP.functor(Functor_1, x6, Arity)) | ||
2739 | { | ||
2740 | foreach (bool l4 in functorCallFunctionName(State, FunctorName, Arity, FunctionName)) | ||
2741 | { | ||
2742 | foreach (bool l5 in maplist_compileTerm(FunctorArgs, State, CompiledArgs)) | ||
2743 | { | ||
2744 | if (YP.termEqual(FunctionName, Atom.NIL)) | ||
2745 | { | ||
2746 | foreach (bool l7 in YP.unify(PseudoCode, new Functor2("call", Atom.a("YP.matchDynamic"), new ListPair(new Functor2("call", Atom.a("Atom.a"), new ListPair(new Functor1("object", FunctorName), Atom.NIL)), new ListPair(new Functor1("objectArray", CompiledArgs), Atom.NIL))))) | ||
2747 | { | ||
2748 | yield return true; | ||
2749 | yield break; | ||
2750 | } | ||
2751 | goto cutIf1; | ||
2752 | } | ||
2753 | foreach (bool l6 in YP.unify(PseudoCode, new Functor3("functorCall", FunctionName, FunctorArgs, CompiledArgs))) | ||
2754 | { | ||
2755 | yield return true; | ||
2756 | yield break; | ||
2757 | } | ||
2758 | cutIf1: | ||
2759 | { } | ||
2760 | } | ||
2761 | } | ||
2762 | } | ||
2763 | } | ||
2764 | } | ||
2765 | } | ||
2766 | |||
2767 | public static IEnumerable<bool> functorCallFunctionName(object arg1, object arg2, object arg3, object arg4) | ||
2768 | { | ||
2769 | { | ||
2770 | object _State = arg1; | ||
2771 | object Name = arg2; | ||
2772 | object Arity = arg3; | ||
2773 | object x4 = arg4; | ||
2774 | if (functorCallIsSpecialForm(Name, Arity)) | ||
2775 | { | ||
2776 | yield break; | ||
2777 | } | ||
2778 | } | ||
2779 | { | ||
2780 | object x1 = arg1; | ||
2781 | object Name = arg2; | ||
2782 | object Arity = arg3; | ||
2783 | object FunctionName = arg4; | ||
2784 | foreach (bool l2 in functorCallYPFunctionName(Name, Arity, FunctionName)) | ||
2785 | { | ||
2786 | yield return true; | ||
2787 | yield break; | ||
2788 | } | ||
2789 | } | ||
2790 | { | ||
2791 | object State = arg1; | ||
2792 | object Arity = arg3; | ||
2793 | Variable Name = new Variable(); | ||
2794 | foreach (bool l2 in YP.unify(arg2, Name)) | ||
2795 | { | ||
2796 | foreach (bool l3 in YP.unify(arg4, Name)) | ||
2797 | { | ||
2798 | if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(""))) | ||
2799 | { | ||
2800 | yield return true; | ||
2801 | yield break; | ||
2802 | } | ||
2803 | } | ||
2804 | } | ||
2805 | } | ||
2806 | { | ||
2807 | object _State = arg1; | ||
2808 | object _Arity = arg3; | ||
2809 | Variable Name = new Variable(); | ||
2810 | foreach (bool l2 in YP.unify(arg2, Name)) | ||
2811 | { | ||
2812 | foreach (bool l3 in YP.unify(arg4, Name)) | ||
2813 | { | ||
2814 | foreach (bool l4 in Atom.module(Name, Atom.a(""))) | ||
2815 | { | ||
2816 | yield return true; | ||
2817 | yield break; | ||
2818 | } | ||
2819 | } | ||
2820 | } | ||
2821 | } | ||
2822 | { | ||
2823 | object _State = arg1; | ||
2824 | object Name = arg2; | ||
2825 | object _Arity = arg3; | ||
2826 | foreach (bool l2 in YP.unify(arg4, Atom.NIL)) | ||
2827 | { | ||
2828 | foreach (bool l3 in Atom.module(Name, Atom.NIL)) | ||
2829 | { | ||
2830 | yield return true; | ||
2831 | yield break; | ||
2832 | } | ||
2833 | } | ||
2834 | } | ||
2835 | { | ||
2836 | object _State = arg1; | ||
2837 | object Name = arg2; | ||
2838 | object Arity = arg3; | ||
2839 | object x4 = arg4; | ||
2840 | Variable Module = new Variable(); | ||
2841 | Variable Message = new Variable(); | ||
2842 | foreach (bool l2 in Atom.module(Name, Module)) | ||
2843 | { | ||
2844 | foreach (bool l3 in YP.atom_concat(Atom.a("Not supporting calls to external module: "), Module, Message)) | ||
2845 | { | ||
2846 | YP.throwException(new Functor2("error", new Functor2("type_error", Atom.a("callable"), new Functor2("/", Name, Arity)), Message)); | ||
2847 | yield return true; | ||
2848 | yield break; | ||
2849 | } | ||
2850 | } | ||
2851 | } | ||
2852 | { | ||
2853 | object _State = arg1; | ||
2854 | object Name = arg2; | ||
2855 | object _Arity = arg3; | ||
2856 | object x4 = arg4; | ||
2857 | YP.throwException(new Functor2("error", new Functor2("type_error", Atom.a("callable"), Name), Atom.a("Term is not callable"))); | ||
2858 | yield return true; | ||
2859 | yield break; | ||
2860 | } | ||
2861 | } | ||
2862 | |||
2863 | public static bool functorCallIsSpecialForm(object Name, object Arity) | ||
2864 | { | ||
2865 | { | ||
2866 | Variable x3 = new Variable(); | ||
2867 | if (YP.termEqual(Arity, 0)) | ||
2868 | { | ||
2869 | if (YP.termEqual(Name, Atom.a("!"))) | ||
2870 | { | ||
2871 | return true; | ||
2872 | } | ||
2873 | if (YP.termEqual(Name, Atom.a("fail"))) | ||
2874 | { | ||
2875 | return true; | ||
2876 | } | ||
2877 | if (YP.termEqual(Name, Atom.a("true"))) | ||
2878 | { | ||
2879 | return true; | ||
2880 | } | ||
2881 | } | ||
2882 | if (YP.termEqual(Arity, 1)) | ||
2883 | { | ||
2884 | if (YP.termEqual(Name, Atom.a("\\+"))) | ||
2885 | { | ||
2886 | return true; | ||
2887 | } | ||
2888 | if (YP.termEqual(Name, Atom.a("once"))) | ||
2889 | { | ||
2890 | return true; | ||
2891 | } | ||
2892 | if (YP.termEqual(Name, Atom.a("$CUTIF"))) | ||
2893 | { | ||
2894 | return true; | ||
2895 | } | ||
2896 | if (YP.termEqual(Name, Atom.a("$DET_NONE_OUT"))) | ||
2897 | { | ||
2898 | return true; | ||
2899 | } | ||
2900 | if (YP.termEqual(Name, Atom.a("call"))) | ||
2901 | { | ||
2902 | return true; | ||
2903 | } | ||
2904 | if (YP.termEqual(Name, Atom.a("current_predicate"))) | ||
2905 | { | ||
2906 | return true; | ||
2907 | } | ||
2908 | if (YP.termEqual(Name, Atom.a("asserta"))) | ||
2909 | { | ||
2910 | return true; | ||
2911 | } | ||
2912 | if (YP.termEqual(Name, Atom.a("assertz"))) | ||
2913 | { | ||
2914 | return true; | ||
2915 | } | ||
2916 | if (YP.termEqual(Name, Atom.a("assert"))) | ||
2917 | { | ||
2918 | return true; | ||
2919 | } | ||
2920 | } | ||
2921 | if (YP.termEqual(Arity, 2)) | ||
2922 | { | ||
2923 | if (YP.termEqual(Name, Atom.a(";"))) | ||
2924 | { | ||
2925 | return true; | ||
2926 | } | ||
2927 | if (YP.termEqual(Name, Atom.a(","))) | ||
2928 | { | ||
2929 | return true; | ||
2930 | } | ||
2931 | if (YP.termEqual(Name, Atom.a("->"))) | ||
2932 | { | ||
2933 | return true; | ||
2934 | } | ||
2935 | if (YP.termEqual(Name, Atom.a("\\="))) | ||
2936 | { | ||
2937 | return true; | ||
2938 | } | ||
2939 | if (YP.termEqual(Name, Atom.a("is"))) | ||
2940 | { | ||
2941 | return true; | ||
2942 | } | ||
2943 | foreach (bool l3 in binaryExpressionConditional(Name, x3)) | ||
2944 | { | ||
2945 | return true; | ||
2946 | } | ||
2947 | } | ||
2948 | if (YP.termEqual(Arity, 3)) | ||
2949 | { | ||
2950 | if (YP.termEqual(Name, Atom.a("findall"))) | ||
2951 | { | ||
2952 | return true; | ||
2953 | } | ||
2954 | if (YP.termEqual(Name, Atom.a("bagof"))) | ||
2955 | { | ||
2956 | return true; | ||
2957 | } | ||
2958 | if (YP.termEqual(Name, Atom.a("setof"))) | ||
2959 | { | ||
2960 | return true; | ||
2961 | } | ||
2962 | if (YP.termEqual(Name, Atom.a("catch"))) | ||
2963 | { | ||
2964 | return true; | ||
2965 | } | ||
2966 | } | ||
2967 | } | ||
2968 | return false; | ||
2969 | } | ||
2970 | |||
2971 | public static IEnumerable<bool> functorCallYPFunctionName(object arg1, object arg2, object arg3) | ||
2972 | { | ||
2973 | { | ||
2974 | foreach (bool l2 in YP.unify(arg1, Atom.a("="))) | ||
2975 | { | ||
2976 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
2977 | { | ||
2978 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.unify"))) | ||
2979 | { | ||
2980 | yield return true; | ||
2981 | yield break; | ||
2982 | } | ||
2983 | } | ||
2984 | } | ||
2985 | } | ||
2986 | { | ||
2987 | foreach (bool l2 in YP.unify(arg1, Atom.a("=.."))) | ||
2988 | { | ||
2989 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
2990 | { | ||
2991 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.univ"))) | ||
2992 | { | ||
2993 | yield return true; | ||
2994 | yield break; | ||
2995 | } | ||
2996 | } | ||
2997 | } | ||
2998 | } | ||
2999 | { | ||
3000 | foreach (bool l2 in YP.unify(arg1, Atom.a("var"))) | ||
3001 | { | ||
3002 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3003 | { | ||
3004 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.var"))) | ||
3005 | { | ||
3006 | yield return true; | ||
3007 | yield break; | ||
3008 | } | ||
3009 | } | ||
3010 | } | ||
3011 | } | ||
3012 | { | ||
3013 | foreach (bool l2 in YP.unify(arg1, Atom.a("nonvar"))) | ||
3014 | { | ||
3015 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3016 | { | ||
3017 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.nonvar"))) | ||
3018 | { | ||
3019 | yield return true; | ||
3020 | yield break; | ||
3021 | } | ||
3022 | } | ||
3023 | } | ||
3024 | } | ||
3025 | { | ||
3026 | foreach (bool l2 in YP.unify(arg1, Atom.a("arg"))) | ||
3027 | { | ||
3028 | foreach (bool l3 in YP.unify(arg2, 3)) | ||
3029 | { | ||
3030 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.arg"))) | ||
3031 | { | ||
3032 | yield return true; | ||
3033 | yield break; | ||
3034 | } | ||
3035 | } | ||
3036 | } | ||
3037 | } | ||
3038 | { | ||
3039 | foreach (bool l2 in YP.unify(arg1, Atom.a("functor"))) | ||
3040 | { | ||
3041 | foreach (bool l3 in YP.unify(arg2, 3)) | ||
3042 | { | ||
3043 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.functor"))) | ||
3044 | { | ||
3045 | yield return true; | ||
3046 | yield break; | ||
3047 | } | ||
3048 | } | ||
3049 | } | ||
3050 | } | ||
3051 | { | ||
3052 | foreach (bool l2 in YP.unify(arg1, Atom.a("repeat"))) | ||
3053 | { | ||
3054 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
3055 | { | ||
3056 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.repeat"))) | ||
3057 | { | ||
3058 | yield return true; | ||
3059 | yield break; | ||
3060 | } | ||
3061 | } | ||
3062 | } | ||
3063 | } | ||
3064 | { | ||
3065 | foreach (bool l2 in YP.unify(arg1, Atom.a("get_code"))) | ||
3066 | { | ||
3067 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3068 | { | ||
3069 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.get_code"))) | ||
3070 | { | ||
3071 | yield return true; | ||
3072 | yield break; | ||
3073 | } | ||
3074 | } | ||
3075 | } | ||
3076 | } | ||
3077 | { | ||
3078 | foreach (bool l2 in YP.unify(arg1, Atom.a("current_op"))) | ||
3079 | { | ||
3080 | foreach (bool l3 in YP.unify(arg2, 3)) | ||
3081 | { | ||
3082 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.current_op"))) | ||
3083 | { | ||
3084 | yield return true; | ||
3085 | yield break; | ||
3086 | } | ||
3087 | } | ||
3088 | } | ||
3089 | } | ||
3090 | { | ||
3091 | foreach (bool l2 in YP.unify(arg1, Atom.a("atom_length"))) | ||
3092 | { | ||
3093 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3094 | { | ||
3095 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.atom_length"))) | ||
3096 | { | ||
3097 | yield return true; | ||
3098 | yield break; | ||
3099 | } | ||
3100 | } | ||
3101 | } | ||
3102 | } | ||
3103 | { | ||
3104 | foreach (bool l2 in YP.unify(arg1, Atom.a("atom_concat"))) | ||
3105 | { | ||
3106 | foreach (bool l3 in YP.unify(arg2, 3)) | ||
3107 | { | ||
3108 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.atom_concat"))) | ||
3109 | { | ||
3110 | yield return true; | ||
3111 | yield break; | ||
3112 | } | ||
3113 | } | ||
3114 | } | ||
3115 | } | ||
3116 | { | ||
3117 | foreach (bool l2 in YP.unify(arg1, Atom.a("sub_atom"))) | ||
3118 | { | ||
3119 | foreach (bool l3 in YP.unify(arg2, 5)) | ||
3120 | { | ||
3121 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.sub_atom"))) | ||
3122 | { | ||
3123 | yield return true; | ||
3124 | yield break; | ||
3125 | } | ||
3126 | } | ||
3127 | } | ||
3128 | } | ||
3129 | { | ||
3130 | foreach (bool l2 in YP.unify(arg1, Atom.a("atom_chars"))) | ||
3131 | { | ||
3132 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3133 | { | ||
3134 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.atom_chars"))) | ||
3135 | { | ||
3136 | yield return true; | ||
3137 | yield break; | ||
3138 | } | ||
3139 | } | ||
3140 | } | ||
3141 | } | ||
3142 | { | ||
3143 | foreach (bool l2 in YP.unify(arg1, Atom.a("atom_codes"))) | ||
3144 | { | ||
3145 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3146 | { | ||
3147 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.atom_codes"))) | ||
3148 | { | ||
3149 | yield return true; | ||
3150 | yield break; | ||
3151 | } | ||
3152 | } | ||
3153 | } | ||
3154 | } | ||
3155 | { | ||
3156 | foreach (bool l2 in YP.unify(arg1, Atom.a("char_code"))) | ||
3157 | { | ||
3158 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3159 | { | ||
3160 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.char_code"))) | ||
3161 | { | ||
3162 | yield return true; | ||
3163 | yield break; | ||
3164 | } | ||
3165 | } | ||
3166 | } | ||
3167 | } | ||
3168 | { | ||
3169 | foreach (bool l2 in YP.unify(arg1, Atom.a("number_chars"))) | ||
3170 | { | ||
3171 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3172 | { | ||
3173 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.number_chars"))) | ||
3174 | { | ||
3175 | yield return true; | ||
3176 | yield break; | ||
3177 | } | ||
3178 | } | ||
3179 | } | ||
3180 | } | ||
3181 | { | ||
3182 | foreach (bool l2 in YP.unify(arg1, Atom.a("number_codes"))) | ||
3183 | { | ||
3184 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3185 | { | ||
3186 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.number_codes"))) | ||
3187 | { | ||
3188 | yield return true; | ||
3189 | yield break; | ||
3190 | } | ||
3191 | } | ||
3192 | } | ||
3193 | } | ||
3194 | { | ||
3195 | foreach (bool l2 in YP.unify(arg1, Atom.a("copy_term"))) | ||
3196 | { | ||
3197 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3198 | { | ||
3199 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.copy_term"))) | ||
3200 | { | ||
3201 | yield return true; | ||
3202 | yield break; | ||
3203 | } | ||
3204 | } | ||
3205 | } | ||
3206 | } | ||
3207 | { | ||
3208 | foreach (bool l2 in YP.unify(arg1, Atom.a("sort"))) | ||
3209 | { | ||
3210 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3211 | { | ||
3212 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.sort"))) | ||
3213 | { | ||
3214 | yield return true; | ||
3215 | yield break; | ||
3216 | } | ||
3217 | } | ||
3218 | } | ||
3219 | } | ||
3220 | { | ||
3221 | // Manually included : script_event for callback to LSL/C# | ||
3222 | |||
3223 | //object x1 = arg1; | ||
3224 | foreach (bool l2 in YP.unify(arg1, Atom.a(@"script_event"))) | ||
3225 | { | ||
3226 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3227 | { | ||
3228 | foreach (bool l4 in YP.unify(arg3, Atom.a(@"YP.script_event"))) | ||
3229 | { | ||
3230 | yield return true; | ||
3231 | yield break; | ||
3232 | } | ||
3233 | } | ||
3234 | } | ||
3235 | } | ||
3236 | { | ||
3237 | foreach (bool l2 in YP.unify(arg1, Atom.a("nl"))) | ||
3238 | { | ||
3239 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
3240 | { | ||
3241 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.nl"))) | ||
3242 | { | ||
3243 | yield return true; | ||
3244 | yield break; | ||
3245 | } | ||
3246 | } | ||
3247 | } | ||
3248 | } | ||
3249 | { | ||
3250 | foreach (bool l2 in YP.unify(arg1, Atom.a("write"))) | ||
3251 | { | ||
3252 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3253 | { | ||
3254 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.write"))) | ||
3255 | { | ||
3256 | yield return true; | ||
3257 | yield break; | ||
3258 | } | ||
3259 | } | ||
3260 | } | ||
3261 | } | ||
3262 | { | ||
3263 | foreach (bool l2 in YP.unify(arg1, Atom.a("put_code"))) | ||
3264 | { | ||
3265 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3266 | { | ||
3267 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.put_code"))) | ||
3268 | { | ||
3269 | yield return true; | ||
3270 | yield break; | ||
3271 | } | ||
3272 | } | ||
3273 | } | ||
3274 | } | ||
3275 | { | ||
3276 | foreach (bool l2 in YP.unify(arg1, Atom.a("see"))) | ||
3277 | { | ||
3278 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3279 | { | ||
3280 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.see"))) | ||
3281 | { | ||
3282 | yield return true; | ||
3283 | yield break; | ||
3284 | } | ||
3285 | } | ||
3286 | } | ||
3287 | } | ||
3288 | { | ||
3289 | foreach (bool l2 in YP.unify(arg1, Atom.a("seen"))) | ||
3290 | { | ||
3291 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
3292 | { | ||
3293 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.seen"))) | ||
3294 | { | ||
3295 | yield return true; | ||
3296 | yield break; | ||
3297 | } | ||
3298 | } | ||
3299 | } | ||
3300 | } | ||
3301 | { | ||
3302 | foreach (bool l2 in YP.unify(arg1, Atom.a("tell"))) | ||
3303 | { | ||
3304 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3305 | { | ||
3306 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.tell"))) | ||
3307 | { | ||
3308 | yield return true; | ||
3309 | yield break; | ||
3310 | } | ||
3311 | } | ||
3312 | } | ||
3313 | } | ||
3314 | { | ||
3315 | foreach (bool l2 in YP.unify(arg1, Atom.a("told"))) | ||
3316 | { | ||
3317 | foreach (bool l3 in YP.unify(arg2, 0)) | ||
3318 | { | ||
3319 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.told"))) | ||
3320 | { | ||
3321 | yield return true; | ||
3322 | yield break; | ||
3323 | } | ||
3324 | } | ||
3325 | } | ||
3326 | } | ||
3327 | { | ||
3328 | foreach (bool l2 in YP.unify(arg1, Atom.a("clause"))) | ||
3329 | { | ||
3330 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3331 | { | ||
3332 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.clause"))) | ||
3333 | { | ||
3334 | yield return true; | ||
3335 | yield break; | ||
3336 | } | ||
3337 | } | ||
3338 | } | ||
3339 | } | ||
3340 | { | ||
3341 | foreach (bool l2 in YP.unify(arg1, Atom.a("retract"))) | ||
3342 | { | ||
3343 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3344 | { | ||
3345 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.retract"))) | ||
3346 | { | ||
3347 | yield return true; | ||
3348 | yield break; | ||
3349 | } | ||
3350 | } | ||
3351 | } | ||
3352 | } | ||
3353 | { | ||
3354 | foreach (bool l2 in YP.unify(arg1, Atom.a("abolish"))) | ||
3355 | { | ||
3356 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3357 | { | ||
3358 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.abolish"))) | ||
3359 | { | ||
3360 | yield return true; | ||
3361 | yield break; | ||
3362 | } | ||
3363 | } | ||
3364 | } | ||
3365 | } | ||
3366 | { | ||
3367 | foreach (bool l2 in YP.unify(arg1, Atom.a("retractall"))) | ||
3368 | { | ||
3369 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3370 | { | ||
3371 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.retractall"))) | ||
3372 | { | ||
3373 | yield return true; | ||
3374 | yield break; | ||
3375 | } | ||
3376 | } | ||
3377 | } | ||
3378 | } | ||
3379 | { | ||
3380 | foreach (bool l2 in YP.unify(arg1, Atom.a("atom"))) | ||
3381 | { | ||
3382 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3383 | { | ||
3384 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.atom"))) | ||
3385 | { | ||
3386 | yield return true; | ||
3387 | yield break; | ||
3388 | } | ||
3389 | } | ||
3390 | } | ||
3391 | } | ||
3392 | { | ||
3393 | foreach (bool l2 in YP.unify(arg1, Atom.a("integer"))) | ||
3394 | { | ||
3395 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3396 | { | ||
3397 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.integer"))) | ||
3398 | { | ||
3399 | yield return true; | ||
3400 | yield break; | ||
3401 | } | ||
3402 | } | ||
3403 | } | ||
3404 | } | ||
3405 | { | ||
3406 | foreach (bool l2 in YP.unify(arg1, Atom.a("float"))) | ||
3407 | { | ||
3408 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3409 | { | ||
3410 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.isFloat"))) | ||
3411 | { | ||
3412 | yield return true; | ||
3413 | yield break; | ||
3414 | } | ||
3415 | } | ||
3416 | } | ||
3417 | } | ||
3418 | { | ||
3419 | foreach (bool l2 in YP.unify(arg1, Atom.a("number"))) | ||
3420 | { | ||
3421 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3422 | { | ||
3423 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.number"))) | ||
3424 | { | ||
3425 | yield return true; | ||
3426 | yield break; | ||
3427 | } | ||
3428 | } | ||
3429 | } | ||
3430 | } | ||
3431 | { | ||
3432 | foreach (bool l2 in YP.unify(arg1, Atom.a("atomic"))) | ||
3433 | { | ||
3434 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3435 | { | ||
3436 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.atomic"))) | ||
3437 | { | ||
3438 | yield return true; | ||
3439 | yield break; | ||
3440 | } | ||
3441 | } | ||
3442 | } | ||
3443 | } | ||
3444 | { | ||
3445 | foreach (bool l2 in YP.unify(arg1, Atom.a("compound"))) | ||
3446 | { | ||
3447 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3448 | { | ||
3449 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.compound"))) | ||
3450 | { | ||
3451 | yield return true; | ||
3452 | yield break; | ||
3453 | } | ||
3454 | } | ||
3455 | } | ||
3456 | } | ||
3457 | { | ||
3458 | foreach (bool l2 in YP.unify(arg1, Atom.a("=="))) | ||
3459 | { | ||
3460 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3461 | { | ||
3462 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.termEqual"))) | ||
3463 | { | ||
3464 | yield return true; | ||
3465 | yield break; | ||
3466 | } | ||
3467 | } | ||
3468 | } | ||
3469 | } | ||
3470 | { | ||
3471 | foreach (bool l2 in YP.unify(arg1, Atom.a("\\=="))) | ||
3472 | { | ||
3473 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3474 | { | ||
3475 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.termNotEqual"))) | ||
3476 | { | ||
3477 | yield return true; | ||
3478 | yield break; | ||
3479 | } | ||
3480 | } | ||
3481 | } | ||
3482 | } | ||
3483 | { | ||
3484 | foreach (bool l2 in YP.unify(arg1, Atom.a("@<"))) | ||
3485 | { | ||
3486 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3487 | { | ||
3488 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.termLessThan"))) | ||
3489 | { | ||
3490 | yield return true; | ||
3491 | yield break; | ||
3492 | } | ||
3493 | } | ||
3494 | } | ||
3495 | } | ||
3496 | { | ||
3497 | foreach (bool l2 in YP.unify(arg1, Atom.a("@=<"))) | ||
3498 | { | ||
3499 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3500 | { | ||
3501 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.termLessThanOrEqual"))) | ||
3502 | { | ||
3503 | yield return true; | ||
3504 | yield break; | ||
3505 | } | ||
3506 | } | ||
3507 | } | ||
3508 | } | ||
3509 | { | ||
3510 | foreach (bool l2 in YP.unify(arg1, Atom.a("@>"))) | ||
3511 | { | ||
3512 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3513 | { | ||
3514 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.termGreaterThan"))) | ||
3515 | { | ||
3516 | yield return true; | ||
3517 | yield break; | ||
3518 | } | ||
3519 | } | ||
3520 | } | ||
3521 | } | ||
3522 | { | ||
3523 | foreach (bool l2 in YP.unify(arg1, Atom.a("@>="))) | ||
3524 | { | ||
3525 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3526 | { | ||
3527 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.termGreaterThanOrEqual"))) | ||
3528 | { | ||
3529 | yield return true; | ||
3530 | yield break; | ||
3531 | } | ||
3532 | } | ||
3533 | } | ||
3534 | } | ||
3535 | { | ||
3536 | foreach (bool l2 in YP.unify(arg1, Atom.a("throw"))) | ||
3537 | { | ||
3538 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3539 | { | ||
3540 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.throwException"))) | ||
3541 | { | ||
3542 | yield return true; | ||
3543 | yield break; | ||
3544 | } | ||
3545 | } | ||
3546 | } | ||
3547 | } | ||
3548 | { | ||
3549 | foreach (bool l2 in YP.unify(arg1, Atom.a("current_prolog_flag"))) | ||
3550 | { | ||
3551 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3552 | { | ||
3553 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.current_prolog_flag"))) | ||
3554 | { | ||
3555 | yield return true; | ||
3556 | yield break; | ||
3557 | } | ||
3558 | } | ||
3559 | } | ||
3560 | } | ||
3561 | { | ||
3562 | foreach (bool l2 in YP.unify(arg1, Atom.a("set_prolog_flag"))) | ||
3563 | { | ||
3564 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3565 | { | ||
3566 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.set_prolog_flag"))) | ||
3567 | { | ||
3568 | yield return true; | ||
3569 | yield break; | ||
3570 | } | ||
3571 | } | ||
3572 | } | ||
3573 | } | ||
3574 | { | ||
3575 | foreach (bool l2 in YP.unify(arg1, Atom.a("current_input"))) | ||
3576 | { | ||
3577 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3578 | { | ||
3579 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.current_input"))) | ||
3580 | { | ||
3581 | yield return true; | ||
3582 | yield break; | ||
3583 | } | ||
3584 | } | ||
3585 | } | ||
3586 | } | ||
3587 | { | ||
3588 | foreach (bool l2 in YP.unify(arg1, Atom.a("current_output"))) | ||
3589 | { | ||
3590 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3591 | { | ||
3592 | foreach (bool l4 in YP.unify(arg3, Atom.a("YP.current_output"))) | ||
3593 | { | ||
3594 | yield return true; | ||
3595 | yield break; | ||
3596 | } | ||
3597 | } | ||
3598 | } | ||
3599 | } | ||
3600 | { | ||
3601 | foreach (bool l2 in YP.unify(arg1, Atom.a("read_term"))) | ||
3602 | { | ||
3603 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3604 | { | ||
3605 | foreach (bool l4 in YP.unify(arg3, Atom.a("Parser.read_term2"))) | ||
3606 | { | ||
3607 | yield return true; | ||
3608 | yield break; | ||
3609 | } | ||
3610 | } | ||
3611 | } | ||
3612 | } | ||
3613 | { | ||
3614 | foreach (bool l2 in YP.unify(arg1, Atom.a("read_term"))) | ||
3615 | { | ||
3616 | foreach (bool l3 in YP.unify(arg2, 3)) | ||
3617 | { | ||
3618 | foreach (bool l4 in YP.unify(arg3, Atom.a("Parser.read_term3"))) | ||
3619 | { | ||
3620 | yield return true; | ||
3621 | yield break; | ||
3622 | } | ||
3623 | } | ||
3624 | } | ||
3625 | } | ||
3626 | { | ||
3627 | foreach (bool l2 in YP.unify(arg1, Atom.a("read"))) | ||
3628 | { | ||
3629 | foreach (bool l3 in YP.unify(arg2, 1)) | ||
3630 | { | ||
3631 | foreach (bool l4 in YP.unify(arg3, Atom.a("Parser.read1"))) | ||
3632 | { | ||
3633 | yield return true; | ||
3634 | yield break; | ||
3635 | } | ||
3636 | } | ||
3637 | } | ||
3638 | } | ||
3639 | { | ||
3640 | foreach (bool l2 in YP.unify(arg1, Atom.a("read"))) | ||
3641 | { | ||
3642 | foreach (bool l3 in YP.unify(arg2, 2)) | ||
3643 | { | ||
3644 | foreach (bool l4 in YP.unify(arg3, Atom.a("Parser.read2"))) | ||
3645 | { | ||
3646 | yield return true; | ||
3647 | yield break; | ||
3648 | } | ||
3649 | } | ||
3650 | } | ||
3651 | } | ||
3652 | } | ||
3653 | |||
3654 | public static IEnumerable<bool> compileTerm(object arg1, object arg2, object arg3) | ||
3655 | { | ||
3656 | { | ||
3657 | object Term = arg1; | ||
3658 | object State = arg2; | ||
3659 | Variable VariableName = new Variable(); | ||
3660 | foreach (bool l2 in YP.unify(arg3, new Functor1("var", VariableName))) | ||
3661 | { | ||
3662 | if (YP.var(Term)) | ||
3663 | { | ||
3664 | foreach (bool l4 in CompilerState.getVariableName(State, Term, VariableName)) | ||
3665 | { | ||
3666 | yield return true; | ||
3667 | yield break; | ||
3668 | } | ||
3669 | } | ||
3670 | } | ||
3671 | } | ||
3672 | { | ||
3673 | object _State = arg2; | ||
3674 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
3675 | { | ||
3676 | foreach (bool l3 in YP.unify(arg3, new Functor1("var", Atom.a("Atom.NIL")))) | ||
3677 | { | ||
3678 | yield return true; | ||
3679 | yield break; | ||
3680 | } | ||
3681 | } | ||
3682 | } | ||
3683 | { | ||
3684 | object Term = arg1; | ||
3685 | object State = arg2; | ||
3686 | object Code = arg3; | ||
3687 | Variable ModuleCode = new Variable(); | ||
3688 | if (YP.atom(Term)) | ||
3689 | { | ||
3690 | foreach (bool l3 in compileAtomModule(Term, 0, State, ModuleCode)) | ||
3691 | { | ||
3692 | foreach (bool l4 in YP.unify(Code, new Functor2("call", Atom.a("Atom.a"), new ListPair(new Functor1("object", Term), new ListPair(ModuleCode, Atom.NIL))))) | ||
3693 | { | ||
3694 | yield return true; | ||
3695 | yield break; | ||
3696 | } | ||
3697 | goto cutIf1; | ||
3698 | } | ||
3699 | foreach (bool l3 in YP.unify(Code, new Functor2("call", Atom.a("Atom.a"), new ListPair(new Functor1("object", Term), Atom.NIL)))) | ||
3700 | { | ||
3701 | yield return true; | ||
3702 | yield break; | ||
3703 | } | ||
3704 | cutIf1: | ||
3705 | { } | ||
3706 | } | ||
3707 | } | ||
3708 | { | ||
3709 | object State = arg2; | ||
3710 | Variable First = new Variable(); | ||
3711 | Variable Rest = new Variable(); | ||
3712 | Variable CompiledList = new Variable(); | ||
3713 | Variable x5 = new Variable(); | ||
3714 | Variable Rest2 = new Variable(); | ||
3715 | foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) | ||
3716 | { | ||
3717 | foreach (bool l3 in YP.unify(arg3, new Functor2("call", Atom.a("ListPair.make"), new ListPair(new Functor1("objectArray", CompiledList), Atom.NIL)))) | ||
3718 | { | ||
3719 | if (YP.nonvar(Rest)) | ||
3720 | { | ||
3721 | foreach (bool l5 in YP.unify(Rest, new ListPair(x5, Rest2))) | ||
3722 | { | ||
3723 | if (YP.termNotEqual(Rest2, Atom.NIL)) | ||
3724 | { | ||
3725 | foreach (bool l7 in maplist_compileTerm(new ListPair(First, Rest), State, CompiledList)) | ||
3726 | { | ||
3727 | yield return true; | ||
3728 | yield break; | ||
3729 | } | ||
3730 | } | ||
3731 | } | ||
3732 | } | ||
3733 | } | ||
3734 | } | ||
3735 | } | ||
3736 | { | ||
3737 | object State = arg2; | ||
3738 | Variable First = new Variable(); | ||
3739 | Variable Rest = new Variable(); | ||
3740 | Variable Arg1 = new Variable(); | ||
3741 | Variable Arg2 = new Variable(); | ||
3742 | foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) | ||
3743 | { | ||
3744 | foreach (bool l3 in YP.unify(arg3, new Functor2("new", Atom.a("ListPair"), new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) | ||
3745 | { | ||
3746 | foreach (bool l4 in compileTerm(First, State, Arg1)) | ||
3747 | { | ||
3748 | foreach (bool l5 in compileTerm(Rest, State, Arg2)) | ||
3749 | { | ||
3750 | yield return true; | ||
3751 | yield break; | ||
3752 | } | ||
3753 | } | ||
3754 | } | ||
3755 | } | ||
3756 | } | ||
3757 | { | ||
3758 | object Term = arg1; | ||
3759 | object State = arg2; | ||
3760 | object Result = arg3; | ||
3761 | Variable Name = new Variable(); | ||
3762 | Variable TermArgs = new Variable(); | ||
3763 | Variable x6 = new Variable(); | ||
3764 | Variable Arity = new Variable(); | ||
3765 | Variable ModuleCode = new Variable(); | ||
3766 | Variable NameCode = new Variable(); | ||
3767 | Variable X1 = new Variable(); | ||
3768 | Variable Arg1 = new Variable(); | ||
3769 | Variable X2 = new Variable(); | ||
3770 | Variable Arg2 = new Variable(); | ||
3771 | Variable X3 = new Variable(); | ||
3772 | Variable Arg3 = new Variable(); | ||
3773 | Variable Args = new Variable(); | ||
3774 | foreach (bool l2 in YP.univ(Term, new ListPair(Name, TermArgs))) | ||
3775 | { | ||
3776 | if (YP.termEqual(TermArgs, Atom.NIL)) | ||
3777 | { | ||
3778 | foreach (bool l4 in YP.unify(Result, new Functor1("object", Name))) | ||
3779 | { | ||
3780 | yield return true; | ||
3781 | yield break; | ||
3782 | } | ||
3783 | goto cutIf2; | ||
3784 | } | ||
3785 | foreach (bool l3 in YP.functor(Term, x6, Arity)) | ||
3786 | { | ||
3787 | foreach (bool l4 in compileAtomModule(Name, Arity, State, ModuleCode)) | ||
3788 | { | ||
3789 | foreach (bool l5 in YP.unify(NameCode, new Functor2("call", Atom.a("Atom.a"), new ListPair(new Functor1("object", Name), new ListPair(ModuleCode, Atom.NIL))))) | ||
3790 | { | ||
3791 | foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) | ||
3792 | { | ||
3793 | foreach (bool l7 in compileTerm(X1, State, Arg1)) | ||
3794 | { | ||
3795 | foreach (bool l8 in YP.unify(Result, new Functor2("new", Atom.a("Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) | ||
3796 | { | ||
3797 | yield return true; | ||
3798 | yield break; | ||
3799 | } | ||
3800 | } | ||
3801 | goto cutIf4; | ||
3802 | } | ||
3803 | foreach (bool l6 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) | ||
3804 | { | ||
3805 | foreach (bool l7 in compileTerm(X1, State, Arg1)) | ||
3806 | { | ||
3807 | foreach (bool l8 in compileTerm(X2, State, Arg2)) | ||
3808 | { | ||
3809 | foreach (bool l9 in YP.unify(Result, new Functor2("new", Atom.a("Functor2"), ListPair.make(new object[] { NameCode, Arg1, Arg2 })))) | ||
3810 | { | ||
3811 | yield return true; | ||
3812 | yield break; | ||
3813 | } | ||
3814 | } | ||
3815 | } | ||
3816 | goto cutIf5; | ||
3817 | } | ||
3818 | foreach (bool l6 in YP.unify(TermArgs, ListPair.make(new object[] { X1, X2, X3 }))) | ||
3819 | { | ||
3820 | foreach (bool l7 in compileTerm(X1, State, Arg1)) | ||
3821 | { | ||
3822 | foreach (bool l8 in compileTerm(X2, State, Arg2)) | ||
3823 | { | ||
3824 | foreach (bool l9 in compileTerm(X3, State, Arg3)) | ||
3825 | { | ||
3826 | foreach (bool l10 in YP.unify(Result, new Functor2("new", Atom.a("Functor3"), ListPair.make(new object[] { NameCode, Arg1, Arg2, Arg3 })))) | ||
3827 | { | ||
3828 | yield return true; | ||
3829 | yield break; | ||
3830 | } | ||
3831 | } | ||
3832 | } | ||
3833 | } | ||
3834 | } | ||
3835 | foreach (bool l6 in maplist_compileTerm(TermArgs, State, Args)) | ||
3836 | { | ||
3837 | foreach (bool l7 in YP.unify(Result, new Functor2("new", Atom.a("Functor"), new ListPair(NameCode, new ListPair(new Functor1("objectArray", Args), Atom.NIL))))) | ||
3838 | { | ||
3839 | yield return true; | ||
3840 | yield break; | ||
3841 | } | ||
3842 | } | ||
3843 | cutIf5: | ||
3844 | cutIf4: | ||
3845 | { } | ||
3846 | } | ||
3847 | goto cutIf3; | ||
3848 | } | ||
3849 | foreach (bool l4 in YP.unify(NameCode, new Functor1("object", Name))) | ||
3850 | { | ||
3851 | foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) | ||
3852 | { | ||
3853 | foreach (bool l6 in compileTerm(X1, State, Arg1)) | ||
3854 | { | ||
3855 | foreach (bool l7 in YP.unify(Result, new Functor2("new", Atom.a("Functor1"), new ListPair(NameCode, new ListPair(Arg1, Atom.NIL))))) | ||
3856 | { | ||
3857 | yield return true; | ||
3858 | yield break; | ||
3859 | } | ||
3860 | } | ||
3861 | goto cutIf6; | ||
3862 | } | ||
3863 | foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) | ||
3864 | { | ||
3865 | foreach (bool l6 in compileTerm(X1, State, Arg1)) | ||
3866 | { | ||
3867 | foreach (bool l7 in compileTerm(X2, State, Arg2)) | ||
3868 | { | ||
3869 | foreach (bool l8 in YP.unify(Result, new Functor2("new", Atom.a("Functor2"), ListPair.make(new object[] { NameCode, Arg1, Arg2 })))) | ||
3870 | { | ||
3871 | yield return true; | ||
3872 | yield break; | ||
3873 | } | ||
3874 | } | ||
3875 | } | ||
3876 | goto cutIf7; | ||
3877 | } | ||
3878 | foreach (bool l5 in YP.unify(TermArgs, ListPair.make(new object[] { X1, X2, X3 }))) | ||
3879 | { | ||
3880 | foreach (bool l6 in compileTerm(X1, State, Arg1)) | ||
3881 | { | ||
3882 | foreach (bool l7 in compileTerm(X2, State, Arg2)) | ||
3883 | { | ||
3884 | foreach (bool l8 in compileTerm(X3, State, Arg3)) | ||
3885 | { | ||
3886 | foreach (bool l9 in YP.unify(Result, new Functor2("new", Atom.a("Functor3"), ListPair.make(new object[] { NameCode, Arg1, Arg2, Arg3 })))) | ||
3887 | { | ||
3888 | yield return true; | ||
3889 | yield break; | ||
3890 | } | ||
3891 | } | ||
3892 | } | ||
3893 | } | ||
3894 | } | ||
3895 | foreach (bool l5 in maplist_compileTerm(TermArgs, State, Args)) | ||
3896 | { | ||
3897 | foreach (bool l6 in YP.unify(Result, new Functor2("new", Atom.a("Functor"), new ListPair(NameCode, new ListPair(new Functor1("objectArray", Args), Atom.NIL))))) | ||
3898 | { | ||
3899 | yield return true; | ||
3900 | yield break; | ||
3901 | } | ||
3902 | } | ||
3903 | cutIf7: | ||
3904 | cutIf6: | ||
3905 | { } | ||
3906 | } | ||
3907 | cutIf3: | ||
3908 | { } | ||
3909 | } | ||
3910 | cutIf2: | ||
3911 | { } | ||
3912 | } | ||
3913 | } | ||
3914 | } | ||
3915 | |||
3916 | public static IEnumerable<bool> compileAtomModule(object Name, object arg2, object arg3, object ModuleCode) | ||
3917 | { | ||
3918 | { | ||
3919 | object Arity = arg2; | ||
3920 | object State = arg3; | ||
3921 | if (CompilerState.nameArityHasModule(State, Name, Arity, Atom.a(""))) | ||
3922 | { | ||
3923 | foreach (bool l3 in YP.unify(ModuleCode, new Functor2("call", Atom.a("Atom.a"), new ListPair(new Functor1("object", Atom.a("")), Atom.NIL)))) | ||
3924 | { | ||
3925 | yield return true; | ||
3926 | yield break; | ||
3927 | } | ||
3928 | } | ||
3929 | } | ||
3930 | { | ||
3931 | object _Arity = arg2; | ||
3932 | object _State = arg3; | ||
3933 | Variable Module = new Variable(); | ||
3934 | foreach (bool l2 in Atom.module(Name, Module)) | ||
3935 | { | ||
3936 | if (YP.termNotEqual(Module, Atom.NIL)) | ||
3937 | { | ||
3938 | foreach (bool l4 in YP.unify(ModuleCode, new Functor2("call", Atom.a("Atom.a"), new ListPair(new Functor1("object", Module), Atom.NIL)))) | ||
3939 | { | ||
3940 | yield return true; | ||
3941 | yield break; | ||
3942 | } | ||
3943 | } | ||
3944 | } | ||
3945 | } | ||
3946 | } | ||
3947 | |||
3948 | public static IEnumerable<bool> maplist_compileTerm(object arg1, object arg2, object arg3) | ||
3949 | { | ||
3950 | { | ||
3951 | object _State = arg2; | ||
3952 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
3953 | { | ||
3954 | foreach (bool l3 in YP.unify(arg3, Atom.NIL)) | ||
3955 | { | ||
3956 | yield return true; | ||
3957 | yield break; | ||
3958 | } | ||
3959 | } | ||
3960 | } | ||
3961 | { | ||
3962 | object State = arg2; | ||
3963 | Variable First = new Variable(); | ||
3964 | Variable Rest = new Variable(); | ||
3965 | Variable FirstResult = new Variable(); | ||
3966 | Variable RestResults = new Variable(); | ||
3967 | foreach (bool l2 in YP.unify(arg1, new ListPair(First, Rest))) | ||
3968 | { | ||
3969 | foreach (bool l3 in YP.unify(arg3, new ListPair(FirstResult, RestResults))) | ||
3970 | { | ||
3971 | if (YP.nonvar(Rest)) | ||
3972 | { | ||
3973 | foreach (bool l5 in compileTerm(First, State, FirstResult)) | ||
3974 | { | ||
3975 | foreach (bool l6 in maplist_compileTerm(Rest, State, RestResults)) | ||
3976 | { | ||
3977 | yield return true; | ||
3978 | yield break; | ||
3979 | } | ||
3980 | } | ||
3981 | } | ||
3982 | } | ||
3983 | } | ||
3984 | } | ||
3985 | } | ||
3986 | |||
3987 | public static IEnumerable<bool> compileExpression(object Term, object State, object Result) | ||
3988 | { | ||
3989 | { | ||
3990 | Variable Name = new Variable(); | ||
3991 | Variable TermArgs = new Variable(); | ||
3992 | Variable X1 = new Variable(); | ||
3993 | Variable FunctionName = new Variable(); | ||
3994 | Variable Arg1 = new Variable(); | ||
3995 | Variable x9 = new Variable(); | ||
3996 | Variable X2 = new Variable(); | ||
3997 | Variable Arg2 = new Variable(); | ||
3998 | Variable x12 = new Variable(); | ||
3999 | Variable Arity = new Variable(); | ||
4000 | if (YP.nonvar(Term)) | ||
4001 | { | ||
4002 | foreach (bool l3 in YP.univ(Term, new ListPair(Name, TermArgs))) | ||
4003 | { | ||
4004 | if (YP.atom(Name)) | ||
4005 | { | ||
4006 | foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, Atom.NIL))) | ||
4007 | { | ||
4008 | foreach (bool l6 in unaryFunction(Name, FunctionName)) | ||
4009 | { | ||
4010 | foreach (bool l7 in compileExpression(X1, State, Arg1)) | ||
4011 | { | ||
4012 | foreach (bool l8 in YP.unify(Result, new Functor2("call", FunctionName, new ListPair(Arg1, Atom.NIL)))) | ||
4013 | { | ||
4014 | yield return true; | ||
4015 | yield break; | ||
4016 | } | ||
4017 | } | ||
4018 | goto cutIf1; | ||
4019 | } | ||
4020 | } | ||
4021 | foreach (bool l5 in YP.unify(Term, new ListPair(x9, Atom.NIL))) | ||
4022 | { | ||
4023 | foreach (bool l6 in compileTerm(Term, State, Result)) | ||
4024 | { | ||
4025 | yield return true; | ||
4026 | yield break; | ||
4027 | } | ||
4028 | goto cutIf2; | ||
4029 | } | ||
4030 | foreach (bool l5 in YP.unify(TermArgs, new ListPair(X1, new ListPair(X2, Atom.NIL)))) | ||
4031 | { | ||
4032 | foreach (bool l6 in binaryFunction(Name, FunctionName)) | ||
4033 | { | ||
4034 | foreach (bool l7 in compileExpression(X1, State, Arg1)) | ||
4035 | { | ||
4036 | foreach (bool l8 in compileExpression(X2, State, Arg2)) | ||
4037 | { | ||
4038 | foreach (bool l9 in YP.unify(Result, new Functor2("call", FunctionName, new ListPair(Arg1, new ListPair(Arg2, Atom.NIL))))) | ||
4039 | { | ||
4040 | yield return true; | ||
4041 | yield break; | ||
4042 | } | ||
4043 | } | ||
4044 | } | ||
4045 | goto cutIf3; | ||
4046 | } | ||
4047 | } | ||
4048 | foreach (bool l5 in YP.functor(Term, x12, Arity)) | ||
4049 | { | ||
4050 | YP.throwException(new Functor2("error", new Functor2("type_error", Atom.a("evaluable"), new Functor2("/", Name, Arity)), Atom.a("Not an expression function"))); | ||
4051 | yield return false; | ||
4052 | } | ||
4053 | cutIf3: | ||
4054 | cutIf2: | ||
4055 | cutIf1: | ||
4056 | { } | ||
4057 | } | ||
4058 | } | ||
4059 | } | ||
4060 | } | ||
4061 | { | ||
4062 | foreach (bool l2 in compileTerm(Term, State, Result)) | ||
4063 | { | ||
4064 | yield return true; | ||
4065 | yield break; | ||
4066 | } | ||
4067 | } | ||
4068 | } | ||
4069 | |||
4070 | public static IEnumerable<bool> unaryFunction(object arg1, object arg2) | ||
4071 | { | ||
4072 | { | ||
4073 | foreach (bool l2 in YP.unify(arg1, Atom.a("-"))) | ||
4074 | { | ||
4075 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.negate"))) | ||
4076 | { | ||
4077 | yield return true; | ||
4078 | yield break; | ||
4079 | } | ||
4080 | } | ||
4081 | } | ||
4082 | { | ||
4083 | foreach (bool l2 in YP.unify(arg1, Atom.a("abs"))) | ||
4084 | { | ||
4085 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.abs"))) | ||
4086 | { | ||
4087 | yield return true; | ||
4088 | yield break; | ||
4089 | } | ||
4090 | } | ||
4091 | } | ||
4092 | { | ||
4093 | foreach (bool l2 in YP.unify(arg1, Atom.a("sign"))) | ||
4094 | { | ||
4095 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.sign"))) | ||
4096 | { | ||
4097 | yield return true; | ||
4098 | yield break; | ||
4099 | } | ||
4100 | } | ||
4101 | } | ||
4102 | { | ||
4103 | foreach (bool l2 in YP.unify(arg1, Atom.a("float"))) | ||
4104 | { | ||
4105 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.toFloat"))) | ||
4106 | { | ||
4107 | yield return true; | ||
4108 | yield break; | ||
4109 | } | ||
4110 | } | ||
4111 | } | ||
4112 | { | ||
4113 | foreach (bool l2 in YP.unify(arg1, Atom.a("floor"))) | ||
4114 | { | ||
4115 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.floor"))) | ||
4116 | { | ||
4117 | yield return true; | ||
4118 | yield break; | ||
4119 | } | ||
4120 | } | ||
4121 | } | ||
4122 | { | ||
4123 | foreach (bool l2 in YP.unify(arg1, Atom.a("truncate"))) | ||
4124 | { | ||
4125 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.truncate"))) | ||
4126 | { | ||
4127 | yield return true; | ||
4128 | yield break; | ||
4129 | } | ||
4130 | } | ||
4131 | } | ||
4132 | { | ||
4133 | foreach (bool l2 in YP.unify(arg1, Atom.a("round"))) | ||
4134 | { | ||
4135 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.round"))) | ||
4136 | { | ||
4137 | yield return true; | ||
4138 | yield break; | ||
4139 | } | ||
4140 | } | ||
4141 | } | ||
4142 | { | ||
4143 | foreach (bool l2 in YP.unify(arg1, Atom.a("ceiling"))) | ||
4144 | { | ||
4145 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.ceiling"))) | ||
4146 | { | ||
4147 | yield return true; | ||
4148 | yield break; | ||
4149 | } | ||
4150 | } | ||
4151 | } | ||
4152 | { | ||
4153 | foreach (bool l2 in YP.unify(arg1, Atom.a("sin"))) | ||
4154 | { | ||
4155 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.sin"))) | ||
4156 | { | ||
4157 | yield return true; | ||
4158 | yield break; | ||
4159 | } | ||
4160 | } | ||
4161 | } | ||
4162 | { | ||
4163 | foreach (bool l2 in YP.unify(arg1, Atom.a("cos"))) | ||
4164 | { | ||
4165 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.cos"))) | ||
4166 | { | ||
4167 | yield return true; | ||
4168 | yield break; | ||
4169 | } | ||
4170 | } | ||
4171 | } | ||
4172 | { | ||
4173 | foreach (bool l2 in YP.unify(arg1, Atom.a("atan"))) | ||
4174 | { | ||
4175 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.atan"))) | ||
4176 | { | ||
4177 | yield return true; | ||
4178 | yield break; | ||
4179 | } | ||
4180 | } | ||
4181 | } | ||
4182 | { | ||
4183 | foreach (bool l2 in YP.unify(arg1, Atom.a("exp"))) | ||
4184 | { | ||
4185 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.exp"))) | ||
4186 | { | ||
4187 | yield return true; | ||
4188 | yield break; | ||
4189 | } | ||
4190 | } | ||
4191 | } | ||
4192 | { | ||
4193 | foreach (bool l2 in YP.unify(arg1, Atom.a("log"))) | ||
4194 | { | ||
4195 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.log"))) | ||
4196 | { | ||
4197 | yield return true; | ||
4198 | yield break; | ||
4199 | } | ||
4200 | } | ||
4201 | } | ||
4202 | { | ||
4203 | foreach (bool l2 in YP.unify(arg1, Atom.a("sqrt"))) | ||
4204 | { | ||
4205 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.sqrt"))) | ||
4206 | { | ||
4207 | yield return true; | ||
4208 | yield break; | ||
4209 | } | ||
4210 | } | ||
4211 | } | ||
4212 | { | ||
4213 | foreach (bool l2 in YP.unify(arg1, Atom.a("\\"))) | ||
4214 | { | ||
4215 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.bitwiseComplement"))) | ||
4216 | { | ||
4217 | yield return true; | ||
4218 | yield break; | ||
4219 | } | ||
4220 | } | ||
4221 | } | ||
4222 | } | ||
4223 | |||
4224 | public static IEnumerable<bool> binaryFunction(object arg1, object arg2) | ||
4225 | { | ||
4226 | { | ||
4227 | foreach (bool l2 in YP.unify(arg1, Atom.a("+"))) | ||
4228 | { | ||
4229 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.add"))) | ||
4230 | { | ||
4231 | yield return true; | ||
4232 | yield break; | ||
4233 | } | ||
4234 | } | ||
4235 | } | ||
4236 | { | ||
4237 | foreach (bool l2 in YP.unify(arg1, Atom.a("-"))) | ||
4238 | { | ||
4239 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.subtract"))) | ||
4240 | { | ||
4241 | yield return true; | ||
4242 | yield break; | ||
4243 | } | ||
4244 | } | ||
4245 | } | ||
4246 | { | ||
4247 | foreach (bool l2 in YP.unify(arg1, Atom.a("*"))) | ||
4248 | { | ||
4249 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.multiply"))) | ||
4250 | { | ||
4251 | yield return true; | ||
4252 | yield break; | ||
4253 | } | ||
4254 | } | ||
4255 | } | ||
4256 | { | ||
4257 | foreach (bool l2 in YP.unify(arg1, Atom.a("/"))) | ||
4258 | { | ||
4259 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.divide"))) | ||
4260 | { | ||
4261 | yield return true; | ||
4262 | yield break; | ||
4263 | } | ||
4264 | } | ||
4265 | } | ||
4266 | { | ||
4267 | foreach (bool l2 in YP.unify(arg1, Atom.a("//"))) | ||
4268 | { | ||
4269 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.intDivide"))) | ||
4270 | { | ||
4271 | yield return true; | ||
4272 | yield break; | ||
4273 | } | ||
4274 | } | ||
4275 | } | ||
4276 | { | ||
4277 | foreach (bool l2 in YP.unify(arg1, Atom.a("mod"))) | ||
4278 | { | ||
4279 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.mod"))) | ||
4280 | { | ||
4281 | yield return true; | ||
4282 | yield break; | ||
4283 | } | ||
4284 | } | ||
4285 | } | ||
4286 | { | ||
4287 | foreach (bool l2 in YP.unify(arg1, Atom.a("**"))) | ||
4288 | { | ||
4289 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.pow"))) | ||
4290 | { | ||
4291 | yield return true; | ||
4292 | yield break; | ||
4293 | } | ||
4294 | } | ||
4295 | } | ||
4296 | { | ||
4297 | foreach (bool l2 in YP.unify(arg1, Atom.a(">>"))) | ||
4298 | { | ||
4299 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.bitwiseShiftRight"))) | ||
4300 | { | ||
4301 | yield return true; | ||
4302 | yield break; | ||
4303 | } | ||
4304 | } | ||
4305 | } | ||
4306 | { | ||
4307 | foreach (bool l2 in YP.unify(arg1, Atom.a("<<"))) | ||
4308 | { | ||
4309 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.bitwiseShiftLeft"))) | ||
4310 | { | ||
4311 | yield return true; | ||
4312 | yield break; | ||
4313 | } | ||
4314 | } | ||
4315 | } | ||
4316 | { | ||
4317 | foreach (bool l2 in YP.unify(arg1, Atom.a("/\\"))) | ||
4318 | { | ||
4319 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.bitwiseAnd"))) | ||
4320 | { | ||
4321 | yield return true; | ||
4322 | yield break; | ||
4323 | } | ||
4324 | } | ||
4325 | } | ||
4326 | { | ||
4327 | foreach (bool l2 in YP.unify(arg1, Atom.a("\\/"))) | ||
4328 | { | ||
4329 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.bitwiseOr"))) | ||
4330 | { | ||
4331 | yield return true; | ||
4332 | yield break; | ||
4333 | } | ||
4334 | } | ||
4335 | } | ||
4336 | { | ||
4337 | foreach (bool l2 in YP.unify(arg1, Atom.a("min"))) | ||
4338 | { | ||
4339 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.min"))) | ||
4340 | { | ||
4341 | yield return true; | ||
4342 | yield break; | ||
4343 | } | ||
4344 | } | ||
4345 | } | ||
4346 | { | ||
4347 | foreach (bool l2 in YP.unify(arg1, Atom.a("max"))) | ||
4348 | { | ||
4349 | foreach (bool l3 in YP.unify(arg2, Atom.a("YP.max"))) | ||
4350 | { | ||
4351 | yield return true; | ||
4352 | yield break; | ||
4353 | } | ||
4354 | } | ||
4355 | } | ||
4356 | } | ||
4357 | |||
4358 | public static void convertFunctionCSharp(object arg1) | ||
4359 | { | ||
4360 | { | ||
4361 | foreach (bool l2 in YP.unify(arg1, Atom.a("getDeclaringClass"))) | ||
4362 | { | ||
4363 | YP.write(Atom.a("public class YPInnerClass {}")); | ||
4364 | YP.nl(); | ||
4365 | YP.write(Atom.a("public static System.Type getDeclaringClass() { return typeof(YPInnerClass).DeclaringType; }")); | ||
4366 | YP.nl(); | ||
4367 | YP.nl(); | ||
4368 | return; | ||
4369 | } | ||
4370 | } | ||
4371 | { | ||
4372 | Variable ReturnType = new Variable(); | ||
4373 | Variable Name = new Variable(); | ||
4374 | Variable ArgList = new Variable(); | ||
4375 | Variable Body = new Variable(); | ||
4376 | Variable Level = new Variable(); | ||
4377 | foreach (bool l2 in YP.unify(arg1, new Functor("function", new object[] { ReturnType, Name, ArgList, Body }))) | ||
4378 | { | ||
4379 | YP.write(Atom.a("public static ")); | ||
4380 | YP.write(ReturnType); | ||
4381 | YP.write(Atom.a(" ")); | ||
4382 | YP.write(Name); | ||
4383 | YP.write(Atom.a("(")); | ||
4384 | convertArgListCSharp(ArgList); | ||
4385 | YP.write(Atom.a(") {")); | ||
4386 | YP.nl(); | ||
4387 | foreach (bool l3 in YP.unify(Level, 1)) | ||
4388 | { | ||
4389 | convertStatementListCSharp(Body, Level); | ||
4390 | YP.write(Atom.a("}")); | ||
4391 | YP.nl(); | ||
4392 | YP.nl(); | ||
4393 | return; | ||
4394 | } | ||
4395 | } | ||
4396 | } | ||
4397 | } | ||
4398 | |||
4399 | public static IEnumerable<bool> convertStatementListCSharp(object arg1, object x1, object x2) | ||
4400 | { | ||
4401 | { | ||
4402 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
4403 | { | ||
4404 | yield return true; | ||
4405 | yield break; | ||
4406 | } | ||
4407 | } | ||
4408 | } | ||
4409 | |||
4410 | public static void convertStatementListCSharp(object arg1, object Level) | ||
4411 | { | ||
4412 | { | ||
4413 | Variable Name = new Variable(); | ||
4414 | Variable Body = new Variable(); | ||
4415 | Variable RestStatements = new Variable(); | ||
4416 | Variable NewStatements = new Variable(); | ||
4417 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("breakableBlock", Name, Body), RestStatements))) | ||
4418 | { | ||
4419 | foreach (bool l3 in append(Body, new ListPair(new Functor1("label", Name), RestStatements), NewStatements)) | ||
4420 | { | ||
4421 | convertStatementListCSharp(NewStatements, Level); | ||
4422 | return; | ||
4423 | } | ||
4424 | } | ||
4425 | } | ||
4426 | { | ||
4427 | Variable Type = new Variable(); | ||
4428 | Variable Name = new Variable(); | ||
4429 | Variable Expression = new Variable(); | ||
4430 | Variable RestStatements = new Variable(); | ||
4431 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("declare", Type, Name, Expression), RestStatements))) | ||
4432 | { | ||
4433 | convertIndentationCSharp(Level); | ||
4434 | YP.write(Type); | ||
4435 | YP.write(Atom.a(" ")); | ||
4436 | YP.write(Name); | ||
4437 | YP.write(Atom.a(" = ")); | ||
4438 | convertExpressionCSharp(Expression); | ||
4439 | YP.write(Atom.a(";")); | ||
4440 | YP.nl(); | ||
4441 | convertStatementListCSharp(RestStatements, Level); | ||
4442 | return; | ||
4443 | } | ||
4444 | } | ||
4445 | { | ||
4446 | Variable Name = new Variable(); | ||
4447 | Variable Expression = new Variable(); | ||
4448 | Variable RestStatements = new Variable(); | ||
4449 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("assign", Name, Expression), RestStatements))) | ||
4450 | { | ||
4451 | convertIndentationCSharp(Level); | ||
4452 | YP.write(Name); | ||
4453 | YP.write(Atom.a(" = ")); | ||
4454 | convertExpressionCSharp(Expression); | ||
4455 | YP.write(Atom.a(";")); | ||
4456 | YP.nl(); | ||
4457 | convertStatementListCSharp(RestStatements, Level); | ||
4458 | return; | ||
4459 | } | ||
4460 | } | ||
4461 | { | ||
4462 | Variable RestStatements = new Variable(); | ||
4463 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldtrue"), RestStatements))) | ||
4464 | { | ||
4465 | convertIndentationCSharp(Level); | ||
4466 | YP.write(Atom.a("yield return true;")); | ||
4467 | YP.nl(); | ||
4468 | convertStatementListCSharp(RestStatements, Level); | ||
4469 | return; | ||
4470 | } | ||
4471 | } | ||
4472 | { | ||
4473 | Variable RestStatements = new Variable(); | ||
4474 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldfalse"), RestStatements))) | ||
4475 | { | ||
4476 | convertIndentationCSharp(Level); | ||
4477 | YP.write(Atom.a("yield return false;")); | ||
4478 | YP.nl(); | ||
4479 | convertStatementListCSharp(RestStatements, Level); | ||
4480 | return; | ||
4481 | } | ||
4482 | } | ||
4483 | { | ||
4484 | Variable RestStatements = new Variable(); | ||
4485 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldbreak"), RestStatements))) | ||
4486 | { | ||
4487 | convertIndentationCSharp(Level); | ||
4488 | YP.write(Atom.a("yield break;")); | ||
4489 | YP.nl(); | ||
4490 | convertStatementListCSharp(RestStatements, Level); | ||
4491 | return; | ||
4492 | } | ||
4493 | } | ||
4494 | { | ||
4495 | Variable RestStatements = new Variable(); | ||
4496 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("return"), RestStatements))) | ||
4497 | { | ||
4498 | convertIndentationCSharp(Level); | ||
4499 | YP.write(Atom.a("return;")); | ||
4500 | YP.nl(); | ||
4501 | convertStatementListCSharp(RestStatements, Level); | ||
4502 | return; | ||
4503 | } | ||
4504 | } | ||
4505 | { | ||
4506 | Variable RestStatements = new Variable(); | ||
4507 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("returntrue"), RestStatements))) | ||
4508 | { | ||
4509 | convertIndentationCSharp(Level); | ||
4510 | YP.write(Atom.a("return true;")); | ||
4511 | YP.nl(); | ||
4512 | convertStatementListCSharp(RestStatements, Level); | ||
4513 | return; | ||
4514 | } | ||
4515 | } | ||
4516 | { | ||
4517 | Variable RestStatements = new Variable(); | ||
4518 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("returnfalse"), RestStatements))) | ||
4519 | { | ||
4520 | convertIndentationCSharp(Level); | ||
4521 | YP.write(Atom.a("return false;")); | ||
4522 | YP.nl(); | ||
4523 | convertStatementListCSharp(RestStatements, Level); | ||
4524 | return; | ||
4525 | } | ||
4526 | } | ||
4527 | { | ||
4528 | Variable Name = new Variable(); | ||
4529 | Variable RestStatements = new Variable(); | ||
4530 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("label", Name), RestStatements))) | ||
4531 | { | ||
4532 | convertIndentationCSharp(Level); | ||
4533 | YP.write(Name); | ||
4534 | YP.write(Atom.a(":")); | ||
4535 | YP.nl(); | ||
4536 | if (YP.termEqual(RestStatements, Atom.NIL)) | ||
4537 | { | ||
4538 | convertIndentationCSharp(Level); | ||
4539 | YP.write(Atom.a("{}")); | ||
4540 | YP.nl(); | ||
4541 | convertStatementListCSharp(RestStatements, Level); | ||
4542 | return; | ||
4543 | goto cutIf1; | ||
4544 | } | ||
4545 | convertStatementListCSharp(RestStatements, Level); | ||
4546 | return; | ||
4547 | cutIf1: | ||
4548 | { } | ||
4549 | } | ||
4550 | } | ||
4551 | { | ||
4552 | Variable Name = new Variable(); | ||
4553 | Variable RestStatements = new Variable(); | ||
4554 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("breakBlock", Name), RestStatements))) | ||
4555 | { | ||
4556 | convertIndentationCSharp(Level); | ||
4557 | YP.write(Atom.a("goto ")); | ||
4558 | YP.write(Name); | ||
4559 | YP.write(Atom.a(";")); | ||
4560 | YP.nl(); | ||
4561 | convertStatementListCSharp(RestStatements, Level); | ||
4562 | return; | ||
4563 | } | ||
4564 | } | ||
4565 | { | ||
4566 | Variable Name = new Variable(); | ||
4567 | Variable ArgList = new Variable(); | ||
4568 | Variable RestStatements = new Variable(); | ||
4569 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("call", Name, ArgList), RestStatements))) | ||
4570 | { | ||
4571 | convertIndentationCSharp(Level); | ||
4572 | YP.write(Name); | ||
4573 | YP.write(Atom.a("(")); | ||
4574 | convertArgListCSharp(ArgList); | ||
4575 | YP.write(Atom.a(");")); | ||
4576 | YP.nl(); | ||
4577 | convertStatementListCSharp(RestStatements, Level); | ||
4578 | return; | ||
4579 | } | ||
4580 | } | ||
4581 | { | ||
4582 | Variable Name = new Variable(); | ||
4583 | Variable _FunctorArgs = new Variable(); | ||
4584 | Variable ArgList = new Variable(); | ||
4585 | Variable RestStatements = new Variable(); | ||
4586 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("functorCall", Name, _FunctorArgs, ArgList), RestStatements))) | ||
4587 | { | ||
4588 | convertStatementListCSharp(new ListPair(new Functor2("call", Name, ArgList), RestStatements), Level); | ||
4589 | return; | ||
4590 | } | ||
4591 | } | ||
4592 | { | ||
4593 | Variable Obj = new Variable(); | ||
4594 | Variable Name = new Variable(); | ||
4595 | Variable ArgList = new Variable(); | ||
4596 | Variable RestStatements = new Variable(); | ||
4597 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("callMember", new Functor1("var", Obj), Name, ArgList), RestStatements))) | ||
4598 | { | ||
4599 | convertIndentationCSharp(Level); | ||
4600 | YP.write(Obj); | ||
4601 | YP.write(Atom.a(".")); | ||
4602 | YP.write(Name); | ||
4603 | YP.write(Atom.a("(")); | ||
4604 | convertArgListCSharp(ArgList); | ||
4605 | YP.write(Atom.a(");")); | ||
4606 | YP.nl(); | ||
4607 | convertStatementListCSharp(RestStatements, Level); | ||
4608 | return; | ||
4609 | } | ||
4610 | } | ||
4611 | { | ||
4612 | Variable Body = new Variable(); | ||
4613 | Variable RestStatements = new Variable(); | ||
4614 | Variable NextLevel = new Variable(); | ||
4615 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("blockScope", Body), RestStatements))) | ||
4616 | { | ||
4617 | convertIndentationCSharp(Level); | ||
4618 | YP.write(Atom.a("{")); | ||
4619 | YP.nl(); | ||
4620 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
4621 | { | ||
4622 | convertStatementListCSharp(Body, NextLevel); | ||
4623 | convertIndentationCSharp(Level); | ||
4624 | YP.write(Atom.a("}")); | ||
4625 | YP.nl(); | ||
4626 | convertStatementListCSharp(RestStatements, Level); | ||
4627 | return; | ||
4628 | } | ||
4629 | } | ||
4630 | } | ||
4631 | { | ||
4632 | Variable Expression = new Variable(); | ||
4633 | Variable Body = new Variable(); | ||
4634 | Variable RestStatements = new Variable(); | ||
4635 | Variable NextLevel = new Variable(); | ||
4636 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("if", Expression, Body), RestStatements))) | ||
4637 | { | ||
4638 | convertIndentationCSharp(Level); | ||
4639 | YP.write(Atom.a("if (")); | ||
4640 | convertExpressionCSharp(Expression); | ||
4641 | YP.write(Atom.a(") {")); | ||
4642 | YP.nl(); | ||
4643 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
4644 | { | ||
4645 | convertStatementListCSharp(Body, NextLevel); | ||
4646 | convertIndentationCSharp(Level); | ||
4647 | YP.write(Atom.a("}")); | ||
4648 | YP.nl(); | ||
4649 | convertStatementListCSharp(RestStatements, Level); | ||
4650 | return; | ||
4651 | } | ||
4652 | } | ||
4653 | } | ||
4654 | { | ||
4655 | Variable Expression = new Variable(); | ||
4656 | Variable Body = new Variable(); | ||
4657 | Variable RestStatements = new Variable(); | ||
4658 | Variable NextLevel = new Variable(); | ||
4659 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("foreach", Expression, Body), RestStatements))) | ||
4660 | { | ||
4661 | convertIndentationCSharp(Level); | ||
4662 | YP.write(Atom.a("foreach (bool l")); | ||
4663 | YP.write(Level); | ||
4664 | YP.write(Atom.a(" in ")); | ||
4665 | convertExpressionCSharp(Expression); | ||
4666 | YP.write(Atom.a(") {")); | ||
4667 | YP.nl(); | ||
4668 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
4669 | { | ||
4670 | convertStatementListCSharp(Body, NextLevel); | ||
4671 | convertIndentationCSharp(Level); | ||
4672 | YP.write(Atom.a("}")); | ||
4673 | YP.nl(); | ||
4674 | convertStatementListCSharp(RestStatements, Level); | ||
4675 | return; | ||
4676 | } | ||
4677 | } | ||
4678 | } | ||
4679 | { | ||
4680 | Variable Expression = new Variable(); | ||
4681 | Variable RestStatements = new Variable(); | ||
4682 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("throw", Expression), RestStatements))) | ||
4683 | { | ||
4684 | convertIndentationCSharp(Level); | ||
4685 | YP.write(Atom.a("throw ")); | ||
4686 | convertExpressionCSharp(Expression); | ||
4687 | YP.write(Atom.a(";")); | ||
4688 | YP.nl(); | ||
4689 | convertStatementListCSharp(RestStatements, Level); | ||
4690 | return; | ||
4691 | } | ||
4692 | } | ||
4693 | } | ||
4694 | |||
4695 | public static void convertIndentationCSharp(object Level) | ||
4696 | { | ||
4697 | { | ||
4698 | Variable N = new Variable(); | ||
4699 | foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) | ||
4700 | { | ||
4701 | repeatWrite(Atom.a(" "), N); | ||
4702 | return; | ||
4703 | } | ||
4704 | } | ||
4705 | } | ||
4706 | |||
4707 | public static void convertArgListCSharp(object arg1) | ||
4708 | { | ||
4709 | { | ||
4710 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
4711 | { | ||
4712 | return; | ||
4713 | } | ||
4714 | } | ||
4715 | { | ||
4716 | Variable Head = new Variable(); | ||
4717 | Variable Tail = new Variable(); | ||
4718 | foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) | ||
4719 | { | ||
4720 | convertExpressionCSharp(Head); | ||
4721 | if (YP.termNotEqual(Tail, Atom.NIL)) | ||
4722 | { | ||
4723 | YP.write(Atom.a(", ")); | ||
4724 | convertArgListCSharp(Tail); | ||
4725 | return; | ||
4726 | goto cutIf1; | ||
4727 | } | ||
4728 | convertArgListCSharp(Tail); | ||
4729 | return; | ||
4730 | cutIf1: | ||
4731 | { } | ||
4732 | } | ||
4733 | } | ||
4734 | } | ||
4735 | |||
4736 | public static void convertExpressionCSharp(object arg1) | ||
4737 | { | ||
4738 | { | ||
4739 | Variable X = new Variable(); | ||
4740 | foreach (bool l2 in YP.unify(arg1, new Functor1("arg", X))) | ||
4741 | { | ||
4742 | YP.write(Atom.a("object ")); | ||
4743 | YP.write(X); | ||
4744 | return; | ||
4745 | } | ||
4746 | } | ||
4747 | { | ||
4748 | Variable Name = new Variable(); | ||
4749 | Variable ArgList = new Variable(); | ||
4750 | foreach (bool l2 in YP.unify(arg1, new Functor2("call", Name, ArgList))) | ||
4751 | { | ||
4752 | YP.write(Name); | ||
4753 | YP.write(Atom.a("(")); | ||
4754 | convertArgListCSharp(ArgList); | ||
4755 | YP.write(Atom.a(")")); | ||
4756 | return; | ||
4757 | } | ||
4758 | } | ||
4759 | { | ||
4760 | Variable Name = new Variable(); | ||
4761 | Variable _FunctorArgs = new Variable(); | ||
4762 | Variable ArgList = new Variable(); | ||
4763 | foreach (bool l2 in YP.unify(arg1, new Functor3("functorCall", Name, _FunctorArgs, ArgList))) | ||
4764 | { | ||
4765 | convertExpressionCSharp(new Functor2("call", Name, ArgList)); | ||
4766 | return; | ||
4767 | } | ||
4768 | } | ||
4769 | { | ||
4770 | Variable Obj = new Variable(); | ||
4771 | Variable Name = new Variable(); | ||
4772 | Variable ArgList = new Variable(); | ||
4773 | foreach (bool l2 in YP.unify(arg1, new Functor3("callMember", new Functor1("var", Obj), Name, ArgList))) | ||
4774 | { | ||
4775 | YP.write(Obj); | ||
4776 | YP.write(Atom.a(".")); | ||
4777 | YP.write(Name); | ||
4778 | YP.write(Atom.a("(")); | ||
4779 | convertArgListCSharp(ArgList); | ||
4780 | YP.write(Atom.a(")")); | ||
4781 | return; | ||
4782 | } | ||
4783 | } | ||
4784 | { | ||
4785 | Variable Name = new Variable(); | ||
4786 | Variable ArgList = new Variable(); | ||
4787 | foreach (bool l2 in YP.unify(arg1, new Functor2("new", Name, ArgList))) | ||
4788 | { | ||
4789 | YP.write(Atom.a("new ")); | ||
4790 | YP.write(Name); | ||
4791 | YP.write(Atom.a("(")); | ||
4792 | convertArgListCSharp(ArgList); | ||
4793 | YP.write(Atom.a(")")); | ||
4794 | return; | ||
4795 | } | ||
4796 | } | ||
4797 | { | ||
4798 | Variable Name = new Variable(); | ||
4799 | foreach (bool l2 in YP.unify(arg1, new Functor1("var", Name))) | ||
4800 | { | ||
4801 | YP.write(Name); | ||
4802 | return; | ||
4803 | } | ||
4804 | } | ||
4805 | { | ||
4806 | foreach (bool l2 in YP.unify(arg1, Atom.a("null"))) | ||
4807 | { | ||
4808 | YP.write(Atom.a("null")); | ||
4809 | return; | ||
4810 | } | ||
4811 | } | ||
4812 | { | ||
4813 | Variable X = new Variable(); | ||
4814 | foreach (bool l2 in YP.unify(arg1, new Functor1("not", X))) | ||
4815 | { | ||
4816 | YP.write(Atom.a("!(")); | ||
4817 | convertExpressionCSharp(X); | ||
4818 | YP.write(Atom.a(")")); | ||
4819 | return; | ||
4820 | } | ||
4821 | } | ||
4822 | { | ||
4823 | Variable X = new Variable(); | ||
4824 | Variable Y = new Variable(); | ||
4825 | foreach (bool l2 in YP.unify(arg1, new Functor2("and", X, Y))) | ||
4826 | { | ||
4827 | YP.write(Atom.a("(")); | ||
4828 | convertExpressionCSharp(X); | ||
4829 | YP.write(Atom.a(") && (")); | ||
4830 | convertExpressionCSharp(Y); | ||
4831 | YP.write(Atom.a(")")); | ||
4832 | return; | ||
4833 | } | ||
4834 | } | ||
4835 | { | ||
4836 | Variable ArgList = new Variable(); | ||
4837 | foreach (bool l2 in YP.unify(arg1, new Functor1("objectArray", ArgList))) | ||
4838 | { | ||
4839 | YP.write(Atom.a("new object[] {")); | ||
4840 | convertArgListCSharp(ArgList); | ||
4841 | YP.write(Atom.a("}")); | ||
4842 | return; | ||
4843 | } | ||
4844 | } | ||
4845 | { | ||
4846 | Variable X = new Variable(); | ||
4847 | Variable Codes = new Variable(); | ||
4848 | foreach (bool l2 in YP.unify(arg1, new Functor1("object", X))) | ||
4849 | { | ||
4850 | if (YP.atom(X)) | ||
4851 | { | ||
4852 | YP.write(Atom.a("\"")); | ||
4853 | foreach (bool l4 in YP.atom_codes(X, Codes)) | ||
4854 | { | ||
4855 | convertStringCodesCSharp(Codes); | ||
4856 | YP.write(Atom.a("\"")); | ||
4857 | return; | ||
4858 | } | ||
4859 | } | ||
4860 | } | ||
4861 | } | ||
4862 | { | ||
4863 | Variable X = new Variable(); | ||
4864 | foreach (bool l2 in YP.unify(arg1, new Functor1("object", X))) | ||
4865 | { | ||
4866 | YP.write(X); | ||
4867 | return; | ||
4868 | } | ||
4869 | } | ||
4870 | } | ||
4871 | |||
4872 | public static void convertStringCodesCSharp(object arg1) | ||
4873 | { | ||
4874 | { | ||
4875 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
4876 | { | ||
4877 | return; | ||
4878 | } | ||
4879 | } | ||
4880 | { | ||
4881 | Variable Code = new Variable(); | ||
4882 | Variable RestCodes = new Variable(); | ||
4883 | foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) | ||
4884 | { | ||
4885 | foreach (bool l3 in putCStringCode(Code)) | ||
4886 | { | ||
4887 | convertStringCodesCSharp(RestCodes); | ||
4888 | return; | ||
4889 | } | ||
4890 | } | ||
4891 | } | ||
4892 | } | ||
4893 | |||
4894 | public static void convertFunctionJavascript(object arg1) | ||
4895 | { | ||
4896 | { | ||
4897 | foreach (bool l2 in YP.unify(arg1, Atom.a("getDeclaringClass"))) | ||
4898 | { | ||
4899 | YP.write(Atom.a("function getDeclaringClass() { return null; }")); | ||
4900 | YP.nl(); | ||
4901 | YP.nl(); | ||
4902 | return; | ||
4903 | } | ||
4904 | } | ||
4905 | { | ||
4906 | Variable x1 = new Variable(); | ||
4907 | Variable Name = new Variable(); | ||
4908 | Variable ArgList = new Variable(); | ||
4909 | Variable Body = new Variable(); | ||
4910 | foreach (bool l2 in YP.unify(arg1, new Functor("function", new object[] { x1, Name, ArgList, Body }))) | ||
4911 | { | ||
4912 | YP.write(Atom.a("function ")); | ||
4913 | YP.write(Name); | ||
4914 | YP.write(Atom.a("(")); | ||
4915 | convertArgListJavascript(ArgList); | ||
4916 | YP.write(Atom.a(") {")); | ||
4917 | YP.nl(); | ||
4918 | convertStatementListJavascript(Body, 1); | ||
4919 | YP.write(Atom.a("}")); | ||
4920 | YP.nl(); | ||
4921 | YP.nl(); | ||
4922 | return; | ||
4923 | } | ||
4924 | } | ||
4925 | } | ||
4926 | |||
4927 | public static void convertStatementListJavascript(object arg1, object arg2) | ||
4928 | { | ||
4929 | { | ||
4930 | object x1 = arg2; | ||
4931 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
4932 | { | ||
4933 | return; | ||
4934 | } | ||
4935 | } | ||
4936 | { | ||
4937 | object Level = arg2; | ||
4938 | Variable Name = new Variable(); | ||
4939 | Variable Body = new Variable(); | ||
4940 | Variable RestStatements = new Variable(); | ||
4941 | Variable NextLevel = new Variable(); | ||
4942 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("breakableBlock", Name, Body), RestStatements))) | ||
4943 | { | ||
4944 | convertIndentationJavascript(Level); | ||
4945 | YP.write(Name); | ||
4946 | YP.write(Atom.a(":")); | ||
4947 | YP.nl(); | ||
4948 | convertIndentationJavascript(Level); | ||
4949 | YP.write(Atom.a("{")); | ||
4950 | YP.nl(); | ||
4951 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
4952 | { | ||
4953 | convertStatementListJavascript(Body, NextLevel); | ||
4954 | convertIndentationJavascript(Level); | ||
4955 | YP.write(Atom.a("}")); | ||
4956 | YP.nl(); | ||
4957 | convertStatementListJavascript(RestStatements, Level); | ||
4958 | return; | ||
4959 | } | ||
4960 | } | ||
4961 | } | ||
4962 | { | ||
4963 | object Level = arg2; | ||
4964 | Variable _Type = new Variable(); | ||
4965 | Variable Name = new Variable(); | ||
4966 | Variable Expression = new Variable(); | ||
4967 | Variable RestStatements = new Variable(); | ||
4968 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("declare", _Type, Name, Expression), RestStatements))) | ||
4969 | { | ||
4970 | convertIndentationJavascript(Level); | ||
4971 | YP.write(Atom.a("var ")); | ||
4972 | YP.write(Name); | ||
4973 | YP.write(Atom.a(" = ")); | ||
4974 | convertExpressionJavascript(Expression); | ||
4975 | YP.write(Atom.a(";")); | ||
4976 | YP.nl(); | ||
4977 | convertStatementListJavascript(RestStatements, Level); | ||
4978 | return; | ||
4979 | } | ||
4980 | } | ||
4981 | { | ||
4982 | object Level = arg2; | ||
4983 | Variable Name = new Variable(); | ||
4984 | Variable Expression = new Variable(); | ||
4985 | Variable RestStatements = new Variable(); | ||
4986 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("assign", Name, Expression), RestStatements))) | ||
4987 | { | ||
4988 | convertIndentationJavascript(Level); | ||
4989 | YP.write(Name); | ||
4990 | YP.write(Atom.a(" = ")); | ||
4991 | convertExpressionJavascript(Expression); | ||
4992 | YP.write(Atom.a(";")); | ||
4993 | YP.nl(); | ||
4994 | convertStatementListJavascript(RestStatements, Level); | ||
4995 | return; | ||
4996 | } | ||
4997 | } | ||
4998 | { | ||
4999 | object Level = arg2; | ||
5000 | Variable RestStatements = new Variable(); | ||
5001 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldtrue"), RestStatements))) | ||
5002 | { | ||
5003 | convertIndentationJavascript(Level); | ||
5004 | YP.write(Atom.a("yield true;")); | ||
5005 | YP.nl(); | ||
5006 | convertStatementListJavascript(RestStatements, Level); | ||
5007 | return; | ||
5008 | } | ||
5009 | } | ||
5010 | { | ||
5011 | object Level = arg2; | ||
5012 | Variable RestStatements = new Variable(); | ||
5013 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldfalse"), RestStatements))) | ||
5014 | { | ||
5015 | convertIndentationJavascript(Level); | ||
5016 | YP.write(Atom.a("yield false;")); | ||
5017 | YP.nl(); | ||
5018 | convertStatementListJavascript(RestStatements, Level); | ||
5019 | return; | ||
5020 | } | ||
5021 | } | ||
5022 | { | ||
5023 | object Level = arg2; | ||
5024 | Variable RestStatements = new Variable(); | ||
5025 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldbreak"), RestStatements))) | ||
5026 | { | ||
5027 | convertIndentationJavascript(Level); | ||
5028 | YP.write(Atom.a("return;")); | ||
5029 | YP.nl(); | ||
5030 | convertStatementListJavascript(RestStatements, Level); | ||
5031 | return; | ||
5032 | } | ||
5033 | } | ||
5034 | { | ||
5035 | object Level = arg2; | ||
5036 | Variable RestStatements = new Variable(); | ||
5037 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("return"), RestStatements))) | ||
5038 | { | ||
5039 | convertIndentationJavascript(Level); | ||
5040 | YP.write(Atom.a("return;")); | ||
5041 | YP.nl(); | ||
5042 | convertStatementListJavascript(RestStatements, Level); | ||
5043 | return; | ||
5044 | } | ||
5045 | } | ||
5046 | { | ||
5047 | object Level = arg2; | ||
5048 | Variable RestStatements = new Variable(); | ||
5049 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("returntrue"), RestStatements))) | ||
5050 | { | ||
5051 | convertIndentationJavascript(Level); | ||
5052 | YP.write(Atom.a("return true;")); | ||
5053 | YP.nl(); | ||
5054 | convertStatementListJavascript(RestStatements, Level); | ||
5055 | return; | ||
5056 | } | ||
5057 | } | ||
5058 | { | ||
5059 | object Level = arg2; | ||
5060 | Variable RestStatements = new Variable(); | ||
5061 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("returnfalse"), RestStatements))) | ||
5062 | { | ||
5063 | convertIndentationJavascript(Level); | ||
5064 | YP.write(Atom.a("return false;")); | ||
5065 | YP.nl(); | ||
5066 | convertStatementListJavascript(RestStatements, Level); | ||
5067 | return; | ||
5068 | } | ||
5069 | } | ||
5070 | { | ||
5071 | object Level = arg2; | ||
5072 | Variable Name = new Variable(); | ||
5073 | Variable RestStatements = new Variable(); | ||
5074 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("breakBlock", Name), RestStatements))) | ||
5075 | { | ||
5076 | convertIndentationJavascript(Level); | ||
5077 | YP.write(Atom.a("break ")); | ||
5078 | YP.write(Name); | ||
5079 | YP.write(Atom.a(";")); | ||
5080 | YP.nl(); | ||
5081 | convertStatementListJavascript(RestStatements, Level); | ||
5082 | return; | ||
5083 | } | ||
5084 | } | ||
5085 | { | ||
5086 | object Level = arg2; | ||
5087 | Variable Name = new Variable(); | ||
5088 | Variable ArgList = new Variable(); | ||
5089 | Variable RestStatements = new Variable(); | ||
5090 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("call", Name, ArgList), RestStatements))) | ||
5091 | { | ||
5092 | convertIndentationJavascript(Level); | ||
5093 | YP.write(Name); | ||
5094 | YP.write(Atom.a("(")); | ||
5095 | convertArgListJavascript(ArgList); | ||
5096 | YP.write(Atom.a(");")); | ||
5097 | YP.nl(); | ||
5098 | convertStatementListJavascript(RestStatements, Level); | ||
5099 | return; | ||
5100 | } | ||
5101 | } | ||
5102 | { | ||
5103 | object Level = arg2; | ||
5104 | Variable Name = new Variable(); | ||
5105 | Variable _FunctorArgs = new Variable(); | ||
5106 | Variable ArgList = new Variable(); | ||
5107 | Variable RestStatements = new Variable(); | ||
5108 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("functorCall", Name, _FunctorArgs, ArgList), RestStatements))) | ||
5109 | { | ||
5110 | convertStatementListJavascript(new ListPair(new Functor2("call", Name, ArgList), RestStatements), Level); | ||
5111 | return; | ||
5112 | } | ||
5113 | } | ||
5114 | { | ||
5115 | object Level = arg2; | ||
5116 | Variable Obj = new Variable(); | ||
5117 | Variable Name = new Variable(); | ||
5118 | Variable ArgList = new Variable(); | ||
5119 | Variable RestStatements = new Variable(); | ||
5120 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("callMember", new Functor1("var", Obj), Name, ArgList), RestStatements))) | ||
5121 | { | ||
5122 | convertIndentationJavascript(Level); | ||
5123 | YP.write(Obj); | ||
5124 | YP.write(Atom.a(".")); | ||
5125 | YP.write(Name); | ||
5126 | YP.write(Atom.a("(")); | ||
5127 | convertArgListJavascript(ArgList); | ||
5128 | YP.write(Atom.a(");")); | ||
5129 | YP.nl(); | ||
5130 | convertStatementListJavascript(RestStatements, Level); | ||
5131 | return; | ||
5132 | } | ||
5133 | } | ||
5134 | { | ||
5135 | object Level = arg2; | ||
5136 | Variable Body = new Variable(); | ||
5137 | Variable RestStatements = new Variable(); | ||
5138 | Variable NextLevel = new Variable(); | ||
5139 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("blockScope", Body), RestStatements))) | ||
5140 | { | ||
5141 | convertIndentationJavascript(Level); | ||
5142 | YP.write(Atom.a("{")); | ||
5143 | YP.nl(); | ||
5144 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5145 | { | ||
5146 | convertStatementListJavascript(Body, NextLevel); | ||
5147 | convertIndentationJavascript(Level); | ||
5148 | YP.write(Atom.a("}")); | ||
5149 | YP.nl(); | ||
5150 | convertStatementListJavascript(RestStatements, Level); | ||
5151 | return; | ||
5152 | } | ||
5153 | } | ||
5154 | } | ||
5155 | { | ||
5156 | object Level = arg2; | ||
5157 | Variable Expression = new Variable(); | ||
5158 | Variable Body = new Variable(); | ||
5159 | Variable RestStatements = new Variable(); | ||
5160 | Variable NextLevel = new Variable(); | ||
5161 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("if", Expression, Body), RestStatements))) | ||
5162 | { | ||
5163 | convertIndentationJavascript(Level); | ||
5164 | YP.write(Atom.a("if (")); | ||
5165 | convertExpressionJavascript(Expression); | ||
5166 | YP.write(Atom.a(") {")); | ||
5167 | YP.nl(); | ||
5168 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5169 | { | ||
5170 | convertStatementListJavascript(Body, NextLevel); | ||
5171 | convertIndentationJavascript(Level); | ||
5172 | YP.write(Atom.a("}")); | ||
5173 | YP.nl(); | ||
5174 | convertStatementListJavascript(RestStatements, Level); | ||
5175 | return; | ||
5176 | } | ||
5177 | } | ||
5178 | } | ||
5179 | { | ||
5180 | object Level = arg2; | ||
5181 | Variable Expression = new Variable(); | ||
5182 | Variable Body = new Variable(); | ||
5183 | Variable RestStatements = new Variable(); | ||
5184 | Variable NextLevel = new Variable(); | ||
5185 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("foreach", Expression, Body), RestStatements))) | ||
5186 | { | ||
5187 | convertIndentationJavascript(Level); | ||
5188 | YP.write(Atom.a("for each (var l")); | ||
5189 | YP.write(Level); | ||
5190 | YP.write(Atom.a(" in ")); | ||
5191 | convertExpressionJavascript(Expression); | ||
5192 | YP.write(Atom.a(") {")); | ||
5193 | YP.nl(); | ||
5194 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5195 | { | ||
5196 | convertStatementListJavascript(Body, NextLevel); | ||
5197 | convertIndentationJavascript(Level); | ||
5198 | YP.write(Atom.a("}")); | ||
5199 | YP.nl(); | ||
5200 | convertStatementListJavascript(RestStatements, Level); | ||
5201 | return; | ||
5202 | } | ||
5203 | } | ||
5204 | } | ||
5205 | { | ||
5206 | object Level = arg2; | ||
5207 | Variable Expression = new Variable(); | ||
5208 | Variable RestStatements = new Variable(); | ||
5209 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("throw", Expression), RestStatements))) | ||
5210 | { | ||
5211 | convertIndentationJavascript(Level); | ||
5212 | YP.write(Atom.a("throw ")); | ||
5213 | convertExpressionJavascript(Expression); | ||
5214 | YP.write(Atom.a(";")); | ||
5215 | YP.nl(); | ||
5216 | convertStatementListJavascript(RestStatements, Level); | ||
5217 | return; | ||
5218 | } | ||
5219 | } | ||
5220 | } | ||
5221 | |||
5222 | public static void convertIndentationJavascript(object Level) | ||
5223 | { | ||
5224 | { | ||
5225 | Variable N = new Variable(); | ||
5226 | foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) | ||
5227 | { | ||
5228 | repeatWrite(Atom.a(" "), N); | ||
5229 | return; | ||
5230 | } | ||
5231 | } | ||
5232 | } | ||
5233 | |||
5234 | public static void convertArgListJavascript(object arg1) | ||
5235 | { | ||
5236 | { | ||
5237 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
5238 | { | ||
5239 | return; | ||
5240 | } | ||
5241 | } | ||
5242 | { | ||
5243 | Variable Head = new Variable(); | ||
5244 | Variable Tail = new Variable(); | ||
5245 | foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) | ||
5246 | { | ||
5247 | convertExpressionJavascript(Head); | ||
5248 | if (YP.termNotEqual(Tail, Atom.NIL)) | ||
5249 | { | ||
5250 | YP.write(Atom.a(", ")); | ||
5251 | convertArgListJavascript(Tail); | ||
5252 | return; | ||
5253 | goto cutIf1; | ||
5254 | } | ||
5255 | convertArgListJavascript(Tail); | ||
5256 | return; | ||
5257 | cutIf1: | ||
5258 | { } | ||
5259 | } | ||
5260 | } | ||
5261 | } | ||
5262 | |||
5263 | public static void convertExpressionJavascript(object arg1) | ||
5264 | { | ||
5265 | { | ||
5266 | Variable X = new Variable(); | ||
5267 | foreach (bool l2 in YP.unify(arg1, new Functor1("arg", X))) | ||
5268 | { | ||
5269 | YP.write(X); | ||
5270 | return; | ||
5271 | } | ||
5272 | } | ||
5273 | { | ||
5274 | Variable Name = new Variable(); | ||
5275 | Variable ArgList = new Variable(); | ||
5276 | foreach (bool l2 in YP.unify(arg1, new Functor2("call", Name, ArgList))) | ||
5277 | { | ||
5278 | YP.write(Name); | ||
5279 | YP.write(Atom.a("(")); | ||
5280 | convertArgListJavascript(ArgList); | ||
5281 | YP.write(Atom.a(")")); | ||
5282 | return; | ||
5283 | } | ||
5284 | } | ||
5285 | { | ||
5286 | Variable Name = new Variable(); | ||
5287 | Variable _FunctorArgs = new Variable(); | ||
5288 | Variable ArgList = new Variable(); | ||
5289 | foreach (bool l2 in YP.unify(arg1, new Functor3("functorCall", Name, _FunctorArgs, ArgList))) | ||
5290 | { | ||
5291 | convertExpressionJavascript(new Functor2("call", Name, ArgList)); | ||
5292 | return; | ||
5293 | } | ||
5294 | } | ||
5295 | { | ||
5296 | Variable Obj = new Variable(); | ||
5297 | Variable Name = new Variable(); | ||
5298 | Variable ArgList = new Variable(); | ||
5299 | foreach (bool l2 in YP.unify(arg1, new Functor3("callMember", new Functor1("var", Obj), Name, ArgList))) | ||
5300 | { | ||
5301 | YP.write(Obj); | ||
5302 | YP.write(Atom.a(".")); | ||
5303 | YP.write(Name); | ||
5304 | YP.write(Atom.a("(")); | ||
5305 | convertArgListJavascript(ArgList); | ||
5306 | YP.write(Atom.a(")")); | ||
5307 | return; | ||
5308 | } | ||
5309 | } | ||
5310 | { | ||
5311 | Variable Name = new Variable(); | ||
5312 | Variable ArgList = new Variable(); | ||
5313 | foreach (bool l2 in YP.unify(arg1, new Functor2("new", Name, ArgList))) | ||
5314 | { | ||
5315 | YP.write(Atom.a("new ")); | ||
5316 | YP.write(Name); | ||
5317 | YP.write(Atom.a("(")); | ||
5318 | convertArgListJavascript(ArgList); | ||
5319 | YP.write(Atom.a(")")); | ||
5320 | return; | ||
5321 | } | ||
5322 | } | ||
5323 | { | ||
5324 | Variable Name = new Variable(); | ||
5325 | foreach (bool l2 in YP.unify(arg1, new Functor1("var", Name))) | ||
5326 | { | ||
5327 | YP.write(Name); | ||
5328 | return; | ||
5329 | } | ||
5330 | } | ||
5331 | { | ||
5332 | foreach (bool l2 in YP.unify(arg1, Atom.a("null"))) | ||
5333 | { | ||
5334 | YP.write(Atom.a("null")); | ||
5335 | return; | ||
5336 | } | ||
5337 | } | ||
5338 | { | ||
5339 | Variable X = new Variable(); | ||
5340 | foreach (bool l2 in YP.unify(arg1, new Functor1("not", X))) | ||
5341 | { | ||
5342 | YP.write(Atom.a("!(")); | ||
5343 | convertExpressionJavascript(X); | ||
5344 | YP.write(Atom.a(")")); | ||
5345 | return; | ||
5346 | } | ||
5347 | } | ||
5348 | { | ||
5349 | Variable X = new Variable(); | ||
5350 | Variable Y = new Variable(); | ||
5351 | foreach (bool l2 in YP.unify(arg1, new Functor2("and", X, Y))) | ||
5352 | { | ||
5353 | YP.write(Atom.a("(")); | ||
5354 | convertExpressionJavascript(X); | ||
5355 | YP.write(Atom.a(") && (")); | ||
5356 | convertExpressionJavascript(Y); | ||
5357 | YP.write(Atom.a(")")); | ||
5358 | return; | ||
5359 | } | ||
5360 | } | ||
5361 | { | ||
5362 | Variable ArgList = new Variable(); | ||
5363 | foreach (bool l2 in YP.unify(arg1, new Functor1("objectArray", ArgList))) | ||
5364 | { | ||
5365 | YP.write(Atom.a("[")); | ||
5366 | convertArgListJavascript(ArgList); | ||
5367 | YP.write(Atom.a("]")); | ||
5368 | return; | ||
5369 | } | ||
5370 | } | ||
5371 | { | ||
5372 | Variable X = new Variable(); | ||
5373 | Variable Codes = new Variable(); | ||
5374 | foreach (bool l2 in YP.unify(arg1, new Functor1("object", X))) | ||
5375 | { | ||
5376 | if (YP.atom(X)) | ||
5377 | { | ||
5378 | YP.write(Atom.a("\"")); | ||
5379 | foreach (bool l4 in YP.atom_codes(X, Codes)) | ||
5380 | { | ||
5381 | convertStringCodesJavascript(Codes); | ||
5382 | YP.write(Atom.a("\"")); | ||
5383 | return; | ||
5384 | } | ||
5385 | } | ||
5386 | } | ||
5387 | } | ||
5388 | { | ||
5389 | Variable X = new Variable(); | ||
5390 | foreach (bool l2 in YP.unify(arg1, new Functor1("object", X))) | ||
5391 | { | ||
5392 | YP.write(X); | ||
5393 | return; | ||
5394 | } | ||
5395 | } | ||
5396 | } | ||
5397 | |||
5398 | public static void convertStringCodesJavascript(object arg1) | ||
5399 | { | ||
5400 | { | ||
5401 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
5402 | { | ||
5403 | return; | ||
5404 | } | ||
5405 | } | ||
5406 | { | ||
5407 | Variable Code = new Variable(); | ||
5408 | Variable RestCodes = new Variable(); | ||
5409 | foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) | ||
5410 | { | ||
5411 | foreach (bool l3 in putCStringCode(Code)) | ||
5412 | { | ||
5413 | convertStringCodesJavascript(RestCodes); | ||
5414 | return; | ||
5415 | } | ||
5416 | } | ||
5417 | } | ||
5418 | } | ||
5419 | |||
5420 | public static void convertFunctionPython(object arg1) | ||
5421 | { | ||
5422 | { | ||
5423 | foreach (bool l2 in YP.unify(arg1, Atom.a("getDeclaringClass"))) | ||
5424 | { | ||
5425 | YP.write(Atom.a("def getDeclaringClass():")); | ||
5426 | YP.nl(); | ||
5427 | YP.write(Atom.a(" return None")); | ||
5428 | YP.nl(); | ||
5429 | YP.nl(); | ||
5430 | return; | ||
5431 | } | ||
5432 | } | ||
5433 | { | ||
5434 | Variable x1 = new Variable(); | ||
5435 | Variable Name = new Variable(); | ||
5436 | Variable ArgList = new Variable(); | ||
5437 | Variable Body = new Variable(); | ||
5438 | Variable Level = new Variable(); | ||
5439 | Variable HasBreakableBlock = new Variable(); | ||
5440 | foreach (bool l2 in YP.unify(arg1, new Functor("function", new object[] { x1, Name, ArgList, Body }))) | ||
5441 | { | ||
5442 | YP.write(Atom.a("def ")); | ||
5443 | YP.write(Name); | ||
5444 | YP.write(Atom.a("(")); | ||
5445 | convertArgListPython(ArgList); | ||
5446 | YP.write(Atom.a("):")); | ||
5447 | YP.nl(); | ||
5448 | foreach (bool l3 in YP.unify(Level, 1)) | ||
5449 | { | ||
5450 | if (hasBreakableBlockPython(Body)) | ||
5451 | { | ||
5452 | foreach (bool l5 in YP.unify(HasBreakableBlock, 1)) | ||
5453 | { | ||
5454 | if (YP.termEqual(HasBreakableBlock, 1)) | ||
5455 | { | ||
5456 | convertIndentationPython(Level); | ||
5457 | YP.write(Atom.a("doBreak = False")); | ||
5458 | YP.nl(); | ||
5459 | foreach (bool l7 in convertStatementListPython(Body, Level, HasBreakableBlock)) | ||
5460 | { | ||
5461 | YP.nl(); | ||
5462 | return; | ||
5463 | } | ||
5464 | goto cutIf2; | ||
5465 | } | ||
5466 | foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) | ||
5467 | { | ||
5468 | YP.nl(); | ||
5469 | return; | ||
5470 | } | ||
5471 | cutIf2: | ||
5472 | { } | ||
5473 | } | ||
5474 | goto cutIf1; | ||
5475 | } | ||
5476 | foreach (bool l4 in YP.unify(HasBreakableBlock, 0)) | ||
5477 | { | ||
5478 | if (YP.termEqual(HasBreakableBlock, 1)) | ||
5479 | { | ||
5480 | convertIndentationPython(Level); | ||
5481 | YP.write(Atom.a("doBreak = False")); | ||
5482 | YP.nl(); | ||
5483 | foreach (bool l6 in convertStatementListPython(Body, Level, HasBreakableBlock)) | ||
5484 | { | ||
5485 | YP.nl(); | ||
5486 | return; | ||
5487 | } | ||
5488 | goto cutIf3; | ||
5489 | } | ||
5490 | foreach (bool l5 in convertStatementListPython(Body, Level, HasBreakableBlock)) | ||
5491 | { | ||
5492 | YP.nl(); | ||
5493 | return; | ||
5494 | } | ||
5495 | cutIf3: | ||
5496 | { } | ||
5497 | } | ||
5498 | cutIf1: | ||
5499 | { } | ||
5500 | } | ||
5501 | } | ||
5502 | } | ||
5503 | } | ||
5504 | |||
5505 | public static bool hasBreakableBlockPython(object arg1) | ||
5506 | { | ||
5507 | { | ||
5508 | Variable _Name = new Variable(); | ||
5509 | Variable _Body = new Variable(); | ||
5510 | Variable _RestStatements = new Variable(); | ||
5511 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("breakableBlock", _Name, _Body), _RestStatements))) | ||
5512 | { | ||
5513 | return true; | ||
5514 | } | ||
5515 | } | ||
5516 | { | ||
5517 | Variable Body = new Variable(); | ||
5518 | Variable _RestStatements = new Variable(); | ||
5519 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("blockScope", Body), _RestStatements))) | ||
5520 | { | ||
5521 | if (hasBreakableBlockPython(Body)) | ||
5522 | { | ||
5523 | return true; | ||
5524 | } | ||
5525 | } | ||
5526 | } | ||
5527 | { | ||
5528 | Variable _Expression = new Variable(); | ||
5529 | Variable Body = new Variable(); | ||
5530 | Variable _RestStatements = new Variable(); | ||
5531 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("if", _Expression, Body), _RestStatements))) | ||
5532 | { | ||
5533 | if (hasBreakableBlockPython(Body)) | ||
5534 | { | ||
5535 | return true; | ||
5536 | } | ||
5537 | } | ||
5538 | } | ||
5539 | { | ||
5540 | Variable _Expression = new Variable(); | ||
5541 | Variable Body = new Variable(); | ||
5542 | Variable _RestStatements = new Variable(); | ||
5543 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("foreach", _Expression, Body), _RestStatements))) | ||
5544 | { | ||
5545 | if (hasBreakableBlockPython(Body)) | ||
5546 | { | ||
5547 | return true; | ||
5548 | } | ||
5549 | } | ||
5550 | } | ||
5551 | { | ||
5552 | Variable x1 = new Variable(); | ||
5553 | Variable RestStatements = new Variable(); | ||
5554 | foreach (bool l2 in YP.unify(arg1, new ListPair(x1, RestStatements))) | ||
5555 | { | ||
5556 | if (hasBreakableBlockPython(RestStatements)) | ||
5557 | { | ||
5558 | return true; | ||
5559 | } | ||
5560 | } | ||
5561 | } | ||
5562 | return false; | ||
5563 | } | ||
5564 | |||
5565 | public static IEnumerable<bool> convertStatementListPython(object arg1, object arg2, object arg3) | ||
5566 | { | ||
5567 | { | ||
5568 | object x1 = arg2; | ||
5569 | object x2 = arg3; | ||
5570 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
5571 | { | ||
5572 | yield return true; | ||
5573 | yield break; | ||
5574 | } | ||
5575 | } | ||
5576 | { | ||
5577 | object Level = arg2; | ||
5578 | object HasBreakableBlock = arg3; | ||
5579 | Variable Name = new Variable(); | ||
5580 | Variable Body = new Variable(); | ||
5581 | Variable RestStatements = new Variable(); | ||
5582 | Variable NextLevel = new Variable(); | ||
5583 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("breakableBlock", Name, Body), RestStatements))) | ||
5584 | { | ||
5585 | convertIndentationPython(Level); | ||
5586 | YP.write(Name); | ||
5587 | YP.write(Atom.a(" = False")); | ||
5588 | YP.nl(); | ||
5589 | convertIndentationPython(Level); | ||
5590 | YP.write(Atom.a("for _ in [1]:")); | ||
5591 | YP.nl(); | ||
5592 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5593 | { | ||
5594 | foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) | ||
5595 | { | ||
5596 | convertIndentationPython(Level); | ||
5597 | YP.write(Atom.a("if ")); | ||
5598 | YP.write(Name); | ||
5599 | YP.write(Atom.a(":")); | ||
5600 | YP.nl(); | ||
5601 | convertIndentationPython(NextLevel); | ||
5602 | YP.write(Atom.a("doBreak = False")); | ||
5603 | YP.nl(); | ||
5604 | convertIndentationPython(Level); | ||
5605 | YP.write(Atom.a("if doBreak:")); | ||
5606 | YP.nl(); | ||
5607 | convertIndentationPython(NextLevel); | ||
5608 | YP.write(Atom.a("break")); | ||
5609 | YP.nl(); | ||
5610 | foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5611 | { | ||
5612 | yield return true; | ||
5613 | yield break; | ||
5614 | } | ||
5615 | } | ||
5616 | } | ||
5617 | } | ||
5618 | } | ||
5619 | { | ||
5620 | object Level = arg2; | ||
5621 | object HasBreakableBlock = arg3; | ||
5622 | Variable _Type = new Variable(); | ||
5623 | Variable Name = new Variable(); | ||
5624 | Variable Expression = new Variable(); | ||
5625 | Variable RestStatements = new Variable(); | ||
5626 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("declare", _Type, Name, Expression), RestStatements))) | ||
5627 | { | ||
5628 | convertIndentationPython(Level); | ||
5629 | YP.write(Name); | ||
5630 | YP.write(Atom.a(" = ")); | ||
5631 | convertExpressionPython(Expression); | ||
5632 | YP.nl(); | ||
5633 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5634 | { | ||
5635 | yield return true; | ||
5636 | yield break; | ||
5637 | } | ||
5638 | } | ||
5639 | } | ||
5640 | { | ||
5641 | object Level = arg2; | ||
5642 | object HasBreakableBlock = arg3; | ||
5643 | Variable Name = new Variable(); | ||
5644 | Variable Expression = new Variable(); | ||
5645 | Variable RestStatements = new Variable(); | ||
5646 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("assign", Name, Expression), RestStatements))) | ||
5647 | { | ||
5648 | convertIndentationPython(Level); | ||
5649 | YP.write(Name); | ||
5650 | YP.write(Atom.a(" = ")); | ||
5651 | convertExpressionPython(Expression); | ||
5652 | YP.nl(); | ||
5653 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5654 | { | ||
5655 | yield return true; | ||
5656 | yield break; | ||
5657 | } | ||
5658 | } | ||
5659 | } | ||
5660 | { | ||
5661 | object Level = arg2; | ||
5662 | object HasBreakableBlock = arg3; | ||
5663 | Variable RestStatements = new Variable(); | ||
5664 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldtrue"), RestStatements))) | ||
5665 | { | ||
5666 | convertIndentationPython(Level); | ||
5667 | YP.write(Atom.a("yield True")); | ||
5668 | YP.nl(); | ||
5669 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5670 | { | ||
5671 | yield return true; | ||
5672 | yield break; | ||
5673 | } | ||
5674 | } | ||
5675 | } | ||
5676 | { | ||
5677 | object Level = arg2; | ||
5678 | object HasBreakableBlock = arg3; | ||
5679 | Variable RestStatements = new Variable(); | ||
5680 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldfalse"), RestStatements))) | ||
5681 | { | ||
5682 | convertIndentationPython(Level); | ||
5683 | YP.write(Atom.a("yield False")); | ||
5684 | YP.nl(); | ||
5685 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5686 | { | ||
5687 | yield return true; | ||
5688 | yield break; | ||
5689 | } | ||
5690 | } | ||
5691 | } | ||
5692 | { | ||
5693 | object Level = arg2; | ||
5694 | object HasBreakableBlock = arg3; | ||
5695 | Variable RestStatements = new Variable(); | ||
5696 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("yieldbreak"), RestStatements))) | ||
5697 | { | ||
5698 | convertIndentationPython(Level); | ||
5699 | YP.write(Atom.a("return")); | ||
5700 | YP.nl(); | ||
5701 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5702 | { | ||
5703 | yield return true; | ||
5704 | yield break; | ||
5705 | } | ||
5706 | } | ||
5707 | } | ||
5708 | { | ||
5709 | object Level = arg2; | ||
5710 | object HasBreakableBlock = arg3; | ||
5711 | Variable RestStatements = new Variable(); | ||
5712 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("return"), RestStatements))) | ||
5713 | { | ||
5714 | convertIndentationPython(Level); | ||
5715 | YP.write(Atom.a("return")); | ||
5716 | YP.nl(); | ||
5717 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5718 | { | ||
5719 | yield return true; | ||
5720 | yield break; | ||
5721 | } | ||
5722 | } | ||
5723 | } | ||
5724 | { | ||
5725 | object Level = arg2; | ||
5726 | object HasBreakableBlock = arg3; | ||
5727 | Variable RestStatements = new Variable(); | ||
5728 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("returntrue"), RestStatements))) | ||
5729 | { | ||
5730 | convertIndentationPython(Level); | ||
5731 | YP.write(Atom.a("return True")); | ||
5732 | YP.nl(); | ||
5733 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5734 | { | ||
5735 | yield return true; | ||
5736 | yield break; | ||
5737 | } | ||
5738 | } | ||
5739 | } | ||
5740 | { | ||
5741 | object Level = arg2; | ||
5742 | object HasBreakableBlock = arg3; | ||
5743 | Variable RestStatements = new Variable(); | ||
5744 | foreach (bool l2 in YP.unify(arg1, new ListPair(Atom.a("returnfalse"), RestStatements))) | ||
5745 | { | ||
5746 | convertIndentationPython(Level); | ||
5747 | YP.write(Atom.a("return False")); | ||
5748 | YP.nl(); | ||
5749 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5750 | { | ||
5751 | yield return true; | ||
5752 | yield break; | ||
5753 | } | ||
5754 | } | ||
5755 | } | ||
5756 | { | ||
5757 | object Level = arg2; | ||
5758 | object HasBreakableBlock = arg3; | ||
5759 | Variable Name = new Variable(); | ||
5760 | Variable RestStatements = new Variable(); | ||
5761 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("breakBlock", Name), RestStatements))) | ||
5762 | { | ||
5763 | convertIndentationPython(Level); | ||
5764 | YP.write(Name); | ||
5765 | YP.write(Atom.a(" = True")); | ||
5766 | YP.nl(); | ||
5767 | convertIndentationPython(Level); | ||
5768 | YP.write(Atom.a("doBreak = True")); | ||
5769 | YP.nl(); | ||
5770 | convertIndentationPython(Level); | ||
5771 | YP.write(Atom.a("break")); | ||
5772 | YP.nl(); | ||
5773 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5774 | { | ||
5775 | yield return true; | ||
5776 | yield break; | ||
5777 | } | ||
5778 | } | ||
5779 | } | ||
5780 | { | ||
5781 | object Level = arg2; | ||
5782 | object HasBreakableBlock = arg3; | ||
5783 | Variable Name = new Variable(); | ||
5784 | Variable ArgList = new Variable(); | ||
5785 | Variable RestStatements = new Variable(); | ||
5786 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("call", Name, ArgList), RestStatements))) | ||
5787 | { | ||
5788 | convertIndentationPython(Level); | ||
5789 | YP.write(Name); | ||
5790 | YP.write(Atom.a("(")); | ||
5791 | convertArgListPython(ArgList); | ||
5792 | YP.write(Atom.a(")")); | ||
5793 | YP.nl(); | ||
5794 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5795 | { | ||
5796 | yield return true; | ||
5797 | yield break; | ||
5798 | } | ||
5799 | } | ||
5800 | } | ||
5801 | { | ||
5802 | object Level = arg2; | ||
5803 | object HasBreakableBlock = arg3; | ||
5804 | Variable Name = new Variable(); | ||
5805 | Variable _FunctorArgs = new Variable(); | ||
5806 | Variable ArgList = new Variable(); | ||
5807 | Variable RestStatements = new Variable(); | ||
5808 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("functorCall", Name, _FunctorArgs, ArgList), RestStatements))) | ||
5809 | { | ||
5810 | foreach (bool l3 in convertStatementListPython(new ListPair(new Functor2("call", Name, ArgList), RestStatements), Level, HasBreakableBlock)) | ||
5811 | { | ||
5812 | yield return true; | ||
5813 | yield break; | ||
5814 | } | ||
5815 | } | ||
5816 | } | ||
5817 | { | ||
5818 | object Level = arg2; | ||
5819 | object HasBreakableBlock = arg3; | ||
5820 | Variable Obj = new Variable(); | ||
5821 | Variable Name = new Variable(); | ||
5822 | Variable ArgList = new Variable(); | ||
5823 | Variable RestStatements = new Variable(); | ||
5824 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor3("callMember", new Functor1("var", Obj), Name, ArgList), RestStatements))) | ||
5825 | { | ||
5826 | convertIndentationPython(Level); | ||
5827 | YP.write(Obj); | ||
5828 | YP.write(Atom.a(".")); | ||
5829 | YP.write(Name); | ||
5830 | YP.write(Atom.a("(")); | ||
5831 | convertArgListPython(ArgList); | ||
5832 | YP.write(Atom.a(")")); | ||
5833 | YP.nl(); | ||
5834 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5835 | { | ||
5836 | yield return true; | ||
5837 | yield break; | ||
5838 | } | ||
5839 | } | ||
5840 | } | ||
5841 | { | ||
5842 | object Level = arg2; | ||
5843 | object HasBreakableBlock = arg3; | ||
5844 | Variable Body = new Variable(); | ||
5845 | Variable RestStatements = new Variable(); | ||
5846 | Variable NextLevel = new Variable(); | ||
5847 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("blockScope", Body), RestStatements))) | ||
5848 | { | ||
5849 | if (YP.termEqual(HasBreakableBlock, 1)) | ||
5850 | { | ||
5851 | convertIndentationPython(Level); | ||
5852 | YP.write(Atom.a("for _ in [1]:")); | ||
5853 | YP.nl(); | ||
5854 | foreach (bool l4 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5855 | { | ||
5856 | foreach (bool l5 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) | ||
5857 | { | ||
5858 | if (YP.termEqual(HasBreakableBlock, 1)) | ||
5859 | { | ||
5860 | if (YP.greaterThan(Level, 1)) | ||
5861 | { | ||
5862 | convertIndentationPython(Level); | ||
5863 | YP.write(Atom.a("if doBreak:")); | ||
5864 | YP.nl(); | ||
5865 | convertIndentationPython(NextLevel); | ||
5866 | YP.write(Atom.a("break")); | ||
5867 | YP.nl(); | ||
5868 | foreach (bool l8 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5869 | { | ||
5870 | yield return true; | ||
5871 | yield break; | ||
5872 | } | ||
5873 | goto cutIf3; | ||
5874 | } | ||
5875 | foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5876 | { | ||
5877 | yield return true; | ||
5878 | yield break; | ||
5879 | } | ||
5880 | cutIf3: | ||
5881 | goto cutIf2; | ||
5882 | } | ||
5883 | foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5884 | { | ||
5885 | yield return true; | ||
5886 | yield break; | ||
5887 | } | ||
5888 | cutIf2: | ||
5889 | { } | ||
5890 | } | ||
5891 | } | ||
5892 | goto cutIf1; | ||
5893 | } | ||
5894 | foreach (bool l3 in YP.unify(NextLevel, Level)) | ||
5895 | { | ||
5896 | foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) | ||
5897 | { | ||
5898 | if (YP.termEqual(HasBreakableBlock, 1)) | ||
5899 | { | ||
5900 | if (YP.greaterThan(Level, 1)) | ||
5901 | { | ||
5902 | convertIndentationPython(Level); | ||
5903 | YP.write(Atom.a("if doBreak:")); | ||
5904 | YP.nl(); | ||
5905 | convertIndentationPython(NextLevel); | ||
5906 | YP.write(Atom.a("break")); | ||
5907 | YP.nl(); | ||
5908 | foreach (bool l7 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5909 | { | ||
5910 | yield return true; | ||
5911 | yield break; | ||
5912 | } | ||
5913 | goto cutIf5; | ||
5914 | } | ||
5915 | foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5916 | { | ||
5917 | yield return true; | ||
5918 | yield break; | ||
5919 | } | ||
5920 | cutIf5: | ||
5921 | goto cutIf4; | ||
5922 | } | ||
5923 | foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5924 | { | ||
5925 | yield return true; | ||
5926 | yield break; | ||
5927 | } | ||
5928 | cutIf4: | ||
5929 | { } | ||
5930 | } | ||
5931 | } | ||
5932 | cutIf1: | ||
5933 | { } | ||
5934 | } | ||
5935 | } | ||
5936 | { | ||
5937 | object Level = arg2; | ||
5938 | object HasBreakableBlock = arg3; | ||
5939 | Variable Expression = new Variable(); | ||
5940 | Variable Body = new Variable(); | ||
5941 | Variable RestStatements = new Variable(); | ||
5942 | Variable NextLevel = new Variable(); | ||
5943 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("if", Expression, Body), RestStatements))) | ||
5944 | { | ||
5945 | convertIndentationPython(Level); | ||
5946 | YP.write(Atom.a("if ")); | ||
5947 | convertExpressionPython(Expression); | ||
5948 | YP.write(Atom.a(":")); | ||
5949 | YP.nl(); | ||
5950 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5951 | { | ||
5952 | foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) | ||
5953 | { | ||
5954 | foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5955 | { | ||
5956 | yield return true; | ||
5957 | yield break; | ||
5958 | } | ||
5959 | } | ||
5960 | } | ||
5961 | } | ||
5962 | } | ||
5963 | { | ||
5964 | object Level = arg2; | ||
5965 | object HasBreakableBlock = arg3; | ||
5966 | Variable Expression = new Variable(); | ||
5967 | Variable Body = new Variable(); | ||
5968 | Variable RestStatements = new Variable(); | ||
5969 | Variable NextLevel = new Variable(); | ||
5970 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor2("foreach", Expression, Body), RestStatements))) | ||
5971 | { | ||
5972 | convertIndentationPython(Level); | ||
5973 | YP.write(Atom.a("for l")); | ||
5974 | YP.write(Level); | ||
5975 | YP.write(Atom.a(" in ")); | ||
5976 | convertExpressionPython(Expression); | ||
5977 | YP.write(Atom.a(":")); | ||
5978 | YP.nl(); | ||
5979 | foreach (bool l3 in YP.unify(NextLevel, YP.add(Level, 1))) | ||
5980 | { | ||
5981 | foreach (bool l4 in convertStatementListPython(Body, NextLevel, HasBreakableBlock)) | ||
5982 | { | ||
5983 | if (YP.termEqual(HasBreakableBlock, 1)) | ||
5984 | { | ||
5985 | convertIndentationPython(Level); | ||
5986 | YP.write(Atom.a("if doBreak:")); | ||
5987 | YP.nl(); | ||
5988 | convertIndentationPython(NextLevel); | ||
5989 | YP.write(Atom.a("break")); | ||
5990 | YP.nl(); | ||
5991 | foreach (bool l6 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5992 | { | ||
5993 | yield return true; | ||
5994 | yield break; | ||
5995 | } | ||
5996 | goto cutIf6; | ||
5997 | } | ||
5998 | foreach (bool l5 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
5999 | { | ||
6000 | yield return true; | ||
6001 | yield break; | ||
6002 | } | ||
6003 | cutIf6: | ||
6004 | { } | ||
6005 | } | ||
6006 | } | ||
6007 | } | ||
6008 | } | ||
6009 | { | ||
6010 | object Level = arg2; | ||
6011 | object HasBreakableBlock = arg3; | ||
6012 | Variable Expression = new Variable(); | ||
6013 | Variable RestStatements = new Variable(); | ||
6014 | foreach (bool l2 in YP.unify(arg1, new ListPair(new Functor1("throw", Expression), RestStatements))) | ||
6015 | { | ||
6016 | convertIndentationPython(Level); | ||
6017 | YP.write(Atom.a("raise ")); | ||
6018 | convertExpressionPython(Expression); | ||
6019 | YP.nl(); | ||
6020 | foreach (bool l3 in convertStatementListPython(RestStatements, Level, HasBreakableBlock)) | ||
6021 | { | ||
6022 | yield return true; | ||
6023 | yield break; | ||
6024 | } | ||
6025 | } | ||
6026 | } | ||
6027 | } | ||
6028 | |||
6029 | public static void convertIndentationPython(object Level) | ||
6030 | { | ||
6031 | { | ||
6032 | Variable N = new Variable(); | ||
6033 | foreach (bool l2 in YP.unify(N, YP.multiply(Level, 2))) | ||
6034 | { | ||
6035 | repeatWrite(Atom.a(" "), N); | ||
6036 | return; | ||
6037 | } | ||
6038 | } | ||
6039 | } | ||
6040 | |||
6041 | public static void convertArgListPython(object arg1) | ||
6042 | { | ||
6043 | { | ||
6044 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
6045 | { | ||
6046 | return; | ||
6047 | } | ||
6048 | } | ||
6049 | { | ||
6050 | Variable Head = new Variable(); | ||
6051 | Variable Tail = new Variable(); | ||
6052 | foreach (bool l2 in YP.unify(arg1, new ListPair(Head, Tail))) | ||
6053 | { | ||
6054 | convertExpressionPython(Head); | ||
6055 | if (YP.termNotEqual(Tail, Atom.NIL)) | ||
6056 | { | ||
6057 | YP.write(Atom.a(", ")); | ||
6058 | convertArgListPython(Tail); | ||
6059 | return; | ||
6060 | goto cutIf1; | ||
6061 | } | ||
6062 | convertArgListPython(Tail); | ||
6063 | return; | ||
6064 | cutIf1: | ||
6065 | { } | ||
6066 | } | ||
6067 | } | ||
6068 | } | ||
6069 | |||
6070 | public static void convertExpressionPython(object arg1) | ||
6071 | { | ||
6072 | { | ||
6073 | Variable X = new Variable(); | ||
6074 | foreach (bool l2 in YP.unify(arg1, new Functor1("arg", X))) | ||
6075 | { | ||
6076 | YP.write(X); | ||
6077 | return; | ||
6078 | } | ||
6079 | } | ||
6080 | { | ||
6081 | Variable Name = new Variable(); | ||
6082 | Variable ArgList = new Variable(); | ||
6083 | foreach (bool l2 in YP.unify(arg1, new Functor2("call", Name, ArgList))) | ||
6084 | { | ||
6085 | YP.write(Name); | ||
6086 | YP.write(Atom.a("(")); | ||
6087 | convertArgListPython(ArgList); | ||
6088 | YP.write(Atom.a(")")); | ||
6089 | return; | ||
6090 | } | ||
6091 | } | ||
6092 | { | ||
6093 | Variable Name = new Variable(); | ||
6094 | Variable _FunctorArgs = new Variable(); | ||
6095 | Variable ArgList = new Variable(); | ||
6096 | foreach (bool l2 in YP.unify(arg1, new Functor3("functorCall", Name, _FunctorArgs, ArgList))) | ||
6097 | { | ||
6098 | convertExpressionPython(new Functor2("call", Name, ArgList)); | ||
6099 | return; | ||
6100 | } | ||
6101 | } | ||
6102 | { | ||
6103 | Variable Obj = new Variable(); | ||
6104 | Variable Name = new Variable(); | ||
6105 | Variable ArgList = new Variable(); | ||
6106 | foreach (bool l2 in YP.unify(arg1, new Functor3("callMember", new Functor1("var", Obj), Name, ArgList))) | ||
6107 | { | ||
6108 | YP.write(Obj); | ||
6109 | YP.write(Atom.a(".")); | ||
6110 | YP.write(Name); | ||
6111 | YP.write(Atom.a("(")); | ||
6112 | convertArgListPython(ArgList); | ||
6113 | YP.write(Atom.a(")")); | ||
6114 | return; | ||
6115 | } | ||
6116 | } | ||
6117 | { | ||
6118 | Variable Name = new Variable(); | ||
6119 | Variable ArgList = new Variable(); | ||
6120 | foreach (bool l2 in YP.unify(arg1, new Functor2("new", Name, ArgList))) | ||
6121 | { | ||
6122 | YP.write(Name); | ||
6123 | YP.write(Atom.a("(")); | ||
6124 | convertArgListPython(ArgList); | ||
6125 | YP.write(Atom.a(")")); | ||
6126 | return; | ||
6127 | } | ||
6128 | } | ||
6129 | { | ||
6130 | Variable Name = new Variable(); | ||
6131 | foreach (bool l2 in YP.unify(arg1, new Functor1("var", Name))) | ||
6132 | { | ||
6133 | YP.write(Name); | ||
6134 | return; | ||
6135 | } | ||
6136 | } | ||
6137 | { | ||
6138 | foreach (bool l2 in YP.unify(arg1, Atom.a("null"))) | ||
6139 | { | ||
6140 | YP.write(Atom.a("None")); | ||
6141 | return; | ||
6142 | } | ||
6143 | } | ||
6144 | { | ||
6145 | Variable X = new Variable(); | ||
6146 | foreach (bool l2 in YP.unify(arg1, new Functor1("not", X))) | ||
6147 | { | ||
6148 | YP.write(Atom.a("not (")); | ||
6149 | convertExpressionPython(X); | ||
6150 | YP.write(Atom.a(")")); | ||
6151 | return; | ||
6152 | } | ||
6153 | } | ||
6154 | { | ||
6155 | Variable X = new Variable(); | ||
6156 | Variable Y = new Variable(); | ||
6157 | foreach (bool l2 in YP.unify(arg1, new Functor2("and", X, Y))) | ||
6158 | { | ||
6159 | YP.write(Atom.a("(")); | ||
6160 | convertExpressionPython(X); | ||
6161 | YP.write(Atom.a(") and (")); | ||
6162 | convertExpressionPython(Y); | ||
6163 | YP.write(Atom.a(")")); | ||
6164 | return; | ||
6165 | } | ||
6166 | } | ||
6167 | { | ||
6168 | Variable ArgList = new Variable(); | ||
6169 | foreach (bool l2 in YP.unify(arg1, new Functor1("objectArray", ArgList))) | ||
6170 | { | ||
6171 | YP.write(Atom.a("[")); | ||
6172 | convertArgListPython(ArgList); | ||
6173 | YP.write(Atom.a("]")); | ||
6174 | return; | ||
6175 | } | ||
6176 | } | ||
6177 | { | ||
6178 | Variable X = new Variable(); | ||
6179 | Variable Codes = new Variable(); | ||
6180 | foreach (bool l2 in YP.unify(arg1, new Functor1("object", X))) | ||
6181 | { | ||
6182 | if (YP.atom(X)) | ||
6183 | { | ||
6184 | YP.write(Atom.a("\"")); | ||
6185 | foreach (bool l4 in YP.atom_codes(X, Codes)) | ||
6186 | { | ||
6187 | convertStringCodesPython(Codes); | ||
6188 | YP.write(Atom.a("\"")); | ||
6189 | return; | ||
6190 | } | ||
6191 | } | ||
6192 | } | ||
6193 | } | ||
6194 | { | ||
6195 | Variable X = new Variable(); | ||
6196 | foreach (bool l2 in YP.unify(arg1, new Functor1("object", X))) | ||
6197 | { | ||
6198 | YP.write(X); | ||
6199 | return; | ||
6200 | } | ||
6201 | } | ||
6202 | } | ||
6203 | |||
6204 | public static void convertStringCodesPython(object arg1) | ||
6205 | { | ||
6206 | { | ||
6207 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
6208 | { | ||
6209 | return; | ||
6210 | } | ||
6211 | } | ||
6212 | { | ||
6213 | Variable Code = new Variable(); | ||
6214 | Variable RestCodes = new Variable(); | ||
6215 | foreach (bool l2 in YP.unify(arg1, new ListPair(Code, RestCodes))) | ||
6216 | { | ||
6217 | if (YP.termEqual(Code, 34)) | ||
6218 | { | ||
6219 | YP.put_code(92); | ||
6220 | YP.put_code(Code); | ||
6221 | convertStringCodesPython(RestCodes); | ||
6222 | return; | ||
6223 | goto cutIf1; | ||
6224 | } | ||
6225 | if (YP.termEqual(Code, 92)) | ||
6226 | { | ||
6227 | YP.put_code(92); | ||
6228 | YP.put_code(Code); | ||
6229 | convertStringCodesPython(RestCodes); | ||
6230 | return; | ||
6231 | goto cutIf1; | ||
6232 | } | ||
6233 | YP.put_code(Code); | ||
6234 | convertStringCodesPython(RestCodes); | ||
6235 | return; | ||
6236 | cutIf1: | ||
6237 | { } | ||
6238 | } | ||
6239 | } | ||
6240 | } | ||
6241 | |||
6242 | public static IEnumerable<bool> putCStringCode(object Code) | ||
6243 | { | ||
6244 | { | ||
6245 | Variable HexDigit = new Variable(); | ||
6246 | Variable HexChar = new Variable(); | ||
6247 | if (YP.lessThanOrEqual(Code, 31)) | ||
6248 | { | ||
6249 | if (YP.lessThanOrEqual(Code, 15)) | ||
6250 | { | ||
6251 | YP.write(Atom.a("\\u000")); | ||
6252 | foreach (bool l4 in YP.unify(HexDigit, Code)) | ||
6253 | { | ||
6254 | if (YP.lessThanOrEqual(HexDigit, 9)) | ||
6255 | { | ||
6256 | foreach (bool l6 in YP.unify(HexChar, YP.add(HexDigit, 48))) | ||
6257 | { | ||
6258 | YP.put_code(HexChar); | ||
6259 | yield return true; | ||
6260 | yield break; | ||
6261 | } | ||
6262 | goto cutIf2; | ||
6263 | } | ||
6264 | foreach (bool l5 in YP.unify(HexChar, YP.add(HexDigit, 55))) | ||
6265 | { | ||
6266 | YP.put_code(HexChar); | ||
6267 | yield return true; | ||
6268 | yield break; | ||
6269 | } | ||
6270 | cutIf2: | ||
6271 | { } | ||
6272 | } | ||
6273 | goto cutIf1; | ||
6274 | } | ||
6275 | YP.write(Atom.a("\\u001")); | ||
6276 | foreach (bool l3 in YP.unify(HexDigit, YP.subtract(Code, 16))) | ||
6277 | { | ||
6278 | if (YP.lessThanOrEqual(HexDigit, 9)) | ||
6279 | { | ||
6280 | foreach (bool l5 in YP.unify(HexChar, YP.add(HexDigit, 48))) | ||
6281 | { | ||
6282 | YP.put_code(HexChar); | ||
6283 | yield return true; | ||
6284 | yield break; | ||
6285 | } | ||
6286 | goto cutIf3; | ||
6287 | } | ||
6288 | foreach (bool l4 in YP.unify(HexChar, YP.add(HexDigit, 55))) | ||
6289 | { | ||
6290 | YP.put_code(HexChar); | ||
6291 | yield return true; | ||
6292 | yield break; | ||
6293 | } | ||
6294 | cutIf3: | ||
6295 | { } | ||
6296 | } | ||
6297 | cutIf1: | ||
6298 | { } | ||
6299 | } | ||
6300 | } | ||
6301 | { | ||
6302 | if (YP.termEqual(Code, 34)) | ||
6303 | { | ||
6304 | YP.put_code(92); | ||
6305 | YP.put_code(34); | ||
6306 | yield return true; | ||
6307 | yield break; | ||
6308 | } | ||
6309 | } | ||
6310 | { | ||
6311 | if (YP.termEqual(Code, 92)) | ||
6312 | { | ||
6313 | YP.put_code(92); | ||
6314 | YP.put_code(92); | ||
6315 | yield return true; | ||
6316 | yield break; | ||
6317 | } | ||
6318 | } | ||
6319 | { | ||
6320 | YP.put_code(Code); | ||
6321 | yield return true; | ||
6322 | yield break; | ||
6323 | } | ||
6324 | } | ||
6325 | |||
6326 | public static IEnumerable<bool> member(object X, object arg2) | ||
6327 | { | ||
6328 | { | ||
6329 | Variable x2 = new Variable(); | ||
6330 | foreach (bool l2 in YP.unify(arg2, new ListPair(X, x2))) | ||
6331 | { | ||
6332 | yield return false; | ||
6333 | } | ||
6334 | } | ||
6335 | { | ||
6336 | Variable x2 = new Variable(); | ||
6337 | Variable Rest = new Variable(); | ||
6338 | foreach (bool l2 in YP.unify(arg2, new ListPair(x2, Rest))) | ||
6339 | { | ||
6340 | foreach (bool l3 in member(X, Rest)) | ||
6341 | { | ||
6342 | yield return false; | ||
6343 | } | ||
6344 | } | ||
6345 | } | ||
6346 | } | ||
6347 | |||
6348 | public static IEnumerable<bool> append(object arg1, object arg2, object arg3) | ||
6349 | { | ||
6350 | { | ||
6351 | Variable List = new Variable(); | ||
6352 | foreach (bool l2 in YP.unify(arg1, Atom.NIL)) | ||
6353 | { | ||
6354 | foreach (bool l3 in YP.unify(arg2, List)) | ||
6355 | { | ||
6356 | foreach (bool l4 in YP.unify(arg3, List)) | ||
6357 | { | ||
6358 | yield return false; | ||
6359 | } | ||
6360 | } | ||
6361 | } | ||
6362 | } | ||
6363 | { | ||
6364 | object List2 = arg2; | ||
6365 | Variable X = new Variable(); | ||
6366 | Variable List1 = new Variable(); | ||
6367 | Variable List12 = new Variable(); | ||
6368 | foreach (bool l2 in YP.unify(arg1, new ListPair(X, List1))) | ||
6369 | { | ||
6370 | foreach (bool l3 in YP.unify(arg3, new ListPair(X, List12))) | ||
6371 | { | ||
6372 | foreach (bool l4 in append(List1, List2, List12)) | ||
6373 | { | ||
6374 | yield return false; | ||
6375 | } | ||
6376 | } | ||
6377 | } | ||
6378 | } | ||
6379 | } | ||
6380 | #pragma warning restore 0168, 0219, 0164,0162 | ||
6381 | } | ||
6382 | } | ||