newgen_stack.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	STACK_NULL   ((stack) NULL)
	defines for empty values
#define	STACK_NULL_P(s)   ((s)==STACK_NULL)
#define	stack_undefined   ((stack)-14)
#define	stack_undefined_p(s)   ((s)==stack_undefined)
#define	STACK_CHECK(s)
#define	STACK_MAP_X(_item, _itemtype, _code, _stack, _downwards)
	not needed
#define	STACK_MAP(_item, _itemtype, _code, _stack)   STACK_MAP_X(_item, _itemtype, _code, _stack, true)
Typedefs
typedef struct __stack_head *	stack
	STACK MANAGEMENT -- headers.
typedef struct __stack_iterator *	stack_iterator
Functions
stack	stack_make (int, int, int)
	allocation
void	stack_free (stack *)
	type, bucket_size, policy
stack	stack_copy (const stack)
	duplicate a stack with its contents.
int	stack_size (const stack)
	observers
int	stack_type (const stack)
int	stack_bsize (const stack)
int	stack_policy (const stack)
int	stack_max_extent (const stack)
int	stack_consistent_p (const stack)
	miscellaneous
bool	stack_empty_p (const stack)
void	stack_info (FILE *, const stack)
void	stack_map (const stack, gen_iter_func_t)
	APPLY f to all items of stack s;.
void	stack_push (void *, stack)
	stack use
void *	stack_pop (stack)
	POPs one item from stack s.
void *	stack_head (const stack)
	returns the item on top of stack s
void *	stack_nth (const stack, int)
	returns the nth item starting from the head and counting from 1, when possible, or NULL, elsewhere.
void *	stack_replace (void *, stack)
	REPLACEs the item on top of stack s, and returns the old item.
stack_iterator	stack_iterator_init (const stack, bool)
	stack iterator
bool	stack_iterator_next_and_go (stack_iterator, void **)
	X-ward.
void	stack_iterator_end (stack_iterator *)
bool	stack_iterator_end_p (stack_iterator)

---

Define Documentation

#define STACK_CHECK

(

s

)

Value:

message_assert("stack null or undefined",                       \
                 !STACK_NULL_P(s) && !stack_undefined_p(s))

Definition at line 58 of file newgen_stack.h.

Referenced by stack_iterator_internal_init(), stack_map(), and STACK_OBSERVER().

#define STACK_MAP	(	_item,
		_itemtype,
		_code,
		_stack		)	STACK_MAP_X(_item, _itemtype, _code, _stack, true)

Definition at line 116 of file newgen_stack.h.

#define STACK_MAP_X	(	_item,
		_itemtype,
		_code,
		_stack,
		_downwards		)

Value:

{                                                                       \
    stack_iterator _i = stack_iterator_init(_stack, _downwards);        \
    void * _vs_item;                                                    \
    while (stack_iterator_next_and_go(_i, &_vs_item))                   \
    {                                                                   \
      _itemtype _item = (_itemtype) _vs_item;                           \
      _code;                                                            \
    }                                                                   \
    stack_iterator_end(&_i);                                            \
  }

not needed

applies _code on the items of _stack downward , with _item of _itemtype.

Definition at line 104 of file newgen_stack.h.

Referenced by claire_loop(), claire_tiling(), stack_copy(), string_buffer_append_sb(), string_buffer_free(), string_buffer_size(), string_buffer_to_file(), string_buffer_to_string_internal(), xml_loop(), xml_Loops(), and xml_tiling().

#define STACK_NULL   ((stack) NULL)

defines for empty values

Definition at line 52 of file newgen_stack.h.

Referenced by stack_free(), and xml_Loops().

#define STACK_NULL_P

(

s

)

((s)==STACK_NULL)

Definition at line 53 of file newgen_stack.h.

Referenced by init_C_comment(), and stack_info().

#define stack_undefined   ((stack)-14)

Definition at line 55 of file newgen_stack.h.

Referenced by actual_c_parser(), CParserError(), effects_private_current_context_stack_initialized_p(), get_from_entity_type_stack_table(), perform_icm_association(), ResetCurrentModule(), and ResetTypedefStack().

#define stack_undefined_p

(

s

)

((s)==stack_undefined)

Definition at line 56 of file newgen_stack.h.

Referenced by c_parse(), CParserError(), FindOrCreateCurrentEntity(), init_C_comment(), MakeTypedefStack(), put_to_entity_type_stack_table(), remove_entity_type_stacks(), stack_info(), step_make_new_directive_module_name(), UpdateEntity(), UseFormalArguments(), and yyparse().

---

Typedef Documentation

typedef struct __stack_head* stack

STACK MANAGEMENT -- headers.

