Main Page | Class List | Directories | File List | Class Members | File Members
src

array.h File Reference

#include "svalue.h"
#include "dmalloc.h"

Go to the source code of this file.

Classes

struct  array

Defines

#define ARRAY_WEAK_FLAG   1
#define ARRAY_CYCLIC   2
#define ARRAY_LVALUE   4
#define ITEM(X)   ((X)->item)
#define PIKE_ARRAY_OP_A   1
#define PIKE_ARRAY_OP_SKIP_A   2
#define PIKE_ARRAY_OP_TAKE_A   3
#define PIKE_ARRAY_OP_B   4
#define PIKE_ARRAY_OP_SKIP_B   8
#define PIKE_ARRAY_OP_TAKE_B   12
#define PIKE_MINTERM(X, Y, Z)   (((X)<<8)+((Y)<<4)+(Z))
#define PIKE_ARRAY_OP_AND   PIKE_MINTERM(PIKE_ARRAY_OP_SKIP_A,PIKE_ARRAY_OP_SKIP_A | PIKE_ARRAY_OP_TAKE_B,PIKE_ARRAY_OP_SKIP_B)
#define PIKE_ARRAY_OP_AND_LEFT   PIKE_MINTERM(PIKE_ARRAY_OP_SKIP_A,PIKE_ARRAY_OP_SKIP_B | PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_B)
#define PIKE_ARRAY_OP_OR   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_A | PIKE_ARRAY_OP_TAKE_B,PIKE_ARRAY_OP_TAKE_B)
#define PIKE_ARRAY_OP_OR_LEFT   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_B | PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_TAKE_B)
#define PIKE_ARRAY_OP_XOR   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_A | PIKE_ARRAY_OP_SKIP_B,PIKE_ARRAY_OP_TAKE_B)
#define PIKE_ARRAY_OP_ADD   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_TAKE_A | PIKE_ARRAY_OP_TAKE_B ,PIKE_ARRAY_OP_TAKE_B)
#define PIKE_ARRAY_OP_SUB   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_A ,PIKE_ARRAY_OP_SKIP_B)
#define free_array(V)
#define allocate_array(X)   low_allocate_array((X),0)
#define allocate_array_no_init(X, Y)   low_allocate_array((X),(Y))
#define low_allocate_array(size, extra_space)
#define array_get_flags(a)   ((a)->flags)
#define gc_cycle_check_array(X, WEAK)   gc_cycle_enqueue((gc_cycle_check_cb *) real_gc_cycle_check_array, (X), (WEAK))
#define BEGIN_AGGREGATE_ARRAY(estimated_size)
#define DO_AGGREGATE_ARRAY(max_keep_on_stack)
#define END_AGGREGATE_ARRAY
#define array_index_no_free(S, A, I)
#define array_set_index(V, I, S)
#define array_fix_unfinished_type_field(A)
#define ACCEPT_UNFINISHED_TYPE_FIELDS   do
#define END_ACCEPT_UNFINISHED_TYPE_FIELDS   while (0)

Typedefs

typedef int(* cmpfun )(const struct svalue *, const struct svalue *)
typedef int(* short_cmpfun )(union anything *, union anything *)
typedef short_cmpfun(* cmpfun_getter )(TYPE_T)

Functions

