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

svalue.c File Reference

#include "global.h"
#include "main.h"
#include "svalue.h"
#include "stralloc.h"
#include "array.h"
#include "mapping.h"
#include "multiset.h"
#include "object.h"
#include "program.h"
#include "constants.h"
#include "pike_error.h"
#include "dynamic_buffer.h"
#include "interpret.h"
#include "gc.h"
#include "pike_macros.h"
#include "pike_types.h"
#include <ctype.h>
#include "queue.h"
#include "bignum.h"
#include "cyclic.h"
#include "pike_float.h"
#include <math.h>

Defines

#define sp   Pike_sp
#define DOTYPE(X, Y, Z)
#define TWO_TYPES(X, Y)   (((X)<<8)|(Y))
#define GC_CHECK_SWITCH(U, T, ZAP, GC_DO, PRE, DO_FUNC, DO_OBJ)
#define DO_CHECK_FUNC_SVALUE(U, T, ZAP, GC_DO)
#define DO_FUNC_SHORT_SVALUE(U, T, ZAP, GC_DO)   Pike_fatal("Cannot have a function in a short svalue.\n");
#define DO_CHECK_OBJ(U, T, ZAP, GC_DO)   GC_DO(U.object);
#define DO_CHECK_OBJ_WEAK(U, T, ZAP, GC_DO)
#define NEVER_ZAP()
#define SET_SUB_SVALUE(V)   s->subtype = (V)
#define SET_SUB_SHORT_SVALUE(V)
#define ZAP_SVALUE()
#define ZAP_SHORT_SVALUE()
#define GC_RECURSE_SWITCH(U, T, ZAP, FREE_WEAK, GC_DO, PRE, DO_FUNC, DO_OBJ, DO_STR)
#define DONT_FREE_WEAK(U, T, ZAP)
#define FREE_WEAK(U, T, ZAP)
#define GC_DO_MARK(U, TN)
#define GC_DONT_MARK(U, TN)   do {} while (0)
#define DO_MARK_FUNC_SVALUE(U, T, ZAP, GC_DO)
#define DONT_MARK_FUNC_SVALUE(U, T, ZAP, GC_DO)
#define DO_MARK_OBJ_WEAK(U, TN)
#define DO_MARK_STRING(U)   DO_IF_DEBUG(if (U.refs && d_flag) gc_mark(U.string))
#define DONT_MARK_STRING(U)
#define DO_CYCLE_CHECK_FUNC_SVALUE(U, T, ZAP, GC_DO)   if (s->subtype == FUNCTION_BUILTIN) break; \
#define DO_CYCLE_CHECK_STRING(U)
#define GC_DO_CYCLE_CHECK(U, TN)   PIKE_CONCAT(gc_cycle_check_, TN)(U.TN, 0)
#define GC_DO_CYCLE_CHECK_WEAK(U, TN)   PIKE_CONCAT(gc_cycle_check_, TN)(U.TN, 1)

Functions

