API tools faq
paste
Advertisement
logicmoo

cls ; swipl block_tagbody.pl

logicmoo
Oct 31st, 2017
641
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Prolog 55.29 KB | None | 0 0
raw download clone embed print report
  1. root@gitlab:/home/dmiles/logicmoo_workspace/packs_usr/wam_common_lisp/prolog/wam_cl# cls ; swipl block_tagbody.pl
  2. Installed packages (38):
  3.  
  4. i clause_attvars@1.1.118    - An alternate interface to the clause database to allow attributed variables to be asserted
  5. i dictoo@1.1.118            - Dict-like OO Syntax
  6. i each_call_cleanup@1.1.118 - Each Call Redo Setup and Cleanup
  7. i eggdrop@1.1.118           - Hook up to an existing IRC Client called an Eggdrop
  8. i file_scope@1.1.118        - File local scoped efects
  9. i fluxplayer-prolog-engine@0.0.1 - Prolog interface to Slack http://www.slack.com
  10. i gvar_syntax@1.1.118       - Global Variable Syntax
  11. i hook_hybrid@1.1.118       - Hook assert retract call of *specific* predicates
  12. i instant_prolog_docs@1.1.118 - Magically document prolog source files based on predicate and variable naming conventions
  13. i lib_atts@1.1.118          - Common atts.pl interface like https://sicstus.sics.se/sicstus/docs/4.0.0/html/sicstus/lib_002datts.html
  14. i logicmoo_base@1.1.118     - LogicMOO - Extends Prolog Programming to support Dynamic Epistemic Logic (DEL) with Constraints
  15. i logicmoo_experimental@1.1.118 - Various experimental packages - warning: HUGE amount of test data
  16. i logicmoo_nlu@1.1.114      - Various English to Logic Convertors - warning: HUGE amount of test data
  17. i logicmoo_packages@1.1.118 - Various packages - warning: HUGE amount of test data
  18. i logicmoo_planner@1.1.118  - Various PDDLish planners - warning: HUGE amount of test data
  19. i logicmoo_planners@1.1.118 - Various Hybrid HTN Planners speaking PDDLish and OCLh
  20. i logicmoo_utils@1.1.118    - Common predicates used by external Logicmoo Utils and Base
  21. i loop_check@1.1.118        - New simple loop checking
  22. i mpi@1.0                   - Porting of the LAMMPI library of Yap Prolog to SWI-Prolog
  23. i multimodal_dcg@1.1.118    - Reduce floundering of DCGs by constraining and narrowing search
  24. i multivar@1.1.118          - User defined datatypes
  25. i must_trace@1.1.118        - Trace with your eyeballs instead of your fingers
  26. i no_repeats@1.1.118        - New ways to avoid duplicate solutions
  27. i pfc@1.1.118               - Pfc -- a package for forward chaining in Prolog
  28. i predicate_streams@1.1.118 - Implement your own Abstract Predicate Streams
  29. i prologmud@1.1.118         - Online text adventure game - MUD Server
  30. i prologmud_samples@1.1.118 - Online text adventure game - Sample
  31. i s_expression@1.1.118      - Utilities for Handling of S-Expression Lisp/Scheme-Like forms and parsing of KIF, GDL, PDDL, CLIF
  32. i slack_prolog@1.1.118      - Prolog interface to Slack http://www.slack.com
  33. i subclause_expansion@1.1.118 - More use specific versions of term/goal expansion hooks
  34. i tabling_dra@1.1.118       - SWI-Prolog interface to Table-handling procedures for the "dra" interpreter. Written by Feliks Kluzniak at UTD (March 2009)
  35. i transpiler@0.1            - A universal translator for programming languages
  36. i trill@4.1.0               - A tableau probabilistic reasoner in three different versions
  37. i wam_common_lisp@1.1.118   - ANSI Common Lisp implemented in Prolog
  38. i with_open_options@1.1.118 - Utilities to open various objects for read/write
  39. i with_thread_local@1.1.118 - Call a Goal with local assertions
  40. i xlisting@1.1.118          - Selective Interactive Non-Deterministic Tracing
  41. i xlisting_web@1.1.118      - Manipulate and browse prolog runtime over www
  42. index(zip/3,[1,2,3])
  43. index(zip_with/4,[1,2,4])
  44. optimize(zip/3)
  45. optimize(zip_with/4)
  46.  
  47.  
  48. /*
  49. :- ( second(l)<<==first(rest(l))
  50.    ).
  51. */
  52. /*
  53. second(L_In, First_Ret) :- !,
  54.         Env=[[bv(l, [L_In|__])]],
  55.         sym_arg_val_env(l, L_In, L_Thru, Env),
  56.         rest(L_Thru, Rest_Ret),
  57.         first(Rest_Ret, First_Ret).
  58. */
  59. /*
  60. second(L_In, First_Ret) :-
  61.         fail,
  62.         ( [second, l]<<==[first, [rest, l]]
  63.         ).
  64. */
  65.  
  66.  
  67. /*
  68. :- ( third(l)<<==first(rest(rest(l)))
  69.    ).
  70. */
  71. /*
  72. third(L_In, First_Ret) :- !,
  73.         Env=[[bv(l, [L_In|__])]],
  74.         sym_arg_val_env(l, L_In, L_Thru, Env),
  75.         rest(L_Thru, Rest_Ret),
  76.         rest(Rest_Ret, Rest_Ret7),
  77.         first(Rest_Ret7, First_Ret).
  78. */
  79. /*
  80. third(L_In, First_Ret) :-
  81.         fail,
  82.         ( [third, l]<<==[first, [rest, [rest, l]]]
  83.         ).
  84. */
  85.  
  86.  
  87. /*
  88. :- ( list_1(a)<<==cons(a, nil)
  89.    ).
  90. */
  91. /*
  92. list_1(A_In, RET) :- !,
  93.         Env=[[bv(a, [A_In|__])]],
  94.         sym_arg_val_env(a, A_In, A_Thru, Env),
  95.         RET=[A_Thru].
  96. */
  97. /*
  98. list_1(A_In, RET) :-
  99.         fail,
  100.         ( [list_1, a]<<==[cons, a, nil]
  101.         ).
  102. */
  103.  
  104.  
  105. /*
  106. :- ( list_2(a, b)<<==cons(a, list_1(b))
  107.    ).
  108. */
  109. /*
  110. list_2(A_In, B_In, RET) :- !,
  111.         Env=[[bv(a, [A_In|__]), bv(b, [B_In|__9])]],
  112.         sym_arg_val_env(a, A_In, A_Thru, Env),
  113.         sym_arg_val_env(b, B_In, B_Thru, Env),
  114.         list_1(B_Thru, List_1_Ret),
  115.         RET=[A_Thru|List_1_Ret].
  116. */
  117. /*
  118. list_2(A_In, B_In, RET) :-
  119.         fail,
  120.         ( [list_2, a, b]<<==[cons, a, [list_1, b]]
  121.         ).
  122. */
  123.  
  124.  
  125. /*
  126. :- ( list_3(a, b, c)<<==cons(a, list_2(b, c))
  127.    ).
  128. */
  129. /*
  130. list_3(A_In, B_In, C_In, RET) :- !,
  131.         Env=[[bv(a, [A_In|__]), bv(b, [B_In|__10]), bv(c, [C_In|__13])]],
  132.         sym_arg_val_env(a, A_In, A_Thru, Env),
  133.         sym_arg_val_env(b, B_In, B_Thru, Env),
  134.         sym_arg_val_env(c, C_In, C_Thru, Env),
  135.         list_2(B_Thru, C_Thru, List_2_Ret),
  136.         RET=[A_Thru|List_2_Ret].
  137. */
  138. /*
  139. list_3(A_In, B_In, C_In, RET) :-
  140.         fail,
  141.         ( [list_3, a, b, c]<<==[cons, a, [list_2, b, c]]
  142.         ).
  143. */
  144.  
  145.  
  146. /*
  147. :- ( lisp_append(l1, l2)<<==if(null(l1), l2, cons(first(l1), lisp_append(rest(l1), l2)))
  148.    ).
  149. */
  150. /*
  151. lisp_append(L1_In13, L2_In16, RET) :- !,
  152.         Env=[[bv(l1, [L1_In13|__]), bv(l2, [L2_In16|__9])]],
  153.         sym_arg_val_env(l1, L1_In13, L1_Thru, Env),
  154.         (   L1_Thru==[]
  155.         ->  sym_arg_val_env(l2, L2_In16, L2_Thru, Env),
  156.             RET=L2_Thru
  157.         ;   symbol_value(l1, Env, L1_Thru11),
  158.             first(L1_Thru11, First_Ret),
  159.             symbol_value(l1, Env, L1_Thru14),
  160.             rest(L1_Thru14, Rest_Ret),
  161.             symbol_value(l2, Env, L2_Thru17),
  162.             lisp_append(Rest_Ret, L2_Thru17, Lisp_append_Ret),
  163.             _1830=[First_Ret|Lisp_append_Ret],
  164.             RET=_1830
  165.         ).
  166. */
  167. /*
  168. lisp_append(L1_In13, L2_In16, RET) :-
  169.         fail,
  170.         ( [lisp_append, l1, l2]<<==[if, [null, l1], l2, [cons, [first, l1], [lisp_append, [rest, l1], l2]]]
  171.         ).
  172. */
  173.  
  174.  
  175. /*
  176. :- ( mapcar(func, l)<<==if(null(l), nil, cons(lisp_apply(func, list_1(first(l))), mapcar(func, rest(l))))
  177.    ).
  178. */
  179. /*
  180. mapcar(Func_In15, L_In18, RET) :- !,
  181.         Env=[[bv(func, [Func_In15|__9]), bv(l, [L_In18|__])]],
  182.         sym_arg_val_env(l, L_In18, L_Thru, Env),
  183.         (   L_Thru==[]
  184.         ->  RET=[]
  185.         ;   sym_arg_val_env(func, Func_In15, Func_Thru, Env),
  186.             symbol_value(l, Env, L_Thru11),
  187.             first(L_Thru11, First_Ret),
  188.             list_1(First_Ret, List_1_Ret),
  189.             lisp_apply(Func_Thru, List_1_Ret, Lisp_apply_Ret),
  190.             symbol_value(func, Env, Func_Thru16),
  191.             symbol_value(l, Env, L_Thru19),
  192.             rest(L_Thru19, Rest_Ret),
  193.             mapcar(Func_Thru16, Rest_Ret, Mapcar_Ret),
  194.             _1836=[Lisp_apply_Ret|Mapcar_Ret],
  195.             RET=_1836
  196.         ).
  197. */
  198. /*
  199. mapcar(Func_In15, L_In18, RET) :-
  200.         fail,
  201.         ( [mapcar, func, l]<<==[if, [null, l], nil, [cons, [lisp_apply, func, [list_1, [first, l]]], [mapcar, func, [rest, l]]]]
  202.         ).
  203. */
  204.  
  205.  
  206. /*
  207. :- ( stream_first(stream)<<==first(stream)
  208.    ).
  209. */
  210. /*
  211. stream_first(Stream_In, First_Ret) :- !,
  212.         Env=[[bv(stream, [Stream_In|__])]],
  213.         sym_arg_val_env(stream, Stream_In, Stream_Thru, Env),
  214.         first(Stream_Thru, First_Ret).
  215. */
  216. /*
  217. stream_first(Stream_In, First_Ret) :-
  218.         fail,
  219.         ( [stream_first, stream]<<==[first, stream]
  220.         ).
  221. */
  222.  
  223.  
  224. /*
  225. :- ( stream_rest(stream)<<==lisp_apply(second(stream), [])
  226.    ).
  227. */
  228. /*
  229. stream_rest(Stream_In, Lisp_apply_Ret) :- !,
  230.         Env=[[bv(stream, [Stream_In|__])]],
  231.         sym_arg_val_env(stream, Stream_In, Stream_Thru, Env),
  232.         second(Stream_Thru, Second_Ret),
  233.         lisp_apply(Second_Ret, [], Lisp_apply_Ret).
  234. */
  235. /*
  236. stream_rest(Stream_In, Lisp_apply_Ret) :-
  237.         fail,
  238.         ( [stream_rest, stream]<<==[lisp_apply, [second, stream], []]
  239.         ).
  240. */
  241.  
  242.  
  243. /*
  244. :- ( stream_cons(a, b)<<==list_2(a, b)
  245.    ).
  246. */
  247. /*
  248. stream_cons(A_In, B_In, List_2_Ret) :- !,
  249.         Env=[[bv(a, [A_In|__]), bv(b, [B_In|__9])]],
  250.         sym_arg_val_env(a, A_In, A_Thru, Env),
  251.         sym_arg_val_env(b, B_In, B_Thru, Env),
  252.         list_2(A_Thru, B_Thru, List_2_Ret).
  253. */
  254. /*
  255. stream_cons(A_In, B_In, List_2_Ret) :-
  256.         fail,
  257.         ( [stream_cons, a, b]<<==[list_2, a, b]
  258.         ).
  259. */
  260.  
  261.  
  262. /*
  263. :- ( stream_null(stream)<<==null(stream)
  264.    ).
  265. */
  266. /*
  267. stream_null(Stream_In, Null_Ret) :- !,
  268.         Env=[[bv(stream, [Stream_In|__])]],
  269.         sym_arg_val_env(stream, Stream_In, Stream_Thru, Env),
  270.         null(Stream_Thru, Null_Ret).
  271. */
  272. /*
  273. stream_null(Stream_In, Null_Ret) :-
  274.         fail,
  275.         ( [stream_null, stream]<<==[null, stream]
  276.         ).
  277. */
  278.  
  279.  
  280. /*
  281. :- ( stream_take(n, stream)<<==if(or(equalp(n, 0), stream_null(stream)), [], cons(stream_first(stream), stream_take(minus(n, 1), stream_rest(stream))))
  282.    ).
  283. */
  284. /*
  285. stream_take(N_In17, Stream_In20, RET) :- !,
  286.         Env=[[bv(n, [N_In17|__]), bv(stream, [Stream_In20|__10])]],
  287.         sym_arg_val_env(n, N_In17, N_Thru, Env),
  288.         equalp(N_Thru, 0, Equalp_Ret),
  289.         sym_arg_val_env(stream, Stream_In20, Stream_Thru, Env),
  290.         stream_null(Stream_Thru, Stream_null_Ret),
  291.         or(Equalp_Ret, Stream_null_Ret, Or_Ret),
  292.         (   Or_Ret\=[]
  293.         ->  RET=[]
  294.         ;   symbol_value(stream, Env, Stream_Thru14),
  295.             stream_first(Stream_Thru14, Stream_first_Ret),
  296.             symbol_value(n, Env, N_Thru18),
  297.             minus(N_Thru18, 1, Minus_Ret),
  298.             symbol_value(stream, Env, Stream_Thru21),
  299.             stream_rest(Stream_Thru21, Stream_rest_Ret),
  300.             stream_take(Minus_Ret, Stream_rest_Ret, Stream_take_Ret),
  301.             _1980=[Stream_first_Ret|Stream_take_Ret],
  302.             RET=_1980
  303.         ).
  304. */
  305. /*
  306. stream_take(N_In17, Stream_In20, RET) :-
  307.         fail,
  308.         ( [stream_take, n, stream]<<==[if, [or, [equalp, n, 0], [stream_null, stream]], [], [cons, [stream_first, stream], [stream_take, [minus, n, 1], [stream_rest, stream]]]]
  309.         ).
  310. */
  311.  
  312.  
  313. /*
  314. :- ( stream_drop(n, stream)<<==if(or(equalp(n, 0), stream_null(stream)), stream, stream_drop(minus(n, 1), stream_rest(stream)))
  315.    ).
  316. */
  317. /*
  318. stream_drop(N_In16, Stream_In19, RET) :- !,
  319.         Env=[[bv(n, [N_In16|__]), bv(stream, [Stream_In19|__10])]],
  320.         sym_arg_val_env(n, N_In16, N_Thru, Env),
  321.         equalp(N_Thru, 0, Equalp_Ret),
  322.         sym_arg_val_env(stream, Stream_In19, Stream_Thru, Env),
  323.         stream_null(Stream_Thru, Stream_null_Ret),
  324.         or(Equalp_Ret, Stream_null_Ret, Or_Ret),
  325.         (   Or_Ret\=[]
  326.         ->  symbol_value(stream, Env, Stream_Thru14),
  327.             RET=Stream_Thru14
  328.         ;   symbol_value(n, Env, N_Thru17),
  329.             minus(N_Thru17, 1, Minus_Ret),
  330.             symbol_value(stream, Env, Stream_Thru20),
  331.             stream_rest(Stream_Thru20, Stream_rest_Ret),
  332.             stream_drop(Minus_Ret, Stream_rest_Ret, Stream_drop_Ret),
  333.             RET=Stream_drop_Ret
  334.         ).
  335. */
  336. /*
  337. stream_drop(N_In16, Stream_In19, RET) :-
  338.         fail,
  339.         ( [stream_drop, n, stream]<<==[if, [or, [equalp, n, 0], [stream_null, stream]], stream, [stream_drop, [minus, n, 1], [stream_rest, stream]]]
  340.         ).
  341. */
  342.  
  343.  
  344. /*
  345. :- ( stream_interval(low, high)<<==if(equalp(low, high), [], stream_cons(low, function(lambda([], stream_interval(plus(low, 1), high)))))
  346.    ).
  347. */
  348. /*
  349. stream_interval(Low_In13, High_In16, RET) :- !,
  350.         Env=[[bv(low, [Low_In13|__]), bv(high, [High_In16|__9])]],
  351.         sym_arg_val_env(low, Low_In13, Low_Thru, Env),
  352.         sym_arg_val_env(high, High_In16, High_Thru, Env),
  353.         equalp(Low_Thru, High_Thru, Equalp_Ret),
  354.         (   Equalp_Ret\=[]
  355.         ->  RET=[]
  356.         ;   symbol_value(low, Env, Low_Thru12),
  357.             stream_cons(Low_Thru12,
  358.  
  359.                         [ closure,
  360.                           [],
  361.                           [LEnv, Stream_interval_Ret]^(symbol_value(low, LEnv, Low_Thru14), plus(Low_Thru14, 1, Plus_Ret), symbol_value(high, LEnv, High_Thru17), stream_interval(Plus_Ret, High_Thru17, Stream_interval_Ret)),
  362.                           Env
  363.                         ],
  364.                         Stream_cons_Ret),
  365.             RET=Stream_cons_Ret
  366.         ).
  367. */
  368. /*
  369. stream_interval(Low_In13, High_In16, RET) :-
  370.         fail,
  371.         ( [stream_interval, low, high]<<==[if, [equalp, low, high], [], [stream_cons, low, [function, [lambda, [], [stream_interval, [plus, low, 1], high]]]]]
  372.         ).
  373. */
  374.  
  375.  
  376. /*
  377. :- ( stream_ints_from(n)<<==stream_cons(n, function(lambda([], stream_ints_from(plus(n, 1)))))
  378.    ).
  379. */
  380. /*
  381. stream_ints_from(N_In6, Stream_cons_Ret) :- !,
  382.         Env=[[bv(n, [N_In6|__])]],
  383.         sym_arg_val_env(n, N_In6, N_Thru, Env),
  384.         stream_cons(N_Thru,
  385.  
  386.                     [ closure,
  387.                       [],
  388.                       [LEnv, Stream_ints_from_Ret]^(symbol_value(n, LEnv, N_Thru7), plus(N_Thru7, 1, Plus_Ret), stream_ints_from(Plus_Ret, Stream_ints_from_Ret)),
  389.                       Env
  390.                     ],
  391.                     Stream_cons_Ret).
  392. */
  393. /*
  394. stream_ints_from(N_In6, Stream_cons_Ret) :-
  395.         fail,
  396.         ( [stream_ints_from, n]<<==[stream_cons, n, [function, [lambda, [], [stream_ints_from, [plus, n, 1]]]]]
  397.         ).
  398. */
  399.  
  400.  
  401. /*
  402. :- ( t1<<==stream_take(3, stream_interval(1, 5))
  403.    ).
  404. */
  405. /*
  406. t1(Stream_take_Ret) :- !,
  407.         Env=[[]],
  408.         stream_interval(1, 5, Stream_interval_Ret),
  409.         stream_take(3, Stream_interval_Ret, Stream_take_Ret).
  410. */
  411. /*
  412. t1(Stream_take_Ret) :-
  413.         fail,
  414.         ( t1<<==[stream_take, 3, [stream_interval, 1, 5]]
  415.         ).
  416. */
  417.  
  418.  
  419. /*
  420. :- ( t2<<==stream_take(5, stream_drop(10, stream_ints_from(1)))
  421.    ).
  422. */
  423. /*
  424. t2(Stream_take_Ret) :- !,
  425.         Env=[[]],
  426.         stream_ints_from(1, Stream_ints_from_Ret),
  427.         stream_drop(10, Stream_ints_from_Ret, Stream_drop_Ret),
  428.         stream_take(5, Stream_drop_Ret, Stream_take_Ret).
  429. */
  430. /*
  431. t2(Stream_take_Ret) :-
  432.         fail,
  433.         ( t2<<==[stream_take, 5, [stream_drop, 10, [stream_ints_from, 1]]]
  434.         ).
  435. */
  436.  
  437.  
  438. /*
  439. :- ( simple(x)<<==x
  440.    ).
  441. */
  442. /*
  443. simple(X_In, X_Thru) :- !,
  444.         Env=[[bv(x, [X_In|__])]],
  445.         sym_arg_val_env(x, X_In, X_Thru, Env).
  446. */
  447. /*
  448. simple(X_In, X_Thru) :-
  449.         fail,
  450.         ( [simple, x]<<==x
  451.         ).
  452. */
  453.  
  454.  
  455. /*
  456. :- ( lisp_append_2(l1, l2)<<==cond([[null(l1), l2], [t, cons(first(l1), lisp_append_2(rest(l1), l2))]])
  457.    ).
  458. */
  459. /*
  460. lisp_append_2(L1_In14, L2_In17, RET) :- !,
  461.         Env=[[bv(l1, [L1_In14|__]), bv(l2, [L2_In17|__10])]],
  462.         sym_arg_val_env(l1, L1_In14, L1_Thru, Env),
  463.         null(L1_Thru, Null_Ret),
  464.         (   Null_Ret\=[]
  465.         ->  sym_arg_val_env(l2, L2_In17, L2_Thru, Env),
  466.             RET=L2_Thru
  467.         ;   (   t\=[]
  468.             ->  symbol_value(l1, Env, L1_Thru12),
  469.                 first(L1_Thru12, First_Ret),
  470.                 symbol_value(l1, Env, L1_Thru15),
  471.                 rest(L1_Thru15, Rest_Ret),
  472.                 symbol_value(l2, Env, L2_Thru18),
  473.                 lisp_append_2(Rest_Ret, L2_Thru18, Lisp_append_2_Ret),
  474.                 _2190=[First_Ret|Lisp_append_2_Ret],
  475.                 _2174=_2190
  476.             ;   _2174=[]
  477.             ),
  478.             RET=_2174
  479.         ).
  480. */
  481. /*
  482. lisp_append_2(L1_In14, L2_In17, RET) :-
  483.         fail,
  484.         ( [lisp_append_2, l1, l2]<<==[cond, [[[null, l1], l2], [t, [cons, [first, l1], [lisp_append_2, [rest, l1], l2]]]]]
  485.         ).
  486. */
  487.  
  488.  
  489. /*
  490. :- ( lisp_error(x)<<==setq(y, 5)
  491.    ).
  492. */
  493. /*
  494. lisp_error(X, 5) :- !,
  495.         Env=[[bv(x, [X|_2986])]],
  496.         symbol_setter(setq, y, 5, Env).
  497. */
  498. /*
  499. lisp_error(X, 5) :-
  500.         fail,
  501.         ( [lisp_error, x]<<==[setq, y, 5]
  502.         ).
  503. */
  504.  
  505.  
  506. /*
  507. :- ( lisp_let()<<==let([bind(x, 3), bind(y, 5)], progn(x, y))
  508.    ).
  509. */
  510. /*
  511. lisp_let(Y_Thru) :- !,
  512.         Env=[[]],
  513.         LETENV=[[bv(x, [3|_4278]), bv(y, [5|_4358])]|Env],
  514.         sym_arg_val_env(x, X_In, X_Thru, LETENV),
  515.         sym_arg_val_env(y, Y_In, Y_Thru, LETENV).
  516. */
  517. /*
  518. lisp_let(Y_Thru) :-
  519.         fail,
  520.         ( [lisp_let]<<==[let, [[bind, x, 3], [bind, y, 5]], [progn, x, y]]
  521.         ).
  522. */
  523.  
  524.  
  525. /*
  526. :- ( lisp_let1()<<==let([bind(x, 3), bind(y, 5)], x, y)
  527.    ).
  528. */
  529. /*
  530. lisp_let1(Y_Thru) :- !,
  531.         Env=[[]],
  532.         LETENV=[[bv(x, [3|_10774]), bv(y, [5|_10854])]|Env],
  533.         sym_arg_val_env(x, X_In, X_Thru, LETENV),
  534.         sym_arg_val_env(y, Y_In, Y_Thru, LETENV).
  535. */
  536. /*
  537. lisp_let1(Y_Thru) :-
  538.         fail,
  539.         ( [lisp_let1]<<==[let, [[bind, x, 3], [bind, y, 5]], x, y]
  540.         ).
  541. */
  542.  
  543.  
  544. /*
  545. :- ( mapfirst(l)<<==mapcar(function(first), l)
  546.    ).
  547. */
  548. /*
  549. mapfirst(L_In, Mapcar_Ret) :- !,
  550.         Env=[[bv(l, [L_In|__])]],
  551.         sym_arg_val_env(l, L_In, L_Thru, Env),
  552.         mapcar([function, first], L_Thru, Mapcar_Ret).
  553. */
  554. /*
  555. mapfirst(L_In, Mapcar_Ret) :-
  556.         fail,
  557.         ( [mapfirst, l]<<==[mapcar, [function, first], l]
  558.         ).
  559. */
  560.  
  561.  
  562. /*
  563. :- ( <<==defvar(fred, 13)
  564.    ).
  565. */
  566. /*
  567. :- symbol_setter(defvar, fred, 13, toplevel).
  568. */
  569.  
  570.  
  571. /*
  572. :- ( <<==defvar(george)
  573.    ).
  574. */
  575. /*
  576. :- symbol_setter(defvar, george, [], toplevel).
  577. */
  578.  
  579.  
  580. /*
  581. :- ( reset_george(val)<<==setq(george, val)
  582.    ).
  583. */
  584. /*
  585. reset_george(Val_In, Val_Thru) :- !,
  586.         Env=[[bv(val, [Val_In|__])]],
  587.         sym_arg_val_env(val, Val_In, Val_Thru, Env),
  588.         symbol_setter(setq, george, Val_Thru, Env).
  589. */
  590. /*
  591. reset_george(Val_In, Val_Thru) :-
  592.         fail,
  593.         ( [reset_george, val]<<==[setq, george, val]
  594.         ).
  595. */
  596.  
  597.  
  598. /*
  599. :- ( make_adder(x)<<==function(lambda([y], plus(x, y)))
  600.    ).
  601. */
  602. /*
  603. make_adder(X_In, [closure, [y], [LEnv, Plus_Ret]^(((sym_arg_val_env(x, X_In, avar(X_Thru, att(initState, t, [])), LEnv), sym_arg_val_env(y, avar(Y_In, att(initState, t, [])), avar(Y_Thru, att(initState, t, [])), LEnv), true), plus(avar(X_Thru, att(initState, t, [])), avar(Y_Thru, att(initState, t, [])), Plus_Ret)), true), Env]) :- !,
  604.         Env=[[bv(x, [X_In|__])]].
  605. */
  606. /*
  607. make_adder(X_In, [closure, [y], [LEnv, Plus_Ret]^(((sym_arg_val_env(x, X_In, avar(X_Thru, att(initState, t, [])), LEnv), sym_arg_val_env(y, avar(Y_In, att(initState, t, [])), avar(Y_Thru, att(initState, t, [])), LEnv), true), plus(avar(X_Thru, att(initState, t, [])), avar(Y_Thru, att(initState, t, [])), Plus_Ret)), true), Env]) :-
  608.         fail,
  609.         ( [make_adder, x]<<==[function, [lambda, [y], [plus, x, y]]]
  610.         ).
  611. */
  612.  
  613.  
  614. /*
  615. :- ( scale_list(xs, scale)<<==let([bind(fred, function(lambda([num], times(scale, num))))], mapcar(fred, xs))
  616.    ).
  617. */
  618. /*
  619. scale_list(Xs_In, Scale_In, Mapcar_Ret) :- !,
  620.         Env=[[bv(xs, [Xs_In|__18]), bv(scale, [Scale_In|__])]],
  621.         LETENV=[[bv(fred, [[closure, [num], [LEnv, Times_Ret]^(sym_arg_val_env(scale, Scale_In, Scale_Thru, LEnv), sym_arg_val_env(num, Num_In, Num_Thru, LEnv), times(Scale_Thru, Num_Thru, Times_Ret)), Env]|_1890])]|Env],
  622.         sym_arg_val_env(fred, Fred_In, Fred_Thru, LETENV),
  623.         sym_arg_val_env(xs, Xs_In, Xs_Thru, LETENV),
  624.         mapcar(Fred_Thru, Xs_Thru, Mapcar_Ret).
  625. */
  626. /*
  627. scale_list(Xs_In, Scale_In, Mapcar_Ret) :-
  628.         fail,
  629.         ( [scale_list, xs, scale]<<==[let, [[bind, fred, [function, [lambda, [num], [times, scale, num]]]]], [mapcar, fred, xs]]
  630.         ).
  631. */
  632.  
  633.  
  634. /*
  635. :- ( make_summer(total)<<==function(lambda([n], setq(total, plus(total, n))))
  636.    ).
  637. */
  638. /*
  639. make_summer(Total_In, [closure, [n], [LEnv, Plus_Ret]^((((sym_arg_val_env(total, Total_In, avar(Total_Thru, att(initState, t, [])), LEnv), sym_arg_val_env(n, avar(N_In, att(initState, t, [])), avar(N_Thru, att(initState, t, [])), LEnv), true), plus(avar(Total_Thru, att(initState, t, [])), avar(N_Thru, att(initState, t, [])), Plus_Ret)), symbol_setter(setq, total, Plus_Ret, LEnv)), true), Env]) :- !,
  640.         Env=[[bv(total, [Total_In|__])]].
  641. */
  642. /*
  643. make_summer(Total_In, [closure, [n], [LEnv, Plus_Ret]^((((sym_arg_val_env(total, Total_In, avar(Total_Thru, att(initState, t, [])), LEnv), sym_arg_val_env(n, avar(N_In, att(initState, t, [])), avar(N_Thru, att(initState, t, [])), LEnv), true), plus(avar(Total_Thru, att(initState, t, [])), avar(N_Thru, att(initState, t, [])), Plus_Ret)), symbol_setter(setq, total, Plus_Ret, LEnv)), true), Env]) :-
  644.         fail,
  645.         ( [make_summer, total]<<==[function, [lambda, [n], [setq, total, [plus, total, n]]]]
  646.         ).
  647. */
  648.  
  649.  
  650. /*
  651. :- ( sum_with_map(xs)<<==let([bind(running_total, 0)], let([bind(summer, function(lambda([n], setq(running_total, plus(running_total, n)))))], mapcar(summer, xs), running_total))
  652.    ).
  653. */
  654. /*
  655. sum_with_map(Xs_In, Running_total_Thru21) :- !,
  656.         Env=[[bv(xs, [Xs_In|__])]],
  657.         LETENV=[[bv(running_total, [0|_2046])]|Env],
  658.         LETENV13=[[bv(summer, [[closure, [n], [LEnv, Plus_Ret]^(sym_arg_val_env(running_total, Running_total_In, Running_total_Thru, LEnv), sym_arg_val_env(n, N_In, N_Thru, LEnv), plus(Running_total_Thru, N_Thru, Plus_Ret), symbol_setter(setq, running_total, Plus_Ret, LEnv)), LETENV]|_2460])]|LETENV],
  659.         sym_arg_val_env(summer, Summer_In, Summer_Thru, LETENV13),
  660.         sym_arg_val_env(xs, Xs_In, Xs_Thru, LETENV13),
  661.         mapcar(Summer_Thru, Xs_Thru, Mapcar_Ret),
  662.         sym_arg_val_env(running_total,
  663.                         Running_total_In20,
  664.                         Running_total_Thru21,
  665.                         LETENV13).
  666. */
  667. /*
  668. sum_with_map(Xs_In, Running_total_Thru21) :-
  669.         fail,
  670.         ( [sum_with_map, xs]<<==[let, [[bind, running_total, 0]], [let, [[bind, summer, [function, [lambda, [n], [setq, running_total, [plus, running_total, n]]]]]], [mapcar, summer, xs], running_total]]
  671.         ).
  672. */
  673.  
  674.  
  675. /*
  676. :- fact==lambda([n], if(n=0, 1, n*fact(sub1(n)))).
  677. */
  678. /*
  679. fact(N_In9, RET) :- !,
  680.         Env=[[bv(n, [N_In9|__])]],
  681.         sym_arg_val_env(n, N_In9, N_Thru, Env),
  682.         =(N_Thru, 0, Vv_c61__Ret),
  683.         (   Vv_c61__Ret\=[]
  684.         ->  RET=1
  685.         ;   symbol_value(n, Env, N_Thru8),
  686.             symbol_value(n, Env, N_Thru10),
  687.             sub1(N_Thru10, Sub1_Ret),
  688.             fact(Sub1_Ret, Fact_Ret),
  689.             mult(N_Thru8, Fact_Ret, Mult_Ret),
  690.             RET=Mult_Ret
  691.         ).
  692. */
  693. /*
  694. fact(N_In9, RET) :-
  695.         fail,
  696.         ( [fact, n]<<==[if, [=, n, 0], 1, [*, n, [fact, [sub1, n]]]]
  697.         ).
  698. */
  699.  
  700.  
  701. /*
  702. :- add1==lambda([n], n+1).
  703. */
  704. /*
  705. add1(N_In, Plus_Ret) :- !,
  706.         Env=[[bv(n, [N_In|__])]],
  707.         sym_arg_val_env(n, N_In, N_Thru, Env),
  708.         plus(N_Thru, 1, Plus_Ret).
  709. */
  710. /*
  711. add1(N_In, Plus_Ret) :-
  712.         fail,
  713.         ( [add1, n]<<==[+, n, 1]
  714.         ).
  715. */
  716.  
  717.  
  718. /*
  719. :- sub1==lambda([n], n-1).
  720. */
  721. /*
  722. sub1(N_In, Minus_Ret) :- !,
  723.         Env=[[bv(n, [N_In|__])]],
  724.         sym_arg_val_env(n, N_In, N_Thru, Env),
  725.         minus(N_Thru, 1, Minus_Ret).
  726. */
  727. /*
  728. sub1(N_In, Minus_Ret) :-
  729.         fail,
  730.         ( [sub1, n]<<==[-, n, 1]
  731.         ).
  732. */
  733.  
  734.  
  735. /*
  736. :- mapcar==lambda([fun, l], if(null(l), nil, cons(fun(car(l)), mapcar(fun, cdr(l))))).
  737. */
  738. /*
  739. mapcar1(Fun_In14, L_In17, RET) :- !,
  740.         Env=[[bv(fun, [Fun_In14|__9]), bv(l, [L_In17|__])]],
  741.         sym_arg_val_env(l, L_In17, L_Thru, Env),
  742.         (   L_Thru==[]
  743.         ->  RET=[]
  744.         ;   sym_arg_val_env(fun, Fun_In14, Fun_Thru, Env),
  745.             symbol_value(l, Env, L_Thru11),
  746.             car(L_Thru11, Car_Ret),
  747.             funcall(Fun_Thru, Car_Ret, Funcall_Ret),
  748.             symbol_value(fun, Env, Fun_Thru15),
  749.             symbol_value(l, Env, L_Thru18),
  750.             cdr(L_Thru18, Cdr_Ret),
  751.             mapcar1(Fun_Thru15, Cdr_Ret, Mapcar1_Ret),
  752.             _1792=[Funcall_Ret|Mapcar1_Ret],
  753.             RET=_1792
  754.         ).
  755. */
  756. /*
  757. mapcar1(Fun_In14, L_In17, RET) :-
  758.         fail,
  759.         ( [mapcar1, fun, l]<<==[if, [null, l], nil, [cons, [fun, [car, l]], [mapcar1, fun, [cdr, l]]]]
  760.         ).
  761. */
  762.  
  763.  
  764. /*
  765. :- length==lambda([l], if(null(l), 0, add1(length(cdr(l))))).
  766. */
  767. /*
  768. length1(L_In6, RET) :- !,
  769.         Env=[[bv(l, [L_In6|__])]],
  770.         sym_arg_val_env(l, L_In6, L_Thru, Env),
  771.         (   L_Thru==[]
  772.         ->  RET=0
  773.         ;   symbol_value(l, Env, L_Thru7),
  774.             cdr(L_Thru7, Cdr_Ret),
  775.             length1(Cdr_Ret, Length1_Ret),
  776.             add1(Length1_Ret, Add1_Ret),
  777.             RET=Add1_Ret
  778.         ).
  779. */
  780. /*
  781. length1(L_In6, RET) :-
  782.         fail,
  783.         ( [length1, l]<<==[if, [null, l], 0, [add1, [length1, [cdr, l]]]]
  784.         ).
  785. */
  786.  
  787.  
  788. /*
  789. :- append==lambda([l1, l2], if(null(l1), l2, cons(car(l1), append(cdr(l1), l2)))).
  790. */
  791. /*
  792. append1(L1_In13, L2_In16, RET) :- !,
  793.         Env=[[bv(l1, [L1_In13|__]), bv(l2, [L2_In16|__9])]],
  794.         sym_arg_val_env(l1, L1_In13, L1_Thru, Env),
  795.         (   L1_Thru==[]
  796.         ->  sym_arg_val_env(l2, L2_In16, L2_Thru, Env),
  797.             RET=L2_Thru
  798.         ;   symbol_value(l1, Env, L1_Thru11),
  799.             car(L1_Thru11, Car_Ret),
  800.             symbol_value(l1, Env, L1_Thru14),
  801.             cdr(L1_Thru14, Cdr_Ret),
  802.             symbol_value(l2, Env, L2_Thru17),
  803.             append1(Cdr_Ret, L2_Thru17, Append1_Ret),
  804.             _1830=[Car_Ret|Append1_Ret],
  805.             RET=_1830
  806.         ).
  807. */
  808. /*
  809. append1(L1_In13, L2_In16, RET) :-
  810.         fail,
  811.         ( [append1, l1, l2]<<==[if, [null, l1], l2, [cons, [car, l1], [append1, [cdr, l1], l2]]]
  812.         ).
  813. */
  814.  
  815.  
  816. /*
  817. :- filter==lambda([fun, s], if('emptyStream?'(s), s, if(fun(head(s)), consStream(head(s), filter(fun, tail(s))), filter(fun, tail(s))))).
  818. */
  819. /*
  820. filter1(Fun_In28, S_In30, RET) :- !,
  821.         Env=[[bv(fun, [Fun_In28|__12]), bv(s, [S_In30|__])]],
  822.         sym_arg_val_env(s, S_In30, S_Thru, Env),
  823.         'emptyStream?'(S_Thru, EmptyStream_c63__Ret),
  824.         (   EmptyStream_c63__Ret\=[]
  825.         ->  symbol_value(s, Env, S_Thru9),
  826.             RET=S_Thru9
  827.         ;   sym_arg_val_env(fun, Fun_In28, Fun_Thru, Env),
  828.             symbol_value(s, Env, S_Thru14),
  829.             head(S_Thru14, Head_Ret),
  830.             funcall(Fun_Thru, Head_Ret, Funcall_Ret),
  831.             (   Funcall_Ret\=[]
  832.             ->  symbol_value(s, Env, S_Thru18),
  833.                 head(S_Thru18, Head_Ret19),
  834.                 symbol_value(fun, Env, Fun_Thru21),
  835.                 symbol_value(s, Env, S_Thru24),
  836.                 tail(S_Thru24, Tail_Ret),
  837.                 filter1(Fun_Thru21, Tail_Ret, Filter1_Ret),
  838.                 consStream(Head_Ret19, Filter1_Ret, ConsStream_Ret),
  839.                 _1782=ConsStream_Ret
  840.             ;   symbol_value(fun, Env, Fun_Thru29),
  841.                 symbol_value(s, Env, S_Thru31),
  842.                 tail(S_Thru31, Tail_Ret32),
  843.                 filter1(Fun_Thru29, Tail_Ret32, Filter1_Ret33),
  844.                 _1782=Filter1_Ret33
  845.             ),
  846.             RET=_1782
  847.         ).
  848. */
  849. /*
  850. filter1(Fun_In28, S_In30, RET) :-
  851.         fail,
  852.         ( [filter1, fun, s]<<==[if, ['emptyStream?', s], s, [if, [fun, [head, s]], [consStream, [head, s], [filter1, fun, [tail, s]]], [filter1, fun, [tail, s]]]]
  853.         ).
  854. */
  855.  
  856.  
  857. /*
  858. :- ( from(n)<<==consStream(n, from(n+1))
  859.    ).
  860. */
  861. /*
  862. from(N_In6, ConsStream_Ret) :- !,
  863.         Env=[[bv(n, [N_In6|__])]],
  864.         sym_arg_val_env(n, N_In6, N_Thru, Env),
  865.         symbol_value(n, Env, N_Thru7),
  866.         plus(N_Thru7, 1, Plus_Ret),
  867.         from(Plus_Ret, From_Ret),
  868.         consStream(N_Thru, From_Ret, ConsStream_Ret).
  869. */
  870. /*
  871. from(N_In6, ConsStream_Ret) :-
  872.         fail,
  873.         ( [from, n]<<==[consStream, n, [from, [+, n, 1]]]
  874.         ).
  875. */
  876.  
  877.  
  878. /*
  879. :- nthStream==lambda([s, n], if(n=1, head(s), nthStream(tail(s), n-1))).
  880. */
  881. /*
  882. nthStream(S_In12, N_In16, RET) :- !,
  883.         Env=[[bv(s, [S_In12|__10]), bv(n, [N_In16|__])]],
  884.         sym_arg_val_env(n, N_In16, N_Thru, Env),
  885.         =(N_Thru, 1, Vv_c61__Ret),
  886.         (   Vv_c61__Ret\=[]
  887.         ->  sym_arg_val_env(s, S_In12, S_Thru, Env),
  888.             head(S_Thru, Head_Ret),
  889.             RET=Head_Ret
  890.         ;   symbol_value(s, Env, S_Thru13),
  891.             tail(S_Thru13, Tail_Ret),
  892.             symbol_value(n, Env, N_Thru17),
  893.             minus(N_Thru17, 1, Minus_Ret),
  894.             nthStream(Tail_Ret, Minus_Ret, NthStream_Ret),
  895.             RET=NthStream_Ret
  896.         ).
  897. */
  898. /*
  899. nthStream(S_In12, N_In16, RET) :-
  900.         fail,
  901.         ( [nthStream, s, n]<<==[if, [=, n, 1], [head, s], [nthStream, [tail, s], [-, n, 1]]]
  902.         ).
  903. */
  904.  
  905.  
  906. /*
  907. :- integers==from(1).
  908. */
  909. /*
  910. :- ssip_define(integers, from(1)).
  911. */
  912.  
  913.  
  914. /*
  915. :- makeCounter==lambda([], begin(counter==0, lambda([], setq(counter, 1+counter)))).
  916. */
  917. /*
  918. makeCounter(Begin_Ret) :- !,
  919.         Env=[[]],
  920.         sym_arg_val_env(counter, Counter_In, Counter_Thru, Env),
  921.         ==(Counter_Thru, 0, Vv_c61__c61__Ret),
  922.         begin(Vv_c61__c61__Ret,
  923.  
  924.               [ closure,
  925.                 [],
  926.                 [LEnv, Plus_Ret]^(sym_arg_val_env(counter, Counter_In5, Counter_Thru6, LEnv), plus(1, Counter_Thru6, Plus_Ret), symbol_setter(setq, counter, Plus_Ret, LEnv)),
  927.                 Env
  928.               ],
  929.               Begin_Ret).
  930. */
  931. /*
  932. makeCounter(Begin_Ret) :-
  933.         fail,
  934.         ( makeCounter<<==[begin, [==, counter, 0], [lambda, [], [setq, counter, [+, 1, counter]]]]
  935.         ).
  936. */
  937.  
  938.  
  939. /*
  940. :- caaaar==lambda([x], car(car(car(car(x))))).
  941. */
  942. /*
  943. caaaar(X_In, Car_Ret9) :- !,
  944.         Env=[[bv(x, [X_In|__])]],
  945.         sym_arg_val_env(x, X_In, X_Thru, Env),
  946.         car(X_Thru, Car_Ret),
  947.         car(Car_Ret, Car_Ret7),
  948.         car(Car_Ret7, Car_Ret8),
  949.         car(Car_Ret8, Car_Ret9).
  950. */
  951. /*
  952. caaaar(X_In, Car_Ret9) :-
  953.         fail,
  954.         ( [caaaar, x]<<==[car, [car, [car, [car, x]]]]
  955.         ).
  956. */
  957.  
  958.  
  959. /*
  960. :- caar==lambda([x], car(car(x))).
  961. */
  962. /*
  963. caar(X_In, Car_Ret7) :- !,
  964.         Env=[[bv(x, [X_In|__])]],
  965.         sym_arg_val_env(x, X_In, X_Thru, Env),
  966.         car(X_Thru, Car_Ret),
  967.         car(Car_Ret, Car_Ret7).
  968. */
  969. /*
  970. caar(X_In, Car_Ret7) :-
  971.         fail,
  972.         ( [caar, x]<<==[car, [car, x]]
  973.         ).
  974. */
  975.  
  976.  
  977. /*
  978. :- reverse==lambda([l], if(null(l), l, append(reverse(cdr(l)), cons(car(l), nil)))).
  979. */
  980. /*
  981. reverse1(L_In12, RET) :- !,
  982.         Env=[[bv(l, [L_In12|__])]],
  983.         sym_arg_val_env(l, L_In12, L_Thru, Env),
  984.         (   L_Thru==[]
  985.         ->  symbol_value(l, Env, L_Thru7),
  986.             RET=L_Thru7
  987.         ;   symbol_value(l, Env, L_Thru9),
  988.             cdr(L_Thru9, Cdr_Ret),
  989.             reverse1(Cdr_Ret, Reverse1_Ret),
  990.             symbol_value(l, Env, L_Thru13),
  991.             car(L_Thru13, Car_Ret),
  992.             _7460=[Car_Ret],
  993.             append(Reverse1_Ret, _7460, Append_Ret),
  994.             RET=Append_Ret
  995.         ).
  996. */
  997. /*
  998. reverse1(L_In12, RET) :-
  999.         fail,
  1000.         ( [reverse1, l]<<==[if, [null, l], l, [append, [reverse1, [cdr, l]], [cons, [car, l], nil]]]
  1001.         ).
  1002. */
  1003. Warning: /home/dmiles/logicmoo_workspace/packs_usr/wam_common_lisp/prolog/wam_cl/block_tagbody.pl:497:
  1004.         Singleton variables: [Temp_one_In,Temp_two_In,Temp_one_In13,Temp_one_In17,Temp_two_In20]
  1005. Welcome to WAM-CL!
  1006. This is a miniscule Lisp interpreter, written in Prolog
  1007. >
  1008. > prolog
  1009. ?- compile_test(X,Y,Z,Q),dbmsg(Y),call(Y),dbmsg(Y).
  1010. /*
  1011. :- lisp_compiled_eval(
  1012.                       [ let,
  1013.                         [b],
  1014.  
  1015.                         [ tagbody,
  1016.                           [setq, b, 2],
  1017.                           [go, tag2],
  1018.                           [setq, a, 1],
  1019.                           tag1,
  1020.                           [setq, b, 3],
  1021.                           [go, tag3],
  1022.                           tag2,
  1023.                           [setq, a, 4],
  1024.                           [go, tag1],
  1025.                           tag3,
  1026.                           [print, ['1+', [plus, a, b]]]
  1027.                         ],
  1028.                         b
  1029.                       ]).
  1030. */
  1031. ( let ( b ) ( tagbody ( setq b 2 ) ( go tag2 ) ( setq a 1 ) tag1 ( setq b 3 ) ( go tag3 ) tag2 ( setq a 4 ) ( go tag1 ) tag3 ( print ( 1+ ( plus a b ) ) ) ) b )
  1032. /*
  1033. :- GoEnvLETENV=[[bv(b, [[]|_238])]|toplevel],
  1034.    call_addr_block(GoEnvLETENV,
  1035.                    (symbol_setter(setq, b, 2, GoEnvLETENV), goto(tag2, [], GoEnvLETENV)),
  1036.  
  1037.                    [ addr(tag1,
  1038.                           '$used',
  1039.                           _600,
  1040.                           (symbol_setter(setq, b, 3, _600), goto(tag3, [], _600))),
  1041.                      addr(tag2,
  1042.                           '$used',
  1043.                           _604,
  1044.                           (symbol_setter(setq, a, 4, _604), goto(tag1, [], _604))),
  1045.                      addr(tag3,
  1046.                           '$used',
  1047.                           _616,
  1048.                           (sym_arg_val_env(a, _618, _620, _616), sym_arg_val_env(b, _622, _624, _616), plus(_620, _624, _626), '1+'(_626, _628), print(_628, _632)))
  1049.                    ],
  1050.                    _GORES18),
  1051.    sym_arg_val_env(b, B_In20, B_Thru21, GoEnvLETENV).
  1052. */
  1053. 8
  1054. /*
  1055. :- [[bv(b, [2|_238])]|toplevel]=[[bv(b, [2|_238])]|toplevel],
  1056.    call_addr_block([[bv(b, [2|_238])]|toplevel],
  1057.                    (symbol_setter(setq, b, 2, [[bv(b, [2|_238])]|toplevel]), goto(tag2, [], [[bv(b, [2|_238])]|toplevel])),
  1058.  
  1059.                    [ addr(tag1,
  1060.                           '$used',
  1061.                           _600,
  1062.                           (symbol_setter(setq, b, 3, _600), goto(tag3, [], _600))),
  1063.                      addr(tag2,
  1064.                           '$used',
  1065.                           _604,
  1066.                           (symbol_setter(setq, a, 4, _604), goto(tag1, [], _604))),
  1067.                      addr(tag3,
  1068.                           '$used',
  1069.                           _616,
  1070.                           (sym_arg_val_env(a, _618, _620, _616), sym_arg_val_env(b, _622, _624, _616), plus(_620, _624, _626), '1+'(_626, _628), print(_628, _632)))
  1071.                    ],
  1072.                    []),
  1073.    sym_arg_val_env(b, 2, 2, [[bv(b, [2|_238])]|toplevel]).
  1074. */
  1075. X = tagbody_let3,
  1076. Y =  ([[bv(b, [2|_238])]|toplevel]=[[bv(b, [2|_238])]|toplevel], call_addr_block([[bv(b, [2|_238])]|toplevel],  (symbol_setter(setq, b, 2, [[bv(b, [2|...])]|toplevel]), goto(tag2, [], [[bv(b, [2|...])]|toplevel])), [addr(tag1, '$used', _600,  (symbol_setter(setq, b, 3, _600), goto(tag3, [], _600))), addr(tag2, '$used', _604,  (symbol_setter(setq, a, 4, _604), goto(tag1, [], _604))), addr(tag3, '$used', _616,  (sym_arg_val_env(a, _618, _620, _616), sym_arg_val_env(..., ..., ..., ...), ..., ...))], []), sym_arg_val_env(b, 2, 2, [[bv(b, [2|_238])]|toplevel])),
  1077. Z = 2,
  1078. Q = 3 ;
  1079. /*
  1080. :- lisp_compiled_eval(
  1081.                       [ tagbody,
  1082.                         [setq, b, 2],
  1083.                         [go, tag2],
  1084.                         [setq, a, 1],
  1085.                         tag1,
  1086.                         [setq, b, 3],
  1087.                         [go, tag3],
  1088.                         tag2,
  1089.                         [setq, a, 4],
  1090.                         [go, tag1],
  1091.                         tag3,
  1092.                         [print, ['1+', [plus, a, b]]]
  1093.                       ]).
  1094. */
  1095. ( tagbody ( setq b 2 ) ( go tag2 ) ( setq a 1 ) tag1 ( setq b 3 ) ( go tag3 ) tag2 ( setq a 4 ) ( go tag1 ) tag3 ( print ( 1+ ( plus a b ) ) ) )
  1096. /*
  1097. :- call_addr_block(toplevel,
  1098.                    (symbol_setter(setq, b, 2, toplevel), goto(tag2, [], toplevel)),
  1099.  
  1100.                    [ addr(tag1,
  1101.                           '$used',
  1102.                           _530,
  1103.                           (symbol_setter(setq, b, 3, _530), goto(tag3, [], _530))),
  1104.                      addr(tag2,
  1105.                           '$used',
  1106.                           _534,
  1107.                           (symbol_setter(setq, a, 4, _534), goto(tag1, [], _534))),
  1108.                      addr(tag3,
  1109.                           '$used',
  1110.                           _536,
  1111.                           (sym_arg_val_env(a, _538, _540, _536), sym_arg_val_env(b, _542, _544, _536), plus(_538, _542, _544), '1+'(_544, _546), print(_546, _548)))
  1112.                    ],
  1113.                    _GORES16).
  1114. */
  1115. 8
  1116. /*
  1117. :- call_addr_block(toplevel,
  1118.                    (symbol_setter(setq, b, 2, toplevel), goto(tag2, [], toplevel)),
  1119.  
  1120.                    [ addr(tag1,
  1121.                           '$used',
  1122.                           _530,
  1123.                           (symbol_setter(setq, b, 3, _530), goto(tag3, [], _530))),
  1124.                      addr(tag2,
  1125.                           '$used',
  1126.                           _532,
  1127.                           (symbol_setter(setq, a, 4, _532), goto(tag1, [], _532))),
  1128.                      addr(tag3,
  1129.                           '$used',
  1130.                           _534,
  1131.                           (sym_arg_val_env(a, _536, _538, _534), sym_arg_val_env(b, _540, _542, _534), plus(_538, _542, _544), '1+'(_544, _546), print(_546, _548)))
  1132.                    ],
  1133.                    []).
  1134. */
  1135. X = tagbody7_prints_8,
  1136. Y = call_addr_block(toplevel,  (symbol_setter(setq, b, 2, toplevel), goto(tag2, [], toplevel)), [addr(tag1, '$used', _530,  (symbol_setter(setq, b, 3, _530), goto(tag3, [], _530))), addr(tag2, '$used', _532,  (symbol_setter(setq, a, 4, _532), goto(tag1, [], _532))), addr(tag3, '$used', _534,  (sym_arg_val_env(a, _536, _538, _534), sym_arg_val_env(b, _540, _542, _534), plus(_538, _542, _544), '1+'(..., ...), print(..., ...)))], []),
  1137. Z = [],
  1138. Q = 7 ;
  1139. /*
  1140. :- lisp_compiled_eval(
  1141.                       [ do,
  1142.  
  1143.                         [ ['temp-one', 1, ['1+', 'temp-one']],
  1144.                           ['temp-two', 0, ['1-', 'temp-two']]
  1145.                         ],
  1146.                         [[>, [-, 'temp-one', 'temp-two'], 5], 'temp-one']
  1147.                       ]).
  1148. */
  1149. ( do ( ( temp-one 1 ( 1+ temp-one ) ) ( temp-two 0 ( 1- temp-two ) ) ) ( ( > ( - temp-one temp-two ) 5 ) temp-one ) )
  1150. /*
  1151. :- call_addr_block(toplevel,
  1152.                    goto(enter([]), [], toplevel),
  1153.  
  1154.                    [ addr(enter([]),
  1155.                           '$used',
  1156.                           _1662,
  1157.                           (_1688=[[bv('temp-one', [1|_1722]), bv('temp-two', [0|_1740])]|_1662], call_addr_block(_1688,  (push_label(dosym1), sym_arg_val_env('temp-one', _1782, _1796, _1688), sym_arg_val_env('temp-two', _1826, _1840, _1688), minus(_1796, _1840, _1868), greaterThan(_1868, 5, _1896), (_1896\=[]->sym_arg_val_env('temp-one', _1950, _1964, _1688), goto(exit([]), _1964, _1688), _1992=_1998;sym_arg_val_env('temp-one', _2028, _2042, _1688), '1+'(_2042, _2068), sym_arg_val_env('temp-two', _2098, _2112, _1688), '1-'(_2112, _2138), symbol_setter(psetq, 'temp-one', _1466, _1412), symbol_setter(psetq, 'temp-two', _1478, _1412), _1450=[[_1466, _1478]]), goto(dosym1, [], _1412)), [addr(dosym1, '$unused', _1480,  (sym_arg_val_env('temp-one', _1482, _1484, _1480), sym_arg_val_env('temp-two', _1486, _1488, _1480), minus(_1484, _1488, _1490), greaterThan(_1490, 5, _1494), (_1494\=[]->sym_arg_val_env('temp-one', _1498, _1502, _1480), goto(exit([]), _1502, _1480), _1504=_1506;sym_arg_val_env('temp-one', _1510, _1514, _1480), '1+'(_1514, _1516), sym_arg_val_env('temp-two', _1520, _1524, _1480), '1-'(_1524, _1526), symbol_setter(psetq, 'temp-one', _1516, _1480), symbol_setter(psetq, 'temp-two', _1526, _1480), _1504=[[_1516, _1526]]), goto(dosym1, [], _1480)))], _1530), goto(exit([]), [], _1408))),
  1158.                      addr(exit([]), '$used', _1532, true)
  1159.                    ],
  1160.                    []).
  1161. */
  1162. /*
  1163. :- call_addr_block(toplevel,
  1164.                    goto(enter([]), [], toplevel),
  1165.  
  1166.                    [ addr(enter([]),
  1167.                           '$used',
  1168.                           _1406,
  1169.                           (_1408=[[bv('temp-one', [1|_1410]), bv('temp-two', [0|_1412])]|_1406], call_addr_block(_1408,  (push_label(dosym1), sym_arg_val_env('temp-one', _1414, _1416, _1408), sym_arg_val_env('temp-two', _1418, _1420, _1408), minus(_1416, _1420, _1422), greaterThan(_1422, 5, _1424), (_1424\=[]->sym_arg_val_env('temp-one', _1426, _1428, _1408), goto(exit([]), _1428, _1408), _1430=_1432;sym_arg_val_env('temp-one', _1434, _1436, _1408), '1+'(_1436, _1438), sym_arg_val_env('temp-two', _1440, _1442, _1408), '1-'(_1442, _1444), symbol_setter(psetq, 'temp-one', _1438, _1408), symbol_setter(psetq, 'temp-two', _1444, _1408), _1430=[[_1438, _1444]]), goto(dosym1, [], _1408)), [addr(dosym1, '$unused', _1446,  (sym_arg_val_env('temp-one', _1448, _1450, _1446), sym_arg_val_env('temp-two', _1452, _1454, _1446), minus(_1450, _1454, _1456), greaterThan(_1456, 5, _1458), (_1458\=[]->sym_arg_val_env('temp-one', _1460, _1462, _1446), goto(exit([]), _1462, _1446), _1464=_1466;sym_arg_val_env('temp-one', _1468, _1470, _1446), '1+'(_1470, _1472), sym_arg_val_env('temp-two', _1474, _1476, _1446), '1-'(_1476, _1478), symbol_setter(psetq, 'temp-one', _1472, _1446), symbol_setter(psetq, 'temp-two', _1478, _1446), _1464=[[_1472, _1478]]), goto(dosym1, [], _1446)))], _1480), goto(exit([]), [], _1406))),
  1170.                      addr(exit([]), '$used', _1482, true)
  1171.                    ],
  1172.                    []).
  1173. */
  1174. X = do(0.0),
  1175. Y = call_addr_block(toplevel, goto(enter([]), [], toplevel), [addr(enter([]), '$used', _1406,  (_1408=[[bv('temp-one', [1|...]), bv('temp-two', [...|...])]|_1406], call_addr_block(_1408,  (push_label(dosym1), sym_arg_val_env('temp-one', _1414, _1416, _1408), sym_arg_val_env(..., ..., ..., ...), ..., ...), [addr(dosym1, '$unused', _1446,  (sym_arg_val_env(..., ..., ..., ...), ..., ...))], _1480), goto(exit([]), [], _1406))), addr(exit([]), '$used', _1482, true)], []),
  1176. Z = [],
  1177. Q = 4 ;
  1178. /*
  1179. :- lisp_compiled_eval(
  1180.                       [ do,
  1181.  
  1182.                         [ ['temp-one', 1, ['1+', 'temp-one']],
  1183.                           ['temp-two', 0, ['1+', 'temp-one']]
  1184.                         ],
  1185.                         [[=, 3, 'temp-two'], 'temp-one']
  1186.                       ]).
  1187. */
  1188. ( do ( ( temp-one 1 ( 1+ temp-one ) ) ( temp-two 0 ( 1+ temp-one ) ) ) ( ( = 3 temp-two ) temp-one ) )
  1189. /*
  1190. :- call_addr_block(toplevel,
  1191.                    goto(enter([]), [], toplevel),
  1192.  
  1193.                    [ addr(enter([]),
  1194.                           '$used',
  1195.                           _1484,
  1196.                           (_1510=[[bv('temp-one', [1|_1544]), bv('temp-two', [0|_1562])]|_1484], call_addr_block(_1510,  (push_label(dosym2), sym_arg_val_env('temp-two', _1604, _1618, _1510), =(3, _1618, _1646), (_1646\=[]->sym_arg_val_env('temp-one', _1700, _1714, _1510), goto(exit([]), _1714, _1510), _1742=_1748;sym_arg_val_env('temp-one', _1778, _1792, _1510), '1+'(_1792, _1818), sym_arg_val_env('temp-one', _1848, _1862, _1510), '1+'(_1862, _1888), symbol_setter(psetq, 'temp-one', _1818, _1510), symbol_setter(psetq, 'temp-two', _1888, _1510), _1742=[[_1818, _1888]]), goto(dosym2, [], _1510)), [addr(dosym2, '$unused', _1976,  (sym_arg_val_env('temp-two', _1990, _1992, _1976), =(3, _1992, _2012), (_2012\=[]->sym_arg_val_env('temp-one', _2058, _2066, _1976), goto(exit([]), _2066, _1976), _2094=_2096;sym_arg_val_env('temp-one', _2116, _2130, _1976), '1+'(_2130, _2152), sym_arg_val_env('temp-one', _2172, _2186, _1976), '1+'(_2186, _2212), symbol_setter(psetq, 'temp-one', _2152, _1976), symbol_setter(psetq, 'temp-two', _2212, _1976), _2094=[[_2152, _2212]]), goto(dosym2, [], _1976)))], _2290), goto(exit([]), [], _1484))),
  1197.                      addr(exit([]), '$used', _2322, true)
  1198.                    ],
  1199.                    []).
  1200. */
  1201. /*
  1202. :- call_addr_block(toplevel,
  1203.                    goto(enter([]), [], toplevel),
  1204.  
  1205.                    [ addr(enter([]),
  1206.                           '$used',
  1207.                           _1250,
  1208.                           (_1254=[[bv('temp-one', [1|_1256]), bv('temp-two', [0|_1258])]|_1250], call_addr_block(_1254,  (push_label(dosym2), sym_arg_val_env('temp-two', _1262, _1266, _1254), =(3, _1266, _1270), (_1270\=[]->sym_arg_val_env('temp-one', _1274, _1278, _1254), goto(exit([]), _1278, _1254), _1280=_1284;sym_arg_val_env('temp-one', _1288, _1292, _1254), '1+'(_1292, _1296), sym_arg_val_env('temp-one', _1300, _1304, _1254), '1+'(_1304, _1308), symbol_setter(psetq, 'temp-one', _1296, _1254), symbol_setter(psetq, 'temp-two', _1308, _1254), _1280=[[_1296, _1308]]), goto(dosym2, [], _1254)), [addr(dosym2, '$unused', _1310,  (sym_arg_val_env('temp-two', _1312, _1314, _1310), =(3, _1314, _1318), (_1318\=[]->sym_arg_val_env('temp-one', _1320, _1324, _1310), goto(exit([]), _1324, _1310), _1326=_1328;sym_arg_val_env('temp-one', _1332, _1336, _1310), '1+'(_1336, _1338), sym_arg_val_env('temp-one', _1304, _1306, _1282), '1+'(_1306, _1308), symbol_setter(psetq, 'temp-one', _1302, _1282), symbol_setter(psetq, 'temp-two', _1308, _1282), _1294=[[_1302, _1308]]), goto(dosym2, [], _1282)))], _1310), goto(exit([]), [], _1248))),
  1209.                      addr(exit([]), '$used', _1312, true)
  1210.                    ],
  1211.                    []).
  1212. */
  1213. X = do(0.1),
  1214. Y = call_addr_block(toplevel, goto(enter([]), [], toplevel), [addr(enter([]), '$used', _1248,  (_1250=[[bv('temp-one', [1|...]), bv('temp-two', [...|...])]|_1248], call_addr_block(_1250,  (push_label(dosym2), sym_arg_val_env('temp-two', _1256, _1258, _1250), =(..., ..., ...), ..., ...), [addr(dosym2, '$unused', _1282,  (sym_arg_val_env(..., ..., ..., ...), ..., ...))], _1310), goto(exit([]), [], _1248))), addr(exit([]), '$used', _1312, true)], []),
  1215. Z = [],
  1216. Q = 3 ;
  1217. /*
  1218. :- lisp_compiled_eval(
  1219.                       [ tagbody,
  1220.                         [setq, b, 2],
  1221.                         [go, tag1],
  1222.                         [setq, a, 1],
  1223.                         tag1,
  1224.                         [setq, a, 4],
  1225.                         [print, [plus, a, b]]
  1226.                       ]).
  1227. */
  1228. ( tagbody ( setq b 2 ) ( go tag1 ) ( setq a 1 ) tag1 ( setq a 4 ) ( print ( plus a b ) ) )
  1229. /*
  1230. :- call_addr_block(toplevel,
  1231.                    (symbol_setter(setq, b, 2, toplevel), goto(tag1, [], toplevel)),
  1232.  
  1233.                    [ addr(tag1,
  1234.                           '$used',
  1235.                           _486,
  1236.                           (symbol_setter(setq, a, 4, _486), sym_arg_val_env(a, _488, _490, _486), sym_arg_val_env(b, _492, _494, _486), plus(_490, _494, _496), print(_496, _498)))
  1237.                    ],
  1238.                    Z).
  1239. */
  1240. 6
  1241. /*
  1242. :- call_addr_block(toplevel,
  1243.                    (symbol_setter(setq, b, 2, toplevel), goto(tag1, [], toplevel)),
  1244.  
  1245.                    [ addr(tag1,
  1246.                           '$used',
  1247.                           _486,
  1248.                           (symbol_setter(setq, a, 4, _486), sym_arg_val_env(a, _488, _490, _486), sym_arg_val_env(b, _492, _494, _486), plus(_490, _494, _496), print(_496, _498)))
  1249.                    ],
  1250.                    []).
  1251. */
  1252. X = tagbody1,
  1253. Y = call_addr_block(toplevel,  (symbol_setter(setq, b, 2, toplevel), goto(tag1, [], toplevel)), [addr(tag1, '$used', _486,  (symbol_setter(setq, a, 4, _486), sym_arg_val_env(a, _488, _490, _486), sym_arg_val_env(b, _492, _494, _486), plus(_490, _494, _496), print(_496, _498)))], []),
  1254. Z = Q, Q = [] ;
  1255. /*
  1256. :- lisp_compiled_eval(
  1257.                       [ block,
  1258.                         block3,
  1259.                         [setq, b, 2],
  1260.                         [go, tag1],
  1261.                         [setq, a, 1],
  1262.                         tag1,
  1263.                         [setq, a, 4],
  1264.                         [print, [plus, a, b]],
  1265.                         ['return-from', block3, [plus, a, b]]
  1266.                       ]).
  1267. */
  1268. ( block block3 ( setq b 2 ) ( go tag1 ) ( setq a 1 ) tag1 ( setq a 4 ) ( print ( plus a b ) ) ( return-from block3 ( plus a b ) ) )
  1269. /*
  1270. :- call_addr_block(toplevel,
  1271.                    goto(enter(block3), [], toplevel),
  1272.  
  1273.                    [ addr(enter(block3),
  1274.                           '$used',
  1275.                           _14970,
  1276.                           (symbol_setter(setq, b, 2, _14970), goto(tag1, [], _14970))),
  1277.                      addr(tag1,
  1278.                           '$used',
  1279.                           _706,
  1280.                           (symbol_setter(setq, a, 4, _706), sym_arg_val_env(a, _708, _710, _706), sym_arg_val_env(b, _712, _714, _706), plus(_710, _714, _716), print(_716, _718), sym_arg_val_env(a, _722, _726, _706), sym_arg_val_env(b, _730, _734, _706), plus(_726, _734, _738), goto(exit(block3), _738, _706))),
  1281.                      addr(exit(block3), '$used', _740, true)
  1282.                    ],
  1283.                    []).
  1284. */
  1285. 6
  1286. /*
  1287. :- call_addr_block(toplevel,
  1288.                    goto(enter(block3), [], toplevel),
  1289.  
  1290.                    [ addr(enter(block3),
  1291.                           '$used',
  1292.                           _704,
  1293.                           (symbol_setter(setq, b, 2, _704), goto(tag1, [], _704))),
  1294.                      addr(tag1,
  1295.                           '$used',
  1296.                           _706,
  1297.                           (symbol_setter(setq, a, 4, _706), sym_arg_val_env(a, _708, _710, _706), sym_arg_val_env(b, _712, _714, _706), plus(_710, _714, _716), print(_716, _718), sym_arg_val_env(a, _722, _726, _706), sym_arg_val_env(b, _730, _734, _706), plus(_726, _734, _738), goto(exit(block3), _738, _706))),
  1298.                      addr(exit(block3), '$used', _740, true)
  1299.                    ],
  1300.                    []).
  1301. */
  1302. X = block3,
  1303. Y = call_addr_block(toplevel, goto(enter(block3), [], toplevel), [addr(enter(block3), '$used', _640,  (symbol_setter(setq, b, 2, _640), goto(tag1, [], _640))), addr(tag1, '$used', _642,  (symbol_setter(setq, a, 4, _642), sym_arg_val_env(a, _644, _646, _642), sym_arg_val_env(b, _648, _650, _642), plus(_646, _650, _652), print(..., ...), ..., ...)), addr(exit(block3), '$used', _666, true)], []),
  1304. Z = [],
  1305. Q = 6 ;
  1306. /*
  1307. :- lisp_compiled_eval([defun, let_simple, [], [let, [val], val]]).
  1308. */
  1309. ( defun let_simple NIL ( let ( val ) val ) )
  1310. /*
  1311. dbmsg(asserta, let_simple(RETVal_Thru)) :-
  1312.         fail,
  1313.         ( [let_simple]<<==[[let, [val], val]]
  1314.         ).
  1315. dbmsg(asserta, let_simple(RETVal_Thru)) :- !,
  1316.         DEnv=[[]],
  1317.         LETENV=[[bv(val, [[]|_260])]|DEnv],
  1318.         sym_arg_val_env(val, Val_In, RETVal_Thru, LETENV).
  1319. */
  1320. /*
  1321. dbmsg(asserta, let_simple(RETVal_Thru)) :-
  1322.         fail,
  1323.         ( [let_simple]<<==[[let, [val], val]]
  1324.         ).
  1325. dbmsg(asserta, let_simple(RETVal_Thru)) :- !,
  1326.         DEnv=[[]],
  1327.         LETENV=[[bv(val, [[]|_260])]|DEnv],
  1328.         sym_arg_val_env(val, Val_In, RETVal_Thru, LETENV).
  1329. */
  1330. X = Z, Z = let_simple,
  1331. Y =  (asserta((let_simple(_326):-fail, ([let_simple]<<==[[let, [val], val]]))), asserta((let_simple(_326):-!, _256=[[]], _262=[[bv(..., ...)]|_256], sym_arg_val_env(val, _330, _326, _262)))),
  1332. Q = [] ;
  1333. /*
  1334. :- lisp_compiled_eval([defun, let_simple1, [], [let, [[val, 1]], val]]).
  1335. */
  1336. ( defun let_simple1 NIL ( let ( ( val 1 ) ) val ) )
  1337. /*
  1338. dbmsg(asserta, let_simple1(RETVal_Thru)) :-
  1339.         fail,
  1340.         ( [let_simple1]<<==[[let, [[val, 1]], val]]
  1341.         ).
  1342. dbmsg(asserta, let_simple1(RETVal_Thru)) :- !,
  1343.         DEnv=[[]],
  1344.         LETENV=[[bv(val, [1|_8900])]|DEnv],
  1345.         sym_arg_val_env(val, Val_In, RETVal_Thru, LETENV).
  1346. */
  1347. /*
  1348. dbmsg(asserta, let_simple1(RETVal_Thru)) :-
  1349.         fail,
  1350.         ( [let_simple1]<<==[[let, [[val, 1]], val]]
  1351.         ).
  1352. dbmsg(asserta, let_simple1(RETVal_Thru)) :- !,
  1353.         DEnv=[[]],
  1354.         LETENV=[[bv(val, [1|_242])]|DEnv],
  1355.         sym_arg_val_env(val, Val_In, RETVal_Thru, LETENV).
  1356. */
  1357. X = Z, Z = let_simple1,
  1358. Y =  (asserta((let_simple1(_308):-fail, ([let_simple1]<<==[[let, [[...|...]], val]]))), asserta((let_simple1(_308):-!, _238=[[]], _244=[[bv(..., ...)]|_238], sym_arg_val_env(val, _312, _308, _244)))),
  1359. Q = 1 ;
  1360. /*
  1361. :- lisp_compiled_eval(
  1362.                       [ defun,
  1363.                         fifteen,
  1364.                         [],
  1365.  
  1366.                         [ let,
  1367.                           [val],
  1368.  
  1369.                           [ tagbody,
  1370.                             [setq, val, 1],
  1371.                             [go, 'point-a'],
  1372.                             [incf, val, 16],
  1373.                             'point-c',
  1374.                             [incf, val, 4],
  1375.                             [go, 'point-b'],
  1376.                             [incf, val, 32],
  1377.                             'point-a',
  1378.                             'point-u',
  1379.                             [incf, val, 2],
  1380.                             [go, 'point-c'],
  1381.                             [incf, val, 64],
  1382.                             'point-b',
  1383.                             [incf, val, 8]
  1384.                           ],
  1385.                           val
  1386.                         ]
  1387.                       ]).
  1388. */
  1389. ( defun fifteen NIL ( let ( val ) ( tagbody ( setq val 1 ) ( go point-a ) ( incf val 16 ) point-c ( incf val 4 ) ( go point-b ) ( incf val 32 ) point-a point-u ( incf val 2 ) ( go point-c ) ( incf val 64 ) point-b ( incf val 8 ) ) val ) )
  1390. /*
  1391. dbmsg(asserta, fifteen(RETVal_Thru)) :-
  1392.         fail,
  1393.         ( [fifteen]<<==[[let, [val], [tagbody, [setq, val, 1], [go, 'point-a'], [incf, val, 16], 'point-c', [incf, val, 4], [go, 'point-b'], [incf, val, 32], 'point-a', 'point-u', [incf, val, 2], [go, 'point-c'], [incf, val, 64], 'point-b', [incf, val, 8]], val]]
  1394.         ).
  1395. dbmsg(asserta, fifteen(RETVal_Thru)) :- !,
  1396.         DEnv=[[]],
  1397.         GoEnvLETENV=[[bv(val, [[]|_240])]|DEnv],
  1398.         call_addr_block(GoEnvLETENV,
  1399.                         (symbol_setter(setq, val, 1, GoEnvLETENV), goto('point-a', [], GoEnvLETENV)),
  1400.  
  1401.                         [ addr('point-c',
  1402.                                '$used',
  1403.                                _504,
  1404.                                (place_op(incf, val, [4], _504, _506), goto('point-b', [], _504))),
  1405.                           addr('point-a',
  1406.                                '$used',
  1407.                                _510,
  1408.                                (push_label('point-u'), place_op(incf, val, [2], _510, _522), goto('point-c', [], _510))),
  1409.                           addr('point-u',
  1410.                                '$unused',
  1411.                                _526,
  1412.                                (place_op(incf, val, [2], _526, _538), goto('point-c', [], _526))),
  1413.                           addr('point-b',
  1414.                                '$used',
  1415.                                _540,
  1416.                                place_op(incf, val, [8], _540, _544))
  1417.                         ],
  1418.                         _GORES14),
  1419.         sym_arg_val_env(val, Val_In, RETVal_Thru, GoEnvLETENV).
  1420. */
  1421. /*
  1422. dbmsg(asserta, fifteen(RETVal_Thru)) :-
  1423.         fail,
  1424.         ( [fifteen]<<==[[let, [val], [tagbody, [setq, val, 1], [go, 'point-a'], [incf, val, 16], 'point-c', [incf, val, 4], [go, 'point-b'], [incf, val, 32], 'point-a', 'point-u', [incf, val, 2], [go, 'point-c'], [incf, val, 64], 'point-b', [incf, val, 8]], val]]
  1425.         ).
  1426. dbmsg(asserta, fifteen(RETVal_Thru)) :- !,
  1427.         DEnv=[[]],
  1428.         GoEnvLETENV=[[bv(val, [[]|_240])]|DEnv],
  1429.         call_addr_block(GoEnvLETENV,
  1430.                         (symbol_setter(setq, val, 1, GoEnvLETENV), goto('point-a', [], GoEnvLETENV)),
  1431.  
  1432.                         [ addr('point-c',
  1433.                                '$used',
  1434.                                _504,
  1435.                                (place_op(incf, val, [4], _504, _506), goto('point-b', [], _504))),
  1436.                           addr('point-a',
  1437.                                '$used',
  1438.                                _510,
  1439.                                (push_label('point-u'), place_op(incf, val, [2], _510, _522), goto('point-c', [], _510))),
  1440.                           addr('point-u',
  1441.                                '$unused',
  1442.                                _526,
  1443.                                (place_op(incf, val, [2], _526, _538), goto('point-c', [], _526))),
  1444.                           addr('point-b',
  1445.                                '$used',
  1446.                                _540,
  1447.                                place_op(incf, val, [8], _540, _544))
  1448.                         ],
  1449.                         _GORES14),
  1450.         sym_arg_val_env(val, Val_In, RETVal_Thru, GoEnvLETENV).
  1451. */
  1452. X = let_tagbody,
  1453. Y =  (asserta((fifteen(_584):-fail, ([fifteen]<<==[[let, [val], [...|...]|...]]))), asserta((fifteen(_584):-!, _236=[[]], _490=[[bv(..., ...)]|_236], call_addr_block(_490,  (symbol_setter(..., ..., ..., ...), goto(..., ..., ...)), [addr(..., ..., ..., ...)|...], _348), sym_arg_val_env(val, _586, _584, _490)))),
  1454. Z = fifteen,
  1455. Q = 15.
  1456.  
  1457. ?- ^D
  1458. root@gitlab:/home/dmiles/logicmoo_workspace/packs_usr/wam_common_lisp/prolog/wam_cl#
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!