PMOD_EXPORT struct array * real_allocate_array (ptrdiff_t size, ptrdiff_t extra_space)
PMOD_EXPORT void really_free_array (struct array *v)
PMOD_EXPORT void do_free_array (struct array *a)
PMOD_EXPORT struct array * array_set_flags (struct array *a, int flags)
PMOD_EXPORT void array_index (struct svalue *s, struct array *v, INT32 ind)
PMOD_EXPORT struct array * array_column (struct array *data, struct svalue *index, int destructive)
PMOD_EXPORT void simple_array_index_no_free (struct svalue *s, struct array *a, struct svalue *ind)
PMOD_EXPORT void array_free_index (struct array *v, INT32 ind)
PMOD_EXPORT void simple_set_index (struct array *a, struct svalue *ind, struct svalue *s)
PMOD_EXPORT struct array * array_insert (struct array *v, struct svalue *s, INT32 ind)
PMOD_EXPORT struct array * resize_array (struct array *a, INT32 size)
PMOD_EXPORT struct array * array_shrink (struct array *v, ptrdiff_t size)
PMOD_EXPORT struct array * array_remove (struct array *v, INT32 ind)
PMOD_EXPORT ptrdiff_t array_search (struct array *v, struct svalue *s, ptrdiff_t start)
PMOD_EXPORT struct array * slice_array (struct array *v, ptrdiff_t start, ptrdiff_t end)
PMOD_EXPORT struct array * friendly_slice_array (struct array *v, ptrdiff_t start, ptrdiff_t end)
PMOD_EXPORT struct array * copy_array (struct array *v)
PMOD_EXPORT void check_array_for_destruct (struct array *v)
PMOD_EXPORT INT32 array_find_destructed_object (struct array *v)
INT32 * get_order (struct array *v, cmpfun fun)
INLINE int set_svalue_cmpfun (const struct svalue *a, const struct svalue *b)
PMOD_EXPORT void sort_array_destructively (struct array *v)
PMOD_EXPORT INT32 * stable_sort_array_destructively (struct array *v)
PMOD_EXPORT INT32 * get_set_order (struct array *a)
PMOD_EXPORT INT32 * get_switch_order (struct array *a)
PMOD_EXPORT INT32 * get_alpha_order (struct array *a)
INT32 set_lookup (struct array *a, struct svalue *s)
INT32 switch_lookup (struct array *a, struct svalue *s)
PMOD_EXPORT struct array * order_array (struct array *v, INT32 *order)
PMOD_EXPORT struct array * reorder_and_copy_array (struct array *v, INT32 *order)
PMOD_EXPORT TYPE_FIELD array_fix_type_field (struct array *v)
PMOD_EXPORT union anything * low_array_get_item_ptr (struct array *a, INT32 ind, TYPE_T t)
PMOD_EXPORT union anything * array_get_item_ptr (struct array *a, struct svalue *ind, TYPE_T t)
INT32 * merge (struct array *a, struct array *b, INT32 opcode)
PMOD_EXPORT struct array * array_zip (struct array *a, struct array *b, INT32 *zipper)
PMOD_EXPORT struct array * add_arrays (struct svalue *argp, INT32 args)
PMOD_EXPORT int array_equal_p (struct array *a, struct array *b, struct processing *p)
PMOD_EXPORT struct array * merge_array_with_order (struct array *a, struct array *b, INT32 op)
PMOD_EXPORT struct array * merge_array_without_order2 (struct array *a, struct array *b, INT32 op)
PMOD_EXPORT struct array * merge_array_without_order (struct array *a, struct array *b, INT32 op)
PMOD_EXPORT struct array * subtract_arrays (struct array *a, struct array *b)
PMOD_EXPORT struct array * and_arrays (struct array *a, struct array *b)
int array_is_constant (struct array *a, struct processing *p)
node * make_node_from_array (struct array *a)
PMOD_EXPORT void push_array_items (struct array *a)
void describe_array_low (struct array *a, struct processing *p, int indent)
void describe_array (struct array *a, struct processing *p, int indent)
PMOD_EXPORT struct array * aggregate_array (INT32 args)
PMOD_EXPORT struct array * append_array (struct array *a, struct svalue *s)
PMOD_EXPORT struct array * explode (struct pike_string *str, struct pike_string *del)
PMOD_EXPORT struct pike_string * implode (struct array *a, struct pike_string *del)
PMOD_EXPORT struct array * copy_array_recursively (struct array *a, struct mapping *p)
PMOD_EXPORT void apply_array (struct array *a, INT32 args)
PMOD_EXPORT struct array * reverse_array (struct array *a)
void array_replace (struct array *a, struct svalue *from, struct svalue *to)
void gc_mark_array_as_referenced (struct array *a)
void real_gc_cycle_check_array (struct array *a, int weak)
unsigned gc_touch_all_arrays (void)
void gc_check_all_arrays (void)
void gc_mark_all_arrays (void)
void gc_cycle_check_all_arrays (void)
void gc_zap_ext_weak_refs_in_arrays (void)
size_t gc_free_all_unreferenced_arrays (void)
void count_memory_in_arrays (INT32 *num_, INT32 *size_)
PMOD_EXPORT struct array * explode_array (struct array *a, struct array *b)
PMOD_EXPORT struct array * implode_array (struct array *a, struct array *b)

Variables

PMOD_EXPORT struct array empty_array weak_empty_array
array * first_array
array * gc_internal_array

