pike.git/ src/ svalue.h > 84736385eac313d7f09dc9260ee5ce6265292e64 [Annotate]

/* 

|| This file is part of Pike. For copyright information see COPYRIGHT. 

|| Pike is distributed under GPL, LGPL and MPL. See the file COPYING 

|| for more information. 

*/ 

#ifndef SVALUE_H 

#define SVALUE_H 

#include "global.h" 

#include "buffer.h" 

#ifndef STRUCT_CALLABLE_DECLARED 

#define STRUCT_CALLABLE_DECLARED 

struct callable; 

#endif 

#ifndef STRUCT_NODE_S_DECLARED 

#define STRUCT_NODE_S_DECLARED 

struct node_s; 

typedef struct node_s node; 

#endif 

struct processing 

{ 

  struct processing *next; 

  void *pointer_a, *pointer_b; 

}; 

struct ref_dummy; 

/** the union of possible types in an svalue. 

*/ 

union anything 

{ 

  INT_TYPE integer;             /**< Union initializations assume this first. */ 

  struct callable *efun; 

  struct array *array; 

  struct mapping *mapping; 

  struct multiset *multiset; 

  struct object *object; 

  struct program *program; 

  struct pike_string *string; 

  struct pike_type *type; 

  INT32 *refs; 

  struct ref_dummy *dummy; 

  FLOAT_TYPE float_number; 

  int identifier;           /**< Used with T_OBJ_INDEX. */ 

  struct svalue *lval;              /**< Used with T_SVALUE_PTR. */ 

  void *ptr; 

#ifdef DEBUG_MALLOC 

  char *loc;                      /* Only used for free svalue debugging. */ 

#endif 

}; 

/* The native types. 

 * 

 * Note that PIKE_T_INT is zero so that cleared memory 

 * is filled with zeroes. 

 */ 

enum PIKE_TYPE { 

    PIKE_T_INT=0, 

    PIKE_T_FLOAT=1, 

/* NB: The reference counted types all have bit 4 set. */ 

    PIKE_T_ARRAY=8, 

    PIKE_T_MAPPING=9, 

    PIKE_T_MULTISET=10, 

    PIKE_T_OBJECT=11, 

    PIKE_T_FUNCTION=12, 

    PIKE_T_PROGRAM=13, 

    PIKE_T_STRING=14, 

    PIKE_T_TYPE=15, 

/* The types above are valid types in svalues. 

 * The following are only used by the internal systems. 

 */ 

/* NB: 6 & 7 below are selected for easy backward compat with Pike 7.8. */ 

    PIKE_T_ZERO= 6,     /**< Can return 0, but nothing else */ 

    T_UNFINISHED=7, 

/* 

 * NOTE: The following types may show up on the stack, but are NOT 

 *       reference counted there. There they are mainly used for 

 *       lvalues. They MUST NOT have a value that has bit 3 (8) set. 

 */ 

    T_VOID=       16, /**< Can't return any value. Also used on stack to fill out the second 

 * svalue on an lvalue when it isn't used. */ 

    T_MANY=       17, 

    PIKE_T_INT_UNTYPED= 18, /* Optimization of int type size */ 

/* Type to put in freed svalues. Only the type field in such svalues 

 * is defined. Freeing a PIKE_T_FREE svalue is allowed and does 

 * nothing. mark_free_svalue() is preferably used to set this type. 

 * 

 * Traditionally T_INT has been used for this without setting a proper 

 * subtype; if T_INT is to be used then the subtype must be set to 

 * NUMBER_NUMBER. 

 * 

 * PIKE_T_FREE svalues are recorded as BIT_INT in type hint fields. 

 */ 

    PIKE_T_FREE=19, 

/** svalue.u.lval points to an svalue. Primarily used in lvalues on 

 * stack, but can also occur in arrays containing lvalue pairs. 

 */ 

    T_SVALUE_PTR=20, 

/** svalue.u.identifer is an identifier index in an object. Primarily 

 * used in lvalues on stack, but can also occur in arrays containing 

 * lvalue pairs. 

 */ 

    T_OBJ_INDEX=21, 

    T_ARRAY_LVALUE=22, 

/* No types above this value should appear on the stack. */ 

    PIKE_T_STACK_MAX=   T_ARRAY_LVALUE, 

    PIKE_T_GET_SET= 32, /* Getter setter. 

                         * Only valid in struct identifier */ 