• a stack is declared with type stack (internals not visible from here!)
• a stack_iterator allows to iterate over the items in a stack.
• allocation with stack_make(newgen domain, bucket size)
• free with stack_free(stack)
• stack_size(stack) returns the number of elements stacked
• stack_empty_p(stack) tells whether the stack is empty or not stack_empty_p(stack)==(stack_size(stack)==0)
• stack_{push,pop,head,replace} do what you may expect from them
• stack_info gives informations about the stack
• stack_map applies the function on all the items in stack.
• stack_iterator_{init,next_and_go,end} to iterate.
• see STACK_MAP for instance.

newgen_assert should be included before.

Fabien COELHO 05/12/1994 encapsulated types

Definition at line 47 of file newgen_stack.h.

typedef struct __stack_iterator* stack_iterator

Definition at line 48 of file newgen_stack.h.

---

Function Documentation

int stack_bsize

(

const

stack

)

int stack_consistent_p

(

const

stack

)

miscellaneous

stack stack_copy

(

const

stack

)

duplicate a stack with its contents.

Definition at line 255 of file stack.c.

References __stack_head::bucket_size, n, __stack_head::policy, stack_make(), STACK_MAP_X, stack_push(), and __stack_head::type.

Referenced by RenameFunctionEntity(), and store_call_context().