PMOD_EXPORT void really_free_short_svalue_ptr (void **s, TYPE_T type)
PMOD_EXPORT void really_free_svalue (struct svalue *s)
PMOD_EXPORT void do_free_svalue (struct svalue *s)
PMOD_EXPORT void debug_free_svalues (struct svalue *s, size_t num, INT32 type_hint DMALLOC_LINE_ARGS)
PMOD_EXPORT void debug_free_mixed_svalues (struct svalue *s, size_t num, INT32 type_hint DMALLOC_LINE_ARGS)
PMOD_EXPORT TYPE_FIELD assign_svalues_no_free (struct svalue *to, const struct svalue *from, size_t num, TYPE_FIELD type_hint)
PMOD_EXPORT TYPE_FIELD assign_svalues (struct svalue *to, const struct svalue *from, size_t num, TYPE_FIELD type_hint)
PMOD_EXPORT void assign_to_short_svalue (union anything *u, TYPE_T type, const struct svalue *s)
PMOD_EXPORT void assign_to_short_svalue_no_free (union anything *u, TYPE_T type, const struct svalue *s)
PMOD_EXPORT void assign_from_short_svalue_no_free (struct svalue *s, const union anything *u, TYPE_T type)
PMOD_EXPORT void assign_short_svalue_no_free (union anything *to, const union anything *from, TYPE_T type)
PMOD_EXPORT void assign_short_svalue (union anything *to, const union anything *from, TYPE_T type)
PMOD_EXPORT unsigned INT32 hash_svalue (const struct svalue *s)
PMOD_EXPORT int svalue_is_true (const struct svalue *s)
PMOD_EXPORT int safe_svalue_is_true (const struct svalue *s)
PMOD_EXPORT int is_identical (const struct svalue *a, const struct svalue *b)
PMOD_EXPORT int is_eq (const struct svalue *a, const struct svalue *b)
PMOD_EXPORT int low_is_equal (const struct svalue *a, const struct svalue *b, struct processing *p)
PMOD_EXPORT int low_short_is_equal (const union anything *a, const union anything *b, TYPE_T type, struct processing *p)
PMOD_EXPORT int is_equal (const struct svalue *a, const struct svalue *b)
PMOD_EXPORT int is_lt (const struct svalue *a, const struct svalue *b)
PMOD_EXPORT int is_le (const struct svalue *a, const struct svalue *b)
PMOD_EXPORT void describe_svalue (const struct svalue *s, int indent, struct processing *p)
PMOD_EXPORT void print_svalue (FILE *out, const struct svalue *s)
PMOD_EXPORT void print_short_svalue (FILE *out, const union anything *a, TYPE_T type)
PMOD_EXPORT void print_svalue_compact (FILE *out, const struct svalue *s)
PMOD_EXPORT void print_short_svalue_compact (FILE *out, const union anything *a, TYPE_T type)
PMOD_EXPORT void copy_svalues_recursively_no_free (struct svalue *to, const struct svalue *from, size_t num, struct mapping *m)
PMOD_EXPORT void real_gc_check_svalues (const struct svalue *s, size_t num)
void gc_check_weak_svalues (const struct svalue *s, size_t num)
PMOD_EXPORT void real_gc_check_short_svalue (const union anything *u, TYPE_T type)
void gc_check_weak_short_svalue (const union anything *u, TYPE_T type)
PMOD_EXPORT TYPE_FIELD real_gc_mark_svalues (struct svalue *s, size_t num)
TYPE_FIELD gc_mark_weak_svalues (struct svalue *s, size_t num)
int real_gc_mark_short_svalue (union anything *u, TYPE_T type)
int gc_mark_weak_short_svalue (union anything *u, TYPE_T type)
int gc_mark_without_recurse (struct svalue *s)
int gc_mark_weak_without_recurse (struct svalue *s)
PMOD_EXPORT TYPE_FIELD real_gc_cycle_check_svalues (struct svalue *s, size_t num)
TYPE_FIELD gc_cycle_check_weak_svalues (struct svalue *s, size_t num)
PMOD_EXPORT int real_gc_cycle_check_short_svalue (union anything *u, TYPE_T type)
int gc_cycle_check_weak_short_svalue (union anything *u, TYPE_T type)
void real_gc_free_svalue (struct svalue *s)
void real_gc_free_short_svalue (union anything *u, TYPE_T type)
PMOD_EXPORT INT32 pike_sizeof (const struct svalue *s)
int svalues_are_constant (struct svalue *s, INT32 num, TYPE_FIELD hint, struct processing *p)

Variables

const struct svalue dest_ob_zero

Define Documentation

#define DO_CHECK_FUNC_SVALUE (  U,
T,
ZAP,
GC_DO   ) 
 

Value:

if (s->subtype == FUNCTION_BUILTIN) {                           \
        DO_IF_DEBUG(                                                    \
          if (d_flag && !gc_check(s->u.efun)) {                         \
            gc_check(s->u.efun->name);                                  \
            gc_check(s->u.efun->type);                                  \
          }                                                             \
        )                                                               \
        break;                                                          \
      }                                                                 \