    /** 

     * Values 0x30 - 0x3f reserved for variables. 

     * Only 0x30 - 0x39 used currently. 

     */ 

    PIKE_T_VAR_0 = '0',         /* 48 */ 

    PIKE_T_VAR_1 = '1', 

    PIKE_T_VAR_2 = '2', 

    PIKE_T_VAR_3 = '3', 

    PIKE_T_VAR_4 = '4', 

    PIKE_T_VAR_5 = '5', 

    PIKE_T_VAR_6 = '6', 

    PIKE_T_VAR_7 = '7', 

    PIKE_T_VAR_8 = '8', 

    PIKE_T_VAR_9 = '9',         /* 57 */ 

/* 

 * The following types are only used in compile-time types and 

 * as markers in struct identifier. 

 */ 

    PIKE_T_LARRAY = 236,        /* Limited array. Only for serialization. */ 

    PIKE_T_LSTRING = 237,       /* Limited string. Only for serialization. */ 

    PIKE_T_ATTRIBUTE = 238,     /* Attribute node. */ 

    PIKE_T_NSTRING = 239,       /* Narrow string. Only for serialization. */ 

    PIKE_T_RING = 240, 

    PIKE_T_NAME = 241,          /**< Named type. */ 

    PIKE_T_SCOPE = 243,         /**< Not supported yet */ 

    PIKE_T_TUPLE = 244,         /**< Not supported yet */ 

    T_ASSIGN = 245, 

    T_DELETED = 246, 

    /** Used to mark an svalue as free and not valid for input 

     *  to the svalue free functions. 

     *  Cf assert_free_svalue(). 

     */ 

    PIKE_T_UNKNOWN=247, 

/* should only be used while compiling */ 

    PIKE_T_AUTO = 248, 

    /* Historic values: 

     * T_OBJ_INDEX = 248,       // Renumbered to 21. 

     * T_LVALUE = 249,          // Renamed to T_SVALUE_PTR and renumbered to 20. 

     * T_ARRAY_LVALUE = 250,    // Renumbered to 22. 

     */ 

    PIKE_T_MIXED = 251, 

    T_NOT = 253, 

    T_AND = 254, 

    T_OR = 255, 

/* This flag is only valid in struct reference, and corresponds 

 * to struct identifier identifier_flags IDENTIFIER_NO_THIS_REF. */ 

#define PIKE_T_NO_REF_FLAG    256 

#define PIKE_T_NO_REF_OBJECT        (PIKE_T_NO_REF_FLAG|PIKE_T_OBJECT) 

#define PIKE_T_NO_REF_FUNCTION      (PIKE_T_NO_REF_FLAG|PIKE_T_FUNCTION) 

#define PIKE_T_NO_REF_MIXED (PIKE_T_NO_REF_FLAG|PIKE_T_MIXED) 

#define PIKE_T_NO_REF_INT   (PIKE_T_NO_REF_FLAG|PIKE_T_INT) 

#define PIKE_T_NO_REF_FLOAT (PIKE_T_NO_REF_FLAG|PIKE_T_FLOAT) 

/* These are only used together with describe() and friends. */ 

#define T_STORAGE 10000 

#define T_MAPPING_DATA 10001 

#define T_PIKE_FRAME 10002 

#define T_MULTISET_DATA 10003 

#define T_STRUCT_CALLABLE 10004 

}; 

/** 

 */ 

struct svalue 

{ 

  union { 

    struct { 

      /* NB: Ought to be "enum PIKE_TYPE type:16", but then the 

       *     machine code generator can't use the &-operator to 

       *     get the field offset. On the other hand the offset 

       *     should always be zero, so... 

       */ 

      unsigned short type; /**< the data type, see PIKE_T_... */ 

      unsigned short subtype; /**< used to store the zero type, among others */ 

    } t; 

    enum PIKE_TYPE named_type:16; 

#if PIKE_BYTEORDER == 1234 

    ptrdiff_t type_subtype; 

#else 

    /* For big-endian 64-bit architectures we don't want to require 

     * 64-bit constants when setting the type_subtype field. 

     */ 

    INT32 type_subtype; 

#if SIZEOF_CHAR_P == 8 

    ptrdiff_t pad__; 

#endif 

#endif 

  } tu; 

  union anything u; /**< contains the value */ 

}; 

#define PIKE_TYPEOF(SVAL)     ((SVAL).tu.t.type) 

