algol68g.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
algol68g.c:  new_one->module = this;
algol68g.c:  new_one->next = *top;
algol68g.c:| c:		string to match, leading '-' or caps in c are mandatory
algol68g.c:  while ((isupper_unsc (*c) || isdigit_unsc (*c) || *c == '-') && match)
algol68g.c:| function:	isolate nodes p-q making p a branch to p-q
algol68g.c:      z->num = node_count++;
algol68g.c:      SYMBOL_TABLE *s = n->symbol_table;
algol68g.c:      if (s != NULL && s->level == i)
algol68g.c:      sprintf (textline, "\n%s(%02d) %-24s %5.2f %s", STARS, phase.k, phase.current,
algol68g.c:      timdif = phase.stop[k] - phase.start[k];
algol68g.c:      memdif = phase.himem[k] - phase.lomem[k];
algol68g.c:      sprintf (textline, "\n%s\t%-24s %5.2f %10d", BARS, phase.text[k], timdif, memdif);
algol68g.c:  sprintf (textline, "\n%s\t%-24s %5.2f %10d total", BARS, "", timsum, memsum);
algol68g.c:      p->info->PROCEDURE_LEVEL = l;
algol68g.c:      p->info->PROCEDURE_NUMBER = k;
algol68g.c:	  p->info->PROCEDURE_NUMBER = *k;
algol68g.c:      p->num = (*c)++;
algol68g.c:	    if (t->info->PROCEDURE_LEVEL < LINE (t)->min_proc_level)
algol68g.c:		LINE (t)->min_proc_level = t->info->PROCEDURE_LEVEL;
algol68g.c:	    if (t->info->PROCEDURE_LEVEL > LINE (t)->max_proc_level)
algol68g.c:		LINE (t)->max_proc_level = t->info->PROCEDURE_LEVEL;
algol68g.c:	    if (t->symbol_table != NULL && (t->symbol_table->level < LINE (t)->min_level))
algol68g.c:		LINE (t)->min_level = t->symbol_table->level;
algol68g.c:	    if (t->symbol_table != NULL && (t->symbol_table->level > LINE (t)->max_level))
algol68g.c:		LINE (t)->max_level = t->symbol_table->level;
algol68g.c:	  NODE *u = SUB (p->sub);
algol68g.c:	  if (u->info->PROCEDURE_NUMBER != TAX (u)->node->info->PROCEDURE_NUMBER)
algol68g.c:	      TAX (u)->priority = EXTERN_LABEL;
algol68g.c:	  TAX (u)->use = A_TRUE;
algol68g.c:	  if (u->info->PROCEDURE_NUMBER != TAX (u)->node->info->PROCEDURE_NUMBER)
algol68g.c:	      TAX (u)->priority = EXTERN_LABEL;
algol68g.c:	  TAX (u)->use = A_TRUE;
algol68g.c:  (*n)->attribute = 0;
algol68g.c:  (*n)->num = m;
algol68g.c:  (*n)->pack = NULL;
algol68g.c:  (*n)->sub = NULL;
algol68g.c:  (*n)->deflexed_mode = NULL;
algol68g.c:  (*n)->name = NULL;
algol68g.c:  (*n)->slice = NULL;
algol68g.c:      t->size = moid_size (TYPE (t));
algol68g.c:      if (t->value == NULL)
algol68g.c:	  t->offset = sum;
algol68g.c:	  sum += t->size;
algol68g.c:  A_ADDR k = assign_offset_tags (c->operators, 0);
algol68g.c:  k = assign_offset_tags (c->identifiers, k);
algol68g.c:  c->ap_increment = assign_offset_tags (c->anonymous, k);
algol68g.c:	  assign_offsets_table (SUB (p)->symbol_table);
algol68g.c:	  PACK *p = TYPE (q)->pack;
algol68g.c:	      p->size = moid_size (TYPE (p));
algol68g.c:	      p->offset = offset;
algol68g.c:	      offset += p->size;
algol68g.c:	      SUB (p)->symbol_table->jump_to = NULL;
algol68g.c:	  TAX (p)->unit = unit;
algol68g.c:      p->no_sweep = NULL;
algol68g.c:		TAG *z = add_tag (p->symbol_table, Anonymous, p,
algol68g.c:		p->no_sweep = z;
algol68g.c:		z->use = A_TRUE;
algol68g.c:	  compile_time = seconds () - compile_time;
algol68g.c:/* TOP-DOWN PARSER */
algol68g.c:	  stand_env->level = 0;
algol68g.c:      a68_prog.top_node->symbol_table = new_symbol_table (stand_env);
algol68g.c:/* BOTTOM-UP PARSER */
algol68g.c:	  a68_prog.top_node->symbol_table->nest = symbol_table_count = 3;
algol68g.c:  compile_time = seconds () - compile_time;
coercion.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
coercion.c:      while (ATTRIBUTE (p) == _REF_ || (ATTRIBUTE (p) == _PROC_ && p->pack == NULL))
coercion.c:	PACK *t = p->pack;
coercion.c:      PACK *q = p->pack;
coercion.c:  else if (ATTRIBUTE (p) == _PROC_ && (p)->pack == NULL)
coercion.c:  while (ATTRIBUTE (p) == _REF_ || (ATTRIBUTE (p) == _PROC_ && p->pack == NULL))
coercion.c:  return (p->name != NULL ? Deflex (SUB (p))->attribute == _STRUCT_ : A_FALSE);
coercion.c:  PACK *pt = p->pack;
coercion.c:      PACK *qt = q->pack;
coercion.c:	  PACK *t = q->pack;
coercion.c:      PACK *pt = p->pack;
coercion.c:	  PACK *qt = q->pack;
coercion.c:      PACK *qt = q->pack;
coercion.c:      return (ATTRIBUTE (p) == _PROC_ && p->pack == NULL);
coercion.c:  else if (ATTRIBUTE (p) == _PROC_ && p->pack == NULL)
coercion.c:  return (p->name != NULL ? Deflex (SUB (p))->attribute == _ROW_ : A_FALSE);
coercion.c:      return (is_strong_name (p, q->name));
coercion.c:  else if (q->slice != NULL)
coercion.c:      return (is_strong_slice (p, q->slice));
coercion.c:  else if (q->slice != NULL && is_strong_slice (p, q))
coercion.c:	  PACK *pt = p->pack;
coercion.c:	      j &= is_coercible (TYPE (pt), SUB (q)->slice, c, allowed_coercion);
coercion.c:	  PACK *pt = p->pack;
coercion.c:	      j &= is_coercible (TYPE (pt), q->slice, c, allowed_coercion);
coercion.c:	  PACK *pt = p->pack, *qt = q->pack;
coercion.c:	  if (p->dim != q->dim)
coercion.c:      PACK *pt = p->pack;
coercion.c:	  p1 = p->has_ref ? p : Deflex (p);
coercion.c:	  q1 = q->has_ref ? q : Deflex (q);
coercion.c:	  p1 = p->has_ref ? p : Deflex (p);
coercion.c:	  q1 = q->has_ref ? q : Deflex (q);
coercion.c:  if (p->sort != q->sort)
coercion.c:      return (is_coercible (TYPE (p), TYPE (q), q->sort, allowed_coercion));
coercion.c:  s->sort = sort;
coercion.c:  s->cast = A_FALSE;
coercion.c:	  SOID *z = y->yield;
coercion.c:	  if (!(z->sort == Strong && TYPE (z) == Mode (HIP)))
coercion.c:	  PACK *s = TYPE (t)->pack;
coercion.c:	  absorb_series_pack (TYPE (t)->pack, mods);
coercion.c:	  t->text = s->text;
coercion.c:	      add_mode_to_pack (&NEXT (t), TYPE (s), s->text, s->node);
coercion.c:  absorb_series_pack (m->pack, &mods);
coercion.c:  for (v = m->pack; v != NULL; v = NEXT (v))
coercion.c:      PACK *v = m->pack;
coercion.c:      for (u = m->pack; u != NULL; u = NEXT (u))
coercion.c:	  for (v = m->pack; v != NULL && go_on; v = NEXT (v))
coercion.c:  absorb_series_pack (m->pack, &mods);
coercion.c:  for (v = m->pack; v != NULL; v = NEXT (v))
coercion.c:      PACK *v = m->pack;
coercion.c:  add_mode_to_pack (&(series->pack), u, NULL, u->node);
coercion.c:  add_mode_to_pack (&(series->pack), v, NULL, v->node);
coercion.c:      absorb_series_pack (series->pack, &mods);
coercion.c:  series->dim = count_pack_members (series->pack);
coercion.c:  if (series->dim == 1)
coercion.c:      return (TYPE (series->pack));
coercion.c:  absorb_series_pack (m->pack, &mods);
coercion.c:  united->pack = NULL;
coercion.c:  v = united->pack;
coercion.c:  w = m->pack;
coercion.c:  for (w = m->pack; w != NULL; w = NEXT (w))
coercion.c:      add_mode_to_pack (&(united->pack), TYPE (w), NULL, m->node);
coercion.c:      united->dim = count_pack_members (united->pack);
coercion.c:      absorb_union_pack (united->pack, &mods);
coercion.c:  if (true_union && united->dim == 1)
coercion.c:      united = TYPE (united->pack);
coercion.c:      z->coming_from_level = NULL;
coercion.c:	  for (p = m->pack; p != NULL; p = NEXT (p))
coercion.c:		  while (k--)
coercion.c:			  j--;
coercion.c:		      for (q = m->pack; q != NULL && coerced_all; q = NEXT (q))
coercion.c:  if (x->cast == A_FALSE)
coercion.c:      add_soid_list (&(*root)->next, where, soid);
coercion.c:      new_one->where = where;
coercion.c:      new_one->yield = (SOID *) heap (size_of (SOID));
coercion.c:      make_soid (new_one->yield, soid->sort, TYPE (soid));
coercion.c:  new_one->num = mode_count++;
coercion.c:  new_one->dim = 0;
coercion.c:  new_one->equivalent_mode = NULL;
coercion.c:  new_one->slice = NULL;
coercion.c:  new_one->deflexed_mode = NULL;
coercion.c:  new_one->name = NULL;
coercion.c:  new_one->next = NULL;
coercion.c:  new_one->pack = NULL;
coercion.c:  p = &new_one->pack;
coercion.c:      TYPE (t) = TYPE (top_sl->yield);
coercion.c:      t->text = NULL;
coercion.c:      t->node = top_sl->where;
coercion.c:      new_one->dim++;
coercion.c:	  make_ref_rowing_coercion (n, p, q->name);
coercion.c:      else if (q->slice != NULL)
coercion.c:	  make_rowing_coercion (n, p, q->slice);
coercion.c:  else if (q->slice != NULL && is_strong_slice (p, q))
coercion.c:  else if (ATTRIBUTE (p) == _PROC_ && p->pack == NULL)
coercion.c:  if (ATTRIBUTE (p) == _PROC_ && p->pack == NULL)
coercion.c:		if (ATTRIBUTE (z) == _PROC_ && p->pack == NULL)
coercion.c:      warror (A_ERR, NEXT (NEXT (p)), CANNOT_COERCE_ERROR, y->type, w.type, Strong);
coercion.c:  if (is_balanced (p, top_sl, x->sort))
coercion.c:      make_soid (y, x->sort, result);
coercion.c:      make_soid (y, x->sort, TYPE (x) != NULL ? TYPE (x) : Mode (ERROR));
coercion.c:	      make_soid (&x, Strong, (*fields)->type);
coercion.c:	  MOID *m = NEXT (SUB (p))->type;
coercion.c:	  add_mode_to_pack (&(u->pack), m, NULL, m->node);
coercion.c:	  MOID *m = NEXT (SUB (p))->type;
coercion.c:	      k = is_coercible_to_component (m, TYPE (top->yield), COERCE_STRICT)
coercion.c:		|| is_united_subset (TYPE (top->yield), m)
coercion.c:		|| is_united_subset (m, TYPE (top->yield));
coercion.c:		  where = top->yield;
coercion.c:	      warror (A_ERR, p, "M cannot be united to M", where->type, m);
coercion.c:	  make_soid (&y, x->sort, SUB (TYPE (x))->slice);
coercion.c:	  make_soid (&y, x->sort, TYPE (x)->slice);
coercion.c:	  PACK *y = TYPE (x)->pack;
coercion.c:	  if (x->sort == Strong)
coercion.c:  if (!is_balanced (p, top_sl, x->sort))
coercion.c:	  make_soid (y, x->sort, TYPE (x));
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:      make_soid (y, x->sort, z);
coercion.c:  if (!is_balanced (p, top_sl, x->sort))
coercion.c:	  make_soid (y, x->sort, TYPE (x));
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:      make_soid (y, x->sort, z);
coercion.c:      while (ATTRIBUTE (u) == _REF_ || (ATTRIBUTE (u) == _PROC_ && u->pack == NULL))
coercion.c:  SUB (p)->type = u;
coercion.c:  if (!is_balanced (p, top_sl, x->sort))
coercion.c:	  make_soid (y, x->sort, TYPE (x));
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:      make_soid (y, x->sort, z);
coercion.c:	  NEXT (SUB (p))->type = Mode (VOID);
coercion.c:      if (SYMBOL (t->node) == n)
coercion.c:	  PACK *p = TYPE (t)->pack;
coercion.c:	  if (t->symbol_table == stand_env)
coercion.c:		  if (t->symbol_table == stand_env)
coercion.c:      TAG *z = find_operator_in_table (s->operators, n, lhs, rhs, lsort, rsort,
coercion.c:      s = s->previous;
coercion.c:  z = find_operator_in_table (stand_env->operators, n, u, u, Firm, Firm, COERCE_NORMAL);
coercion.c:  z = find_operator_in_table (stand_env->operators, n, u, u, Firm, Firm, COERCE_NORMAL);
coercion.c:      PACK *v = TYPE (t)->pack;
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:	  t = find_operator (p->symbol_table, SYMBOL (p), TYPE (y), NULL);
coercion.c:	      make_soid (y, x->sort, Mode (ERROR));
coercion.c:	      make_soid (y, x->sort, SUB (TYPE (t)));
coercion.c:	      make_soid (y, x->sort, Mode (ERROR));
coercion.c:  check_secondary (NEXT (p)->sub, &e, y);
coercion.c:  make_soid (y, x->sort, TYPE (y));
coercion.c:      make_soid (y, x->sort, ls.type);
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:	  op = find_operator (NEXT (p)->symbol_table, SYMBOL (NEXT (p)), ls.type, rs.type);
coercion.c:	      make_soid (y, x->sort, Mode (ERROR));
coercion.c:	      make_soid (y, x->sort, SUB (TYPE (op)));
coercion.c:	      make_soid (y, x->sort, Mode (ERROR));
coercion.c:  while (ATTRIBUTE (name_moid) == _PROC_ && name_moid->pack == NULL)
coercion.c:      make_soid (y, x->sort, Mode (ERROR));
coercion.c:      make_soid (y, x->sort, Mode (ERROR));
coercion.c:      make_soid (y, x->sort, name_moid);
coercion.c:  while (ATTRIBUTE (lhs) == _PROC_ && lhs->pack == NULL)
coercion.c:  while (ATTRIBUTE (rhs) == _PROC_ && rhs->pack == NULL)
coercion.c:  make_soid (y, x->sort, Mode (BOOL));
coercion.c:  make_soid (y, x->sort, Mode (BOOL));
coercion.c:  check_enclosed (NEXT (p)->sub, &w, y);
coercion.c:      warror (A_ERR, NEXT (p), CANNOT_COERCE_ERROR, y->type, w.type, Strong);
coercion.c:  make_soid (y, x->sort, TYPE (p));
coercion.c:  while (ATTRIBUTE (n) == _REF_ || (ATTRIBUTE (n) == _PROC_ && n->pack == NULL))
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:      make_soid (y, x->sort, n);
coercion.c:      check_argument_list_2 (p, n->pack, &d);
coercion.c:      if (d.type->dim != n->dim)
coercion.c:	  if (n->dim == 1)
coercion.c:	      warror (A_ERR, p, "call of M requires D argument", n, n->dim);
coercion.c:	      warror (A_ERR, p, "call of M requires D arguments", n, n->dim);
coercion.c:	  make_soid (y, x->sort, Mode (ERROR));
coercion.c:	  make_soid (y, x->sort, SUB (n));
coercion.c:	 || (ATTRIBUTE (n) == _PROC_ && n->pack == NULL))
coercion.c:  if (n == NULL || !(Deflex (n)->slice != NULL || is_ref_row (n)))
coercion.c:      make_soid (y, x->sort, Mode (ERROR));
coercion.c:      rowdim = Deflex (SUB (n))->dim;
coercion.c:      rowdim = Deflex (n)->dim;
coercion.c:      make_soid (y, x->sort, Mode (ERROR));
coercion.c:	      m = m->name;
coercion.c:	      m = m->slice;
coercion.c:	  subs--;
coercion.c:      make_soid (y, x->sort, ANNOTATION (NEXT (p)) == Trimmer && m->deflexed_mode != NULL ? m->deflexed_mode : m);
coercion.c:      make_soid (y, x->sort, ANNOTATION (NEXT (p)) == Trimmer && m->trim != NULL ? m->trim : m);
coercion.c:	  t = n->pack;
coercion.c:      else if (n->multiple_mode != NULL)
coercion.c:	  t = n->multiple_mode->pack;
coercion.c:	  t = n->name->pack;
coercion.c:      make_soid (y, x->sort, Mode (ERROR));
coercion.c:  t_2 = str->pack;
coercion.c:      if (t->text == fs)
coercion.c:	  make_soid (y, x->sort, TYPE (t));
coercion.c:	  SUB (p)->pack = t_2;
coercion.c:  make_soid (y, x->sort, Mode (ERROR));
coercion.c:	  make_soid (y, x->sort, SUB (p)->type);
coercion.c:	  make_soid (y, x->sort, TYPE (p));
coercion.c:	  make_soid (y, x->sort, SUB (p)->type);
coercion.c:	    make_soid (y, x->sort, TYPE (p));
coercion.c:	  coerce_routine_text (NEXT (NEXT (p))->sub);
coercion.c:  make_soid (&w, Meek, SUB (p)->type);
coercion.c:  SUB (p)->type = NULL;
coercion.c:	  make_soid (&s, Strong, (*r)->type);
coercion.c:	  (*r) = (*r)->next;
coercion.c:	  PACK *t = TYPE (q)->pack;
coercion.c:	  make_soid (&w, Strong, SUB (TYPE (q))->slice);
coercion.c:	  make_soid (&w, Strong, TYPE (q)->slice);
coercion.c:	  return (TYPE (TYPE (p)->pack));
coercion.c:  coerce_secondary (NEXT (p)->sub, &e);
coercion.c:  NEXT (p)->type = TYPE (NEXT (p)->sub);
coercion.c:	  MOID *opmoid = TAX (NEXT (p))->type;
coercion.c:	  make_soid (&w, Strong, TYPE (opmoid->pack));
coercion.c:	  make_soid (&w, Strong, TYPE (NEXT (opmoid->pack)));
coercion.c:	  TYPE (p) = SUB (p)->type;
coercion.c:  make_soid (&w, Strong, NEXT (NEXT (p))->type);
coercion.c:  coerce_tertiary (NEXT (NEXT (p))->sub, &w);
coercion.c:  coerce_tertiary (NEXT (NEXT (p))->sub, &w);
coercion.c:  make_soid (&w, /* Weak */ Strong, NEXT (p)->type);
coercion.c:  coerce_secondary (NEXT (p)->sub, &w);
coercion.c:	      TYPE (p) = SUB (p)->type;
coercion.c:  coerce_enclosed (NEXT (p)->sub, &w);
coercion.c:	  make_soid (&s, Strong, (*r)->type);
coercion.c:	  *r = (*r)->next;
coercion.c:  t = proc->pack;
coercion.c:  coerce_indexer (NEXT (p)->sub);
elems.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
elems.c:| init_elems_list:	initialise use of elems-lists
elems.c:| reset_elems_list:	make old elem-list available for new use
elems.c:| add_elem: 	add elements to elem-list
elems.c:| p:		head of elem-list
elems.c:  new_one->a = a;
elems.c:  new_one->b = b;
elems.c:| p:		head of elem-list
elems.c:      if (p->a == a && p->b == b)
elems.c:| p:		head of elem-list
elems.c:      if (p->a == a)
elems.c:  m->coming_from_level = c;
elems.c:      for (q = c->moids; q != NULL; q = NEXT (q))
elems.c:	      add_moid_list (q, SUB (p)->symbol_table);
env_cray.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      x->status = INITIALISED_MASK;
env_cray.c:      x->value = y.value;
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      x->value *= y.value;
env_cray.c: * need to make a copy - this routine is explicitly destructive when source and
env_cray.c:  b_b = (A_BYTE *) ref_to_ptr (&arr_b->array);
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_b->lwb - tup_b->shift) * tup_b->span + arr_b->slice_offset) * arr_b->elem_size +
env_cray.c:    arr_b->field_offset;
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_b = tup_b->span * arr_b->elem_size;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      x->status = INITIALISED_MASK;
env_cray.c:      x->value = y->value;
env_cray.c:  b_c = (A_BYTE *) ref_to_ptr (&arr_c->array);
env_cray.c:  b_b = (A_BYTE *) ref_to_ptr (&arr_b->array);
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_c->lwb - tup_c->shift) * tup_c->span + arr_c->slice_offset) * arr_c->elem_size +
env_cray.c:    arr_c->field_offset;
env_cray.c:    ((tup_b->lwb - tup_b->shift) * tup_b->span + arr_b->slice_offset) * arr_b->elem_size +
env_cray.c:    arr_b->field_offset;
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_c = tup_c->span * arr_c->elem_size;
env_cray.c:  inc_b = tup_b->span * arr_b->elem_size;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      x->status = INITIALISED_MASK;
env_cray.c:      x->value = y->value + z->value;
env_cray.c:  b_c = (A_BYTE *) ref_to_ptr (&arr_c->array);
env_cray.c:  b_b = (A_BYTE *) ref_to_ptr (&arr_b->array);
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_c->lwb - tup_c->shift) * tup_c->span + arr_c->slice_offset) * arr_c->elem_size +
env_cray.c:    arr_c->field_offset;
env_cray.c:    ((tup_b->lwb - tup_b->shift) * tup_b->span + arr_b->slice_offset) * arr_b->elem_size +
env_cray.c:    arr_b->field_offset;
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_c = tup_c->span * arr_c->elem_size;
env_cray.c:  inc_b = tup_b->span * arr_b->elem_size;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      x->status = INITIALISED_MASK;
env_cray.c:      x->value = y->value - z->value;
env_cray.c:  b_c = (A_BYTE *) ref_to_ptr (&arr_c->array);
env_cray.c:  b_b = (A_BYTE *) ref_to_ptr (&arr_b->array);
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_c->lwb - tup_c->shift) * tup_c->span + arr_c->slice_offset) * arr_c->elem_size +
env_cray.c:    arr_c->field_offset;
env_cray.c:    ((tup_b->lwb - tup_b->shift) * tup_b->span + arr_b->slice_offset) * arr_b->elem_size +
env_cray.c:    arr_b->field_offset;
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_c = tup_c->span * arr_c->elem_size;
env_cray.c:  inc_b = tup_b->span * arr_b->elem_size;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      x->status = INITIALISED_MASK;
env_cray.c:      x->value = y->value * z->value;
env_cray.c:  b_c = (A_BYTE *) ref_to_ptr (&arr_c->array);
env_cray.c:  b_b = (A_BYTE *) ref_to_ptr (&arr_b->array);
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_c->lwb - tup_c->shift) * tup_c->span + arr_c->slice_offset) * arr_c->elem_size +
env_cray.c:    arr_c->field_offset;
env_cray.c:    ((tup_b->lwb - tup_b->shift) * tup_b->span + arr_b->slice_offset) * arr_b->elem_size +
env_cray.c:    arr_b->field_offset;
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_c = tup_c->span * arr_c->elem_size;
env_cray.c:  inc_b = tup_b->span * arr_b->elem_size;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      if (z->value == 0.0)
env_cray.c:      x->status = INITIALISED_MASK;
env_cray.c:      x->value = y->value / z->value;
env_cray.c:  b_b = (A_BYTE *) ref_to_ptr (&arr_b->array);
env_cray.c:  b_a = (A_BYTE *) ref_to_ptr (&arr_a->array);
env_cray.c:    ((tup_b->lwb - tup_b->shift) * tup_b->span + arr_b->slice_offset) * arr_b->elem_size +
env_cray.c:    arr_b->field_offset;
env_cray.c:    ((tup_a->lwb - tup_a->shift) * tup_a->span + arr_a->slice_offset) * arr_a->elem_size +
env_cray.c:    arr_a->field_offset;
env_cray.c:  inc_b = tup_b->span * arr_b->elem_size;
env_cray.c:  inc_a = tup_a->span * arr_a->elem_size;
env_cray.c:      real_to_mp (p, dfac, x->value * y->value, digits);
env_mp.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
env_mp.c:| This file contains a multi-precision (mp) library for Algol68G.
env_mp.c:| field of public-key cryptography, that has spawned a great deal of 
env_mp.c:| of the 9th Fermat number "2 ** 512 + 1", an 155-digit number.
env_mp.c:| D.M. Smith, "A Multiple-Precision Division Algorithm"
env_mp.c:| Mathematics of Computation 66 (1996) 157-163
env_mp.c:| D.M. Smith, "Efficient Multiple-Precision Evaluation of Elementary Functions"
env_mp.c:| Mathematics of Computation 52 (1989) 131-134
env_mp.c:| user-definable precision. This library takes a sloppy approach towards 
env_mp.c:| can be made before overflow occurs - that's why we specify "MAX_REPR_INT".
env_mp.c:| (LONG_MP_DIGITS - 1) * LOG_MP_BASE + 1, since the most significant mp digit 
env_mp.c:static int mp_pi_size = -1;
env_mp.c:      warror (A_RTE, p, "multiple-precision exponent out of range (Z)", str, NULL);
env_mp.c:  while (--j >= 2)
env_mp.c:  sprintf (s, "%c0.%d", z[2] >= 0 ? '+' : '-', (int) fabs (z[2]));
env_mp.c:  strcat (s, expo >= 0 ? "E+" : "E-");
env_mp.c:  memset (&z[3], 0, (digits - 1) * size_of (mp_digit));
env_mp.c:| Cheap alternative to test "x = y", that is, "x - y = 0".
env_mp.c:  while (--k > 0)
env_mp.c:| Aligns a fresh 10-base "z" into a "MP_BASE" mantissa.
env_mp.c:      shift = LOG_MP_BASE - *expo % LOG_MP_BASE - 1;
env_mp.c:      shift = (-*expo - 1) % LOG_MP_BASE;
env_mp.c:      (*expo)--;
env_mp.c:  sign = s[0] == '-' ? -1 : 1;
env_mp.c:  if (s[0] == '+' || s[0] == '-')
env_mp.c:  comma = -1;
env_mp.c:	  int value = (int) s[i] - (int) '0';
env_mp.c:  expo += comma >= 0 ? comma - 1 : cijfers - 1;
env_mp.c:      expo = -expo;
env_mp.c:  int n = 0, j, sign_k = k >= 0 ? 1 : -1;
env_mp.c:      k = -k;
env_mp.c:  for (j = 2 + n; j >= 2; j--)
env_mp.c:      z[2] = -z[2];
env_mp.c:  for (j = 2 + expo; j >= 2; j--)
env_mp.c:  return (neg ? -sum : sum);
env_mp.c:  sign_x = x > 0 ? 1 : -1;
env_mp.c:  expo--;
env_mp.c:      a = a * 10 - y;
env_mp.c:      for (j = 2; j <= 1 + digits && (j - 3) * LOG_MP_BASE <= DBL_DIG; j++)
env_mp.c:      return (z[2] >= 0 ? sum : -sum);
env_mp.c:  for (j = 1 + digits; j > k; j--)
env_mp.c:	  mp_digit carry = (int) ((-wj - 1) / (double) MP_BASE) + 1;
env_mp.c:	  w[j - 1] = w[j - 1] - carry;
env_mp.c:	  w[j] = wj - carry * (double) MP_BASE;
env_mp.c:	  w[j - 1] = w[j - 1] + carry;
env_mp.c:      z[1] = w[1] - 1;
env_mp.c:      z[1] = w[1] - 1;
env_mp.c:	  x[2] = -x[2];
env_mp.c:	  z[2] = -z[2];
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y2 >= 0 ? 1 : -1;
env_mp.c:  if (sign_x == 1 && sign_y == -1)
env_mp.c:  else if (sign_x == -1 && sign_y == 1)
env_mp.c:  else if (sign_x == -1 && sign_y == -1)
env_mp.c:      z[2] = -z[2];
env_mp.c:	  shl_y = x[1] - y[1];
env_mp.c:	  shl_x = y[1] - x[1];
env_mp.c:	  int i_x = j - (int) shl_x;
env_mp.c:	  int i_y = j - (int) shl_y;
env_mp.c:      z[2] = -z[2];
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y2 >= 0 ? 1 : -1;
env_mp.c:  if (sign_x == 1 && sign_y == -1)
env_mp.c:  else if (sign_x == -1 && sign_y == 1)
env_mp.c:      z[2] = -z[2];
env_mp.c:  else if (sign_x == -1 && sign_y == -1)
env_mp.c:	  shl_y = x[1] - y[1];
env_mp.c:	  shl_x = y[1] - x[1];
env_mp.c:      first_non_zero = -1;
env_mp.c:	  int i_x = j - (int) shl_x;
env_mp.c:	  int i_y = j - (int) shl_y;
env_mp.c:	  w[k] = x_j - y_j;
env_mp.c:	      w[j] = -w[j];
env_mp.c:      first_non_zero = -1;
env_mp.c:	  int j = first_non_zero - 2;
env_mp.c:	  for (k = 2; k <= 2 + l_w - j; k++)
env_mp.c:	  w[1] -= j;
env_mp.c:	  z[2] = -z[2];
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y2 >= 0 ? 1 : -1;
env_mp.c:    (int) (floor) ((double) MAX_REPR_INT / (2 * (double) MP_BASE * (double) MP_BASE)) - 1;
env_mp.c:  for (i = 1 + digits; i >= 2; i--)
env_mp.c:	  if (FORCE_NORMALISATION || overflow < 2 || ((digits) - i) % overflow == 0)
env_mp.c:	  for (j = 1 + digits; j >= 2; j--)
env_mp.c:	      w[j + i - 1] += b[i] * a[j];
env_mp.c:| D. M. Smith, "A Multiple-Precision Division Algorithm" 
env_mp.c:| Mathematics of Computation 66 (1996) 157-163.
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y2 >= 0 ? 1 : -1;
env_mp.c:  w[1] = x[1] - y[1];
env_mp.c:	(((double) w[ka - 1] * MP_BASE + (double) w[ka]) * MP_BASE +
env_mp.c:	      w[j] = w[j] - q * y[j - ka + 2];
env_mp.c:      w[ka] = w[ka] + w[ka - 1] * MP_BASE;
env_mp.c:      w[ka - 1] = q;
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y2 >= 0 ? 1 : -1;
env_mp.c:  w[1] = x[1] - y[1];
env_mp.c:	(((double) w[ka - 1] * MP_BASE + (double) w[ka]) * MP_BASE +
env_mp.c:	      w[j] = w[j] - q * y[j - ka + 2];
env_mp.c:      w[ka] = w[ka] + w[ka - 1] * MP_BASE;
env_mp.c:      w[ka - 1] = q;
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y >= 0 ? 1 : -1;
env_mp.c:  for (j = 1 + digits; j >= 2; j--)
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y >= 0 ? 1 : -1;
env_mp.c:	(((double) w[ka - 1] * MP_BASE + (double) w[ka]) * MP_BASE +
env_mp.c:      w[ka] = w[ka] - q * y;
env_mp.c:      w[ka] = w[ka] + w[ka - 1] * MP_BASE;
env_mp.c:      w[ka - 1] = q;
env_mp.c:  sign_x = x2 >= 0 ? 1 : -1;
env_mp.c:  sign_y = y >= 0 ? 1 : -1;
env_mp.c:	(((double) w[ka - 1] * MP_BASE + (double) w[ka]) * MP_BASE +
env_mp.c:      w[ka] = w[ka] - q * y;
env_mp.c:      w[ka] = w[ka] + w[ka - 1] * MP_BASE;
env_mp.c:      w[ka - 1] = q;
env_mp.c:      n = -n;
env_mp.c:  else if (z[1] > -1)
env_mp.c:  else if (z[1] < -1)
env_mp.c:| sqrt (y) = sqrt (MP_BASE * x) * sqrt (MP_BASE ** (n - 1)) 
env_mp.c:|          = sqrt (MP_BASE * x) * MP_BASE ** (n - 1) / 2
env_mp.c:	  z_g[1] += (expo - 1) / 2;
env_mp.c:      if (tmp[1] < (sum[1] - digits_g))
env_mp.c:  while (m--)
env_mp.c:/* We use ln (1 / x) = - ln (x) */
env_mp.c:| We scale when "x_g" exceeds "MP_BASE ** +- 2", 
env_mp.c:| ln (x) = (x - 1) - (x - 1) ** 2 / 2 + (x - 1) ** 3 / 3 - ...
env_mp.c:	  if (tmp[1] < (z_g[1] - digits_g))
env_mp.c:	      tmp[2] = n % 2 == 0 ? -tmp[2] : tmp[2];
env_mp.c:| Newton's method: x<n+1> = x<n> - 1 + a / exp (x<n>)
env_mp.c:      z_g[2] = -z_g[2];
env_mp.c:/* "x" mod "y" = "x" - "y" * trunc ("x" / "y") */
env_mp.c:| sin (-x) = sin (x) 
env_mp.c:| sin (x) = - sin (x - pi); pi < x <= 2 pi
env_mp.c:| sin (x) = sin (pi - x);   pi / 2 < x <= pi
env_mp.c:      x_g[2] = -x_g[2];
env_mp.c:| Use triple-angle relation to reduce argument.
env_mp.c:      if (tmp[1] < (z_g[1] - digits_g))
env_mp.c:	  tmp[2] = even ? tmp[2] : -tmp[2];
env_mp.c:| Inverse scaling using sin (3x) = sin (x) * (3 - 4 sin ** 2 (x))
env_mp.c:  while (m--)
env_mp.c:      z[2] = -z[2];
env_mp.c:      z[2] = x_g[2] >= 0 ? z[2] : -z[2];
env_mp.c:      x_g[2] = -x_g[2];
env_mp.c:  if (x_g[1] < -1)
env_mp.c:| arctan (x) = x - x ** 3 / 3 + x ** 5 / 5 - x ** 7 / 7 + ..
env_mp.c:	  if (tmp[1] < (z_g[1] - digits_g))
env_mp.c:	      tmp[2] = even ? tmp[2] : -tmp[2];
env_mp.c:| Newton's method: x<n+1> = x<n> - cos (x<n>) * (sin (x<n>) - a cos (x<n>))
env_mp.c:  z[2] = chsn ? -z[2] : z[2];
env_mp.c:  return (z[1] >= 0 && z[1] <= LONG_MP_DIGITS - 2);
env_mp.c:  z[1] = LONG_MP_DIGITS - 2;
env_mp.c:  while (--j >= 2)
env_mp.c:      z[j] = MP_BASE - 1;
env_mp.c:  z[1] = -(long_mp_digits () - 1);
env_mp.c:  z[1] = MAX_MP_EXPONENT - 1;
env_mp.c:      z[j] = MP_BASE - 1;
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  z[2] = -z[2];
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:      PUSH_INT (p, -1);
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  if (z[1] <= digits - 1)
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *z = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  set_mp_short (y, MP_BASE / 2, -1, digits);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  y = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-size - size_of (A_REF)));
env_mp.c:  y = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-size - size_of (A_REF)));
env_mp.c:  y = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-size - size_of (A_REF)));
env_mp.c:  y = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-size - size_of (A_REF)));
env_mp.c:  y = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-size - size_of (A_REF)));
env_mp.c:  y = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-size - size_of (A_REF)));
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *y = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  stack_pointer = old_sp - size;
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size), *y;
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *x = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  a[2] = -a[2];
env_mp.c:  b[2] = -b[2];
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  b[2] = -b[2];
env_mp.c:  mp_digit *d = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *c = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-3 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-4 * size);
env_mp.c:  mp_digit *d = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *c = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-3 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-4 * size);
env_mp.c:  mp_digit *d = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *c = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-3 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-4 * size);
env_mp.c:  mp_digit *d = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *c = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-3 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-4 * size);
env_mp.c:  imx = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  rex = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:      j.value = -j.value;
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-3 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-4 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-3 * size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-4 * size);
env_mp.c:  d = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  c = (mp_digit *) (STACK_OFFSET (-2 * size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-2 * size - size_of (A_REF)));
env_mp.c:  d = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  c = (mp_digit *) (STACK_OFFSET (-2 * size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-2 * size - size_of (A_REF)));
env_mp.c:  d = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  c = (mp_digit *) (STACK_OFFSET (-2 * size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-2 * size - size_of (A_REF)));
env_mp.c:  d = (mp_digit *) (STACK_OFFSET (-size));
env_mp.c:  c = (mp_digit *) (STACK_OFFSET (-2 * size));
env_mp.c:  z = (A_REF *) (STACK_OFFSET (-2 * size - size_of (A_REF)));
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  mp_digit *b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  mp_digit *a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:	  z[2] = -z[2];
env_mp.c:  return (z[1] >= 0 && z[1] <= varying_mp_digits - 2);
env_mp.c:  z[1] = varying_mp_digits - 2;
env_mp.c:  while (--j >= 2)
env_mp.c:      z[j] = MP_BASE - 1;
env_mp.c:  z[1] = -(longlong_mp_digits () - 1);
env_mp.c:  z[1] = MAX_MP_EXPONENT - 1;
env_mp.c:      z[j] = MP_BASE - 1;
env_mp.c:      if (z[1] > LONG_MP_DIGITS - 1)
env_mp.c:  b = (mp_digit *) STACK_OFFSET (-size);
env_mp.c:  a = (mp_digit *) STACK_OFFSET (-2 * size);
env_mp.c:  INCREMENT_STACK_POINTER (p, 2 * (size_long - size));
env_mp.c:  b = (mp_digit *) STACK_OFFSET (-size_long);
env_mp.c:  a = (mp_digit *) STACK_OFFSET (-2 * size_long);
env_mp.c:  DECREMENT_STACK_POINTER (p, 2 * (size_long - size));
env_plot.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
env_plot.c:| 24-bit interpretation (internally, we extend to 48 bits by doubling each
env_plot.c:  if (file->device.device_made)
env_plot.c:  file->device.page_size = new_string (a_to_c_string (p, z, page_ptr));
env_plot.c:  file->device.device = new_string (a_to_c_string (p, z, device_ptr));
env_plot.c:  file->device.device_made = A_TRUE;
env_plot.c:  if (!f->opened)
env_plot.c:  if (!(f->device.device_opened))
env_plot.c:  if (f->device.device_made)
env_plot.c:      if (f->device.device != NULL)
env_plot.c:	  free (f->device.device);
env_plot.c:      if (f->device.page_size != NULL)
env_plot.c:	  free (f->device.page_size);
env_plot.c:  pl_selectpl (f->device.device_handle);
env_plot.c:  pl_deletepl (f->device.device_handle);
env_plot.c:  if (f->stream != NULL && fclose (f->stream) != 0)
env_plot.c:  f->device.device_opened = A_FALSE;
env_plot.c:/* First set up the general device, then plotter-specific things */
env_plot.c:  if (f->device.device_opened)
env_plot.c:      if (f->device.device_handle < 0)
env_plot.c:	  warror (A_RTE, p, "cannot create Z device", f->device.device);
env_plot.c:      pl_selectpl (f->device.device_handle);
env_plot.c:  if (!f->opened)
env_plot.c:  if (f->read_mood)
env_plot.c:  if (f->write_mood)
env_plot.c:  if (!f->chan.draw)
env_plot.c:  if (!f->device.device_made)
env_plot.c:/* Supported plotter type - X Window System */
env_plot.c:  if (!strcmp (f->device.device, "X"))
env_plot.c:      char *z = f->device.page_size, size[BUFFER_SIZE];
env_plot.c:      if (!scan_int (f->device.page_size, &z, &(f->device.window_x_size)))
env_plot.c:      if (!scan_int (f->device.page_size, &z, &(f->device.window_y_size)))
env_plot.c:      f->stream = NULL;
env_plot.c:      sprintf (size, "%dx%d", f->device.window_x_size, f->device.window_y_size);
env_plot.c:      f->device.device_handle = pl_newpl ("X", NULL, NULL, log_file);
env_plot.c:      if (f->device.device_handle < 0)
env_plot.c:	  warror (A_RTE, p, "cannot create Z device", f->device.device);
env_plot.c:      pl_selectpl (f->device.device_handle);
env_plot.c:      XPLOT_APP_NAME = f->identification;
env_plot.c:	  warror (A_RTE, p, "cannot open Z device", f->device.device);
env_plot.c:      pl_space (0, 0, f->device.window_x_size, f->device.window_y_size);
env_plot.c:/* Supported plotter type - Portable aNyMap */
env_plot.c:  else if (!strcmp (f->device.device, "pnm"))
env_plot.c:      char *z = f->device.page_size, size[BUFFER_SIZE];
env_plot.c:      if (!scan_int (f->device.page_size, &z, &(f->device.window_x_size)))
env_plot.c:      if (!scan_int (f->device.page_size, &z, &(f->device.window_y_size)))
env_plot.c:      if ((f->stream = fopen (f->identification, "w")) == NULL)
env_plot.c:	  warror (A_RTE, p, "cannot open Z for drawing; \"Z\"", f->identification,
env_plot.c:	  f->read_mood = A_FALSE;
env_plot.c:	  f->write_mood = A_FALSE;
env_plot.c:	  f->text_mood = A_FALSE;
env_plot.c:	  f->draw_mood = A_TRUE;
env_plot.c:      sprintf (size, "%dx%d", f->device.window_x_size, f->device.window_y_size);
env_plot.c:      f->device.device_handle = pl_newpl ("pnm", NULL, f->stream, log_file);
env_plot.c:      if (f->device.device_handle < 0)
env_plot.c:	  warror (A_RTE, p, "cannot create Z device", f->device.device);
env_plot.c:      pl_selectpl (f->device.device_handle);
env_plot.c:	  warror (A_RTE, p, "cannot open Z device", f->device.device);
env_plot.c:      pl_space (0, 0, f->device.window_x_size, f->device.window_y_size);
env_plot.c:/* Supported plotter type - GIF */
env_plot.c:  else if (!strcmp (f->device.device, "gif"))
env_plot.c:      char *z = f->device.page_size, size[BUFFER_SIZE];
env_plot.c:      if (!scan_int (f->device.page_size, &z, &(f->device.window_x_size)))
env_plot.c:      if (!scan_int (f->device.page_size, &z, &(f->device.window_y_size)))
env_plot.c:      if ((f->stream = fopen (f->identification, "w")) == NULL)
env_plot.c:	  warror (A_RTE, p, "cannot open Z for drawing; \"Z\"", f->identification,
env_plot.c:	  f->read_mood = A_FALSE;
env_plot.c:	  f->write_mood = A_FALSE;
env_plot.c:	  f->text_mood = A_FALSE;
env_plot.c:	  f->draw_mood = A_TRUE;
env_plot.c:      sprintf (size, "%dx%d", f->device.window_x_size, f->device.window_y_size);
env_plot.c:      f->device.device_handle = pl_newpl ("gif", NULL, f->stream, log_file);
env_plot.c:      if (f->device.device_handle < 0)
env_plot.c:	  warror (A_RTE, p, "cannot create Z device", f->device.device);
env_plot.c:      pl_selectpl (f->device.device_handle);
env_plot.c:	  warror (A_RTE, p, "cannot open Z device", f->device.device);
env_plot.c:      pl_space (0, 0, f->device.window_x_size, f->device.window_y_size);
env_plot.c:/* Supported plotter type - Postscript */
env_plot.c:  else if (!strcmp (f->device.device, "ps"))
env_plot.c:      if ((f->stream = fopen (f->identification, "w")) == NULL)
env_plot.c:	  warror (A_RTE, p, "cannot open Z for drawing; \"Z\"", f->identification,
env_plot.c:	  f->read_mood = A_FALSE;
env_plot.c:	  f->write_mood = A_FALSE;
env_plot.c:	  f->text_mood = A_FALSE;
env_plot.c:	  f->draw_mood = A_TRUE;
env_plot.c:      pl_parampl ("PAGESIZE", f->device.page_size);
env_plot.c:      f->device.device_handle = pl_newpl ("ps", NULL, f->stream, log_file);
env_plot.c:      if (f->device.device_handle < 0)
env_plot.c:	  warror (A_RTE, p, "cannot create Z device", f->device.device);
env_plot.c:      pl_selectpl (f->device.device_handle);
env_plot.c:	  warror (A_RTE, p, "cannot open Z device", f->device.device);
env_plot.c:      f->device.window_x_size = 1000;
env_plot.c:      f->device.window_y_size = 1000;
env_plot.c:      pl_space (0, 0, f->device.window_x_size, f->device.window_y_size);
env_plot.c:      warror (A_RTE, p, "unrecognised or unsupported plotter type Z", f->device.device);
env_plot.c:  f->draw_mood = A_TRUE;
env_plot.c:  f->device.device_opened = A_TRUE;
env_plot.c:  f->device.x_coord = 0;
env_plot.c:  f->device.y_coord = 0;
env_plot.c:  PUSH_REAL (p, (double) f->device.window_y_size / (double) f->device.window_x_size);
env_plot.c:  z = ((A_INT *) STACK_TOP)->value;
env_plot.c:  z = ((A_INT *) STACK_TOP)->value;
env_plot.c:  j = (z - 1) % COLOUR_NAMES;
env_plot.c:  z = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  f->device.red = x;
env_plot.c:  f->device.green = y;
env_plot.c:  f->device.blue = z;
env_plot.c:  z = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  f->device.red = x;
env_plot.c:  f->device.green = y;
env_plot.c:  f->device.blue = z;
env_plot.c:  f->device.red = x;
env_plot.c:  f->device.green = y;
env_plot.c:  f->device.blue = z;
env_plot.c:  width = ((A_INT *) STACK_TOP)->value;
env_plot.c:  pl_linewidth ((int) (width * f->device.window_y_size));
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  pl_fmove (x * f->device.window_x_size, y * f->device.window_y_size);
env_plot.c:  f->device.x_coord = x;
env_plot.c:  f->device.y_coord = y;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  pl_fline (f->device.x_coord * f->device.window_x_size,
env_plot.c:	    f->device.y_coord * f->device.window_y_size, x * f->device.window_x_size,
env_plot.c:	    y * f->device.window_y_size);
env_plot.c:  f->device.x_coord = x;
env_plot.c:  f->device.y_coord = y;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  pl_fpoint (x * f->device.window_x_size, y * f->device.window_y_size);
env_plot.c:  f->device.x_coord = x;
env_plot.c:  f->device.y_coord = y;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  pl_fbox (f->device.x_coord * f->device.window_x_size,
env_plot.c:	   f->device.y_coord * f->device.window_y_size, x * f->device.window_x_size,
env_plot.c:	   y * f->device.window_y_size);
env_plot.c:  f->device.x_coord = x;
env_plot.c:  f->device.y_coord = y;
env_plot.c:  r = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  pl_fcircle (x * f->device.window_x_size, y * f->device.window_y_size,
env_plot.c:	      r * MAX (f->device.window_x_size, f->device.window_y_size));
env_plot.c:  f->device.x_coord = x;
env_plot.c:  f->device.y_coord = y;
env_plot.c:  r = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  y = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  x = ((A_REAL *) STACK_TOP)->value;
env_plot.c:  k = (int) (r * MAX (f->device.window_x_size, f->device.window_y_size));
env_plot.c:  for (j = k; j >= 0; j--)
env_plot.c:      frac = 1.0 - ((double) j / (double) k);
env_plot.c:      pl_color ((int) (frac * f->device.red * COLOUR_MAX),
env_plot.c:		(int) (frac * f->device.green * COLOUR_MAX),
env_plot.c:		(int) (frac * f->device.blue * COLOUR_MAX));
env_plot.c:      pl_fcircle (x * f->device.window_x_size, y * f->device.window_y_size, j);
env_plot.c:  pl_color ((int) (f->device.red * COLOUR_MAX), (int) (f->device.green * COLOUR_MAX),
env_plot.c:	    (int) (f->device.blue * COLOUR_MAX));
env_plot.c:  f->device.x_coord = x;
env_plot.c:  f->device.y_coord = y;
env_prelude.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
env_prelude.c:  PUSH_REAL (p, seconds () - cputime_0);
env_prelude.c:  return (k >= 0 ? k : -k);
env_prelude.c:  return (k > 0 ? 1 : (k < 0 ? -1 : 0));
env_prelude.c:  return (x >= 0.0 ? x : -x);
env_prelude.c:  return (x > 0.0 ? 1.0 : (x < 0.0 ? -1.0 : 0.0));
env_prelude.c:  return (x - y * (INT_64_BIT) (x / y));
env_prelude.c:  A_BOOL *j = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
env_prelude.c:  j->value = !j->value;
env_prelude.c:  i = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
env_prelude.c:  i->value = i->value & j->value;
env_prelude.c:  i = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
env_prelude.c:  i->value = i->value | j->value;
env_prelude.c:  i = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
env_prelude.c:  i->value = i->value ^ j->value;
env_prelude.c:  i = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
env_prelude.c:  i->value = i->value == j->value;
env_prelude.c:  i = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
env_prelude.c:  i->value = i->value != j->value;
env_prelude.c:  i = (A_BITS *) (STACK_OFFSET (-size_of (A_BITS)));
env_prelude.c:  i->value = ~i->value;
env_prelude.c:  i = (A_BITS *) (STACK_OFFSET (-size_of (A_BITS)));
env_prelude.c:  i->value = i->value & j->value;
env_prelude.c:  i = (A_BITS *) (STACK_OFFSET (-size_of (A_BITS)));
env_prelude.c:  i->value = i->value | j->value;
env_prelude.c:  i = (A_BITS *) (STACK_OFFSET (-size_of (A_BITS)));
env_prelude.c:  i->value = i->value ^ j->value;
env_prelude.c:  for (n = 0; n < (BITS_WIDTH - i.value); n++)
env_prelude.c:  A_INT *j = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  j->value = -j->value;
env_prelude.c:  A_INT *j = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  j->value = j->value >= 0 ? j->value : -j->value;
env_prelude.c:  A_INT *j = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  j->value = j->value == 0 ? 0 : (j->value > 0 ? 1 : -1);
env_prelude.c:  i = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  i->value += j->value;
env_prelude.c:  i = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  i->value -= j->value;
env_prelude.c:  i = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  i->value *= j->value;
env_prelude.c:  i = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  if (j->value == 0)
env_prelude.c:  i->value /= j->value;
env_prelude.c:  i = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
env_prelude.c:  if (j->value == 0)
env_prelude.c:  k = i->value % j->value;
env_prelude.c:      k += iabs (j->value);
env_prelude.c:  i->value = k;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  address->value += i->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  address->value -= i->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  address->value *= i->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  if (i->value == 0)
env_prelude.c:  address->value /= i->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  if (i->value == 0)
env_prelude.c:  address->value %= i->value;
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = -x->value;
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = x->value >= 0 ? x->value : -x->value;
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = (INT_64_BIT) x->value;
env_prelude.c:  x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value += y->value;
env_prelude.c:  x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value -= y->value;
env_prelude.c:  x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value *= y->value;
env_prelude.c:  if (y->value == 0.0)
env_prelude.c:  x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value /= y->value;
env_prelude.c:      j = -j;
env_prelude.c:      y.value = -y.value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  address->value += a->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  address->value -= a->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  address->value *= a->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  if (a->value == 0)
env_prelude.c:  address->value /= a->value;
env_prelude.c:      j.value = (INT_64_BIT) (x.value - 0.5);
env_prelude.c:  if (x.value < -MAX_INT || x.value > MAX_INT)
env_prelude.c:  j.value = x.value > 0 ? 1 : x.value < 0 ? -1 : 0;
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = sin (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  if (x->value < -1 || x->value > 1)
env_prelude.c:  x->value = asin (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = cos (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  if (x->value < -1 || x->value > 1)
env_prelude.c:  x->value = acos (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = tan (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = atan (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  x->value = exp (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  if (x->value <= 0)
env_prelude.c:  x->value = log (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  if (x->value <= 0)
env_prelude.c:  x->value = log10 (x->value);
env_prelude.c:  A_REAL *x = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  if (x->value < 0)
env_prelude.c:  x->value = sqrt (x->value);
env_prelude.c:  *(A_REAL *) (STACK_OFFSET (-size_of (A_REAL))) = im;
env_prelude.c:  imx = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  rex = (A_REAL *) (STACK_OFFSET (-2 * size_of (A_REAL)));
env_prelude.c:  imx->value = -imx->value;
env_prelude.c:  rex->value = -rex->value;
env_prelude.c:  imx = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  rex = (A_REAL *) (STACK_OFFSET (-2 * size_of (A_REAL)));
env_prelude.c:  imx->value += imy->value;
env_prelude.c:  rex->value += rey->value;
env_prelude.c:  imx = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  rex = (A_REAL *) (STACK_OFFSET (-2 * size_of (A_REAL)));
env_prelude.c:  imx->value -= imy->value;
env_prelude.c:  rex->value -= rey->value;
env_prelude.c:  PUSH_REAL (p, rex.value * rey.value - imx.value * imy.value);
env_prelude.c:	  PUSH_REAL (p, (imx.value - r * rex.value) / den);
env_prelude.c:	  PUSH_REAL (p, (imx.value * r - rex.value) / den);
env_prelude.c:      j.value = -j.value;
env_prelude.c:	  rea = rez * rey - imz * imy;
env_prelude.c:      rea = rex.value * rey - imx.value * imy;
env_prelude.c:  PUSH_BOOL (p, (rex->value == rey->value) && (imx->value == imy->value));
env_prelude.c:  PUSH_BOOL (p, !((rex->value == rey->value) && (imx->value == imy->value)));
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  imx->value += imy->value;
env_prelude.c:  rex->value += rey->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  imx->value -= imy->value;
env_prelude.c:  rex->value -= rey->value;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  rez = rex->value * rey->value - imx->value * imy->value;
env_prelude.c:  imz = imx->value * rey->value + rex->value * imy->value;
env_prelude.c:  imx->value = imz;
env_prelude.c:  rex->value = rez;
env_prelude.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
env_prelude.c:  if (rey->value == 0.0 && imy->value == 0.0)
env_prelude.c:  if (dabs (rey->value) >= dabs (imy->value))
env_prelude.c:      double r = imy->value / rey->value, den = rey->value + r * imy->value;
env_prelude.c:      rez = (rex->value + r * imx->value) / den;
env_prelude.c:      imz = (imx->value - r * rex->value) / den;
env_prelude.c:      double r = rey->value / imy->value, den = imy->value + r * rey->value;
env_prelude.c:      rez = (rex->value * r + imx->value) / den;
env_prelude.c:      imz = (imx->value * r - rex->value) / den;
env_prelude.c:  imx->value = imz;
env_prelude.c:  rex->value = rez;
env_prelude.c:  im = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
env_prelude.c:  im->value = -im->value;
env_prelude.c:  a_3->dim = 1;
env_prelude.c:  a_3->type = Mode (CHAR);
env_prelude.c:  a_3->elem_size = size_of (A_CHAR);
env_prelude.c:  a_3->slice_offset = 0;
env_prelude.c:  a_3->field_offset = 0;
env_prelude.c:  a_3->array = d;
env_prelude.c:  t_3->lwb = 1;
env_prelude.c:  t_3->upb = 2;
env_prelude.c:  t_3->shift = t_3->lwb;
env_prelude.c:  t_3->span = 1;
env_prelude.c:  b_3 = ref_to_ptr (&a_3->array);
env_prelude.c:  a_3->dim = 1;
env_prelude.c:  a_3->type = Mode (CHAR);
env_prelude.c:  a_3->elem_size = size_of (A_CHAR);
env_prelude.c:  a_3->slice_offset = 0;
env_prelude.c:  a_3->field_offset = 0;
env_prelude.c:  a_3->array = d;
env_prelude.c:  t_3->lwb = 1;
env_prelude.c:  t_3->upb = l_1 + l_2;
env_prelude.c:  t_3->shift = t_3->lwb;
env_prelude.c:  t_3->span = 1;
env_prelude.c:  b_1 = ref_to_ptr (&a_1->array);
env_prelude.c:  b_2 = ref_to_ptr (&a_2->array);
env_prelude.c:  b_3 = ref_to_ptr (&a_3->array);
env_prelude.c:  for (k = t_1->lwb; k <= t_1->upb; k++)
env_prelude.c:  for (k = t_2->lwb; k <= t_2->upb; k++)
env_prelude.c:  a_3->dim = 1;
env_prelude.c:  a_3->type = Mode (CHAR);
env_prelude.c:  a_3->elem_size = size_of (A_CHAR);
env_prelude.c:  a_3->slice_offset = 0;
env_prelude.c:  a_3->field_offset = 0;
env_prelude.c:  a_3->array = d;
env_prelude.c:  t_3->lwb = 1;
env_prelude.c:  t_3->upb = l_1 + l_2;
env_prelude.c:  t_3->shift = t_3->lwb;
env_prelude.c:  t_3->span = 1;
env_prelude.c:  b_1 = ref_to_ptr (&a_1->array);
env_prelude.c:  b_2 = ref_to_ptr (&a_2->array);
env_prelude.c:  b_3 = ref_to_ptr (&a_3->array);
env_prelude.c:  for (k = t_1->lwb; k <= t_1->upb; k++)
env_prelude.c:  for (k = t_2->lwb; k <= t_2->upb; k++)
env_prelude.c:  a_3->dim = 1;
env_prelude.c:  a_3->type = Mode (CHAR);
env_prelude.c:  a_3->elem_size = size_of (A_CHAR);
env_prelude.c:  a_3->slice_offset = 0;
env_prelude.c:  a_3->field_offset = 0;
env_prelude.c:  a_3->array = d;
env_prelude.c:  t_3->lwb = 1;
env_prelude.c:  t_3->upb = l_1 + l_2;
env_prelude.c:  t_3->shift = t_3->lwb;
env_prelude.c:  t_3->span = 1;
env_prelude.c:  b_1 = ref_to_ptr (&a_1->array);
env_prelude.c:  b_2 = ref_to_ptr (&a_2->array);
env_prelude.c:  b_3 = ref_to_ptr (&a_3->array);
env_prelude.c:  for (k = t_2->lwb; k <= t_2->upb; k++)
env_prelude.c:  for (k = t_1->lwb; k <= t_1->upb; k++)
env_prelude.c:  b_1 = ref_to_ptr (&a_1->array);
env_prelude.c:  b_2 = ref_to_ptr (&a_2->array);
env_prelude.c:	  A_CHAR *ch = (A_CHAR *) & b_1[INDEX_1_DIM (a_1, t_1, t_1->lwb + k)];
env_prelude.c:	  a = (int) ch->value;
env_prelude.c:	  A_CHAR *ch = (A_CHAR *) & b_2[INDEX_1_DIM (a_2, t_2, t_2->lwb + k)];
env_prelude.c:	  b = (int) ch->value;
env_prelude.c:      diff += (a - b);
env_prelude.c:  while (--k > 1)
env_prelude.c:  z[1] = -1;
env_prelude.c:  GET_DESCRIPTOR (x, t, &z) PUSH_INT (p, t->lwb);
env_prelude.c:  GET_DESCRIPTOR (x, t, &z) PUSH_INT (p, t->upb);
env_prelude.c:  if (k.value < 1 || k.value > x->dim)
env_prelude.c:  PUSH_INT (p, t[k.value - 1].lwb);
env_prelude.c:  if (k.value < 1 || k.value > x->dim)
env_prelude.c:  PUSH_INT (p, t[k.value - 1].upb);
env_transput.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
env_transput.c:  f->status = INITIALISED_MASK;
env_transput.c:  f->identification = NULL;
env_transput.c:  f->terminator = NULL;
env_transput.c:  f->chan = stand_in_channel;
env_transput.c:  f->stream = stdin;
env_transput.c:  f->opened = A_TRUE;
env_transput.c:  f->read_mood = A_TRUE;
env_transput.c:  f->write_mood = A_FALSE;
env_transput.c:  f->text_mood = A_TRUE;
env_transput.c:  f->draw_mood = A_FALSE;
env_transput.c:  f->file_end_mended.body = nil_pointer;
env_transput.c:  f->file_end_mended.environ = nil_ref;
env_transput.c:  f->value_error_mended.body = nil_pointer;
env_transput.c:  f->value_error_mended.environ = nil_ref;
env_transput.c:  f->status = INITIALISED_MASK;
env_transput.c:  f->identification = NULL;
env_transput.c:  f->terminator = NULL;
env_transput.c:  f->chan = stand_out_channel;
env_transput.c:  f->stream = stdout;
env_transput.c:  f->opened = A_TRUE;
env_transput.c:  f->read_mood = A_FALSE;
env_transput.c:  f->write_mood = A_TRUE;
env_transput.c:  f->text_mood = A_TRUE;
env_transput.c:  f->draw_mood = A_FALSE;
env_transput.c:  f->file_end_mended.body = nil_pointer;
env_transput.c:  f->file_end_mended.environ = nil_ref;
env_transput.c:  f->value_error_mended.body = nil_pointer;
env_transput.c:  f->value_error_mended.environ = nil_ref;
env_transput.c:  f->status = INITIALISED_MASK;
env_transput.c:  f->identification = NULL;
env_transput.c:  f->terminator = NULL;
env_transput.c:  f->chan = stand_back_channel;
env_transput.c:  f->stream = NULL;
env_transput.c:  f->opened = A_FALSE;
env_transput.c:  f->read_mood = A_FALSE;
env_transput.c:  f->write_mood = A_FALSE;
env_transput.c:  f->text_mood = A_FALSE;
env_transput.c:  f->draw_mood = A_FALSE;
env_transput.c:  f->file_end_mended.body = nil_pointer;
env_transput.c:  f->file_end_mended.environ = nil_ref;
env_transput.c:  f->value_error_mended.body = nil_pointer;
env_transput.c:  f->value_error_mended.environ = nil_ref;
env_transput.c:  f->status = INITIALISED_MASK;
env_transput.c:  f->identification = NULL;
env_transput.c:  f->terminator = NULL;
env_transput.c:  f->chan = stand_error_channel;
env_transput.c:  f->stream = stderr;
env_transput.c:  f->opened = A_TRUE;
env_transput.c:  f->read_mood = A_FALSE;
env_transput.c:  f->write_mood = A_TRUE;
env_transput.c:  f->text_mood = A_TRUE;
env_transput.c:  f->draw_mood = A_FALSE;
env_transput.c:  f->file_end_mended.body = nil_pointer;
env_transput.c:  f->file_end_mended.environ = nil_ref;
env_transput.c:  f->value_error_mended.body = nil_pointer;
env_transput.c:  f->value_error_mended.environ = nil_ref;
env_transput.c:  h_ptr = row.value + row.handle->offset;
env_transput.c:| to accomodate the string - this is caller's responsibility! 
env_transput.c:	  A_BYTE *base = ref_to_ptr (&arr->array);
env_transput.c:	  for (k = tup->lwb; k <= tup->upb; k++)
env_transput.c:		(tup->span * (k - tup->shift) + arr->slice_offset) * arr->elem_size +
env_transput.c:		arr->field_offset;
env_transput.c:	      str[n++] = ch->value;
env_transput.c:	  A_BYTE *base = ref_to_ptr (&(arr->array));
env_transput.c:	  for (k = tup->lwb; k <= tup->upb && !found; k++)
env_transput.c:		(tup->span * (k - tup->shift) + arr->slice_offset) * arr->elem_size +
env_transput.c:		arr->field_offset;
env_transput.c:	      if ((found = (c == ch->value)))
env_transput.c:  if (file->terminator != NULL)
env_transput.c:      free (file->terminator);
env_transput.c:  file->terminator = new_string (a_to_c_string (p, str, str_ptr));
env_transput.c:  PUSH_BOOL (p, file->chan.put);
env_transput.c:  PUSH_BOOL (p, file->chan.get);
env_transput.c:  PUSH_BOOL (p, file->chan.bin);
env_transput.c:  PUSH_BOOL (p, file->chan.set);
env_transput.c:  PUSH_BOOL (p, file->chan.reset);
env_transput.c:  PUSH_BOOL (p, file->chan.draw);
env_transput.c:  file->status = INITIALISED_MASK;
env_transput.c:  file->chan = chan;
env_transput.c:  file->opened = A_TRUE;
env_transput.c:  file->read_mood = A_FALSE;
env_transput.c:  file->write_mood = A_FALSE;
env_transput.c:  file->text_mood = A_FALSE;
env_transput.c:  file->draw_mood = A_FALSE;
env_transput.c:  if (file->identification != NULL)
env_transput.c:      free (file->identification);
env_transput.c:  file->identification = new_string (a_to_c_string (p, name, iden_ptr));
env_transput.c:  file->terminator = NULL;
env_transput.c:  file->value_error_mended.body = nil_pointer;
env_transput.c:  file->value_error_mended.environ = nil_ref;
env_transput.c:  file->file_end_mended.body = nil_pointer;
env_transput.c:  file->file_end_mended.environ = nil_ref;
env_transput.c:  if (!file->opened || (!file->read_mood && !file->write_mood && !file->draw_mood))
env_transput.c:  file->device.device_made = A_FALSE;
env_transput.c:  if (file->device.device_opened)
env_transput.c:  if (file->stream != NULL && fclose (file->stream) != 0)
env_transput.c:      file->opened = A_FALSE;
env_transput.c:  if (!file->opened)
env_transput.c:  file->read_mood = A_FALSE;
env_transput.c:  file->write_mood = A_FALSE;
env_transput.c:  file->text_mood = A_FALSE;
env_transput.c:  file->draw_mood = A_FALSE;
env_transput.c:  if (file->stream != NULL)
env_transput.c:      rewind (file->stream);
env_transput.c:  if (file->opened)
env_transput.c:      if (file->stream != NULL && fclose (file->stream) != 0)
env_transput.c:	  file->opened = A_FALSE;
env_transput.c:  if (file->identification != NULL && remove (file->identification) != 0)
env_transput.c:      free (file->identification);
env_transput.c:      file->identification = NULL;
env_transput.c:  file->file_end_mended = z;
env_transput.c:  file->value_error_mended = z;
env_transput.c:	      PACK *args = Mode (PROC_REF_FILE_BOOL)->pack;
env_transput.c:	      TAX (body)->incarnation++;
env_transput.c:	      TAX (body)->incarnation--;
env_transput.c:  exec_handler (p, ((A_FILE *) ref_to_ptr (&file_ptr))->file_end_mended, file_ptr);
env_transput.c:  if (((A_BOOL *) STACK_TOP)->value == 0)
env_transput.c:  FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      exec_handler (p, ((A_FILE *) ref_to_ptr (&file_ptr))->value_error_mended, file_ptr);
env_transput.c:      if (((A_BOOL *) STACK_TOP)->value == 0)
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->write_mood)
env_transput.c:      outimage (p, file->stream, textline);
env_transput.c:  else if (file->read_mood)
env_transput.c:      BOOLEAN go_on = !feof (file->stream);
env_transput.c:	  ch = char_scanner (p, Mode (CHAR), file->stream);
env_transput.c:	  go_on = ch != '\n' && ch != EOF && !feof (file->stream);
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->write_mood)
env_transput.c:  else if (file->read_mood)
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->write_mood)
env_transput.c:      outimage (p, file->stream, textline);
env_transput.c:  else if (file->read_mood)
env_transput.c:      if (!feof (file->stream))
env_transput.c:	  ch = char_scanner (p, Mode (CHAR), file->stream);
env_transput.c:  if (slen < *len - 1)
env_transput.c:  if (ch != EOF && (ch == '+' || ch == '-'))
env_transput.c:  char x_e = toupper (((A_CHAR *) ref_to_ptr (&genie_exp_char_ptr))->value);
env_transput.c:  if (ch != EOF && (ch == '+' || ch == '-'))
env_transput.c:      if (ch != EOF && (ch == '+' || ch == '-'))
env_transput.c:  FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      char flip = ((A_CHAR *) ref_to_ptr (&genie_flip_char_ptr))->value;
env_transput.c:      char flop = ((A_CHAR *) ref_to_ptr (&genie_flop_char_ptr))->value;
env_transput.c:		   ((A_FILE *) ref_to_ptr (&file_ptr))->terminator, f);
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:		  TAX (body)->incarnation++;
env_transput.c:		  TAX (body)->incarnation--;
env_transput.c:  base = ref_to_ptr (&arr->array);
env_transput.c:      genie_read_one_elem (p, (MOID *) (z->value),
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->write_mood)
env_transput.c:  if (!file->chan.get)
env_transput.c:  if (!file->read_mood && !file->write_mood)
env_transput.c:      if ((file->stream = fopen (file->identification, "r")) == NULL)
env_transput.c:	  warror (A_RTE, p, "cannot open Z for getting E", file->identification,
env_transput.c:	  file->draw_mood = A_FALSE;
env_transput.c:	  file->read_mood = A_TRUE;
env_transput.c:	  file->write_mood = A_FALSE;
env_transput.c:	  file->text_mood = A_TRUE;
env_transput.c:  if (!file->text_mood)
env_transput.c:  base = ref_to_ptr (&arr->array);
env_transput.c:      genie_read_one_elem (p, (MOID *) (z->value),
env_transput.c:      f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:	  A_BYTE *base = ref_to_ptr (&(arr->array));
env_transput.c:	  for (k = tup->lwb; k <= tup->upb; k++)
env_transput.c:		(tup->span * (k - tup->shift) + arr->slice_offset) * arr->elem_size +
env_transput.c:		arr->field_offset;
env_transput.c:	      strchat (z, ch->value);
env_transput.c:      PUSH_INT (p, z->value);
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:      PUSH_REAL (p, z->value);
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:      PUSH_INT (p, REAL_WIDTH - 1);
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:      PUSH_INT (p, LONG_REAL_WIDTH - 1);
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:      PUSH_INT (p, LONGLONG_REAL_WIDTH - 1);
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:		ref_to_ptr (z->value ==
env_transput.c:			    1 ? &genie_flip_char_ptr : &genie_flop_char_ptr))->value);
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      sprintf (textline, "%c", k->value);
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      sprintf (textline, BITS_FORMAT, z->value);
env_transput.c:  FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:		  TAX (body)->incarnation++;
env_transput.c:		  TAX (body)->incarnation--;
env_transput.c:  base = ref_to_ptr (&arr->array);
env_transput.c:      genie_write_one_elem (p, (MOID *) (z->value), &base[m + size_of (A_POINTER)], stand_out);
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->read_mood)
env_transput.c:  if (!file->chan.put)
env_transput.c:  if (!file->read_mood && !file->write_mood)
env_transput.c:      if ((file->stream = fopen (file->identification, "w")) == NULL)
env_transput.c:	  warror (A_RTE, p, "cannot open Z for putting E", file->identification,
env_transput.c:	  file->draw_mood = A_FALSE;
env_transput.c:	  file->read_mood = A_FALSE;
env_transput.c:	  file->write_mood = A_TRUE;
env_transput.c:	  file->text_mood = A_TRUE;
env_transput.c:  if (!file->text_mood)
env_transput.c:  base = ref_to_ptr (&(arr->array));
env_transput.c:      genie_write_one_elem (p, (MOID *) (z->value), &(base[elem_ptr + size_of (A_POINTER)]),
env_transput.c:  FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:      z->status = INITIALISED_MASK;
env_transput.c:      z->status = INITIALISED_MASK;
env_transput.c:      ((A_REAL *) z)->status = INITIALISED_MASK;
env_transput.c:      z->status = INITIALISED_MASK;
env_transput.c:      z->status = INITIALISED_MASK;
env_transput.c:      z->status = INITIALISED_MASK;
env_transput.c:		   ((A_FILE *) ref_to_ptr (&file_ptr))->terminator, f);
env_transput.c:      FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:		  TAX (body)->incarnation++;
env_transput.c:		  TAX (body)->incarnation--;
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->write_mood)
env_transput.c:  if (!file->chan.get)
env_transput.c:  if (!file->chan.bin)
env_transput.c:  if (!file->read_mood && !file->write_mood)
env_transput.c:      if ((file->stream = fopen (file->identification, "rb")) == NULL)
env_transput.c:	  warror (A_RTE, p, "cannot open Z for getting E", file->identification,
env_transput.c:	  file->draw_mood = A_FALSE;
env_transput.c:	  file->read_mood = A_TRUE;
env_transput.c:	  file->write_mood = A_FALSE;
env_transput.c:	  file->text_mood = A_FALSE;
env_transput.c:  if (file->text_mood)
env_transput.c:  base = ref_to_ptr (&(arr->array));
env_transput.c:      genie_read_bin_one_elem (p, (MOID *) (z->value), &base[elem_ptr + size_of (A_POINTER)],
env_transput.c:  FILE *f = ((A_FILE *) ref_to_ptr (&file_ptr))->stream;
env_transput.c:		  TAX (body)->incarnation++;
env_transput.c:		  TAX (body)->incarnation--;
env_transput.c:  if (!file->opened)
env_transput.c:  if (file->draw_mood)
env_transput.c:  if (file->read_mood)
env_transput.c:  if (!file->chan.put)
env_transput.c:  if (!file->chan.bin)
env_transput.c:  if (!file->read_mood && !file->write_mood)
env_transput.c:      if ((file->stream = fopen (file->identification, "wb")) == NULL)
env_transput.c:	  warror (A_RTE, p, "cannot open Z for putting E", file->identification,
env_transput.c:	  file->draw_mood = A_FALSE;
env_transput.c:	  file->read_mood = A_FALSE;
env_transput.c:	  file->write_mood = A_TRUE;
env_transput.c:	  file->text_mood = A_FALSE;
env_transput.c:  if (file->text_mood)
env_transput.c:  base = ref_to_ptr (&arr->array);
env_transput.c:      genie_write_bin_one_elem (p, (MOID *) (z->value), &base[elem_ptr + size_of (A_POINTER)],
env_transput.c:#define ERROR_CHAR (((A_CHAR *) ref_to_ptr (&genie_error_char_ptr))->value)
env_transput.c:#define EXPONENT_CHAR (((A_CHAR *) ref_to_ptr (&genie_exp_char_ptr))->value)
env_transput.c:#define Sign(z) ((z) > 0 ? 1 : ((z) < 0 ? - 1 : 0))
env_transput.c:#define ABS_64(z) ((z) >= 0 ? (z) : -(z))
env_transput.c:| THIS ROUTINE IS FOR DEBUGGING PURPOSES AND WILL FAIL ON NON-IEEE HARDWARE.
env_transput.c:| over-anxious with optimisations, so use this with optimisations off.
env_transput.c:  while (--k >= 0)
env_transput.c:  h_ptr = row.value + row.handle->offset;
env_transput.c:      size += size_of (int) - rem;
env_transput.c:  int j = width - strlen (str);
env_transput.c:  while (--j >= 0)
env_transput.c:|        (INT length := ABS width - (x < 0 OR width > 0 | 1 | 0),
env_transput.c:|            (x < 0 | "-" |: width > 0 | "+" | "") PLUSTO s;
env_transput.c:|            (width /= 0 | (ABS width - UPB s) * " " PLUSTO s);
env_transput.c:  mode = (MOID *) (((A_POINTER *) STACK_TOP)->value);
env_transput.c:      INT_64_BIT x = ((A_INT *) (STACK_OFFSET (size_of (A_POINTER))))->value;
env_transput.c:      int length = ABS_64 (width.value) - (x < 0 || width.value > 0 ? 1 : 0);
env_transput.c:	      plusto ('-', s);
env_transput.c:      length = ABS_64 (width.value) - (ltz || width.value > 0 ? 1 : 0);
env_transput.c:	      plusto ('-', s);
env_transput.c:|                   y -:= c; c));
env_transput.c:  set_mp_short (t, MP_BASE / 10, -1, digits);
env_transput.c:  *y -= c;
env_transput.c:|        IF INT length := ABS width - (x < 0 OR width > 0 | 1 | 0);
env_transput.c:|                (x < 0 | "-" |: width > 0 | "+" | "") PLUSTO s;
env_transput.c:|                (width /= 0 | (ABS width - UPB s) * " " PLUSTO s);
env_transput.c:|           THEN fixed (v, width, after - 1)
env_transput.c:  mode = (MOID *) (((A_POINTER *) STACK_TOP)->value);
env_transput.c:      double x = ((A_REAL *) (STACK_OFFSET (size_of (A_POINTER))))->value;
env_transput.c:      INT_64_BIT length = ABS_64 (width.value) - (x < 0 || width.value > 0 ? 1 : 0);
env_transput.c:		  plusto ('-', s);
env_transput.c:	      PUSH_INT (p, after.value - 1);
env_transput.c:      length = ABS_64 (width.value) - (ltz || width.value > 0 ? 1 : 0);
env_transput.c:	      set_mp_short (z0, MP_BASE / 10, -1, digits);
env_transput.c:		  plusto ('-', s);
env_transput.c:	      x[2] = ltz ? -fabs (x[2]) : fabs (x[2]);
env_transput.c:	      PUSH_INT (p, after.value - 1);
env_transput.c:      INT_64_BIT x = ((A_INT *) (STACK_OFFSET (size_of (A_POINTER))))->value;
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:	  ((A_POINTER *) STACK_TOP)->value = (void *) Mode (LONG_REAL);
env_transput.c:	  ((A_POINTER *) STACK_TOP)->value = (void *) Mode (LONGLONG_REAL);
env_transput.c:|       (y /= 0.0 | WHILE y < h DO y *:= 10.0; p -:= 1 OD);
env_transput.c:  if ((y[1] - g[1]) > 1)
env_transput.c:      (*q) += LOG_MP_BASE * (y[1] - g[1] - 1);
env_transput.c:      if ((y[1] - h[1]) < -1)
env_transput.c:	  (*q) -= LOG_MP_BASE * (h[1] - y[1] - 1);
env_transput.c:	  y[1] = h[1] - 1;
env_transput.c:	  (*q)--;
env_transput.c:	  (*p)--;
env_transput.c:|        IF INT before = ABS width - ABS exp -
env_transput.c:|                        (after /= 0 | after + 1 | 0) - 2;
env_transput.c:|           s := fixed (SIGN x * y, SIGN width * (ABS width - ABS exp - 1),
env_transput.c:|           THEN float (x, width, (after /= 0 | after - 1 | 0),
env_transput.c:|                    (exp > 0 | exp + 1 | exp - 1))
env_transput.c:  mode = (MOID *) (((A_POINTER *) STACK_TOP)->value);
env_transput.c:      double x = ((A_REAL *) (STACK_OFFSET (size_of (A_POINTER))))->value;
env_transput.c:	ABS_64 (width.value) - ABS_64 (expo.value) - (after.value !=
env_transput.c:						      0 ? after.value + 1 : 0) - 2;
env_transput.c:				   moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:	  PUSH_INT (p, Sign (width.value) * (ABS_64 (width.value) - ABS_64 (expo.value) - 1));
env_transput.c:				   moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:	      PUSH_INT (p, after.value != 0 ? after.value - 1 : 0);
env_transput.c:	      PUSH_INT (p, expo.value > 0 ? expo.value + 1 : expo.value - 1);
env_transput.c:	ABS_64 (width.value) - ABS_64 (expo.value) - (after.value !=
env_transput.c:						      0 ? after.value + 1 : 0) - 2;
env_transput.c:	  z[2] = ltz ? -z[2] : z[2];
env_transput.c:				   moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:	  PUSH_INT (p, Sign (width.value) * (ABS_64 (width.value) - ABS_64 (expo.value) - 1));
env_transput.c:				   moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:	      PUSH_INT (p, after.value != 0 ? after.value - 1 : 0);
env_transput.c:	      PUSH_INT (p, expo.value > 0 ? expo.value + 1 : expo.value - 1);
env_transput.c:      INT_64_BIT x = ((A_INT *) (STACK_OFFSET (size_of (A_POINTER))))->value;
env_transput.c:			       moid_size (Mode (NUMBER)) - (size_of (A_POINTER) +
env_transput.c:	  ((A_POINTER *) STACK_TOP)->value = (void *) Mode (LONG_REAL);
env_transput.c:	  ((A_POINTER *) STACK_TOP)->value = (void *) Mode (LONGLONG_REAL);
env_transput.c:  stack_pointer = old_sp - size_of (A_INT) - moid_size (Mode (NUMBER));
env_transput.c:  stack_pointer = old_sp - 2 * size_of (A_INT) - moid_size (Mode (NUMBER));
env_transput.c:  stack_pointer = old_sp - 3 * size_of (A_INT) - moid_size (Mode (NUMBER));
garbage.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
garbage.c:/* A mark-and-sweep garbage collector */
garbage.c:  p->genie.heap_pointer = heap_pointer;
garbage.c:  p->genie.free_handles = free_handle_count;
garbage.c:      p->genie.heap_pointer = heap_pointer;
garbage.c:      p->genie.free_handles = free_handle_count;
garbage.c:	(double) (p->genie.free_handles - free_handle_count) / (double) max_handle_count;
garbage.c:	  p->genie.heap_pointer = heap_pointer;
garbage.c:	  p->genie.free_handles = free_handle_count;
garbage.c:	  double g = (double) (heap_pointer - p->genie.heap_pointer) / (double) heap_size;
garbage.c:	      p->genie.heap_pointer = heap_pointer;
garbage.c:	      p->genie.free_handles = free_handle_count;
garbage.c:  block_heap_compacter--;
garbage.c:  (z->handle)->status |= NO_SWEEP_MASK;
garbage.c:  (z->handle)->status &= ~NO_SWEEP_MASK;
garbage.c:  return (heap_size - heap_pointer);
garbage.c:      warror (A_RTE, module->top_node, "out of memory");
garbage.c:      exit_genie (module->top_node, 1);
garbage.c:      warror (A_RTE, module->top_node, "out of memory");
garbage.c:      exit_genie (module->top_node, 1);
garbage.c:  for (handle_pointer = 0; handle_pointer < (handle_pool_size - size_of (A_HANDLE));
garbage.c:      z->status = NULL_MASK;
garbage.c:      z->offset = 0;
garbage.c:      z->size = 0;
garbage.c:      z->number = counter++;
garbage.c:      PACK *p = m->pack;
garbage.c:  for (k = 0; k < arr->dim && span > 0; k++)
garbage.c:      ptr->k = ptr->lwb;
garbage.c:/* And now the x-dimensional sweeper starts */
garbage.c:  elem = ref_to_ptr (&(arr->array));
garbage.c:      for (k = 0; k < arr->dim; k++)
garbage.c:	  old_index += ptr->span * (ptr->k - ptr->shift);
garbage.c:      old_addr = (old_index + arr->slice_offset) * arr->elem_size + arr->field_offset;
garbage.c:      while (carry && ndim < arr->dim)
garbage.c:	  if (ptr->k < ptr->upb)
garbage.c:	      (ptr->k)++;
garbage.c:	      ptr->k = ptr->lwb;
garbage.c:      if (z != NULL && (z->status & INITIALISED_MASK) && z->handle != NULL
garbage.c:	  && !(z->handle->status & COLOUR_MASK))
garbage.c:	  if (z->handle->status & COOKIE_MASK)
garbage.c:	  z->handle->status |= COOKIE_MASK;
garbage.c:	  if (z->status & HEAP_MASK)
garbage.c:	      z->handle->status |= COLOUR_MASK;
garbage.c:	  z->handle->status &= ~COOKIE_MASK;
garbage.c:      PACK *p = m->pack;
garbage.c:	  colour_deep_heap (&address[p->offset], TYPE (p));
garbage.c:      if (z->status & INITIALISED_MASK && !(z->handle->status & COLOUR_MASK)
garbage.c:	  && z->handle != NULL)
garbage.c:	  if (z->handle->status & COOKIE_MASK)
garbage.c:	  z->handle->status |= COOKIE_MASK;
garbage.c:	  if (z->status & HEAP_MASK)
garbage.c:	      z->handle->status |= COLOUR_MASK;
garbage.c:	  if ((a->array).handle != NULL)
garbage.c:	      (a->array).handle->status |= COLOUR_MASK;
garbage.c:	  z->handle->status &= ~COOKIE_MASK;
garbage.c:      SYMBOL_TABLE *q = p->symbol_table;
garbage.c:	  for (i = q->identifiers; i != NULL; i = NEXT (i))
garbage.c:	      colour_deep_heap (FRAME_LOCAL (fp, i->offset), TYPE (i));
garbage.c:	  for (i = q->anonymous; i != NULL; i = NEXT (i))
garbage.c:	      colour_deep_heap (FRAME_LOCAL (fp, i->offset), TYPE (i));
garbage.c:      colour_heap (((A_REF *) & start_of_frames[fp])->value);
garbage.c:      if ((z->status & COLOUR_MASK) == 0 && (z->status & NO_SWEEP_MASK) == 0)
garbage.c:	  z->status &= ~ALLOCATED_MASK;
garbage.c:	  garbage_bytes_freed += z->size;
garbage.c:      goodbye ((z->status & COLOUR_MASK) == 0
garbage.c:	       && (z->status & NO_SWEEP_MASK) == 0, "bad GC consistency", NULL);
garbage.c:      if (HEAP_ADDRESS (heap_pointer) != HEAP_ADDRESS (z->offset))
garbage.c:	  memmove (HEAP_ADDRESS (heap_pointer), HEAP_ADDRESS (z->offset), z->size);
garbage.c:      z->status &= ~COLOUR_MASK;
garbage.c:      z->offset = heap_pointer;
garbage.c:      heap_pointer += z->size;
garbage.c:      goodbye ((z->status & COLOUR_MASK) != 0, "bad GC consistency", NULL);
garbage.c:      z->status &= ~(COLOUR_MASK | COOKIE_MASK);
garbage.c:  garbage_seconds += (seconds () - t0);
garbage.c:      x->status = ALLOCATED_MASK;
garbage.c:      x->offset = 0;
garbage.c:      x->size = 0;
garbage.c:      x->type = a68m;
garbage.c:      free_handle_count--;
garbage.c:      size += size_of (int) - rem;
garbage.c:      x->size = size;
garbage.c:      x->offset = heap_pointer;
genie.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie.c:  if (z->status & FRAME_MASK)
genie.c:      return (&start_of_frames[z->value]);
genie.c:  else if (z->status & HEAP_MASK)
genie.c:      return (&start_of_heap[z->value + z->handle->offset]);
genie.c:  else if (z->status & STACK_MASK)
genie.c:      return (&start_of_stack[z->value]);
genie.c:  else if (z->status & NIL_MASK)
genie.c:      printf ("\nstatus = %08x %08x", z->status, z->handle->status);
genie.c:  ret_line_number = LINE (p)->num;
genie.c:  return (t->identifiers == NULL && t->operators == NULL
genie.c:	  && t->priority == NULL && t->indicants == NULL && t->labels == NULL
genie.c:	  && t->local_identifiers == NULL && t->local_operators == NULL
genie.c:	  && t->anonymous == NULL);
genie.c:      p->genie.is_coercion = is_coercion (p);
genie.c:      p->genie.is_new_level = is_new_level (ATTRIBUTE (p));
genie.c:      p->genie.propagator.unit = genie_unit;
genie.c:      p->genie.propagator.clause = genie_enclosed;
genie.c:      p->genie.propagator.source = p;
genie.c:	  TYPE (p)->size = moid_size (TYPE (p));
genie.c:	  TYPE (p)->mode = mode_attribute (TYPE (p));
genie.c:      if (p->symbol_table != NULL)
genie.c:	  p->symbol_table->empty_table = genie_empty_table (p->symbol_table);
genie.c:	  if (p->symbol_table->level > *max_lev)
genie.c:	      *max_lev = p->symbol_table->level;
genie.c:	  if (q != NULL && q->node != NULL && q->node->symbol_table != NULL)
genie.c:	      p->genie.level = q->node->symbol_table->level;
genie.c:	  if (q != NULL && q->node != NULL && q->node->symbol_table != NULL)
genie.c:	      p->genie.level = q->node->symbol_table->level;
genie.c:	      p->genie.offset = &start_of_frames[FRAME_INFO_SIZE + q->offset];
genie.c:	  if (q != NULL && q->node != NULL && q->node->symbol_table != NULL)
genie.c:	      p->genie.level = q->node->symbol_table->level;
genie.c:	      p->genie.offset = &start_of_frames[FRAME_INFO_SIZE + q->offset];
genie.c:	  if (q->procedure == genie_add_int)
genie.c:	      p->genie.basic_operation = PLUS_INT;
genie.c:	  else if (q->procedure == genie_sub_int)
genie.c:	      p->genie.basic_operation = MINUS_INT;
genie.c:	  else if (q->procedure == genie_mul_int)
genie.c:	      p->genie.basic_operation = TIMES_INT;
genie.c:	  else if (q->procedure == genie_over_int)
genie.c:	      p->genie.basic_operation = OVER_INT;
genie.c:	  else if (q->procedure == genie_add_real)
genie.c:	      p->genie.basic_operation = PLUS_REAL;
genie.c:	  else if (q->procedure == genie_sub_real)
genie.c:	      p->genie.basic_operation = MINUS_REAL;
genie.c:	  else if (q->procedure == genie_mul_real)
genie.c:	      p->genie.basic_operation = TIMES_REAL;
genie.c:	  else if (q->procedure == genie_div_real)
genie.c:	      p->genie.basic_operation = DIV_REALS;
genie.c:	  p->genie.enclosed_children = A_TRUE;
genie.c:	  p->genie.enclosed_children =
genie.c:      return (p->genie.enclosed_children);
genie.c:      if (LINE (p)->num != 0)
genie.c:	      if (p->symbol_table->level < global_level || global_level == 0)
genie.c:		  global_level = p->symbol_table->level;
genie.c:/*  genie_lex_levels (module->top_node, 1); */
genie.c:  genie_preprocess (module->top_node, &max_lex_lvl);
genie.c:  genie_mark_enclosed_children (module->top_node);
genie.c:  if (module->options.trace)
genie.c:  if (module->options.time_limit > 0)
genie.c:      alarm (module->options.time_limit);
genie.c:      NODE *p = SUB (module->top_node);
genie.c:	  warror (A_RTE, module->top_node, "out of memory");
genie.c:	  exit_genie (module->top_node, 1);
genie.c:	  warror (A_RTE, module->top_node, "out of memory");
genie.c:	  exit_genie (module->top_node, 1);
genie.c:      FRAME_LEXICAL_LEVEL (frame_pointer) = p->symbol_table->level;
genie.c:      genie_init_transput (module->top_node);
genie.c:      (void) genie_enclosed (SUB (module->top_node));
genie.c:	  if (module->files.listing.opened)
genie.c:	      outimage (NULL, module->files.listing.stream, textline);
genie.c:/*	stack_dump (module->files.listing.stream, frame_pointer, 128); */
genie.c:	  heap_size -= HEAP_OVERHEAD * KILOBYTE;
genie.c:  warrortty (module->top_line, A_RTE);
genie.c:  if (module->options.trace)
genie.c:      sprintf (textline, "\n%sgenie finishes: %.2f seconds\n", BARS, seconds () - cputime_0);
genie_atoms.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_atoms.c:  INCREMENT_STACK_POINTER (p, size - (stack_pointer - sp));
genie_atoms.c:  if (SUB (p) != NULL && SUB (p)->constant != NULL)
genie_atoms.c:      self->unit = genie_constant;
genie_atoms.c:      p->constant = (void *) heap (size);
genie_atoms.c:      memmove (p->constant, (void *) (STACK_OFFSET (-size)), size);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:      xr = (mp_digit *) STACK_OFFSET (-2 * size_long_mp ());
genie_atoms.c:      xi = (mp_digit *) STACK_OFFSET (-size_long_mp ());
genie_atoms.c:      for (k = BITS_WIDTH - 1; k >= 0; k--)
genie_atoms.c:      if (SUB (p)->constant != NULL)
genie_atoms.c:	  p->constant = (void *) heap (size_of (A_REF));
genie_atoms.c:	  memcpy (p->constant, &z, size_of (A_REF));
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  row = genie_make_row (p, TYPE (p)->slice, 1, sp);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:/* REF ROW, decide whether we want A->[] A or [] A->[,] A */
genie_atoms.c:      if (Deflex (mode)->dim >= 2)
genie_atoms.c:/* ROW, decide whether we want A->[] A or [] A->[,] A */
genie_atoms.c:      if (Deflex (TYPE (p))->dim >= 2)
genie_atoms.c:  z.environ.value = descent_static_link (1 + TAX (label)->symbol_table->level);
genie_atoms.c:  switch (q->mode)
genie_atoms.c:	A_REF *z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	A_PROCEDURE *z = (A_PROCEDURE *) (STACK_OFFSET (-size_of (A_PROCEDURE)));
genie_atoms.c:	k = (z->body.status & INITIALISED_MASK) && (z->body.status & INITIALISED_MASK);
genie_atoms.c:	A_INT *z = (A_INT *) (STACK_OFFSET (-moid_size (q)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	A_INT *z = (A_INT *) (STACK_OFFSET (-size_of (A_INT)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	mp_digit *z = (mp_digit *) (STACK_OFFSET (-size_long_mp ()));
genie_atoms.c:	mp_digit *z = (mp_digit *) (STACK_OFFSET (-size_longlong_mp ()));
genie_atoms.c:	A_REAL *z = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	mp_digit *z = (mp_digit *) (STACK_OFFSET (-size_long_mp ()));
genie_atoms.c:	mp_digit *z = (mp_digit *) (STACK_OFFSET (-size_longlong_mp ()));
genie_atoms.c:	A_REAL *r = (A_REAL *) (STACK_OFFSET (-size_of (A_REAL)));
genie_atoms.c:	A_REAL *i = (A_REAL *) (STACK_OFFSET (-2 * size_of (A_REAL)));
genie_atoms.c:	k = (r->status & INITIALISED_MASK) && (i->status & INITIALISED_MASK);
genie_atoms.c:	mp_digit *r = (mp_digit *) (STACK_OFFSET (-2 * size_long_mp ()));
genie_atoms.c:	mp_digit *i = (mp_digit *) (STACK_OFFSET (-size_long_mp ()));
genie_atoms.c:	mp_digit *r = (mp_digit *) (STACK_OFFSET (-2 * size_longlong_mp ()));
genie_atoms.c:	mp_digit *i = (mp_digit *) (STACK_OFFSET (-size_longlong_mp ()));
genie_atoms.c:	A_BOOL *z = (A_BOOL *) (STACK_OFFSET (-size_of (A_BOOL)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	A_CHAR *z = (A_CHAR *) (STACK_OFFSET (-size_of (A_CHAR)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	A_BITS *z = (A_BITS *) (STACK_OFFSET (-size_of (A_BITS)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:	A_FILE *z = (A_FILE *) (STACK_OFFSET (-size_of (A_FILE)));
genie_atoms.c:	k = z->status & INITIALISED_MASK;
genie_atoms.c:      if (TAX (self.source)->loc_assigned)
genie_atoms.c:      self.source->genie.propagator.unit = self.unit;
genie_atoms.c:      self.source->genie.propagator.unit = self.unit;
genie_atoms.c:      self.source->genie.propagator.unit = self.unit;
genie_atoms.c:      self.source->genie.propagator.unit = self.unit;
genie_atoms.c:	    p->genie.propagator = genie_voiding (p);
genie_atoms.c:	    p->genie.propagator = genie_uniting (p);
genie_atoms.c:	    p->genie.propagator = genie_widening (p);
genie_atoms.c:	    p->genie.propagator = genie_rowing (p);
genie_atoms.c:	    p->genie.propagator = genie_dereferencing (p);
genie_atoms.c:	    p->genie.propagator = genie_deproceduring (p);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:      if (primary.unit == genie_identifier_standenv_proc && p->no_sweep == NULL)
genie_atoms.c:	  PACK *args = TYPE (prim)->pack;
genie_atoms.c:	  if (prim->genie.propagator.unit == genie_own_identifier
genie_atoms.c:	      && TAX (prim->genie.propagator.source)->loc_procedure && p->no_sweep == NULL)
genie_atoms.c:	  if (k.value < t->lwb)
genie_atoms.c:	  if (k.value > t->upb)
genie_atoms.c:	  (*offset) += t->span * (k.value - t->shift);
genie_atoms.c:	      L = old_tup->lwb;
genie_atoms.c:	      U = old_tup->upb;
genie_atoms.c:		  if (k.value < old_tup->lwb)
genie_atoms.c:		  L = old_tup->lwb;
genie_atoms.c:		  if (k.value > old_tup->upb)
genie_atoms.c:		  U = old_tup->upb;
genie_atoms.c:		  D = L - k.value;
genie_atoms.c:		  D = absent ? 0 : L - 1;
genie_atoms.c:	  new_tup->lwb = L - D;
genie_atoms.c:	  new_tup->upb = (L - D) + (U - L);
genie_atoms.c:	  new_tup->span = old_tup->span;
genie_atoms.c:	  new_tup->shift = old_tup->shift - D;
genie_atoms.c:      if (k->value < t->lwb)
genie_atoms.c:      else if (k->value > t->upb)
genie_atoms.c:      (*sum) += t->span * (k->value - t->shift);
genie_atoms.c:	    if (k->value < t->lwb)
genie_atoms.c:	    else if (k->value > t->upb)
genie_atoms.c:	    (*sum) += t->span * (k->value - t->shift);
genie_atoms.c:      heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_atoms.c:      adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_atoms.c:	  name.status = INITIALISED_MASK | x->array.status;
genie_atoms.c:	  name.value = x->array.value + adress;
genie_atoms.c:	  name.handle = x->array.handle;
genie_atoms.c:	  Push (p, ref_to_ptr (&(x->array)) + adress, MOID_SIZE (result_moid));
genie_atoms.c:      int new_size = size_of (A_ARRAY) + Deflex (result_moid)->dim * size_of (A_TUPLE);
genie_atoms.c:      new_des->dim = Deflex (result_moid)->dim;
genie_atoms.c:      new_des->type = old_des->type;
genie_atoms.c:      new_des->elem_size = old_des->elem_size;
genie_atoms.c:      offset = old_des->slice_offset;
genie_atoms.c:      new_des->slice_offset = offset;
genie_atoms.c:      new_des->field_offset = old_des->field_offset;
genie_atoms.c:      new_des->array = old_des->array;
genie_atoms.c:	  all_own &= s->genie.propagator.unit == genie_own_identifier;
genie_atoms.c:	  all_const &= s->genie.propagator.unit == genie_constant;
genie_atoms.c:      if (TAX (primary.source)->loc_assigned)
genie_atoms.c:      p->constant = (void *) heap (size_of (A_INT));
genie_atoms.c:      memmove (p->constant, &z, size_of (A_INT));
genie_atoms.c:      PUSH_INT (p, ((A_INT *) (p->constant))->value);
genie_atoms.c:      p->constant = (void *) heap (size_of (A_BITS));
genie_atoms.c:      memmove (p->constant, &z, size_of (A_BITS));
genie_atoms.c:      PUSH_BITS (p, ((A_BITS *) (p->constant))->value);
genie_atoms.c:      p->constant = (void *) heap (size_long_mp ());
genie_atoms.c:      memmove (p->constant, z, size_long_mp ());
genie_atoms.c:      p->constant = (void *) heap (size_longlong_mp ());
genie_atoms.c:      memmove (p->constant, z, size_longlong_mp ());
genie_atoms.c:      p->constant = (void *) heap (size_of (A_REAL));
genie_atoms.c:      memmove (p->constant, &z, size_of (A_REAL));
genie_atoms.c:      PUSH_REAL (p, ((A_REAL *) (p->constant))->value);
genie_atoms.c:      p->constant = (void *) heap (size_long_mp ());
genie_atoms.c:      memmove (p->constant, z, size_long_mp ());
genie_atoms.c:      p->constant = (void *) heap (size_longlong_mp ());
genie_atoms.c:      memmove (p->constant, z, size_longlong_mp ());
genie_atoms.c:      p->constant = (void *) heap (size_of (A_REF));
genie_atoms.c:      memmove (p->constant, &z, size_of (A_REF));
genie_atoms.c:      PUSH_REF (p, *(A_REF *) (p->constant));
genie_atoms.c:  (void) (q->procedure) (p);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  if (q->stand_env_proc != 0)
genie_atoms.c:  if (p->no_sweep != NULL)
genie_atoms.c:  if (p->genie.is_coercion)
genie_atoms.c:      p->genie.propagator = genie_coercion (p);
genie_atoms.c:	    p->genie.propagator = genie_primary (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_control_structure (p);
genie_atoms.c:	    p->genie.propagator = genie_identifier (p);
genie_atoms.c:	    p->genie.propagator = genie_call (p);
genie_atoms.c:	    p->genie.propagator = genie_slice (p);
genie_atoms.c:	    p->genie.propagator = genie_denoter (p);
genie_atoms.c:	    p->genie.propagator = genie_cast (p);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  if (SUB (TYPE (p))->type_has_rows)
genie_atoms.c:	      x.value = frame_pointer + FRAME_INFO_SIZE + TAX (p)->offset;
genie_atoms.c:	      y.value = frame_pointer + FRAME_INFO_SIZE + TAX (p)->offset;
genie_atoms.c:	  z.value = frame_pointer + FRAME_INFO_SIZE + TAX (p)->offset;
genie_atoms.c:      dims = Deflex (SUB (q))->dim;
genie_atoms.c:      ((A_ARRAY *) ref_to_ptr (&row2))->type = SUB (SUB (r));
genie_atoms.c:      ((A_ARRAY *) ref_to_ptr (&row2))->field_offset += SUB (p)->pack->offset;
genie_atoms.c:      dims = Deflex (q)->dim;
genie_atoms.c:      ((A_ARRAY *) ref_to_ptr (&row2))->type = SUB (r);
genie_atoms.c:      ((A_ARRAY *) ref_to_ptr (&row2))->field_offset += SUB (p)->pack->offset;
genie_atoms.c:      A_REF *z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
genie_atoms.c:      z->value += SUB (p)->pack->offset;
genie_atoms.c:      memmove (STACK_TOP, STACK_OFFSET (SUB (p)->pack->offset), MOID_SIZE (TYPE (p)));
genie_atoms.c:  if (p->genie.is_coercion)
genie_atoms.c:      p->genie.propagator = genie_coercion (p);
genie_atoms.c:	    p->genie.propagator = genie_generator (p);
genie_atoms.c:	    p->genie.propagator = genie_selection (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_secondary (SUB (p));
genie_atoms.c:	    p->genie.propagator.unit = genie_primary;
genie_atoms.c:	    p->genie.propagator.clause = NULL;
genie_atoms.c:	    p->genie.propagator.source = p;
genie_atoms.c:	    p->genie.propagator = genie_primary (p);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:      PACK *args = oper_moid->pack;
genie_atoms.c:  while (k--)
genie_atoms.c:      if (TAX (operators)->procedure != NULL)
genie_atoms.c:	  (void) (TAX (operators)->procedure) (operators);
genie_atoms.c:  BOOLEAN no_sweep_tag = (PARENT (p)->no_sweep == NULL);
genie_atoms.c:  lhs = p->genie.lhs = EXECUTE_UNIT (p);
genie_atoms.c:      PROPAGATOR rhs = NEXT (op)->genie.rhs = EXECUTE_UNIT (NEXT (op));
genie_atoms.c:      p->genie.rhs = rhs;
genie_atoms.c:      NEXT (op)->genie.lhs = lhs;
genie_atoms.c:      if (TAX (op)->procedure != NULL)
genie_atoms.c:	  (void) (TAX (op)->procedure) (op);
genie_atoms.c:	      switch (op->genie.basic_operation)
genie_atoms.c:  if (p->genie.is_coercion)
genie_atoms.c:      p->genie.propagator = genie_coercion (p);
genie_atoms.c:	    p->genie.propagator = genie_tertiary (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_formula (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_monadic (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_nihil (p);
genie_atoms.c:	    p->genie.propagator.unit = genie_secondary;
genie_atoms.c:	    p->genie.propagator.clause = NULL;
genie_atoms.c:	    p->genie.propagator.source = p;
genie_atoms.c:	    p->genie.propagator = genie_secondary (p);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  z = *(A_REF *) (STACK_OFFSET (-size_of (A_REF)));
genie_atoms.c:  if (source_moid->type_has_rows != 0)
genie_atoms.c:	  if (source_moid->has_flex)
genie_atoms.c:	  if (source_moid->has_flex)
genie_atoms.c:  A_PROCEDURE z = *(A_PROCEDURE *) (FRAME_OFFSET (FRAME_INFO_SIZE + p->routine->offset));
genie_atoms.c:      found = (TAX (label)->symbol_table == FRAME_TREE (f)->symbol_table)
genie_atoms.c:	      warror (A_RTE, p, "internal - cyclic frames", NULL);
genie_atoms.c:      warror (A_RTE, p, "internal - did not find frame for label");
genie_atoms.c:      warror (A_RTE, p, "internal - did not find jump buffer for label");
genie_atoms.c:  TAX (label)->symbol_table->jump_to = TAX (label)->unit;
genie_atoms.c:  if (p->genie.is_coercion)
genie_atoms.c:      p->genie.propagator = genie_coercion (p);
genie_atoms.c:	    p->genie.propagator = EXECUTE_UNIT (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_assignation (p);
genie_atoms.c:	    p->genie.propagator = genie_identity_relation (p);
genie_atoms.c:	    p->genie.propagator = genie_and_function (p);
genie_atoms.c:	    p->genie.propagator = genie_or_function (p);
genie_atoms.c:	    p->genie.propagator = genie_routine_text (p);
genie_atoms.c:	    p->genie.propagator = genie_skip (p);
genie_atoms.c:	    p->genie.propagator = genie_assertion (p);
genie_atoms.c:	    p->genie.propagator.unit = genie_tertiary;
genie_atoms.c:	    p->genie.propagator.clause = NULL;
genie_atoms.c:	    p->genie.propagator.source = p;
genie_atoms.c:	    p->genie.propagator = genie_tertiary (p);
genie_atoms.c:  return (p->genie.propagator);
genie_atoms.c:  if (p->symbol_table->labels == NULL)
genie_atoms.c:	    && SEQUENCE (p)->genie.enclosed_children == A_FALSE;
genie_atoms.c:	  NODE *jump_to = p->symbol_table->jump_to;
genie_atoms.c:      if (Deflex (m)->dim == 1)
genie_atoms.c:	  new_display = genie_make_row (p, Deflex (m)->slice, count, sp);
genie_atoms.c:/* [,,] AMODE display, we concatenate 1 + (n-1) to n dimensions */
genie_atoms.c:			       (FRAME_OFFSET (FRAME_INFO_SIZE + TAX (q)->offset)),
genie_atoms.c:				(FRAME_INFO_SIZE + TAX (q)->offset)),
genie_atoms.c:	    p->genie.propagator = genie_enclosed (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_closed (SUB (p));
genie_atoms.c:	    p->genie.propagator = genie_collateral (NEXT (SUB (p)));
genie_atoms.c:	    p->genie.propagator = genie_collateral (p);
genie_atoms.c:	    p->genie.propagator = genie_conditional_prop (p);
genie_atoms.c:	    p->genie.propagator = genie_loop (SUB (p));
genie_atoms.c:  return (p->genie.propagator);
genie_declare.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_declare.c:      sp -= size_of (A_TUPLE);
genie_declare.c:      t->span = genie_get_row_size (sp, dim - 1);
genie_declare.c:      return (t->span * w);
genie_declare.c:      if (TYPE (p)->type_has_rows != 0)
genie_declare.c:		  genie_prepare_declarer (NEXT (NEXT (TAX (p)->node)));
genie_declare.c:	  ;			/* Nothing to do - no rows here */
genie_declare.c:	  *declarer = (TYPE (p)->type_has_rows != 0) ? p : NULL;
genie_declare.c:	      h_ptr.value += (*field)->offset;
genie_declare.c:	  (*field) = (*field)->next;
genie_declare.c:  if (p != NULL && TYPE (p)->type_has_rows != 0)
genie_declare.c:		      (NEXT (NEXT (TAX (p)->node)), sp, h_ptr, hp_init));
genie_declare.c:	  int k, ndim = Deflex (TYPE (p))->dim;
genie_declare.c:	  heap_ptr = desc_ptr.handle->offset;
genie_declare.c:	      stack_ptr -= size_of (A_TUPLE);
genie_declare.c:	  if (TYPE (NEXT (p))->type_has_rows != 0)
genie_declare.c:	  PACK *Q = TYPE (p)->pack;
genie_declare.c:	    z.value = frame_pointer + FRAME_INFO_SIZE + TAX (p)->offset;
genie_declare.c:	    if (TYPE (p)->type_has_rows)
genie_declare.c:	    if (SUB (TYPE (p))->type_has_rows != 0)
genie_declare.c:		if (*declarer != NULL && SUB (TYPE (*declarer))->type_has_rows != 0)
genie_declare.c:			loc = *(A_REF *) (FRAME_OFFSET (FRAME_INFO_SIZE + TAX (p)->offset));
genie_declare.c:			z = (A_REF *) (FRAME_OFFSET (FRAME_INFO_SIZE + TAX (p)->offset));
genie_declare.c:			*(A_REF *) (start_of_frames + z->value) = row_ptr;
genie_declare.c:		*(A_REF *) (FRAME_OFFSET (FRAME_INFO_SIZE + TAX (p)->offset)) = z;
genie_declare.c:		if (SUB (TYPE (*declarer))->type_has_rows != 0)
genie_declare.c:		A_REF z = *(A_REF *) (FRAME_OFFSET (FRAME_INFO_SIZE + TAX (p)->offset));
genie_declare.c:		if (source_moid->type_has_rows)
genie_declare.c:			if (source_moid->has_flex)
genie_declare.c:			if (source_moid->has_flex)
genie_expres.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_expres.c:| come from cancelling "push-something-then-pop-same" pairs.
genie_expres.c:  z = ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value += z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value -= z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value *= z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_INT *) STACK_ADDRESS (old_stack_pointer))->value /= z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value += z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value -= z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value *= z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  z = ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value;
genie_expres.c:  ((A_REAL *) STACK_ADDRESS (old_stack_pointer))->value /= z;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  (void) (TAX (op)->procedure) (op);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  b->value = a->value + b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  b->value = b->value + a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  b->value = a->value - b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  b->value = b->value - a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  b->value = a->value * b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  b->value = b->value * a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  if (b->value == 0)
genie_expres.c:  b->value = a->value / b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  if (a->value == 0)
genie_expres.c:  b->value = b->value / a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  b->value = a->value + b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  b->value = b->value + a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  b->value = a->value - b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  b->value = b->value - a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  b->value = a->value * b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  b->value = b->value * a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  if (b->value == 0.0)
genie_expres.c:  b->value = a->value / b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  if (a->value == 0.0)
genie_expres.c:  b->value = b->value / a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = a->value + b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = b->value + a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = a->value - b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = b->value - a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = a->value * b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = b->value * a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  if (b->value == 0)
genie_expres.c:  b->value = a->value / b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  if (a->value == 0)
genie_expres.c:  b->value = b->value / a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = a->value + b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = b->value + a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = a->value - b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = b->value - a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = a->value * b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b->value = b->value * a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = p->genie.lhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  if (b->value == 0.0)
genie_expres.c:  b->value = a->value / b->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *q = NEXT (NEXT (p))->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  if (a->value == 0.0)
genie_expres.c:  b->value = b->value / a->value;
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  PUSH_INT (p, a->value + b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  PUSH_INT (p, a->value - b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  PUSH_INT (p, a->value * b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_INT *) FRAME_ADDRESS (z->value);
genie_expres.c:  if (b->value == 0)
genie_expres.c:  PUSH_INT (p, a->value / b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  PUSH_REAL (p, a->value + b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  PUSH_REAL (p, a->value - b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  PUSH_REAL (p, a->value * b->value);
genie_expres.c:  return (p->genie.propagator);
genie_expres.c:  NODE *lhs = p->genie.lhs.source;
genie_expres.c:  NODE *rhs = p->genie.rhs.source;
genie_expres.c:  a = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  b = (A_REAL *) FRAME_ADDRESS (z->value);
genie_expres.c:  if (b->value == 0.0)
genie_expres.c:  PUSH_REAL (p, a->value / b->value);
genie_expres.c:  return (p->genie.propagator);
genie_frame.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_frame.c:| It is more work to access non-local variables, but you don't have to copy the display on 
genie_frame.c:	      link->node->symbol_table->level, link->dynamic_link, link->static_link,
genie_frame.c:	      link->jump_stat, link->node);
genie_frame.c:      f = link->dynamic_link;
genie_frame.c:	    (*inits)->inits = save;
genie_frame.c:	    TAX (p)->loc_procedure = A_TRUE;
genie_frame.c:	    Pop (p, FRAME_OFFSET (FRAME_INFO_SIZE + TAX (p)->offset), MOID_SIZE (TYPE (p)));
genie_frame.c:      if (p->genie.is_new_level)
genie_frame.c:		genie_init_proc_op (SUB (p), &(SYMBOL_TABLE (p)->inits), n_init);
genie_frame.c:		    genie_init_proc_op (SUB (p), &(SYMBOL_TABLE (p)->inits), n_init);
genie_frame.c:  if (SYMBOL_TABLE (p)->inits == NULL)
genie_frame.c:      NODE *q = SYMBOL_TABLE (p)->inits;
genie_frame.c:      for (; q != NULL; q = q->inits)
genie_frame.c:	  TAX (q)->loc_procedure = A_TRUE;
genie_frame.c:	  Pop (q, FRAME_OFFSET (FRAME_INFO_SIZE + TAX (q)->offset), MOID_SIZE (TYPE (q)));
genie_frame.c:  if (!SYMBOL_TABLE (p)->initialise_frame)
genie_frame.c:  if (SYMBOL_TABLE (p)->initialise_anon)
genie_frame.c:      for (a = SYMBOL_TABLE (p)->anonymous; a != NULL; a = NEXT (a))
genie_frame.c:	  if (a->priority == ROUTINE_TEXT)
genie_frame.c:	      int youngest = TAX (a->node)->youngest_environ;
genie_frame.c:	      a->incarnation = 0;
genie_frame.c:	      z.body.value = (void *) a->node;
genie_frame.c:	      *(A_PROCEDURE *) (FRAME_OFFSET (FRAME_INFO_SIZE + a->offset)) = z;
genie_frame.c:	  else if (a->priority == Generator)
genie_frame.c:	      TAG *b = a->body;
genie_frame.c:		  b = SYMBOL_TABLE (p)->identifiers;
genie_frame.c:		  while (b != NULL && (SYMBOL (a->node) != SYMBOL (b->node)))
genie_frame.c:		  a->body = b;
genie_frame.c:		  p = (A_REF *) (FRAME_OFFSET (FRAME_INFO_SIZE + b->offset));
genie_frame.c:		  p->status = INITIALISED_MASK | FRAME_MASK;
genie_frame.c:		  p->value = frame_pointer + FRAME_INFO_SIZE + a->offset;
genie_frame.c:		  p->handle = &nil_handle;
genie_frame.c:		  p->handle->type = TYPE (b);
genie_frame.c:		  b->loc_assigned = A_TRUE;
genie_frame.c:      SYMBOL_TABLE (p)->initialise_anon = modifications > 0;
genie_frame.c:  if (SYMBOL_TABLE (p)->proc_ops)
genie_frame.c:      SYMBOL_TABLE (p)->proc_ops = genie_frame_constant (p) > 0;
genie_frame.c:  SYMBOL_TABLE (p)->initialise_frame = SYMBOL_TABLE (p)->initialise_anon
genie_frame.c:    || SYMBOL_TABLE (p)->proc_ops;
genie_frame.c:			   FRAME_INFO_SIZE + SYMBOL_TABLE (p)->ap_increment);
genie_frame.c:  memset ((A_BYTE *) (FRAME_OFFSET (FRAME_INFO_SIZE)), 0x00, SYMBOL_TABLE (p)->ap_increment);
genie_frame.c:      warror (A_RTE, p, "internal - circular stack frame", NULL);
genie_frame.c:      exit_genie (p, -1);
genie_moles.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_moles.c:| From New Latin - moles = mass, molecule = small mass. 
genie_moles.c:  Push (p, p->constant, MOID_SIZE (TYPE (p)));
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:/* Dereferences a unit; peephole saving of push-something-pop-same */
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  Push (p, &start_of_frames[z->value], MOID_SIZE (SUB (TYPE (p))));
genie_moles.c:  if (!(z->status & ASSIGNED_MASK))
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  if (!(z->status & ASSIGNED_MASK))
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *body = ((NODE *) z->body.value), *q = SEQUENCE (p);
genie_moles.c:  PACK *args = TYPE (id)->pack;
genie_moles.c:  open_frame (entry, IS_PROCEDURE_PARM, z->environ.value);
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      NODE *q = s->genie.propagator.source;
genie_moles.c:      if (k->value < t->lwb)
genie_moles.c:      else if (k->value > t->upb)
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  Push (p, &((ref_to_ptr (&(x->array)))[adress]), MOID_SIZE (result_moid));
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      NODE *q = s->genie.propagator.source;
genie_moles.c:      A_INT *k = (A_INT *) q->constant;
genie_moles.c:      if (k->value < t->lwb)
genie_moles.c:      else if (k->value > t->upb)
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  Push (p, ref_to_ptr (&(x->array)) + adress, MOID_SIZE (result_moid));
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:| for instance m [i, ENTIER 3 * random, k - 1] given REF [,,] INT m.
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      if (k->value < t->lwb)
genie_moles.c:      else if (k->value > t->upb)
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  Push (p, ref_to_ptr (&(x->array)) + adress, MOID_SIZE (result_moid));
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      NODE *q = s->genie.propagator.source;
genie_moles.c:      if (k->value < t->lwb)
genie_moles.c:      else if (k->value > t->upb)
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  name.status = INITIALISED_MASK | x->array.status;
genie_moles.c:  name.value = x->array.value + adress;
genie_moles.c:  name.handle = x->array.handle;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      NODE *q = s->genie.propagator.source;
genie_moles.c:      A_INT *k = (A_INT *) q->constant;
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  name.status = INITIALISED_MASK | x->array.status;
genie_moles.c:  name.value = x->array.value + adress;
genie_moles.c:  name.handle = x->array.handle;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:| for instance m [i, j + k, k - i] given REF [,,] INT m. Used in assigning to 
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      if (k->value < t->lwb)
genie_moles.c:      else if (k->value > t->upb)
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  name.status = INITIALISED_MASK | x->array.status;
genie_moles.c:  name.value = x->array.value + adress;
genie_moles.c:  name.handle = x->array.handle;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:| for instance m [i, j + k, k - i] given REF [,,] INT m. Used in assigning to 
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source, *s;
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:      if (k->value < t->lwb)
genie_moles.c:      else if (k->value > t->upb)
genie_moles.c:      index += t->span * (k->value - t->shift);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  name.status = INITIALISED_MASK | x->array.status;
genie_moles.c:  name.value = x->array.value + adress;
genie_moles.c:  name.handle = x->array.handle;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  heap_ptr = z.handle->offset + size_of (A_ARRAY);
genie_moles.c:  adress = (index + x->slice_offset) * x->elem_size + x->field_offset;
genie_moles.c:  name.status = INITIALISED_MASK | x->array.status;
genie_moles.c:  name.value = x->array.value + adress;
genie_moles.c:  name.handle = x->array.handle;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  x = TAX (prim->genie.propagator.source);
genie_moles.c:  (void) (x->procedure) (p);
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  z.body.value = (void *) q->procedure;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  memmove (STACK_TOP, STACK_OFFSET (SUB (p)->pack->offset), size);
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  z = (A_REF *) (STACK_OFFSET (-size_of (A_REF)));
genie_moles.c:  z->value += SUB (p)->pack->offset;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:| Example: bracketed sub-expressions: i * (j + k).
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source;
genie_moles.c:  z->status |= ASSIGNED_MASK;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source;
genie_moles.c:  z->status |= ASSIGNED_MASK;
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source;
genie_moles.c:  z->status |= ASSIGNED_MASK;
genie_moles.c:	   (A_BYTE *) (NEXT (NEXT (SUB (p)))->genie.propagator.source->constant), size);
genie_moles.c:  return (p->genie.propagator);
genie_moles.c:  NODE *q = SUB (p)->genie.propagator.source;
genie_moles.c:  z->status |= ASSIGNED_MASK;
genie_moles.c:	   (A_BYTE *) (NEXT (NEXT (SUB (p)))->genie.propagator.source->constant), size);
genie_moles.c:  return (p->genie.propagator);
genie_mon.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_mon.c:	  for (k = tup->lwb; k <= tup->upb; k++)
genie_mon.c:		(tup->span * (k - tup->shift) + arr->slice_offset) * arr->elem_size +
genie_mon.c:		arr->field_offset;
genie_mon.c:	      A_CHAR *ch = (A_CHAR *) (ref_to_ptr (&arr->array) + addr);
genie_mon.c:	      strchat (z, ch->value);
genie_mon.c:  if (heap_available () < minimum || (expr_stack_size - stack_pointer) < minimum)
genie_mon.c:      if ((z->status & INITIALISED_MASK) != 0)
genie_mon.c:	  PUSH_INT (p, z->value);
genie_mon.c:      if ((z->status & INITIALISED_MASK) != 0)
genie_mon.c:	  PUSH_REAL (p, z->value);
genie_mon.c:	  PUSH_INT (p, 8 - 1);
genie_mon.c:	  PUSH_INT (p, 8 - 1);
genie_mon.c:      if ((k->status & INITIALISED_MASK) != 0)
genie_mon.c:	  sprintf (textline, BITS_FORMAT, k->value);
genie_mon.c:      if ((z->status & INITIALISED_MASK) != 0)
genie_mon.c:	  sprintf (textline, "%s", z->value ? "TRUE" : "FALSE");
genie_mon.c:      if ((k->status & INITIALISED_MASK) != 0)
genie_mon.c:	  sprintf (textline, "\"%c\"", k->value);
genie_mon.c:  PACK *q = m->pack;
genie_mon.c:      sprintf (textline, "\n\t%s %s ", moid_str (TYPE (q), 32), q->text);
genie_mon.c:  if (z->status & INITIALISED_MASK)
genie_mon.c:      sprintf (textline, "\n\t%s ", moid_str (z->value, 32));
genie_mon.c:      show_data_item (f, p, (MOID *) z->value, &address[size_of (A_POINTER)]);
genie_mon.c:	  A_BYTE *chars = ref_to_ptr (&arr->array);
genie_mon.c:	  for (k = tup->lwb; k <= tup->upb; k++)
genie_mon.c:		(tup->span * (k - tup->shift) + arr->slice_offset) * arr->elem_size +
genie_mon.c:		arr->field_offset;
genie_mon.c:	      sprintf (textline, "%c", ch->value);
genie_mon.c:      sprintf (textline, "\n\tslice_offset = %d field_offset = %d\n", arr->slice_offset,
genie_mon.c:	       arr->field_offset);
genie_mon.c:      for (k = 0; k < Deflex (m)->dim; k++)
genie_mon.c:	  sprintf (textline, "HEAP %08x", q.value + q.handle->offset);
genie_mon.c:	  sprintf (textline, "TREE %08x", ((NODE *) z.body.value)->num);
genie_mon.c:      A_ADDR pos_in_frame_stack = link + FRAME_INFO_SIZE + q->offset;
genie_mon.c:		   moid_str (TYPE (q), 32), SYMBOL (q->node));
genie_mon.c:	  show_data_item (f, p, TYPE (q), FRAME_LOCAL (link, q->offset));
genie_mon.c:	  switch (q->priority)
genie_mon.c:		show_data_item (f, p, TYPE (q), FRAME_LOCAL (link, q->offset));
genie_mon.c:      SYMBOL_TABLE *q = p->symbol_table;
genie_mon.c:      sprintf (textline, "\n%sStack frame level %d", BARS, q->level);
genie_mon.c:      show_frame_vars (f, p, link, q->identifiers, Identifier);
genie_mon.c:      show_frame_vars (f, p, link, q->operators, Operator);
genie_mon.c:      show_frame_vars (f, p, link, q->anonymous, Anonymous);
genie_mon.c:/* Draws a '-' beneath the position in the source line where 'p' is at */
genie_mon.c:  SOURCE_LINE *l = p->info->line;
genie_mon.c:  int k, pos_in_line = strlen (l->String) - strlen (p->info->char_in_line);
genie_mon.c:  strncpy (z, l->String, BUFFER_SIZE);
genie_mon.c:  z[BUFFER_SIZE - 1] = '\0';
genie_mon.c:  sprintf (textline, "\n%-4d %s\n     ", l->num, z);
genie_mon.c:  sprintf (textline, "-\n");
genie_mon.c:| Shows lines where 'p' is at and draws a '-' beneath the position in the source line 
genie_mon.c:  if (p != NULL && p->info->module != NULL)
genie_mon.c:      SOURCE_LINE *r = p->info->line;
genie_mon.c:      SOURCE_LINE *l = p->info->module->top_line;
genie_mon.c:	  if (abs (r->num - l->num) <= depth)
genie_mon.c:	      int k, pos_in_line = strlen (l->String) - strlen (p->info->char_in_line);
genie_mon.c:	      strncpy (z, l->String, BUFFER_SIZE);
genie_mon.c:	      z[BUFFER_SIZE - 1] = '\0';
genie_mon.c:	      sprintf (textline, "\n%-4d %s", l->num, z);
genie_mon.c:		  sprintf (textline, "-");
genie_mon.c:      sprintf (textline, "\n%s%08x %s", BARS, handle->offset, moid_str (TYPE (handle), 32));
genie_mon.c:      stack_dump (f, dynamic_link, depth - 1);
genie_mon.c:  sprintf (textline, "\nHT         Halt Typing - suppress output to tty");
genie_mon.c:  sprintf (textline, "\nHX         Halt Execution - terminates the program");
genie_mon.c:  SYMBOL_TABLE *q = p->symbol_table;
genie_mon.c:  sprintf (textline, "\n%sStack frame level %d", BARS, q->level);
genie_name.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_row.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_row.c:  arr->dim = 1;
genie_row.c:  arr->type = Mode (CHAR);
genie_row.c:  arr->elem_size = moid_size (Mode (CHAR));
genie_row.c:  arr->slice_offset = 0;
genie_row.c:  arr->field_offset = 0;
genie_row.c:  arr->array.status = INITIALISED_MASK | HEAP_MASK;
genie_row.c:  arr->array.value = 0;
genie_row.c:  arr->array.handle = &nil_handle;
genie_row.c:  tup->lwb = 1;
genie_row.c:  tup->upb = 0;
genie_row.c:  tup->span = 1;
genie_row.c:  tup->shift = tup->lwb;
genie_row.c:  arr->dim = 1;
genie_row.c:  arr->type = src_mode;
genie_row.c:  arr->elem_size = MOID_SIZE (src_mode);
genie_row.c:  arr->slice_offset = 0;
genie_row.c:  arr->field_offset = 0;
genie_row.c:  arr->array = array;
genie_row.c:  tup->lwb = 1;
genie_row.c:  tup->upb = 1;
genie_row.c:  tup->shift = tup->lwb;
genie_row.c:  tup->span = 1;
genie_row.c:    heap_generator (p, dst_mode, size_of (A_ARRAY) + SUB (dst_mode)->dim * size_of (A_TUPLE));
genie_row.c:  new_arr->dim = SUB (dst_mode)->dim;
genie_row.c:  new_arr->type = old_arr->type;
genie_row.c:  new_arr->elem_size = old_arr->elem_size;
genie_row.c:  new_arr->slice_offset = 0;
genie_row.c:  new_arr->field_offset = 0;
genie_row.c:  new_arr->array = old_arr->array;
genie_row.c:  for (k = 0; k < SUB (src_mode)->dim; k++)
genie_row.c: | In the stack are 'm' n-dimensional arrays.
genie_row.c: | This routine makes a (n+1)-dimensional array from them.
genie_row.c:  int i, j, k, span, dim = Deflex (amode)->dim - 1;
genie_row.c:    heap_generator (p, amode, size_of (A_ARRAY) + Deflex (amode)->dim * size_of (A_TUPLE));
genie_row.c:  new_arr->dim = Deflex (amode)->dim;
genie_row.c:  new_arr->type = SUB (amode);
genie_row.c:  new_arr->elem_size = MOID_SIZE (SUB (amode));
genie_row.c:  new_arr->slice_offset = 0;
genie_row.c:  new_arr->field_offset = 0;
genie_row.c:	  A_REF dst = genie_copy_row (*src, p, Deflex (amode->slice));
genie_row.c:		  if ((ref_tup->upb != run_tup->upb) || (ref_tup->lwb != run_tup->lwb))
genie_row.c:	  old_t = ref_tup + (dim - 1 - k);
genie_row.c:	  new_t = new_tup + (dim - k);
genie_row.c:	  new_t->lwb = old_t->lwb;
genie_row.c:	  new_t->upb = old_t->upb;
genie_row.c:/*        new_t->shift = 1; */
genie_row.c:	  new_t->shift = new_t->lwb;
genie_row.c:	  new_t->span = span;
genie_row.c:  new_tup->lwb = 1;
genie_row.c:  new_tup->upb = m;
genie_row.c:  new_tup->shift = new_tup->lwb;
genie_row.c:  new_tup->span = span;
genie_row.c:  new_arr->array = heap_generator (p, TYPE (p), m * span * new_arr->elem_size);
genie_row.c:	  for (k = dim; k > 0; k--)
genie_row.c:	      old_t = ref_tup + (k - 1);
genie_row.c:	      old_t->k = old_t->lwb;
genie_row.c:	      new_t->k = new_t->lwb;
genie_row.c:	  old_elem = ref_to_ptr (&(ref_arr->array));
genie_row.c:	  new_elem = ref_to_ptr (&(new_arr->array));
genie_row.c:		  old_index += old_t->span * (old_t->k - old_t->shift);
genie_row.c:		(old_index + ref_arr->slice_offset) * ref_arr->elem_size +
genie_row.c:		ref_arr->field_offset;
genie_row.c:	      new_index = j * new_tup->span;
genie_row.c:		  new_index += new_t->span * (new_t->k - new_t->shift);
genie_row.c:		(new_index + new_arr->slice_offset) * new_arr->elem_size +
genie_row.c:		new_arr->field_offset;
genie_row.c:		       new_arr->elem_size);
genie_row.c:		  if (old_t->k < old_t->upb)
genie_row.c:		      (old_t->k)++;
genie_row.c:		      (new_t->k)++;
genie_row.c:		      old_t->k = old_t->lwb;
genie_row.c:		      new_t->k = new_t->lwb;
genie_row.c:  arr->dim = 1;
genie_row.c:  arr->type = amode;
genie_row.c:  arr->elem_size = MOID_SIZE (amode);
genie_row.c:  arr->slice_offset = 0;
genie_row.c:  arr->field_offset = 0;
genie_row.c:  arr->array = new_arr;
genie_row.c:  tup->lwb = 1;
genie_row.c:  tup->upb = m;
genie_row.c:  tup->shift = tup->lwb;
genie_row.c:  tup->span = 1;
genie_row.c:      A_ADDR offset = k * arr->elem_size;
genie_row.c:      if (amode->type_has_rows)
genie_row.c:		   arr->elem_size);
genie_row.c:      for (pack = m->pack; pack != NULL; pack = NEXT (pack))
genie_row.c:	  new_old.value += pack->offset;
genie_row.c:	  new_dst.value += pack->offset;
genie_row.c:	  if (TYPE (pack)->type_has_rows)
genie_row.c:  new_row = heap_generator (p, m, size_of (A_ARRAY) + old_arr->dim * size_of (A_TUPLE));
genie_row.c:  new_arr->dim = old_arr->dim;
genie_row.c:  new_arr->type = old_arr->type;
genie_row.c:  new_arr->elem_size = old_arr->elem_size;
genie_row.c:  new_arr->slice_offset = 0;
genie_row.c:  new_arr->field_offset = 0;
genie_row.c:  for (k = 1; k <= old_arr->dim; k++)
genie_row.c:      old_p = &(old_tup[old_arr->dim - k]);
genie_row.c:      new_p = &(new_tup[new_arr->dim - k]);
genie_row.c:      new_p->lwb = old_p->lwb;
genie_row.c:      new_p->upb = old_p->upb;
genie_row.c:      new_p->span = span;
genie_row.c:/*        new_p->shift = 1; */
genie_row.c:      new_p->shift = new_p->lwb;
genie_row.c:      old_p->k = old_p->lwb;
genie_row.c:      new_p->k = new_p->lwb;
genie_row.c:  new_arr->array = heap_generator (p, TYPE (p), span * new_arr->elem_size);
genie_row.c:/* And now the x-dimensional copier starts */
genie_row.c:      old_elem = ref_to_ptr (&(old_arr->array));
genie_row.c:      new_elem = ref_to_ptr (&(new_arr->array));
genie_row.c:	  for (k = 0; k < old_arr->dim; k++)
genie_row.c:	      old_index += old_p->span * (old_p->k - old_p->shift);
genie_row.c:	    (old_index + old_arr->slice_offset) * old_arr->elem_size + old_arr->field_offset;
genie_row.c:	  for (k = 0; k < new_arr->dim; k++)
genie_row.c:	      new_index += new_p->span * (new_p->k - new_p->shift);
genie_row.c:	    (new_index + new_arr->slice_offset) * new_arr->elem_size + new_arr->field_offset;
genie_row.c:	  if (SUB (m)->type_has_rows)
genie_row.c:	      A_REF new_old = old_arr->array, new_dst = new_arr->array;
genie_row.c:	      else if (ATTRIBUTE (m->slice) == _FLEX_ || m->slice == Mode (STRING))
genie_row.c:	      else if (ATTRIBUTE (m->slice) == _ROW_)
genie_row.c:		       moid_size (old_arr->type));
genie_row.c:	  while (carry && ndim < old_arr->dim)
genie_row.c:	      if (old_p->k < old_p->upb)
genie_row.c:		  (old_p->k)++;
genie_row.c:		  (new_p->k)++;
genie_row.c:		  old_p->k = old_p->lwb;
genie_row.c:		  new_p->k = new_p->lwb;
genie_row.c:      for (pack = m->pack; pack != NULL; pack = NEXT (pack))
genie_row.c:	  new_old.value += pack->offset;
genie_row.c:	  new_dst.value += pack->offset;
genie_row.c:	  if (TYPE (pack)->type_has_rows)
genie_row.c:  for (k = 1; k <= old_arr->dim; k++)
genie_row.c:      old_p = &(old_tup[old_arr->dim - k]);
genie_row.c:      new_p = &(new_tup[new_arr->dim - k]);
genie_row.c:      if (bound_check && ((new_p->upb != old_p->upb) || (new_p->lwb != old_p->lwb)))
genie_row.c:      old_p->k = old_p->lwb;
genie_row.c:      new_p->k = new_p->lwb;
genie_row.c:/* The n-dimensional copier */
genie_row.c:      old_elem = ref_to_ptr (&(old_arr->array));
genie_row.c:      new_elem = ref_to_ptr (&(new_arr->array));
genie_row.c:	  for (k = 0; k < old_arr->dim; k++)
genie_row.c:	      old_index += old_p->span * (old_p->k - old_p->shift);
genie_row.c:	    (old_index + old_arr->slice_offset) * old_arr->elem_size + old_arr->field_offset;
genie_row.c:	  for (k = 0; k < new_arr->dim; k++)
genie_row.c:	      new_index += new_p->span * (new_p->k - new_p->shift);
genie_row.c:	    (new_index + new_arr->slice_offset) * new_arr->elem_size + new_arr->field_offset;
genie_row.c:	  if (SUB (m)->type_has_rows)
genie_row.c:	      A_REF new_old = old_arr->array, new_dst = new_arr->array;
genie_row.c:	      else if (ATTRIBUTE (m->slice) == _FLEX_ || m->slice == Mode (STRING))
genie_row.c:	      else if (ATTRIBUTE (m->slice) == _ROW_)
genie_row.c:		       moid_size (old_arr->type));
genie_row.c:	  while (carry && ndim < old_arr->dim)
genie_row.c:	      if (old_p->k < old_p->upb)
genie_row.c:		  (old_p->k)++;
genie_row.c:		  (new_p->k)++;
genie_row.c:		  old_p->k = old_p->lwb;
genie_row.c:		  new_p->k = new_p->lwb;
genie_signal.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_volatile.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
genie_volatile.c:		  *(A_INT *) (FRAME_OFFSET (FRAME_INFO_SIZE + TAX (counter)->offset)) = var;
genie_volatile.c:	      if (q->symbol_table->initialise_frame)
heap.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
keywords.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
keywords.c:      int k = strcmp (z, (*p)->text);
keywords.c:	  p = &(*p)->less;
keywords.c:	  p = &(*p)->more;
keywords.c:  (*p)->text = z;
keywords.c:  (*p)->less = (*p)->more = NULL;
keywords.c:      int k = strcmp (t, (*p)->text);
keywords.c:	  p = &(*p)->less;
keywords.c:	  p = &(*p)->more;
keywords.c:	  p = p->less;
keywords.c:	  p = p->more;
keywords.c:	  return (p->text);
keywords.c:      int k = a - (*p)->attribute;
keywords.c:	  p = &(*p)->less;
keywords.c:	  p = &(*p)->more;
keywords.c:  (*p)->attribute = a;
keywords.c:  (*p)->text = t;
keywords.c:  (*p)->less = (*p)->more = NULL;
keywords.c:      int k = strcmp (t, (*p)->text);
keywords.c:	  p = &(*p)->less;
keywords.c:	  p = &(*p)->more;
keywords.c:  (*p)->attribute = a;
keywords.c:  (*p)->text = t;
keywords.c:  (*p)->less = (*p)->more = NULL;
keywords.c:      int k = strcmp (t, p->text);
keywords.c:	  p = p->less;
keywords.c:	  p = p->more;
keywords.c:      if ((z = find_keyword_att (p->less, a)) != NULL)
keywords.c:      else if ((z = find_keyword_att (p->more, a)) != NULL)
listing.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
listing.c:	return ("---");
listing.c:  while (*s != '\0' && (n--) != 0)
listing.c:		  z[1] = '-';
listing.c:  sprintf (q, "%04x", p->num);
listing.c:      int i = z->dim;
listing.c:	  while (i--)
listing.c:      sprintf (textline, "%s", SYMBOL (z->node));
listing.c:      if (pack->text != NULL)
listing.c:	  sprintf (textline, " %s", pack->text);
listing.c:	  int i = z->dim;
listing.c:	  while (--i)
listing.c:	  brief_fields_flat (f, z->pack);
listing.c:	  brief_fields_flat (f, z->pack);
listing.c:	  if (z->pack != NULL)
listing.c:	      brief_fields_flat (f, z->pack);
listing.c:	  brief_fields_flat (f, z->pack);
listing.c:	  brief_fields_flat (f, z->pack);
listing.c:      if (m->equivalent_mode != NULL)
listing.c:      if (m->slice != NULL)
listing.c:	  sprintf (textline, "slice:%s ", dtoa (m->slice));
listing.c:      if (m->deflexed_mode != NULL)
listing.c:	  sprintf (textline, "deflex:%s ", dtoa (m->deflexed_mode));
listing.c:      if (m->multiple_mode != NULL)
listing.c:	  sprintf (textline, "multiple:%s ", dtoa (m->multiple_mode));
listing.c:      if (m->name != NULL)
listing.c:	  sprintf (textline, "name:%s ", dtoa (m->name));
listing.c:      if (m->trim != NULL)
listing.c:	  sprintf (textline, "trim:%s ", dtoa (m->trim));
listing.c:      if (m->use == A_FALSE)
listing.c:      NODE *where = s->node;
listing.c:      if (where != NULL && ((MASK (where) & CROSS_REFERENCE_MASK) || where->num == -1))
listing.c:		sprintf (textline, "%s ", SYMBOL (s->node));
listing.c:		sprintf (textline, "%s ", SYMBOL (s->node));
listing.c:		sprintf (textline, "Priority %s %d", SYMBOL (s->node), s->priority);
listing.c:		sprintf (textline, "%s ", SYMBOL (s->node));
listing.c:		sprintf (textline, "LABEL %s", SYMBOL (s->node));
listing.c:		sprintf (textline, " %04x", s->unit->num);
listing.c:		switch (s->priority)
listing.c:		      sprintf (textline, " (sweep %04x)", s->node->num);
listing.c:	  if (where != NULL && where->info != NULL && where->info->line != NULL)
listing.c:	      sprintf (textline, ", line %d", where->info->line->num);
listing.c:	  if (where != NULL && where->info != NULL && TAX (where) != NULL)
listing.c:	      sprintf (textline, ", offset %x", s->offset);
listing.c:  if (next->indicants != NULL)
listing.c:      xref_tags (f, next->indicants, Indicant);
listing.c:  if (next->operators != NULL)
listing.c:      xref_tags (f, next->operators, _OP_);
listing.c:  if (next->priority != NULL)
listing.c:      xref_tags (f, next->priority, _PRIO_);
listing.c:  if (next->identifiers != NULL)
listing.c:      xref_tags (f, next->identifiers, Identifier);
listing.c:  if (next->labels != NULL)
listing.c:      xref_tags (f, next->labels, LABEL);
listing.c:  if (next->anonymous != NULL)
listing.c:      xref_tags (f, next->anonymous, Anonymous);
listing.c:      sprintf (textline, "\n%sMode %04x ", BARS, p->num);
listing.c:	      SYMBOL_TABLE *c = SUB (p)->symbol_table;
listing.c:	      if (c->indicants == NULL && c->operators == NULL
listing.c:		  && c->priority == NULL && c->identifiers == NULL && c->anonymous == NULL
listing.c:		  && c->labels == NULL)
listing.c:	      sprintf (textline, "\n%sCross reference level %d", BARS, c->level);
listing.c:	      if (c->previous == stand_env)
listing.c:		  sprintf (textline, ", embedded in level %d", c->previous->level);
listing.c:	      if (c->moids != NULL)
listing.c:		  xref_moids (f, c->moids);
listing.c:		      sprintf (editline, "%04x ", TYPE (p)->num);
listing.c:		  sprintf (textline, " %-30s", editline);
listing.c:		  else if (p->genie.propagator.unit != genie_unit
listing.c:			   && genie_function_name (p->genie.propagator.unit) != NULL)
listing.c:		      strcat (editline, genie_function_name (p->genie.propagator.unit));
listing.c:		  sprintf (textline, " %-12s", editline);
listing.c:		  if (p->info->PROCEDURE_NUMBER != 0)
listing.c:		      sprintf (textline, " %c", dig2char (p->info->PROCEDURE_NUMBER));
listing.c:		  if (p->info->PROCEDURE_LEVEL != 0)
listing.c:		      sprintf (textline, " %c", dig2char (p->info->PROCEDURE_LEVEL));
listing.c:		  sprintf (textline, " %04x", p->num);
listing.c:		  if (p->genie.propagator.unit != NULL
listing.c:		      && p->genie.propagator.source->num != p->num)
listing.c:		      sprintf (textline, " %04x", p->genie.propagator.source->num);
listing.c:		  if (p->genie.propagator.clause != NULL
listing.c:		      && p->genie.propagator.source->num != p->num)
listing.c:		      sprintf (textline, " %04x", p->genie.propagator.source->num);
listing.c:		  if (p->symbol_table != NULL)
listing.c:		      sprintf (textline, " %c", dig2char (p->symbol_table->level));
listing.c:		  if (p->constant != NULL)
listing.c:		  if (p->no_sweep != NULL)
listing.c:		  if (p->symbol_table != NULL)
listing.c:		      if (p->symbol_table->empty_table)
listing.c:		      if (p->symbol_table->initialise_frame)
listing.c:		      if (p->symbol_table->initialise_anon)
listing.c:		      if (p->symbol_table->proc_ops)
listing.c:  SOURCE_LINE *line = module->top_line;
listing.c:  FILE *f = module->files.listing.stream;
listing.c:  if (module->files.listing.opened == 0)
listing.c:      int k = strlen (line->String) - 1;
listing.c:      if (line->num <= 0)
listing.c:      if ((line->String)[k] == '\n')
listing.c:	  (line->String)[k] = '\0';
listing.c:      if (line->list != 0)
listing.c:	  sprintf (textline, "\n\t%-4d", line->num);
listing.c:		       make_numbers (line->min_proc_level, line->max_proc_level),
listing.c:		       make_numbers (line->min_level, line->max_level));
listing.c:	    char d[LINE_LENGTH + 1], *s = line->String;
listing.c:	  if (line->messages != NULL)
listing.c:	      MESSAGE *d = line->messages;
listing.c:	      char *p = line->String;
listing.c:		      for (d = line->messages; d != NULL; d = NEXT (d))
listing.c:			  if (d->where->info->char_in_line == p && ++more == 1)
listing.c:			      first = d->num;
listing.c:			      length = strlen (SYMBOL (d->where));
listing.c:	      for (d = line->messages; d != NULL; d = NEXT (d))
listing.c:		  sprintf (textline, "\n%s", d->text);
listing.c:	  if (module->options.cross_reference)
listing.c:	      cross_reference (f, line->top_node, line);
listing.c:	  if (module->options.tree_listing && leaves_to_print (module->top_node, line))
listing.c:	      low_level (module->top_node, 1, &y, line);
listing.c:	      tree_listing (f, module->top_node, 1, &y, line);
listing.c:  SOURCE_LINE *line = module->top_line;
listing.c:  if (module->files.listing.opened == 0)
listing.c:      int k = strlen (line->String) - 1;
listing.c:      if ((line->String)[k] == '\n')
listing.c:	  (line->String)[k] = '\0';
listing.c:      if (line->list != 0)
listing.c:	  sprintf (textline, "\n%-4d", line->num);
listing.c:		       make_numbers (line->min_proc_level, line->max_proc_level),
listing.c:		       make_numbers (line->min_level, line->max_level));
listing.c:	    char d[LINE_LENGTH + 1], *s = line->String;
listing.c:	  if (line->messages != NULL)
listing.c:	      MESSAGE *d = line->messages;
listing.c:	      char *p = line->String;
listing.c:		      for (d = line->messages; d != NULL; d = NEXT (d))
listing.c:			  if (d->where->info->char_in_line == p && ++more == 1)
listing.c:			      first = d->num;
listing.c:			      length = strlen (SYMBOL (d->where));
listing.c:	      for (d = line->messages; d != NULL; d = NEXT (d))
listing.c:		  sprintf (textline, "\n%s", d->text);
listing.c:  FILE *f = module->files.listing.stream;
listing.c:  if (module->options.moid_listing && top_moid_list != NULL)
listing.c:  if (module->options.standard_prelude_listing && stand_env != NULL)
listing.c:  if (module->top_refinement != NULL)
listing.c:      REFINEMENT *x = module->top_refinement;
listing.c:	  sprintf (textline, "\n\t\"%s\"", x->name);
listing.c:	  if (x->line != NULL)
listing.c:	      sprintf (textline, ", defined in line %d", x->line->num);
listing.c:	  if (x->appl != NULL)
listing.c:	      sprintf (textline, ", applied in line %d", x->appl->num);
listing.c:	  switch (x->applications)
listing.c:  if (module->options.list != NULL)
listing.c:      for (i = module->options.list; i != NULL; i = NEXT (i))
listing.c:	  sprintf (textline, " %s", i->str);
listing.c:  if (module->options.statistics_listing)
listing.c:	  for (z = module->top_line; z != NULL; z = NEXT (z))
listing.c:	      for (d = z->messages; d != NULL; d = NEXT (d))
listing.c:		  sprintf (textline, "\n\tline %d: %s: %s", z->num, phase.text[d->phase],
listing.c:			   d->text);
message.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
message.c:      if (m->pack != NULL && NEXT (m->pack) == NULL)
message.c:	  return (TYPE (m->pack));
message.c:|  M moid - if error mode return without giving a message
message.c:|  N moid - MOID (NULL)
message.c:  if (p != NULL && p->info != NULL && p->info->module != NULL)
message.c:      if (sev == A_WRN && p->info->module->options.no_warnings)
message.c:	  if (a->num > 0)
message.c:	      sprintf (d, "in line %d", a->num);
message.c:	  strcat (q, atoa ("\"%s\"", find_keyword_att (top_keyword, att)->text));
message.c:	  if (m != NULL && m->files.generic_name != NULL)
message.c:	      sprintf (textline, "\n%s%s: %s: %s", STARS, m->files.generic_name, st, b);
message.c:	  MESSAGE **msg_ptr = &(LINE (p)->messages);
message.c:	      msg_ptr = &((*msg_ptr)->next);
message.c:	  if (LINE (p)->num > 0)
message.c:		       p->info->module->files.generic_name, LINE (p)->num, st, b, k);
message.c:		       p->info->module->files.generic_name, st, b, k);
message.c:	  msg->phase = phase.k;
message.c:	  msg->text = new_string (a);
message.c:	  msg->where = p;
message.c:	  msg->num = k;
message.c:	  msg->message_number = 0;
message.c:	  if (p->msg == NULL)
message.c:	      p->msg = msg;
message.c:	  if (m != NULL && m->files.generic_name != NULL)
message.c:	  MESSAGE **msg_ptr = &(LINE (p)->messages);
message.c:	      msg_ptr = &((*msg_ptr)->next);
message.c:	  if (LINE (p)->num > 0)
message.c:	  msg->phase = phase.k;
message.c:	  msg->text = new_string (a);
message.c:	  msg->where = p;
message.c:	  msg->num = k;
message.c:	  msg->message_number = 0;
message.c:	  if (p->msg == NULL)
message.c:	      p->msg = msg;
message.c:      MESSAGE *d = p->messages;
message.c:	  MESSAGE *d = p->messages;
message.c:	  if ((p->String)[strlen (p->String) - 1] == '\n')
message.c:	      (p->String)[strlen (p->String) - 1] = '\0';
message.c:	  sprintf (textline, "\n%-4d %s\n     ", p->num, p->String);
message.c:	  c = p->String;
message.c:		  for (d = p->messages; d != NULL; d = NEXT (d))
message.c:		      if (d->where->info->char_in_line == c && ++more == 1)
message.c:			  f = d->num;
message.c:	  for (d = p->messages; d != NULL; d = NEXT (d))
message.c:		  sprintf (textline, "\n%s", d->text);
message.c:		  sprintf (textline, "\n%s", d->text);
moids.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
moids.c:  MOID *p = stand_env->moids, *q = NULL;
moids.c:	  && SYMBOL (p->node) == SYMBOL (indicant))
moids.c:	  return (get_mode_from_standard_moid (sizety - 1, indicant, A_FALSE));
moids.c:  x->in_standard_environ = z == &(stand_env->moids);
moids.c:  x->use = A_FALSE;
moids.c:  x->size = 0;
moids.c:  x->num = mode_count++;
moids.c:  x->node = node;
moids.c:  x->safe = 1;
moids.c:  x->type_has_rows = att == _ROW_;
moids.c:  x->pack = pack;
moids.c:  x->slice = NULL;
moids.c:  x->deflexed_mode = NULL;
moids.c:  x->name = NULL;
moids.c:  x->multiple_mode = NULL;
moids.c:  x->trim = NULL;
moids.c:  z->text = text;
moids.c:  z->node = node;
moids.c:	    return (-1);
moids.c:		TYPE (t->node) = new_one;
moids.c:		TYPE (t->node) = z;
moids.c:      (*p)->slice = add_row (&NEXT (*p), k - 1, f, n);
moids.c:      (*p)->slice = f;
moids.c:	      m = &p->symbol_table->moids;
moids.c:	      m = &p->symbol_table->previous->moids;
moids.c:	      TYPE (p)->slice = new_one->slice;
moids.c:  m = &(p->symbol_table->previous->moids);
moids.c:  MOID **m = &p->symbol_table->moids, *new_one;
moids.c:	      MOID **m = &q->symbol_table->moids, *new_one =
moids.c:	      MOID **m = &q->symbol_table->moids, *new_one =
moids.c:	      NEXT (q)->type = new_one;
moids.c:	  MOID **m = &p->symbol_table->moids, *new_one = NEXT (NEXT (p))->type;
moids.c:| Routines to check well-formedness of MOIDs.
moids.c:	  while (z != NULL && (SYMBOL (z->node) != SYMBOL (p->node)))
moids.c:	  TAG *z = SUB (p)->symbol_table->indicants, *table = z;
moids.c:		  warror (A_ERR, z->node, "M specifies a cyclic mode", TYPE (z));
moids.c:  if (dec->safe == 0)
moids.c:	  if (SYMBOL (def) == SYMBOL (dec->node))
moids.c:	      TAG *s = def->symbol_table->indicants;
moids.c:		  if (SYMBOL (s->node) == SYMBOL (dec->node))
moids.c:	  return (yin ? A_TRUE : check_yin_yang_pack (def, dec->pack, yin, A_TRUE));
moids.c:	  return (check_yin_yang_pack (def, dec->pack, yin, yang));
moids.c:	  if (dec->pack != NULL)
moids.c:	      z->safe = 0;
moids.c:      if (modes_equivalent (TYPE (s), TYPE (t)) && s->text == t->text)
moids.c:	  return (DIMENSION (a) == DIMENSION (b) && packs_equivalent (a->pack, b->pack));
moids.c:	  return (fields_equivalent (a->pack, b->pack) && fields_equivalent (b->pack, a->pack));
moids.c:	  return (DIMENSION (a) == DIMENSION (b) && packs_equivalent (a->pack, b->pack)
moids.c:	  return (DIMENSION (a) == DIMENSION (b) && packs_equivalent (a->pack, b->pack));
moids.c:	  return (DIMENSION (a) == DIMENSION (b) && packs_equivalent (a->pack, b->pack));
moids.c:      if (q->in_standard_environ && p->in_standard_environ)
moids.c:	  SYMBOL_TABLE *s = SUB (p)->symbol_table;
moids.c:	  TAG *z = s->indicants;
moids.c:	      TAG *y = find_tag_global (s, Indicant, SYMBOL (z->node));
moids.c:	      if (y != NULL && y->node != NULL)
moids.c:		  TYPE (z) = TYPE (NEXT (NEXT (y->node)));
moids.c:	  SYMBOL_TABLE *s = SUB (p)->symbol_table;
moids.c:	  MOID *z = s->moids;
moids.c:		  TAG *y = find_tag_global (s, Indicant, SYMBOL (z->node));
moids.c:		  if (y != NULL && y->node != NULL)
moids.c:		      EQUIVALENT (z) = TYPE (NEXT (NEXT (y->node)));
moids.c:			      SYMBOL (z->node));
moids.c:      add_mode_to_pack (dst, z, src->text, src->node);
moids.c:  make_name_pack (m->pack, &u, p);
moids.c:  save->pack = u;
moids.c:  if (m->slice != NULL)
moids.c:      return (add_mode (p, _REF_, 0, NULL, m->slice, NULL));
moids.c:	  SYMBOL_TABLE *symbol_table = SUB (p)->symbol_table;
moids.c:	  MOID **topmoid = &(symbol_table->moids);
moids.c:	      MOID *m = symbol_table->moids;
moids.c:		  if (m->name == NULL && ATTRIBUTE (m) == _REF_)
moids.c:			  m->name = make_name_struct (SUB (m), topmoid);
moids.c:			  m->name = make_name_row (SUB (m), topmoid);
moids.c:			  m->name = make_name_row (SUB (m->sub), topmoid);
moids.c:      add_mode_to_pack (dst, add_row (p, dim, TYPE (src), NULL), src->text, src->node);
moids.c:  make_multiple_row_pack (m->pack, &u, p, dim);
moids.c:  save->pack = u;
moids.c:      add_mode_to_pack (dst, z, src->text, src->node);
moids.c:  make_flex_multiple_row_pack (m->pack, &u, p, dim);
moids.c:  x->pack = u;
moids.c:	  SYMBOL_TABLE *symbol_table = SUB (p)->symbol_table;
moids.c:	  MOID **top = &symbol_table->moids;
moids.c:	      MOID *q = symbol_table->moids;
moids.c:		  if (q->multiple_mode != NULL)
moids.c:		      if (SUB (q)->multiple_mode != NULL)
moids.c:			  q->multiple_mode = make_name_struct (SUB (q)->multiple_mode, top);
moids.c:			  q->multiple_mode = make_multiple_struct (SUB (q), top, DIMENSION (q));
moids.c:			      q->multiple_mode =
moids.c:	  PACK *s = TYPE (t)->pack;
moids.c:	  absorb_union_pack (TYPE (t)->pack, mods);
moids.c:	  t->text = s->text;
moids.c:	      add_mode_to_pack (&NEXT (t), TYPE (s), s->text, s->node);
moids.c:	  MOID *m = SUB (p)->symbol_table->moids;
moids.c:		  absorb_union_pack (m->pack, mods);
moids.c:  PACK *s = u->pack;
moids.c:	      NEXT (t) = NEXT (t->next);
moids.c:	  MOID *m = SUB (p)->symbol_table->moids;
moids.c:| For instance REF STRING -> REF [] CHAR.
moids.c:	  PACK *t = m->pack;
moids.c:  if (m->deflexed_mode != NULL)
moids.c:      return (m->deflexed_mode);
moids.c:      (*p)->sub = new_one;
moids.c:      return (m->deflexed_mode = *p);
moids.c:      (*p)->sub = new_one;
moids.c:      return (m->deflexed_mode = *p);
moids.c:      return (m->deflexed_mode = make_deflexed (SUB (m), p));
moids.c:	  new_slice = make_deflexed (m->slice, p);
moids.c:	  add_mode (p, _ROW_, DIMENSION (m) - 1, NULL, new_slice, NULL);
moids.c:      (*p)->slice = new_slice;
moids.c:      return (m->deflexed_mode = *p);
moids.c:      m->deflexed_mode = save;
moids.c:      make_deflexed_pack (m->pack, &u, p);
moids.c:      save->pack = u;
moids.c:      return (m->deflexed_mode = make_deflexed (n, p));
moids.c:      add_mode_to_pack (dst, make_deflexed (TYPE (src), p), src->text, src->node);
moids.c:	  SYMBOL_TABLE *s = SUB (p)->symbol_table;
moids.c:	  MOID *m = s->moids, **top = &s->moids;
moids.c:	      if (((!m->has_flex) && (m->has_flex = mode_has_flex (m)))
moids.c:		  && (m->deflexed_mode == NULL))
moids.c:		  m->deflexed_mode = make_deflexed (m, top);
moids.c:		  goodbye (mode_has_flex (m->deflexed_mode), "deflexing failed for ",
moids.c:			   moid_str (m->deflexed_mode, 80));
moids.c:	      if (m->trim == NULL && ATTRIBUTE (m) == _FLEX_)
moids.c:		  m->trim = SUB (m);
moids.c:	      else if (m->trim == NULL && ATTRIBUTE (m) == _REF_
moids.c:		  m->trim = *top;
moids.c:	  PACK *p = m->pack;
moids.c:	  PACK *p = m->pack;
moids.c:	  PACK *p = m->pack;
moids.c:	  MOID *m = SUB (p)->symbol_table->moids;
moids.c:	      if (m->node != NULL && mode_has_void (m))
moids.c:		  warror (A_ERR, m->node, "M is related to M", m, Mode (VOID));
moids.c:      PACK *p = m->pack;
moids.c:	  k |= (TYPE (p)->type_has_rows = mode_has_row (TYPE (p)));
moids.c:      return (m->type_has_rows || ATTRIBUTE (m) == _ROW_ || ATTRIBUTE (m) == _FLEX_);
moids.c:	  MOID *m = SUB (p)->symbol_table->moids;
moids.c:	      m->type_has_rows = mode_has_row (m);
moids.c:  de_equivalencer (&(q->deflexed_mode));
moids.c:  de_equivalencer (&(q->multiple_mode));
moids.c:  de_equivalencer (&(q->name));
moids.c:  de_equivalencer (&(q->slice));
moids.c:  de_equivalencer (&(q->trim));
moids.c:  for (p = q->pack; p != NULL; p = NEXT (p))
moids.c:	  if (SUB (p)->symbol_table != NULL)
moids.c:	      de_equivalence_tags (SUB (p)->symbol_table->indicants);
moids.c:	      moid_de_equivalence (SUB (p)->symbol_table->moids);
moids.c:	  PACK *t = m->pack;
moids.c:      TYPE (start)->size = moid_size (TYPE (start));
moids.c:      if (!(TYPE (start)->has_ref))
moids.c:	  TYPE (start)->has_ref = mode_has_ref (TYPE (start));
moids.c:      if (!(TYPE (start)->has_flex))
moids.c:	  TYPE (start)->has_flex = mode_has_flex (TYPE (start));
moids.c:  de_equivalence_tags (stand_env->indicants);
moids.c:  de_equivalence_tags (stand_env->identifiers);
moids.c:  de_equivalence_tags (stand_env->operators);
moids.c:  moid_de_equivalence (stand_env->moids);
moids.c:/* Check yin-yang of modes */
moids.c:      return (1 + (TYPE (p)->num = renumber_moids (NEXT (p))));
moidsize.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
moidsize.c:      PACK *z = p->pack;
moidsize.c:      PACK *z = p->pack;
moidsize.c:  if (p->size == 0)
moidsize.c:      return (p->size = moid_size2 (p));
moidsize.c:      return (p->size);
news.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
news.c:  z->info = (NODE_INFO *) heap (size_of (NODE_INFO));
news.c:  z->info->module = NULL;
news.c:  z->info->mask = 0;
news.c:  z->info->PROCEDURE_LEVEL = 0;
news.c:  z->info->PROCEDURE_NUMBER = 0;
news.c:  z->info->char_in_line = NULL;
news.c:  z->info->symbol = NULL;
news.c:  z->info->line = NULL;
news.c:  z->info->tag = NULL;
news.c:  z->attribute = 0;
news.c:  z->annotation = 0;
news.c:  z->scope_error = A_FALSE;
news.c:  z->genie.basic_operation = BASIC_NONE;
news.c:  z->genie.propagator.unit = NULL;
news.c:  z->genie.propagator.clause = NULL;
news.c:  z->genie.propagator.source = NULL;
news.c:  z->genie.lhs.unit = NULL;
news.c:  z->genie.lhs.clause = NULL;
news.c:  z->genie.lhs.source = NULL;
news.c:  z->genie.rhs.unit = NULL;
news.c:  z->genie.rhs.clause = NULL;
news.c:  z->genie.rhs.source = NULL;
news.c:  z->genie.is_coercion = A_FALSE;
news.c:  z->genie.is_new_level = A_FALSE;
news.c:  z->genie.enclosed_children = A_TRUE;
news.c:  z->genie.seq = NULL;
news.c:  z->genie.seq_set = A_FALSE;
news.c:  z->genie.parent = NULL;
news.c:  z->genie.function_name = NULL;
news.c:  z->num = -1;
news.c:  z->symbol_table = NULL;
news.c:  z->type = NULL;
news.c:  z->next = NULL;
news.c:  z->prev = NULL;
news.c:  z->sub = NULL;
news.c:  z->inits = NULL;
news.c:  z->pack = NULL;
news.c:  z->msg = NULL;
news.c:  z->no_sweep = NULL;
news.c:  z->routine = NULL;
news.c:  z->constant = NULL;
news.c:  z->level = symbol_table_count++;
news.c:  z->nest = symbol_table_count;
news.c:  z->attribute = 0;
news.c:  z->environ = NULL;
news.c:  z->ap_increment = 0;
news.c:  z->empty_table = A_FALSE;
news.c:  z->initialise_frame = A_TRUE;
news.c:  z->proc_ops = A_TRUE;
news.c:  z->initialise_anon = A_TRUE;
news.c:  z->previous = p;
news.c:  z->identifiers = NULL;
news.c:  z->operators = NULL;
news.c:  z->priority = NULL;
news.c:  z->indicants = NULL;
news.c:  z->labels = NULL;
news.c:  z->local_identifiers = NULL;
news.c:  z->local_operators = NULL;
news.c:  z->anonymous = NULL;
news.c:  z->moids = NULL;
news.c:  z->jump_to = NULL;
news.c:  z->inits = NULL;
news.c:  z->attribute = 0;
news.c:  z->num = 0;
news.c:  z->dim = 0;
news.c:  z->safe = 0;
news.c:  z->use = A_FALSE;
news.c:  z->has_ref = A_FALSE;
news.c:  z->has_flex = A_FALSE;
news.c:  z->type_has_rows = A_FALSE;
news.c:  z->in_standard_environ = A_FALSE;
news.c:  z->size = 0;
news.c:  z->node = NULL;
news.c:  z->pack = NULL;
news.c:  z->sub = NULL;
news.c:  z->equivalent_mode = 0;
news.c:  z->slice = NULL;
news.c:  z->deflexed_mode = NULL;
news.c:  z->name = NULL;
news.c:  z->multiple_mode = NULL;
news.c:  z->trim = NULL;
news.c:  z->next = NULL;
news.c:  z->type = NULL;
news.c:  z->text = NULL;
news.c:  z->node = NULL;
news.c:  z->next = NULL;
news.c:  z->prev = NULL;
news.c:  z->size = 0;
news.c:  z->offset = 0;
news.c:  z->symbol_table = NULL;
news.c:  z->type = NULL;
news.c:  z->node = NULL;
news.c:  z->unit = NULL;
news.c:  z->value = NULL;
news.c:  z->stand_env_proc = 0;
news.c:  z->procedure = NULL;
news.c:  z->scope = Primal;
news.c:  z->scope_assigned = A_FALSE;
news.c:  z->heap = 0;
news.c:  z->priority = 0;
news.c:  z->use = A_FALSE;
news.c:  z->in_proc = 0;
news.c:  z->optimise = 0;
news.c:  z->access = 0;
news.c:  z->size = 0;
news.c:  z->offset = 0;
news.c:  z->incarnation = 0;
news.c:  z->youngest_environ = 0;
news.c:  z->loc_assigned = A_FALSE;
news.c:  z->loc_procedure = A_FALSE;
news.c:  z->next = NULL;
news.c:  z->alias = NULL;
news.c:  z->body = NULL;
news.c:  z->String = NULL;
news.c:  z->messages = NULL;
news.c:  z->num = 0;
news.c:  z->print_status = 0;
news.c:  z->min_level = 0;
news.c:  z->max_level = 0;
news.c:  z->min_proc_level = 0;
news.c:  z->max_proc_level = 0;
news.c:  z->list = 0;
news.c:  z->dir = 0;
news.c:  z->top_node = NULL;
news.c:  z->next = NULL;
news.c:  z->prev = NULL;
options.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
options.c:  while (p[0] == '-')
options.c:  printf ("\n-print unit                Prints the value yielded by Algol 68 unit `unit'");
options.c:  printf ("\n-execute unit              Executes Algol 68 unit `unit'");
options.c:  printf ("\n-heap number               Sets heap size to `number' kB");
options.c:  printf ("\n-handles number            Sets handle space size to `number' kB");
options.c:  printf ("\n-frame number              Sets frame stack size to `number' kB");
options.c:  printf ("\n-stack number              Sets stack size to `number' kB");
options.c:  printf ("\n-extensive                 Generates extensive listing");
options.c:  printf ("\n-listing                   Generates concise listing");
options.c:  printf ("\n-moids                     Generates overview of moids in listing file");
options.c:  printf ("\n-preludelisting            Generates a listing of preludes");
options.c:  printf ("\n-source, -nosource         Controls listing of source lines in listing file");
options.c:  printf ("\n-statistics                Generates statistics in listing file");
options.c:  printf ("\n-terminal                  Echo listing file to stdout");
options.c:  printf ("\n-tree, -notree             Generates syntax tree listing in listing file");
options.c:    ("\n-unused                    Generates an overview of unused tags in the listing file");
options.c:    ("\n-xref, -noxref             Controls generating a cross reference in the listing file");
options.c:  printf ("\n-assertions, -noassertions Controls elaboration of assertions");
options.c:  printf ("\n-check, -norun             Check syntax only, interpreter does not start");
options.c:  printf ("\n-nowarnings                Suppresses warning messages");
options.c:  printf ("\n-pragmats, -nopragmats     Controls elaboration of pragmat items");
options.c:    ("\n-precision number          Sets precision for long long real to `number' significant digits");
options.c:  printf ("\n-timelimit number          Interrupts the interpreter after `number' seconds");
options.c:  printf ("\n-trace, -notrace           Controls tracing a running program");
options.c:  printf ("\n-verbose                   Algol68G will inform you on its actions");
options.c:  printf ("\n-version                   States the version of the running copy");
options.c:  printf ("\n-echo string               Echoes `string' to standard output");
options.c:      (*l)->str = new_string (str);
options.c:      (*l)->processed = A_FALSE;
options.c:  module->options.list = NULL;
options.c:  if (module->options.pragmat_sema)
options.c:      if (!(i->processed))
options.c:	  BOOLEAN minus_sign = (i->str)[0] == '-';
options.c:	  char *p = strip_minus (i->str);
options.c:	      module->files.generic_name = new_string (p);
options.c:	      if (!error && strcmp (i->str, "=") == 0)
options.c:		  int decimals = strtol (i->str, &end_ptr, 10);
options.c:		  if (!(error = (end_ptr == i->str)))
options.c:		  if (strcmp (i->str, "=") == 0)
options.c:		      sprintf (textline, "\n%s", i->str);
options.c:/* The one-liners */
options.c:		  if (strcmp (i->str, "=") == 0)
options.c:			      fprintf (f, "PR -ext PR\n(%s)\n", i->str);
options.c:			      fprintf (f, "PR -ext PR\nprint((%s))\n", i->str);
options.c:			  module->files.generic_name = new_string (name);
options.c:	      if (!error && strcmp (i->str, "=") == 0)
options.c:		  int k = strtol (i->str, &end_ptr, 10);
options.c:		  if (!(error = (end_ptr == i->str)))
options.c:	      module->options.gnu_diags = A_FALSE;
options.c:	      module->options.bold_strop = A_FALSE;
options.c:	      module->options.check_only = A_TRUE;
options.c:	      module->options.mc_test_set = A_TRUE;
options.c:	      module->options.no_warnings = A_TRUE;
options.c:	      module->options.pragmat_sema = A_TRUE;
options.c:	      module->options.pragmat_sema = A_FALSE;
options.c:	      module->options.verbose = A_TRUE;
options.c:	      module->options.version = A_TRUE;
options.c:	      module->options.source_listing = A_TRUE;
options.c:	      module->options.cross_reference = A_TRUE;
options.c:	      module->options.nodemask |= (CROSS_REFERENCE_MASK | SOURCE_MASK);
options.c:	      module->options.nodemask &= ~(CROSS_REFERENCE_MASK | SOURCE_MASK);
options.c:	      module->options.standard_prelude_listing = A_TRUE;
options.c:	      module->options.statistics_listing = A_TRUE;
options.c:	      module->options.source_listing = A_TRUE;
options.c:	      module->options.tree_listing = A_TRUE;
options.c:	      module->options.nodemask |= (TREE_MASK | SOURCE_MASK);
options.c:	      module->options.nodemask ^= (TREE_MASK | SOURCE_MASK);
options.c:	      module->options.unused = A_TRUE;
options.c:	      module->options.source_listing = A_TRUE;
options.c:	      module->options.tree_listing = A_TRUE;
options.c:	      module->options.cross_reference = A_TRUE;
options.c:	      module->options.moid_listing = A_TRUE;
options.c:	      module->options.standard_prelude_listing = A_TRUE;
options.c:	      module->options.statistics_listing = A_TRUE;
options.c:	      module->options.unused = A_TRUE;
options.c:	      module->options.nodemask |=
options.c:	      module->options.source_listing = A_TRUE;
options.c:	      module->options.cross_reference = A_TRUE;
options.c:	      module->options.statistics_listing = A_TRUE;
options.c:	      module->options.nodemask |= (SOURCE_MASK | CROSS_REFERENCE_MASK);
options.c:	      module->options.tty_listing = A_TRUE;
options.c:	      module->options.cross_reference = A_TRUE;
options.c:	      module->options.statistics_listing = A_TRUE;
options.c:	      module->options.nodemask |= (SOURCE_MASK | CROSS_REFERENCE_MASK);
options.c:	      module->options.source_listing = A_TRUE;
options.c:	      module->options.nodemask |= SOURCE_MASK;
options.c:	      module->options.nodemask &= ~SOURCE_MASK;
options.c:	      module->options.moid_listing = A_TRUE;
options.c:	      module->options.nodemask |= ASSERT_MASK;
options.c:	      module->options.nodemask &= ~ASSERT_MASK;
options.c:	      module->options.trace = A_TRUE;
options.c:	      module->options.nodemask |= TRACE_MASK;
options.c:	      module->options.nodemask &= ~TRACE_MASK;
options.c:	      if (!error && strcmp (i->str, "=") == 0)
options.c:		  k = strtol (i->str, &end_ptr, 10);
options.c:		  if (errno == 0 && !(error = (end_ptr == i->str)))
options.c:			  module->options.time_limit = k;
options.c:      j->processed = A_TRUE;
options.c:  module->options.check_only = A_FALSE;
options.c:  module->options.moid_listing = A_FALSE;
options.c:  module->options.tree_listing = A_FALSE;
options.c:  module->options.source_listing = A_FALSE;
options.c:  module->options.statistics_listing = A_FALSE;
options.c:  module->options.tty_listing = A_FALSE;
options.c:  module->options.standard_prelude_listing = A_FALSE;
options.c:  module->options.verbose = A_FALSE;
options.c:  module->options.version = A_FALSE;
options.c:  module->options.cross_reference = A_FALSE;
options.c:  module->options.no_warnings = A_FALSE;
options.c:  module->options.unused = A_FALSE;
options.c:  module->options.pragmat_sema = A_TRUE;
options.c:  module->options.trace = A_FALSE;
options.c:  module->options.mc_test_set = A_FALSE;
options.c:  module->options.nodemask = ASSERT_MASK;
options.c:  module->options.time_limit = 0;
options.c:  module->options.bold_strop = A_TRUE;
options.c:  module->options.gnu_diags = A_TRUE;
options.c:	      if (input_line[strlen (input_line) - 1] == '\n')
options.c:		  input_line[strlen (input_line) - 1] = '\0';
options.c:      set_options (module, module->options.list, A_FALSE);
options.c:	  add_option_list (&(module->options.list), q);
parser.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
parser.c:| This file contains a hand-coded parser for Algol68G.
parser.c:| (2) Then, a top-down parser determines the basic-block structure of the program
parser.c:|     so symbol tables can be set up that the bottom-up parser will consult
parser.c:| (3) Finally a bottom-up parser tries to resolve the structure of the program.
parser.c:| function:	diagnose non-matching parentheses
parser.c:  for (; p != NULL; p = p->next)
parser.c:	    begins--;
parser.c:	    opens--;
parser.c:	    subs--;
parser.c:	    ifs--;
parser.c:	    cases--;
parser.c:	    dos--;
parser.c:#define More(n) ((n) > 0 ? (n) : (-n)) > 1 ? " (more than once)" : ""
parser.c:| function:	diagnose non-matching parentheses
parser.c:	    q = pre_parse (top, p->next);
parser.c:	    q = pre_parse (top, p->next);
parser.c:	    q = pre_parse (top, p->next);
parser.c:	    q = pre_parse (top, p->next);
parser.c:	    q = pre_parse (top, p->next);
parser.c:	    q = pre_parse (top, p->next);
parser.c:	  p = p->next;
parser.c:| NEXT is a top-down parser that branches out the basic blocks. 
parser.c:| function:	check for premature end-of-file (NULL token)
parser.c:| function:	return whether token indicates a unit-terminator in a loop clause
parser.c:	      open_p->info->line->num, current_module);
parser.c:| NEXT part is the bottom-up parser, that parses in a 
parser.c:| mode-independent way, that is, it knows nothing about constituent modes
parser.c:| trivial deviation from the original language - arguably it forces using
parser.c:| This is a Mailloux-type parser, in the sense that it scans a "phrase" for
parser.c:|                IF a = b THEN RE a ELSE  pi * (IM a - IM b) FI
parser.c:| Phrase level 3                               +-----------+
parser.c:| Phrase level 2    +---+      +--+       +----------------+
parser.c:| Phrase level 1 +--------------------------------------------+
parser.c:| that Algol 68 does not require to be present - filling in gives one format for
parser.c:      NEXT (z)->prev = z;
parser.c:		  add_tag (p->symbol_table, Indicant, q, NULL, 0);
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:      if (ATTRIBUTE (q) == BOLD_TAG && find_tag_global (q->symbol_table, Indicant, SYMBOL (q)))
parser.c:	      TAG *z = add_tag (p->symbol_table, LABEL, q, NULL, LOCAL_LABEL);
parser.c:	      z->unit = NULL;
parser.c:	      && find_identifier_global (q->symbol_table, SYMBOL (q)) == LABEL)
parser.c:	      TAX (q) = find_tag_global (q->symbol_table, LABEL, SYMBOL (q));
parser.c:	       && find_identifier_global (q->symbol_table, SYMBOL (q)) == LABEL)
parser.c:	  TAX (q) = find_tag_global (q->symbol_table, LABEL, SYMBOL (q));
parser.c:		  add_tag (p->symbol_table, Identifier, q, NULL, NORMAL_IDENTIFIER);
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:		  add_tag (p->symbol_table, Identifier, q, NULL, NORMAL_IDENTIFIER);
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:		      NEXT (q)->attribute = _ASSIGN_;
parser.c:		  add_tag (p->symbol_table, Identifier, q, NULL, NORMAL_IDENTIFIER);
parser.c:		  TAG *t = add_tag (p->symbol_table, Identifier, q, NULL,
parser.c:		  t->in_proc = 1;
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:		  add_tag (p->symbol_table, Identifier, q, NULL, NORMAL_IDENTIFIER);
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:		  add_tag (p->symbol_table, Identifier, q, NULL, NORMAL_IDENTIFIER);
parser.c:		  add_tag (p->symbol_table, Identifier, q, NULL, NORMAL_IDENTIFIER);
parser.c:		  (q = NEXT (q))->attribute = _ASSIGN_;
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:		  add_tag (p->symbol_table, _PRIO_, y, NULL, x);
parser.c:	  int ops = 1 + count_operands (NEXT (SUB (q))->sub);
parser.c:		  add_tag (p->symbol_table, _OP_, q, NULL, 0);
parser.c:		  else if (ops == 2 && !find_tag_global (q->symbol_table, _PRIO_, SYMBOL (q)))
parser.c:		      add_tag (q->symbol_table, _PRIO_, q, NULL, 1);
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:		  add_tag (p->symbol_table, _OP_, q, NULL, 0);
parser.c:		  if (ATTRIBUTE (NEXT (q->next)) != PARAMETER_PACK)
parser.c:		      k = 1 + count_operands (NEXT (q->next)->sub);
parser.c:		  if (k == 2 && !find_tag_global (q->symbol_table, _PRIO_, SYMBOL (q)))
parser.c:		      add_tag (q->symbol_table, _PRIO_, q, NULL, 1);
parser.c:		  (q = NEXT (q))->attribute = _ALT_EQUALS_;
parser.c:	  if (find_tag_global (q->symbol_table, _OP_, SYMBOL (q)))
parser.c:	  if (find_tag_global (q->symbol_table, _OP_, SYMBOL (q)))
parser.c:	      TAG *s = find_tag_global (q->symbol_table, _PRIO_, SYMBOL (q));
parser.c:		  q->info->priority = s->priority;
parser.c:	      q->info->priority = 1;
parser.c:| We work inside out - higher priority expressions get reduced first.
parser.c:	      q->info->priority = 10;
parser.c:      while (p != NULL && ATTRIBUTE (p) == Operator && p->info->priority == u)
parser.c:	  && NEXT (q)->info->priority == k);
parser.c:	  if (q->info->priority > max)
parser.c:	      max = q->info->priority;
parser.c:	  if (q->info->priority < min)
parser.c:	      min = q->info->priority;
parser.c:  for (priority = max; priority >= min; priority--)
parser.c:| Export-clauses are a bit of a future extension, but fragments are already here.
parser.c:| This routine starts parsing the sub-phrase that starts one level down.
parser.c:| Here are cases that need reducing from right-to-left whereas many things
parser.c:| can be reduced left-to-right. Assignations are a notable example; we could
parser.c:| The second-in-command supervising routine. 
parser.c:	  int a = ATTRIBUTE (NEXT (q)->sub);
parser.c:	  int a = ATTRIBUTE (NEXT (q)->sub);
parser.c:      if (NEXT (q) != NULL && NEXT (q)->sub != NULL)
parser.c:	  if (match (q, _FLEX_, _SUB_, Declarer, Stop) && NEXT (q)->sub != NULL)
parser.c:| Before reducing control structure - these structures have a sub-structure
parser.c:| Export-clauses are a bit of a future extension, but fragments are already here.
parser.c:      current_module = p->info->module;
prelude.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
prelude.c:  n->num = -1;
prelude.c:  n->info->PROCEDURE_LEVEL = 0;
prelude.c:  n->info->PROCEDURE_NUMBER = 0;
prelude.c:  new_one->use = A_FALSE;
prelude.c:  new_one->alias = NULL;
prelude.c:  new_one->optimise = 0;
prelude.c:  new_one->symbol_table = stand_env;
prelude.c:  new_one->node = n;
prelude.c:  new_one->value = c != NULL ? add_token (&top_token, c)->text : NULL;
prelude.c:  new_one->priority = p;
prelude.c:  new_one->procedure = q;
prelude.c:  new_one->stand_env_proc = q != NULL;
prelude.c:  new_one->unit = NULL;
prelude.c:  new_one->heap = _HEAP_;
prelude.c:      bind_tag (&stand_env->identifiers, new_one);
prelude.c:      bind_tag (&stand_env->operators, new_one);
prelude.c:      bind_tag (&stand_env->priority, new_one);
prelude.c:      bind_tag (&stand_env->indicants, new_one);
prelude.c:      bind_tag (&stand_env->labels, new_one);
prelude.c:  MOID *y, **z = &(stand_env->moids);
prelude.c:      new_one->text = NULL;
prelude.c:      add_stand_env (Identifier, some_node (find_token (&top_token, n)->text), NULL, m, 0, q);
prelude.c:      add_stand_env (Identifier, some_node (find_token (&top_token, n)->text), NULL, m, 0, q);
prelude.c:  add_mode (&stand_env->moids, Standard, p, some_node (find_keyword (top_keyword, t)->text),
prelude.c:  *m = stand_env->moids;
prelude.c:      add_stand_env (_PRIO_, some_node (find_token (&top_token, p)->text), NULL, NULL, b, NULL);
prelude.c:      add_stand_env (_OP_, some_node (find_token (&top_token, n)->text), NULL, m, 0, q);
prelude.c:  add_mode (&stand_env->moids, _ROWS_, 0, NULL, NULL, NULL);
prelude.c:  Mode (ROWS) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (INT), NULL);
prelude.c:  Mode (REF_INT) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (REAL), NULL);
prelude.c:  Mode (REF_REAL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (COMPLEX), NULL);
prelude.c:  Mode (REF_COMPLEX) = Mode (REF_COMPL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (BITS), NULL);
prelude.c:  Mode (REF_BITS) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (LONG_INT), NULL);
prelude.c:  Mode (REF_LONG_INT) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (LONG_REAL), NULL);
prelude.c:  Mode (REF_LONG_REAL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (LONG_COMPLEX), NULL);
prelude.c:  Mode (REF_LONG_COMPLEX) = Mode (REF_LONG_COMPL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (LONGLONG_INT), NULL);
prelude.c:  Mode (REF_LONGLONG_INT) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (LONGLONG_REAL), NULL);
prelude.c:  Mode (REF_LONGLONG_REAL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (LONGLONG_COMPLEX), NULL);
prelude.c:  Mode (REF_LONGLONG_COMPLEX) = Mode (REF_LONGLONG_COMPL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (BOOL), NULL);
prelude.c:  Mode (REF_BOOL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (CHAR), NULL);
prelude.c:  Mode (REF_CHAR) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (FILE), NULL);
prelude.c:  Mode (REF_FILE) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _ROW_, 1, NULL, Mode (REAL), NULL);
prelude.c:  stand_env->moids->type_has_rows = A_TRUE;
prelude.c:  Mode (ROW_REAL) = stand_env->moids;
prelude.c:  Mode (ROW_REAL)->slice = Mode (REAL);
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (ROW_REAL), NULL);
prelude.c:  Mode (REF_ROW_REAL) = stand_env->moids;
prelude.c:  Mode (REF_ROW_REAL)->name = Mode (REF_REAL);
prelude.c:  add_mode (&stand_env->moids, _ROW_, 2, NULL, Mode (REAL), NULL);
prelude.c:  stand_env->moids->type_has_rows = A_TRUE;
prelude.c:  Mode (ROWROW_REAL) = stand_env->moids;
prelude.c:  Mode (ROWROW_REAL)->slice = Mode (ROW_REAL);
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (ROWROW_REAL), NULL);
prelude.c:  Mode (REF_ROWROW_REAL) = stand_env->moids;
prelude.c:  Mode (REF_ROWROW_REAL)->name = Mode (REF_ROW_REAL);
prelude.c:  add_mode (&stand_env->moids, _ROW_, 1, NULL, Mode (BOOL), NULL);
prelude.c:  stand_env->moids->type_has_rows = A_TRUE;
prelude.c:  Mode (ROW_BOOL) = stand_env->moids;
prelude.c:  Mode (ROW_BOOL)->slice = Mode (BOOL);
prelude.c:  add_mode (&stand_env->moids, _ROW_, 1, NULL, Mode (BITS), NULL);
prelude.c:  stand_env->moids->type_has_rows = A_TRUE;
prelude.c:  Mode (ROW_BITS) = stand_env->moids;
prelude.c:  Mode (ROW_BITS)->slice = Mode (BITS);
prelude.c:  add_mode (&stand_env->moids, _ROW_, 1, NULL, Mode (CHAR), NULL);
prelude.c:  stand_env->moids->type_has_rows = A_TRUE;
prelude.c:  Mode (ROW_CHAR) = stand_env->moids;
prelude.c:  Mode (ROW_CHAR)->slice = Mode (CHAR);
prelude.c:  add_mode (&stand_env->moids, _FLEX_, 0, NULL, Mode (ROW_CHAR), NULL);
prelude.c:  stand_env->moids->type_has_rows = A_TRUE;
prelude.c:  stand_env->moids->deflexed_mode = Mode (ROW_CHAR);
prelude.c:  stand_env->moids->trim = Mode (ROW_CHAR);
prelude.c:  Mode (STRING)->equivalent_mode = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (ROW_CHAR), NULL);
prelude.c:  Mode (REF_ROW_CHAR) = stand_env->moids;
prelude.c:  Mode (REF_ROW_CHAR)->name = Mode (REF_CHAR);
prelude.c:  add_mode (&stand_env->moids, _PROC_, 0, NULL, Mode (ROW_CHAR), NULL);
prelude.c:  Mode (PROC_ROW_CHAR) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _REF_, 0, NULL, Mode (STRING)->equivalent_mode, NULL);
prelude.c:  stand_env->moids->name = Mode (REF_CHAR);
prelude.c:  stand_env->moids->deflexed_mode = Mode (REF_ROW_CHAR);
prelude.c:  stand_env->moids->trim = Mode (REF_ROW_CHAR);
prelude.c:  Mode (REF_STRING) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _PROC_, 0, NULL, Mode (STRING), NULL);
prelude.c:  Mode (PROC_STRING) = stand_env->moids;
prelude.c:  stand_env->moids->deflexed_mode = Mode (PROC_ROW_CHAR);
prelude.c:  add_mode_to_pack (&z, Mode (REAL), add_token (&top_token, "im")->text, NULL);
prelude.c:  add_mode_to_pack (&z, Mode (REAL), add_token (&top_token, "re")->text, NULL);
prelude.c:  add_mode (&stand_env->moids, _STRUCT_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (COMPLEX)->equivalent_mode = Mode (COMPL)->equivalent_mode = stand_env->moids;
prelude.c:  Mode (COMPLEX) = Mode (COMPL) = stand_env->moids;
prelude.c:  add_mode_to_pack (&z, Mode (REF_REAL), add_token (&top_token, "im")->text, NULL);
prelude.c:  add_mode_to_pack (&z, Mode (REF_REAL), add_token (&top_token, "re")->text, NULL);
prelude.c:  add_mode (&stand_env->moids, _STRUCT_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (REF_COMPLEX)->name = Mode (REF_COMPL)->name = stand_env->moids;
prelude.c:  add_mode_to_pack (&z, Mode (LONG_REAL), add_token (&top_token, "im")->text, NULL);
prelude.c:  add_mode_to_pack (&z, Mode (LONG_REAL), add_token (&top_token, "re")->text, NULL);
prelude.c:  add_mode (&stand_env->moids, _STRUCT_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (LONG_COMPLEX)->equivalent_mode = Mode (LONG_COMPL)->equivalent_mode = stand_env->moids;
prelude.c:  Mode (LONG_COMPLEX) = Mode (LONG_COMPL) = stand_env->moids;
prelude.c:  add_mode_to_pack (&z, Mode (REF_LONG_REAL), add_token (&top_token, "im")->text, NULL);
prelude.c:  add_mode_to_pack (&z, Mode (REF_LONG_REAL), add_token (&top_token, "re")->text, NULL);
prelude.c:  add_mode (&stand_env->moids, _STRUCT_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (REF_LONG_COMPLEX)->name = Mode (REF_LONG_COMPL)->name = stand_env->moids;
prelude.c:  add_mode_to_pack (&z, Mode (LONGLONG_REAL), add_token (&top_token, "im")->text, NULL);
prelude.c:  add_mode_to_pack (&z, Mode (LONGLONG_REAL), add_token (&top_token, "re")->text, NULL);
prelude.c:  add_mode (&stand_env->moids, _STRUCT_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (LONGLONG_COMPLEX)->equivalent_mode = Mode (LONGLONG_COMPL)->equivalent_mode =
prelude.c:    stand_env->moids;
prelude.c:  Mode (LONGLONG_COMPLEX) = Mode (LONGLONG_COMPL) = stand_env->moids;
prelude.c:  add_mode_to_pack (&z, Mode (REF_LONGLONG_REAL), add_token (&top_token, "im")->text, NULL);
prelude.c:  add_mode_to_pack (&z, Mode (REF_LONGLONG_REAL), add_token (&top_token, "re")->text, NULL);
prelude.c:  add_mode (&stand_env->moids, _STRUCT_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (REF_LONGLONG_COMPLEX)->name = Mode (REF_LONGLONG_COMPL)->name = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _UNION_, count_pack_members (z), NULL, NULL, z);
prelude.c:  Mode (NUMBER) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _PROC_, count_pack_members (z), NULL, Mode (VOID), z);
prelude.c:  Mode (PROC_VOID) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _PROC_, count_pack_members (z), NULL, Mode (BOOL), z);
prelude.c:  Mode (PROC_REF_FILE_BOOL) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _PROC_, count_pack_members (z), NULL, Mode (VOID), z);
prelude.c:  Mode (PROC_REF_FILE_VOID) = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _IN_TYPE_, 0, NULL, NULL, NULL);
prelude.c:  a68_modes.SIMPLIN = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _ROW_, 1, NULL, a68_modes.SIMPLIN, NULL);
prelude.c:  a68_modes.ROW_SIMPLIN = stand_env->moids;
prelude.c:  a68_modes.ROW_SIMPLIN->slice = a68_modes.SIMPLIN;
prelude.c:  add_mode (&stand_env->moids, _OUT_TYPE_, 0, NULL, NULL, NULL);
prelude.c:  a68_modes.SIMPLOUT = stand_env->moids;
prelude.c:  add_mode (&stand_env->moids, _ROW_, 1, NULL, a68_modes.SIMPLOUT, NULL);
prelude.c:  a68_modes.ROW_SIMPLOUT = stand_env->moids;
prelude.c:  a68_modes.ROW_SIMPLOUT->slice = a68_modes.SIMPLOUT;
prelude.c:  standard_prio ("-:=", 1);
prelude.c:  standard_prio ("-", 6);
prelude.c:  standard_op ("-", m, genie_minus_int);
prelude.c:  standard_op ("-", m, genie_sub_int);
prelude.c:  standard_op ("-:=", m, genie_minusab_int);
prelude.c:  standard_op ("-", m, genie_minus_real);
prelude.c:  standard_op ("-", m, genie_sub_real);
prelude.c:  standard_op ("-:=", m, genie_minusab_real);
prelude.c:  standard_op ("-", m, genie_minus_complex);
prelude.c:  standard_op ("-", m, genie_sub_complex);
prelude.c:  standard_op ("-:=", m, genie_minusab_complex);
prelude.c:| Binding for the multiple-precision library.
prelude.c:  standard_op ("-", m, genie_minus_long_mp);
prelude.c:  standard_op ("-", m, genie_sub_long_mp);
prelude.c:  standard_op ("-:=", m, genie_minusab_long_mp);
prelude.c:  standard_op ("-", m, genie_minus_long_mp);
prelude.c:  standard_op ("-", m, genie_sub_long_mp);
prelude.c:  standard_op ("-:=", m, genie_minusab_long_mp);
prelude.c:  standard_op ("-", m, genie_minus_long_complex);
prelude.c:  standard_op ("-", m, genie_sub_long_complex);
prelude.c:  standard_op ("-:=", m, genie_minusab_long_complex);
prelude.c:  standard_op ("-", m, genie_minus_long_mp);
prelude.c:  standard_op ("-", m, genie_sub_long_mp);
prelude.c:  standard_op ("-:=", m, genie_minusab_long_mp);
prelude.c:  standard_op ("-", m, genie_minus_long_mp);
prelude.c:  standard_op ("-", m, genie_sub_long_mp);
prelude.c:  standard_op ("-:=", m, genie_minusab_long_mp);
prelude.c:  standard_op ("-", m, genie_minus_long_complex);
prelude.c:  standard_op ("-", m, genie_sub_long_complex);
prelude.c:  standard_op ("-:=", m, genie_minusab_long_complex);
pretty.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
pretty.c:	      w -= (int) strlen (b) - l0;
pretty.c:	  for (; i <= abs (n->dim) && w > 0; i++)
pretty.c:	      if (n->dim < 0)
pretty.c:		      w -= (int) strlen ("SHORT ");
pretty.c:		  w -= (int) strlen ("LONG ");
pretty.c:	  if (w >= (int) strlen (SYMBOL (n->node)))
pretty.c:	      strcat (b, SYMBOL (n->node));
pretty.c:	      moid2str2 (b, SUB (n), w - (int) strlen ("REF .."));
pretty.c:	      moid2str2 (b, SUB (n), w - (int) strlen ("FLEX .."));
pretty.c:	  int j = (int) strlen ("[] ..") + 2 * (n->dim - 1);
pretty.c:	      for (i = 1; i < n->dim; i++)
pretty.c:	      moid2str2 (b, SUB (n), w - j);
pretty.c:	      tpack (b, n->pack, w - (int) strlen ("STRUCT (..)"));
pretty.c:	      tpack (b, n->pack, w - (int) strlen ("UNION (..)"));
pretty.c:	  if (n->pack != NULL)
pretty.c:		  tpack (b, n->pack, w - (int) strlen ("PROC (..) .."));
pretty.c:		  moid2str2 (b, SUB (n), w - (int) strlen (b));
pretty.c:		  moid2str2 (b, SUB (n), w - (int) strlen ("PROC .."));
pretty.c:	      tpack (b, n->pack, w - (int) strlen ("(..)"));
pretty.c:	      tpack (b, n->pack, w - (int) strlen ("(..)"));
scanner.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
scanner.c:#define IN_PRELUDE(p) (LINE(p)->num <= 0)
scanner.c:| returns:	int value of c if valid digit, -1 otherwise
scanner.c:      return (-1);
scanner.c:  z->String = new_string (str);
scanner.c:  z->num = (*l_num)++;
scanner.c:  z->print_status = NOT_PRINTED;
scanner.c:  z->list = 0;
scanner.c:  z->dir = NOT_PRINTED;
scanner.c:  z->messages = NULL;
scanner.c:  z->top_node = NULL;
scanner.c:  z->min_level = INT_MAX;
scanner.c:  z->max_level = 0;
scanner.c:  z->min_proc_level = INT_MAX;
scanner.c:  z->max_proc_level = 0;
scanner.c:  if (module->top_line == NULL)
scanner.c:      module->top_line = z;
scanner.c:  FILE *f = module->files.source.stream;
scanner.c:  FILE *f = module->files.source.stream;
scanner.c:      (*l_ptr)->list = (*l_ptr)->list || (module->options.nodemask & SOURCE_MASK);
scanner.c:	  *l_ptr = (*l_ptr)->next;
scanner.c:	      *s_ptr = (*l_ptr)->String;
scanner.c:	  (*l_ptr)->list = (*l_ptr)->list || (module->options.nodemask & SOURCE_MASK);
scanner.c:	      stop = (strcmp (term_s, &(lex_buf[b - term_s_length])) == 0);
scanner.c:      lex_buf[b - term_s_length] = '\0';
scanner.c:      if (module->options.bold_strop)
scanner.c:	      if (c == '+' || c == '-')
scanner.c:		  if (c == '+' || c == '-')
scanner.c:	  if (c == '+' || c == '-')
scanner.c:  else if (strchr ("!%^&?+-~<>/*", c) != NULL)
scanner.c:  if ((l = module->top_line) != NULL)
scanner.c:      s = l->String;
scanner.c:	      c = add_token (&top_token, lex_buf)->text;
scanner.c:		      SYMBOL (p) = find_keyword (top_keyword, "GOTO")->text;
scanner.c:		      c = kw->text;
scanner.c:		  c = kw->text;
scanner.c:			  set_options (module, module->options.list, A_FALSE);
scanner.c:	      q->num = node_count++;
scanner.c:	      MASK (q) = module->options.nodemask;
scanner.c:	      if (start_l->top_node == NULL)
scanner.c:		  start_l->top_node = q;
scanner.c:	      q->info->char_in_line = start_c;
scanner.c:	      q->info->priority = 0;
scanner.c:	      q->info->PROCEDURE_LEVEL = 0;
scanner.c:	      q->info->PROCEDURE_NUMBER = 0;
scanner.c:	      q->symbol_table = NULL;
scanner.c:	      q->info->module = module;
scanner.c:	      if (module->top_node == NULL)
scanner.c:		  module->top_node = q;
scanner.c:    REFINEMENT *x = z->top_refinement;
scanner.c:    NODE *q = z->top_node;
scanner.c:	printf ("\n%16s from %d upto %d", x->name, x->begin->num, x->end->num);
scanner.c:    while (q != NULL && n--)
scanner.c:	printf ("\n%d %16s", q->num, SYMBOL (q));
scanner.c:	    printf (" next:%d", NEXT (q)->num);
scanner.c:	    printf (" prev:%d", PREVIOUS (q)->num);
scanner.c:  NODE *p = z->top_node;
scanner.c:  z->top_refinement = NULL;
scanner.c:      new_one->next = NULL;
scanner.c:      new_one->name = SYMBOL (p);
scanner.c:      new_one->applications = 0;
scanner.c:      new_one->line = LINE (p);
scanner.c:      new_one->appl = NULL;
scanner.c:      new_one->tree = p;
scanner.c:      new_one->begin = NULL;
scanner.c:      new_one->end = NULL;
scanner.c:	  new_one->begin = p;
scanner.c:	  new_one->end = p;
scanner.c:      x = z->top_refinement;
scanner.c:	  if (x->name == new_one->name)
scanner.c:	      warror (A_ERR, new_one->tree, "refinement already defined", NULL);
scanner.c:	  new_one->next = z->top_refinement;
scanner.c:	  z->top_refinement = new_one;
scanner.c:  if (z->top_refinement == NULL)
scanner.c:  x = z->top_refinement;
scanner.c:      x->applications = 0;
scanner.c:/* Before we introduce infinite loops, find where closing-prelude starts */
scanner.c:  p = z->top_node;
scanner.c:      warror (A_ERR, z->top_node, Consistency, NULL);
scanner.c:  p = z->top_node;
scanner.c:	  x = z->top_refinement;
scanner.c:	      if (x->name == SYMBOL (p))
scanner.c:	      y->applications++;
scanner.c:	      if (y->applications > 1)
scanner.c:		  warror (A_ERR, y->line->top_node, "refinement applied more than once", NULL);
scanner.c:		  y->appl = LINE (p);
scanner.c:		      NEXT (PREVIOUS (p)) = y->begin;
scanner.c:		  if (y->begin != NULL)
scanner.c:		      PREVIOUS (y->begin) = PREVIOUS (p);
scanner.c:		      PREVIOUS (NEXT (p)) = y->end;
scanner.c:		  if (y->end != NULL)
scanner.c:		      NEXT (y->end) = NEXT (p);
scanner.c:		  p = y->begin;	/* So we can substitute the refinements within */
scanner.c:      x = z->top_refinement;
scanner.c:	  if (x->applications == 0)
scanner.c:	      warror (A_ERR, x->line->top_node, "refinement is not applied", NULL);
scope.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
scope.c:#define LEVEL(z) ((z)->symbol_table->level)
scope.c:      ns->where = where;
scope.c:      ns->tuple = tup;
scope.c:	  if (s->tuple.transient == TRANSIENT && !s->where->scope_error)
scope.c:	      warror (A_ERR, s->where, "attempt to store transient name");
scope.c:	      s->where->scope_error = A_TRUE;
scope.c:	  if (dest < s->tuple.level && !s->where->scope_error)
scope.c:	      warror (A_ERR, s->where, "M A violates scope rule", TYPE (s->where),
scope.c:		      ATTRIBUTE (s->where));
scope.c:	      s->where->scope_error = A_TRUE;
scope.c:      if (s->tuple.level > z.level)
scope.c:	  z = s->tuple;
scope.c:      if (s->tuple.level > z.level && s->tuple.level <= treshold)
scope.c:	  z = s->tuple;
scope.c:	    if (TYPE (p) != NULL && TAX (p) != NULL && TYPE (p)->type_has_rows && no_ref)
scope.c:			   scope_make_tuple (TAX (p)->symbol_table->level, NOT_TRANSIENT));
scope.c:	    scope_add (s, p, scope_make_tuple (TAX (p)->youngest_environ, NOT_TRANSIENT));
scope.c:			   scope_make_tuple (TAX (p)->symbol_table->level, NOT_TRANSIENT));
scope.c:  TAX (p)->youngest_environ = scope_find_youngest_outside (s, LEVEL (p)).level;
scope.c:	      TAX (p)->scope = TAX (NEXT (NEXT (p)))->youngest_environ;
scope.c:	      TAX (p)->scope_assigned = A_TRUE;
scope.c:  routine_tuple = scope_make_tuple (TAX (p)->youngest_environ, NOT_TRANSIENT);
scope.c:	  if (!TAX (p)->scope_assigned)
scope.c:	      TAX (p)->scope = scope_find_youngest (s).level;
scope.c:	      TAX (p)->scope_assigned = A_TRUE;
scope.c:	  if (transient_row (SUB (p)->type))
scope.c:	      if (TAX (p)->priority == PARAMETER_IDENTIFIER)
scope.c:			     scope_make_tuple (TAX (p)->symbol_table->level - 0.5,
scope.c:				 scope_make_tuple (TAX (p)->symbol_table->level,
scope.c:	      scope_add (s, p, scope_make_tuple (TAX (p)->scope, NOT_TRANSIENT));
scope.c:	      scope_bounds (NEXT (SUB (p))->sub);
scope.c:	  scope_enclosed_clause (NEXT (SUB (p))->sub, s);
scope.c:	  NODE *unit = NEXT (SUB (p)->next);
scope.c:	  scope_tertiary (SUB (p->sub), &ns);
scope.c:      if (ATTRIBUTE (p) == Identifier && !TAX (p)->in_proc)
scope.c:	  if (p->num < TAX (p)->node->num && ATTRIBUTE (TYPE (p)) != _PROC_)
tausworthe.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
tausworthe.c:| This file contains a "stand-alone" version of GNU Scientific Library (GSL)
tausworthe.c:| computed modulo 2^32. In the formulas above '^' means exclusive-or 
tausworthe.c:| (C-notation), not exponentiation. 
tausworthe.c:| The algorithm is for 32-bit integers, hence a bitmask is used to clear 
tausworthe.c:| work on architectures where integers are 64-bit.
tausworthe.c:| P. L'Ecuyer, "Tables of Maximally-Equidistributed Combined LFSR Generators",
tausworthe.c:| Mathematics of Computation, 68, 225 (1999), 261--269.
tausworthe.c:| Mathematics of Computation, 65, 213 (1996), 203--213.
tausworthe.c:  b1 = ((((state->z1 << 6UL) & MASK) ^ state->z1) >> 13UL);
tausworthe.c:  state->z1 = ((((state->z1 & 4294967294UL) << 18UL) & MASK) ^ b1);
tausworthe.c:  b2 = ((((state->z2 << 2UL) & MASK) ^ state->z2) >> 27UL);
tausworthe.c:  state->z2 = ((((state->z2 & 4294967288UL) << 2UL) & MASK) ^ b2);
tausworthe.c:  b3 = ((((state->z3 << 13UL) & MASK) ^ state->z3) >> 21UL);
tausworthe.c:  state->z3 = ((((state->z3 & 4294967280UL) << 7UL) & MASK) ^ b3);
tausworthe.c:  b4 = ((((state->z4 << 3UL) & MASK) ^ state->z4) >> 12UL);
tausworthe.c:  state->z4 = ((((state->z4 & 4294967168UL) << 13UL) & MASK) ^ b4);
tausworthe.c:  return (state->z1 ^ state->z2 ^ state->z3 ^ state->z4);
tausworthe.c:  state->z1 = LCG (s);
tausworthe.c:  if (state->z1 < 2UL)
tausworthe.c:      state->z1 += 2UL;
tausworthe.c:  state->z2 = LCG (state->z1);
tausworthe.c:  if (state->z2 < 8UL)
tausworthe.c:      state->z2 += 8UL;
tausworthe.c:  state->z3 = LCG (state->z2);
tausworthe.c:  if (state->z3 < 16UL)
tausworthe.c:      state->z3 += 16UL;
tausworthe.c:  state->z4 = LCG (state->z3);
tausworthe.c:  if (state->z4 < 128UL)
tausworthe.c:      state->z4 += 128UL;
taxes.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
taxes.c:	  TAG *z = find_tag_global (p->symbol_table, Identifier, SYMBOL (p));
taxes.c:	  else if ((z = find_tag_global (p->symbol_table, LABEL, SYMBOL (p))) == NULL)
taxes.c:	      z = add_tag (p->symbol_table, Identifier, p, Mode (ERROR), NORMAL_IDENTIFIER);
taxes.c:	      z->node = p;
taxes.c:	  TAG *z = find_tag_global (p->symbol_table, Indicant, SYMBOL (p));
taxes.c:		  z->node = p;
taxes.c:	  TAG *z = add_tag (p->symbol_table, Identifier, p, NULL,
taxes.c:	  if (p->symbol_table->identifiers
taxes.c:	      && p->symbol_table->identifiers->priority == SPECIFIER_IDENTIFIER)
taxes.c:	    TYPE (p->symbol_table->identifiers) = TYPE (p);
taxes.c:	  HEAP (add_tag (p->symbol_table, Identifier, p, NULL, PARAMETER_IDENTIFIER)) = _LOC_;
taxes.c:	  for (s = p->symbol_table->identifiers; s && TYPE (s) == NULL; s = NEXT (s))
taxes.c:	      add_tag (p->symbol_table, Identifier, p, Mode (INT), LOOP_IDENTIFIER);
taxes.c:	  TAG *z = add_tag (p->symbol_table, Anonymous, p, TYPE (p), ROUTINE_TEXT);
taxes.c:	  p->routine = z;
taxes.c:	  z->use = A_TRUE;
taxes.c:	      TAG *z = add_tag (p->symbol_table, Anonymous, p,
taxes.c:	      z->use = A_TRUE;
taxes.c:	  MOID *m = SUB (p)->symbol_table->moids;
taxes.c:	      if (ATTRIBUTE (m) == _STRUCT_ && m->equivalent_mode == NULL)
taxes.c:		  PACK *s = m->pack;
taxes.c:			  if (s->text == t->text)
taxes.c:			      while (NEXT (s) != NULL && NEXT (s)->text == t->text)
taxes.c:	  SYMBOL_TABLE *symbol_table = SUB (p)->symbol_table;
taxes.c:	  MOID *m = symbol_table->moids;
taxes.c:	      if (ATTRIBUTE (m) == _UNION_ && m->equivalent_mode == NULL)
taxes.c:		  PACK *s = m->pack;
taxes.c:		      warror (A_ERR, m->node, "M must have at least two members", m);
taxes.c:		  for (s = m->pack; s != NULL && x; s = NEXT (s))
taxes.c:      TAG *s = c->operators;
taxes.c:	  if (s != self && SYMBOL (s->node) == n)
taxes.c:	      PACK *t = TYPE (s)->pack;
taxes.c:      PACK *u = TYPE (s)->pack;
taxes.c:	   find_firmly_related_op (s->symbol_table, SYMBOL (s->node), TYPE (u),
taxes.c:				   NEXT (u) ? NEXT (u)->type : NULL, s)) != NULL)
taxes.c:	  if (t->symbol_table == stand_env)
taxes.c:		      SYMBOL (s->node), TYPE (t), SYMBOL (t->node), NULL);
taxes.c:	      warror (A_ERR, p, "M Z is firmly related to M Z", TYPE (s), SYMBOL (s->node),
taxes.c:		      TYPE (t), SYMBOL (t->node), NULL);
taxes.c:	  test_firmly_related_ops_local (p == NULL ? NULL : NEXT (s)->node, NEXT (s));
taxes.c:	  TAG *oops = SUB (p)->symbol_table->operators;
taxes.c:	      test_firmly_related_ops_local (oops->node, oops);
taxes.c:  test_firmly_related_ops_local (NULL, stand_env->operators);
taxes.c:  if (find_local (n->symbol_table, a, SYMBOL (n)) != NULL)
taxes.c:      z->symbol_table = s;
taxes.c:      z->priority = p;
taxes.c:      z->node = n;
taxes.c:	  bind_tag (&s->identifiers, z);
taxes.c:	  bind_tag (&s->operators, z);
taxes.c:	  bind_tag (&s->priority, z);
taxes.c:	  bind_tag (&s->indicants, z);
taxes.c:	  bind_tag (&s->labels, z);
taxes.c:	  bind_tag (&s->anonymous, z);
taxes.c:	  s = here->operators;
taxes.c:	  s = here->priority;
taxes.c:	  s = here->identifiers;
taxes.c:	  s = here->indicants;
taxes.c:	  s = here->labels;
taxes.c:	  if (SYMBOL (s->node) == tag)
taxes.c:      return (find_tag_global (here->previous, a, tag));
taxes.c:      for (s = here->identifiers; s != NULL; s = NEXT (s))
taxes.c:	  if (SYMBOL (s->node) == tag)
taxes.c:      for (s = here->labels; s != NULL; s = NEXT (s))
taxes.c:	  if (SYMBOL (s->node) == tag)
taxes.c:      return (find_identifier_global (here->previous, tag));
taxes.c:	  s = here->operators;
taxes.c:	  s = here->priority;
taxes.c:	  s = here->identifiers;
taxes.c:	  s = here->indicants;
taxes.c:	  s = here->labels;
taxes.c:	  if (SYMBOL (s->node) == tag)
taxes.c:	  TAG *entry = find_local (p->symbol_table, Identifier, SYMBOL (p));
taxes.c:	  if ((*m)->attribute == _REF_)
taxes.c:	  TAG *entry = find_local (p->symbol_table, Identifier, SYMBOL (p));
taxes.c:	      TAG *z = add_tag (p->symbol_table, Anonymous, p, SUB (*m),
taxes.c:	      z->use = A_TRUE;
taxes.c:	  TAG *entry = find_local (p->symbol_table, Identifier, SYMBOL (p));
taxes.c:	      TAG *z = add_tag (p->symbol_table, Anonymous, p, SUB (TYPE (p)),
taxes.c:	      z->use = A_TRUE;
taxes.c:	  TAG *entry = find_local (p->symbol_table, Identifier, SYMBOL (p));
taxes.c:	  MOID *m = NEXT (NEXT (p))->type;
taxes.c:	  TAG *entry = p->symbol_table->operators;
taxes.c:	  while (entry != NULL && entry->node != p)
taxes.c:	  TAG *entry = p->symbol_table->operators;
taxes.c:	  MOID *m = NEXT (NEXT (p))->type;
taxes.c:	  while (entry != NULL && entry->node != p)
taxes.c:	  TAG *entry = p->symbol_table->priority;
taxes.c:	  while (entry != NULL && entry->node != p)
taxes.c:  for (; p != NULL; p = p->next)
taxes.c:	  TAX (p)->node = p;
taxes.c:	  p->routine->node = p;
taxes.c:	  p->routine = NULL;
taxes.c:      p->symbol_table = s;
taxes.c:	      SUB (p)->symbol_table->previous = s;
taxes.c:  SYMBOL_TABLE *top = p->symbol_table;
taxes.c:	      SUB (q)->symbol_table->level = l + 1;
taxes.c:	      SUB (q)->symbol_table->previous = top;
taxes.c:		      SUB (q)->symbol_table->level = l + 2;
taxes.c:	      SUB (q)->symbol_table = top;
taxes.c:      q->symbol_table = top;
taxes.c:	  NEXT (q)->symbol_table = NEXT (q)->forlink->symbol_table;
taxes.c:	      SUB (p)->symbol_table->nest = symbol_table_count++;
taxes.c:  SYMBOL_TABLE *s = p->symbol_table;
taxes.c:      q->symbol_table = s;
taxes.c:	      SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:		  SUB (q)->symbol_table = s;
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:			  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:			  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:		  SUB (q)->symbol_table = s;
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:			  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:			  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:		  SUB (q)->symbol_table = s;
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:			  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:			  SUB (q)->symbol_table = new_symbol_table (s);
taxes.c:	      SUB (q)->symbol_table = u;
taxes.c:		  SUB (q)->symbol_table = new_symbol_table (u);
taxes.c:	      SUB (q)->symbol_table = s;
taxes.c:	      NEXT (q)->symbol_table = NULL;
taxes.c:	      for (; r != NULL && NEXT (q)->symbol_table == NULL; r = NEXT (r))
taxes.c:		      NEXT (q)->symbol_table = SUB (r)->symbol_table;
taxes.c:		      NEXT (q)->forlink = SUB (r);
terminal.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
terminal.c:  while (ch != '\n' && ch != EOF && k < CMS_LINE_SIZE - 1)
unused.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
unused.c:  if (m != NULL && m->use == A_FALSE)
unused.c:      PACK *p = m->pack;
unused.c:      m->use = A_TRUE;
unused.c:	  mark_mode (m->slice);
unused.c:	  TAG *z = find_tag_global (p->symbol_table, Identifier, SYMBOL (p));
unused.c:	      z->use = A_TRUE;
unused.c:	      TAX (p)->use = A_TRUE;
unused.c:	  if ((z = find_tag_global (p->symbol_table, _PRIO_, SYMBOL (p))) != NULL)
unused.c:	      z->use = A_TRUE;
unused.c:	  TAG *z = find_tag_global (p->symbol_table, Indicant, SYMBOL (p));
unused.c:	      z->use = A_TRUE;
unused.c:	      TAX (p)->use = A_TRUE;
unused.c:      if (!s->use)
unused.c:	  warror (A_WRN, s->node, "#tag S is not used", s->node);
unused.c:      if (SUB (p) != NULL && LINE (p)->num != 0)
unused.c:	  if (is_new_level (ATTRIBUTE (p)) && ATTRIBUTE (SUB (p)->symbol_table) != _ENVIRON_)
unused.c:	      unused (SUB (p)->symbol_table->operators);
unused.c:	      unused (SUB (p)->symbol_table->priority);
unused.c:	      unused (SUB (p)->symbol_table->identifiers);
unused.c:	      unused (SUB (p)->symbol_table->indicants);
unused.c:	      unused (SUB (p)->symbol_table->labels);
victal.c:| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