Define Documentation

#define ACCEPT_UNFINISHED_TYPE_FIELDS   do
 

#define allocate_array (  X   )     low_allocate_array((X),0)
 

#define allocate_array_no_init (  X,
Y   )     low_allocate_array((X),(Y))
 

#define ARRAY_CYCLIC   2
 

#define array_fix_unfinished_type_field (  A   ) 
 

Value:

do {                            \
    struct array *a_ = (A);                                             \
    if (a_->type_field & BIT_UNFINISHED) {                              \
      DO_IF_DEBUG (array_check_type_field (a_));                        \
      array_fix_type_field (a_);                                        \
    }                                                                   \
  } while (0)

#define array_get_flags (  a   )     ((a)->flags)
 

#define array_index_no_free (  S,
A,
I   ) 
 

Value:

do {                            \
  INT32 ind_=(I);                                               \
  struct array *v_=(A);                                         \
  DO_IF_DEBUG(                                                  \
    if(ind_<0 || ind_>=v_->size)                                \
    Pike_fatal("Illegal index in low level index routine.\n");  \
    )                                                           \
                                                                \
  assign_svalue_no_free((S), ITEM(v_) + ind_);                  \
}while(0)

#define ARRAY_LVALUE   4
 

#define array_set_index (  V,
I,
S   ) 
 

Value:

do {                                     \
  struct array *v_=(V);                                                  \
  INT32 index_=(I);                                                      \
  struct svalue *s_=(S);                                                 \
  struct svalue tmp_;                                                    \
                                                                         \
  DO_IF_DEBUG(                                                           \
  if(index_<0 || index_>v_->size)                                        \
    Pike_fatal("Illegal index in low level array set routine.\n");       \
    )                                                                    \
                                                                         \
  check_destructed(s_);                                                  \
  tmp_=ITEM(v_)[index_];                                                 \
                                                                         \
  v_->type_field |= 1 << s_->type;                                       \
  assign_svalue_no_free( ITEM(v_) + index_, s_);                         \
  free_svalue(&tmp_);                                                    \
}while(0)

#define ARRAY_WEAK_FLAG   1
 

#define BEGIN_AGGREGATE_ARRAY (  estimated_size   ) 
 

Value:

do {                    \
  struct svalue *base__;                                                \
  push_array(allocate_array_no_init(0, (estimated_size)));              \
  base__ = Pike_sp;                                                     \
  base__[-1].u.array->type_field = (BIT_MIXED | BIT_UNFINISHED);

#define DO_AGGREGATE_ARRAY (  max_keep_on_stack   ) 
 

Value:

do {                                                                    \
    ptrdiff_t diff__ = Pike_sp - base__;                                \
    if (diff__ > (max_keep_on_stack)) {                                 \
      INT32 oldsize__ = base__[-1].u.array->size;                       \
      ACCEPT_UNFINISHED_TYPE_FIELDS {                                   \
        base__[-1].u.array =                                            \
          resize_array(base__[-1].u.array, oldsize__ + diff__);         \
      } END_ACCEPT_UNFINISHED_TYPE_FIELDS;                              \
      /* Unless the user does something, the type field will contain */ \
      /* BIT_MIXED|BIT_UNFINISHED from the allocation above. */         \
      MEMCPY((char *) (ITEM(base__[-1].u.array) + oldsize__),           \
             (char *) base__, diff__ * sizeof(struct svalue));          \
      Pike_sp = base__;                                                 \
    }                                                                   \
  } while (0)

#define END_ACCEPT_UNFINISHED_TYPE_FIELDS   while (0)
 

#define END_AGGREGATE_ARRAY
 

Value:

DO_AGGREGATE_ARRAY(0);                                          \
  DO_IF_DEBUG(if (Pike_sp[-1].type != T_ARRAY) {                        \
                Pike_fatal("Lost track of aggregated array.\n");        \
              });                                                       \
  array_fix_type_field(Pike_sp[-1].u.array);                            \
} while (0)

#define free_array (  V   ) 
 

Value:

do{                                             \
    struct array *v_=(V);                                               \
    debug_malloc_touch(v_);                                             \
    DO_IF_DEBUG (                                                       \
      DO_IF_PIKE_CLEANUP (                                              \
        if (gc_external_refs_zapped)                                    \
          gc_check_zapped (v_, PIKE_T_ARRAY, __FILE__, __LINE__)));     \
    if(!sub_ref(v_))                                                    \
      really_free_array(v_);                                            \
  }while(0)