#define PIKE_SUBTYPEOF(SVAL)        ((SVAL).tu.t.subtype) 

#define TYPEOF(SVAL)                PIKE_TYPEOF(SVAL) 

#define SUBTYPEOF(SVAL)             PIKE_SUBTYPEOF(SVAL) 

#define SET_SVAL_TYPE(SVAL, TYPE)     (TYPEOF(SVAL) = (TYPE)) 

#define SET_SVAL_SUBTYPE(SVAL, TYPE)        (SUBTYPEOF(SVAL) = (TYPE)) 

#if PIKE_BYTEORDER == 1234 

#define TYPE_SUBTYPE(X,Y) ((unsigned int)(X)|((unsigned int)(Y)<<16)) 

#else 

#define TYPE_SUBTYPE(X,Y) ((unsigned int)(Y)|((unsigned int)(X)<<16)) 

#endif 

#define SET_SVAL_TYPE_SUBTYPE(SVAL, TYPE, SUBTYPE) \ 

  ((SVAL).tu.type_subtype = TYPE_SUBTYPE(TYPE,SUBTYPE)) 

/* Setting the entire type_subtype field is probably faster than 

 * just setting the type field. 

 */ 

#define SET_SVAL_TYPE_DC(SVAL, TYPE)  SET_SVAL_TYPE_SUBTYPE(SVAL, TYPE, 0) 

#define SET_SVAL(SVAL, TYPE, SUBTYPE, FIELD, EXPR) do { \ 

    /* Set the type afterwards to avoid a clobbered     \ 

     * svalue in case EXPR throws. */                   \ 

    struct svalue * __sv_ptr = &( SVAL );               \ 

    __sv_ptr->u.FIELD = (EXPR);                         \ 

    SET_SVAL_TYPE_SUBTYPE(*__sv_ptr, TYPE, SUBTYPE);    \ 

  } while(0) 

/* 

*/ 

#define INVALIDATE_SVAL(SVAL) SET_SVAL_TYPE_DC(SVAL, 99) /* an invalid type */ 

/* NOTE: The t* macros below currently use the old type encoding 

 *       to be compatible with __parse_pike_type() in older 

 *       versions of Pike. 

 */ 

#define tArr(VAL) "\000" VAL 

#define tArray tArr(tMix) 

#define tLArr(LEN, VAL) "\354" LEN VAL 

#define tMap(IND,VAL) "\001" IND VAL 

#define tMapping tMap(tMix,tMix) 

#define tSet(IND) "\002" IND 

#define tMultiset tSet(tMix) 

#define tObj "\003\000\000\000\000\000" 

#define tFuncV(ARGS,REST,RET) MagictFuncV(RET,REST,ARGS) 

#define tFunc(ARGS,RET) MagictFunc(RET,ARGS) 

#define tTuple(T1,T2)         "\364" T1 T2 

#define tTriple(T1,T2,T3)   tTuple(T1, tTuple(T2, T3)) 

#define tQuad(T1,T2,T3,T4)  tTriple(tTuple(T1, T2), T3, T4) 

/* These two magic funcions are used to make MSVC++ work 

 * even if 'ARGS' is empty. 

 */ 

#define MagictFuncV(RET,REST,ARGS) "\004" ARGS "\021" REST RET 

#define MagictFunc(RET,ARGS) tFuncV(ARGS "", tVoid, RET) 

#define tFunction tFuncV("" ,tOr(tZero,tVoid),tOr(tMix,tVoid)) 

#define tNone "" 

#define tPrg(X) "\005" X 

#define tProgram(X) "\005" X 

#define tStr "\006" 

#define tString "\006" 

#define tNStr(T) "\357" T 

#define tStr0 "\357" tZero 

#define tStr7 "\357" "\010\000\000\000\000\000\000\000\177" 

#define tStr8 "\357" "\010\000\000\000\000\000\000\000\377" 

#define tStr16 "\357" "\010\000\000\000\000\000\000\377\377" 

#define tStr32 "\006" 

#define tLStr(LEN, VAL) "\355" LEN VAL 

#define tType(T) "\007" T 

#define tInt "\022" 

#define tInt0 "\010\000\000\000\000\000\000\000\000" 

#define tInt1 "\010\000\000\000\001\000\000\000\001" 

#define tInt2 "\010\000\000\000\002\000\000\000\002" 

#define tInt01 "\010\000\000\000\000\000\000\000\001" 