{
  stack n = stack_make(s->type, s->bucket_size, s->policy);
  STACK_MAP_X(i, void*, stack_push(i, n), s, 0);
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool stack_empty_p

(

const

stack

)

Referenced by actual_c_parser(), c_parse(), EnterScope(), ExitScope(), FindOrCreateCurrentEntity(), GetContext(), GetParentScope(), GetScope(), PopContext(), ResetTypedefStack(), string_buffer_reset(), UpdateEntity(), and yyparse().

Here is the caller graph for this function:

void stack_free

(

stack *

)

type, bucket_size, policy

Definition at line 280 of file stack.c.

References free_buckets(), gen_free_area(), stack_head(), STACK_NULL, and STACK_PTR_NULL.

Referenced by actual_c_parser(), bottom_up_abc_statement(), claire_tasks(), CParserError(), gen_internal_context_multi_recurse(), genread_parse(), initial_code_abc_statement(), interprocedural_abc_statement(), loop_statistics(), pips_code_abc_statement(), remove_entity_type_stacks(), ResetCurrentModule(), ResetTypedefStack(), string_buffer_free(), top_down_abc_statement(), typing_of_expressions(), xml_Boxes(), xml_Task(), and xml_tasks().

{
  free_buckets((*ps)->stack), (*ps)->stack=STACK_PTR_NULL;
  free_buckets((*ps)->avail), (*ps)->avail=STACK_PTR_NULL;
  gen_free_area((void**) *ps, sizeof(stack_head));
  *ps = STACK_NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* stack_head

(

const

stack

)

returns the item on top of stack s

HEAD

Definition at line 406 of file stack.c.

References assert, __stack_bucket::items, __stack_bucket::n_item, __stack_head::stack, STACK_PTR_NULL_P, __stack_bucket::succ, and x.

Referenced by abc_instrumentation_insert_before_statement(), arguments_are_something(), bottom_up_abc_insert_before_statement(), c_parse(), call_rwt(), check_format(), check_io_list(), check_spec(), check_this_loop(), check_this_test(), check_this_whileloop(), EnterScope(), ExitScope(), FindOrCreateCurrentEntity(), gen_get_recurse_current_ancestor(), genread_parse(), GetContext(), GetContextCopy(), GetFunction(), GetScope(), interprocedural_abc_insert_before_statement(), is_integer_specifier(), is_label_integer_string_specifier(), is_label_specifier(), is_string_specifier(), is_unit_specifier(), is_varibale_array_element_specifier(), loop_flt(), loop_rwt(), MakeBreakStatement(), MakeCaseStatement(), MakeContinueStatement(), MakeDefaultStatement(), MakeForloop(), MakeParameterList(), MakeSwitchStatement(), MakeWhileLoop(), PopContext(), push_loop(), quick_multi_already_seen_p(), seq_rwt(), stack_free(), StackPop(), StackPush(), statement_with_at_most_one_expression_integer(), statement_with_at_most_one_integer_or_character(), statement_without_argument(), stmt_rwt(), store_call_context(), test_rwt(), top_down_abc_insert_before_statement(), type_this_entity_if_needed(), type_this_expression(), type_this_instruction(), typing_arguments_of_user_function(), typing_assign_substring(), typing_buffer_inout(), typing_function_argument_type_to_return_type(), typing_implied_do(), typing_of_assign(), typing_substring(), uns_rwt(), UpdateAbstractEntity(), UpdateDerivedEntity(), UpdateEntity(), wl_rwt(), and yyparse().

{
  _stack_ptr x = s->stack;
  if (x->n_item==0) x = x->succ;
  assert(!STACK_PTR_NULL_P(x) && x->n_item>0);

  /*   HEAD
   */
  return x->items[(x->n_item)-1];
}

void stack_info	(	FILE *	,
		const	stack
	)

else

else

Definition at line 328 of file stack.c.

References __stack_head::avail, fprintf(), __stack_head::max_extent, number_of_buckets(), __stack_head::size, __stack_head::stack, STACK_NULL_P, stack_undefined_p, and __stack_head::type.

{
  fprintf(f, "stack_info about stack %p\n", s);

  if (STACK_NULL_P(s))
  {
    fprintf(f, " - is null\n");
    return;
  }
  /* else */
  if (stack_undefined_p(s))
  {
    fprintf(f, " - is undefined\n");
    return;
  }
  /* else */
  fprintf(f, " - type %d, size %zd, max extent %zd\n",
          s->type, s->size, s->max_extent);
  fprintf(f, " - buckets: %d in use, %d available\n",
          number_of_buckets(s->stack), number_of_buckets(s->avail));
}

Here is the call graph for this function:

void stack_iterator_end

(

stack_iterator *

)

Definition at line 181 of file stack.c.

References free(), and NULL.

{
  (*pi)->bucket = NEWGEN_FREED;
  (*pi)->downward = 0;
  (*pi)->index = 0;
  (*pi)->list = NEWGEN_FREED;
  free(*pi);
  *pi=(stack_iterator) NULL;
}

Here is the call graph for this function:

bool stack_iterator_end_p

(

stack_iterator

)

Definition at line 176 of file stack.c.

References STACK_ITERATOR_END_P.

{
  return STACK_ITERATOR_END_P(i);
}

stack_iterator stack_iterator_init	(	const	stack,
		bool
	)

stack iterator

This way the stack type is fully encapsulated, but it is not very efficient, due to the many function calls. Consider "stack_map" first which has a very small overhead.

Definition at line 154 of file stack.c.

References malloc(), and stack_iterator_internal_init().

{
  stack_iterator i = (stack_iterator) malloc(sizeof(_stack_iterator));
  stack_iterator_internal_init(s, down, i);
  return i;
}

Here is the call graph for this function:

bool stack_iterator_next_and_go	(	stack_iterator	,
		void **
	)

X-ward.

Definition at line 161 of file stack.c.

References __stack_iterator::bucket, __stack_iterator::index, __stack_bucket::items, NEXT_ITERATION, NULL, and STACK_ITERATOR_END_P.

Referenced by stack_nth().

{
  if (STACK_ITERATOR_END_P(i))
  {
    *pitem = (void*) NULL;
    return false;
  }
  else
  {
    *pitem = (i->bucket->items)[i->index];
    NEXT_ITERATION(i);
    return true;
  }
}

Here is the caller graph for this function:

stack stack_make	(	int	type,
		int	bucket_size,
		int	policy
	)

allocation

not too small

not used

Definition at line 234 of file stack.c.

References allocate_bucket(), __stack_head::avail, __stack_head::bucket_size, malloc(), __stack_head::max_extent, message_assert, __stack_head::n_buckets, __stack_head::policy, __stack_head::size, __stack_head::stack, STACK_DEFAULT_SIZE, STACK_PTR_NULL, and __stack_head::type.

Referenced by actual_c_parser(), bottom_up_abc_statement(), c_parse(), claire_tasks(), gen_internal_context_multi_recurse(), genread_parse(), guard_elimination(), if(), initial_code_abc_statement(), InitializeBlock(), interprocedural_abc_statement(), loop_statistics(), MakeCurrentModule(), MakeTypedefStack(), pips_code_abc_statement(), push_pips_context(), stack_copy(), string_buffer_make(), tiling_sequence(), top_down_abc_statement(), typing_of_expressions(), xml_Boxes(), xml_Task(), xml_tasks(), and yyparse().

{
  stack s = (stack) malloc(sizeof(_stack_head));
  message_assert("pointer was allocated", s);

  if (bucket_size<10) bucket_size=STACK_DEFAULT_SIZE; /* not too small */

  s->size = 0;
  s->type = type;
  s->policy = policy; /* not used */
  s->bucket_size = bucket_size;
  s->max_extent = 0;
  s->n_buckets = 0;
  s->stack = allocate_bucket(bucket_size);
  s->avail = STACK_PTR_NULL;

  return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void stack_map	(	const	stack,
		gen_iter_func_t
	)

APPLY f to all items of stack s;.

Definition at line 309 of file stack.c.

References __stack_bucket::items, __stack_bucket::n_item, NULL, __stack_head::stack, STACK_CHECK, __stack_bucket::succ, and x.

{
  _stack_ptr x;
  int i;

  STACK_CHECK(s);

  for(x=s->stack; x!=NULL; x=x->succ)
    for(i=(x->n_item)-1; i>=0; i--)
      (*f)(x->items[i]);
}

int stack_max_extent

(

const

stack

)

void* stack_nth	(	const stack	s,
		int	nskip
	)

returns the nth item starting from the head and counting from 1, when possible, or NULL, elsewhere.

stack_nth(stack,1)==stack_head(stack) if stack_size(stack)>=1.

Definition at line 422 of file stack.c.

References message_assert, NULL, stack_iterator_internal_init(), and stack_iterator_next_and_go().

Referenced by GetParentScope().

{
  void * value = NULL;
  message_assert("positive nskip", nskip>=0);
  // message_assert("deep enough stack", stack_size(s)>=nskip);
  _stack_iterator si;
  stack_iterator_internal_init(s, true, &si);
  while (nskip && stack_iterator_next_and_go(&si, &value))
    nskip--;
  return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int stack_policy

(

const

stack

)

void* stack_pop

(

stack

s

)

POPs one item from stack s.

the empty buckets are not freed here. stack_free does the job.

POP!

Definition at line 385 of file stack.c.

References assert, __stack_head::avail, __stack_bucket::items, __stack_bucket::n_item, __stack_head::size, __stack_head::stack, STACK_PTR_NULL_P, __stack_bucket::succ, and x.

Referenced by c_parse(), ExitScope(), gen_internal_context_multi_recurse(), genread_parse(), NStackPop(), pop_current_statement(), pop_loop(), pop_pips_context(), pop_uns(), PopContext(), PopFunction(), PopTypedef(), quick_multi_recurse_obj_out(), stmt_rwt(), string_buffer_reset(), UpdateAbstractEntity(), UpdateDerivedEntity(), UpdateEntity(), and yyparse().

{
  _stack_ptr x = s->stack;

  if (x->n_item==0)
  {
    _stack_ptr saved = x->succ;
    x->succ = s->avail, s->avail = x;
    s->stack = saved, x = saved;
  }

  assert(!STACK_PTR_NULL_P(x) && x->n_item>0);

  /*   POP!
   */
  s->size--;
  return x->items[--x->n_item];
}

Here is the caller graph for this function:

void stack_push	(	void *	item,
		stack	s
	)

stack use

stack use

PUSHes the item on stack s a new bucket is allocated if necessary. the size it the same than the initial bucket size. Other policies may be considered.

PUSH!

Definition at line 359 of file stack.c.

References assert, find_or_allocate(), __stack_bucket::items, __stack_head::max_extent, __stack_bucket::max_items, __stack_bucket::n_item, __stack_head::size, __stack_head::stack, STACK_PTR_NULL_P, __stack_bucket::succ, and x.

{
  _stack_ptr x = s->stack;

  assert(!STACK_PTR_NULL_P(x));

  if (x->n_item == x->max_items)
  {
    _stack_ptr saved = x;
    x = find_or_allocate(s);
    x->succ = saved;
    s->stack = x;
  }

  /*   PUSH!
   */
  s->size++;
  if (s->size > s->max_extent) s->max_extent = s->size;
  x->items[x->n_item++] = item;
}

Here is the call graph for this function:

void* stack_replace	(	void *	,
		stack
	)

REPLACEs the item on top of stack s, and returns the old item.

REPLACE

Definition at line 436 of file stack.c.

References assert, __stack_bucket::items, __stack_bucket::n_item, __stack_head::stack, STACK_PTR_NULL_P, __stack_bucket::succ, and x.

{
  _stack_ptr x = s->stack;
  void *old;

  if (x->n_item==0) x = x->succ;
  assert(!STACK_PTR_NULL_P(x) && x->n_item>0);

  /*    REPLACE
   */
  old = x->items[(x->n_item)-1];
  x->items[(x->n_item)-1] = item;

  return old;
}

int stack_size

(

const

stack

)

observers

Referenced by abc_instrumentation_insert_before_statement(), bottom_up_abc_insert_before_statement(), c_parse(), claire_loop(), claire_tiling(), gen_internal_context_multi_recurse(), genread_parse(), GetContext(), GetContextCopy(), GetParentScope(), interprocedural_abc_insert_before_statement(), PopContext(), PushContext(), ScopeStackSize(), top_down_abc_insert_before_statement(), UpdateAbstractEntity(), UpdateDerivedEntity(), UpdateEntity(), xml_tiling(), and yyparse().

Here is the caller graph for this function:

int stack_type

(

const

stack

)