#define DO_CHECK_OBJ (  U,
T,
ZAP,
GC_DO   )     GC_DO(U.object);
 

#define DO_CHECK_OBJ_WEAK (  U,
T,
ZAP,
GC_DO   ) 
 

Value:

if (U.object->prog &&                                           \
          !(U.object->prog->flags & PROGRAM_NO_WEAK_FREE))              \
        gc_check_weak(U.object);                                        \
      else                                                              \
        gc_check(U.object);

#define DO_CYCLE_CHECK_FUNC_SVALUE (  U,
T,
ZAP,
GC_DO   )     if (s->subtype == FUNCTION_BUILTIN) break; \
 

#define DO_CYCLE_CHECK_STRING (  U   ) 
 

#define DO_FUNC_SHORT_SVALUE (  U,
T,
ZAP,
GC_DO   )     Pike_fatal("Cannot have a function in a short svalue.\n");
 

#define DO_MARK_FUNC_SVALUE (  U,
T,
ZAP,
GC_DO   ) 
 

Value:

if (s->subtype == FUNCTION_BUILTIN) {                           \
        DO_IF_DEBUG(                                                    \
          if (d_flag) {                                                 \
            gc_mark(s->u.efun->name);                                   \
            gc_mark(s->u.efun->type);                                   \
          }                                                             \
        )                                                               \
        break;                                                          \
      }                                                                 \

#define DO_MARK_OBJ_WEAK (  U,
TN   ) 
 

Value:

if (U.object->prog &&                                           \
          (U.object->prog->flags & PROGRAM_NO_WEAK_FREE))               \
        GC_DO_MARK(U, TN)

#define DO_MARK_STRING (  U   )     DO_IF_DEBUG(if (U.refs && d_flag) gc_mark(U.string))
 

#define DONT_FREE_WEAK (  U,
T,
ZAP   ) 
 

#define DONT_MARK_FUNC_SVALUE (  U,
T,
ZAP,
GC_DO   ) 
 

Value:

if (s->subtype == FUNCTION_BUILTIN)                             \
        break;                                                          \

#define DONT_MARK_STRING (  U   ) 
 

#define DOTYPE (  X,
Y,
Z   ) 
 

Value:

case X:                                         \
   while(num--) {                                                       \
    DO_IF_DMALLOC(debug_malloc_update_location(s->u.Z, dmalloc_location));      \
    Y(s->u.Z);                                                          \
    DO_IF_DMALLOC(s->u.Z=(void *)-1);                                   \
    PIKE_MEM_WO(s->u.Z);                                                \
    s++;                                                                \
   }return

#define FREE_WEAK (  U,
T,
ZAP   ) 
 

Value:

if (gc_do_weak_free(U.refs)) {                                  \
        ZAP();                                                          \
        freed = 1;                                                      \
        break;                                                          \
      }

#define GC_CHECK_SWITCH (  U,
T,
ZAP,
GC_DO,
PRE,
DO_FUNC,
DO_OBJ   ) 
 

Value:

switch (T) {                                                            \
    case T_FUNCTION:                                                    \
      PRE DO_FUNC(U, T, ZAP, GC_DO)                                     \
    case T_OBJECT:                                                      \
      PRE DO_OBJ(U, T, ZAP, GC_DO) break;                               \
    case T_STRING:                                                      \
      PRE DO_IF_DEBUG(if (d_flag) gc_check(U.string);) break;           \
    case T_PROGRAM:                                                     \
    case T_ARRAY:                                                       \
    case T_MULTISET:                                                    \
    case T_MAPPING:                                                     \
      PRE GC_DO(U.refs); break;                                         \
  }

#define GC_DO_CYCLE_CHECK (  U,
TN   )     PIKE_CONCAT(gc_cycle_check_, TN)(U.TN, 0)
 

#define GC_DO_CYCLE_CHECK_WEAK (  U,
TN   )     PIKE_CONCAT(gc_cycle_check_, TN)(U.TN, 1)
 

#define GC_DO_MARK (  U,
TN   ) 
 

Value:

gc_mark_enqueue((queue_call) PIKE_CONCAT3(gc_mark_, TN, _as_referenced), \
                      U.TN)

#define GC_DONT_MARK (  U,
TN   )     do {} while (0)
 

#define GC_RECURSE_SWITCH (  U,
T,
ZAP,
FREE_WEAK,
GC_DO,
PRE,
DO_FUNC,
DO_OBJ,
DO_STR   ) 
 

Value:

switch (T) {                                                            \
    case T_FUNCTION:                                                    \
      PRE DO_FUNC(U, T, ZAP, GC_DO)                                     \
    case T_OBJECT:                                                      \
      PRE                                                               \
      if (!U.object->prog) {                                            \
        ZAP();                                                          \
        freed = 1;                                                      \
        break;                                                          \
      }                                                                 \
      FREE_WEAK(U, T, ZAP) DO_OBJ(U, object);                           \
      break;                                                            \
    case T_STRING:                                                      \
      DO_STR(U); break;                                                 \
    case T_PROGRAM:                                                     \
      PRE FREE_WEAK(U, T, ZAP) GC_DO(U, program); break;                \
    case T_ARRAY:                                                       \
      PRE FREE_WEAK(U, T, ZAP) GC_DO(U, array); break;                  \
    case T_MULTISET:                                                    \
      PRE FREE_WEAK(U, T, ZAP) GC_DO(U, multiset); break;               \
    case T_MAPPING:                                                     \
      PRE FREE_WEAK(U, T, ZAP) GC_DO(U, mapping); break;                \
  }

 
#define NEVER_ZAP (   ) 
 

#define SET_SUB_SHORT_SVALUE (  V   ) 
 

#define SET_SUB_SVALUE (  V   )     s->subtype = (V)
 

#define sp   Pike_sp
 

#define TWO_TYPES (  X,
Y   )     (((X)<<8)|(Y))
 

 
#define ZAP_SHORT_SVALUE (   ) 
 

Value:

do {                                                            \
        gc_free_short_svalue(u, type);                                  \
        u->refs = 0;                                                    \
      } while (0)

 
#define ZAP_SVALUE (   ) 
 

Value:

do {                                                            \
        gc_free_svalue(s);                                              \
        s->type = T_INT;                                                \
        s->u.integer = 0;                                               \
        s->subtype = NUMBER_DESTRUCTED;                                 \
      } while (0)

Function Documentation

PMOD_EXPORT void assign_from_short_svalue_no_free (  struct svalue *  s,
const union anything *  u,
TYPE_T  type
) 
 

PMOD_EXPORT void assign_short_svalue (  union anything *  to,
const union anything *  from,
TYPE_T  type
) 
 

PMOD_EXPORT void assign_short_svalue_no_free (  union anything *  to,
const union anything *  from,
TYPE_T  type
) 
 

PMOD_EXPORT TYPE_FIELD assign_svalues (  struct svalue *  to,
const struct svalue *  from,
size_t  num,
TYPE_FIELD  type_hint
) 
 

PMOD_EXPORT TYPE_FIELD assign_svalues_no_free (  struct svalue *  to,
const struct svalue *  from,
size_t  num,
TYPE_FIELD  type_hint
) 
 

PMOD_EXPORT void assign_to_short_svalue (  union anything *  u,
TYPE_T  type,
const struct svalue *  s
) 
 

PMOD_EXPORT void assign_to_short_svalue_no_free (  union anything *  u,
TYPE_T  type,
const struct svalue *  s
) 
 

PMOD_EXPORT void copy_svalues_recursively_no_free (  struct svalue *  to,
const struct svalue *  from,
size_t  num,
struct mapping *  m
) 
 

PMOD_EXPORT void debug_free_mixed_svalues (  struct svalue *  s,
size_t  num,
INT32 type_hint  DMALLOC_LINE_ARGS
) 
 

PMOD_EXPORT void debug_free_svalues (  struct svalue *  s,
size_t  num,
INT32 type_hint  DMALLOC_LINE_ARGS
) 
 

