arity.c:    fprintf(features,"---- Unifications and Features ----\n\n");
arity.c:    fprintf(features,"\ttop-top: %d = %3.1lf\n",PERUNIF(Atoptop));
arity.c:    fprintf(features,"\ttop-X: %d = %3.1lf\n",PERUNIF(Atop));
arity.c:    fprintf(features,"\tX-X: %d = %3.1lf\n",PERUNIF(Auid));
arity.c:    fprintf(features,"\tX-Y: %d = %3.1lf\n",PERUNIF(Audiff));
arity.c:    fprintf(features,"\tnil-nil: %d = %3.1lf\n",PERMERGE(Anilnil));
arity.c:    fprintf(features,"\tnil-X: %d = %3.1lf\n",PERMERGE(Anil));
arity.c:    fprintf(features,"\tX-X: %d = %3.1lf\n",PERMERGE(Aident));
arity.c:    fprintf(features,"\tX-Y: %d = %3.1lf\n",PERMERGE(Adiff));
arity.c:    if(n->left) {
arity.c:      rec_print_feat(n->left);
arity.c:    fprintf(features,n->key);
arity.c:    if(n->right) {
arity.c:      rec_print_feat(n->right);
arity.c:    same=check_equal(u->left,v) &&
arity.c:      find(FEATURECMP,u->key,v) &&
arity.c:	check_equal(u->right,v);
arity.c:  if(u->type==top)
arity.c:    if(v->type==top)
arity.c:    if(v->type==top)
arity.c:      if(u->type==v->type)
arity.c:	if(u->type->children || v->type->children)
arity.c:    u->type->keyword->symbol,
arity.c:    v->type->keyword->symbol);
arity.c:  fprintf(features,"add %s to %s",s,u->type->keyword->symbol);
arity.c:  print_features(u->attr_list);
bi_math.c: * bi_math.c - math builtins
bi_math.c:  Multiplication is considered as a 3-variable relation as in Prolog:
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  constant-time independent of argument values.
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:		if ((tmp>  1 && val3==trunc(val1/(tmp-1))) ||
bi_math.c:		    (tmp< -1 && val3==trunc(val1/(tmp+1))))
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_one_arg(t->attr_list,&arg1);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_one_arg(t->attr_list,&arg1);
bi_math.c:  arg3=aim->b;
bi_math.c:          if (trigflag==TANFLAG || (val3>= -1 && val3<=1)) {
bi_math.c:  t=aim->a;
bi_math.c:  get_one_arg(t->attr_list,&arg1);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  Addition is considered as a 3-variable relation as in Prolog:
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:	  success=unify_real_result(arg2,val3-val1);
bi_math.c:	  success=unify_real_result(arg1,val3-val2);
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:	  success=unify_real_result(arg3,val1-val2);
bi_math.c:	  success=unify_real_result(arg2,val1-val3);
bi_math.c:	  success=(val3==val1-val2);
bi_math.c:	    success=unify_real_result(arg3,-val1);
bi_math.c:	    success=unify_real_result(arg1,-val3);
bi_math.c:	    success=(val1== -val3);
bi_math.c:  t=aim->a;
bi_math.c:  get_one_arg(t->attr_list,&arg1);
bi_math.c:  arg3=aim->b;
bi_math.c:  t=aim->a;
bi_math.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_math.c:  arg3=aim->b;
bi_math.c:  new_built_in(syntax_module,"-",function,c_sub);
bi_sys.c:  t=aim->a;
bi_sys.c:  get_two_args(t->attr_list,&arg1,&arg2);
bi_sys.c:    else if (arg1->type==true)
bi_sys.c:    else if (arg1->type==false)
bi_sys.c:    else if (arg2->type==true)
bi_sys.c:    else if (arg2->type==false)
bi_sys.c:  t=aim->a;
bi_sys.c:  t=aim->a;
bi_sys.c:  t=aim->a;
bi_sys.c:  t=aim->a;
bi_sys.c:  t=aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:  t=aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:  ans->type = NOTQUIET ? false : true;
bi_sys.c:  Return the cpu-time in seconds used by the Wild_Life interpreter.
bi_sys.c:  t=aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:    thetime=(life_end.tms_utime-life_start.tms_utime)/60.0;
bi_sys.c:  This is useful for building real-time applications such as clocks.
bi_sys.c:  t=aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:  Return a psi-term containing the local time split up into year, month, day,
bi_sys.c:  This is useful for building real-time applications such as clocks.
bi_sys.c:  t=aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:  psitime->type=timesym;
bi_sys.c:  stack_add_int_attr(psitime, year_attr,    thetime->tm_year+1900);
bi_sys.c:  stack_add_int_attr(psitime, month_attr,   thetime->tm_mon+1);
bi_sys.c:  stack_add_int_attr(psitime, day_attr,     thetime->tm_mday);
bi_sys.c:  stack_add_int_attr(psitime, hour_attr,    thetime->tm_hour);
bi_sys.c:  stack_add_int_attr(psitime, minute_attr,  thetime->tm_min);
bi_sys.c:  stack_add_int_attr(psitime, second_attr,  thetime->tm_sec);
bi_sys.c:  stack_add_int_attr(psitime, weekday_attr, thetime->tm_wday);
bi_sys.c:  t=aim->a;
bi_sys.c:  t1 = sizeof(mem_base)*(stack_pointer-mem_base);
bi_sys.c:  t2 = sizeof(mem_base)*(mem_limit-heap_pointer);
bi_sys.c:  t3 = sizeof(mem_base)*(mem_limit-mem_base);
bi_sys.c:  t=aim->a;
bi_sys.c:  funct = aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:  get_two_args(funct->attr_list, &arg1, &arg2);
bi_sys.c:    if(matches(arg1->type,quoted_string,&longer) && arg1->value) {
bi_sys.c:      s=(GENERIC)getenv((char *)arg1->value);
bi_sys.c:	t->type=quoted_string;
bi_sys.c:	t->value=(GENERIC)heap_copy_string(s);
bi_sys.c:  funct=aim->a;
bi_sys.c:  result=aim->b;
bi_sys.c:  get_two_args(funct->attr_list,&arg1,&arg2);
bi_sys.c:    if((success=matches(arg1->type,quoted_string,&smaller)))
bi_sys.c:      if(arg1->value) {
bi_sys.c:	value=(REAL)system((char *)arg1->value);
bi_sys.c:  t=aim->a;
bi_sys.c:	return makePsiTerm((void *)p->value);
bi_sys.c:	return (GENERIC )(p->next);
bi_sys.c:/* Return a ptr to a psi-term marked as  evaluated.  The psi-term is a copy at
bi_sys.c: * the top level of the goal residuated on p, with the rest of the psi-term
bi_sys.c:	copyPsiTerm(psi, p->goal->a);
bi_sys.c:	psi->status = 4;
bi_sys.c:	return (GENERIC )(p->next);
bi_sys.c:	p->type = x;
bi_sys.c:  rlist(A) ->  list all eval/prove goals residuated on variable 'A'.
bi_sys.c:	func = aim->a;
bi_sys.c:	get_one_arg(func->attr_list, &arg1);
bi_sys.c:	result = aim->b;
bi_sys.c:	other = makePsiList((void *)arg1->resid,
bi_sys.c:	g->next=NULL;
bi_sys.c:  residuate(A,B) ->  residuate goal B on variable A, non_strict in both args
bi_sys.c:	pred = aim->a;
bi_sys.c:	get_two_args(pred->attr_list, &arg1, &arg2);
bi_sys.c:  Multiple-variable residuation of a predicate.
bi_sys.c:  mresiduate(A,B) ->  residuate goal B on a list of variables A, non_strict in
bi_sys.c:  pred = aim->a;
bi_sys.c:  get_two_args(pred->attr_list, &arg1, &arg2);
bi_sys.c:  while(tmp && tmp->type==alist) { /*  RM: Dec 14 1992  */
bi_sys.c:    get_two_args(tmp->attr_list,&var,&tmp);
bi_sys.c:  if(!tmp || tmp->type!=nil) {
bi_sys.c:    Errorline("%P should be a nil-terminated list in mresiduate.\n",arg1);
bi_type.c: * bi_type.c - builtins for doing type heierachy stuff
bi_type.c:static long c_children()   /*  RM: Dec 14 1992  Re-wrote most of the routine */
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_two_args(funct->attr_list,&arg1,&arg2);
bi_type.c:  if (arg1->type==top)
bi_type.c:    p=arg1->type->children;
bi_type.c:      p=p->next;
bi_type.c:      if (heap_pointer-stack_pointer < 3*count*sizeof(psi_term)) {
bi_type.c:    if (!(arg1->type==real && arg1->value)) /* PVR 15.2.94 */
bi_type.c:        ptype = (ptr_definition) p->value;
bi_type.c:        if (hidden_type(ptype)) { p=p->next; continue; }
bi_type.c:        p1->type = ptype;
bi_type.c:        p = p->next;
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_two_args(funct->attr_list,&arg1,&arg2);
bi_type.c:    p = arg1->type->parents;
bi_type.c:    if (arg1->type!=top && p==NULL) {
bi_type.c:      p1->type = (ptr_definition) top;
bi_type.c:      if ((arg1->type==quoted_string || arg1->type==integer ||
bi_type.c:          arg1->type==real) && arg1->value!=NULL) {
bi_type.c:           argument, where arg1->value = NULL, MH */
bi_type.c:        p1->type = arg1->type;
bi_type.c:          ptype = (ptr_definition) p->value;
bi_type.c:          if (hidden_type(ptype)) { p=p->next; continue; }
bi_type.c:          p1->type = ptype;
bi_type.c:          p = p->next;
bi_type.c:  g=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  /* we already know that either arg1->type == arg2->type or that at both
bi_type.c:  if (arg2->value) {
bi_type.c:    if (arg1->value) {
bi_type.c:      if (arg1->type==real || arg1->type==integer) {
bi_type.c:        ans=( *(REAL *)arg1->value == *(REAL *)arg2->value);
bi_type.c:      else if (arg1->type==quoted_string) {
bi_type.c:        ans=lf_strcmp((char *)arg1->value,(char *)arg2->value)==0;
bi_type.c:    if (arg1->value && (arg1->type==real || arg1->type==integer)) {
bi_type.c:      if (arg2->type==integer)
bi_type.c:        ans=(*(REAL *)arg1->value == floor(*(REAL *)arg1->value));
bi_type.c:  if (  arg1->type==arg2->type
bi_type.c:     || (  (arg1->type==real || arg1->type==integer)
bi_type.c:        && (arg2->type==real || arg2->type==integer)
bi_type.c:        && (arg1->value || arg2->value)
bi_type.c:    if(arg1->type==cut) /*  RM: Jan 21 1993  */
bi_type.c:    matches(arg1->type, arg2->type, &ans);
bi_type.c:  /*Errorline("isa %P %P -> %d\n",arg1,arg2,ans);*/
bi_type.c:  Main routine to handle all the isa built-in functions.
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_two_args(funct->attr_list,&arg1,&arg2);
bi_type.c:  Succeed iff argument is a function (built-in or user-defined).
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_one_arg(funct->attr_list,&arg1);
bi_type.c:    ans=(arg1->type->type==function);
bi_type.c:  glob=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_one_arg(glob->attr_list,&arg1);
bi_type.c:	 arg1->type->type==global &&
bi_type.c:	 (GENERIC)arg1->type->global_value>=heap_pointer
bi_type.c:  Succeed iff argument is a predicate (built-in or user-defined).
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_one_arg(funct->attr_list,&arg1);
bi_type.c:    ans=(arg1->type->type==predicate);
bi_type.c:  Succeed iff argument is a sort (built-in or user-defined).
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_one_arg(funct->attr_list,&arg1);
bi_type.c:    ans=(arg1->type->type==type);
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_two_args(funct->attr_list,&arg1,&arg2);
bi_type.c:    ans=(arg1->value!=NULL);
bi_type.c:  funct=aim->a;
bi_type.c:  result=aim->b;
bi_type.c:  get_two_args(funct->attr_list,&arg1,&arg2);
bi_type.c:    ans=sub_type(arg1->type,real) && (arg1->value!=NULL);
bi_type.c:  pred=aim->a;
bi_type.c:  get_two_args(pred->attr_list,&arg1,&arg2);
bi_type.c:	return (p->value != NULL);
bi_type.c:  func=aim->a;
bi_type.c:  get_two_args(func->attr_list,&arg1,&arg2);
bi_type.c:  result = aim->b;
bi_type.c:  if ((ret=glb(arg1->type, arg2->type, &ans, &complexType)) == 0)
bi_type.c:    /* glb is one of arg1->type or arg2->type AND at least one is a value */
bi_type.c:    ans = (ptr_definition)decodedType->value;
bi_type.c:    decodedType = decodedType->next;
bi_type.c:  if (isValue(arg1)) other->value=arg1->value;
bi_type.c:  if (isValue(arg2)) other->value=arg2->value;
bi_type.c:      Errorline("glb of multiple-inheritance value sorts not yet implemented.\n");
bi_type.c:  func=aim->a;
bi_type.c:  get_two_args(func->attr_list,&arg1,&arg2);
bi_type.c:  result = aim->b;
bi_type.c:    ans = (ptr_definition)decodedType->value;
bi_type.c:    decodedType = decodedType->next;
built_ins.c:  empty->type=nil;
built_ins.c:  cons->type=alist;
built_ins.c:    stack_insert(FEATURECMP,(GENERIC)one,&(cons->attr_list),(GENERIC)head);
built_ins.c:    stack_insert(FEATURECMP,(GENERIC)two,&(cons->attr_list),(GENERIC)tail);
built_ins.c:  pair->type=and;
built_ins.c:    stack_insert(FEATURECMP,(GENERIC)one,&(pair->attr_list),(GENERIC)left);
built_ins.c:    stack_insert(FEATURECMP,(GENERIC)two,&(pair->attr_list),(GENERIC)right);
built_ins.c:  m->type=integer;
built_ins.c:  m->value=heap_alloc(sizeof(REAL));
built_ins.c:  *(REAL *)m->value=(REAL)n;
built_ins.c:  t->type = quoted_string;
built_ins.c:  t->value=(GENERIC)heap_copy_string((GENERIC)s);
built_ins.c:  t->type = quoted_string;
built_ins.c:  t->value=(GENERIC)heap_ncopy_string(s,n);
built_ins.c:  Get the value of a Life string, or the name of a non-string psi-term.
built_ins.c:  if (equal_types(t->type,quoted_string)) {
built_ins.c:    if (t->value) {
built_ins.c:      *fn = (char *) t->value;
built_ins.c:      *fn = quoted_string->keyword->symbol;
built_ins.c:    *fn = t->type->keyword->symbol;
built_ins.c:    if(tree->right)
built_ins.c:      tail=make_feature_list(tree->right,tail,module,val);
built_ins.c:    d=str_to_int(tree->key);
built_ins.c:    if (d== -1) { /* Feature is not a number */
built_ins.c:      def=update_feature(module,tree->key); /* Extract module RM: Feb 3 1993 */
built_ins.c:	  tail=stack_cons((ptr_psi_term)tree->data,(ptr_psi_term)tail);
built_ins.c:	  new->type=def;
built_ins.c:	tail=stack_cons((ptr_psi_term)tree->data,(ptr_psi_term)tail);
built_ins.c:	new->type=(d==floor(d))?integer:real;
built_ins.c:	new->value=heap_alloc(sizeof(REAL));
built_ins.c:	*(REAL *)new->value=(REAL)d;
built_ins.c:    if(tree->left)
built_ins.c:      tail=make_feature_list(tree->left,tail,module,val);
built_ins.c:    success=matches(t->type,real,&smaller);
built_ins.c:      if (smaller && t->value) {
built_ins.c:        *v= *(REAL *)t->value;
built_ins.c:  This is used in all the arithmetic built-in functions to get their arguments.
built_ins.c:    success=matches(t->type,real,&smaller);
built_ins.c:	if (t->value) {
built_ins.c:	  *v= *(REAL *)t->value;
built_ins.c:	  push_ptr_value(def_ptr,(GENERIC *)&(t->type));
built_ins.c:	  push_ptr_value(int_ptr,(GENERIC *)&(t->status));
built_ins.c:	  t->type=real;
built_ins.c:	  t->status=0;
built_ins.c:  Check if psi_term T is a boolean. V <- TRUE or FALSE value of T.
built_ins.c:    success=matches(t->type,boolean,&smaller);
built_ins.c:	if(matches(t->type,false,&smaller) && smaller) {
built_ins.c:	  if(matches(t->type,true,&smaller) && smaller) {
built_ins.c:	  push_ptr_value(def_ptr,(GENERIC *)&(t->type));
built_ins.c:	  push_ptr_value(int_ptr,(GENERIC *)&(t->status));
built_ins.c:	  t->type=boolean;
built_ins.c:	  t->status=0;
built_ins.c:  This is used by built-in logical functions to return their result.
built_ins.c:  u->type=v?true:false;
built_ins.c:     What's *your* Birthday? Maybe you'd like a Birthday-Bug-Card!
built_ins.c:    push_ptr_value(def_ptr,(GENERIC *)&(t->type));
built_ins.c:      t->type=true;
built_ins.c:      t->status=0;
built_ins.c:      t->type=false;
built_ins.c:      t->status=0;
built_ins.c:    if (t->resid)
built_ins.c:  This is used by built-in arithmetic functions to return their result.
built_ins.c:  if (t->value) {
built_ins.c:    assert(t->value==NULL); /* 10.6 */
built_ins.c:    push_ptr_value(int_ptr,(GENERIC *)&(t->value));
built_ins.c:    t->value=heap_alloc(sizeof(REAL)); /* 12.5 */
built_ins.c:    *(REAL *)t->value = v;
built_ins.c:    matches(t->type,integer,&smaller);
built_ins.c:	push_ptr_value(def_ptr,(GENERIC *)&(t->type));
built_ins.c:	t->type=integer;
built_ins.c:	t->status=0;
built_ins.c:      if (t->resid)
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  arg3=aim->b;
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  arg3=aim->b;
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    if(arg2->type!=disj_nil) /*  RM: Feb  1 1993  */
built_ins.c:      push_choice_point(eval,arg2,result,(GENERIC)funct->type->rule);
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  arg3=aim->b;
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  arg3=aim->b;
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  arg3=aim->b;
built_ins.c:  Internal built-in predicate that handles functions in predicate positions.
built_ins.c:  t=aim->a;
built_ins.c:  get_one_arg(t->attr_list,&arg1);
built_ins.c:    if (sub_type(boolean,arg1->type)) {
built_ins.c:      succ=matches(arg1->type,true,&lesseq);
built_ins.c:        succ=matches(arg1->type,false,&lesseq);
built_ins.c:          if (arg1->type->type==predicate) {
built_ins.c:  tmp->type=boolean;
built_ins.c:  funct=aim->a;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    arg3=aim->b;
built_ins.c:    a1comp = matches(arg1->type,boolean,&sm1);
built_ins.c:    a2comp = matches(arg2->type,boolean,&sm2);
built_ins.c:    a3comp = matches(arg3->type,boolean,&sm3);
built_ins.c:      a1 = get_bool(arg1->type);
built_ins.c:      a2 = get_bool(arg2->type);
built_ins.c:      a3 = get_bool(arg3->type);
built_ins.c:	/* tmp->type=boolean; */
built_ins.c:	/* tmp->type=boolean; */
built_ins.c:	/* tmp->type=boolean; */
built_ins.c:      Errorline("Non-boolean argument or result in '%P'.\n",funct);
built_ins.c:  funct=aim->a;
built_ins.c:  get_one_arg(funct->attr_list,&arg1);
built_ins.c:    arg2=aim->b;
built_ins.c:    a1comp = matches(arg1->type,boolean,&sm1);
built_ins.c:    a2comp = matches(arg2->type,boolean,&sm2);
built_ins.c:      a1 = get_bool(arg1->type);
built_ins.c:      a2 = get_bool(arg2->type);
built_ins.c:      Errorline("Non-boolean argument or result in '%P'.\n",funct);
built_ins.c:  funct=aim->a;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    arg3=aim->b;
built_ins.c:    a1comp = matches(arg1->type,boolean,&sm1);
built_ins.c:    a2comp = matches(arg2->type,boolean,&sm2);
built_ins.c:    a3comp = matches(arg3->type,boolean,&sm3);
built_ins.c:      a1 = get_bool(arg1->type);
built_ins.c:      a2 = get_bool(arg2->type);
built_ins.c:      a3 = get_bool(arg3->type);
built_ins.c:      Errorline("Non-boolean argument or result in '%P'.\n",funct);
built_ins.c:  a known function, then it builds the psi-term F(Args), and evaluates it.
built_ins.c:  funct=aim->a;
built_ins.c:  n=find(FEATURECMP,functor->keyword->symbol,funct->attr_list);
built_ins.c:    other=(ptr_psi_term )n->data;
built_ins.c:    if (other->type==top)
built_ins.c:      if(other->type && other->type->type!=function) {
built_ins.c:        /* funct->attr_list, except '*functor*', into other->attr_list. */
built_ins.c:        fattr=distinct_tree(funct->attr_list); /* Make distinct copy: PVR */
built_ins.c:	push_goal(eval,other,aim->b,(GENERIC)other->type->rule);
built_ins.c:	merge_unify(&(other->attr_list),fattr);
built_ins.c:        /* We don't want to remove anything from funct->attr_list here. */
built_ins.c:	delete_attr(functor->keyword->symbol,&(other->attr_list));
built_ins.c:  Here we evaluate "project(Psi-term,Label)". This
built_ins.c:  returns the psi-term associated to label Label in Psi-term.
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    if(arg2->type!=top) {
built_ins.c:      if(arg2->value && sub_type(arg2->type,quoted_string)) /* 10.8 */
built_ins.c:	label=(GENERIC)arg2->value;
built_ins.c:	if(arg2->value && sub_type(arg2->type,integer)) { /* 10.8 */
built_ins.c:	  v= *(REAL *)arg2->value;
built_ins.c:	    Errorline("non-integer numeric feature in %P\n",funct);
built_ins.c:	  if(arg2->type->keyword->private_feature) /*  RM: Mar 12 1993  */
built_ins.c:	    label=(GENERIC)arg2->type->keyword->combined_name;
built_ins.c:	    label=(GENERIC)arg2->type->keyword->symbol; 
built_ins.c:      n=find(FEATURECMP,(char *)label,arg1->attr_list);
built_ins.c:	push_goal(unify,result,(ptr_psi_term)n->data,(GENERIC)NULL);
built_ins.c:      else if (arg1->type->type==function && !(arg1->flags&QUOTED_TRUE)) {
built_ins.c:	    push_psi_ptr_value(result,(GENERIC *)&(result->coref));
built_ins.c:	  result->coref=inc_heap_copy(result);
built_ins.c:	  heap_insert(FEATURECMP,label,&(arg1->attr_list),(GENERIC)result->coref);
built_ins.c:	  if(arg1->type->always_check || arg1->attr_list)
built_ins.c:	    bk_stack_insert(FEATURECMP,label,&(arg1->attr_list),(GENERIC)result);
built_ins.c:	    bk_stack_insert(FEATURECMP,label,&(arg1->attr_list),(GENERIC)result);
built_ins.c:	    fetch_def_lazy(arg1, arg1->type,arg1->type,NULL,NULL,0,0); // djd added zeros
built_ins.c:	  if (arg1->resid)
built_ins.c:  Arithmetic not-equal.
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  arg3=aim->b;
built_ins.c:  t=aim->a;
built_ins.c:  t=aim->a;
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    other->type=((arg1->type==top)&&(arg1->attr_list==NULL))?true:false;
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    other->type=((arg1->type==top)&&(arg1->attr_list==NULL))?false:true;
built_ins.c:  Succeed iff argument is a function (built-in or user-defined).
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    other->type=(arg1->type->type==function)?true:false;
built_ins.c:  Succeed iff argument is a predicate (built-in or user-defined).
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    other->type=(arg1->type->type==predicate)?true:false;
built_ins.c:  Succeed iff argument is a sort (built-in or user-defined).
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    other->type=(arg1->type->type==type)?true:false;
built_ins.c:  ptr_node n=t->attr_list;
built_ins.c:  if (n && n->left==NULL && n->right==NULL && !featcmp(n->key,one,FEATURECMP)) {
built_ins.c:    *arg1=(ptr_psi_term)n->data;
built_ins.c:  ptr_psi_term t=aim->a;
built_ins.c:  assert_protected(t->attr_list,FALSE);
built_ins.c:  ptr_psi_term t=aim->a;
built_ins.c:  assert_protected(t->attr_list,TRUE);
built_ins.c:  during unification (i.e. they are only checked when the psi-term is
built_ins.c:  given attributes, and they are not checked as long as the psi-term has
built_ins.c:  ptr_psi_term t=aim->a;
built_ins.c:  assert_delay_check(t->attr_list);
built_ins.c:  ptr_psi_term t=aim->a;
built_ins.c:  assert_args_not_eval(t->attr_list);
built_ins.c:  ptr_psi_term t=aim->a;
built_ins.c:  g=aim->a;
built_ins.c:    n=find(FEATURECMP,one,g->attr_list);
built_ins.c:      arg1= (ptr_psi_term )n->data;
built_ins.c:  file, including calls to user-defined predicates and other load predicates.
built_ins.c:  t=aim->a;
built_ins.c:  get_two_args(t->attr_list,&arg1,&arg2);
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:    gts=choice_stack->time_stamp;
built_ins.c:    gts=global_time_stamp-1;
built_ins.c:  The built-ins get_choice, set_choice, and exists_choice are implemented
built_ins.c:  t=aim->a;
built_ins.c:  get_one_arg(t->attr_list,&arg1);
built_ins.c:          while (cutpt && cutpt->time_stamp>gts) cutpt=cutpt->next;
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:          while (cp && cp->time_stamp>gts2) cp=cp->next;
built_ins.c:          ans=(cp && cp->time_stamp>gts1);
built_ins.c:        ans_term->type=ans?true:false;
built_ins.c:  ptr_psi_term arg;       /* argumenrt 2 psi-term */
built_ins.c:    arg=(ptr_psi_term)n->data;
built_ins.c:    queryflag->type =
built_ins.c:  Parse a string and return a quoted psi-term.
built_ins.c:  The global variable names are recognized (see the built-in
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(funct->attr_list,&arg1);
built_ins.c:    success=matches(arg1->type,quoted_string,&smaller);
built_ins.c:      if (arg1->value) {
built_ins.c:        stringinput=(char*)arg1->value;
built_ins.c:          n=find(FEATURECMP,two,funct->attr_list);
built_ins.c:            arg2=(ptr_psi_term)n->data;
built_ins.c:            queryflag->type=
built_ins.c:          /* Optional third argument returns true or false if the psi-term
built_ins.c:          n=find(FEATURECMP,three,funct->attr_list);
built_ins.c:            arg3=(ptr_psi_term)n->data;
built_ins.c:            varflag->type=var_occurred?true:false;
built_ins.c:  g=aim->a;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:	n=find(FEATURECMP,two,g->attr_list); /*  RM: Jun  8 1993  */
built_ins.c:	  arg2=(ptr_psi_term)n->data;
built_ins.c:	  queryflag->type=
built_ins.c:	n=find(FEATURECMP,three,g->attr_list);
built_ins.c:	  arg3=(ptr_psi_term)n->data;
built_ins.c:	  g->type=integer;
built_ins.c:	  g->value=heap_alloc(sizeof(REAL));
built_ins.c:	  *(REAL *)g->value=line;
built_ins.c:      if (t->type==eof) eof_flag=TRUE;
built_ins.c:           (life_end.tms_utime-life_start.tms_utime)/60.0,
built_ins.c:           garbage_time*100 / ((life_end.tms_utime-life_start.tms_utime)/60.0)
built_ins.c:  if ( aborthooksym->type!=function ||
built_ins.c:       !aborthooksym->rule->b ||
built_ins.c:       aborthooksym->rule->b->type==abortsym) {
built_ins.c:    /* Do a 'user-defined abort': initialize the system, then */
built_ins.c:    /* prove the user-defined abort routine (which is set by  */
built_ins.c:    aborthook->type=aborthooksym;
built_ins.c:  t=aim->a;
built_ins.c:  Errorline("built-in %P is not implemented yet.\n",t);
built_ins.c:  t=aim->a;
built_ins.c:  Create a function with one rule F -> X, where F and X are the
built_ins.c:  function, but none for an undefined (i.e. uninterpreted) psi-term, which is
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    d=arg1->type;
built_ins.c:    if (d->type==function || d->type==undef) {
built_ins.c:      if (d->type==undef || !d->protected) {
built_ins.c:        if (!arg1->attr_list) {
built_ins.c:          d->type=function;
built_ins.c:          d->protected=FALSE;
built_ins.c:          p->a=heap_psi_term(4);
built_ins.c:          p->a->type=d;
built_ins.c:          p->b=quote_copy(arg2,HEAP);
built_ins.c:          p->next=NULL;
built_ins.c:          d->rule=p;
built_ins.c:  g=aim->a;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:  g=aim->a;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    if (!lf_strcmp(t->type->keyword->symbol,"->")) {
built_ins.c:      get_two_args(t->attr_list,&head,&body);
built_ins.c:            (head->type->type==function || head->type->type==undef))
built_ins.c:    else if (!lf_strcmp(t->type->keyword->symbol,":-")) {
built_ins.c:      get_two_args(t->attr_list,&head,&body);
built_ins.c:            (head->type->type==predicate || head->type->type==undef)) {
built_ins.c:            body->type=succeed;
built_ins.c:    else if (t->type->type==predicate || t->type->type==undef) {
built_ins.c:      body->type=succeed;
built_ins.c:        push_goal(del_clause,head,body,(GENERIC)&(head->type->rule));
built_ins.c:      push_goal(clause,head,body,(GENERIC)&(head->type->rule));
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  g=aim->a;
built_ins.c:  if (g->attr_list) {
built_ins.c:    global_error_check(g->attr_list, &error, &eval);
built_ins.c:      global_tree(g->attr_list);
built_ins.c:    global_error_check(n->left, error, eval);
built_ins.c:    t=(ptr_psi_term)n->data;
built_ins.c:    if (t->type==leftarrowsym) {
built_ins.c:      get_two_args(t->attr_list,&a1,&a2);
built_ins.c:    if (!bad_init && t->type->type!=undef && t->type->type!=global) {
built_ins.c:		t->type->type,
built_ins.c:      t->type=error_psi_term->type;
built_ins.c:      t->value=NULL; /*  RM: Mar 23 1993  */
built_ins.c:    global_error_check(n->right, error, eval);
built_ins.c:    global_tree(n->left);
built_ins.c:    t=(ptr_psi_term)n->data;
built_ins.c:    global_tree(n->right);
built_ins.c:  if (t->type==leftarrowsym) {
built_ins.c:    get_two_args(t->attr_list,&t,&u);
built_ins.c:  t->type->type=global;
built_ins.c:  t->type->init_value=quote_copy(u,HEAP); /*  RM: Mar 23 1993  */
built_ins.c:      val=t->type->global_value;
built_ins.c:      push_psi_ptr_value(val,&(val->coref));
built_ins.c:      val->coref=u;
built_ins.c:      t->type->global_value=u;
built_ins.c:  g=aim->a;
built_ins.c:  if (g->attr_list) {
built_ins.c:    persistent_error_check(g->attr_list, &error);
built_ins.c:      persistent_tree(g->attr_list);
built_ins.c:    persistent_error_check(n->left, error);
built_ins.c:    t=(ptr_psi_term)n->data;
built_ins.c:    if (t->type->type!=undef && t->type->type!=global) {
built_ins.c:	         t->type->type,
built_ins.c:      t->type=error_psi_term->type;
built_ins.c:    persistent_error_check(n->right, error);
built_ins.c:    persistent_tree(n->left);
built_ins.c:    t=(ptr_psi_term)n->data;
built_ins.c:    persistent_tree(n->right);
built_ins.c:  t->type->type=global;
built_ins.c:  if ((GENERIC)t->type->global_value<(GENERIC)heap_pointer)
built_ins.c:    t->type->global_value=heap_psi_term(4);
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:	    /* push_ptr_value(psi_term_ptr,(GENERIC *)&(arg2->coref)); 9.6 */
built_ins.c:	    push_psi_ptr_value(arg2,(GENERIC *)&(arg2->coref));
built_ins.c:	    arg2->coref=input_state;
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:	if (overlap_type(arg2->type,stream)) /* 10.8 */
built_ins.c:	    arg3->type=stream;
built_ins.c:	    arg3->value=(GENERIC)output_stream;
built_ins.c:	    /* push_ptr_value(psi_term_ptr,(GENERIC *)&(arg2->coref)); 9.6 */
built_ins.c:	    push_psi_ptr_value(arg2,(GENERIC *)&(arg2->coref));
built_ins.c:	    arg2->coref=arg3;
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    if (equal_types(arg1->type,inputfilesym)) {
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    if(equal_types(arg1->type,stream) && arg1->value) {
built_ins.c:      output_stream=(FILE *)arg1->value;
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    if (sub_type(arg1->type,sys_stream))
built_ins.c:    outclose=equal_types(arg1->type,stream) && arg1->value;
built_ins.c:    if (equal_types(arg1->type,inputfilesym)) {
built_ins.c:      ptr_node n=find(FEATURECMP,STREAM,arg1->attr_list);
built_ins.c:        arg1=(ptr_psi_term)n->data;
built_ins.c:        inclose=(arg1->value!=NULL);
built_ins.c:      fclose((FILE *)arg1->value);
built_ins.c:      if (inclose && arg1->value==(GENERIC)input_stream)
built_ins.c:      else if (outclose && arg1->value==(GENERIC)output_stream)
built_ins.c:      arg1->value=NULL;
built_ins.c:  At end of file, return the psi-term 'end_of_file'.
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:        t->type=eof;
built_ins.c:        t->type=integer;
built_ins.c:        t->value=heap_alloc(sizeof(REAL)); /* 12.5 */
built_ins.c:        * (REAL *)t->value = (REAL) c;
built_ins.c:  Write the root of a psi-term to the current output stream or to stderr.
built_ins.c:  in the range 0..255), and any other psi-term (in which case its name is
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    if ((equal_types(arg1->type,integer) || equal_types(arg1->type,real))
built_ins.c:        && arg1->value) {
built_ins.c:      i = (unsigned long) floor(*(REAL *) arg1->value);
built_ins.c:        Errorline("out-of-range character value in %P.\n",g);
built_ins.c:  g=aim->a;
built_ins.c:  pred_write(g->attr_list);
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    if (equal_types(arg1->type,integer) && arg1->value) {
built_ins.c:      pw = *(REAL *)arg1->value;
built_ins.c:    else if (sub_type(integer,arg1->type)) {
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    if (equal_types(arg1->type,integer) && arg1->value) {
built_ins.c:      dl = *(REAL *)arg1->value;
built_ins.c:    else if (sub_type(integer,arg1->type)) {
built_ins.c:  g=aim->a;
built_ins.c:  arg3=aim->b;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    other->type=arg1->type;    
built_ins.c:    other->value=arg1->value;
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg_addr(g->attr_list,&arg1addr);
built_ins.c:    if (arg1->type->type==predicate) {
built_ins.c:      call_once->type=calloncesym;
built_ins.c:      call_once->attr_list=(ca=STACK_ALLOC(node));
built_ins.c:      ca->key=one;
built_ins.c:      ca->left=ca->right=NULL;
built_ins.c:      ca->data=(GENERIC)arg1;
built_ins.c:        n=find(FEATURECMP,(val1?two:three),g->attr_list);
built_ins.c:          arg2=(ptr_psi_term)n->data;
built_ins.c:          trueterm->type=true;
built_ins.c:  Here we evaluate "has_feature(Label,Psi-term,Value)". This
built_ins.c:  is a boolean function that returns true iff Psi-term
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:  n=find(FEATURECMP,three,funct->attr_list); /*  RM: Feb 10 1993  */
built_ins.c:    arg3=(ptr_psi_term)n->data;
built_ins.c:    if (arg1->value && sub_type(arg1->type,quoted_string))
built_ins.c:      label=(GENERIC)arg1->value;
built_ins.c:    else if (arg1->value && sub_type(arg1->type,integer)) {
built_ins.c:      v= *(REAL *)arg1->value;
built_ins.c:    } else if (arg1->type->keyword->private_feature) {
built_ins.c:      label=(GENERIC)arg1->type->keyword->combined_name;
built_ins.c:      label=(GENERIC)arg1->type->keyword->symbol;
built_ins.c:    n=find(FEATURECMP,(char *)label,arg2->attr_list);
built_ins.c:    ans->type=(n!=NULL)?true:false;
built_ins.c:      push_goal(unify,arg3,(ptr_psi_term)n->data,(GENERIC)NULL);
built_ins.c:  Convert the feature names of a psi_term into a list of psi-terms.
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:	      make_feature_list(arg1->attr_list,stack_nil(),module,0),
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:	      make_feature_list(arg1->attr_list,stack_nil(),module,1),
built_ins.c:   psi-term list of them.
built_ins.c:   Note the similarity between this routine and a tree-to-list
built_ins.c:  for(def=first_definition;def;def=def->next) {
built_ins.c:      if (((botflag?def->children:def->parents)==NULL &&
built_ins.c:           def->type==type ||
built_ins.c:           def->type==undef)
built_ins.c:        new->type=def;
built_ins.c:      ptr_operator_data od=def->op_data;
built_ins.c:        new->type=opsym;
built_ins.c:        stack_add_int_attr(new,one,od->precedence);
built_ins.c:        switch (od->type) {
built_ins.c:          type->type=xf_sym;
built_ins.c:          type->type=yf_sym;
built_ins.c:          type->type=fx_sym;
built_ins.c:          type->type=fy_sym;
built_ins.c:          type->type=xfx_sym;
built_ins.c:          type->type=xfy_sym;
built_ins.c:          type->type=yfx_sym;
built_ins.c:        name->type=def;
built_ins.c:        od=od->next;
built_ins.c:  Return a list of all operators (represented as 3-tuples op(prec,type,atom)).
built_ins.c:  g=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:/* PVR 23.2.94 -- Added this to fix c_strip and c_copy_pointer */
built_ins.c:  m->key = n->key;
built_ins.c:  m->data = n->data;
built_ins.c:  m->left = copy_attr_list(n->left);
built_ins.c:  m->right = copy_attr_list(n->right);
built_ins.c:  Return the attributes of a psi-term, that is, a psi-term of type @ but with
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    merge_unify(&(result->attr_list),copy_attr_list(arg1->attr_list));
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:  funct = aim->a;
built_ins.c:  result = aim->b;
built_ins.c:  get_two_args(funct->attr_list, &arg1, &arg2);
built_ins.c:    assert((unsigned long)(arg1->type)!=4);
built_ins.c:  funct = aim->a;
built_ins.c:  result = aim->b;
built_ins.c:  get_two_args(funct->attr_list, &arg1, &arg2);
built_ins.c:  funct = aim->a;
built_ins.c:  result = aim->b;
built_ins.c:  get_two_args(funct->attr_list, &arg1, &arg2);
built_ins.c:  Split a double into two 32-bit words.
built_ins.c:  funct = aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list, &arg1, &arg2);
built_ins.c:      Errorline("non-numeric arguments in %P\n",funct);
built_ins.c:  funct = aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list, &arg1, &arg2);
built_ins.c:      success=matches(arg1->type,quoted_string,&smaller);
built_ins.c:	if (arg1->value) {
built_ins.c:	  unify_real_result(result,(REAL)(long)(arg1->value));
built_ins.c:	      t->type=quoted_string;
built_ins.c:	      t->value=(GENERIC)(long)val;
built_ins.c:  funct = aim->a;
built_ins.c:  get_two_args(funct->attr_list, &arg1, &arg2);
built_ins.c:    if(matches(arg1->type,quoted_string,&smaller) && arg1->value)
built_ins.c:      success=!chdir(expand_file_name((char *)arg1->value));
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    if(arg1->type==top)
built_ins.c:      if(FALSE /*arg1->type->type!=predicate*/) {
built_ins.c:        other->type=false;
built_ins.c:        other->type=true;
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    if(arg1->type==top)
built_ins.c:      if(FALSE /*arg1->type->type!=predicate*/) {
built_ins.c:        other->type=false;
built_ins.c:        other->type=true;
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:	Errorline("cannot use '<-' on persistent value in %P\n",g);
built_ins.c:        /* If no trail, then can safely overwrite the psi-term */
built_ins.c:        push_psi_ptr_value(arg2,(GENERIC *)&(arg2->coref)); /* 14.12 */
built_ins.c:        arg2->coref=arg1; /* 14.12 */
built_ins.c:        push_psi_ptr_value(arg1,(GENERIC *)&(arg1->coref));
built_ins.c:        arg1->coref=arg2;
built_ins.c:      push_psi_ptr_value(arg1,(GENERIC *)&(arg1->coref));
built_ins.c:      arg1->coref=arg2;
built_ins.c:  This implements non-backtrackable assignment.
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  This implements non-backtrackable assignment on global variables.
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:	push_psi_ptr_value(arg1,(GENERIC *)&(arg1->coref));
built_ins.c:	arg1->coref= new;
built_ins.c:	*arg1= *new; /* Overwrite in-place */
built_ins.c:	new->coref=arg1;
built_ins.c:  funct=aim->a;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    result=aim->b;
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  funct=aim->a;
built_ins.c:  get_one_arg(funct->attr_list,&arg1);
built_ins.c:    other->type=arg1->type;
built_ins.c:    other->value=arg1->value;
built_ins.c:    other->attr_list=copy_attr_list(arg1->attr_list); /* PVR 23.2.94 */
built_ins.c:    result=aim->b;
built_ins.c:  funct=aim->a;
built_ins.c:  get_one_arg(funct->attr_list,&arg1);
built_ins.c:    result=aim->b;
built_ins.c:  undo(G) :- G.
built_ins.c:  push the goal onto the goal-stack.
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  g=aim->a;
built_ins.c:  get_one_arg(g->attr_list,&arg1);
built_ins.c:    /* if (!arg1->type->evaluate_args) mark_quote(arg1); 8.9 */ /* 18.2 PVR */
built_ins.c:    if (arg1->type->type!=predicate) {
built_ins.c:    rule=(ptr_pair_list)aim->c; /* 8.9 */ /* Isn't aim->c always NULL? */
built_ins.c:    if (!rule) rule=arg1->type->rule; /* 8.9 */
built_ins.c:    /* if ((unsigned long)rule==DEFRULES) rule=arg1->type->rule; 8.9 */
built_ins.c:        Errorline("the argument %P of freeze must be user-defined.\n",arg1); /* 8.9 */
built_ins.c:        while (rule && (rule->a==NULL || rule->b==NULL)) {
built_ins.c:          rule=rule->next;
built_ins.c:          if (TRUE /*arg1->type->evaluate_args 8.9 */)
built_ins.c:	    head=eval_copy(rule->a,STACK);
built_ins.c:	    head=quote_copy(rule->a,STACK);
built_ins.c:	  body=eval_copy(rule->b,STACK);
built_ins.c:	  head->status=4;
built_ins.c:	  if (rule->next)
built_ins.c:	    /* push_choice_point(prove,g,rule->next,NULL); 8.9 */
built_ins.c:	    push_choice_point(prove,g,(ptr_psi_term)DEFRULES,(GENERIC)rule->next);
built_ins.c:	  /* eval_args(head->attr_list); */
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    if (overlap_type(arg1->type,integer)) {
built_ins.c:      if (arg1->value) {
built_ins.c:	t->type=quoted_string;
built_ins.c:        str[0] = (unsigned char) floor(*(REAL *) arg1->value);
built_ins.c:	t->value=(GENERIC)str;
built_ins.c:  psi-term's name.
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:    get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:      success=matches(arg1->type,quoted_string,&smaller);
built_ins.c:	if (arg1->value) {
built_ins.c:	  unify_real_result(result,(REAL)(*((unsigned char *)arg1->value)));
built_ins.c:        unify_real_result(result,(REAL)(*((unsigned char *)arg1->type->keyword->symbol)));
built_ins.c:  Convert a string to a psi-term whose name is the string's value.
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    success=overlap_type(arg1->type,quoted_string);
built_ins.c:	if(!arg1->value)
built_ins.c:	  t->type=update_symbol(mod,(char *)arg1->value);
built_ins.c:	  if(t->type==error_psi_term->type)
built_ins.c:  Convert a psi-term's name into a string with the name as value.
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(funct->attr_list,&arg1);
built_ins.c:    t->type=quoted_string;
built_ins.c:    if(arg1->value && sub_type(arg1->type,real)) {
built_ins.c:      sprintf(buf,"%g", *((double *)(arg1->value)));
built_ins.c:      t->value=(GENERIC)heap_copy_string((GENERIC)buf);
built_ins.c:      if(arg1->value && sub_type(arg1->type,quoted_string)) {
built_ins.c:	t->value=(GENERIC)heap_copy_string((GENERIC)arg1->value);
built_ins.c:	t->value=(GENERIC)heap_copy_string((GENERIC)arg1->type->keyword->symbol);
built_ins.c:  Convert an integer psi-term into a string representing its value.
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_one_arg(funct->attr_list,&arg1);
built_ins.c:    if (overlap_type(arg1->type,integer)) {
built_ins.c:      if (arg1->value) {
built_ins.c:        the_int = *(REAL *)arg1->value;
built_ins.c:        if (neg) the_int = -the_int;
built_ins.c:        i--;
built_ins.c:          i--;
built_ins.c:          val[i]= '0' + (unsigned long) (the_int-next*10);
built_ins.c:        if (neg) { i--; val[i]='-'; }
built_ins.c:        t->type=quoted_string;
built_ins.c:        t->value=(GENERIC)heap_copy_string((GENERIC)&val[i]);
built_ins.c:  This routine is different than the straight-forward implementation in Life
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:   n->key = one;
built_ins.c:   n->data = NULL; /* To be filled in later */
built_ins.c:   n->left = NULL;
built_ins.c:   n->right = NULL;
built_ins.c:     n2->key = two;
built_ins.c:     *a2 = (ptr_psi_term *) &(n2->data);
built_ins.c:     n2->left = NULL;
built_ins.c:     n2->right = NULL;
built_ins.c:   n1->key = one;
built_ins.c:   *a1 = (ptr_psi_term *) &(n1->data);
built_ins.c:   n1->left = NULL;
built_ins.c:   n1->right = n2;
built_ins.c:   t->type = typ;
built_ins.c:   t->attr_list = n1;
built_ins.c:/* This is true for a user-defined function or predicate with a definition, */
built_ins.c:    if (r->a!=NULL) return TRUE;
built_ins.c:    r=r->next;
built_ins.c:/* Return TRUE if rules r are for a built-in */
built_ins.c:  ptr_definition d = t->type;
built_ins.c:  ptr_pair_list r = t->type->rule;
built_ins.c:  if (t->type->type==type) {
built_ins.c:    if (!d->always_check) {
built_ins.c:    if (!d->protected) {
built_ins.c:      fprintf(output_stream,"%s(",(d->protected?"static":"dynamic"));
built_ins.c:  if (!d->evaluate_args) {
built_ins.c:  of a type (i.e. the non-inherited constraints).
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:    fp=arg1->type->type;
built_ins.c:    r=arg1->type->rule;
built_ins.c:        s1="built-in ";
built_ins.c:        s1="user-defined ";
built_ins.c:                arg1->type->keyword->symbol,s1,s2);
built_ins.c:                arg1->type->keyword->symbol,s1,s2);
built_ins.c:        if (arg1->value) {
built_ins.c:          if (arg1->type!=quoted_string) fprintf(output_stream,"'");
built_ins.c:          if (arg1->type!=quoted_string) fprintf(output_stream,"'");
built_ins.c:                  arg1->type->keyword->symbol);
built_ins.c:		   arg1->type->keyword->symbol,
built_ins.c:		   arg1->type->global_value);
built_ins.c:                arg1->type->keyword->symbol,"","");	
built_ins.c:        fprintf(output_stream,"%% '%s' is undefined.\n", arg1->type->keyword->symbol);
built_ins.c:        n->data = (GENERIC) t;
built_ins.c:          *a1 = r->a; /* Func, pred, or type */
built_ins.c:          *a2 = r->b;
built_ins.c:          if (r->a) {
built_ins.c:            if (fp==type) { if (r->b==NULL) *a3 = r->a; else *a3 = t2; }
built_ins.c:          r = r->next;
built_ins.c:  t=aim->a;
built_ins.c:  Template for C built-in predicates.
built_ins.c:  g=aim->a;
built_ins.c:  get_two_args(g->attr_list,&arg1,&arg2);
built_ins.c:  Template for C built-in functions.
built_ins.c:  funct=aim->a;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:  Add a new built-in predicate or function.
built_ins.c:    exit(-1);
built_ins.c:  d->type=t;
built_ins.c:  d->rule=(ptr_pair_list )built_in_index;
built_ins.c:  od->precedence=p;
built_ins.c:  od->type=t;
built_ins.c:  od->next=d->op_data;
built_ins.c:  d->op_data=od;
built_ins.c:  Declare a new operator or change a pre-existing one.
built_ins.c:  n=t->attr_list;
built_ins.c:    atom=(ptr_psi_term )n->data;
built_ins.c:    if (!atom->value) {
built_ins.c:      s=atom->type->keyword->symbol;
built_ins.c:      if (sub_type(prec->type,integer) && prec->value) { /* 10.8 */
built_ins.c:        p = * (REAL *)prec->value;
built_ins.c:          if (type->type == xf_sym) kind=xf;
built_ins.c:          else if (type->type == yf_sym) kind=yf;
built_ins.c:          else if (type->type == fx_sym) kind=fx;
built_ins.c:          else if (type->type == fy_sym) kind=fy;
built_ins.c:          else if (type->type == xfx_sym) kind=xfx;
built_ins.c:          else if (type->type == xfy_sym) kind=xfy;
built_ins.c:          else if (type->type == yfx_sym) kind=yfx;
built_ins.c:            Errorline("bad operator kind '%s'.\n",type->type->keyword->symbol);
built_ins.c:    if(p+n-1>l)
built_ins.c:      n=l-p+1;
built_ins.c:    *(result+i)= *(s+p+i-1);
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  n1=find(FEATURECMP,one,funct->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:  n2=find(FEATURECMP,two,funct->attr_list);
built_ins.c:    arg2= (ptr_psi_term )n2->data;
built_ins.c:       if (overlap_type(arg1->type,quoted_string)) /* 10.8 */
built_ins.c:          if (arg1->value)
built_ins.c:              c_arg1= (char *)arg1->value;
built_ins.c:       if (overlap_type(arg2->type,quoted_string)) /* 10.8 */
built_ins.c:          if (arg2->value)
built_ins.c:              c_arg2= (char *)arg2->value;
built_ins.c:      temp_result->type=quoted_string;
built_ins.c:      temp_result->value=(GENERIC) c_result;
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    arg2->type=quoted_string;
built_ins.c:    arg2->value=(GENERIC)heap_copy_string((GENERIC)arg1->type->keyword->module->module_name);
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  get_two_args(funct->attr_list,&arg1,&arg2);
built_ins.c:    arg2->type=quoted_string;
built_ins.c:    arg2->value=(GENERIC)heap_copy_string((GENERIC)arg1->type->keyword->combined_name);
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  n1=find(FEATURECMP,one,funct->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:       if (overlap_type(arg1->type,quoted_string)) /* 10.8 */
built_ins.c:          if (arg1->value)
built_ins.c:              c_arg1= (char *)arg1->value;
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  n1=find(FEATURECMP,one,funct->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:  n2=find(FEATURECMP,two,funct->attr_list);
built_ins.c:    arg2= (ptr_psi_term )n2->data;
built_ins.c:  n3=find(FEATURECMP,three,funct->attr_list);
built_ins.c:    arg3= (ptr_psi_term )n3->data;
built_ins.c:       if (overlap_type(arg1->type,quoted_string)) /* 10.8 */
built_ins.c:          if (arg1->value)
built_ins.c:              c_arg1= (char *)arg1->value;
built_ins.c:       if (overlap_type(arg2->type,integer)) /* 10.8 */
built_ins.c:          if (arg2->value)
built_ins.c:              c_arg2= (long)(* (double *)(arg2->value));
built_ins.c:       if (overlap_type(arg3->type,integer)) /* 10.8 */
built_ins.c:          if (arg3->value)
built_ins.c:              c_arg3= (long)(* (double *)(arg3->value));
built_ins.c:      temp_result->type=quoted_string;
built_ins.c:      temp_result->value=(GENERIC) c_result;
built_ins.c:  g=aim->a;
built_ins.c:  n1=find(FEATURECMP,one,g->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:  n2=find(FEATURECMP,two,g->attr_list);
built_ins.c:    arg2= (ptr_psi_term )n2->data;
built_ins.c:       if (overlap_type(arg1->type,quoted_string))
built_ins.c:          if (arg1->value)
built_ins.c:              c_arg1= (char *)arg1->value;
built_ins.c:       if (overlap_type(arg2->type,quoted_string))
built_ins.c:          if (arg2->value)
built_ins.c:              c_arg2= (char *)arg2->value;
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  n1=find(FEATURECMP,one,funct->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:       if (overlap_type(arg1->type,integer))
built_ins.c:          if (arg1->value)
built_ins.c:              c_arg1= (long)(* (double *)(arg1->value));
built_ins.c:        c_result=c_result-(c_result/c_arg1)*c_arg1;
built_ins.c:  t=aim->a;
built_ins.c:  n1=find(FEATURECMP,one,t->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:       if (overlap_type(arg1->type,integer))
built_ins.c:          if (arg1->value)
built_ins.c:              c_arg1= (long)(* (double *)(arg1->value));
built_ins.c:  funct=aim->a;
built_ins.c:  result=aim->b;
built_ins.c:  n1=find(FEATURECMP,one,funct->attr_list);
built_ins.c:    arg1= (ptr_psi_term )n1->data;
built_ins.c:    while(arg1->coref) {
built_ins.c:      arg1=arg1->coref;
built_ins.c:  result=aim->b;
built_ins.c:  for(i=arg_c-1;i>=0;i--) {
built_ins.c:    str->type=quoted_string;
built_ins.c:    str->value=(GENERIC)heap_copy_string((GENERIC)arg_v[i]);
built_ins.c:  Initialise the symbol tree with the built-in types.
built_ins.c:  Declare all built-in predicates and functions.
built_ins.c:  leftarrowsym		=update_symbol(syntax_module,"<-");
built_ins.c:  funcsym		=update_symbol(syntax_module,"->");
built_ins.c:  minus_symbol          =update_symbol(syntax_module,"-");/* RM: Jun 21 1993 */
built_ins.c:  predsym		=update_symbol(syntax_module,":-");
built_ins.c:  error_psi_term->type=update_symbol(bi_module,"*** ERROR ***");
built_ins.c:  error_psi_term->type->code=NOT_CODED;
built_ins.c:  null_psi_term->type	=nullsym;
built_ins.c:  one=t->keyword->symbol;
built_ins.c:  two=t->keyword->symbol;
built_ins.c:  three=t->keyword->symbol;
built_ins.c:  year_attr=t->keyword->symbol;
built_ins.c:  month_attr=t->keyword->symbol;
built_ins.c:  day_attr=t->keyword->symbol;
built_ins.c:  hour_attr=t->keyword->symbol;
built_ins.c:  minute_attr=t->keyword->symbol;
built_ins.c:  second_attr=t->keyword->symbol;
built_ins.c:  weekday_attr=t->keyword->symbol;
built_ins.c:  nothing->type=type;
built_ins.c:  top->type=type;
built_ins.c:  /* Built-in routines */
built_ins.c:	       disjunction->keyword->symbol,
built_ins.c:  /* Psi-term navigation */
built_ins.c:  new_built_in(syntax_module,"<-",predicate,c_bk_assign);
built_ins.c:  /* new_built_in(syntax_module,"<<-",predicate,c_assign);  RM: Feb 24 1993  */
built_ins.c:  new_built_in(syntax_module,"<<-",predicate,c_global_assign);
built_ins.c:  /* new_built_in(syntax_module,"<<<-",predicate,c_global_assign); */
built_ins.c:  new_built_in(syntax_module,":-",predicate,c_declaration);
built_ins.c:  new_built_in(syntax_module,"->",predicate,c_declaration);
built_ins.c:  hash_lookup(bi_module->symbol_table,"set_module")->public=TRUE;
built_ins.c:  hash_lookup(bi_module->symbol_table,"built_in")->public=TRUE;
copy.c:#define HASH(A) (((long) A + ((long) A >> 3)) & (HASHSIZE-1))
copy.c:#define HASHEND (-1)
copy.c:  r->key = t->key;
copy.c:  r->left  = (t->left)  ? copy_tree(t->left,copy_flag,heap_flag)  : NULL;
copy.c:  t1 = (ptr_psi_term)(t->data);
copy.c:  r->data = (GENERIC) t2;
copy.c:  r->right = (t->right) ? copy_tree(t->right,copy_flag,heap_flag) : NULL;
copy.c:  All copy-related routines are non-interruptible by the garbage collector.
copy.c:      /* If it was eval-copied before, then quote it now. */
copy.c:	/* If any subterm has zero curr_status (i.e., if u->status==0),
copy.c:	curr_status=u->status;
copy.c:      if (heap_pointer-stack_pointer < COPY_THRESHOLD) {
copy.c:	Errorline("psi-term too large -- get a bigger Life!\n");
copy.c:      if (copy_flag==EVAL_FLAG && !t->type->evaluate_args) /* 24.8 25.8 */
copy.c:      u->resid=NULL; /* 24.8 Don't copy residuations */
copy.c:      u->time_stamp=global_time_stamp; /* 9.6 */
copy.c:      if (t->attr_list)
copy.c:	u->attr_list=copy_tree(t->attr_list, local_copy_flag, heap_flag);
copy.c:	switch(t->type->type) {
copy.c:	  if (t->type->properties)
copy.c:	u->status=curr_status;
copy.c:	u->flags=curr_status?QUOTED_TRUE:FALSE; /* 14.9 */
copy.c:	u->status=4;
copy.c:	u->flags=QUOTED_TRUE; /* 14.9 */
copy.c:      /* else copy_flag==EXACT_FLAG & u->status=t->status */
copy.c:	if (t->type==cut) u->value=NULL;
copy.c:	if (t->type==cut) {
copy.c:	  u->value=(GENERIC)choice_stack;
copy.c:  This is used by APPLY in order to build the calling psi-term which is used
copy.c:    n->key=t->key;
copy.c:    n->data=t->data;
copy.c:    n->left=distinct_tree(t->left);
copy.c:    n->right=distinct_tree(t->right);
copy.c:  psi-term which is used for matching.  Note that this routine is not
copy.c:  res->time_stamp=global_time_stamp; /* 9.6 */
copy.c:  /* res->coref=distinct_copy(t->coref); */
copy.c:  res->attr_list=distinct_tree(t->attr_list);
copy.c:/* Mark a psi-term u (which is a copy of t) as completely evaluated. */
copy.c:/* Assumes the psi-term is a copy of another psi-term t, which is made through */
copy.c:        u->status=4;
copy.c:        u->flags=QUOTED_TRUE; /* 14.9 */
copy.c:        mark_quote_tree_c(t->attr_list,heap_flag);
copy.c:      /* Create a stub & mark it as to-be-quoted. */
copy.c:    mark_quote_tree_c(n->left,heap_flag);
copy.c:    mark_quote_c((ptr_psi_term) (n->data),heap_flag);
copy.c:    mark_quote_tree_c(n->right,heap_flag);
copy.c:/* Mark a psi-term as to be evaluated (i.e. strict), except for arguments   */
copy.c:/* propagate zero status upwards.  Avoid doing superfluous work: non-shared */
copy.c:    flag = t->type->evaluate_args;
copy.c:      /* If any subterm has zero curr_status (i.e., if t->status==0),
copy.c:      curr_status=t->status;
copy.c:        mark_eval_tree_new(t->attr_list);
copy.c:	mark_quote_tree_new(t->attr_list);
copy.c:      switch(t->type->type) {
copy.c:        if (t->type->properties)
copy.c:          t->status=curr_status;
copy.c:        t->status=curr_status;
copy.c:        t->flags=curr_status?QUOTED_TRUE:FALSE; /* 14.9 */
copy.c:    mark_eval_tree_new(n->left);
copy.c:    mark_eval_new((ptr_psi_term) (n->data));
copy.c:    mark_eval_tree_new(n->right);
copy.c:    t->status=4;
copy.c:    t->flags=QUOTED_TRUE; /* 14.9 */
copy.c:    mark_quote_tree_new(t->attr_list);
copy.c:    mark_quote_tree_new(n->left);
copy.c:    mark_quote_new((ptr_psi_term) (n->data));
copy.c:    mark_quote_tree_new(n->right);
copy.c:/* Mark a psi-term as completely evaluated. */
copy.c:  if (t && !(t->status&RMASK)) {
copy.c:    t->status = 4;
copy.c:    t->flags=QUOTED_TRUE; /* 14.9 */
copy.c:    t->status |= RMASK;
copy.c:    mark_quote(t->coref);
copy.c:    mark_quote_tree(t->attr_list);
copy.c:    t->status &= ~RMASK;
copy.c:    mark_quote_tree(t->left);
copy.c:    mark_quote((ptr_psi_term) (t->data));
copy.c:    mark_quote_tree(t->right);
copy.c:/* Back-trackably mark a psi-term as completely evaluated. */
copy.c:  if (t && !(t->status&RMASK)) {
copy.c:    if(t->status!=4 && (GENERIC)t<heap_pointer)/*  RM: Jul 16 1993  */
copy.c:      push_ptr_value(int_ptr,(GENERIC *)&(t->status));
copy.c:    t->status = 4;
copy.c:    t->flags=QUOTED_TRUE; /* 14.9 */
copy.c:    t->status |= RMASK;
copy.c:    bk_mark_quote(t->coref);
copy.c:    bk_mark_quote_tree(t->attr_list);
copy.c:    t->status &= ~RMASK;
copy.c:    bk_mark_quote_tree(t->left);
copy.c:    bk_mark_quote((ptr_psi_term) (t->data));
copy.c:    bk_mark_quote_tree(t->right);
error.c:  while (g) { i++; g=g->next; }
error.c:  while (c) { i++; c=c->next; }
error.c:  while (t) { i++; t=t->next; }
error.c:  for (i=indent; i>=0; i--) printf(" ");
error.c:/* Old error printing routines -- these should be superceded by Errorline */
error.c:  psi-term which caused the error, S a message to print.
error.c:  psi-term which caused the error, S a message to print.
error.c:  psi-term which caused the error, S a message to print.
error.c:      ((arg1 && !overlap_type(arg1->type,real)) ||
error.c:       (arg2 && !overlap_type(arg2->type,real)))) {
error.c:    report_warning(t,"non-numeric argument(s)");
hash_table.c:  Create a hash-table for max size keywords.
hash_table.c:  new->size=size;
hash_table.c:  new->used=0;
hash_table.c:  new->data=(ptr_keyword *)malloc(size*sizeof(ptr_keyword));
hash_table.c:    new->data[i]=NULL;
hash_table.c:  old_data=table->data;
hash_table.c:  old_size=table->size;
hash_table.c:  table->size=new_size; /* Must be power of 2 */
hash_table.c:  table->used=0;
hash_table.c:  table->data=(ptr_keyword *)malloc(new_size*sizeof(ptr_keyword));
hash_table.c:    table->data[i]=NULL;
hash_table.c:      hash_insert(table,old_data[i]->symbol,old_data[i]);
hash_table.c:  n &= (table->size-1);
hash_table.c:  while(table->data[n] && lf_strcmp(table->data[n]->symbol,symbol)) {
hash_table.c:    n &= table->size-1;
hash_table.c:  /* printf("found %s at %d keyword %x\n",symbol,n,table->data[n]); */
hash_table.c:  return table->data[n];
hash_table.c:  if(!table->data[n])
hash_table.c:    table->used++;
hash_table.c:  table->data[n]=keyword;
hash_table.c:  if(table->used*2>table->size)
hash_table.c:    hash_expand(table,table->size*2);
hash_table.c:  printf("Size: %d\n",table->size);
hash_table.c:  printf("Used: %d\n",table->used);
hash_table.c:  for(i=0;i<table->size;i++)
hash_table.c:    if(table->data[i]) {
hash_table.c:      s=table->data[i]->symbol;
info2.c:  [I do! -hak]
info2.c:  printf("Copyright (C) 1991-93 DEC Paris Research Laboratory\n");
info2.c:  printf("Extensions, Copyright (C) 1994-1995 Intelligent Software Group, SFU\n");
info2.c:    printf("\n- Main data-structure sizes:\n");
info2.c:    pnf("stacked choice-point",sizeof(struct choice_point));
info2.c:    printf("\n- Size of C built-in types:\n");
info2.c:    printf("\n- System constants:\n");
info3.c:  [I do! -hak]
info3.c:  printf("Copyright (C) 1991-93 DEC Paris Research Laboratory\n");
info3.c:  printf("Extensions, Copyright (C) 1994-1995 Intelligent Software Group, SFU\n");
info3.c:    printf("\n- Main data-structure sizes:\n");
info3.c:    pnf("stacked choice-point",sizeof(struct choice_point));
info3.c:    printf("\n- Size of C built-in types:\n");
info3.c:    printf("\n- System constants:\n");
info.c:  [I do! -hak]
info.c:  printf("Copyright (C) 1991-93 DEC Paris Research Laboratory\n");
info.c:  printf("Extensions, Copyright (C) 1994-1995 Intelligent Software Group, SFU\n");
info.c:    printf("\n- Main data-structure sizes:\n");
info.c:    pnf("stacked choice-point",sizeof(struct choice_point));
info.c:    printf("\n- Size of C built-in types:\n");
info.c:    printf("\n- System constants:\n");
interrupt.c:    while (DIGIT(d)) { count=count*10+(d-'0'); d=read_char(); }
lefun.c:  result->type=top;
lefun.c:  result->status=stat;
lefun.c:  result->flags=stat?QUOTED_TRUE:FALSE; /* 14.9 */
lefun.c:  result->attr_list=NULL;
lefun.c:  result->coref=NULL;
lefun.c:  result->time_stamp=global_time_stamp; /* 9.6 */
lefun.c:  result->resid=NULL;
lefun.c:  result->value=NULL;
lefun.c:  result->type = (thereal==floor(thereal)) ? integer : real;
lefun.c:  result->status=stat;
lefun.c:  result->flags=stat?QUOTED_TRUE:FALSE; /* 14.9 */
lefun.c:  result->attr_list=NULL;
lefun.c:  result->coref=NULL;
lefun.c:  result->time_stamp=global_time_stamp; /* 9.6 */
lefun.c:  result->resid=NULL;
lefun.c:  result->value=(GENERIC)heap_alloc(sizeof(REAL));
lefun.c:  (* (REAL *)(result->value)) = thereal;
lefun.c:  result->type=top;
lefun.c:  result->status=stat;
lefun.c:  result->flags=stat?QUOTED_TRUE:FALSE; /* 14.9 */
lefun.c:  result->attr_list=NULL;
lefun.c:  result->coref=NULL;
lefun.c:  result->time_stamp=global_time_stamp; /* 9.6 */
lefun.c:  result->resid=NULL;
lefun.c:  result->value=NULL;
lefun.c:  curr->var=t;
lefun.c:  curr->othervar=u;
lefun.c:  curr->next=resid_vars;
lefun.c:  curr->var=t;
lefun.c:  curr->othervar=NULL; /* 21.9 */
lefun.c:  curr->next=resid_vars;
lefun.c:    Errorline("attempt to residuate on psi-term %P in the heap.\n",var);
lefun.c:  r= &(var->resid);
lefun.c:    if ((*r)->goal == g) { /* This goal is already attached */
lefun.c:      result=glb_code((*r)->sortflag,(*r)->bestsort,
lefun.c:		      TRUE,(GENERIC)var->type,
lefun.c:      result=glb_value(result,resflag,rescode,(*r)->value,var->value,
lefun.c:	result=glb_code(resflag,rescode,TRUE,(GENERIC)othervar->type,
lefun.c:        result=glb_value(result,resflag2,rescode2,resvalue,othervar->value,
lefun.c:	  if ((*r)->value==NULL && resvalue2!=NULL) { /* 6.10 */
lefun.c:	    push_ptr_value(int_ptr,&((*r)->value));
lefun.c:	  if ((*r)->bestsort!=rescode2) {
lefun.c:            push_ptr_value(((*r)->sortflag?def_ptr:code_ptr),
lefun.c:			   &((*r)->bestsort));
lefun.c:            (*r)->bestsort=rescode2; /* 21.9 */
lefun.c:	  if ((*r)->sortflag!=resflag2) {
lefun.c:            push_ptr_value(int_ptr,(GENERIC *)&((*r)->sortflag));
lefun.c:            (*r)->sortflag=resflag2; /* 21.9 */
lefun.c:	if ((*r)->value==NULL && resvalue!=NULL) { /* 6.10 */
lefun.c:	  push_ptr_value(int_ptr,&((*r)->value));
lefun.c:	if ((*r)->bestsort!=rescode) {
lefun.c:          push_ptr_value(((*r)->sortflag?def_ptr:code_ptr),
lefun.c:	                 &((*r)->bestsort));
lefun.c:          (*r)->bestsort=rescode; /* 21.9 */
lefun.c:	if ((*r)->sortflag!=resflag) {
lefun.c:          push_ptr_value(int_ptr,(GENERIC *)&((*r)->sortflag));
lefun.c:          (*r)->sortflag=resflag; /* 21.9 */
lefun.c:      r= &((*r)->next);  /* look at the next one */
lefun.c:      result=glb_code(TRUE,(GENERIC)var->type,TRUE,(GENERIC)othervar->type,&resflag,&rescode);
lefun.c:      result=glb_value(result,resflag,rescode,var->value,othervar->value,
lefun.c:	(*r)->sortflag=resflag;
lefun.c:        (*r)->bestsort=rescode; /* 21.9 */
lefun.c:	(*r)->value=resvalue; /* 6.10 */
lefun.c:      (*r)->sortflag=TRUE;
lefun.c:      (*r)->bestsort=(GENERIC)var->type; /* 21.9 */
lefun.c:      (*r)->value=(GENERIC)var->value; /* 6.10 */
lefun.c:    (*r)->goal=g;
lefun.c:    (*r)->next=NULL;
lefun.c:  if (!(g->pending)) {
lefun.c:    push_ptr_value(int_ptr,(GENERIC *)&(g->pending));
lefun.c:    g->pending=TRUE;
lefun.c:/* LIFE-defined routines reset the goal stack to what it was */
lefun.c:  goal_stack=resid_aim->next; /* reset goal stack */
lefun.c:/* C-defined routines do all stack manipulation themselves */
lefun.c:  /* goal_stack=resid_aim->next; */
lefun.c:    print_resid_message(resid_aim->a,resid_vars);
lefun.c:    t=resid_vars->var; /* 21.9 */
lefun.c:    u=resid_vars->othervar; /* 21.9 */
lefun.c:    resid_vars=resid_vars->next;
lefun.c:  psi-term is left intact.
lefun.c:  goal_stack=resid_aim->next;
lefun.c:  funct=(ptr_psi_term )resid_aim->a;
lefun.c:  result=(ptr_psi_term )resid_aim->b;
lefun.c:  This is done by simply pushing the residuated goals onto the goal-stack.
lefun.c:  if (r=t->resid) {
lefun.c:    if (trailflag) push_ptr_value(resid_ptr,(GENERIC *)&(t->resid));
lefun.c:    t->resid=NULL;
lefun.c:      g=r->goal;
lefun.c:      if (g->pending) {
lefun.c:	push_ptr_value(int_ptr,(GENERIC *)&(g->pending));
lefun.c:	g->pending=FALSE;
lefun.c:	push_ptr_value(goal_ptr,(GENERIC *)&(g->next));
lefun.c:	g->next=goal_stack;
lefun.c:        Traceline("releasing %P\n",g->a);
lefun.c:      r=r->next;
lefun.c:  g= &(u->resid);
lefun.c:    g = &((*g)->next);
lefun.c:  *g=v->resid;
lefun.c:  It creates an extra psi-term (with value top) in which to write the result.
lefun.c:  funct=(ptr_psi_term )aim->a;
lefun.c:  push2_ptr_value(int_ptr,(GENERIC *)&(funct->status),(GENERIC)(funct->status & SMASK));
lefun.c:  funct->status=4;
lefun.c:  /* if (!funct->type->evaluate_args) mark_quote(funct); 25.8 */ /* 18.2 PVR */
lefun.c:  result=(ptr_psi_term )aim->b;
lefun.c:  rule=(ptr_pair_list )aim->c;
lefun.c:      while (rule && (rule->a==NULL || rule->b==NULL)) {
lefun.c:        rule=rule->next;
lefun.c:        /* push_choice_point(eval,funct,result,rule->next); */ /* 17.6 */
lefun.c:	    head=eval_copy(rule->a,STACK);
lefun.c:	head=quote_copy(rule->a,STACK);
lefun.c:        body=eval_copy(rule->b,STACK);
lefun.c:	head->status=4;
lefun.c:        if (rule->next) /* 17.6 */
lefun.c:          push_choice_point(eval,funct,result,(GENERIC)rule->next);
lefun.c:        /* eval_args(head->attr_list); */
lefun.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
lefun.c:  	/* RESID */ match_attr1(&((*u)->right),v->right,rb);
lefun.c:        t = (ptr_psi_term) (*u)->data;
lefun.c:  	/* RESID */ push_goal(match,(ptr_psi_term)(*u)->data,(ptr_psi_term)v->data,(GENERIC)rb);
lefun.c:  	/* RESID */ match_attr1(&((*u)->left),v->left,rb);
lefun.c:        temp=v->right;
lefun.c:        v->right=NULL;
lefun.c:  	/* RESID */ match_attr1(&((*u)->left),v,rb);
lefun.c:  	v->right=temp;
lefun.c:  	temp=v->left;
lefun.c:  	v->left=NULL;
lefun.c:  	/* RESID */ match_attr1(&((*u)->right),v,rb);
lefun.c:  	v->left=temp;
lefun.c:      match_attr1(u,v->right,rb);
lefun.c:      t = (ptr_psi_term) v->data;
lefun.c:      match_attr1(u,v->left,rb);
lefun.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
lefun.c:  	/* RESID */ match_attr2(&((*u)->right),v->right,rb);
lefun.c:  	/* RESID */ match_attr2(&((*u)->left),v->left,rb);
lefun.c:        temp=v->right;
lefun.c:        v->right=NULL;
lefun.c:  	/* RESID */ match_attr2(&((*u)->left),v,rb);
lefun.c:  	v->right=temp;
lefun.c:  	temp=v->left;
lefun.c:  	v->left=NULL;
lefun.c:  	/* RESID */ match_attr2(&((*u)->right),v,rb);
lefun.c:  	v->left=temp;
lefun.c:    match_attr1(&((*u)->right),v,rb);
lefun.c:    t = (ptr_psi_term) (*u)->data;
lefun.c:    /* Create a new psi-term to put the (useless) result: */
lefun.c:    match_attr1(&((*u)->left),v,rb);
lefun.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
lefun.c:  	/* RESID */ match_attr3(&((*u)->right),v->right,rb);
lefun.c:        t1 = (ptr_psi_term) (*u)->data;
lefun.c:        t2 = (ptr_psi_term) v->data;
lefun.c:  	/* RESID */ /* push_goal(match,(*u)->data,v->data,rb); */
lefun.c:  	/* RESID */ match_attr3(&((*u)->left),v->left,rb);
lefun.c:        temp=v->right;
lefun.c:        v->right=NULL;
lefun.c:  	/* RESID */ match_attr3(&((*u)->left),v,rb);
lefun.c:  	v->right=temp;
lefun.c:  	temp=v->left;
lefun.c:  	v->left=NULL;
lefun.c:  	/* RESID */ match_attr3(&((*u)->right),v,rb);
lefun.c:  	v->left=temp;
lefun.c:  u=(ptr_psi_term )aim->a;
lefun.c:  v=(ptr_psi_term )aim->b;
lefun.c:  rb=(ptr_resid_block)aim->c;
lefun.c:    if (success=matches(u->type,v->type,&lesseq)) {
lefun.c:        if (u->type!=cut || v->type!=cut) { /* Ignore value field for cut! */
lefun.c:          if (v->value) {
lefun.c:            if (u->value) {
lefun.c:              if (overlap_type(v->type,real))
lefun.c:                success=(*((REAL *)u->value)==(*((REAL *)v->value)));
lefun.c:              else if (overlap_type(v->type,quoted_string))
lefun.c:                success=(lf_strcmp((char *)u->value,(char *)v->value)==0);
lefun.c:              else if (overlap_type(v->type,sys_bytedata)) {
lefun.c:		unsigned long ulen = *((unsigned long *) u->value);
lefun.c:		unsigned long vlen = *((unsigned long *) v->value);
lefun.c:                success=(ulen==vlen && bcmp((char *)u->value,(char *)v->value,ulen)==0);
lefun.c:      else if (u->value) {
lefun.c:        if (v->value) {
lefun.c:          if (overlap_type(v->type,real))
lefun.c:            success=(*((REAL *)u->value)==(*((REAL *)v->value)));
lefun.c:        else if (overlap_type(u->type,integer)) {
lefun.c:          r= *((REAL *)u->value);
lefun.c:          v->coref=u;
lefun.c:	  match_attr(&(u->attr_list),v->attr_list,rb);
lefun.c:    flag = eval_args(n->right);
lefun.c:    flag = check_out((ptr_psi_term)n->data) && flag;
lefun.c:    flag = eval_args(n->left) && flag;
lefun.c:  if (t->value)
lefun.c:     RM: Dec 16 1992  Re-instated this check then disabled it again
lefun.c:     Errorline("embedded functions appeared in %P.\n",resid_aim->a);
lefun.c:    /* Create a psi-term to put the result */
lefun.c:    copy->status &= ~RMASK;
lefun.c:    /* push_ptr_value(psi_term_ptr,&(t->coref)); */
lefun.c:    push_psi_ptr_value(t,(GENERIC *)&(t->coref));
lefun.c:    t->coref=result;
lefun.c:    push_goal(eval,copy,result,(GENERIC)t->type->rule);
lefun.c:    /* Avoid evaluation for built-in functions with unevaluated arguments */
lefun.c:    if (t->type==iff) {
lefun.c:      get_one_arg(t->attr_list,&t1);
lefun.c:    else if(t->type==disjunction) {
lefun.c:    else if (t->type!=such_that) {
lefun.c:      if (t->type->evaluate_args)
lefun.c:        eval_args(t->attr_list);
lefun.c:      /* else mark_quote_tree(t->attr_list); 24.8 25.8 */
lefun.c:  push2_ptr_value(int_ptr,(GENERIC *)&(t->status),(GENERIC)(t->status & SMASK));
lefun.c:  /* push_ptr_value(int_ptr,&(t->status)); */
lefun.c:  if (t->type->properties) {
lefun.c:    if (t->attr_list || t->type->always_check) {
lefun.c:      /* t->status=(2 & SMASK) | (t->status & RMASK); PVR 18.2.94 */
lefun.c:      eval_args(t->attr_list);
lefun.c:      t->status= (2 & SMASK) | (t->status & RMASK);
lefun.c:	if (!ovverlap_type(t->type,alist))
lefun.c:	t->status= (4 & SMASK) | (t->status & RMASK);
lefun.c:    flag=eval_args(t->attr_list);
lefun.c:  - T is a conjunction,
lefun.c:  - T is a type which has properties to check.
lefun.c:  - The same for T's arguments.
lefun.c:  - i_check_out(t) checks out everything except functions.  When a function
lefun.c:  - f_check_out(t) checks out functions too.
lefun.c:  - i_eval_args(n) checks out all arguments, except functions.
lefun.c:  - check_func(t) checks out a function & all its arguments (including all
lefun.c:    of unification, matching, built-ins, and user-defined routines.
lefun.c:            t->status,t); for brunobug.lf PVR 14.2.94 */
lefun.c:            t->status,t); /* for brunobug.lf PVR 14.2.94 */
lefun.c:  if (t->status || (GENERIC)t>=heap_pointer) /*  RM: Feb  8 1993  */
lefun.c:    t->status |= RMASK;
lefun.c:    switch(t->type->type) { /*  RM: Feb  8 1993  */
lefun.c:      flag=eval_args(t->attr_list);
lefun.c:    t->status &= ~RMASK;
lefun.c:/* These routines handle evaluation-by-need.  Check_out is changed  */
lefun.c:/* Functions inside of psi-terms are only evaluated if needed.  It  */
lefun.c:/*       If the psi-term P is a function, call check_func to        */
lefun.c:/*       If the psi-term P recursively contains any functions, then */
lefun.c:/*       a built-in, even those not used by the built-in.           */
lefun.c:/*    deref_ptr(P) = while (P->coref) P=P->coref                    */
lefun.c:/* Ensure evaluation of top of psi-term */
lefun.c:  if (t->status==0) {
lefun.c:    if(t->type->type==function) {
lefun.c:      if(t->type->type==global) { /*  RM: Feb 10 1993  */
lefun.c:	if (t->status!=2) {
lefun.c:	    push_ptr_value(int_ptr,(GENERIC *)&(t->status)); /*  RM: Jul 15 1993  */
lefun.c:	  t->status=4;
lefun.c:/* Ensure evaluation of *all* of psi-term */
lefun.c:  if (t->status==0) {
lefun.c:    if (t->type->type==function) {
lefun.c:      if(t->type->type==global) { /*  RM: Feb 10 1993  */
lefun.c:	/* if (t->status!=2) Tried adding this -- PVR 9.2.94 */
lefun.c:	    push_ptr_value(int_ptr,(GENERIC *)&(t->status));/*  RM: Jul 15 1993  */
lefun.c:	  t->status=4;
lefun.c:	  deref_rec_args(t->attr_list);
lefun.c:    deref_rec_args(n->right);
lefun.c:    t1 = (ptr_psi_term) (n->data);
lefun.c:    deref_rec_args(n->left);
lefun.c:  deref_rec_args_exc(t->attr_list,set);
lefun.c:    deref_rec_args_exc(n->right,set);
lefun.c:    if (!in_set(n->key,set)) {
lefun.c:      t = (ptr_psi_term) (n->data);
lefun.c:    deref_rec_args_exc(n->left,set);
lefun.c:  if (t->status==0) {
lefun.c:    if (t->type->type==function) {
lefun.c:      if(t->type->type==global) { /*  RM: Feb 10 1993  */
lefun.c:	t->status=4;
lefun.c:      rb->cc_cr = (can_curry<<1) + curried; /* 11.9 */
lefun.c:      rb->ra = resid_aim;
lefun.c:      rb->rv = resid_vars;
lefun.c:      /* rb->cr = curried; 11.9 */
lefun.c:      /* rb->cc = can_curry; 11.9 */
lefun.c:      rb->md = match_date;
lefun.c:      can_curry = (rb->cc_cr&2)?TRUE:FALSE; /* 11.9 */
lefun.c:      curried   = (rb->cc_cr&1)?TRUE:FALSE; /* 11.9 */
lefun.c:      resid_aim = rb->ra;
lefun.c:      resid_vars = rb->rv;
lefun.c:      /* curried = rb->cr; 11.9 */
lefun.c:      /* can_curry = rb->cc; 11.9 */
lefun.c:      *match_date = rb->md;
lefun.c:  if(!t->type->global_value) {
lefun.c:      n->type=psi_term_ptr;
lefun.c:      n->a= (GENERIC) &(t->type->global_value);
lefun.c:      n->b= NULL;
lefun.c:      n->next=undo_stack;
lefun.c:    t->type->global_value=eval_copy(t->type->init_value,STACK);
lefun.c:  if(t->type->type==global && t!=t->type->global_value) {
lefun.c:    push_psi_ptr_value(t,(GENERIC *)&(t->coref));
lefun.c:    t->coref=t->type->global_value;
lefun.c:  Initialize all non-persistent global variables.
lefun.c:    for(def=first_definition;def;def=def->next) {
lefun.c:    if(def->type==global && ((GENERIC)def->global_value<heap_pointer)) {
lefun.c:    def->global_value=eval_copy(def->init_value,STACK); 
lefun.c:  for(def=first_definition;def;def=def->next)
lefun.c:    if((GENERIC)(def->global_value)<(GENERIC)heap_pointer)
lefun.c:      def->global_value=NULL;
lib2.c:/* VERSION of Wild-LIFE for calling from C */
lib2.c:    if(n->left)
lib2.c:      f=group_features(f,n->left);
lib2.c:    *f=n->key;
lib2.c:    if(n->right)
lib2.c:      f=group_features(f,n->right);
lib2.c:    sprintf(prompt_buffer,"%s%s",current_module->module_name,PROMPT);
lib2.c:  This routine contains the Read-Solve-Prlong loop.
lib2.c:  /* printf("%ld\n",(long)(stack_pointer-mem_base)); */ /* 8.10 */
lib2.c:      if(goal_stack && goal_stack->type==c_what_next) {
lib2.c:	if((long)(goal_stack->a)==c_query_level)
lib2.c:	    c_query_level--;
lib2.c:	  c_query_level--;
lib2.c:	goal_stack=goal_stack->next;
lib2.c:    result=(ptr_psi_term)n->data;
lib2.c:    if(n->left)
lib2.c:      result+=WFfeature_count_loop(n->left);
lib2.c:    if(n->right)
lib2.c:      result+=WFfeature_count_loop(n->right);
lib2.c:    result=WFfeature_count_loop(psi->attr_list);
lib2.c:    result=psi->type->keyword->combined_name;
lib2.c:    n=WFfeature_count_loop(psi->attr_list);
lib2.c:      group_features(features,psi->attr_list);
lib2.c:    if(sub_type(psi->type,real) && psi->value) {
lib2.c:      value= *((double *)psi->value);
lib2.c:    if(sub_type(psi->type,quoted_string) && psi->value) {
lib2.c:      value=(char *)psi->value;
lib2.c:    n=find(FEATURECMP,feature,psi->attr_list);
lib2.c:      result=(PsiTerm)n->data;
lib.c:/* VERSION of Wild-LIFE for calling from C */
lib.c:    if(n->left)
lib.c:      f=group_features(f,n->left);
lib.c:    *f=n->key;
lib.c:    if(n->right)
lib.c:      f=group_features(f,n->right);
lib.c:    sprintf(prompt_buffer,"%s%s",current_module->module_name,PROMPT);
lib.c:  This routine contains the Read-Solve-Prlong loop.
lib.c:  /* printf("%ld\n",(long)(stack_pointer-mem_base)); */ /* 8.10 */
lib.c:      if(goal_stack && goal_stack->type==c_what_next) {
lib.c:	if((long)(goal_stack->a)==c_query_level)
lib.c:	    c_query_level--;
lib.c:	  c_query_level--;
lib.c:	goal_stack=goal_stack->next;
lib.c:    result=(ptr_psi_term)n->data;
lib.c:    if(n->left)
lib.c:      result+=WFfeature_count_loop(n->left);
lib.c:    if(n->right)
lib.c:      result+=WFfeature_count_loop(n->right);
lib.c:    result=WFfeature_count_loop(psi->attr_list);
lib.c:    result=psi->type->keyword->combined_name;
lib.c:    n=WFfeature_count_loop(psi->attr_list);
lib.c:      group_features(features,psi->attr_list);
lib.c:    if(sub_type(psi->type,real) && psi->value) {
lib.c:      value= *((double *)psi->value);
lib.c:    if(sub_type(psi->type,quoted_string) && psi->value) {
lib.c:      value=(char *)psi->value;
lib.c:    n=find(FEATURECMP,feature,psi->attr_list);
lib.c:      result=(PsiTerm)n->data;
life2.c:This routine contains the Read-Solve-Prlong loop.
life2.c:    /* printf("%ld\n",(long)(stack_pointer-mem_base)); */ /* 8.10 */
life2.c:      exitflag=(s->type==eof);
life2.c:          Errorline("non-NULL undo stack.\n");
life2.c:  /* hash_display(x_module->symbol_table); */
life.c:This routine contains the Read-Solve-Prlong loop.
life.c:    /* printf("%ld\n",(long)(stack_pointer-mem_base)); */ /* 8.10 */
life.c:      exitflag=(s->type==eof);
life.c:          Errorline("non-NULL undo stack.\n");
life.c:  /* hash_display(x_module->symbol_table); */
list.c:    header->First = NULL;
list.c:    header->Last = NULL;
list.c:    header->Lock = 0;
list.c:    header->GetLinks = getLinks;
list.c:    RefListGetLinksProc  getLinks = header->GetLinks;
list.c:    (*getLinks)(atom)->Next = header->First;
list.c:    (*getLinks)(atom)->Prev = NULL;
list.c:    if (header->First != NULL)
list.c:      (*getLinks)(header->First)->Prev = atom;
list.c:      header->Last  = atom;
list.c:    header->First = atom;
list.c:    RefListGetLinksProc  getLinks = header->GetLinks;
list.c:    if (header->Last != NULL)
list.c:      (*getLinks)(header->Last)->Next = atom;
list.c:      header->First = atom;
list.c:    (*getLinks)(atom)->Prev = header->Last;
list.c:    (*getLinks)(atom)->Next = NULL;
list.c:    header->Last  = atom;
list.c:    RefListGetLinksProc  getLinks = header->GetLinks;
list.c:        (*getLinks)(atom)->Next = mark;
list.c:        if (mark != header->First)
list.c:            (*getLinks)(atom)->Prev = (*getLinks)(mark)->Prev;
list.c:            (*getLinks)((*getLinks)(mark)->Prev)->Next = atom;
list.c:            (*getLinks)(atom)->Prev = NULL;
list.c:            header->First = atom;
list.c:        (*getLinks)(mark)->Prev = atom;
list.c:    RefListGetLinksProc  getLinks = header->GetLinks;
list.c:    if (header->Lock > 1)
list.c:        (*getLinks)(atom)->Prev = mark;
list.c:        if (mark != header->Last)
list.c:            (*getLinks)(atom)->Next = (*getLinks)(mark)->Next;
list.c:            (*getLinks)((*getLinks)(mark)->Next)->Prev = atom;
list.c:            (*getLinks)(atom)->Next = NULL;
list.c:            header->Last = atom;
list.c:        (*getLinks)(mark)->Next = atom;
list.c:    RefListGetLinksProc	getLinks = header->GetLinks;
list.c:    if ((*getLinks)(first)->Next != second)
list.c:    if (header->First == first)
list.c:      header->First = second;
list.c:      (*getLinks)((*getLinks)(first)->Prev)->Next = second;
list.c:    if (header->Last == second)
list.c:      header->Last = first;
list.c:      (*getLinks)((*getLinks)(second)->Next)->Prev = first;
list.c:    (*getLinks)(second)->Prev = (*getLinks)(first)->Prev;
list.c:    (*getLinks)(first)->Next  = (*getLinks)(second)->Next;
list.c:    (*getLinks)(first)->Prev  = second;
list.c:    (*getLinks)(second)->Next = first;
list.c:    save = (*header->GetLinks)(atom)->Next;
list.c:    (*header->GetLinks)(atom)->Next = (*header->GetLinks)(atom)->Prev;
list.c:    (*header->GetLinks)(atom)->Prev = save;
list.c:    RefListGetLinksProc	getLinks = header->GetLinks;
list.c:    cur = header->First;
list.c:    header->First = header->Last;
list.c:    header->Last  = cur;
list.c:	next = (*getLinks)(cur)->Next;
list.c:/*-----------------------------------------------------------------------------
list.c:	- The container is 'updated' two times if the first and last atom
list.c:-----------------------------------------------------------------------------*/
list.c:    RefListGetLinksProc  getLinks = header->GetLinks;
list.c:    if (header->Lock > 1)
list.c:    if ((*getLinks)(atom)->Prev != NULL)
list.c:        (*getLinks)((*getLinks)(atom)->Prev)->Next = 
list.c:            (*getLinks)(atom)->Next;
list.c:      header->First = (*getLinks)(atom)->Next;
list.c:    if ((*getLinks)(atom)->Next != NULL)
list.c:        (*getLinks)((*getLinks)(atom)->Next)->Prev = 
list.c:            (*getLinks)(atom)->Prev;
list.c:      header->Last = (*getLinks)(atom)->Prev;
list.c:    (*getLinks)(atom)->Prev = NULL;
list.c:    (*getLinks)(atom)->Next = NULL;
list.c:    RefListGetLinksProc  getLinks = header1->GetLinks;
list.c:    if (header1->GetLinks == header2->GetLinks)
list.c:    if (header2->First != NULL)
list.c:        if (header1->First == NULL)
list.c:            header1->First = header2->First;
list.c:            (*getLinks)(header1->Last)->Next  = header2->First;
list.c:            (*getLinks)(header2->First)->Prev = header1->Last;
list.c:        header1->Last = header2->Last;
list.c:    header->Lock += 1;
list.c:    header->Lock -=1;
list.c:/*-----------------------------------------------------------------------------
list.c:-----------------------------------------------------------------------------*/
list.c:    return (List_EnumFrom (header, header->First, proc, closure));
list.c:    header->Lock += 1;
list.c:    header->Lock -=1;
list.c:    return (List_EnumBackFrom (header, header->Last, proc, closure));
list.c:    return (links->Next == NULL && links->Prev == NULL);
list.c:    RefListGetLinksProc  getLinks = header->GetLinks;
list.c:	newHeader->First = List_Next (header, atom);
list.c:	newHeader->Last  = header->Last;
list.c:	header->Last = atom;
list.c:	(*getLinks)(atom)->Next = NULL;
list.c:	(*getLinks)(newHeader->First)->Prev = NULL;
login.c:long more_v_attr; /* Vice-versa */
login.c:    if (t->key==one) {
login.c:      *a=(ptr_psi_term )t->data;
login.c:      n=t->right;
login.c:	if (n->key==two)
login.c:	  *b=(ptr_psi_term )n->data;
login.c:	    *b=(ptr_psi_term )n->data;
login.c:	*a=(ptr_psi_term )n->data;
login.c:	*b=(ptr_psi_term )n->data;
login.c:    if (t->key==one) {
login.c:      *a=(ptr_psi_term)t->data;
login.c:	*a=(ptr_psi_term)n->data;
login.c:    if (t->key==one)
login.c:      *a= (ptr_psi_term *)(&t->data);
login.c:	*a= (ptr_psi_term *)(&n->data);
login.c:  For predicates or functions, insert the clause 'HEAD :- BODY' or the rule
login.c:  'HEAD -> BODY' into the definition of HEAD.
login.c:  /* assert(head->resid==NULL); 10.8 */
login.c:  /* assert(body->resid==NULL); 10.8 */
login.c:    def=head->type;
login.c:    if (def->type==undef || def->type==typ)
login.c:	 /* def->type==undef ||
login.c:	    def->keyword->module==current_module */
login.c:	if (def->rule && (unsigned long)def->rule<=MAX_BUILT_INS) {
login.c:	  Errorline("the built-in %T '%s' may not be redefined.\n",
login.c:		    def->type, def->keyword->symbol);
login.c:	  def->type=typ;
login.c:	  /* p->a=exact_copy(head2,HEAP); 24.8 25.8 */
login.c:	  /* p->b=exact_copy(body,HEAP); 24.8 25.8 */
login.c:	  p->a=quote_copy(head2,HEAP); /* 24.8 25.8 */
login.c:	  p->b=quote_copy(body,HEAP); /* 24.8 25.8 */
login.c:	    p->next=def->rule;
login.c:	    def->rule=p;
login.c:	    p->next=NULL;
login.c:	    p2= &(def->rule);
login.c:	      p2= &((*p2)->next);
login.c:		  def->type,
login.c:		  def->keyword->combined_name,
login.c:		  current_module->module_name);
login.c:                def->type, def->keyword->symbol, typ);
login.c:  The psi_term T is of the form 'H :- B' or 'H -> B', but it may be incorrect
login.c:      get_two_args(t->attr_list,&arg1,&arg2);
login.c:      arg2->type->keyword->symbol, arg1->type->keyword->symbol);
login.c:      str=arg2->type->keyword->symbol;
login.c:      *(arg2->type)= *(arg1->type);
login.c:      arg2->type->keyword->symbol=str;
login.c:  if (equ_tok((*t),":-"))
login.c:    if (equ_tok((*t),"->"))
login.c:	  /* if (equ_tok((*t),"<<<-")) {   RM: Feb 10 1993
login.c:  UNIFY and vice-versa.
login.c:  The argument to PROVE is the adress of a PSI_TERM (psi-term) which represents
login.c:      n->type=t;
login.c:      n->a= (GENERIC)p;
login.c:      n->b= *p;
login.c:      n->next=undo_stack;
login.c:  Same as push_ptr_value, but only for psi-terms whose definition field is
login.c:  This routine implements the time-stamp technique of only trailing
login.c:  q is address of psi-term, p is address of field inside psi-term
login.c:      /* (q->time_stamp != global_time_stamp) && */
login.c:      m->type=int_ptr;
login.c:      m->a= (GENERIC) &(q->time_stamp);
login.c:      m->b= (GENERIC) (q->time_stamp);
login.c:      m->next=undo_stack;
login.c:      n->type=def_ptr;
login.c:      n->a= (GENERIC)p;
login.c:      n->b= *p;
login.c:      n->next=m;
login.c:      n->type=def_ptr;
login.c:      n->a= (GENERIC)p;
login.c:      n->b= *p;
login.c:      n->next=undo_stack;
login.c:      q->time_stamp=global_time_stamp;
login.c:  Same as push_ptr_value, but only for psi-terms whose coref field is being
login.c:  This routine implements the time-stamp technique of only trailing
login.c:  q is address of psi-term, p is address of field inside psi-term
login.c:      /* (q->time_stamp != global_time_stamp) && */
login.c:      m->type=int_ptr;
login.c:      m->a= (GENERIC) &(q->time_stamp);
login.c:      m->b= (GENERIC) (q->time_stamp);
login.c:      m->next=undo_stack;
login.c:      n->type=psi_term_ptr;
login.c:      n->a= (GENERIC)p;
login.c:      n->b= *p;
login.c:      n->next=m;
login.c:      n->type=psi_term_ptr;
login.c:      n->a= (GENERIC)p;
login.c:      n->b= *p;
login.c:      n->next=undo_stack;
login.c:      q->time_stamp=global_time_stamp;
login.c:  n->type=t;
login.c:  n->a= (GENERIC)p;
login.c:  n->b= *p;
login.c:  n->next=undo_stack;
login.c:  n->type=type;
login.c:  n->a=(GENERIC)disp;
login.c:  n->b=(GENERIC)wind;
login.c:  n->next=undo_stack;
login.c:    n->type=t;
login.c:    n->a= (GENERIC)p;
login.c:    n->b= (GENERIC)v;
login.c:    n->next=undo_stack;
login.c:  thegoal->type=t;
login.c:  thegoal->a=a;
login.c:  thegoal->b=b;
login.c:  thegoal->c=c;
login.c:  thegoal->next=goal_stack;
login.c:  thegoal->pending=FALSE;
login.c:  alternative->type=t;
login.c:  alternative->a=a;
login.c:  alternative->b=b;
login.c:  alternative->c=c;
login.c:  alternative->next=goal_stack;
login.c:  alternative->pending=FALSE;
login.c:  choice->undo_point=undo_stack;
login.c:  choice->goal_stack=alternative;
login.c:  choice->next=choice_stack;
login.c:  choice->stack_top=top;
login.c:  choice->time_stamp=global_time_stamp; /* 9.6 */
login.c:choice_stack?choice_stack->time_stamp:INIT_TIME_STAMP;
login.c:  Undoes any side-effects up to LIMIT. Limit being the adress of the stack of
login.c:  side-effects you wish to return to.
login.c:    if (undo_stack->type & undo_action) {
login.c:      switch(undo_stack->type) { /*** RM 8/12/92 ***/
login.c:        x_destroy_window((Display *)undo_stack->a,(Window)undo_stack->b);
login.c:        x_show_window((Display *)undo_stack->a,(Window)undo_stack->b);
login.c:        x_hide_window((Display *)undo_stack->a,(Window)undo_stack->b);
login.c:        x_show_subwindow((Display *)undo_stack->a,(Window)undo_stack->b);
login.c:        x_hide_subwindow((Display *)undo_stack->a,(Window)undo_stack->b);
login.c:      *((GENERIC *)(undo_stack->a))=undo_stack->b;
login.c:    undo_stack=undo_stack->next;
login.c:    if (u->type & undo_action) {
login.c:    if (u->type==destroy_window) {
login.c:    x_destroy_window((unsigned long)u->a,(unsigned long)u->b);
login.c:    else if (u->type==show_window) {
login.c:    x_show_window((unsigned long)u->a,(unsigned long)u->b);
login.c:    else if (u->type==hide_window) {
login.c:    x_hide_window((unsigned long)u->a,(unsigned long)u->b);
login.c:    u=u->next;
login.c:  Undo everything back to the previous choice-point and take the alternative
login.c:  goal_stack=choice_stack->goal_stack;
login.c:  undo(choice_stack->undo_point);
login.c:  /* global_time_stamp=choice_stack->time_stamp; */ /* 9.6 */
login.c:  stack_pointer=choice_stack->stack_top;
login.c:  choice_stack=choice_stack->next;
login.c:  This routine should be called when a cut built-in is done.
login.c:    cut_sp = cutpt->stack_top;
login.c:    cut_limit = cutpt->undo_point;
login.c:    if (!(u->type & undo_action) && VALID_RANGE(u->a) &&
login.c:        (unsigned long)u->a>(unsigned long)cut_sp && (unsigned long)u->a<=(unsigned long)stack_pointer) {
login.c:      *prev = u->next;
login.c:    prev = &(u->next);
login.c:    u = u->next;
login.c:    if ((u->type & undo_action) &&
login.c:        ((unsigned long)u->a==disp) && ((unsigned long)u->b==wind)) {
login.c:      *prev = u->next;
login.c:    prev = &(u->next);
login.c:    u = u->next;
login.c:    u = c->undo_point;
login.c:    prev = &(c->undo_point);
login.c:    while (u && (u->type & undo_action) &&
login.c:           ((unsigned long)u->a==disp) && ((unsigned long)u->b==wind)) {
login.c:      *prev = u->next;
login.c:      prev = &(u->next);
login.c:      u = u->next;
login.c:    c = c->next;
login.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
login.c:	if (v->right)
login.c:	  merge1(&((*u)->right),v->right);
login.c:	push_goal(unify,(ptr_psi_term)(*u)->data,(ptr_psi_term)v->data,NULL);
login.c:	if (v->left)
login.c:	  merge1(&((*u)->left),v->left);
login.c:	temp=v->right;
login.c:	v->right=NULL;
login.c:	merge1(&((*u)->left),v);
login.c:	v->right=temp;
login.c:        temp=v->left;
login.c:        v->left=NULL;
login.c:        merge1(&((*u)->right),v);
login.c:        v->left=temp;
login.c:/* For each lone argument in either u or v, create a new psi-term to put */
login.c:/* the (useless) result: This is needed so that *all* arguments of a uni-*/
login.c:/* unified psi-term are evaluated, which avoids incorrect 'Yes' answers. */
login.c:      merge2(u,v->right);
login.c:      t = (ptr_psi_term) v->data;
login.c:      merge2(u,v->left);
login.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
login.c:	/* if (v->right) */
login.c:	merge2(&((*u)->right),v->right);
login.c:	/* if (v->left) */
login.c:	merge2(&((*u)->left),v->left);
login.c:	temp=v->right;
login.c:	v->right=NULL;
login.c:	merge2(&((*u)->left),v);
login.c:	v->right=temp;
login.c:        temp=v->left;
login.c:        v->left=NULL;
login.c:        merge2(&((*u)->right),v);
login.c:        v->left=temp;
login.c:    merge2(&((*u)->right),v);
login.c:    t = (ptr_psi_term) (*u)->data;
login.c:    merge2(&((*u)->left),v);
login.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
login.c:	if (v->right)
login.c:	  merge3(&((*u)->right),v->right);
login.c:        t1 = (ptr_psi_term) (*u)->data;
login.c:        /* t2 = (ptr_psi_term) v->data; */
login.c:	/* push_goal(unify,(*u)->data,v->data,NULL); */
login.c:	if (v->left)
login.c:	  merge3(&((*u)->left),v->left);
login.c:	temp=v->right;
login.c:	v->right=NULL;
login.c:	merge3(&((*u)->left),v);
login.c:	v->right=temp;
login.c:        temp=v->left;
login.c:        v->left=NULL;
login.c:        merge3(&((*u)->right),v);
login.c:        v->left=temp;
login.c:  attributes fields of psi-terms.  U and V are merged together, that is U
login.c:  For each label L in V and L->Vpsi_term:
login.c:  If L is in U Then With L->Upsi_term Do unify(Upsi_term,Vpsi_term)
login.c:  Else merge L->Vpsi_term in U.
login.c:      merge(u,v->right);
login.c:      t = (ptr_psi_term) v->data;
login.c:      merge(u,v->left);
login.c:      cmp=featcmp((*u)->key,v->key,FEATURECMP);
login.c:        /* if (v->right) */
login.c:	merge(&((*u)->right),v->right);
login.c:        push_goal(unify,(*u)->data,v->data,NULL);
login.c:        /* if (v->left) */
login.c:	merge(&((*u)->left),v->left);
login.c:        temp=v->right;
login.c:        v->right=NULL;
login.c:        merge(&((*u)->left),v);
login.c:        v->right=temp;
login.c:        temp=v->left;
login.c:        v->left=NULL;
login.c:        merge(&((*u)->right),v);
login.c:        v->left=temp;
login.c:    merge(&((*u)->right),v);
login.c:    t = (ptr_psi_term) (*u)->data;
login.c:    merge(&((*u)->left),v);
login.c:/* For built-ins.c */
login.c:  It prints the number of of sub-goals attempted, along with cpu-time
login.c:    t = (end_time.tms_utime - start_time.tms_utime)/60.0;
login.c:    printf(", %ld stack",sizeof(mem_base)*(stack_pointer-mem_base));
login.c:    printf(", %ld heap",sizeof(mem_base)*(mem_limit-heap_pointer));
login.c:  for enumerating type disjunctions--all higher constraints have already
login.c:  push2_ptr_value(int_ptr,(GENERIC *)&(u->status),(GENERIC)(u->status & SMASK));
login.c:  u->status=(4 & SMASK) | (u->status & RMASK);
login.c:  utype=u->type;
login.c:  prop=u->type->properties;
login.c:      if (allflag || prop->c==utype) {
login.c:        v=eval_copy(prop->a,STACK);
login.c:        w=eval_copy(prop->b,STACK);
login.c:        v->status=4;
login.c:        i_eval_args(v->attr_list);
login.c:      prop=prop->next;
login.c:  below both type1 and type2, the types of the two psi-terms whose
login.c:  if (!u->type->always_check) if (u->attr_list==NULL) return;
login.c:  push_ptr_value(int_ptr,(GENERIC *)&(u->status));
login.c:  u->status=4;
login.c:  prop=u->type->properties;
login.c:    checked1 = old1attr || old1->always_check;
login.c:    checked2 = old2attr || old2->always_check;
login.c:      /* In matches, mi is TRUE iff oldi <| prop->c.            */
login.c:      if (!checked1) m1=FALSE; else matches(old1,prop->c,&m1);
login.c:      if (!checked2) m2=FALSE; else matches(old2,prop->c,&m2);
login.c:	/* At this point, prop->c is an attribute that has not yet */
login.c:	v=eval_copy(prop->a,STACK);
login.c:	w=eval_copy(prop->b,STACK);
login.c:	v->status=4;
login.c:	i_eval_args(v->attr_list);
login.c:      prop=prop->next;
login.c:  U and V are the two psi-terms to unify.
login.c:  It swaps the two psi-terms into chronological order.
login.c:  u=(ptr_psi_term )aim->a;
login.c:  v=(ptr_psi_term )aim->b;
login.c:    /**** Swap the two psi-terms to get them into chronological order ****/
login.c:    u_func=(u->type->type==function);
login.c:    v_func=(v->type->type==function);
login.c:    old1stat=u->status; /* 18.2.94 */
login.c:    old2stat=v->status; /* 18.2.94 */
login.c:    /* if (u_func && !(u->flags&QUOTED_TRUE) && v->attr_list) { */
login.c:    if (u_func && u->status==4 && !(u->flags&QUOTED_TRUE) && v->attr_list) {
login.c:    /* if (v_func && !(v->flags&QUOTED_TRUE) && u->attr_list) { */
login.c:    if (v_func && v->status==4 && !(v->flags&QUOTED_TRUE) && u->attr_list) {
login.c:    success=(compare=glb(u->type,v->type,&new_type,&new_code));
login.c:      old1 = u->type;
login.c:      old2 = v->type;
login.c:      old1attr = u->attr_list;
login.c:      old2attr = v->attr_list;
login.c:	  new_type=(ptr_definition )d->value;
login.c:	  d=d->next;
login.c:	if (u->value && !v->value)
login.c:	  if (v->value && !u->value)
login.c:      /**** Determine the status of the resulting psi-term ****/
login.c:	if (u->status <4 && v->status <4)
login.c:	if (u->status<4)
login.c:	if (v->status<4)
login.c:	u->type->keyword->symbol,
login.c:	v->type->keyword->symbol,
login.c:	u->status,
login.c:	v->status,
login.c:      if (u->value && sub_type(new_type,integer)) {
login.c:	r= *(REAL *)u->value;
login.c:      if (success && v->value && sub_type(new_type,integer)) {
login.c:	r= *(REAL *)v->value;
login.c:        /* LAZY-EAGER */
login.c:	if (u->value!=v->value)
login.c:	  if (!u->value) {
login.c:	    push_ptr_value(int_ptr,&(u->value));
login.c:	    u->value=v->value;		
login.c:	  else if (v->value) {
login.c:              success=(*((REAL *)u->value)==(*((REAL *)v->value)));
login.c:              success=(lf_strcmp((char *)u->value,(char *)v->value)==0);
login.c:	      unsigned long ulen = *((unsigned long *)u->value);
login.c:	      unsigned long vlen = *((unsigned long *)v->value);
login.c:		       (bcmp((char *)u->value,(char *)v->value,ulen)==0));
login.c:            else if (u->type==cut && v->type==cut) { /* 22.9 */
login.c:              mincut = (u->value<v->value?u->value:v->value);
login.c:              if (mincut!=u->value) {
login.c:                push_ptr_value(cut_ptr,&(u->value));
login.c:                u->value=mincut;
login.c:              Warningline("'%s' may not be unified.\n",new_type->keyword->symbol);
login.c:      /**** Bind the two psi-terms ****/
login.c:	/* push_ptr_value(psi_term_ptr,&(v->coref)); 9.6 */
login.c:	push_psi_ptr_value(v,(GENERIC *)&(v->coref));
login.c:	v->coref=u;
login.c:	if (!equal_types(u->type,new_type)) {	      
login.c:	  push_ptr_value(def_ptr,(GENERIC *)&(u->type));
login.c:          /* push_def_ptr_value(u,(GENERIC *)&(u->type)); */ /* 14.8 */
login.c:	  u->type=new_type;
login.c:	if (u->status!=new_stat) {
login.c:	  push_ptr_value(int_ptr,(GENERIC *)&(u->status));
login.c:	  u->status=new_stat;
login.c:	arity_merge(u->attr_list,v->attr_list);
login.c:	if (u->attr_list || v->attr_list)
login.c:	  merge(&(u->attr_list),v->attr_list);
login.c:	  if (!(u->flags&QUOTED_TRUE | v->flags&QUOTED_TRUE)) {
login.c:            Traceline("re-evaluating curried expression %P\n", u);
login.c:	    if (u->status!=0) {
login.c:	      push_ptr_value(int_ptr,(GENERIC *)&(u->status));
login.c:	      u->status=0;
login.c:	if (v->flags&QUOTED_TRUE && !(u->flags&QUOTED_TRUE)) { /* 16.9 */
login.c:	  push_ptr_value(int_ptr,(GENERIC *)&(u->flags));
login.c:	  u->flags|=QUOTED_TRUE;
login.c:	if (u->resid)
login.c:	if (v->resid)
login.c:	     (u->type->type==type || v->type->type==type)) { 18.2.94 */
login.c:        if (new_stat<4 && u->type->type==type) {
login.c:          /* This does not check the already-checked properties     */
login.c:  sub-goals onto the goal_stack. Special cases are CUT and AND (","). Built-in
login.c:  thegoal=(ptr_psi_term )aim->a;
login.c:  rule=(ptr_pair_list )aim->b;
login.c:    if (thegoal->type!=and) {
login.c:      if (thegoal->type!=cut)
login.c:	if(thegoal->type!=life_or) {
login.c:	  /* User-defined predicates with unevaluated arguments */
login.c:	  /* Built-ins do this themselves (see built_ins.c). */
login.c:	  /* if (!thegoal->type->evaluate_args) mark_quote(thegoal); 24.8 25.8 */
login.c:	    goal_stack=aim->next;
login.c:	      rule=(ptr_pair_list)thegoal->type->rule;
login.c:	      if (thegoal->type->type==predicate) {	
login.c:	      else if ( thegoal->type->type==function
login.c:		      || ( thegoal->type->type==type
login.c:			 && sub_type(boolean,thegoal->type)
login.c:		if (thegoal->type->type==function && !rule)
login.c:		  bool_pred->type=boolpredsym;
login.c:		  bool_pred->attr_list=(a=STACK_ALLOC(node));
login.c:		  a->key=one;
login.c:		  a->left=a->right=NULL;
login.c:		  a->data=(GENERIC) thegoal;
login.c:   	      else if (!thegoal->type->protected && thegoal->type->type==undef) {
login.c:	      else if (thegoal->type==true || thegoal->type==false) {
login.c:		success=(thegoal->type==true);
login.c:		/* Call the call_handler (which may do an auto-load). */
login.c:		call_handler->type=call_handlersym;
login.c:		if (thegoal->type!=tracesym) /* 26.1 */
login.c:		  Traceline("prove built-in %P\n", thegoal);
login.c:		while (rule && (rule->a==NULL || rule->b==NULL)) {
login.c:		  rule=rule->next;
login.c:		    /* if (thegoal->type->evaluate_args) 8.9 */
login.c:		    head=eval_copy(rule->a,STACK);
login.c:		    head=quote_copy(rule->a,STACK);
login.c:		  body=eval_copy(rule->b,STACK);
login.c:		  /* if (body->type==built_in) */
login.c:		  /*   body->coref=head; */
login.c:		  if (rule->next)
login.c:		    push_choice_point(prove,thegoal,(ptr_psi_term)rule->next,NULL);
login.c:		  if (body->type!=succeed)
login.c:		  /* push_ptr_value(psi_term_ptr,(GENERIC *)&(head->coref)); 9.6 */
login.c:		  push_psi_ptr_value(head,(GENERIC *)&(head->coref));
login.c:		  head->coref=thegoal;
login.c:		  merge(&(thegoal->attr_list),head->attr_list);
login.c:		  if (!head->status) {
login.c:		    i_eval_args(head->attr_list);
login.c:	else { /* ';' built-in */
login.c:	  goal_stack=aim->next;
login.c:	  get_two_args(thegoal->attr_list,&arg1,&arg2);
login.c:      else { /* 'Cut' built-in*/
login.c:	goal_stack=aim->next;
login.c:	/* assert((ptr_choice_point)(thegoal->value)<=choice_stack); 12.7 */
login.c:	cut_to(thegoal->value); /* 12.7 */
login.c:    else { /* 'And' built-in */
login.c:      goal_stack=aim->next;
login.c:      get_two_args(thegoal->attr_list,&arg1,&arg2);
login.c:  t=(ptr_psi_term)aim->a;
login.c:  d=(ptr_int_list)aim->b;
login.c:  if (d->next) {
login.c:    push_choice_point(type_disj,t,(ptr_psi_term)d->next,NULL);
login.c:  push_ptr_value(def_ptr,(GENERIC *)&(t->type));
login.c:  /* push_def_ptr_value(t,(GENERIC *)&(t->type)); */ /* 14.8 */
login.c:  t->type=(ptr_definition)d->value;
login.c:  Traceline("setting type disjunction to %s.\n", t->type->keyword->symbol);
login.c:  if ((t->attr_list || t->type->always_check) && t->status<4)
login.c:  head=(ptr_psi_term)aim->a;
login.c:  body=(ptr_psi_term)aim->b;
login.c:  p=(ptr_pair_list *)aim->c;
login.c:    if ((*p)->next) {
login.c:	push_choice_point(del_clause,head,body,(GENERIC)&((*p)->next));
login.c:	push_choice_point(clause,head,body,(GENERIC)&((*p)->next));
login.c:    if ((*p)->a) {
login.c:      rule_head=quote_copy((*p)->a,STACK);
login.c:      rule_body=quote_copy((*p)->b,STACK);
login.c:      rule_head->status=4;
login.c:      rule_body->status=4;
login.c:      i_eval_args(rule_body->attr_list);
login.c:      i_eval_args(rule_head->attr_list);
login.c:      Traceline("fetching next clause for %s\n", head->type->keyword->symbol);
login.c:      Errorline("the built-in %P cannot be retracted.\n",head);
login.c:      Errorline("the definition of built-in %P is not accessible.\n",head);
login.c:  return (choice_stack==NULL) || (choice_stack->goal_stack->type==what_next);
login.c:    cp=cp->next;
login.c:  return (vt?(num_vars(vt->left)+1+num_vars(vt->right)):0);
login.c:      if (goal_stack->type==what_next) {
login.c:  while (cp && cp->goal_stack && cp->goal_stack->type!=what_next)
login.c:    cp=cp->next;
login.c:  if (cp && cp->goal_stack && cp->goal_stack->type==what_next)
login.c:  a) retry current goal -> ';'
login.c:  b) quit current goal -> RETURN
login.c:  c) add current goal -> 'new goal ?'
login.c:  d) return to top level -> '.'
login.c:  level=((unsigned long)aim->c);
login.c:  if (aim->a) {
login.c:    var_occurred=var_occurred || ((unsigned long)aim->b)&TRUEMASK; /* 18.8 */
login.c:    eventflag=(((unsigned long)aim->b)&(TRUEMASK*2))!=0;
login.c:      level--;
login.c:  Infoline(aim->a?"\n*** Yes":"\n*** No");
login.c:  if (aim->a || level>0) print_variables(NOTQUIET);
login.c:      strcpy(pr,current_module->module_name);
login.c:    if (aborthooksym->type != function )
login.c:	for(i=1;i<=lev;i++) { *pr='-'; pr++; *pr='-'; pr++; }
login.c:      if (s->type==eof) {
login.c:  Continue loading a file from the current psi-term up to the next query.
login.c:  input_state=(ptr_psi_term)aim->a;
login.c:  file_date=(unsigned long)aim->b;
login.c:  fn=(GENERIC)aim->c;
login.c:    /* Variables in queries in files are *completely independent* of top- */
login.c:    /* level variables.  I.e.: top-level variables are *not* recognized   */
login.c:    if (s->type==eof) {
login.c:      INPUT_FILE_NAME))->value,
login.c:      CURRENT_MODULE))->value);
login.c:    //   CURRENT_MODULE))->value));
login.c:    set_current_module(find_module(((ptr_psi_term)get_attr(input_state, CURRENT_MODULE))->value));
login.c:  This is the inference engine.  It distributes sub-goals to the appropriate
login.c:	  c=c->next;
login.c:    switch(aim->type) {
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      /* assert((ptr_choice_point)aim->a <= choice_stack); 12.7 */
login.c:      /* choice_stack=(ptr_choice_point)aim->a; */
login.c:      cut_to(aim->a); /* 12.7 */
login.c:      /* RESID */ restore_resid((ptr_resid_block)aim->c, &unused_match_date);
login.c:          Traceline("result of %P is %P\n", resid_aim->a, aim->a);
login.c:        goal_stack=aim->next;
login.c:        /* PVR 5.11 choice_stack=(ptr_choice_point)aim->b; */
login.c:        i_check_out(aim->a);
login.c:      /* assert((ptr_choice_point)aim->b<=choice_stack); 12.7 */
login.c:      /* PVR 5.11 */ /* choice_stack=(ptr_choice_point)aim->b; */
login.c:        cut_to(aim->b); /* 12.7 */
login.c:      /* RESID */ restore_resid((ptr_resid_block)aim->c, &unused_match_date);
login.c:        Warningline("frozen goal has a missing parameter '%P' and fails.\n",aim->a);
login.c:        if (resid_aim) Traceline("releasing frozen goal: %P\n", aim->a);
login.c:	/* PVR 5.12 choice_stack=(ptr_choice_point)aim->b; */
login.c:	goal_stack=aim->next;
login.c:        /* assert((ptr_choice_point)aim->b<=choice_stack); 12.7 */
login.c:        /* PVR 5.12 */ /* choice_stack=(ptr_choice_point)aim->b; */
login.c:        cut_to(aim->b); /* 12.7 */
login.c:      /* This 'cut' is actually more like a no-op! */
login.c:      restore_resid((ptr_resid_block)aim->c, &unused_match_date);
login.c:        Warningline("implied goal has a missing parameter '%P' and fails.\n",aim->a);
login.c:        if (resid_aim) Traceline("executing implied goal: %P\n", aim->a);
login.c:	goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      goal_stack=aim->next;
login.c:      p=(ptr_pair_list*)aim->a;
login.c:                (*p)->a,((*p)->a->type->type==function?"->":":-"),(*p)->b);
login.c:      (*p)->a=NULL;
login.c:      (*p)->b=NULL;
login.c:      (*p)=(*p)->next; /* Remove retracted element from pairlist */
login.c:      Errorline("bad goal on stack %d.\n",goal_stack->type);
login.c:      goal_stack=aim->next;
login.c:	if (xcount<=0 && aim->type==prove) {
login.c:	  xcount--;
login.c:      if (heap_pointer-stack_pointer < GC_THRESHOLD)
login.c:        stepcount--;
lub.c: * lub.c - find least upper bound of the root sorts of two psi terms
lub.c:		tail->next = STACK_ALLOC(int_list);
lub.c:		tail= tail->next;
lub.c:		tail->value = more->value;
lub.c:		tail->next = NULL;
lub.c:		more = more->next;
lub.c:  par=def->parents;
lub.c:    p=(ptr_definition)par->value;
lub.c:    len=bit_length(p->code);
lub.c:    par=par->next;
lub.c:	par = p->parents;
lub.c:	assert(par->value != NULL);
lub.c:	head->value = par->value;
lub.c:	head->next  = NULL;
lub.c:	par = par->next;
lub.c:/*		pc(head->value);*/
lub.c:		len = bit_length(((ptr_definition )head->value)->code);
lub.c:			if (!((ptr_definition )head->value == top) &&
lub.c:				!((ptr_definition )head->value == built_in) &&
lub.c:				(sub_CodeType(pattern,((ptr_definition)head->value)->code)))
lub.c:				or_codes(ans, ((ptr_definition)head->value)->code);
lub.c:				mark_ancestors((ptr_definition)head->value,flags);
lub.c:									 ((ptr_definition )head->value)->parents);
lub.c:		head = head->next;
lub.c:	ans->value = (GENERIC )x;
lub.c:	ans->next = NULL;
lub.c:	ta = a->type;
lub.c:	tb = b->type;
lub.c:	pattern = copyTypeCode(ta->code);
lub.c:	or_codes(pattern, tb->code);		/* pattern to search for */
lub.c:	/* initialize the table to be non-searched */
memory.c:#define ALIGNUP(X) { (X) = (GENERIC)( ((long) (X) + (ALIGN-1)) & ~(ALIGN-1) ); }
memory.c:    if(arg_v[i][0]=='-' && (int)strlen(arg_v[i])>=l+1)
memory.c:  for(c=choice_stack;c;c=c->next)
memory.c:    printf("\tc=%lx\ts=%lx\tg=%lx\tu=%lx\n",(long)c,(long)c->stack_top,(long)c->goal_stack,(long)c->undo_point);
memory.c:    if (u->a<mem_base || u->a>mem_limit ||
memory.c:        (GENERIC)u->next<mem_base || (GENERIC)u->next>mem_limit) {
memory.c:      printf("UNDO: type:%ld a:%lx b:%lx next:%lx\n",(long)u->type,(long)u->a,(long)u->b,(long)u->next);
memory.c:    u=u->next;
memory.c:       || (!VALID_ADDRESS(u->a) && !(u->type & undo_action))
memory.c:               (long)u,u->type,(long)u->a,(long)u->b,(long)u->next);
memory.c:    u=u->next;
memory.c:        else if (len & (ALIGN-1)) len=len-(len & (ALIGN-1))+ALIGN;
memory.c:        /* if (len & (ALIGN-1)) len=len-(len & (ALIGN-1))+ALIGN; 12.6 */
memory.c:        assert((len & (ALIGN-1))==0);
memory.c:    addr--;  /* PVR fix: adding this statement avoids accessing beyond */
memory.c:          if (len & (ALIGN-1)) len=len-(len & (ALIGN-1))+ALIGN;
memory.c:          assert((len & (ALIGN-1))==0);
memory.c:          if (len & (ALIGN-1)) len=len-(len & (ALIGN-1))+ALIGN;
memory.c:          assert((len & (ALIGN-1))==0);
memory.c:	    a--;
memory.c:	  addr--;
memory.c:	  new_addr--;
memory.c:      addr--;
memory.c:  If L=LONELY then that means that P is a pointer to a sub-field of a
memory.c:        value--;       /* Reset low bit */
memory.c:        value--;
memory.c:	value--;
memory.c:    c= &((*c)->next);
memory.c:    check_psi_term(&((*p)->a));
memory.c:    check_psi_term(&((*p)->b));
memory.c:    p= &((*p)->next);
memory.c:    check_psi_term(&((*p)->a));
memory.c:    check_psi_term(&((*p)->b));
memory.c:    check_definition(&((*p)->c));
memory.c:    p= &((*p)->next);
memory.c:    check_definition((struct wl_definition **)&((*c)->value));
memory.c:    c= &((*c)->next);
memory.c:    op = &((*op)->next);
memory.c:    check_module((struct wl_module **)&((*c)->value));
memory.c:    c= &((*c)->next);
memory.c:    check_module_tree(&((*n)->left));
memory.c:    check_string(&((*n)->key));
memory.c:    check_module((struct wl_module **)&((*n)->data));
memory.c:    check_module_tree(&((*n)->right));
memory.c:    check_string(&((*m)->module_name));
memory.c:    check_string(&((*m)->source_file));
memory.c:    check_module_list(&((*m)->open_modules));
memory.c:    check_module_list(&((*m)->inherited_modules));
memory.c:    check_hash_table((*m)->symbol_table);
memory.c:  for(i=0;i<table->size;i++)
memory.c:    if(table->data[i])
memory.c:      check_keyword(&(table->data[i]));
memory.c:    check_module((struct wl_module **)&((*k)->module));
memory.c:    check_string(&((*k)->symbol));
memory.c:    check_string(&((*k)->combined_name));
memory.c:    check_definition((struct wl_definition **)&((*k)->definition));
memory.c:    check_keyword(&((*d)->keyword)); /*  RM: Jan 12 1993  */
memory.c:    printf("%lx %20s %ld\n",(long)*d,(*d)->keyword->symbol,amount_used);
memory.c:    check_code(&((*d)->code));
memory.c:    check_pair_list(&((*d)->rule));
memory.c:    check_triple_list(&((*d)->properties));
memory.c:    if ((*d)->type==type) {
memory.c:      check_kids(&((*d)->parents));
memory.c:      check_kids(&((*d)->children));
memory.c:    check_psi_term(&((*d)->global_value)); /*  RM: Feb  9 1993  */
memory.c:    check_psi_term(&((*d)->init_value));   /*  RM: Mar 23 1993  */
memory.c:    check_operator_data(&((*d)->op_data)); /* PVR 5.6 */
memory.c:    check_block_def(&((*d)->block_def)); /*  RM: Jan 27 1993  */
memory.c:    d= &((*d)->next);
memory.c:    check_code(&((*d)->code));
memory.c:  /* p = &((*d)->properties); */
memory.c:    check_keyword(&((*d)->keyword)); /*  RM: Jan 12 1993  */
memory.c:    check_pair_list(&((*d)->rule));
memory.c:    check_triple_list(&((*d)->properties));
memory.c:    if ((*d)->type==type) {
memory.c:      check_kids(&((*d)->parents));
memory.c:      check_kids(&((*d)->children));
memory.c:    check_operator_data(&((*d)->op_data)); /* PVR 5.6 */
memory.c:    check_block_def(&((*d)->block_def));  /*CB 25/01/93 */
memory.c:    check_symbol(&((*n)->left));
memory.c:    check_string(&((*n)->key));
memory.c:    check_keyword((struct wl_keyword **)&((*n)->data));   /*  RM: Jan 12 1993  */
memory.c:    check_symbol(&((*n)->right));
memory.c:    check_definition((struct wl_definition **)&((*p)->value));
memory.c:    p= &((*p)->next);
memory.c:    switch ((*g)->type) {
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_psi_term(&((*g)->b));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      if ((unsigned long)(*g)->b!=DEFRULES) check_pair_list(&((*g)->b));
memory.c:      check_pair_list(&((*g)->c));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_psi_term(&((*g)->b));
memory.c:      /* check_choice(&((*g)->b)); */
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_psi_term(&((*g)->b));
memory.c:      check_pair_list(&((*g)->c));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_string(&((*g)->c));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_psi_term(&((*g)->b));
memory.c:      check_resid_block((struct wl_resid_block **)&((*g)->c));
memory.c:      /* assert((GENERIC)(*g)->a <= (GENERIC)choice_stack); 12.7 17.7 */
memory.c:      if (pass==1 && (ptr_choice_point)(*g)->a>choice_stack)
memory.c:        (*g)->a=(ptr_psi_term)choice_stack;
memory.c:      unchecked(&((*g)->a),LONELY,17);
memory.c:      check_psi_term(&((*g)->a));
memory.c:      /* assert((GENERIC)(*g)->b <= (GENERIC)choice_stack); 12.7 17.7 */
memory.c:      if (pass==1 && (ptr_choice_point)(*g)->b>choice_stack)
memory.c:        (*g)->b=(ptr_psi_term)choice_stack;
memory.c:      unchecked(&((*g)->b),LONELY,18);
memory.c:      check_resid_block((struct wl_resid_block **)&((*g)->c));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      /* assert((GENERIC)(*g)->b <= (GENERIC)choice_stack); 12.7 17.7 */
memory.c:      if (pass==1 && (ptr_choice_point)(*g)->b>choice_stack)
memory.c:        (*g)->b=(ptr_psi_term)choice_stack;
memory.c:      unchecked(&((*g)->b),LONELY,19);
memory.c:      check_resid_block((struct wl_resid_block **)&((*g)->c));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_type_disj(&((*g)->b));
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_psi_term(&((*g)->b));
memory.c:      unchecked(&((*g)->c),LONELY,20);
memory.c:      /* check_pair_list((*g)->c); */ /* 6.8 */
memory.c:      check_psi_term(&((*g)->a));
memory.c:      check_psi_term(&((*g)->b));
memory.c:      unchecked(&((*g)->c),LONELY,21);
memory.c:      /* check_pair_list((*g)->c); */ /* 6.8 */
memory.c:      unchecked(&((*g)->a),LONELY,22);
memory.c:      /* check_pair_list((*g)->a); */ /* 6.8 */
memory.c:      /*PVR*/ /* check_choice(&((*g)->b)); 9.6 */
memory.c:    g= &((*g)->next);
memory.c:    if ((*r)->sortflag) /* 22.9 */
memory.c:      check_definition((struct wl_definition **)&((*r)->bestsort));
memory.c:      check_code(&((*r)->bestsort)); /* 21.9 */
memory.c:    code = (*r)->sortflag ? ((ptr_definition)((*r)->bestsort))->code
memory.c:			  : (ptr_int_list)(*r)->bestsort;
memory.c:    if ((*r)->value) {
memory.c:      if (code==alist->code) { /*  RM: Dec 15 1992  Will be removed */
memory.c:  	l=(ptr_list *) &((*r)->value);
memory.c:      else if (sub_CodeType(code,real->code))
memory.c:        unchecked(&((*r)->value),sizeof(REAL),24);
memory.c:      else if (sub_CodeType(code,quoted_string->code))
memory.c:        check_string(&((*r)->value));
memory.c:      else if (sub_CodeType(code,sys_bytedata->code))
memory.c:	check_bytedata(&((*r)->value),1);
memory.c:      else if (sub_CodeType(code,cut->code)) {
memory.c:        if (pass==1 && (*r)->value>(GENERIC)choice_stack)
memory.c:          (*r)->value=(GENERIC)choice_stack;
memory.c:        unchecked(&((*r)->value),LONELY,25);
memory.c:      else if (sub_CodeType(code,variable->code)) /* 8.8 */
memory.c:	check_string(&((*r)->value));
memory.c:    check_goal_stack(&((*r)->goal));
memory.c:    r= &((*r)->next);
memory.c:      check_goal_stack(&((*rb)->ra));
memory.c:      check_resid_list(&((*rb)->rv)); /* 21.9 */
memory.c:      /* unchecked(&((*rb)->rl),LONELY,27); 12.6 */  /* 10.6 */
memory.c:      unchecked(&((*rb)->md),LONELY,28); /* 10.6 */
memory.c:      /* check_goal_stack(&((*rb)->rl)); 10.6 */
memory.c:      /* check_psi_term(&((*rb)->md)); 10.6 */
memory.c:    /* A psi-term on the heap has no residuation list. */
memory.c:      assert((*t)->resid==NULL);
memory.c:    check_definition((struct wl_definition **)&((*t)->type));
memory.c:    check_attr(&((*t)->attr_list));
memory.c:    if ((*t)->value) {
memory.c:      if ((*t)->type==alist) { /*  RM: Dec 15 1992  Should be removed  */
memory.c:  	l=(ptr_list *) &((*t)->value);
memory.c:	if (sub_type((*t)->type,real))
memory.c:	  unchecked(&((*t)->value),sizeof(REAL),30);
memory.c:	else if (sub_type((*t)->type,quoted_string))
memory.c:	  check_string(&((*t)->value));
memory.c:	else if (sub_type((*t)->type,sys_bytedata)) {
memory.c:	  if (((unsigned long) * ((*t)->value)) > 100000) { // Practical test DJD
memory.c:	    //	  fprintf(stderr,"pre 2 check_bytedata DJD %lx val %lx %lx %ld\n",(unsigned long)&((*t)->value),(unsigned long)((*t)->value),(unsigned long)* ((*t)->value),  (unsigned long) * (GENERIC *) * ((*t)->value)) ;
memory.c:	  check_bytedata((unsigned long) * ((*t)->value),2);
memory.c:	    //	  fprintf(stderr,"pre check_bytedata DJD %lx val %lx %lx %lx\n",(unsigned long)&((*t)->value),(unsigned long)((*t)->value),(unsigned long)* ((*t)->value),  (unsigned long) * ((*t)->value)) ;
memory.c:	  check_bytedata(((*t)->value),2);
memory.c:	else if ((*t)->type->type==block) {  /*  RM: Jan 27 1993  */
memory.c:	  check_block_value(&((*t)->value));
memory.c:	else if ((*t)->type==cut) { /*  RM: Oct 28 1993  */
memory.c:	  /* assert((*t)->value <= (GENERIC)choice_stack); 12.7 17.7 */
memory.c:	  if (pass==1 && (*t)->value>(GENERIC)choice_stack)
memory.c:	    (*t)->value=(GENERIC)choice_stack;
memory.c:	  unchecked(&((*t)->value),LONELY,31);
memory.c:	else if (sub_type((*t)->type,variable)) /* 8.8 */
memory.c:	  check_string(&((*t)->value));
memory.c:	else if (((*t)->type!=stream) && (strcmp((*t)->type->keyword->combined_name,"sys#file_stream") != 0) && (strcmp((*t)->type->keyword->combined_name,"sys#stream") != 0) && (strcmp((*t)->type->keyword->combined_name,"built_ins#stream") != 0)   )
memory.c:	  Errorline("non-NULL value field in garbage collector, type='%s', value=%d.\n",
memory.c:		    (*t)->type->keyword->combined_name,
memory.c:		    (*t)->value);
memory.c:    /* check_psi_term(&((*t)->coref)); 9.6 */
memory.c:    if ((*t)->resid)
memory.c:      check_resid(&((*t)->resid));
memory.c:    t = &((*t)->coref);
memory.c:/******** CHECK_ATTR(attribute-tree)
memory.c:    check_attr(&((*n)->left));
memory.c:    check_string(&((*n)->key));
memory.c:    check_psi_term((struct wl_psi_term **)&((*n)->data));
memory.c:    n = &((*n)->right);
memory.c:    /* check_attr(&((*n)->right)); 9.6 */
memory.c:    switch((*s)->type) {
memory.c:      check_psi_term((struct wl_psi_term **)&((*s)->b));
memory.c:      check_resid(&((*s)->b));
memory.c:      check_definition((struct wl_definition **)&((*s)->b));
memory.c:      check_code(&((*s)->b));
memory.c:      check_goal_stack(&((*s)->b));
memory.c:      check_block_value(&((*s)->b));
memory.c:    s= &((*s)->next);
memory.c:    c= &((*c)->next);
memory.c:    check_undo_stack(&((*c)->undo_point)); /* 17.7 */
memory.c:    check_goal_stack(&((*c)->goal_stack));
memory.c:    c= &((*c)->next);
memory.c:    /* unchecked(&(c->undo_point),LONELY,36); 17.7 */
memory.c:    unchecked(&(c->stack_top),LONELY,37);
memory.c:    c=c->next;
memory.c:    if (!(p->type & undo_action)) {
memory.c:      if (VALID_RANGE(p->a)) unchecked(&(p->a),LONELY,38);
memory.c:      if (p->type==cut_ptr) unchecked(&(p->b),LONELY,39); /* 22.9 */
memory.c:    p=p->next;
memory.c:    check_psi_term((struct wl_psi_term **)&((*l)->value));
memory.c:    l= &((*l)->next);
memory.c:    check_psi_term((struct wl_psi_term **)&((*l)->var));
memory.c:    check_psi_term((struct wl_psi_term **)&((*l)->othervar));
memory.c:    l= &((*l)->next);
memory.c:    check_var(&((*n)->left));
memory.c:    check_string(&((*n)->key));
memory.c:    check_psi_term((struct wl_psi_term **)&((*n)->data));
memory.c:    check_var(&((*n)->right));
memory.c:  /* First of all, get all the codes right so that data type-checking remains
memory.c:     Kids and Parents cannot be checked because the built-in types have codes
memory.c:  // fprintf(stderr,"- Done CHECKDJD 23\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000002\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000003\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000004\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000005\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000006\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000007\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000008\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000009\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000010\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000011\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000012\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000013\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000014\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000015\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000016\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000017\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000018\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000019\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 0000020\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 24\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 25\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 26\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 27\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 28\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 29\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 30\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 31\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 32\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 33\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 34\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 35\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 36\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 37\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 38\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 39\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 40\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 41\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 42\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 43\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 44\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 45\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 46\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 47\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 48\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 49\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 50\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 51\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 52\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 53\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 54\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 55\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 56\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 57\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 58\n"); 
memory.c:  // fprintf(stderr,"- Done CHECKDJD 59\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 60\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 61\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 62\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 63\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 64\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 65\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 66\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 67\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 68\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 69\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 70\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 71\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 72\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 73\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 74\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 75\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 76\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 77\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 78\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 79\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 80\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 81\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 82\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 83\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 84\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 85\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 86\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 87\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 88\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 89\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 90\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 91\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 92\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 93\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 94\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 95\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 96\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 97\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 98\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 99\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 100\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 101\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 102\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 103\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 104\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 105\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 106\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 107\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 108\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 109\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 110\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 111\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 112\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 113\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 114\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 115\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 116\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 117\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 118\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 119\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 120\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 121\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 122\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 123\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 124\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 125\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 126\n");
memory.c:  // fprintf(stderr,"- Done CHECKDJD 127\n");
memory.c:          (100*((unsigned long)heap_pointer-(unsigned long)stack_pointer)+mem_size/2)/mem_size,
memory.c:          ((unsigned long)heap_pointer-(unsigned long)stack_pointer+512)/1024,
memory.c:          (100*((unsigned long)mem_limit-(unsigned long)heap_pointer)+mem_size/2)/mem_size,
memory.c:          (100*((unsigned long)stack_pointer-(unsigned long)mem_base)+mem_size/2)/mem_size);
memory.c:  This is a half-space GC, it first explores all known structures, then
memory.c:  start_number_cells = (stack_pointer-mem_base) + (mem_limit-heap_pointer);
memory.c:  life_time=(garbage_start_time.tms_utime - last_garbage_time.tms_utime)/60.0;
memory.c:  fprintf(stderr,"- Done pass 1 ");
memory.c:  fprintf(stderr,"- Done compress ");
memory.c:  //  fprintf(stderr,"- Done check AA\n");
memory.c:  // fprintf(stderr,"- Done assert AA\n");
memory.c:  fprintf(stderr,"- Done pass 2\n");
memory.c:  gc_time=(garbage_end_time.tms_utime - garbage_start_time.tms_utime)/60.0;
memory.c:  end_number_cells = (stack_pointer-mem_base) + (mem_limit-heap_pointer);
memory.c:    if (s & (ALIGN-1))
memory.c:      s = s - (s & (ALIGN-1))+ALIGN;
memory.c:    heap_pointer -= s;
memory.c:    if (s & (ALIGN-1))
memory.c:      s = s - (s & (ALIGN-1)) + ALIGN;
memory.c:  The second is only used for the half-space garbage collector.
memory.c:  The start and end addresses of the blocks are re-aligned correctly.
memory.c:    mem_limit=mem_base+alloc_words-2;
memory.c:    other_limit=other_base+alloc_words-2;
memory.c:    delta = other_base - mem_base;
memory.c:	mem_base[i]= -1234;
memory.c:	other_base[i]= -1234;
memory.c:  if (heap_pointer-stack_pointer < GC_THRESHOLD) {
memory.c:    if (heap_pointer-stack_pointer < GC_THRESHOLD+GC_THRESHOLD/10) {
modules.c:    return (ptr_module)(nodule->data);
modules.c:    new->module_name=(char *)heap_copy_string((GENERIC)module);
modules.c:    new->source_file=(char *)heap_copy_string((GENERIC)input_file_name);
modules.c:    new->open_modules=NULL;
modules.c:    new->inherited_modules=NULL;
modules.c:    new->symbol_table=hash_create(16); /*  RM: Feb  3 1993  */
modules.c:    heap_insert(STRINGCMP,(GENERIC)new->module_name,&module_table,(GENERIC)new);
modules.c:  /* printf("*** Current module: '%s'\n",current_module->module_name); */
modules.c:    printf("Extracted module name '%s' from '%s'\n",result->module_name,str);
modules.c:  Return the sub-string of symbol without the module prefix.
modules.c:  if(term->value && term->type==quoted_string)
modules.c:    return (char *)term->value;
modules.c:    return term->type->keyword->symbol;
modules.c:      strcpy(module_buffer,module->module_name);
modules.c:  /* printf("*** New definition: %s\n",key->combined_name); */
modules.c:  result->next=first_definition; /* Linked list of all definitions */
modules.c:  result->keyword=key;
modules.c:  result->rule=NULL;
modules.c:  result->properties=NULL;
modules.c:  result->date=0;
modules.c:  result->type=undef;
modules.c:  result->always_check=TRUE;
modules.c:  result->protected=TRUE;
modules.c:  result->evaluate_args=TRUE;
modules.c:  result->already_loaded=FALSE;
modules.c:  result->children=NULL;
modules.c:  result->parents=NULL;
modules.c:  result->code=NOT_CODED;
modules.c:  result->op_data=NULL;
modules.c:  result->global_value=NULL; /*  RM: Feb  8 1993  */
modules.c:  result->init_value=NULL;   /*  RM: Mar 23 1993  */
modules.c:  key->definition=result;
modules.c:  /* printf("looking up %s#%s\n",module->module_name,symbol); */
modules.c:  key=hash_lookup(module->symbol_table,symbol);
modules.c:    if(key->public || module==current_module)
modules.c:      result=key->definition;
modules.c:		key->combined_name);
modules.c:      result=error_psi_term->type;
modules.c:		module->module_name,symbol);
modules.c:      result=error_psi_term->type;
modules.c:	key->module=module;
modules.c:	key->symbol=(char *)heap_copy_string((GENERIC)symbol);
modules.c:	key->combined_name=(char *)heap_copy_string((GENERIC)make_module_token(module,symbol));
modules.c:	key->public=FALSE;
modules.c:	key->private_feature=FALSE; /*  RM: Mar 11 1993  */
modules.c:	key->definition=NULL;
modules.c:	hash_insert(module->symbol_table,key->symbol,key);
modules.c:	opens=module->open_modules;
modules.c:	  opened=(ptr_module)(opens->value);
modules.c:	    tempkey=hash_lookup(opened->symbol_table,symbol);
modules.c:	      if(openkey && openkey->public && tempkey->public) {
modules.c:		if(openkey->definition==tempkey->definition) {
modules.c:			      openkey->combined_name,
modules.c:			      tempkey->combined_name);
modules.c:			    openkey->combined_name,
modules.c:			    tempkey->combined_name);
modules.c:		  result=error_psi_term->type;
modules.c:		if(!openkey || !openkey->public)
modules.c:	  opens=opens->next;
modules.c:	  if(openkey && openkey->public) {
modules.c:	    if(!openkey->public)
modules.c:	      Warningline("implicit reference to non-public symbol: %s\n",
modules.c:			  openkey->combined_name);
modules.c:	    result=openkey->definition;
modules.c:	    key->definition=result;
modules.c:	      key->module->module_name,
modules.c:	      key->symbol,
modules.c:	      openkey->module->module_name,
modules.c:	      openkey->symbol);
modules.c:  Return the value of a function without arguments. This returns a psi-term on
modules.c:  def=(ptr_definition)n->data;
modules.c:  if(def && def->type==function) {
modules.c:  rule=def->rule;
modules.c:  while (rule && (!rule->a || !rule->b))
modules.c:  rule=rule->next;
modules.c:  result=(ptr_psi_term)rule->b;
modules.c:  k=k->definition->keyword;
modules.c:    return k->combined_name;
modules.c:    return k->symbol;
modules.c:  k=k->definition->keyword;
modules.c:    prettyf(k->module->module_name);
modules.c:  prettyf(k->symbol);
modules.c:  k=k->definition->keyword;
modules.c:    prettyf(k->module->module_name);
modules.c:  prettyf_quote(k->symbol);
modules.c:  This routine retrieves the necessary psi-term to determine the current
modules.c:  call=aim->a;
modules.c:  get_two_args(call->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:  call=aim->a;
modules.c:  if (call->attr_list) {
modules.c:    open_module_tree(call->attr_list, &onefailed);
modules.c:    open_module_tree(n->left,onefailed);
modules.c:    t=(ptr_psi_term)n->data;
modules.c:    open_module_tree(n->right,onefailed);
modules.c:    for (opens=current_module->open_modules;opens;opens=opens->next)
modules.c:	if (opens->value==(GENERIC)open_module) {
modules.c:	     open_module->module_name); */ /*  RM: Jan 27 1993  */
modules.c:	opens->value=(GENERIC)open_module;
modules.c:	opens->next=current_module->open_modules;
modules.c:	current_module->open_modules=opens;
modules.c:	for (i=0;i<open_module->symbol_table->size;i++)
modules.c:	  if ((key1=open_module->symbol_table->data[i]) && key1->public) {
modules.c:	    key2=hash_lookup(current_module->symbol_table,key1->symbol);
modules.c:	    if (key2 && key1->definition!=key2->definition)
modules.c:			key1->combined_name,
modules.c:			key2->combined_name);
modules.c:  key=hash_lookup(current_module->symbol_table,term->type->keyword->symbol);
modules.c:    if(key->definition->keyword->module!=current_module && !bool) {
modules.c:	       key->definition->keyword->symbol,
modules.c:	       key->definition->keyword->combined_name);
modules.c:    key->public=bool;
modules.c:    def=update_symbol(current_module,term->type->keyword->symbol);
modules.c:    def->keyword->public=bool;
modules.c:/* Do for all arguments, for the built-ins
modules.c:    traverse_tree(n->left,flag);
modules.c:    t=(ptr_psi_term)n->data;
modules.c:    traverse_tree(n->right,flag);
modules.c:  call=aim->a;
modules.c:  if (call->attr_list) {
modules.c:    traverse_tree(call->attr_list,MAKE_PUBLIC);
modules.c:  call=aim->a;
modules.c:  if (call->attr_list) {
modules.c:    traverse_tree(call->attr_list,MAKE_PRIVATE);
modules.c:  call=aim->a;
modules.c:  get_two_args(call->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:    if(arg1->type==true)
modules.c:      if(arg1->type==false)
modules.c:  call=aim->a;
modules.c:  get_two_args(call->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:    if(arg1->type==true)
modules.c:      if(arg1->type==false)
modules.c:  call=aim->a;
modules.c:  get_two_args(call->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:    if(arg1->type==true)
modules.c:      if(arg1->type==false)
modules.c:  long *info;  // some trouble w this - don't see
modules.c:    if(term->type==old && !term->value) {
modules.c:      push_ptr_value(def_ptr,(GENERIC *)&(term->type));
modules.c:      term->type=new;
modules.c:    old_attr=term->attr_list;
modules.c:      push_ptr_value(int_ptr,(GENERIC *)&(term->attr_list));
modules.c:      term->attr_list=NULL;
modules.c:  if(old_attr->left)
modules.c:    replace_attr(old_attr->left,term,old,new);
modules.c:  value=(ptr_psi_term)old_attr->data;
modules.c:  if(old->keyword->private_feature)  /*  RM: Mar 12 1993  */
modules.c:    oldlabel=old->keyword->combined_name;
modules.c:    oldlabel=old->keyword->symbol;
modules.c:  if(new->keyword->private_feature)  /*  RM: Mar 12 1993  */
modules.c:    newlabel=new->keyword->combined_name;
modules.c:    newlabel=new->keyword->symbol;
modules.c:  if(!lf_strcmp(old_attr->key,oldlabel))
modules.c:    stack_insert(FEATURECMP,(GENERIC)newlabel,&(term->attr_list),(GENERIC)value);
modules.c:    stack_insert(FEATURECMP,(GENERIC)old_attr->key,&(term->attr_list),(GENERIC)value);
modules.c:  if(old_attr->right)
modules.c:    replace_attr(old_attr->right,term,old,new);
modules.c:  call=aim->a;
modules.c:  get_two_args(call->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:  n=find(FEATURECMP,three,call->attr_list);
modules.c:    arg3=(ptr_psi_term)n->data;
modules.c:    replace(arg1->type,arg2->type,arg3);
modules.c:  g=aim->a;
modules.c:  result=aim->b;
modules.c:  other->type=quoted_string;
modules.c:  other->value=(GENERIC)heap_copy_string((GENERIC)current_module->module_name);
modules.c:    current_module->module_name)
modules.c:    ->keyword->symbol
modules.c:  /* other->type=update_symbol(current_module,current_module->module_name); */
modules.c:  Return the psi-term Module#Symbol
modules.c:  call=aim->a;
modules.c:    result=aim->b;
modules.c:    other->type=update_symbol(module_access,module_access->module_name);
modules.c:  Unify two psi-terms, where it is known that V is on the heap (a persistent
modules.c:     u->type->keyword->symbol,
modules.c:     v->type->keyword->symbol); */
modules.c:  compare=glb(u->type,v->type,&new_type,&new_code);
modules.c:    if(v->value) {
modules.c:      if(u->value) {
modules.c:	if(u->value!=v->value) { /* One never knows */
modules.c:	  if (overlap_type(v->type,real))
modules.c:	    success=(*((REAL *)u->value)==(*((REAL *)v->value)));
modules.c:	  else if (overlap_type(v->type,quoted_string))
modules.c:	    success=(lf_strcmp((char *)u->value,(char *)v->value)==0);
modules.c:      if(u->value)
modules.c:      /**** Bind the two psi-terms ****/
modules.c:      push_psi_ptr_value(u,(GENERIC *)&(u->coref));
modules.c:      u->coref=v;
modules.c:      success=global_unify_attr(u->attr_list,v->attr_list);
modules.c:      if(success && u->resid)
modules.c:      dummy_printf("%s %s\n",u->key,v->key);
modules.c:      cmp=featcmp(u->key,v->key,FEATURECMP);
modules.c:	temp=u->right;
modules.c:	u->right=NULL;
modules.c:	success=global_unify_attr(u,v->left) && global_unify_attr(temp,v);
modules.c:	u->right=temp;
modules.c:	  temp=u->left;
modules.c:	  u->left=NULL;
modules.c:	  success=global_unify_attr(u,v->right) && global_unify_attr(temp,v);
modules.c:	  u->left=temp;
modules.c:	    global_unify_attr(u->left,v->left) &&
modules.c:	      global_unify_attr(u->right,v->right) &&
modules.c:		global_unify(u->data,v->data);
modules.c:  g=aim->a;
modules.c:  get_two_args(g->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:    key=hash_lookup(current_module->symbol_table,arg1->type->keyword->symbol);
modules.c:      if(key->definition!=arg2->type) {
modules.c:		 key->combined_name,
modules.c:		 arg2->type->keyword->combined_name);
modules.c:	key->definition=arg2->type;
modules.c:		key->combined_name,
modules.c:		current_module->module_name);
modules.c:  Convert a psi-term to a module. The psi-term must be a string.
modules.c:  if(overlap_type(psi->type,quoted_string) && psi->value)
modules.c:    s=(char *)psi->value;
modules.c:    s=psi->type->keyword->symbol;
modules.c:  key=hash_lookup(current_module->symbol_table,term->type->keyword->symbol);
modules.c:      if(key->definition->keyword->module!=current_module) {
modules.c:      key->definition->keyword->symbol,
modules.c:      key->definition->keyword->combined_name);
modules.c:    key->private_feature=TRUE;
modules.c:    def=key->definition;
modules.c:    def=update_symbol(current_module,term->type->keyword->symbol);
modules.c:    def->keyword->private_feature=TRUE;
modules.c:  if(ok && def->keyword->public) {
modules.c:		def->keyword->combined_name);
modules.c:  call=aim->a;
modules.c:  if (call->attr_list) {
modules.c:    traverse_tree(call->attr_list,MAKE_FEATURE_PRIVATE);
modules.c:  key=hash_lookup(module->symbol_table,feature);
modules.c:  if(key && key->private_feature)
modules.c:    return key->definition;
modules.c:  funct=aim->a;
modules.c:  result=aim->b;
modules.c:  get_two_args(funct->attr_list,(ptr_psi_term *)&arg1,(ptr_psi_term *)&arg2);
modules.c:  for(d=first_definition;d;d=d->next)
modules.c:    if(d->keyword->public && (!module || d->keyword->module==module)) {
modules.c:      car->type=d;
parser.c:  if(t->type==final_dot || t->type==final_question) /*  RM: Jul  9 1993  */
parser.c:  s=t->type->keyword->symbol;
parser.c:      printf("-> ");
parser.c:    parser_stack_index--;
parser.c:  o=tok.type->op_data;
parser.c:    if(typ==o->type)
parser.c:      r=o->precedence;
parser.c:      o=o->next;
parser.c:  p->time_stamp=global_time_stamp; /* 9.6 */
parser.c:  p->time_stamp=global_time_stamp; /* 9.6 */
parser.c:  structure, but instead creates a generic psi-term with 2 features. The list
parser.c:	[a,b,c|d] -> cons(a,cons(b,cons(c,d))).
parser.c:	[] -> nil
parser.c:	{a;b;c} -> disj(a,disj(b,disj(c,{}))).
parser.c:	{} -> {} = *bottom*
parser.c:  stream, that is, a whole psi-term.
parser.c:	      if(t2.type->keyword->private_feature) /*  RM: Mar 11 1993  */
parser.c:		feature_insert(t2.type->keyword->combined_name,
parser.c:		feature_insert(t2.type->keyword->symbol,
parser.c:    stack_insert(FEATURECMP,(GENERIC)functor->keyword->symbol,
parser.c:    module->type=quoted_string;
parser.c:    module->value=(GENERIC)heap_copy_string((GENERIC)current_module->module_name);
parser.c:  tok->attr_list=NULL;
parser.c:  tok->resid=NULL;
parser.c:     POINTERS to psi-terms instead of PSI_TERMS !!!
parser.c:      if (a1->type==top && 
parser.c:	 !a1->attr_list &&
parser.c:	 !a1->resid) {
parser.c:	  /* push_ptr_value(psi_term_ptr,&(a1->coref)); 9.6 */
parser.c:	  push_psi_ptr_value(a1,(GENERIC *)&(a1->coref));
parser.c:	a1->coref=stack_copy_psi_term(*arg2);
parser.c:	if(a2->type==top && 
parser.c:	   !a2->attr_list &&
parser.c:	   !a2->resid) {
parser.c:	    /* push_ptr_value(psi_term_ptr,&(a2->coref)); 9.6 */
parser.c:	    push_psi_ptr_value(a2,(GENERIC *)&(a2->coref));
parser.c:	  a2->coref=stack_copy_psi_term(*arg1);
parser.c:    if(tok->type==minus_symbol &&
parser.c:       a1->value &&
parser.c:       (a1->type==integer || a1->type==real))  {
parser.c:      tok->type=a1->type;
parser.c:      tok->value=(GENERIC)heap_alloc(sizeof(REAL));
parser.c:      *(REAL *)tok->value = - *(REAL *)a1->value;
parser.c:    stack_insert(FEATURECMP,(GENERIC)one,&(tok->attr_list),(GENERIC)stack_copy_psi_term(*arg1));
parser.c:      stack_insert(FEATURECMP,(GENERIC)two,&(tok->attr_list),(GENERIC)stack_copy_psi_term(*arg2));
parser.c:  is <= PREC, and replace it with the corresponding psi-term. Do not go any
parser.c:  This reads in one life-form from the input stream which finishes with
parser.c:  [A,4*5,b-4!] then STR1="," and STR2="|" . It would be incorrect if "," were
parser.c:	    pr_1=pr_op-1;
parser.c:	      pr_1=pr_op-1;
parser.c:	      pr_2=pr_op-1;
parser.c:		pr_1=pr_op-1;
parser.c:		pr_2=pr_op-1;
parser.c:		pr_2=pr_op-1;
parser.c:	    pr_2=pr_op-1;
parser.c:  parser_stack_index=limit-1;
parser.c:  It also indicates the type psi-term read, that is whether it was a clause
parser.c:  /* Mark all the psi-terms corresponding to variables in the var_tree as    */
print.c:#define COMMA_PREC ((commasym->op_data)?(commasym->op_data->precedence):0)
print.c:#define COLON_PREC ((colonsym->op_data)?(colonsym->op_data->precedence):0)
print.c:/* Generate a nice-looking new variable name. */
print.c:    g--;
print.c:    perr("Variable name too long -- the universe has ceased to exist.");
print.c:  Returns -1 if s is not an integer.
print.c:    v= -1;
print.c:      v=v*10+(c-'0');
print.c:    if (c!=0) v= -1;
print.c:  Print the integer B under binary format (currently 26 is printed **-*-).
print.c:  for (p=INT_SIZE;p--;p>0) 
print.c:      print_bin(c->value);
print.c:      c=c->next;
print.c:  psi-term being printed. If it is more than once then a tag will have to
print.c:      n->data=(GENERIC)no_name;
print.c:    if (t->left) {
print.c:      go_through_tree(t->left);
print.c:    check_pointer((ptr_psi_term)t->data);
print.c:    if (t->right) {
print.c:      go_through_tree(t->right);
print.c:  if (t->attr_list)
print.c:    go_through_tree(t->attr_list);
print.c:  if(r=t->resid)
print.c:      if(r->goal->pending)
print.c:	go_through(r->goal->a);
print.c:      r=r->next;
print.c:    insert_variables(vars->right,force);
print.c:    p=(ptr_psi_term )vars->data;
print.c:      if (n->data || force)
print.c:	n->data=(GENERIC)vars->key;
print.c:    insert_variables(vars->left,force);
print.c:  NAME:value inside a psi-term.
print.c:    forbid_variables(n->right);
print.c:    v=(ptr_psi_term )n->data;
print.c:    heap_insert(INTEGERCMP,(GENERIC)n1,&printed_pointers,(GENERIC)n->key);
print.c:    forbid_variables(n->left);
print.c:  possibly cyclic psi-terms with coreferences from one to another.
print.c:/* Return TRUE iff s starts with a non-lowercase character. */
print.c:  if (*s=='-') s++;
print.c:    (2) S contains a non-alphanumeric character
print.c:        or starts with a non-lowercase character, and
print.c:        non-SINGLE SYMBOL characters (in that case, S does not need quotes),and
print.c:    indx->str=(char *)heap_alloc(strlen(buffer)+1);
print.c:    strcpy(indx->str,buffer);
print.c:  indx->tab=t;
print.c:  (*t)->broken=FALSE;
print.c:  (*t)->printed=FALSE;
print.c:  (*t)->column=0;
print.c:    w= -1;
print.c:      if(i->tab->broken && i->tab->printed) {
print.c:	pos=i->tab->column;
print.c:      if(!i->tab->printed) i->tab->column=pos;
print.c:      if(!(i->tab->broken))
print.c:	if(!root || (root && (root->column)>=(i->tab->column)))
print.c:	  root=i->tab;
print.c:      /* pos=pos+strlen(i->str); */
print.c:      pos=strpos(pos,i->str);
print.c:      i->tab->printed=TRUE;
print.c:      i->tab->printed=FALSE;
print.c:	worst->broken=TRUE;
print.c:    if(t->left)
print.c:      c+=count_features(t->left);
print.c:    if(t->right)
print.c:      c+=count_features(t->right);
print.c:  return (t->type==t_type &&
print.c:	  count_features(t->attr_list)==2 &&
print.c:	  find(FEATURECMP,one,t->attr_list) &&
print.c:	  find(FEATURECMP,two,t->attr_list));
print.c:  t_type=t->type;
print.c:      pretty_symbol(t_type->keyword);  /*  RM: Jan 13 1993  */
print.c:    get_two_args(t->attr_list,&car,&cdr);
print.c:    if(n && n->data) {
print.c:	  (cdr->type==nil && overlap_type(t_type,alist)) ||
print.c:	  (cdr->type==disj_nil && t_type==disjunction)
print.c:	  && !cdr->attr_list)
print.c:  Print a psi-term, but first precede it with the appropriate TAG. Don't
print.c:  reprint the same psi-term twice.
print.c:  if (n && n->data) {
print.c:    if (n->data==(GENERIC)no_name) {
print.c:      n->data=unique_name();
print.c:      /* n->data=(GENERIC)heap_copy_string(name); */
print.c:      prettyf((char *)n->data);
print.c:      heap_insert(INTEGERCMP,(GENERIC)nn2,&printed_pointers,(GENERIC)n->data);
print.c:      prettyf((char *)n2->data);
print.c:    long f=check_opargs(n->left) | check_opargs(n->right);
print.c:    if (!featcmp(n->key,"1",FEATURECMP)) return 1 | f;
print.c:    if (!featcmp(n->key,"2",FEATURECMP)) return 2 | f;
print.c:  long numarg=check_opargs(t->attr_list);
print.c:  ptr_operator_data opdat=t->type->op_data;
print.c:    op=opdat->type;
print.c:    opdat=opdat->next;
print.c:  *prec=opdat->precedence;
print.c:    get_two_args(t->attr_list, &arg1, &arg2);
print.c:    if (!p1 && lf_strcmp(t->type->keyword->symbol,",")) {
print.c:    pretty_quote_symbol(t->type->keyword); /*  RM: Jan 13 1993  */
print.c:        (!lf_strcmp(t->type->keyword->symbol,",") ||
print.c:         !lf_strcmp(t->type->keyword->symbol,":-"))) {
print.c:      if (!p2 && lf_strcmp(t->type->keyword->symbol,".")) prettyf(" ");
print.c:    get_two_args(t->attr_list, &arg1, &arg2); /* arg2 does not exist */
print.c:    pretty_quote_symbol(t->type->keyword);  /*  RM: Jan 13 1993  */
print.c:    get_two_args(t->attr_list, &arg1, &arg2); /* arg2 does not exist */
print.c:    pretty_quote_symbol(t->type->keyword); /*  RM: Jan 13 1993  */
print.c:    /* if (trace) printf("<%ld>",t->status); For brunobug.lf PVR 14.2.94 */
print.c:    if((t->type==alist || t->type==disjunction) && check_legal_cons(t,t->type))
print.c:      if(t->type==nil && !t->attr_list)
print.c:	if(t->type==disj_nil && !t->attr_list) /*  RM: Feb  1 1993  */
print.c:	if (t->value) {
print.c:	  if(t->type->type==block) {  /* RM 20 Jan 1993 */
print.c:	  if (sub_type(t->type,integer)) {
print.c:	    val = *(REAL *)t->value;
print.c:	    if (neg) val = -val;
print.c:	    sprintf(segbuf[seg],"%s%ld",(neg?"-":""),(unsigned long)val);
print.c:	    for (i=seg; i>=0; i--) prettyf(segbuf[i]);
print.c:	    if (!equal_types(t->type,integer)) {
print.c:	      pretty_symbol(t->type->keyword); /*  RM: Jan 13 1993  */
print.c:	  else if (sub_type(t->type,real)) {
print.c:	    sprintf(buf,"%lg",*(REAL *)t->value);
print.c:	    if (!equal_types(t->type,real) &&
print.c:		!equal_types(t->type,integer)) {
print.c:	      pretty_symbol(t->type->keyword); /*  RM: Jan 13 1993  */
print.c:	  else if (sub_type(t->type,quoted_string)) {
print.c:	    prettyf_quoted_string(t->value);
print.c:	    if(!equal_types(t->type,quoted_string)) {
print.c:	      pretty_quote_symbol(t->type->keyword); /*  RM: Jan 13 1993  */
print.c:	  else if (sub_type(t->type,sys_bytedata)) {
print.c:	    pretty_quote_symbol(t->type->keyword);
print.c:	  else if (equal_types(t->type,stream)) {
print.c:	    sprintf(buf,"stream(%ld)",(long)t->value);
print.c:	  else if (equal_types(t->type,eof))
print.c:	    pretty_quote_symbol(eof->keyword); /*  RM: Jan 13 1993  */
print.c:	  else if (equal_types(t->type,cut))
print.c:	    pretty_quote_symbol(cut->keyword); /*  RM: Jan 13 1993  */
print.c:	    pretty_symbol(t->type->keyword); /*  RM: Jan 13 1993  */
print.c:	  if (!argswritten) pretty_quote_symbol(t->type->keyword);
print.c:	/* write_canon -- PVR 24.2.94 */
print.c:	if (!argswritten && t->attr_list &&
print.c:	  pretty_attr(t->attr_list,depth+1);
print.c:	if (depth>=print_depth && !write_canon && t->attr_list) /* 20.8 */
print.c:    if (r=t->resid)
print.c:	if (r->goal->pending) {
print.c:	    pretty_psi_term(r->goal->a,0,depth);
print.c:	r=r->next;
print.c:    if (t->left) {
print.c:      do_pretty_attr(t->left,tab,cnt,two,depth);
print.c:    v=str_to_int(t->key);
print.c:	module=extract_module_from_name(t->key);
print.c:	  prettyf(module->module_name);
print.c:      prettyf_quote(strip_module_name(t->key));
print.c:    /* pretty_tag_or_psi_term(t->data,(two?COMMA_PREC:MAX_PRECEDENCE+1)); */
print.c:    pretty_tag_or_psi_term((ptr_psi_term)t->data,COMMA_PREC,depth);
print.c:    if (t->right) {
print.c:      do_pretty_attr(t->right,tab,cnt,two,depth);
print.c:    if (t->left || t->right) return TRUE; else return FALSE;
print.c:    if(i->tab->broken && i->tab->printed) {
print.c:      for(j=0;j<i->tab->column;j++)
print.c:    fprintf(outfile,"%s",i->str);
print.c:    i->tab->printed=TRUE;
print.c:  if(n->left) {
print.c:    pretty_variables(n->left,tab);
print.c:  prettyf(n->key);
print.c:  tok=(ptr_psi_term )n->data;
print.c:  if(n2 && lf_strcmp((char *)n2->data,n->key)<0)
print.c:    prettyf((char *)n2->data);
print.c:    if (eqsym->op_data) {
print.c:      eqprec=eqsym->op_data->precedence;
print.c:  if(n->right) {
print.c:    pretty_variables(n->right,tab);
print.c:  Used by all versions of the built-in predicate write,
print.c:  and by the built-in predicate listing.
print.c:    write_attributes(n->left,tab);
print.c:    pretty_tag_or_psi_term((ptr_psi_term)n->data,MAX_PRECEDENCE+1,0);
print.c:    write_attributes(n->right,tab);
print.c:/* For the listing built-in */
print.c:    if (!write_corefs) main_pred_write(n->left);
print.c:      check_pointer((ptr_psi_term)n->data);
print.c:      pretty_tag_or_psi_term((ptr_psi_term)n->data,MAX_PRECEDENCE+1,0);
print.c:    if (!write_corefs) main_pred_write(n->right);
print.c:  Print a couple of psi-terms (u,v) with the correct co-referencing. Print
print.c:    check_pointer(r2->var);
print.c:    r2=r2->next;
print.c:    pretty_tag_or_psi_term(r2->var,MAX_PRECEDENCE+1,0);
print.c:    r2=r2->next;
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:    if (ioctl (stdin_fileno, TIOCGETP, &param_input) == -1)
raw.c:    if (ioctl (stdin_fileno, TIOCSETN, &param) == -1)
raw.c:    if (ioctl (stdin_fileno, TCGETA, &argio) == -1)
raw.c:    /* with IXON, do not interpret ctrl-S and ctrl-Q */
raw.c:    /* map LF to CR-LF */
raw.c:    if (ioctl (stdin_fileno, TCSETA, &argio) == -1)
raw.c:  c_get_raw (-Char, -EventFlag)
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:	level = (unsigned long) aim->c;
raw.c:	    if (nfds == -1)
raw.c:		    /* I don't understand - jch - Fri Aug 28 1992 */
raw.c:        bcopy (&bufbuf[1], bufbuf, BUFSIZ-1);
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:    if (ioctl (stdin_fileno, TIOCSETN, &param_input) == -1)
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:    deref_ptr (aim->a);
raw.c:    unify_bool_result (aim->b, mode_raw);
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:    deref_ptr (aim->a);
raw.c:    unify_bool_result (aim->b, x_window_creation);
raw.c:    unify_bool_result (aim->b, FALSE);
raw.c:  this built-in should be used only by the life-shell of Kathleen.
raw.c:    deref_ptr (aim->a);
raw.c:/* set up the built-ins for the mode raw */
sys.c:  funct=aim->a;
sys.c:  result=aim->b;
sys.c:    n=find(FEATURECMP,argi[i].feature,funct->attr_list);
sys.c:      arg = (ptr_psi_term) n->data;
sys.c:	  if (overlap_type(arg->type,*type))
sys.c:	if (overlap_type(arg->type,argi[i].type))
sys.c:      if (arg->value) {
sys.c:	    if (sub_type(arg->type,*type))
sys.c:	  if (sub_type(arg->type,(ptr_definition)type)) goto correct;
sys.c:      /* missing value - do we need it */
sys.c:	if (argo[i] && !(argi[i].options&UNEVALED) && !argo[i]->value)
sys.c:  temp_result->type=sort;
sys.c:  temp_result->value=(GENERIC)b;
sys.c:#define BYTEDATA_SIZE(X) (*(unsigned long *)(X->value))
sys.c:#define BYTEDATA_DATA(X) ((char*)((char*)X->value + sizeof(unsigned long)))
sys.c:  long bits = *(REAL *)args[0]->value;
sys.c:  unsigned char *s3 = ((unsigned char *) temp_result->value) + sizeof(size3);
sys.c:  return bitvector_binop_code((unsigned long *)args[0]->value,
sys.c:			      (unsigned long *)args[1]->value,
sys.c:    s3 = ((unsigned char *) temp_result->value) + sizeof(size1);
sys.c:  return bitvector_unop_code((unsigned long *)args[0]->value,
sys.c:    s2 = ((unsigned char *) temp_result->value) + sizeof(size1);
sys.c:    s2 = ((unsigned char *) temp_result->value) + sizeof(size1);
sys.c:  return bitvector_bit_code((unsigned long *)args[0]->value,
sys.c:			    (long)*((REAL*)args[1]->value),
sys.c:  regexp * re = regcomp((char *)args[0]->value);
sys.c:  if (re->regmust != NULL)
sys.c:    re->regmust = (char *) ((unsigned long) (re->regmust - (char *)re));
sys.c:  bcopy((char*)re,((char*)temp_result->value)+sizeof(unsigned long),bytes);
sys.c:  regexp_execute(RE:regexp,S:string) -> @(0=>(S0,E0),(S1,E1),...)
sys.c:  regexp_execute(RE:regexp,S:string,@(N=>(SN,EN),...)) -> boolean
sys.c:  regexp * re = (regexp*)(((char *)args[0]->value)+sizeof(unsigned long));
sys.c:  char * must = re->regmust;
sys.c:    offset = *(REAL*)args[3]->value;
sys.c:    if (offset < 0 || offset > strlen((char*)args[1]->value)) {
sys.c:    re->regmust = (char*)re+(unsigned long)must;
sys.c:  if (regexec(re,((char *)args[1]->value) + offset) == 0) {
sys.c:    if (must != NULL) re->regmust = must; /* back into an offset */
sys.c:    char **sp = re->startp;
sys.c:    char **ep = re->endp;
sys.c:    if (must != NULL) re->regmust = must; /* back into an offset */
sys.c:	n3=find(FEATURECMP,buffer,args[2]->attr_list);
sys.c:	  ptr_psi_term psi = (ptr_psi_term) n3->data;
sys.c:	     are 1-based rather than 0-based.  Who is the moron who made
sys.c:	  ptr_psi_term bounds = stack_pair(stack_int(*sp - (char *)args[1]->value + 1),
sys.c:					   stack_int(*ep - (char *)args[1]->value + 1));
sys.c:      psi->type = top;
sys.c:	{ ptr_psi_term bounds = stack_pair(stack_int(*sp - (char *)args[1]->value + 1),
sys.c:					   stack_int(*ep - (char *)args[1]->value + 1));
sys.c:	  stack_insert_copystr(buffer,&(psi->attr_list),(GENERIC)bounds); }
sys.c:  if (s->op != OP && s->op != FP_NONE) fflush(s->fp); \
sys.c:  s->op = OP;
sys.c:  ((ptr_stream)BYTEDATA_DATA(result))->fp = fp;
sys.c:  ((ptr_stream)BYTEDATA_DATA(result))->op = FP_NONE;
sys.c:  FILE *fp = fdopen((int)*(REAL*)args[0]->value,
sys.c:		    (char*)args[1]->value);
sys.c:  FILE *fp = fopen((char*)args[0]->value,
sys.c:		   (char*)args[1]->value);
sys.c:  if (fclose(((ptr_stream)BYTEDATA_DATA(args[0]))->fp) != 0)
sys.c:  char* txt = (char*)args[1]->value;
sys.c:      fwrite((void*)txt,sizeof(char),strlen(txt),srm->fp)<=0)
sys.c:  srm->op = FP_NONE;
sys.c:  if (fflush(srm->fp)!=0) return FALSE;
sys.c:  long size = *(REAL*)args[1]->value;
sys.c:  t->type = quoted_string;
sys.c:  t->value=(GENERIC)heap_alloc(size+1);
sys.c:  bzero((char*)t->value,size+1);
sys.c:  if (fread((void*)t->value,sizeof(char),size,srm->fp) <= 0)
sys.c:    while (idx<buf->top)
sys.c:      if (buf->data[idx] == c) {
sys.c:    buf=buf->next;
sys.c:    while (idx<buf->top)
sys.c:      if (!*str || buf->data[idx] != *str)
sys.c:    if (!*str && !buf->next) return str;
sys.c:      buf=buf->next;
sys.c:  if ((*buf)->top < TEXTBUFSIZE)
sys.c:    (*buf)->data[(*buf)->top++] = c;
sys.c:    (*buf)->next = (struct text_buffer *)
sys.c:    if (!(*buf)->next) {
sys.c:      exit(-1);
sys.c:    bzero((char*)(*buf)->next,sizeof(struct text_buffer));
sys.c:    *buf = (*buf)->next;
sys.c:    (*buf)->top = 1;
sys.c:    (*buf)->data[0]=c;
sys.c:    next = buf->next;
sys.c:  FILE *fp = srm->fp; /*FILE* fp = *(FILE**)BYTEDATA_DATA(args[0]);*/
sys.c:  char *sep = (char*)args[1]->value;
sys.c:    lastidx=curbuf->top - 1;
sys.c:  for(lastbuf=&rootbuf,size=0;lastbuf!=NULL;lastbuf=lastbuf->next)
sys.c:    size += lastbuf->top;
sys.c:  t->type=quoted_string;
sys.c:  t->value=(GENERIC)heap_alloc(size+1);
sys.c:  for(lastbuf=&rootbuf,sep=(char*)t->value;
sys.c:      lastbuf!=NULL;sep+=lastbuf->top,lastbuf=lastbuf->next)
sys.c:    bcopy(lastbuf->data,sep,lastbuf->top);
sys.c:  ((char*)t->value)[size]='\0';
sys.c:  if ((c=getc(srm->fp)) == EOF) return FALSE;
sys.c:  if (srm->op != FP_NONE || srm->op != FP_INPUT) {
sys.c:    fflush(srm->fp);
sys.c:    srm->op = FP_NONE;
sys.c:  return unify_real_result(result,(REAL)ftell(srm->fp));
sys.c:  srm->op = FP_NONE;
sys.c:    (fseek(srm->fp /**(FILE**)BYTEDATA_DATA(args[0])*/,
sys.c:	   (long)*(REAL*)args[1]->value,
sys.c:	   args[2]?(long)*(REAL*)args[2]->value:SEEK_SET) < 0)
sys.c:  push_goal(unify,fileptr2stream((FILE*)args[0]->value,sys_stream),
sys.c:  tmp->type=stream;
sys.c:  tmp->value=(GENERIC)((ptr_stream)BYTEDATA_DATA(args[0]))->fp;
sys.c:    s=(char*)args[0]->value;
sys.c:    s=(char*)args[1]->value;
sys.c:  int fd = fileno(((ptr_stream)BYTEDATA_DATA(args[0]))->fp); /**(FILE**)BYTEDATA_DATA(args[0]));*/
sys.c:    char* hostname = args[1]?(char*)args[1]->value:NULL;
sys.c:    name.sin_port = htons((unsigned short)*(REAL*)args[2]->value);
sys.c:      bcopy(h->h_addr,(char*)&(name.sin_addr.s_addr),h->h_length);
sys.c:    char* path = (char*)args[3]->value;
sys.c:  int fd = fileno(((ptr_stream)BYTEDATA_DATA(args[0]))->fp); /**(FILE**)BYTEDATA_DATA(args[0]));*/
sys.c:  int n = *(REAL*)args[1]->value;
sys.c:  int fd = fileno(((ptr_stream)BYTEDATA_DATA(args[0]))->fp); /**(FILE**)BYTEDATA_DATA(args[0]));*/
sys.c:  long n = args[0]?(long)*(REAL*)args[0]->value:errno;
sys.c:    key=args[1]->type->keyword;
sys.c:    key=hash_lookup(current_module->symbol_table,
sys.c:		    args[0]->type->keyword->symbol);
sys.c:    if (key->definition->type != undef) {
sys.c:      Errorline("symbol %s already defined in %P.",key->combined_name,funct);
sys.c:    else key->definition=args[0]->type;
sys.c:    key->module=current_module;
sys.c:    key->symbol=args[0]->type->keyword->symbol;
sys.c:    key->combined_name=(char *)
sys.c:      heap_copy_string((GENERIC)make_module_token(current_module,key->symbol));
sys.c:    key->public=FALSE;
sys.c:    key->private_feature=FALSE;
sys.c:    key->definition=args[0]->type; /* use given definition */
sys.c:    hash_insert(current_module->symbol_table,key->symbol,key);
sys.c:    exit(-1);
sys.c:  u->type=sym;
sys.c:    stack_insert(FEATURECMP,(GENERIC)lst[i].name,&(u->attr_list),(GENERIC)lst[i].value);
sys.c:  if (id == -1 || status == -1) {
sys.c:  pid_t id = waitpid((pid_t)(long)*(REAL*)args[0]->value,&status,
sys.c:		     args[1]?(int)(long)*(REAL*)args[1]->value:0);
sys.c:  return (kill((pid_t)*(REAL*)args[0]->value,
sys.c:	       (int)*(REAL*)args[1]->value)==0)?TRUE:FALSE;
sys.c:  if (args[1]->type == top) {
sys.c:  if (sub_type(args[1]->type,integer) && args[1]->value)
sys.c:    sprintf(buffer,"%ld",(long)*(REAL*)args[1]->value);
sys.c:  else if (sub_type(args[1]->type,quoted_string) && args[1]->value)
sys.c:    strcpy(buffer,(char*)args[1]->value);
sys.c:    strcpy(buffer,args[1]->type->keyword->symbol);
sys.c:  n=find(FEATURECMP,buffer,args[0]->attr_list);
sys.c:  if (n) push_goal(unify,(ptr_psi_term)n->data,result,NULL);
sys.c:  if (args[1]->type == top) {
sys.c:  if (sub_type(args[1]->type,integer) && args[1]->value)
sys.c:    sprintf(buffer,"%ld",(long)*(REAL*)args[1]->value);
sys.c:  else if (sub_type(args[1]->type,quoted_string) && args[1]->value)
sys.c:    strcpy(buffer,(char*)args[1]->value);
sys.c:    strcpy(buffer,args[1]->type->keyword->symbol);
sys.c:  if (find(FEATURECMP,buffer,args[0]->attr_list))
sys.c:  if (args[1]->type == top) {
sys.c:  if (sub_type(args[1]->type,integer) && args[1]->value)
sys.c:    sprintf(buffer,"%ld",(long)*(REAL*)args[1]->value);
sys.c:  else if (sub_type(args[1]->type,quoted_string) && args[1]->value)
sys.c:    strcpy(buffer,(char*)args[1]->value);
sys.c:    strcpy(buffer,args[1]->type->keyword->symbol);
sys.c:  if (find(FEATURECMP,buffer,args[0]->attr_list)) {
sys.c:   call_once(G) -> T | G,!,T=true;T=false.
sys.c:  value->type = false;
sys.c:  value->type = true;
sys.c:  if (args[0]->type==top) residuate(args[0]);
sys.c:  else if (args[0]->type->type!=function) {
sys.c:    if (sub_type(args[1]->type,integer) && args[1]->value)
sys.c:      feat = (GENERIC)get_numeric_feature((long)*(REAL*)args[1]->value);
sys.c:    else if (sub_type(args[1]->type,quoted_string) && args[1]->value)
sys.c:      feat = (GENERIC)args[1]->value;
sys.c:      feat = (GENERIC)heap_copy_string((GENERIC)args[1]->type->keyword->symbol);
sys.c:    stack_insert(FEATURECMP,feat,&(fun->attr_list),(GENERIC)args[2]);
sys.c:    push_goal(eval,fun,result,(GENERIC)fun->type->rule);
sys_dbm.c:  if (dbminit((char*)args[0]->value)<0) return FALSE;
sys_dbm.c:  d.dptr  = (char*)args[0]->value;
sys_dbm.c:  key.dptr  = (char*)args[0]->value;
sys_dbm.c:  content.dptr  = (char*)args[1]->value;
sys_dbm.c:  key.dptr  = (char*)args[0]->value;
sys_dbm.c:  key.dptr  = (char*)args[0]->value;
templates.c:    if (n = find (FEATURECMP, number, g->attr_list))
templates.c:        return (*arg = (ptr_psi_term) n->data) ? TRUE: FALSE;
token.c:/* Psi-term containing global input file state */
token.c:/* Psi-term containing stdin file state */
token.c:/* All psi-terms created here are on the HEAP. */
token.c:/* All these routines are NON-backtrackable. */
token.c:  if(p->type==error_psi_term->type) {
token.c:/* Add an attribute whose value is an integer to a psi-term */
token.c:  t1->type=integer;
token.c:  t1->value=heap_alloc(sizeof(REAL));
token.c:  *(REAL *)t1->value = (REAL) value;
token.c:  heap_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list), (GENERIC)t1);
token.c:  t1->type=integer;
token.c:  t1->value=heap_alloc(sizeof(REAL)); /* 12.5 */
token.c:  *(REAL *)t1->value = (REAL) value;
token.c:  stack_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list),(GENERIC) t1);
token.c:/* Modify an attribute whose value is an integer to a psi-term */
token.c:  n=find(FEATURECMP,attrname,t->attr_list);
token.c:  t1=(ptr_psi_term)n->data;
token.c:  *(REAL *)t1->value = (REAL) value;
token.c:  n=find(FEATURECMP,attrname,t->attr_list);
token.c:  t1=(ptr_psi_term)n->data;
token.c:  *(REAL *)t1->value = (REAL) value;
token.c:/* Add an attribute whose value is a string to a psi-term */
token.c:  t1->type=quoted_string;
token.c:  t1->value=(GENERIC)heap_copy_string((GENERIC)str);
token.c:  heap_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list),(GENERIC) t1);
token.c:  t1->type=quoted_string;
token.c:  t1->value=(GENERIC)stack_copy_string((GENERIC)str);
token.c:  stack_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list),(GENERIC) t1);
token.c:/* Modify an attribute whose value is a string to a psi-term */
token.c:  n=find(FEATURECMP,attrname,t->attr_list);
token.c:  t1=(ptr_psi_term)n->data;
token.c:  t1->value=(GENERIC)heap_copy_string((GENERIC)str);
token.c:ATTENTION - This should be made backtrackable if used
token.c:  n=find(FEATURECMP,attrname,t->attr_list);
token.c:  t1=(ptr_psi_term)n->data;
token.c:  t1->value=(GENERIC)stack_copy_string(str);
token.c:/* Attach a psi-term to another as an attribute. */
token.c:  heap_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list),(GENERIC) g);
token.c:  stack_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list),(GENERIC) g);
token.c:  bk_stack_insert(FEATURECMP,heap_copy_string((GENERIC)attrname),&(t->attr_list), (GENERIC)g);
token.c:/* Get the GENERIC value of a psi-term's attribute */
token.c:  ptr_node n=find(FEATURECMP,attrname,t->attr_list);
token.c:  return (GENERIC) n->data;
token.c:/* Get the psi-term's STREAM attribute */
token.c:  return (FILE *) ((ptr_psi_term)get_attr(t,STREAM))->value;
token.c:/* Save global state into an existing file state psi-term t */
token.c:  n=find(FEATURECMP,STREAM,t->attr_list);
token.c:  t1=(ptr_psi_term)n->data;
token.c:  t1->value=(GENERIC)input_stream;
token.c:  heap_mod_str_attr(t,CURRENT_MODULE,current_module->module_name);
token.c:  t1->type=(eof_flag?true:false);
token.c:  t1->type=(start_of_line?true:false);
token.c:/* Restore global state from an existing file state psi-term t */
token.c:  input_stream = (FILE *) ((ptr_psi_term)get_attr(t,STREAM))->value;
token.c:  str = (char*) ((ptr_psi_term)get_attr(t,INPUT_FILE_NAME))->value;
token.c:  line_count = *(REAL *) ((ptr_psi_term)get_attr(t,LINE_COUNT))->value;
token.c:  saved_char = *(REAL *) ((ptr_psi_term)get_attr(t,SAVED_CHAR))->value;
token.c:  old_saved_char= *(REAL *)((ptr_psi_term)get_attr(t,OLD_SAVED_CHAR))->value;
token.c:  eof_flag = ((ptr_psi_term)get_attr(t,EOF_FLAG))->type==true;
token.c:  start_of_line = ((ptr_psi_term)get_attr(t,START_OF_LINE))->type==true;
token.c:      CURRENT_MODULE))->value));
token.c:/* Create a new file state psi-term that reflects the current global state */
token.c:  (*t)->type=inputfilesym;
token.c:  t1->type=stream;
token.c:  t1->value=(GENERIC)input_stream;
token.c:  heap_add_str_attr(*t,CURRENT_MODULE,current_module->module_name);
token.c:    current_module->module_name);
token.c:  t1->type=(eof_flag?true:false);
token.c:  t1->type=(start_of_line?true:false);
token.c:     pb->lc   = line_count;
token.c:     pb->sol  = start_of_line;
token.c:     pb->sc   = saved_char;
token.c:     pb->osc  = old_saved_char;
token.c:     pb->spt  = saved_psi_term;
token.c:     pb->ospt = old_saved_psi_term;
token.c:     pb->ef   = eof_flag;
token.c:     line_count         = pb->lc;
token.c:     start_of_line      = pb->sol;
token.c:     saved_char         = pb->sc;
token.c:     old_saved_char     = pb->osc;
token.c:     saved_psi_term     = pb->spt;
token.c:     old_saved_psi_term = pb->ospt;
token.c:     eof_flag           = pb->ef;
token.c:   This is to avoid mix-ups between terminal and file I/O since the
token.c:	user=pw->pw_dir;
token.c:  tok->type=comment;
token.c:    exit(-1);
token.c:    tok->value=(GENERIC)heap_copy_string((GENERIC)str);
token.c:    tok->type=update_symbol(NULL,str); /* Maybe no_module would be better */
token.c:    tok->value=NULL;
token.c:  tok->coref=NULL;
token.c:  tok->resid=NULL;
token.c:  tok->attr_list=NULL;
token.c:    strcpy(str,module->module_name);
token.c:  tok->type=typ;
token.c:    /* printf("module=%s\n",module->module_name); */
token.c:    tok->type=update_symbol(module,str); /*  RM: Feb  3 1993  */
token.c:    tok->value=NULL;
token.c:    if (tok->type->type==global) {
token.c:    if (FALSE /*tok->type->type==global && tok->type->global_value*/) {
token.c:      n=find(STRINGCMP,tok->type->keyword->symbol,var_tree);
token.c:			 (GENERIC)tok->type->keyword->symbol,
token.c:			 (GENERIC)tok->type->global_value);
token.c:    tok->value=(GENERIC)heap_copy_string((GENERIC)str);
token.c:  Accepted syntax: digit+ [ . digit+ ] [ {e|E} {+|-|empty} digit* ]
token.c:  /* if (sgn=(c=='-')) c=read_char(); */
token.c:  /* tok->type=integer;   RM: Mar  8 1993  */
token.c:  do { f=f*10.0+(c-'0'); c=read_char(); } while (DIGIT(c));
token.c:      /* tok->type=real;     RM: Mar  8 1993  */
token.c:      while (DIGIT(c2)) { f=f+(c2-'0')/p; p=p*10.0; c2=read_char(); }
token.c:    if (c2=='+' || c2=='-' || DIGIT(c2)) {
token.c:      tok->type=real;
token.c:      while (DIGIT(c2)) { pwr=pwr*10+(c2-'0'); c2=read_char(); }
token.c:      while (pwr>=100) { pwr-=100; if (posflag) p*=1e100; else p/=1e100; }
token.c:      while (pwr>=10 ) { pwr-=10;  if (posflag) p*=1e10;  else p/=1e10;  }
token.c:      while (pwr>0   ) { pwr-=1;   if (posflag) p*=1e1;   else p/=1e1;   }
token.c:  /* if (sgn) f = -f; */
token.c:  tok->value=heap_alloc(sizeof(REAL)); /* 12.5 */
token.c:  *(REAL *)tok->value=f;
token.c:    tok->type=integer;
token.c:    tok->type=real;
token.c:/* Used as a built-in */
token.c:    tok->type=nothing;
token.c:      tok->type=eof;
token.c:      tok->value=NULL;
token.c:      tok->type=quoted_string;
token.c:      /* Adding this results in problems with terms like (N-1) */
token.c:      /* if (c=='-' && (c2=read_char()) && DIGIT(c2)) {
token.c:	    tok->type=final_dot;
token.c:	    tok->type=final_question;
token.c:	  tok->value=NULL;
token.c:		    tok->type=update_symbol(current_module,p);
token.c:		    tok->value=NULL;
token.c:    if (tok->type==variable) {
token.c:      if (tok->value) {
token.c:        if (!lf_strcmp((char *)tok->value,"_")) {
token.c:          tok->type=update_symbol(current_module,p);
token.c:          tok->value=NULL;
token.c:          n=find(STRINGCMP,(char *)tok->value,var_tree);
token.c:            bk2_stack_insert(STRINGCMP,tok->value,&var_tree,(GENERIC)t); /* 17.8 */
token.c:            tok->coref=t;
token.c:  	    tok->coref=(ptr_psi_term)n->data;
token.c:  if (tok->type==comment)
token.c:  if (tok->type!=variable)
token.c:    tok->coref=NULL;
token.c:  tok->attr_list=NULL;
token.c:  tok->status=0;
token.c:  tok->flags=FALSE; /* 14.9 */
token.c:  tok->resid=NULL;
token.c:  if (tok->type==cut) /* 12.7 */
token.c:    tok->value=(GENERIC)choice_stack;
trees.c:  return a-b;
trees.c:/* Modify s to point to first non-zero digit. */
trees.c:  char *sint; /* Ptr to first non-zero digit */
trees.c:  if (*sgn=(*stmp=='-')) {
trees.c:  *len=stmp-sint;
trees.c:/* Modify s to point to first non-zero digit. */
trees.c:  char *sint; /* Ptr to first non-zero digit */
trees.c:  if (*sgn=(*stmp=='-')) {
trees.c:    if (*sgn == 0 && *stmp > '0') *sgn = -1;
trees.c:  *len=stmp-sint;
trees.c:      /* if (*str1==0 && *str2==0) return 0; "" bug is unaffected -- PVR 23.2.94 */
trees.c:	return *str1 - *str2;
trees.c:	  if (sgn1!=sgn2) return (sgn1-sgn2); /* Check signs first */
trees.c:	  if (len1!=len2) return (len1-len2); /* Then check lengths */
trees.c:	  return -1;
trees.c:      return( int1 - int2);
trees.c:      (*tree)->key = copystr ? (char *)heap_copy_string(keystr) : keystr;
trees.c:      // (*tree)->key  = (heapflag==HEAP) ? heap_copy_string(keystr) : stack_copy_string(keystr);
trees.c:      (*tree)->left=NULL;
trees.c:      (*tree)->right=NULL;
trees.c:      (*tree)->data=info;
trees.c:    sprintf(nnn1,"%ld",(long)(*tree)->key);
trees.c:    cmp=featcmp(keystr,(*tree)->key,comp);
trees.c:    cmp=featcmp(keystr,(*tree)->key,comp);
trees.c:    tree=(&((*tree)->left));
trees.c:	    (*tree)->data=info;
trees.c:	  tree=(&((*tree)->right));
trees.c:	sprintf(nnn1,"%ld",(long)tree->key);
trees.c:	cmp=featcmp(keystr,tree->key,comp);
trees.c:	tree=tree->left;
trees.c:	tree=tree->right;
trees.c:    printf("Find: '%s' -> %x\n",keystr,result);
trees.c:    if(t->data==p)
trees.c:      r=find_data(p,t->left);
trees.c:	r=find_data(p,t->right);
trees.c:    result=(ptr_definition )n->data;
trees.c:    result->keyword->symbol=s;
trees.c:    result->rule=NULL;
trees.c:    result->properties=NULL;
trees.c:    result->date=0;
trees.c:    result->type=undef;
trees.c:    result->always_check=TRUE;
trees.c:    result->protected=TRUE;
trees.c:    result->evaluate_args=TRUE;
trees.c:    result->already_loaded=FALSE;
trees.c:    result->children=NULL;
trees.c:    result->parents=NULL;
trees.c:    result->code=NOT_CODED;
trees.c:    result->op_data=NULL;
trees.c:    cmp=featcmp(s,(*n)->key,FEATURECMP);
trees.c:      delete_attr(s,&((*n)->left));
trees.c:	delete_attr(s,&((*n)->right));
trees.c:    else if ((*n)->left) {
trees.c:      if ((*n)->right) {
trees.c:        r=(*n)->right;
trees.c:        new=heap_insert(FEATURECMP,r->key,&((*n)->left),r->data);
trees.c:        new->left=r->left;
trees.c:        new->right=r->right;
trees.c:        *n = (*n) -> left;
trees.c:        *n = (*n)->left;
trees.c:      *n = (*n)->right;
types.c:    if (((ptr_definition)(*dl)->value)==d)
types.c:      *dl = (*dl)->next;
types.c:      dl= &((*dl)->next);
types.c:  d=t->type;
types.c:  if (d->date<file_date) {
types.c:    if (d->type==type) {
types.c:        Warningline("extending definition of sort '%s'.\n",d->keyword->symbol);
types.c:    else if (d->protected && d->type!=undef) {
types.c:      if (d->date>0) {
types.c:                  d->type, d->keyword->combined_name);
types.c:        if (d->rule && (unsigned long)d->rule<=MAX_BUILT_INS /*&& input_stream==stdin*/) {
types.c:          /* d is a built-in, and therefore cannot be altered. */
types.c:          Errorline("the built-in %T '%s' may not be extended.\n",
types.c:                    d->type, d->keyword->symbol);
types.c:          /* d is not a built-in, and therefore can be altered. */
types.c:          Warningline("extending the %T '%s'.\n",d->type,d->keyword->symbol);
types.c:      if (d->type==type) { /* d is an already existing type */
types.c:        /* It seems to be a no-op. */
types.c:        remove_cycles(d, &(d->children));
types.c:        remove_cycles(d, &(d->parents));
types.c:        /* d->rule=NULL; */ /* Types must keep their rules! */
types.c:        /* d->properties=NULL; */ /* Types get new properties from encode */
types.c:      if (d->date==0) d->date=file_date;
types.c:      /* d->type=undef; */ /* Objects keep their type! */
types.c:      /* d->always_check=TRUE; */
types.c:      /* d->protected=TRUE; */
types.c:      /* d->children=NULL; */
types.c:      /* d->parents=NULL; */
types.c:      /* d->code=NOT_CODED; */
types.c:  n->value=v;
types.c:  n->next=l;
types.c:    if (t1->type==top) {
types.c:      if (t1->value || t2->value) {
types.c:  if (t1->type==t2->type) {
types.c:  d1=t1->type;
types.c:  d2=t2->type;
types.c:  if (d1->type==predicate || d1->type==function) {
types.c:              d1->type, d1->keyword->symbol);
types.c:  else if (d2->type==predicate || d2->type==function) {
types.c:              d2->type, d2->keyword->symbol);
types.c:    d1->type=type;
types.c:    d2->type=type;
types.c:    /* d1->parents=cons(d2,d1->parents); */
types.c:    /* d2->children=cons(d1,d2->children); */
types.c:    assert_protected(n->left,prot);
types.c:    t=(ptr_psi_term)n->data;
types.c:    if (t->type) {
types.c:      if (t->type->type==type) {
types.c:                    t->type->keyword->symbol);
types.c:      else if ((unsigned long)t->type->rule<MAX_BUILT_INS &&
types.c:               (unsigned long)t->type->rule>0) {
types.c:          Warningline("'%s' is a built-in--it has not been made dynamic.\n",
types.c:                      t->type->keyword->symbol);
types.c:        t->type->protected=prot;
types.c:        if (prot) t->type->date&=(~1); else t->type->date|=1;
types.c:    assert_protected(n->right,prot);
types.c:    assert_args_not_eval(n->left);
types.c:    t=(ptr_psi_term)n->data;
types.c:    if (t->type) {
types.c:      if (t->type->type==type) {
types.c:        Warningline("'%s' is a sort--only functions and predicates\
types.c: can have unevaluated arguments.\n",t->type->keyword->symbol);
types.c:        t->type->evaluate_args=FALSE;
types.c:    assert_args_not_eval(n->right);
types.c:    assert_delay_check(n->left);
types.c:    t=(ptr_psi_term)n->data;
types.c:    if (t->type) {
types.c:      t->type->always_check=FALSE;
types.c:    assert_delay_check(n->right);
types.c:    d=((ptr_keyword)n->data)->definition;
types.c:    d->already_loaded=FALSE;
types.c:    clear_already_loaded(n->left);
types.c:    clear_already_loaded(n->right);
types.c:  Add that to the type-definitions.
types.c:  get_two_args(t->attr_list,&arg1,&arg2);
types.c:  get_two_args(t->attr_list,&typ1,&arg2);
types.c:    if (arg2->type && arg2->type->keyword && arg2->type->keyword->symbol && !lf_strcmp(arg2->type->keyword->symbol,"|")) {
types.c:      get_two_args(arg2->attr_list,&arg2,&pred);
types.c:    if (typ2 && typ2->type) {
types.c:      if (typ2->type==disjunction) {
types.c:        if (typ1->attr_list && eqflag) {
types.c:        while(typ2 && typ2->type!=nil) {
types.c:          get_two_args(typ2->attr_list,&arg2,&typ2); /*  RM: Dec 14 1992  */
types.c:              if (ok && (arg2->attr_list || pred!=NULL)) {
types.c:              if (ok && arg2->attr_list) {
types.c:        if (typ1->attr_list) {
types.c:        typ2->type=typ1->type;
types.c:        if (ok && (typ2->attr_list || pred!=NULL))
types.c:        if (typ2->attr_list) {
types.c:        if (ok && (typ1->attr_list || pred!=NULL))
types.c:  get_two_args(t->attr_list,&arg1,&arg2);
types.c:    if (!lf_strcmp(arg1->type->keyword->symbol,"|")) {
types.c:      get_two_args(arg1->attr_list,&arg1,&pred);
types.c:      d=arg1->type;
types.c:      if (d->type==predicate || d->type==function) {
types.c:                  d->type, d->keyword->symbol);
types.c:        d->type=type;
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if(d->type==type && d->parents==NULL) {
types.c:      l->value=(GENERIC)d;
types.c:      l->next=adults;
types.c:  l->value=(GENERIC)d;
types.c:  l->next=children;
types.c:  rule = d->rule;
types.c:    t= &(d->properties);
types.c:        if ((*t)->a==rule->a && (*t)->b==rule->b && (*t)->c==d)
types.c:          t= &((*t)->next);
types.c:        (*t)->a=rule->a;
types.c:        (*t)->b=rule->b;
types.c:        (*t)->c=d;
types.c:        (*t)->next=NULL;
types.c:    rule=rule->next;
types.c:  l->value=(GENERIC)d;
types.c:  l->next=children;
types.c:    t= &(d->properties);
types.c:        if ((*t)->a==prop->a && (*t)->b==prop->b && (*t)->c==prop->c)
types.c:          t= &((*t)->next);
types.c:        (*t)->a=prop->a;
types.c:        (*t)->b=prop->b;
types.c:        (*t)->c=prop->c;
types.c:        (*t)->next=NULL;
types.c:    prop=prop->next;
types.c:      d=(ptr_definition)adults->value;
types.c:	children=children->next;
types.c:	kids=d->children;
types.c:	while(kids && d && kids->value && d->properties) { // added d & kids->value & d->properties djd
types.c:	  insert_prop(kids->value,d->properties);
types.c:	  /* if (d->always_check && kids->value)
types.c:	     ((ptr_definition)kids->value)->always_check=TRUE; */
types.c:	  kids=kids->next;
types.c:      adults=adults->next;
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if (d->type==type) c0++;
types.c:  Clear the bit-vector coding of the sorts.
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if (d->type==type) d->code=NOT_CODED;
types.c:  nothing->parents.
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if (d->type==type && d->children==NULL && d!=nothing)
types.c:      nothing->parents=cons(d,nothing->parents);
types.c:  Build a list of all sorts (except nothing) in nothing->parents.
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if (d->type==type && d!=nothing)
types.c:      nothing->parents=cons(d,nothing->parents);
types.c:  code->value=0;
types.c:  code->next=NULL;
types.c:    code->next=HEAP_ALLOC(int_list);
types.c:    code=code->next;
types.c:    code->value=0;
types.c:    code->next=NULL;
types.c:    p=p-INT_SIZE;
types.c:  code->value=(GENERIC)v;
types.c:  code->value=0;
types.c:  code->next=NULL;
types.c:    u->value= (GENERIC)(((unsigned long)(u->value)) | ((unsigned long)(v->value)));
types.c:    v=v->next;
types.c:    if (u->next==NULL && v) {
types.c:      u->next=HEAP_ALLOC(int_list);
types.c:      u=u->next;
types.c:      u->value=0;
types.c:      u->next=NULL;
types.c:      u=u->next;
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if (d->type==type) {
types.c:      c = d->code;
types.c:      ci = &(d->code);  /*  RM: Feb 15 1993  */
types.c:        ci= &(c->next);
types.c:        c=c->next;
types.c:        w--;
types.c:        (*ci)->value=0;
types.c:        ci= &((*ci)->next);
types.c:  so that nothing really horrible happens if the user modifies built-in types
types.c:  if (t2!=top && !type_member(t2,t1->parents))
types.c:    t1->parents=cons(t2,t1->parents);
types.c:  if (t2!=top && !type_member(t1,t2->children))
types.c:    t2->children=cons(t1,t2->children);
types.c:   if (t==(ptr_definition)tlst->value) return TRUE;
types.c:   tlst=tlst->next;
types.c:  perr_s("%s",d->keyword->symbol);
types.c:    perr_sort_list(anc->next);
types.c:    if (anc->next) perr(" <| ");
types.c:    perr_sort((ptr_definition)anc->value);
types.c:  perr_sort((ptr_definition)anc->value);
types.c:  ptr_int_list p=d->parents;
types.c:    pd=(ptr_definition)p->value;
types.c:    if (pd->code==NOT_CODED) {
types.c:      pd->code = (ptr_int_list)TRUE;
types.c:    p=p->next;
types.c:  child_list = d->children;
types.c:    child = (ptr_definition)child_list->value;
types.c:    if (child->always_check) {
types.c:      child->always_check = FALSE;
types.c:    child_list = child_list->next;
types.c:  for(d=first_definition;d;d=d->next)
types.c:    if (d->type==type && !d->always_check)
types.c:  This routine performs type-coding using transitive closure.
types.c:    nothing->parents=NULL;
types.c:    nothing->children=NULL;
types.c:    top->parents=NULL;
types.c:    top->children=NULL;
types.c:    type_count=count_sorts(-1); /* bottom does not count */
types.c:    nothing->parents=NULL; /* Must be cleared before all_sorts */
types.c:    nothing->parents=NULL; /* Must be cleared before least_sorts */
types.c:    nothing->code=NULL;
types.c:    Traceline("*** Codes:\n%C= %s\n", NULL, nothing->keyword->symbol);
types.c:    layer=nothing->parents;
types.c:      while (l && l->value) {  // changed from do to while djd & added l->value
types.c:       xdef=(ptr_definition)l->value;
types.c:        if (xdef && xdef->code==NOT_CODED && xdef!=top) { // added xde f->code dj0d
types.c:          kids=xdef->children;
types.c:          while (kids && kids->value) {  // added kids->value djd
types.c:            kdef=(ptr_definition)kids->value;
types.c:            or_codes(code,kdef->code);
types.c:            kids=kids->next;
types.c:	    xdef->code=code;
types.c:	    Traceline("%C = %s\n", code, xdef->keyword->symbol);
types.c:        l=l->next;
types.c:        xdef=(ptr_definition)l->value;
types.c:        dads=xdef->parents;
types.c:        while (dads && dads->value) {  // added dads-> value djd
types.c:          ddef=(ptr_definition)dads->value;
types.c:          if(ddef && ddef->code==NOT_CODED) { // added ddef djd
types.c:            kids=ddef->children;
types.c:              kdef=(ptr_definition)kids->value;
types.c:              if(kdef && kdef->code==NOT_CODED)  // added kdef djd
types.c:              kids=kids->next;
types.c:          dads=dads->next;
types.c:        l=l->next;
types.c:    top->code=two_to_the(p);
types.c:      or_codes(top->code,two_to_the(i));
types.c:    Traceline("%C = @\n\n", top->code);
types.c:	       gamma_table[i]->code,
types.c:	       gamma_table[i]->keyword->combined_name);
types.c:  Do the comparison of the value fields of two psi-terms.
types.c:  completeness for disequality for psi-terms with non-NULL value fields.
types.c:  result   result of preceding glb_code call (non-NULL iff non-empty intersec.)
types.c:  value1   value field of first psi-term.
types.c:  value2   value field of second psi-term.
types.c:  /* At this point, both value fields are non-NULL */
types.c:  code = f ? ((ptr_definition)c)->code : (ptr_int_list)c;
types.c:  /* This rather time-consuming analysis is necessary if both objects */
types.c:  /* have non-NULL value fields.  Note that only those objects with a */
types.c:  /* non-NULL value field needed for disentailment are looked at.     */
types.c:  if (sub_CodeType(code,real->code)) {
types.c:  else if (sub_CodeType(code,quoted_string->code)) {
types.c:  This is needed to correctly handle psi-terms that don't have a sort code
types.c:  cd1=(ptr_int_list)(f1?(GENERIC)((ptr_definition)c1)->code:c1);
types.c:  cd2=(ptr_int_list)(f2?(GENERIC)((ptr_definition)c2)->code:c2);
types.c:    else if (cd2==top->code) {
types.c:  else if (cd1==top->code) {
types.c:    if (cd2==top->code) {
types.c:  else if (cd2==top->code) {
types.c:    (*cd3)->next=NULL;
types.c:    v1=(unsigned long)(cd1->value);
types.c:    v2=(unsigned long)(cd2->value);
types.c:    (*cd3)->value=(GENERIC)v3;
types.c:    cd1=cd1->next;
types.c:    cd2=cd2->next;
types.c:    cd3= &((*cd3)->next);
types.c:       t1->keyword->combined_name,
types.c:       t2->keyword->combined_name); */
types.c:    c1=t1->code;
types.c:    c2=t2->code;
types.c:        (*c3)->next=NULL;
types.c:        v1=(unsigned long)(c1->value);
types.c:        v2=(unsigned long)(c2->value);
types.c:        (*c3)->value=(GENERIC)v3;
types.c:        c1=c1->next;
types.c:        c2=c2->next;
types.c:        c3= &((*c3)->next);
types.c:    c1=t1->code;
types.c:    c2=t2->code;
types.c:        result=(((unsigned long)(c1->value)) & ((unsigned long)(c2->value)));
types.c:        c1=c1->next;
types.c:        c2=c2->next;
types.c:  printf("overlap_type(%s,%s) => %ld\n",t1->def->keyword->symbol,t2->def->keyword->symbol,result);
types.c:      if ((unsigned long)c1->value & ~(unsigned long)c2->value) return FALSE;
types.c:      c1=c1->next;
types.c:      c2=c2->next;
types.c:        return sub_CodeType(t1->code, t2->code);
types.c:        c1=t1->code;
types.c:        c2=t2->code;
types.c:            if ((unsigned long)c1->value &  (unsigned long)c2->value) result=TRUE;
types.c:            if ((unsigned long)c1->value & ~(unsigned long)c2->value) *smaller=FALSE;
types.c:            c1=c1->next;
types.c:            c2=c2->next;
types.c:  be passed the whole psi-term.
types.c:  result=matches(t1->type,t2->type,&sm);
types.c:    /* At this point, t1->type <| t2->type */
types.c:    if (t1->type==t2->type) {
types.c:      if (t1->value!=NULL && t2->value==NULL)
types.c:    v=(unsigned long)c->value;
types.c:    c=c->next;
types.c:    p--;
types.c:    c2=gamma_table[p]->code;
types.c:      prev= &(c3->next);
types.c:      c3->value=(GENERIC)(((unsigned long)(c->value)) & ~((unsigned long)(c2->value)));
types.c:      c=c->next;
types.c:      c2=c2->next;
xdisplaylist.c:    return &((Line *) elt)->links;
xdisplaylist.c:    elt->action = action;
xdisplaylist.c:    elt->x0 = x0;
xdisplaylist.c:    elt->y0 = y0;
xdisplaylist.c:    elt->x1 = x1;
xdisplaylist.c:    elt->y1 = y1;
xdisplaylist.c:    elt->function = function;
xdisplaylist.c:    elt->color = color;
xdisplaylist.c:    elt->linewidth = linewidth;
xdisplaylist.c:    elt->action = action;
xdisplaylist.c:    elt->x = x;
xdisplaylist.c:    elt->y = y;
xdisplaylist.c:    elt->width = width;
xdisplaylist.c:    elt->height = height;
xdisplaylist.c:    elt->startangle = startangle;
xdisplaylist.c:    elt->arcangle = arcangle;
xdisplaylist.c:    elt->function = function;
xdisplaylist.c:    elt->color = color;
xdisplaylist.c:    elt->linewidth = linewidth;
xdisplaylist.c:    elt->action = action;
xdisplaylist.c:    elt->x = x;
xdisplaylist.c:    elt->y = y;
xdisplaylist.c:    elt->width = width;
xdisplaylist.c:    elt->height = height;
xdisplaylist.c:    elt->function = function;
xdisplaylist.c:    elt->color = color;
xdisplaylist.c:    elt->linewidth = linewidth;
xdisplaylist.c:    elt->action = action;
xdisplaylist.c:    elt->npoints = npoints;
xdisplaylist.c:    elt->points = p = (XPoint *) malloc (npoints*2*sizeof(short));
xdisplaylist.c:    for (; npoints > 0; npoints--, p++, points++)
xdisplaylist.c:    elt->function = function;
xdisplaylist.c:    elt->color = color;
xdisplaylist.c:    elt->linewidth = linewidth;
xdisplaylist.c:    elt->action = action;
xdisplaylist.c:    elt->x = x;
xdisplaylist.c:    elt->y = y;
xdisplaylist.c:    elt->str = (char *) malloc (strlen (str)+1); /* 11.9 */
xdisplaylist.c:    strcpy (elt->str, str);
xdisplaylist.c:    *(elt->str+strlen(str)) = '\0';
xdisplaylist.c:    elt->function = function;
xdisplaylist.c:    elt->color = color;
xdisplaylist.c:    elt->font = font;
xdisplaylist.c:    switch (elt->action)
xdisplaylist.c:	    x_set_gc (g->display, g->gc, line->function,
xdisplaylist.c:		      line->color, line->linewidth, xDefaultFont);
xdisplaylist.c:	    XDrawLine (g->display, g->drawable, g->gc,
xdisplaylist.c:		       line->x0, line->y0, line->x1, line->y1);
xdisplaylist.c:	    x_set_gc (g->display, g->gc, arc->function,
xdisplaylist.c:		      arc->color, arc->linewidth, xDefaultFont);
xdisplaylist.c:	    if (arc->action == DRAW_ARC)
xdisplaylist.c:	        XDrawArc (g->display, g->drawable, g->gc,
xdisplaylist.c:			  arc->x, arc->y, 
xdisplaylist.c:			  arc->width, arc->height,
xdisplaylist.c:			  arc->startangle, arc->arcangle);
xdisplaylist.c:	        XFillArc (g->display, g->drawable, g->gc,
xdisplaylist.c:			  arc->x, arc->y, 
xdisplaylist.c:			  arc->width, arc->height,
xdisplaylist.c:			  arc->startangle, arc->arcangle);
xdisplaylist.c:	    x_set_gc (g->display, g->gc, rectangle->function,
xdisplaylist.c:		      rectangle->color, rectangle->linewidth, xDefaultFont);
xdisplaylist.c:	    if (rectangle->action == DRAW_RECTANGLE)
xdisplaylist.c:	        XDrawRectangle (g->display, g->drawable, g->gc,
xdisplaylist.c:				rectangle->x, rectangle->y, 
xdisplaylist.c:				rectangle->width, rectangle->height);
xdisplaylist.c:	        XFillRectangle (g->display, g->drawable, g->gc,
xdisplaylist.c:				rectangle->x, rectangle->y, 
xdisplaylist.c:				rectangle->width, rectangle->height);
xdisplaylist.c:	    x_set_gc (g->display, g->gc, s->function,
xdisplaylist.c:		      s->color, xDefaultLineWidth, s->font);
xdisplaylist.c:	    if (s->action == DRAW_STRING)
xdisplaylist.c:	        XDrawString (g->display, g->drawable, g->gc,
xdisplaylist.c:			     s->x, s->y, 
xdisplaylist.c:			     s->str, strlen (s->str));
xdisplaylist.c:	        XDrawImageString (g->display, g->drawable, g->gc,
xdisplaylist.c:			     s->x, s->y, 
xdisplaylist.c:			     s->str, strlen (s->str));
xdisplaylist.c:	    x_set_gc (g->display, g->gc, polygon->function,
xdisplaylist.c:		      polygon->color, polygon->linewidth, xDefaultFont);
xdisplaylist.c:	    if (polygon->action == FILL_POLYGON)
xdisplaylist.c:	        XFillPolygon (g->display, g->drawable, g->gc,
xdisplaylist.c:			      polygon->points, polygon->npoints,
xdisplaylist.c:	        XDrawLines   (g->display, g->drawable, g->gc,
xdisplaylist.c:			      polygon->points, polygon->npoints,
xdisplaylist.c:   - jch - Thu Aug  6 16:58:22 MET DST 1992
xdisplaylist.c:    /* does not work with a pixmap, only with windows !! @#@^&%#(*&! - jch */
xdisplaylist.c:    switch (elt->action)
xdisplaylist.c:	    free (s->str);
xdisplaylist.c:	    free (polygon->points);
xdisplaylist.c:    "%!PS-Adobe-2.0\n",
xdisplaylist.c:    int ret; // added bacause of compiler warning - should be checked below 
xdisplaylist.c:    rgb->pixel = color;
xdisplaylist.c:    int ret; // added bacause of compiler warning - should be checked below 
xdisplaylist.c:    switch (elt->action)
xdisplaylist.c:	    pbuf = add_number (pbuf, line->x0);
xdisplaylist.c:	    pbuf = add_number (pbuf, psc->height - line->y0);
xdisplaylist.c:	    pbuf = add_number (pbuf, line->x1);
xdisplaylist.c:	    pbuf = add_number (pbuf, psc->height - line->y1);
xdisplaylist.c:	    x_get_rgb_values (psc->display, psc->window, line->color, &color);
xdisplaylist.c:	    pbuf = add_number (pbuf, line->linewidth);
xdisplaylist.c:	    ret = write (psc->f, pbuf, strlen (pbuf));
xdisplaylist.c:	    pbuf = add_number (pbuf, rectangle->x);
xdisplaylist.c:	    pbuf = add_number (pbuf, psc->height - rectangle->y);
xdisplaylist.c:	    pbuf = add_number (pbuf, rectangle->width);
xdisplaylist.c:	    pbuf = add_number (pbuf, rectangle->height);
xdisplaylist.c:	    x_get_rgb_values (psc->display, psc->window, rectangle->color, &color);
xdisplaylist.c:	    if (rectangle->action == DRAW_RECTANGLE)
xdisplaylist.c:		pbuf = add_number (pbuf, rectangle->linewidth);
xdisplaylist.c:	    ret = write (psc->f, pbuf, strlen (pbuf));
xdisplaylist.c:	    pbuf = add_number (pbuf, arc->x+arc->width/2);
xdisplaylist.c:	    pbuf = add_number (pbuf, psc->height - (arc->y+arc->height/2));
xdisplaylist.c:	    pbuf = add_number (pbuf, arc->width/2);
xdisplaylist.c:	    pbuf = add_number (pbuf, arc->height/2);
xdisplaylist.c:	    pbuf = add_number (pbuf, arc->startangle);
xdisplaylist.c:	    pbuf = add_number (pbuf, (arc->startangle+arc->arcangle)/64);
xdisplaylist.c:	    x_get_rgb_values (psc->display, psc->window, arc->color, &color);
xdisplaylist.c:	    if (arc->action == DRAW_ARC)
xdisplaylist.c:		pbuf = add_number (pbuf, arc->linewidth);
xdisplaylist.c:	    ret = write (psc->f, pbuf, strlen (pbuf));
xdisplaylist.c:	    pbuf = add_number (pbuf, s->x);
xdisplaylist.c:	    pbuf = add_number (pbuf, psc->height - s->y);
xdisplaylist.c:	    pbuf = add_string (pbuf, s->str);
xdisplaylist.c:	    x_get_rgb_values (psc->display, psc->window, s->color, &color);
xdisplaylist.c:	    if (s->action == DRAW_STRING)
xdisplaylist.c:	    ret = write (psc->f, pbuf, strlen (pbuf));
xdisplaylist.c:	    x_get_rgb_values (psc->display, psc->window, polygon->color, &color);
xdisplaylist.c:	    p = polygon->points;
xdisplaylist.c:	    pbuf = add_number (pbuf, p->x);
xdisplaylist.c:	    pbuf = add_number (pbuf, psc->height - p->y);
xdisplaylist.c:	    for (i=1; i<polygon->npoints; i++, p++)
xdisplaylist.c:		pbuf = add_number (pbuf, p->x);
xdisplaylist.c:		pbuf = add_number (pbuf, psc->height - p->y);
xdisplaylist.c:	    ret = write (psc->f, pbuf, strlen (pbuf));
xdisplaylist.c:    int ret; // added bacause of compiler warning - should be checked below 
xdisplaylist.c:		   S_IRUSR|S_IWUSR|S_IRWXG)) == -1)
xpred.c:  XGetErrorText(display,x_error->error_code,msg,128);
xpred.c:     jch - Fri Aug  7 17:58:27 MET DST 1992
xpred.c:  n=find(FEATURECMP,perm,t->attr_list);
xpred.c:    t1=(ptr_psi_term)n->data;
xpred.c:    if(!t1->value) {
xpred.c:      push_ptr_value(int_ptr,(GENERIC *)&(t1->value));
xpred.c:      t1->value=heap_alloc(sizeof(REAL));
xpred.c:    *(REAL *)t1->value =(REAL) value;
xpred.c:    t1->type=integer;
xpred.c:    t1->value=heap_alloc(sizeof(REAL));
xpred.c:    *(REAL *)t1->value =(REAL) value;
xpred.c:    bk_stack_insert(FEATURECMP,(GENERIC)perm,&(t->attr_list),(GENERIC)t1);
xpred.c:  n=find(FEATURECMP,perm,t->attr_list);
xpred.c:    t1=(ptr_psi_term)n->data;
xpred.c:    /*push_ptr_value(psi_term_ptr,(GENERIC *)&(t1->coref));*/
xpred.c:      value->coref=t1;
xpred.c:    bk_stack_insert(FEATURECMP,(GENERIC)perm,&(t->attr_list),(GENERIC)value);
xpred.c:  push_ptr_value(int_ptr,(GENERIC *)&(t->value));
xpred.c:  t->value = heap_alloc(sizeof(REAL));
xpred.c:  *(REAL *) t->value = v;
xpred.c:  matches(t->type,integer,&smaller);
xpred.c:      push_ptr_value(def_ptr,(GENERIC *)&(t->type));
xpred.c:      t->type = integer;
xpred.c:      t->status = 0;
xpred.c:      if(t->resid)
xpred.c:/* build a psi-term of type t with a feature f of value v */
xpred.c:  p->type = t;
xpred.c:/* return the value of the attribute attributeName on the psi-term psiTerm */
xpred.c:  nodeAttr=find(FEATURECMP,attributeName,psiTerm->attr_list);
xpred.c:  psiValue=(ptr_psi_term)nodeAttr->data;
xpred.c:  if(psiValue->value)
xpred.c:    return *(REAL *) psiValue->value;
xpred.c:    return -34466; /* Real nasty hack for now  RM: Apr 23 1993  */
xpred.c:/* return the psi-term of the attribute attributeName on the psi-term psiTerm */
xpred.c:  if((nodeAttr = find(FEATURECMP,attributeName,psiTerm->attr_list)) == NULL)
xpred.c:      Errorline("in GetPsiAttr: no attribute name on psi-term ?\n");
xpred.c:  if((psiValue =(ptr_psi_term) nodeAttr->data) == NULL)
xpred.c:      Errorline("in GetPsiAttr: no value on psi-term ?\n");
xpred.c:  xcOpenConnection(+Name,-Connection)
xpred.c:  xcDefaultRootWindow(+Display,-Root)
xpred.c:      *attribute =(unsigned long)(display->proto_major_version);
xpred.c:      *attribute =(unsigned long)(display->proto_minor_version);
xpred.c:      *attribute =(unsigned long)(display->qlen);
xpred.c:      *attribute =(unsigned long)(display->request);
xpred.c:      *attribute =(unsigned long)(display->min_keycode);
xpred.c:      *attribute =(unsigned long)(display->max_keycode);
xpred.c:  xcGetConnectionAttribute(+Display,+AttributeId,-Value)
xpred.c:  xcGetScreenAttribute(+Display,+Screen,+AttributeId,-Value)
xpred.c:  +Permanent,+Show,-Window)
xpred.c:      psiWindow->type = xwindow;
xpred.c:  I just keep this code in case - jch - Thu Aug  6 16:11:23 MET DST 1992
xpred.c:    +Permanent,+Show,-Window)
xpred.c:  xcGetWindowGeometry(+Display,+Window,-X,-Y,-Width,-Height)
xpred.c:  xcGetWindowAttribute(+Display,+Window,+AttributeId,-Value)
xpred.c:  map the sub-windows on the display Connection.
xpred.c:  unmap the sub-windows on the display Connection.
xpred.c:  if(!strcmp(psi->type->keyword->symbol,"true"))
xpred.c:      exit_life(TRUE); /* was: main_loop_ok=FALSE; - jch */
xpred.c:  xcCreateGC(+Connection,+Drawable,-GC)
xpred.c:      *attribute = gc->values.function;
xpred.c:      *attribute = gc->values.plane_mask;
xpred.c:      *attribute = gc->values.foreground;
xpred.c:      *attribute = gc->values.background;
xpred.c:      *attribute = gc->values.line_width;
xpred.c:      *attribute = gc->values.line_style;
xpred.c:      *attribute = gc->values.cap_style;
xpred.c:      *attribute = gc->values.join_style;
xpred.c:      *attribute = gc->values.fill_style;
xpred.c:      *attribute = gc->values.fill_rule;
xpred.c:      *attribute = gc->values.tile;
xpred.c:      *attribute = gc->values.stipple;
xpred.c:      *attribute = gc->values.ts_x_origin;
xpred.c:      *attribute = gc->values.ts_y_origin;
xpred.c:      *attribute = gc->values.font;
xpred.c:      *attribute = gc->values.subwindow_mode;
xpred.c:      *attribute = gc->values.graphics_exposures;
xpred.c:      *attribute = gc->values.clip_x_origin;
xpred.c:      *attribute = gc->values.clip_y_origin;
xpred.c:      *attribute = gc->values.clip_mask;
xpred.c:      *attribute = gc->values.dash_offset;
xpred.c:      *attribute =(unsigned char)(gc->values.dashes);
xpred.c:      *attribute = gc->values.arc_mode;
xpred.c:      *attribute = gc->rects;
xpred.c:      *attribute = gc->dashes;
xpred.c:  xcGetGCAttribute(+GC,+AttributeId,-Val)
xpred.c:  xcRequestColor(+Connection,+ColorMap,+Red,+Green,+Blue,-Pixel)
xpred.c:  xcRequestNamedColor(+Connection,+ColorMap,+Name,-Pixel)
xpred.c:  draw a line(X0,Y0) ->(X1,Y1)
xpred.c:  xcPointsAlloc(+NbPoints,-Points)
xpred.c:  xcLoadFont(+Connection,+Name,-Font)
xpred.c:      unify_real_result(aim->b,(REAL) overall.width);
xpred.c:  bk_stack_add_int_attr(psiEvent,"display",event->xany.display);
xpred.c:  bk_stack_add_int_attr(psiEvent,"window",event->xany.window);
xpred.c:  switch(event->type) {
xpred.c:    psiEvent->type = xkeyboard_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"x",event->xkey.x);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y",event->xkey.y);
xpred.c:    bk_stack_add_int_attr(psiEvent,"state",event->xkey.state);
xpred.c:    psiEvent->type = xbutton_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"x",event->xbutton.x);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y",event->xbutton.y);
xpred.c:    bk_stack_add_int_attr(psiEvent,"x_root",event->xbutton.x_root);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y_root",event->xbutton.y_root);
xpred.c:    bk_stack_add_int_attr(psiEvent,"state",event->xbutton.state);
xpred.c:    bk_stack_add_int_attr(psiEvent,"button",event->xbutton.button);
xpred.c:    psiEvent->type = xexpose_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"width",event->xexpose.width);
xpred.c:    bk_stack_add_int_attr(psiEvent,"height",event->xexpose.height);
xpred.c:    psiEvent->type = xdestroy_event;
xpred.c:    psiEvent->type = xmotion_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"x",event->xbutton.x);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y",event->xbutton.y);
xpred.c:    bk_stack_add_int_attr(psiEvent,"x_root",event->xbutton.x_root);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y_root",event->xbutton.y_root);
xpred.c:    psiEvent->type = xconfigure_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"x",event->xconfigure.x);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y",event->xconfigure.y);
xpred.c:    bk_stack_add_int_attr(psiEvent,"width",event->xconfigure.width);
xpred.c:    bk_stack_add_int_attr(psiEvent,"height",event->xconfigure.height);
xpred.c:		       event->xconfigure.border_width);
xpred.c:    psiEvent->type = xenter_event;
xpred.c:    psiEvent->type = xleave_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"root",     event->xcrossing.root);
xpred.c:    bk_stack_add_int_attr(psiEvent,"subwindow",event->xcrossing.subwindow);
xpred.c:    bk_stack_add_int_attr(psiEvent,"x",event->xcrossing.x);
xpred.c:    bk_stack_add_int_attr(psiEvent,"y",event->xcrossing.y);
xpred.c:    bk_stack_add_int_attr(psiEvent,"focus",event->xcrossing.focus);
xpred.c:    bk_stack_add_int_attr(psiEvent,"state",event->xcrossing.state);
xpred.c:    psiEvent->type = xmisc_event;
xpred.c:    bk_stack_add_int_attr(psiEvent,"event_type",event->type);
xpred.c:/* some stuff to handle a list of psi-terms  */
xpred.c:/*  RM: Dec 15 1992   Re-written to handle new list structure */
xpred.c:  return lst->type==nil;
xpred.c:  if(lst->type==alist) {
xpred.c:    get_two_args(lst->attr_list,&car,&cdr);
xpred.c:  if(lst->type==alist) {
xpred.c:    get_two_args(lst->attr_list,&car,&cdr);
xpred.c:  stack_insert(FEATURECMP,(GENERIC)one,&(lst->attr_list),(GENERIC)value);
xpred.c:  stack_insert(FEATURECMP,(GENERIC)two,&(lst->attr_list),(GENERIC)value);
xpred.c:  push_ptr_value_global(psi_term_ptr,(GENERIC *)&(end->coref));
xpred.c:  end->coref=stack_cons(value,stack_nil());
xpred.c:  return end->coref;
xpred.c:/*  RM: Dec 15 1992  Re-written for new lists */
xpred.c:      push_ptr_value_global(psi_term_ptr,(GENERIC *)&(lst->coref));
xpred.c:      lst->coref=cdr;
xpred.c:  return !((Display *)GetIntAttr(psiEvent,"display") == closure->display
xpred.c:	   && (Window)GetIntAttr(psiEvent,"window") == closure->window
xpred.c:	   &&(GetIntAttr(psiEvent,"mask") & closure->mask) != 0);
xpred.c:  result=aim->b;
xpred.c:    /* transform the request into a psi-term */
xpred.c:    /* stack_insert(FEATURECMP,"event",&(eventElt->attr_list),(GENERIC)result); */
xpred.c:    /* return a psi-term containing an `empty' event */
xpred.c:       psiEvent->type = xevent;  RM: May  5 1993  */
xpred.c:    push_goal(unify,psiEvent,aim->b,NULL); /*  RM: May  5 1993  */
xpred.c:  /* push_goal(unify,psiEvent,aim->b,NULL);   RM: May  5 1993  */
xpred.c:  if ((Display *)GetIntAttr(psiEvent,"display") == closure->display
xpred.c:       && (Window)GetIntAttr(psiEvent,"window") ==closure->window
xpred.c:       && (GetIntAttr(psiEvent,"mask") & closure->mask) != 0)
xpred.c:  -root_return,  -child_return,
xpred.c:  -root_x_return,-root_y_return,
xpred.c:  -win_x_return, -win_y_return,
xpred.c:  -mask_return,  -same_screen)
xpred.c:  this predicate returns a psi-term containing loads of info about where the
xpred.c:  Set up the X built-in predicates.
xpred.c:/* not a built-in */
xpred.c:      if(nfds == -1)
xpred.c:		if((nbchar = read(stdin_fileno,&c,1)) == -1)
xpred.c:  if(c = saved_char) /* not an error ;-) */
xpred.c:/* returns the psi-event of the list corresponding to the existing event */
xpred.c:     xevent_name[type],xevent_name[event->type]); */
xpred.c:    Warningline("xevent_existing is non-null in x_build_existing_event");
xpred.c:  if(eventClosure->display == NULL) {
xpred.c:    eventClosure->display = display;
xpred.c:    eventClosure->window = window;
xpred.c:    eventClosure->mask = mask;
xpred.c:    eventClosure->beginSpan = eventElt;
xpred.c:    if(eventClosure->display == display && eventClosure->window == window) {
xpred.c:      eventClosure->mask |= mask;
xpred.c:      if(XCheckWindowEvent(eventClosure->display,eventClosure->window,
xpred.c:			     eventClosure->mask,&event)
xpred.c:	  /* && event.xany.window == eventClosure->window */)
xpred.c:	  /* build a psi-term containing the event */
xpred.c:				  eventClosure->beginSpan,
xpred.c:	  eventClosure->display = display;
xpred.c:	  eventClosure->window = window;
xpred.c:	  eventClosure->mask = mask;
xpred.c:	  eventClosure->beginSpan = eventElt;
xpred.c:/* not a built-in */
xpred.c:      /* build a psi-term containing the event */
xpred.c:  /* we need the psi-term window(not the value) to get the display list,the pixmap ...
xpred.c:     jch - Fri Aug  7 15:29:14 MET DST 1992
xpred.c:  direction,font-ascent,font-descent,
xpred.c:  left-bearing,right-bearing,width,ascent,descent)
xpred.c:  types[3] = real;   /* -Direction     */
xpred.c:  types[4] = real;   /* -Font-ascent   */
xpred.c:  types[5] = real;   /* -Font-descent  */
xpred.c:  types[6] = real;   /* -left bearing  */
xpred.c:  types[7] = real;   /* -right bearing */
xpred.c:  types[8] = real;   /* -width         */
xpred.c:  types[9] = real;   /* -ascent        */
xpred.c:  types[10]= real;   /* -descent       */
xpred.c:  if((resid = psiTerm->resid) == NULL)
xpred.c:  if(resid->next != NULL)
xpred.c:  if((aim = resid->goal) == NULL)