#define tInt02 "\010\000\000\000\000\000\000\000\002" 

#define tInt03 "\010\000\000\000\000\000\000\000\003" 

#define tInt04 "\010\000\000\000\000\000\000\000\004" 

#define tInt05 "\010\000\000\000\000\000\000\000\005" 

#define tInt06 "\010\000\000\000\000\000\000\000\006" 

#define tInt07 "\010\000\000\000\000\000\000\000\007" 

#define tInt08 "\010\000\000\000\000\000\000\000\010" 

#define tInt09 "\010\000\000\000\000\000\000\000\011" 

#define tIntPos "\010\000\000\000\000\177\377\377\377" 

#define tIntNeg "\010\200\000\000\000\000\000\000\000" 

#define tInt1Plus "\010\000\000\000\001\177\377\377\377" 

#define tInt2Plus "\010\000\000\000\002\177\377\377\377" 

#define tIntMinus "\010\200\000\000\000\377\377\377\377" 

#define tInt_10 "\010\377\377\377\377\000\000\000\000" 

#define tInt_11 "\010\377\377\377\377\000\000\000\001" 

#define tByte "\010\000\000\000\000\000\000\000\377" 

#define tWord "\010\000\000\000\000\000\000\377\377" 

#define tFlt "\011" 

#define tFloat "\011" 

#define tZero "\016" 

#define tVoid "\020" 

#define tVar(X) #X 

#define tSetvar(X,Y) "\365" #X Y 

#define tScope(X,T) "\363" #X Y 

#define tNot(X) "\375" X 

#define tAnd(X,Y) "\376" X Y 

#define tOr(X,Y) "\377" X Y 

#define tOr3(X,Y,Z) tOr(X,tOr(Y,Z)) 

#define tOr4(X,Y,Z,A) tOr(X,tOr(Y,tOr(Z,A))) 

#define tOr5(X,Y,Z,A,B) tOr(X,tOr(Y,tOr(Z,tOr(A,B)))) 

#define tOr6(X,Y,Z,A,B,C) tOr(X,tOr(Y,tOr(Z,tOr(A,tOr(B,C))))) 

#define tOr7(X,Y,Z,A,B,C,D) tOr(X,tOr(Y,tOr(Z,tOr(A,tOr(B,tOr(C,D)))))) 

#define tOr8(A,B,C,D,E,F,G,H) tOr(A,tOr7(B,C,D,E,F,G,H)) 

#define tOr9(A,B,C,D,E,F,G,H,I) tOr(A,tOr8(B,C,D,E,F,G,H,I)) 

#define tMix "\373" 

#define tMixed "\373" 

#define tComplex tOr6(tArray,tMapping,tMultiset,tObj,tFunction,tPrg(tObj)) 

#define tStringIndicable tOr5(tMapping,tObj,tFunction,tPrg(tObj),tMultiset) 

#define tRef tOr(tString,tComplex) 

#define tIfnot(X,Y) tAnd(tNot(X),Y) 

#define tAny tOr(tVoid,tMix) 

#define tAttr(X,Y) "\356\0" X "\0" Y 

#define tName(X,Y) "\361\0" X "\0" Y 

#if PIKE_BYTEORDER == 1234 

/* Little endian */ 

#define tAttr1(X,Y) "\356\5" X "\0\0" Y 

#define tAttr2(X,Y) "\356\6" X "\0\0\0\0" Y 

#define tName1(X,Y) "\361\5" X "\0\0" Y 

#define tName2(X,Y) "\361\6" X "\0\0\0\0" Y 

#else /* PIKE_BYTEORDER != 1234 */ 

/* Big endian */ 

#define tAttr1(X,Y) "\356\1" X "\0\0" Y 

#define tAttr2(X,Y) "\356\2" X "\0\0\0\0" Y 

#define tName1(X,Y) "\361\1" X "\0\0" Y 

#define tName2(X,Y) "\361\2" X "\0\0\0\0" Y 

#endif /* PIKE_BYTEORDER == 1234 */ 

/* Some convenience macros for common attributes. */ 

#define tSprintfFormat(X)     tAttr("sprintf_format", X) 

#define tSprintfArgs(X)             tAttr("sprintf_args", X) 

#define tDeprecated(X)              tAttr("deprecated", X) 

#define tUtf8Str            tAttr("utf8", tStr8) 