This macro frees one reference to the array V. If the reference is the last reference to the array, it will free the memory used by the array V.
Parameters:
V an array struct to be freed.

#define gc_cycle_check_array (  X,
WEAK   )     gc_cycle_enqueue((gc_cycle_check_cb *) real_gc_cycle_check_array, (X), (WEAK))
 

#define ITEM (  X   )     ((X)->item)
 

#define low_allocate_array (  size,
extra_space   ) 
 

Value:

dmalloc_touch (struct array *,                                  \
                 real_allocate_array ((size), (extra_space)))

#define PIKE_ARRAY_OP_A   1
 

#define PIKE_ARRAY_OP_ADD   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_TAKE_A | PIKE_ARRAY_OP_TAKE_B ,PIKE_ARRAY_OP_TAKE_B)
 

#define PIKE_ARRAY_OP_AND   PIKE_MINTERM(PIKE_ARRAY_OP_SKIP_A,PIKE_ARRAY_OP_SKIP_A | PIKE_ARRAY_OP_TAKE_B,PIKE_ARRAY_OP_SKIP_B)
 

#define PIKE_ARRAY_OP_AND_LEFT   PIKE_MINTERM(PIKE_ARRAY_OP_SKIP_A,PIKE_ARRAY_OP_SKIP_B | PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_B)
 

#define PIKE_ARRAY_OP_B   4
 

#define PIKE_ARRAY_OP_OR   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_A | PIKE_ARRAY_OP_TAKE_B,PIKE_ARRAY_OP_TAKE_B)
 

#define PIKE_ARRAY_OP_OR_LEFT   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_B | PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_TAKE_B)
 

#define PIKE_ARRAY_OP_SKIP_A   2
 

#define PIKE_ARRAY_OP_SKIP_B   8
 

#define PIKE_ARRAY_OP_SUB   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_A ,PIKE_ARRAY_OP_SKIP_B)
 

#define PIKE_ARRAY_OP_TAKE_A   3
 

#define PIKE_ARRAY_OP_TAKE_B   12
 

#define PIKE_ARRAY_OP_XOR   PIKE_MINTERM(PIKE_ARRAY_OP_TAKE_A,PIKE_ARRAY_OP_SKIP_A | PIKE_ARRAY_OP_SKIP_B,PIKE_ARRAY_OP_TAKE_B)
 

#define PIKE_MINTERM (  X,
Y,
Z   )     (((X)<<8)+((Y)<<4)+(Z))
 

Typedef Documentation

typedef int(* cmpfun)(const struct svalue *, const struct svalue *)
 

typedef short_cmpfun(* cmpfun_getter)(TYPE_T)
 

typedef int(* short_cmpfun)(union anything *, union anything *)
 

Function Documentation

PMOD_EXPORT struct array* add_arrays (  struct svalue *  argp,
INT32  args
) 
 

PMOD_EXPORT struct array* aggregate_array (  INT32  args  ) 
 

Pops a number of arguments off of the stack an puts them in an array. The 'top' of the stack will be the last element in the array.

Parameters:
args The number of arguments to aggregate.

PMOD_EXPORT struct array* and_arrays (  struct array *  a,
struct array *  b
) 
 

PMOD_EXPORT struct array* append_array (  struct array *  a,
struct svalue *  s
) 
 

PMOD_EXPORT void apply_array (  struct array *  a,
INT32  args
) 
 

PMOD_EXPORT struct array* array_column (  struct array *  data,
struct svalue *  index,
int  destructive
) 
 

PMOD_EXPORT int array_equal_p (  struct array *  a,
struct array *  b,
struct processing *  p
) 
 

PMOD_EXPORT INT32 array_find_destructed_object (  struct array *  v  ) 
 

This function finds the index of any destructed object in a set. It could be optimized to search out the object part with a binary search lookup if the array is mixed.

PMOD_EXPORT TYPE_FIELD array_fix_type_field (  struct array *  v  ) 
 

PMOD_EXPORT void array_free_index (  struct array *  v,
INT32  index
) 
 

Extract an svalue from an array.

