Wild Life  2.29
 All Data Structures Files Functions Variables Typedefs Macros
bi_type.c
Go to the documentation of this file.
1 
6 //
7 // Copyright (c) 1992 Digital Equipment Corporation
8 // All Rights Reserved.
9 //
10 // The standard digital prl copyrights exist and where compatible
11 // the below also exists.
12 // Permission to use, copy, modify, and distribute this
13 // software and its documentation for any purpose and without
14 // fee is hereby granted, provided that the above copyright
15 // notice appear in all copies. Copyright holder(s) make no
16 // representation about the suitability of this software for
17 // any purpose. It is provided "as is" without express or
18 // implied warranty.
19 //
20 //
21 
22 #include "defs.h"
23 
30 static long c_children() /* RM: Dec 14 1992 Re-wrote most of the routine */
31 {
32  long success=TRUE;
33  ptr_psi_term funct,result,arg1,arg2,t,p1;
34  ptr_int_list p;
35 
36  funct=aim->aaaa_1;
37  deref_ptr(funct);
38  result=aim->bbbb_1;
39  get_two_args(funct->attr_list,&arg1,&arg2);
40 
41  if (!arg1) {
42  curry();
43  return success;
44  }
45 
46  deref(arg1);
47  deref_args(funct,set_1);
49 
50  if (arg1->type==top)
51  t=collect_symbols(greatest_sel); /* RM: Feb 3 1993 */
52  else {
53  p=arg1->type->children;
54 
55  /* Hack: check there's enough memory to build the list */
56  /* RM: Jul 22 1993 */
57  /*
58  { int count=0;
59  while(p) {
60  count++;
61  p=p->next;
62  }
63  if (heap_pointer-stack_pointer < 3*count*sizeof(psi_term)) {
64  goal_stack=aim;
65  garbage();
66  return success;
67  }
68  */
69 
70  t=stack_nil();
71  if (!(arg1->type==real && arg1->value_3)) /* PVR 15.2.94 */
72  while (p) {
73  ptr_definition ptype;
74 
75  ptype = (ptr_definition) p->value_1;
76  if (hidden_type(ptype)) { p=p->next; continue; }
77  p1 = stack_psi_term(0);
78  p1->type = ptype;
79  t=stack_cons(p1,t);
80  p = p->next;
81  }
82  }
83  push_goal(unify,result,t,NULL);
84 
85  return success;
86 }
87 
88 
89 
96 static long c_parents()
97 {
98  long success=TRUE;
99  ptr_psi_term funct,result,arg1,arg2,t,p1;
100  ptr_int_list p;
101 
102  funct=aim->aaaa_1;
103  deref_ptr(funct);
104  result=aim->bbbb_1;
105  get_two_args(funct->attr_list,&arg1,&arg2);
106  if (arg1) {
107  deref(arg1);
108  deref_args(funct,set_1);
109  resid_aim=NULL;
110  t=stack_nil(); /* RM: Dec 14 1992 */
111  p = arg1->type->parents;
112  if (arg1->type!=top && p==NULL) {
113  /* Top is the only parent */
114  p1 = stack_psi_term(4);
115  p1->type = (ptr_definition) top;
116  t=stack_cons(p1,t); /* RM: Dec 14 1992 */
117  }
118  else {
119  if ((arg1->type==quoted_string || arg1->type==integer ||
120  arg1->type==real) && arg1->value_3!=NULL) {
121  /* arg1 is a string, long or real: return a list with arg1 as
122  argument, where arg1->value_2 = NULL, MH */
123  p1 = stack_psi_term(4);
124  p1->type = arg1->type;
125  t=stack_cons(p1,t); /* RM: Dec 14 1992 */
126  }
127  else {
128  /* Look at the parents list */
129  while (p) {
130  ptr_definition ptype;
131 
132  ptype = (ptr_definition) p->value_1;
133  if (hidden_type(ptype)) { p=p->next; continue; }
134  p1 = stack_psi_term(4);
135  p1->type = ptype;
136  t=stack_cons(p1,t); /* RM: Dec 14 1992 */
137  p = p->next;
138  }
139  }
140  }
141  push_goal(unify,result,t,NULL);
142  }
143  else
144  curry();
145 
146  return success;
147 }
148 
149 
150 
151 
159 static long c_smallest()
160 {
161  long success=TRUE;
162  ptr_psi_term result, g, t;
163 
164  g=aim->aaaa_1;
166  result=aim->bbbb_1;
167  t=collect_symbols(least_sel); /* RM: Feb 3 1993 */
168  push_goal(unify,result,t,NULL);
169 
170  return success;
171 }
172 
181 {
182  long ans=TRUE;
183 
184  /* we already know that either arg1->type == arg2->type or that at both
185  * of the two are either long or real
186  */
187 
188  if (arg2->value_3) {
189  if (arg1->value_3) {
190  if (arg1->type==real || arg1->type==integer) {
191  ans=( *(REAL *)arg1->value_3 == *(REAL *)arg2->value_3);
192  }
193  else if (arg1->type==quoted_string) {
194  ans=(strcmp((char *)arg1->value_3,(char *)arg2->value_3)==0);
195  }
196  }
197  else
198  ans=FALSE;
199  }
200  else {
201  if (arg1->value_3 && (arg1->type==real || arg1->type==integer)) {
202  if (arg2->type==integer)
203  ans=(*(REAL *)arg1->value_3 == floor(*(REAL *)arg1->value_3));
204  else
205  ans=TRUE;
206  }
207  }
208  return ans;
209 }
210 
217 static long isa(arg1,arg2)
218  ptr_psi_term arg1, arg2;
219 {
220  long ans;
221 
222  if ( arg1->type==arg2->type
223  || ( (arg1->type==real || arg1->type==integer)
224  && (arg2->type==real || arg2->type==integer)
225  && (arg1->value_3 || arg2->value_3)
226  )
227  ) {
228 
229  if(arg1->type==cut) /* RM: Jan 21 1993 */
230  ans=TRUE;
231  else
232  ans=isSubTypeValue(arg1, arg2);
233  }
234  else {
235  (void)matches(arg1->type, arg2->type, &ans);
236  }
237 
238  /*Errorline("isa %P %P -> %d\n",arg1,arg2,ans);*/
239 
240  return ans;
241 }
242 
249 static long isa_select(ptr_psi_term arg1,ptr_psi_term arg2,long sel)
250 {
251  long ans;
252 
253  switch (sel) {
254  case isa_le_sel: ans=isa(arg1,arg2);
255  break;
256  case isa_lt_sel: ans=isa(arg1,arg2) && !isa(arg2,arg1);
257  break;
258  case isa_ge_sel: ans=isa(arg2,arg1);
259  break;
260  case isa_gt_sel: ans=isa(arg2,arg1) && !isa(arg1,arg2);
261  break;
262  case isa_eq_sel: ans=isa(arg1,arg2) && isa(arg2,arg1);
263  break;
264 
265  case isa_nle_sel: ans= !isa(arg1,arg2);
266  break;
267  case isa_nlt_sel: ans= !(isa(arg1,arg2) && !isa(arg2,arg1));
268  break;
269  case isa_nge_sel: ans= !isa(arg2,arg1);
270  break;
271  case isa_ngt_sel: ans= !(isa(arg2,arg1) && !isa(arg1,arg2));
272  break;
273  case isa_neq_sel: ans= !(isa(arg1,arg2) && isa(arg2,arg1));
274  break;
275 
276  case isa_cmp_sel: ans=isa(arg1,arg2) || isa(arg2,arg1);
277  break;
278  case isa_ncmp_sel: ans= !(isa(arg1,arg2) || isa(arg2,arg1));
279  break;
280  }
281  return ans;
282 }
283 
290 static long c_isa_main(long sel)
291 {
292  long success=TRUE,ans;
293  ptr_psi_term arg1,arg2,funct,result;
294 
295  funct=aim->aaaa_1;
296  deref_ptr(funct);
297  result=aim->bbbb_1;
298  get_two_args(funct->attr_list,&arg1,&arg2);
299  if (arg1 && arg2) {
300  deref(arg1);
301  deref(arg2);
302  deref_args(funct,set_1_2);
303  ans=isa_select(arg1,arg2,sel);
304  unify_bool_result(result,ans);
305  }
306  else curry();
307 
308  return success;
309 }
310 
322 static long c_isa_le()
323 {
324  return c_isa_main(isa_le_sel);
325 }
337 static long c_isa_lt()
338 {
339  return c_isa_main(isa_lt_sel);
340 }
352 static long c_isa_ge()
353 {
354  return c_isa_main(isa_ge_sel);
355 }
367 static long c_isa_gt()
368 {
369  return c_isa_main(isa_gt_sel);
370 }
382 static long c_isa_eq()
383 {
384  return c_isa_main(isa_eq_sel);
385 }
397 static long c_isa_nle()
398 {
399  return c_isa_main(isa_nle_sel);
400 }
412 static long c_isa_nlt()
413 {
414  return c_isa_main(isa_nlt_sel);
415 }
427 static long c_isa_nge()
428 {
429  return c_isa_main(isa_nge_sel);
430 }
442 static long c_isa_ngt()
443 {
444  return c_isa_main(isa_ngt_sel);
445 }
457 static long c_isa_neq()
458 {
459  return c_isa_main(isa_neq_sel);
460 }
466 static long c_isa_cmp()
467 {
468  return c_isa_main(isa_cmp_sel);
469 }
475 static long c_isa_ncmp()
476 {
477  return c_isa_main(isa_ncmp_sel);
478 }
479 
480 
481 
488 static long c_is_function() /* RM: Jan 29 1993 */
489 {
490  int success=TRUE,ans;
491  ptr_psi_term arg1,funct,result;
492 
493  funct=aim->aaaa_1;
494  deref_ptr(funct);
495  result=aim->bbbb_1;
496  get_one_arg(funct->attr_list,&arg1);
497  if (arg1) {
498  deref(arg1);
499  deref_args(funct,set_1);
500  ans=(arg1->type->type_def==(def_type)function_it);
501  unify_bool_result(result,ans);
502  }
503  else curry();
504 
505  return success;
506 }
507 
508 
509 
516 static long c_is_persistent() /* RM: Feb 9 1993 */
517 {
518  int success=TRUE,ans;
519  ptr_psi_term arg1,glob,result;
520 
521  glob=aim->aaaa_1;
522  deref_ptr(glob);
523  result=aim->bbbb_1;
524  get_one_arg(glob->attr_list,&arg1);
525  if (arg1) {
526  deref(arg1);
527  deref_args(glob,set_1);
528  ans=(
529  arg1->type->type_def==(def_type)global &&
531  ) ||
532  (GENERIC)arg1>=heap_pointer;
533  unify_bool_result(result,ans);
534  }
535  else curry();
536 
537  return success;
538 }
539 
540 
541 
548 static long c_is_predicate() /* RM: Jan 29 1993 */
549 {
550  int success=TRUE,ans;
551  ptr_psi_term arg1,funct,result;
552 
553  funct=aim->aaaa_1;
554  deref_ptr(funct);
555  result=aim->bbbb_1;
556  get_one_arg(funct->attr_list,&arg1);
557  if (arg1) {
558  deref(arg1);
559  deref_args(funct,set_1);
560  ans=(arg1->type->type_def==(def_type)predicate);
561  unify_bool_result(result,ans);
562  }
563  else curry();
564 
565  return success;
566 }
567 
568 
569 
576 static long c_is_sort() /* RM: Jan 29 1993 */
577 {
578  int success=TRUE,ans;
579  ptr_psi_term arg1,funct,result;
580 
581  funct=aim->aaaa_1;
582  deref_ptr(funct);
583  result=aim->bbbb_1;
584  get_one_arg(funct->attr_list,&arg1);
585  if (arg1) {
586  deref(arg1);
587  deref_args(funct,set_1);
588  ans=(arg1->type->type_def==(def_type)type_it);
589  unify_bool_result(result,ans);
590  }
591  else curry();
592 
593  return success;
594 }
595 
596 
597 
606 static long c_is_value()
607 {
608  long success=TRUE,ans;
609  ptr_psi_term arg1,arg2,funct,result;
610 
611  funct=aim->aaaa_1;
612  deref_ptr(funct);
613  result=aim->bbbb_1;
614  get_two_args(funct->attr_list,&arg1,&arg2);
615  if (arg1) {
616  deref(arg1);
617  deref_args(funct,set_1);
618  ans=(arg1->value_3!=NULL);
619  unify_bool_result(result,ans);
620  }
621  else curry();
622 
623  return success;
624 }
625 
632 static long c_is_number()
633 {
634  long success=TRUE,ans;
635  ptr_psi_term arg1,arg2,funct,result;
636 
637  funct=aim->aaaa_1;
638  deref_ptr(funct);
639  result=aim->bbbb_1;
640  get_two_args(funct->attr_list,&arg1,&arg2);
641  if (arg1) {
642  deref(arg1);
643  deref_args(funct,set_1);
644  ans=sub_type(arg1->type,real) && (arg1->value_3!=NULL);
645  unify_bool_result(result,ans);
646  }
647  else curry();
648 
649  return success;
650 }
651 
652 
662 {
663  ptr_psi_term pred,arg1,arg2;
664 
665  pred=aim->aaaa_1;
666  deref_ptr(pred);
667  get_two_args(pred->attr_list,&arg1,&arg2);
668 
669  if (!arg1) (void)reportAndAbort(pred,"no first argument");
670  deref(arg1);
671 
672  if (!arg2) (void)reportAndAbort(pred,"no second argument");
673  deref(arg2);
674 
675  deref_args(pred, set_1_2);
676 
677  if (isa(arg1, arg2))
678  {
679  residuate(arg2);
680  return TRUE;
681  }
682  return FALSE;
683 }
684 
692 {
693  return (p->value_3 != NULL);
694 }
695 
696 
697 
708 long c_glb()
709 {
710  ptr_psi_term func,arg1,arg2, result, other;
711  ptr_definition ans;
712  ptr_int_list complexType;
713  ptr_int_list decodedType = NULL;
714  long ret;
715 
716  func=aim->aaaa_1;
717  deref_ptr(func);
718  get_two_args(func->attr_list,&arg1,&arg2);
719 
720  if ((!arg1) || (!arg2)) {
721  curry();
722  return TRUE;
723  }
724  result = aim->bbbb_1;
725  deref(result);
726  deref(arg1);
727  deref(arg2);
728  deref_args(func, set_1_2);
729 
730  if ((ret=glb(arg1->type, arg2->type, &ans, &complexType)) == 0)
731  return FALSE;
732 
733  if ((ret != 4)&&(isValue(arg1)||isValue(arg2))) {
734  /* glb is one of arg1->type or arg2->type AND at least one is a value */
735  if (!isSubTypeValue(arg1, arg2) && !isSubTypeValue(arg2, arg1))
736  return FALSE;
737  }
738  if (!ans) {
739  decodedType = decode(complexType);
740  ans = (ptr_definition)decodedType->value_1;
741  decodedType = decodedType->next;
742  }
743  other=makePsiTerm(ans);
744 
745  if (isValue(arg1)) other->value_3=arg1->value_3;
746  if (isValue(arg2)) other->value_3=arg2->value_3;
747 
748  if (isValue(arg1) || isValue(arg2)) {
749  if (decodedType) {
750  Errorline("glb of multiple-inheritance value sorts not yet implemented.\n");
751  return FALSE;
752  }
753  }
754 
755  if (decodedType)
756  push_choice_point(type_disj, result,(ptr_psi_term) decodedType,(GENERIC) NULL);
757 
758  resid_aim = NULL;
759  push_goal(unify,result,other,NULL);
760  return TRUE;
761 }
762 
763 
764 
775 long c_lub()
776 {
777  ptr_psi_term func,arg1,arg2, result, other;
778  ptr_definition ans=NULL;
779  ptr_int_list decodedType = NULL;
780 
781  func=aim->aaaa_1;
782  deref_ptr(func);
783  get_two_args(func->attr_list,&arg1,&arg2);
784 
785  if ((!arg1) || (!arg2))
786  {
787  curry();
788  return TRUE;
789  }
790  result = aim->bbbb_1;
791  deref(result);
792  deref(arg1);
793  deref(arg2);
794  deref_args(func, set_1_2);
795 
796  /* now lets find the list of types that is the lub */
797 
798  decodedType = lub(arg1, arg2, &other);
799 
800  if (decodedType) {
801  ans = (ptr_definition)decodedType->value_1;
802  decodedType = decodedType->next;
803  other = makePsiTerm(ans);
804  }
805 
806  if (decodedType)
807  push_choice_point(type_disj, result,(ptr_psi_term) decodedType,(GENERIC) NULL);
808 
809  resid_aim = NULL;
810  push_goal(unify,result,other,NULL);
811  return TRUE;
812 }
813 
820 void insert_type_builtins() /* RM: Jan 29 1993 */
821 {
822  /* Sort comparisons */
824  new_built_in(syntax_module,":<",(def_type)function_it,c_isa_lt);
825  new_built_in(syntax_module,":>=",(def_type)function_it,c_isa_ge);
826  new_built_in(syntax_module,":>",(def_type)function_it,c_isa_gt);
827  new_built_in(syntax_module,":==",(def_type)function_it,c_isa_eq);
828  new_built_in(syntax_module,":><",(def_type)function_it,c_isa_cmp);
829  new_built_in(syntax_module,":\\=<",(def_type)function_it,c_isa_nle);
830  new_built_in(syntax_module,":\\<",(def_type)function_it,c_isa_nlt);
831  new_built_in(syntax_module,":\\>=",(def_type)function_it,c_isa_nge);
832  new_built_in(syntax_module,":\\>",(def_type)function_it,c_isa_ngt);
833  new_built_in(syntax_module,":\\==",(def_type)function_it,c_isa_neq);
834  new_built_in(syntax_module,":\\><",(def_type)function_it,c_isa_ncmp);
835 
836 
837  /* Type checks */
838  new_built_in(bi_module,"is_value",(def_type)function_it,c_is_value);
839  new_built_in(bi_module,"is_number",(def_type)function_it,c_is_number);
840  new_built_in(bi_module,"is_function",(def_type)function_it,c_is_function);
841  new_built_in(bi_module,"is_predicate",(def_type)function_it,c_is_predicate);
842  new_built_in(bi_module,"is_sort",(def_type)function_it,c_is_sort);
843  new_built_in(bi_module,"is_persistent",(def_type)function_it,c_is_persistent);
844 
845  /* Sort hierarchy maneuvering */
846  new_built_in(bi_module,"children",(def_type)function_it,c_children);
847  new_built_in(bi_module,"parents",(def_type)function_it,c_parents);
848  new_built_in(bi_module,"least_sorts",(def_type)function_it,c_smallest);
850  new_built_in(bi_module,"glb",(def_type)function_it,c_glb);
851  new_built_in(bi_module,"lub",(def_type)function_it,c_lub);
852 }
ptr_psi_term makePsiTerm(ptr_definition x)
Definition: bi_sys.c:572
void new_built_in(ptr_module m, char *s, def_type t, long(*r)())
new_built_in
Definition: built_ins.c:5371
ptr_psi_term aaaa_1
Definition: def_struct.h:224
static long c_isa_cmp()
c_isa_cmp
Definition: bi_type.c:466
#define predicate
Definition: def_const.h:361
#define function_it
Definition: def_const.h:362
void get_two_args(ptr_node t, ptr_psi_term *a, ptr_psi_term *b)
get_two_args
Definition: login.c:47
int isSubTypeValue(ptr_psi_term arg1, ptr_psi_term arg2)
isSubTypeValue
Definition: bi_type.c:180
static long c_smallest()
c_smallest
Definition: bi_type.c:159
static long isa(ptr_psi_term arg1, ptr_psi_term arg2)
Definition: bi_type.c:217
struct wl_definition * def_type
Definition: def_struct.h:32
ptr_psi_term stack_cons(ptr_psi_term head, ptr_psi_term tail)
stack_cons
Definition: built_ins.c:46
void insert_type_builtins()
void insert_type_builtins
Definition: bi_type.c:820
void residuate(ptr_psi_term t)
residuate
Definition: lefun.c:125
#define least_sel
Definition: def_const.h:6
long c_lub()
long c_lub
Definition: bi_type.c:775
#define isa_nlt_sel
Definition: def_const.h:305
long glb(ptr_definition t1, ptr_definition t2, ptr_definition *t3, ptr_int_list *c3)
glb
Definition: types.c:1481
void push_choice_point(goals t, ptr_psi_term a, ptr_psi_term b, GENERIC c)
push_choice_point
Definition: login.c:638
void push_goal(goals t, ptr_psi_term a, ptr_psi_term b, GENERIC c)
push_goal
Definition: login.c:600
#define isa_eq_sel
Definition: def_const.h:303
static long c_is_number()
static long c_is_number
Definition: bi_type.c:632
static long c_is_predicate()
c_is_predicate
Definition: bi_type.c:548
static long c_isa_lt()
c_isa_lt
Definition: bi_type.c:337
#define global
Definition: def_const.h:364
void unify_bool_result(ptr_psi_term t, long v)
unify_bool_result
Definition: built_ins.c:345
static long c_isa_ncmp()
c_isa_ncmp
Definition: bi_type.c:475
long c_glb()
long c_glb
Definition: bi_type.c:708
ptr_int_list decode(ptr_int_list c)
decode
Definition: types.c:1784
long reportAndAbort(ptr_psi_term g, char *s)
Definition: error.c:732
def_type type_def
Definition: def_struct.h:133
long matches(ptr_definition t1, ptr_definition t2, long *smaller)
matches
Definition: types.c:1666
#define set_empty
Definition: def_const.h:193
#define isa_le_sel
Definition: def_const.h:299
void get_one_arg(ptr_node t, ptr_psi_term *a)
get_one_arg
Definition: login.c:99
#define set_1
Definition: def_const.h:194
ptr_definition top
Definition: def_glob.h:106
void curry()
curry
Definition: lefun.c:174
#define NULL
Definition: def_const.h:203
ptr_goal resid_aim
Definition: def_glob.h:220
#define REAL
Definition: def_const.h:72
static long c_children()
Return a list of roots of the children types of T (except bottom).
Definition: bi_type.c:30
static long c_isa_nle()
c_isa_nle
Definition: bi_type.c:397
long sub_type(ptr_definition t1, ptr_definition t2)
sub_type
Definition: types.c:1642
#define isa_nge_sel
Definition: def_const.h:306
#define isa_ngt_sel
Definition: def_const.h:307
#define type_it
Definition: def_const.h:363
void Errorline(char *format,...)
Definition: error.c:414
#define set_1_2
Definition: def_const.h:196
ptr_definition real
Definition: def_glob.h:102
#define greatest_sel
Definition: def_const.h:7
#define deref_ptr(P)
Definition: def_macro.h:95
#define isa_neq_sel
Definition: def_const.h:308
static long c_isa_ge()
c_isa_ge
Definition: bi_type.c:352
#define TRUE
Definition: def_const.h:127
long c_isa_subsort()
long c_isa_subsort
Definition: bi_type.c:661
static long c_isa_nlt()
c_isa_nlt
Definition: bi_type.c:412
static long c_isa_ngt()
c_isa_ngt
Definition: bi_type.c:442
static long c_isa_gt()
c_isa_gt
Definition: bi_type.c:367
ptr_definition integer
Definition: def_glob.h:93
ptr_psi_term global_value
Definition: def_struct.h:141
#define FALSE
Definition: def_const.h:128
#define deref(P)
Definition: def_macro.h:142
ptr_int_list lub(ptr_psi_term a, ptr_psi_term b, ptr_psi_term *pp)
Definition: lub.c:173
ptr_definition quoted_string
Definition: def_glob.h:101
struct wl_definition * ptr_definition
Definition: def_struct.h:31
ptr_psi_term stack_psi_term(long stat)
stack_psi_term
Definition: lefun.c:21
GENERIC value_3
Definition: def_struct.h:170
ptr_module syntax_module
Definition: def_glob.h:159
ptr_psi_term stack_nil()
stack_nil
Definition: built_ins.c:26
ptr_goal aim
Definition: def_glob.h:49
static long c_is_value()
c_is_value
Definition: bi_type.c:606
GENERIC heap_pointer
Definition: def_glob.h:12
#define isa_cmp_sel
Definition: def_const.h:309
static long c_isa_nge()
c_isa_nge
Definition: bi_type.c:427
#define unify
Definition: def_const.h:274
#define isa_nle_sel
Definition: def_const.h:304
static long c_parents()
Return a list of roots of the parent types of T.
Definition: bi_type.c:96
static long c_is_sort()
c_is_sort
Definition: bi_type.c:576
#define deref_args(P, S)
Definition: def_macro.h:145
#define isa_ge_sel
Definition: def_const.h:301
ptr_psi_term collect_symbols(long sel)
collect_symbols
Definition: built_ins.c:3696
ptr_definition cut
Definition: def_glob.h:83
static long c_is_function()
c_is_function
Definition: bi_type.c:488
static long isa_select(ptr_psi_term arg1, ptr_psi_term arg2, long sel)
isa_select
Definition: bi_type.c:249
static long c_isa_eq()
c_isa_eq
Definition: bi_type.c:382
static long c_isa_main(long sel)
c_isa_main
Definition: bi_type.c:290
#define type_disj
Definition: def_const.h:284
ptr_module bi_module
Definition: def_glob.h:155
#define isa_gt_sel
Definition: def_const.h:302
long isValue(ptr_psi_term p)
isValue(p)
Definition: bi_type.c:691
static long c_isa_le()
c_isa_le
Definition: bi_type.c:322
ptr_definition type
Definition: def_struct.h:165
static long c_is_persistent()
c_is_persistent
Definition: bi_type.c:516
#define isa_lt_sel
Definition: def_const.h:300
GENERIC value_1
Definition: def_struct.h:54
ptr_psi_term bbbb_1
Definition: def_struct.h:225
#define isa_ncmp_sel
Definition: def_const.h:310
unsigned long * GENERIC
Definition: def_struct.h:17
static long c_isa_neq()
c_isa_neq
Definition: bi_type.c:457
long hidden_type(ptr_definition t)
hidden_type
Definition: built_ins.c:3669
ptr_int_list children
Definition: def_struct.h:131
ptr_node attr_list
Definition: def_struct.h:171
ptr_int_list next
Definition: def_struct.h:55
ptr_int_list parents
Definition: def_struct.h:130