#define tSimpleCallable tOr3(tArray,tFunction,tObj) 

#define tCallable tOr3(tArr(tSimpleCallable),tFunction,tObj) 

#define BIT_ARRAY (1<<PIKE_T_ARRAY) 

#define BIT_MAPPING (1<<PIKE_T_MAPPING) 

#define BIT_MULTISET (1<<PIKE_T_MULTISET) 

#define BIT_OBJECT (1<<PIKE_T_OBJECT) 

#define BIT_FUNCTION (1<<PIKE_T_FUNCTION) 

#define BIT_PROGRAM (1<<PIKE_T_PROGRAM) 

#define BIT_STRING (1<<PIKE_T_STRING) 

#define BIT_TYPE (1<<PIKE_T_TYPE) 

#define BIT_INT (1<<PIKE_T_INT) 

#define BIT_FLOAT (1<<PIKE_T_FLOAT) 

#define BIT_ZERO (1<<PIKE_T_ZERO) 

/** Used to signify that the type field hasn't been set according to 

 * reality. */ 

#define BIT_UNFINISHED (1 << T_UNFINISHED) 

/** This is only used in typechecking to signify that this 

 * argument may be omitted. 

 */ 

#define BIT_VOID (1 << T_VOID) 

/** This is used in typechecking to signify that the rest of the 

 * arguments have to be of this type. 

 */ 

#define BIT_MANY (1 << T_MANY) 

#define BIT_NOTHING 0 

#define BIT_MIXED 0xff7f 

#define BIT_BASIC (BIT_INT|BIT_FLOAT|BIT_STRING|BIT_TYPE) 

#define BIT_COMPLEX (BIT_ARRAY|BIT_MULTISET|BIT_OBJECT|BIT_PROGRAM|BIT_MAPPING|BIT_FUNCTION) 

#define BIT_CALLABLE (BIT_FUNCTION|BIT_PROGRAM|BIT_ARRAY|BIT_OBJECT) 

#define BIT_REF_TYPES (BIT_STRING|BIT_TYPE|BIT_COMPLEX) 

/* Max type which contains svalues */ 

#define MAX_COMPLEX PIKE_T_PROGRAM 

/* Min type with ref count */ 

#define MIN_REF_TYPE PIKE_T_ARRAY 

/* Max type handled by svalue primitives */ 

#define MAX_TYPE PIKE_T_TYPE 

#define REFCOUNTED_TYPE(T)    (((T) & ~(MIN_REF_TYPE - 1)) == MIN_REF_TYPE) 

#define NUMBER_NUMBER 0 

#define NUMBER_UNDEFINED 1 

#define NUMBER_DESTRUCTED 2 

#define FUNCTION_BUILTIN USHRT_MAX 

extern PMOD_EXPORT const  struct svalue svalue_undefined, svalue_int_zero; 

extern PMOD_EXPORT const  struct svalue svalue_int_one; 

/* 

 * Storage struct for a trampoline object 

 * (not a part of the program type) 

 */ 

struct pike_trampoline 

{ 

  struct pike_frame *frame; 

  INT32 func; 

}; 

/* NB: From builtin.cmod. */ 

extern struct program *pike_trampoline_program; 

#define is_gt(a,b) is_lt(b,a) 

#define is_ge(a,b) is_le(b,a) 

/* SAFE_IS_ZERO is compatible with the old IS_ZERO, but you should 

 * consider using UNSAFE_IS_ZERO instead, since exceptions thrown from 

 * `! functions will be propagated correctly then. */ 

#define UNSAFE_IS_ZERO(X) (PIKE_TYPEOF(*(X))==PIKE_T_INT?(X)->u.integer==0:(1<<PIKE_TYPEOF(*(X)))&(BIT_OBJECT|BIT_FUNCTION)?!complex_svalue_is_true(X):0) 

#define SAFE_IS_ZERO(X) (PIKE_TYPEOF(*(X))==PIKE_T_INT?(X)->u.integer==0:(1<<PIKE_TYPEOF(*(X)))&(BIT_OBJECT|BIT_FUNCTION)?!safe_svalue_is_true(X):0) 

#define IS_UNDEFINED(X) (check_svalue (X), PIKE_TYPEOF(*(X))==PIKE_T_INT&&PIKE_SUBTYPEOF(*(X))==NUMBER_UNDEFINED) 