PMOD_EXPORT union anything* array_get_item_ptr (  struct array *  a,
struct svalue *  ind,
TYPE_T  t
) 
 

Get a pointer to the 'union anything' specified if it is of the specified type. The 'union anything' may be changed, but not the type. The differance between this routine and the one above is that this takes the index as an svalue.

PMOD_EXPORT void array_index (  struct svalue *  s,
struct array *  v,
INT32  index
) 
 

Extract an svalue from an array. This function frees the contents of of the svalue 's' and replaces it with a copy of the contents from index 'index' in the array 'v'.

Parameters:
index The index of the array to be extracted.
s The recipient of the extracted array element.
v The array to extract the element from.
This function is similar to assign_svalue(s, v->item + n); except that it adds debug and safety measures. Usually, this function is not needed.

Note:
If n is out of bounds, Pike will dump core. If Pike was compiled with DEBUG, a message will be written first stating what the problem was.

PMOD_EXPORT struct array* array_insert (  struct array *  v,
struct svalue *  s,
INT32  index
) 
 

Insert an svalue into an array and grow the array if nessesary.

int array_is_constant (  struct array *  a,
struct processing *  p
) 
 

PMOD_EXPORT struct array* array_remove (  struct array *  v,
INT32  index
) 
 

Remove an index from an array and shrink the array destructively. Because this function is destructive, and might free the region for 'v', do not use this function on arrays that might have been sent to a Pike function.

Parameters:
v The array to operate on.
index The index of the element to remove
Returns:
a new array with the contents of the input minus the removed index.

void array_replace (  struct array *  a,
struct svalue *  from,
struct svalue *  to
) 
 

PMOD_EXPORT ptrdiff_t array_search (  struct array *  v,
struct svalue *  s,
ptrdiff_t  start
) 
 

Search for in svalue in an array.

Returns:
the index if found, -1 otherwise

PMOD_EXPORT struct array* array_set_flags (  struct array *  a,
int  flags
) 
 

Set the flags on an array. If the array is empty then only the weak flag is significant.

PMOD_EXPORT struct array* array_shrink (  struct array *  v,
ptrdiff_t  size
) 
 

Shrink an array destructively

PMOD_EXPORT struct array* array_zip (  struct array *  a,
struct array *  b,
INT32 *  zipper
) 
 

This routine merges two arrays in the order specified by 'zipper' zipper normally produced by merge() above.

PMOD_EXPORT void check_array_for_destruct (  struct array *  v  ) 
 

Clean an array from destructed objects.

PMOD_EXPORT struct array* copy_array (  struct array *  v  ) 
 

Copy an array.

PMOD_EXPORT struct array* copy_array_recursively (  struct array *  a,
struct mapping *  p
) 
 

void count_memory_in_arrays (  INT32 *  num_,
INT32 *  size_
) 
 

void describe_array (  struct array *  a,
struct processing *  p,
int  indent
) 
 

void describe_array_low (  struct array *  a,
struct processing *  p,
int  indent
) 
 

PMOD_EXPORT void do_free_array (  struct array *  a  ) 
 

Decrement the references (and free if unused) an array if it is not null.

PMOD_EXPORT struct array* explode (  struct pike_string *  str,
struct pike_string *  del
) 
 

PMOD_EXPORT struct array* explode_array (  struct array *  a,
struct array *  b
) 
 

PMOD_EXPORT struct array* friendly_slice_array (  struct array *  v,
ptrdiff_t  start,
ptrdiff_t  end
) 
 

Slice a piece of an array (nondestructively).

Returns:
an array consisting of v[start..end-1]

void gc_check_all_arrays (  void   ) 
 

void gc_cycle_check_all_arrays (  void   ) 
 

size_t gc_free_all_unreferenced_arrays (  void   ) 
 

void gc_mark_all_arrays (  void   ) 
 

void gc_mark_array_as_referenced (  struct array *  a  ) 
 

unsigned gc_touch_all_arrays (  void   ) 
 

void gc_zap_ext_weak_refs_in_arrays (  void   ) 
 

PMOD_EXPORT INT32* get_alpha_order (  struct array *  a  ) 
 

Return an 'order' suitable for sorting.

INT32* get_order (  struct array *  v,
cmpfun  fun
) 
 

PMOD_EXPORT INT32* get_set_order (  struct array *  a  ) 
 

Return an 'order' suitable for making mappings and multisets.