PMOD_EXPORT void describe_svalue (  const struct svalue *  s,
int  indent,
struct processing *  p
) 
 

PMOD_EXPORT void do_free_svalue (  struct svalue *  s  ) 
 

void gc_check_weak_short_svalue (  const union anything *  u,
TYPE_T  type
) 
 

void gc_check_weak_svalues (  const struct svalue *  s,
size_t  num
) 
 

int gc_cycle_check_weak_short_svalue (  union anything *  u,
TYPE_T  type
) 
 

TYPE_FIELD gc_cycle_check_weak_svalues (  struct svalue *  s,
size_t  num
) 
 

int gc_mark_weak_short_svalue (  union anything *  u,
TYPE_T  type
) 
 

TYPE_FIELD gc_mark_weak_svalues (  struct svalue *  s,
size_t  num
) 
 

int gc_mark_weak_without_recurse (  struct svalue *  s  ) 
 

int gc_mark_without_recurse (  struct svalue *  s  ) 
 

PMOD_EXPORT unsigned INT32 hash_svalue (  const struct svalue *  s  ) 
 

PMOD_EXPORT int is_eq (  const struct svalue *  a,
const struct svalue *  b
) 
 

PMOD_EXPORT int is_equal (  const struct svalue *  a,
const struct svalue *  b
) 
 

PMOD_EXPORT int is_identical (  const struct svalue *  a,
const struct svalue *  b
) 
 

PMOD_EXPORT int is_le (  const struct svalue *  a,
const struct svalue *  b
) 
 

PMOD_EXPORT int is_lt (  const struct svalue *  a,
const struct svalue *  b
) 
 

PMOD_EXPORT int low_is_equal (  const struct svalue *  a,
const struct svalue *  b,
struct processing *  p
) 
 

PMOD_EXPORT int low_short_is_equal (  const union anything *  a,
const union anything *  b,
TYPE_T  type,
struct processing *  p
) 
 

PMOD_EXPORT INT32 pike_sizeof (  const struct svalue *  s  ) 
 

PMOD_EXPORT void print_short_svalue (  FILE *  out,
const union anything *  a,
TYPE_T  type
) 
 

PMOD_EXPORT void print_short_svalue_compact (  FILE *  out,
const union anything *  a,
TYPE_T  type
) 
 

PMOD_EXPORT void print_svalue (  FILE *  out,
const struct svalue *  s
) 
 

PMOD_EXPORT void print_svalue_compact (  FILE *  out,
const struct svalue *  s
) 
 

PMOD_EXPORT void real_gc_check_short_svalue (  const union anything *  u,
TYPE_T  type
) 
 

PMOD_EXPORT void real_gc_check_svalues (  const struct svalue *  s,
size_t  num
) 
 

PMOD_EXPORT int real_gc_cycle_check_short_svalue (  union anything *  u,
TYPE_T  type
) 
 

PMOD_EXPORT TYPE_FIELD real_gc_cycle_check_svalues (  struct svalue *  s,
size_t  num
) 
 

void real_gc_free_short_svalue (  union anything *  u,
TYPE_T  type
) 
 

void real_gc_free_svalue (  struct svalue *  s  ) 
 

int real_gc_mark_short_svalue (  union anything *  u,
TYPE_T  type
) 
 

PMOD_EXPORT TYPE_FIELD real_gc_mark_svalues (  struct svalue *  s,
size_t  num
) 
 

PMOD_EXPORT void really_free_short_svalue_ptr (  void **  s,
TYPE_T  type
) 
 

PMOD_EXPORT void really_free_svalue (  struct svalue *  s  ) 
 

PMOD_EXPORT int safe_svalue_is_true (  const struct svalue *  s  ) 
 

PMOD_EXPORT int svalue_is_true (  const struct svalue *  s  ) 
 

int svalues_are_constant (  struct svalue *  s,
INT32  num,
TYPE_FIELD  hint,
struct processing *  p
) 
 

Variable Documentation

const struct svalue dest_ob_zero
 

Initial value:

 {
  T_INT, 0,



}

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