home *** CD-ROM | disk | FTP | other *** search
/ APDL Public Domain 1 / APDL_PD1A.iso / program / language / huprolog / Source / C / UNI < prev   
Encoding:
Text File  |  1990-06-10  |  13.3 KB  |  487 lines
  1. /***************************************************
  2. ****************************************************
  3. **                                                **
  4. **  HU-Prolog     Portable Interpreter System     ** 
  5. **                                                **
  6. **  Release 1.62   January  1990                  **
  7. **                                                **
  8. **  Authors:      C.Horn, M.Dziadzka, M.Horn      **
  9. **                                                **
  10. **  (C) 1989      Humboldt-University             **
  11. **                Department of Mathematics       **
  12. **                GDR 1086 Berlin, P.O.Box 1297   **
  13. **                                                **
  14. ****************************************************
  15. ***************************************************/
  16.  
  17. #include "systems.h"
  18. #include "types.h"
  19. #include "errors.h"
  20. #include "atoms.h"
  21. #include "manager.h"
  22.  
  23. /* 
  24.  
  25. When backtracking occurs, it is necessary to undo the variable bindings
  26. introduced during execution of the failed clauses.  For this purpose,
  27. certain critical bindings are recorded on an auxiliary stack called the
  28. trail.  The critical bindings are those involving variables created in
  29. environments older than choicepoint: those newer than choicepoint will
  30. disappear when the stacks contract.
  31.  
  32. */
  33.  
  34. #if P8000
  35. #define reg1 register
  36. #define reg2 register
  37. #define reg3 register
  38. #define reg4 register
  39. #define reg5 register
  40. #define reg6 register
  41. #endif
  42.  
  43. #if RISCOS
  44. #define reg1 register
  45. #define reg2 register
  46. #define reg3 register
  47. #define reg4 register
  48. #endif
  49.  
  50.  
  51. #if MSC 
  52. #define reg1 register
  53. #define reg2 register
  54. #endif
  55.  
  56. #ifndef reg1
  57. #define reg1 
  58. #endif
  59. #ifndef reg2
  60. #define reg2 
  61. #endif
  62. #ifndef reg3
  63. #define reg3 
  64. #endif
  65. #ifndef reg4
  66. #define reg4 
  67. #endif
  68. #ifndef reg5
  69. #define reg5 
  70. #endif
  71. #ifndef reg6
  72. #define reg6 
  73. #endif
  74. #ifndef reg7
  75. #define reg7
  76. #endif
  77. #ifndef reg8
  78. #define reg8
  79. #endif
  80. #ifndef reg9
  81. #define reg9
  82. #endif
  83. #ifndef reg10
  84. #define reg10
  85. #endif
  86. #ifndef reg11
  87. #define reg11
  88. #endif
  89. #ifndef reg12
  90. #define reg12
  91. #endif
  92.  
  93. /*
  94. EXPORT   boolean UNIFY();
  95. EXPORT   boolean INTRES(), LONGRES();
  96. EXPORT  void KILLSTACKS();
  97. EXPORT   ENV NEWENV(int);
  98. EXPORT   ENV ENVTOP;
  99. EXPORT  TRAIL TRAILEND;
  100. EXPORT TERM DEREF();
  101. */
  102.  
  103. IMPORT TERM HEAPTOP; /* from manager.c */
  104. IMPORT ATOM ATOMSTOP; /* from manager.c */
  105. IMPORT STRING STRINGSTOP;
  106. IMPORT TERM GLOTOP;
  107. IMPORT ENV CHOICEPOINT;
  108. IMPORT boolean OCHECK;
  109. IMPORT void ABORT();      /* from io.c */
  110. IMPORT void reclaim_heap();
  111. FORWARD boolean UNIFY();
  112.  
  113. #if !INLINE
  114. GLOBAL TERM DEREF(register TERM x, register TERM b)
  115. { if(name(x)==UNBOUNDT) 
  116.     { if(is_heapterm(x)) return mkfreevar(); }
  117.   else
  118.     { if(name(x)==SKELT) x=b+offset(x); 
  119.       while(name(x)==VART) x=val(x); 
  120.     }
  121.   return x;
  122. }
  123. #endif
  124.  
  125.  
  126. #if !POINTEROFFSET
  127. GLOBAL TRAIL TRAILEND=trail_units(1);
  128. GLOBAL TRAIL BASETRAIL=trail_units(1);
  129. #define ENDTRAILER MAXTRAILER
  130. #endif
  131.  
  132. #if POINTEROFFSET
  133. GLOBAL TRAIL TRAILEND= &TRAILTAB[1];
  134. GLOBAL TRAIL BASETRAIL= &TRAILTAB[1];
  135. LOCAL TRAIL ENDTRAILER= &TRAILTAB[MAXTRAILER];
  136. #endif
  137.  
  138. GLOBAL ENV   ENVTOP=env_units(1);
  139. GLOBAL ENV   BASEENV=env_units(1);
  140.  
  141.  
  142. /*
  143.    Specialized unification algorithm for returning integer results.
  144.    IntResult(x, i) is equivalent to Unify(x, MakeInt(i), ee, 0, 0)
  145.    but avoids allocating a global node.
  146. */
  147.  
  148. GLOBAL boolean INTRES (register TERM X, register int I)
  149. { 
  150.   deref(X);
  151.   if(name(X)==INTT) return ival(X)==I;
  152.   if(name(X)==UNBOUNDT)
  153.      { name(X)=INTT; ival(X)=I; 
  154.        if(X<base(CHOICEPOINT)) 
  155.           { if(TRAILEND >=ENDTRAILER) ABORT(TRAILSPACEE);
  156.             boundvar(TRAILEND)=X; inc_trail(TRAILEND); }
  157.        return true; 
  158.      }
  159.   return false;
  160. }
  161.  
  162.  
  163. #if LONGARITH
  164. GLOBAL boolean LONGRES(TERM T, long L)
  165. {
  166.    if(minint<=L && L<=maxint)
  167.      return INTRES(T,(int)L);
  168.    else return UNI(T,mklong(L));
  169. }
  170. #endif
  171. /*
  172.  
  173. The abstract Prolog machine contains two stacks, the local stack and
  174. the global stack.  The local stack is held in the global array
  175. 'display', with local variables in the global array 'locstack'.  These
  176. arrays have stack pointers 'envtop' and 'loctop' respectively.  The
  177. global stack is held as a chain of nodes starting at 'glotop'.
  178.  
  179. */
  180.  
  181. /* Create a new environment e. */
  182.  
  183. /*
  184.    Do not alterate Newenv
  185.    Newenv is used in execute as inline-code
  186.  */
  187. GLOBAL ENV NEWENV (REGISTER int VAR_SIZES)
  188. { register ENV EP; register TERM T;
  189.   if((EP=ENVTOP)>=MAXENVS) ABORT(FRAMESPACEE);
  190.   inc_env(ENVTOP);
  191.   choice(EP)=CHOICEPOINT;
  192.   trail(EP)=TRAILEND;
  193.   atomtop(EP)=ATOMSTOP;
  194.   base(EP)=T=GLOTOP;
  195.   if((GLOTOP+=(unsigned)VAR_SIZES) >=HEAPTOP) reclaim_heap(true);
  196.   while(dec_term(VAR_SIZES)>=0)
  197.     { name(T)=UNBOUNDT; inc_term(T); } 
  198.   return EP;
  199. }
  200.  
  201.  
  202. /*
  203.    Dispose of all environments after newtop, together with all
  204.    associated global storage, and undo critical variable bindings.
  205.    Do not alterate Killstacks
  206.    Killstacks is used in execute as inline-code
  207.  */
  208. GLOBAL void KILLSTACKS (register ENV N)
  209. { if(ENVTOP>=N)
  210.     { register TRAIL  Q,QQ; 
  211.       CHOICEPOINT=choice(N);
  212.       ATOMSTOP=atomtop(N);
  213.       STRINGSTOP= (STRING)nextatom(ATOMSTOP);
  214.       GLOTOP=base(N);
  215.       ENVTOP=N;
  216.       Q=TRAILEND; TRAILEND=QQ=trail(N);
  217.       while(QQ<Q) 
  218.         { name(boundvar(QQ))=UNBOUNDT; inc_trail(QQ); }
  219.     }
  220. }
  221.  
  222. /* 
  223. Unify implements the unification algorithm, which finds the most
  224. general common instance of a pair of terms. It performs the matching
  225. substitution by introducing variable bindings.  The occur check
  226. is executed only if the corresponding flag is set.
  227. */
  228.  
  229. #if OCCUR_CHECK
  230. LOCAL boolean O_Check(reg3 int N, reg5 TERM V, reg4 TERM T, 
  231.                       reg6 TERM BT, int DEPTH)
  232. { /* returns true, if V is an element of T */
  233.   reg1 TERM S=T; 
  234.   reg2 ATOM A;
  235.   if(N==0) return false;
  236.   if(DEPTH==0)ABORT(DEPTHE);
  237.   for(;;)
  238.   {  
  239.     if(name(S)==SKELT) S=BT+offset(S); 
  240.     while(name(S)==VART) S=val(S);
  241.     if(name(S)==UNBOUNDT) return (S==V);
  242.     if(O_Check(arity(name(S)),V,son(S),BT,DEPTH-1)) return true; 
  243.     if(--N==0) break;
  244.     S=next_br(T);
  245.   } 
  246.   return false;
  247. }
  248. #endif
  249.  
  250.  
  251. /* 
  252.    BIND creates a copy of the given argument list X on the stack
  253.    N - length of argument list;
  254.    X - pointer to first argument (X is assumed to be on heap);
  255.    B - base of the current environment for X;
  256. */
  257.  
  258. #define bindspace(N) \
  259.                { if((GLOTOP+=term_units(N))>=HEAPTOP) reclaim_heap(true); }
  260.  
  261. LOCAL TERM BIND(int N, TERM X, TERM B)
  262. {
  263.   reg1 TERM Y;
  264.   reg2 TERM T;
  265.   T=Y=GLOTOP;
  266. bind_top:
  267.   bindspace(N);
  268.  
  269.   for(;;)
  270.     if(name(X)==SKELT) 
  271.     { reg3 TERM S;
  272.       S=B+offset(X);
  273.       while(name(S)==VART) S=val(S); 
  274.       name(Y)=VART; val(Y)=S;
  275.       if(--N==0)goto ret;
  276.       next_br(X);next_br(Y);continue;
  277.     }
  278.     else 
  279.     { reg3 int S;
  280.       if(S=arity(name(Y)=name(X)))
  281.         { if(--N !=0) son(Y)=BIND(S,son(X),B);
  282.           else { N=S;Y=son(Y)=GLOTOP; X=son(X); goto bind_top; }
  283.           next_br(Y);next_br(X); continue;
  284.         }
  285.       else val(Y)=val(X);
  286.       if(--N==0)goto ret;
  287.       next_br(X);next_br(Y);continue;
  288.     }
  289.  ret: return T;
  290. }
  291.  
  292. /* Unify x1 and x2.  Perform the matching substitution
  293.    by binding variables. */
  294. #if ! INLINE
  295. GLOBAL boolean UNI(TERM Y1, TERM Y2)
  296. { return UNIFY(1,Y1,Y2,BE,BE,MAXDEPTH); }
  297. #endif
  298.  
  299.  
  300.  
  301. GLOBAL boolean UNIFY (int N, TERM Y1, TERM Y2, TERM B1, TERM B2, 
  302.                       int DEPTH)
  303. { reg1 TERM X1=Y1; reg2 TERM X2=Y2; 
  304.   reg4 ATOM A1; reg3 ATOM A2; reg5 TERM BC; 
  305.   TERM TOP; TRAIL TEND; card TAILRECUR=DEPTH; 
  306.  
  307. #define trailing(v,h)        {if(v<BC) { boundvar(TRAILEND)=v;\
  308.               if(inc_trail(TRAILEND)>=ENDTRAILER) ABORT(TRAILSPACEE);}}
  309. #define dereferencing(x,b) {if(name(x)==SKELT) x=b+offset(x);\
  310.                       while(name(x)==VART) x=val(x);}
  311. #define varbind(x,y)       { if(x<y)\
  312.         {name(y)=VART; val(y)=x; trailing(y,A1); }\
  313.         else { if(heap_term(x)) goto nextbrother;\
  314.           else if(x>y) {name(x)=VART;val(x)=y; trailing(x,A1);}}}
  315. #undef  annontvar
  316. #define annontvar          heap_term
  317. #if OCCUR_CHECK
  318. #define occurcheck(ar,v,t,b){if(OCHECK && \
  319.                       O_Check(ar,v,son(t),b,MAXDEPTH))goto failure;}
  320. #define occur1check(n,v,t,b){if(OCHECK && arity(n))\
  321.                  if(O_Check(arity(n),v,son(t),b,MAXDEPTH))goto failure;}
  322. #endif
  323. #if !OCCUR_CHECK
  324. #define occurcheck(ar,v,t,b)
  325. #define occur1check(n,v,t,b)
  326. #endif
  327. #define heap_term(x)  (x>GLOTOP)
  328. #define stack_term(x) (x<=GLOTOP)
  329.  
  330.   if(DEPTH==0) ABORT(DEPTHE);
  331.   TEND=TRAILEND;
  332.   TOP=GLOTOP;
  333.   BC=base(CHOICEPOINT); 
  334. deref_top:   
  335.   for(;;)
  336.     { A2=name(X2);
  337.       
  338.       if(A2>FUNCNAME)
  339.         { dereferencing(X1,B1); 
  340.           if((A1=name(X1))!=A2) 
  341.             { if(A1==UNBOUNDT) 
  342.                 { if(annontvar(X1)) goto nextbrother;
  343.                   trailing(X1,A1); 
  344.                   if(A1=arity(A2)) goto func3; 
  345.                   name(X1)=A2;son(X1)=nil_term;goto nextbrother;}
  346.               goto failure;
  347.             }
  348.           if(A1=arity(A2)) goto func4;
  349.           goto nextbrother;
  350.         } 
  351.       if(A2==SKELT)
  352.         { X2=B2+offset(X2); 
  353.           if((A2=name(X2))==UNBOUNDT) goto unboundt2;
  354.           else if(A2 !=VART) goto func2;
  355.           goto vart2;
  356.         }
  357.       if(A2==UNBOUNDT) 
  358.         { if(annontvar(X2)) goto nextbrother; 
  359.           goto unboundt2;
  360.         }
  361.       if(A2==VART) 
  362.         { vart2: 
  363.           do X2=val(X2);while(name(X2)==VART);
  364.           A2=name(X2); 
  365.         }
  366.       if(A2==UNBOUNDT) 
  367.         { unboundt2: dereferencing(X1,B1); 
  368.           if((A1=name(X1))>FUNCNAME)
  369.             { trailing(X2,A2);
  370.               if(stack_term(X1))
  371.                 { occur1check(A1,X2,X1,B1);
  372.                   name(X2)=A1; son(X2)=son(X1);
  373.                 }
  374.               else if(A2=arity(A1))
  375.                 { occurcheck((int)A2,X2,X1,B1);
  376.                   name(X2)=A1; 
  377.                 bind1:
  378.                   X2=son(X2)=GLOTOP;
  379.                   X1=son(X1);
  380.                   bindspace(A2);
  381.                   for(;;)
  382.                     { if(name(X1)==SKELT) 
  383.                         { register TERM X;
  384.                           X=B1+offset(X1); 
  385.                           while(name(X)==VART) X=val(X);
  386.                           name(X2)=VART;val(X2)=X; 
  387.                           if(--A2==0) break;
  388.                           next_br(X1); next_br(X2);continue;
  389.                         }
  390.                       name(X2)=A1=name(X1); 
  391.                       if(--A2==0)
  392.                         { 
  393.                           if(A1==INTT) { ival(X2)=ival(X1);break;}
  394.                           if(A2=arity(A1)) goto bind1; 
  395.                           else son(X2)=nil_term;
  396.                           break;
  397.                         }
  398.                       else
  399.                         { if(A1=arity(A1))
  400.                             { son(X2)=BIND((int)A1,son(X1),B1);}
  401.                           else val(X2)=val(X1);
  402.                           next_br(X1);next_br(X2);
  403.                         }
  404.                     }
  405.                 }
  406.               else { name(X2)=A1; son(X2)=nil_term; }
  407.             } 
  408.           else if(A1!=A2)
  409.             {name(X2)=A1;ival(X2)=A1=ival(X1);trailing(X2,A2);}
  410.           else /* A1==UNBOUNDT */
  411.               varbind(X1,X2)
  412.         }
  413.       else 
  414.         { func2: dereferencing(X1,B1); 
  415.           if((A1=name(X1))!=A2) 
  416.             if(A1==UNBOUNDT)
  417.               { if(annontvar(X1)) goto nextbrother;
  418.                 trailing(X1,A1);
  419.                 if(A1=arity(A2))
  420.                   { func3: 
  421.                     occurcheck((int)A1,X1,X2,B2);
  422.                     name(X1)=A2;
  423.                     if(X2>GLOTOP)   /* heap_term */
  424.                       { bind2:
  425.                         X1=son(X1)=GLOTOP;
  426.                         X2=son(X2);
  427.                         bindspace(A1);
  428.                         for(;;)
  429.                           { if(name(X2)==SKELT) 
  430.                               { register TERM X;
  431.                                 X=B2+offset(X2); 
  432.                                 while(name(X)==VART) X=val(X);
  433.                                 name(X1)=VART;val(X1)=X;
  434.                                 if(--A1==0) break;
  435.                                 next_br(X1); next_br(X2);continue;
  436.                               }
  437.                             name(X1)=A2=name(X2);
  438.                             if(A2=arity(A2))
  439.                               { if(--A1 !=0)
  440.                                   { son(X1)=BIND((int)A2,son(X2),B2);
  441.                                     next_br(X1);next_br(X2); 
  442.                                     continue;
  443.                                   }
  444.                                 else
  445.                                   { A1=A2; goto bind2;}
  446.                               }
  447.                             val(X1)=val(X2);
  448.                             if(--A1==0) break;
  449.                             next_br(X1); next_br(X2);continue;
  450.                           }
  451.                       }
  452.                     else son(X1)=son(X2);
  453.                   }
  454.                 else  {  name(X1)=A2; val(X1)=val(X2);  }
  455.               } 
  456.             else goto failure;
  457.           else if(A1=arity(A2))
  458.             {func4:  
  459.               if(--N==0)
  460.                { N=A1; Y1=X1=son(X1);Y2=X2=son(X2);
  461.                  if(++TAILRECUR!=0) goto deref_top;
  462.                  ABORT(DEPTHE);
  463.                }        
  464.               if(!UNIFY((int)A1,son(X1),son(X2),B1,B2,DEPTH-1))
  465.                       goto failure;
  466.               X1=next_br(Y1); X2=next_br(Y2); continue;
  467.             }
  468.           else 
  469.             if(val(X1)!=val(X2)) goto failure;
  470.        }
  471. nextbrother:     
  472.     if(--N==0) goto success;
  473.     X1=next_br(Y1); X2=next_br(Y2);continue;
  474.   }
  475.   
  476. failure:        
  477.   GLOTOP=TOP; 
  478.   while(TEND<TRAILEND)
  479.    { X1=boundvar(dec_trail(TRAILEND)); name(X1)=UNBOUNDT;}
  480.   return false;
  481.  
  482. success: 
  483.   return true;
  484. }
  485.  
  486.  
  487.