aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs')
-rw-r--r--OpenSim/Region/ScriptEngine/Shared/Api/Runtime/YieldProlog/Parser.cs4575
1 files changed, 0 insertions, 4575 deletions
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
31using System;
32using 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
38namespace 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}