PMOD_EXPORT INT32* get_switch_order (  struct array *  a  ) 
 

Return an 'order' suitable for switches.

Note: This is used by encode_value_canonic(). It must keep the sorting rules for all the types that function allows in multiset and mapping indices.

PMOD_EXPORT struct pike_string* implode (  struct array *  a,
struct pike_string *  del
) 
 

PMOD_EXPORT struct array* implode_array (  struct array *  a,
struct array *  b
) 
 

PMOD_EXPORT union anything* low_array_get_item_ptr (  struct array *  a,
INT32  ind,
TYPE_T  t
) 
 

Get a pointer to the 'union anything' specified if it is of the specified type. The 'union anything' may be changed, but not the type.

node* make_node_from_array (  struct array *  a  ) 
 

INT32* merge (  struct array *  a,
struct array *  b,
INT32  opcode
) 
 

Organize an array of INT32 to specify how to zip two arrays together to maintain the order. The first item in this array is the size of the result the rest is n >= 0 for a[ n ] or n < 0 for b[ ~n ].

PMOD_EXPORT struct array* merge_array_with_order (  struct array *  a,
struct array *  b,
INT32  op
) 
 

Merge two arrays and retain their order. This is done by arranging them into ordered sets, merging them as sets and then rearranging the zipper before zipping the sets together.

PMOD_EXPORT struct array* merge_array_without_order (  struct array *  a,
struct array *  b,
INT32  op
) 
 

PMOD_EXPORT struct array* merge_array_without_order2 (  struct array *  a,
struct array *  b,
INT32  op
) 
 

PMOD_EXPORT struct array* order_array (  struct array *  v,
INT32 *  order
) 
 

Reorganize an array in the order specified by 'order'.

PMOD_EXPORT void push_array_items (  struct array *  a  ) 
 

PMOD_EXPORT struct array* real_allocate_array (  ptrdiff_t  size,
ptrdiff_t  extra_space
) 
 

Allocate an array. This might be changed in the future to allocate linked lists or something. The new array has zero references.

When building arrays, it is recommended that you push the values on the stack and call aggregate_array or f_aggregate instead of allocating and filling in the values 'by hand'.

Parameters:
size The size of the new array, in elements.
extra_space The number of extra elements space should be reserved for.
Returns:
A pointer to the allocated array struct.

void real_gc_cycle_check_array (  struct array *  a,
int  weak
) 
 

PMOD_EXPORT void really_free_array (  struct array *  v  ) 
 

Free an array. Call this when the array has zero references.

Parameters:
v The array to free.

PMOD_EXPORT struct array* reorder_and_copy_array (  struct array *  v,
INT32 *  order
) 
 

Copy and reorganize an array.

PMOD_EXPORT struct array* resize_array (  struct array *  a,
INT32  size
) 
 

Resize an array destructively.

PMOD_EXPORT struct array* reverse_array (  struct array *  a  ) 
 

INT32 set_lookup (  struct array *  a,
struct svalue *  s
) 
 

INLINE int set_svalue_cmpfun (  const struct svalue *  a,
const struct svalue *  b
) 
 

PMOD_EXPORT void simple_array_index_no_free (  struct svalue *  s,
struct array *  a,
struct svalue *  ind
) 
 

PMOD_EXPORT void simple_set_index (  struct array *  a,
struct svalue *  ind,
struct svalue *  s
) 
 

PMOD_EXPORT struct array* slice_array (  struct array *  v,
ptrdiff_t  start,
ptrdiff_t  end
) 
 

Slice a piece of an array (nondestructively)

Returns:
an array consisting of v[start..end-1]

PMOD_EXPORT void sort_array_destructively (  struct array *  v  ) 
 

This sort is unstable.

PMOD_EXPORT INT32* stable_sort_array_destructively (  struct array *  v  ) 
 

This sort is stable. The return value is like the one from get_alpha_order.

PMOD_EXPORT struct array* subtract_arrays (  struct array *  a,
struct array *  b
) 
 

INT32 switch_lookup (  struct array *  a,
struct svalue *  s
) 
 

Variable Documentation

struct array* first_array
 

struct array* gc_internal_array
 

PMOD_EXPORT struct array empty_array weak_empty_array
 

The empty weak array.

Generated on Fri Jul 22 23:44:28 2005 for Pike by  doxygen 1.3.9.1