#define IS_DESTRUCTED(X)                                                \ 

  ((PIKE_TYPEOF(*(X)) == PIKE_T_OBJECT && !(X)->u.object->prog) ||      \ 

 (PIKE_TYPEOF(*(X)) == PIKE_T_FUNCTION &&                               \ 

  PIKE_SUBTYPEOF(*(X)) != FUNCTION_BUILTIN                              \ 

  && (!(X)->u.object->prog                                              \ 

      || ((X)->u.object->prog == pike_trampoline_program                \ 

          && !((struct pike_trampoline *)(X)->u.object->storage)        \ 

          ->frame->current_object->prog                                 \ 

          && PIKE_SUBTYPEOF(*(X)) ==                                    \ 

          QUICK_FIND_LFUN(pike_trampoline_program, LFUN_CALL))))) 

/* var MUST be a variable!!! */ 

#define safe_check_destructed(var) do{ \ 

    if(IS_DESTRUCTED(var))             \ 

      var=&svalue_int_zero;            \ 

  }while(0) 

/* FIXME: Is this actually used for functions? */ 

#define check_short_destructed(U,T) \ 

do{ \ 

  union anything *_u=(U); \ 

  if(( (1<<(T)) & (BIT_OBJECT | BIT_FUNCTION) ) && \ 

     _u->object && !_u->object->prog) { \ 

    free_object(_u->object); \ 

    _u->object = 0; \ 

  } \ 

}while(0) 

#define add_ref(X) ((void)((X)->refs++)) 

#define sub_ref(X) (--(X)->refs > 0) 

#ifdef PIKE_DEBUG 

PMOD_EXPORT extern void describe(void *); /* defined in gc.c */ 

PMOD_EXPORT extern const char msg_type_error[]; 

PMOD_EXPORT extern const char msg_assign_svalue_error[]; 

#define IS_INVALID_TYPE(T) is_invalid_stack_type(T) 

#define check_type(T) do {                                            \ 

    TYPE_T typ_ = (T);                                                  \ 

    if (IS_INVALID_TYPE (typ_)) Pike_fatal(msg_type_error, typ_);       \ 

  } while (0) 

#define check_svalue_type(S) do {                                     \ 

    const struct svalue *sval_ = (S);                                   \ 

    TYPE_T typ_ = PIKE_TYPEOF(*sval_);                                  \ 

    if (IS_INVALID_TYPE (typ_)) debug_svalue_type_error (sval_);        \ 

  } while (0) 

#define check_svalue(S) debug_check_svalue(dmalloc_check_svalue(S,DMALLOC_LOCATION())) 

void low_thorough_check_short_svalue (const union anything *u, TYPE_T type); 

#define thorough_check_short_svalue(U, T) do {                                \ 

    union anything *anyth_ = (U);                                       \ 

    TYPE_T typ_ = (T);                                                  \ 

    check_short_svalue (anyth_, typ_);                                  \ 

    if (d_flag <= 50) /* Done directly by check_svalue otherwise. */    \ 

      if (REFCOUNTED_TYPE(typ_))                                        \ 

        low_thorough_check_short_svalue (anyth_, typ_);                 \ 

  } while (0) 

#define thorough_check_svalue(S) do {                                       \ 

    struct svalue *sval_ = (S);                                         \ 

    check_svalue (sval_);                                               \ 

    if (d_flag <= 50) /* Done directly by check_svalue otherwise. */    \ 

      if (REFCOUNTED_TYPE(PIKE_TYPEOF(*sval_)))                         \ 

        low_thorough_check_short_svalue (&sval_->u, PIKE_TYPEOF(*sval_)); \ 

  } while (0) 

void check_short_svalue(const union anything *u, TYPE_T type); 

PMOD_EXPORT void debug_svalue_type_error (const struct svalue *s); 

PMOD_EXPORT int is_invalid_stack_type(unsigned int t); 

PMOD_EXPORT void debug_check_svalue(const struct svalue *s); 

void debug_check_type_hint (const struct svalue *svals, size_t num, TYPE_FIELD type_hint); 

PMOD_EXPORT void real_gc_mark_external_svalues(const struct svalue *s, ptrdiff_t num, 

                                               const char *place); 

PMOD_EXPORT extern const char msg_sval_obj_wo_refs[]; 

#define check_refs(S) do {                                            \ 

    if(REFCOUNTED_TYPE(PIKE_TYPEOF(*(S))) &&                            \ 

       (!(S)->u.refs || (S)->u.refs[0] < 0)) {                          \ 

   fprintf (stderr, "%s", msg_sval_obj_wo_refs);                        \ 

   describe((S)->u.refs);                                               \ 

   Pike_fatal("%s", msg_sval_obj_wo_refs);                              \ 

 } }while(0) 

PMOD_EXPORT extern const char msg_ssval_obj_wo_refs[]; 

#define check_refs2(S,T) do { \ 

if(REFCOUNTED_TYPE(T) && (S)->refs && (S)->refs[0] <= 0) {\ 

  fprintf (stderr, "%s", msg_ssval_obj_wo_refs);           \ 

  describe((S)->refs);                                     \ 

  Pike_fatal("%s", msg_ssval_obj_wo_refs);                 \ 

} }while(0) 

#define check_type_hint(SVALS, NUM, TYPE_HINT)                                \ 

  debug_check_type_hint ((SVALS), (NUM), (TYPE_HINT)) 

#ifdef DEBUG_MALLOC 

static inline struct svalue PIKE_UNUSED_ATTRIBUTE *dmalloc_check_svalue(struct svalue *s, char *l) 

{ 

  if(s && REFCOUNTED_TYPE(PIKE_TYPEOF(*s))) 

    debug_malloc_update_location(s->u.refs,l); 

  return s; 

} 

static inline struct svalue PIKE_UNUSED_ATTRIBUTE *dmalloc_check_svalues(struct svalue *s, size_t num, char *l) 

{ 

  while (num--) dmalloc_check_svalue (s + num, l); 

  return s; 

} 

static inline union anything PIKE_UNUSED_ATTRIBUTE *dmalloc_check_union(union anything *u,int type, char * l) 

{ 

  if(u && REFCOUNTED_TYPE(type)) 

    debug_malloc_update_location(u->refs,l); 

  return u; 

} 

#undef add_ref 

#define add_ref(X) (((INT32 *)debug_malloc_update_location( &((X)->refs), DMALLOC_NAMED_LOCATION(" add_ref")))[0]++) 

#undef sub_ref 

#define sub_ref(X) (--((INT32 *)debug_malloc_update_location( &((X)->refs), DMALLOC_NAMED_LOCATION(" sub_ref")))[0] > 0) 

#else  /* !DEBUG_MALLOC */ 

#define dmalloc_check_svalue(S,L) (S) 

#define dmalloc_check_svalues(S,L,N) (S) 

#define dmalloc_check_union(U,T,L) (U) 

#endif      /* !DEBUG_MALLOC */ 

/* To be used for type checking in macros. */ 

static inline struct array PIKE_UNUSED_ATTRIBUTE *pass_array (struct array *a) {return a;} 

static inline struct mapping PIKE_UNUSED_ATTRIBUTE *pass_mapping (struct mapping *m) {return m;} 

static inline struct multiset PIKE_UNUSED_ATTRIBUTE *pass_multiset (struct multiset *l) {return l;} 

static inline struct object PIKE_UNUSED_ATTRIBUTE *pass_object (struct object *o) {return o;} 

static inline struct program PIKE_UNUSED_ATTRIBUTE *pass_program (struct program *p) {return p;} 

static inline struct pike_string PIKE_UNUSED_ATTRIBUTE *pass_string (struct pike_string *s) {return s;} 

static inline struct pike_type PIKE_UNUSED_ATTRIBUTE *pass_type (struct pike_type *t) {return t;} 

static inline struct callable PIKE_UNUSED_ATTRIBUTE *pass_callable (struct callable *c) {return c;} 

#else  /* !PIKE_DEBUG */ 

#define check_svalue(S) ((void) 0) 

#define check_short_svalue(U, T) ((void) 0) 

#define check_type(T) do {} while (0) 

#define check_svalue_type(S) do {} while (0) 

#define check_refs(S) do {} while (0) 

#define check_refs2(S,T) do {} while (0) 

#define check_type_hint(SVALS, NUM, TYPE_HINT) ((void) 0) 

#define dmalloc_check_svalue(S,L) (S) 

#define dmalloc_check_svalues(S,L,N) (S) 

#define dmalloc_check_union(U,T,L) (U) 

#define pass_array(A) (A) 

#define pass_mapping(M) (M) 

#define pass_multiset(L) (L) 

#define pass_object(O) (O) 

#define pass_program(P) (P) 

#define pass_string(S) (S)