interpret.h File Reference

#include "global.h"
#include "program.h"
#include "pike_error.h"
#include "object.h"
#include "pike_rusage.h"
#include "block_alloc_h.h"

Go to the source code of this file.

Classes

struct Pike_interpreter

struct pike_frame

struct external_variable_context

struct Pike_stack

Defines

#define PIKE_FRAME_RETURN_INTERNAL   1

#define PIKE_FRAME_RETURN_POP   2

#define PIKE_FRAME_MALLOCED_LOCALS   0x8000

#define check__positive(X, Y)

#define debug_check_stack()

#define low_stack_check(X)

#define check_stack(X)

#define check_mark_stack(X)

#define check_c_stack(X)

#define fatal_check_c_stack(X)

#define STACK_LEVEL_START(depth)   do {

#define STACK_LEVEL_DONE(depth)   } while(0)

#define STACK_LEVEL_CHECK(depth)

#define pop_stack()   do{ free_svalue(--Pike_sp); debug_check_stack(); }while(0)

#define pop_2_elems()   do { pop_stack(); pop_stack(); }while(0)

#define MAYBE_CAST_TO_LONG(X)   ((long)(X))

#define pop_n_elems(X)

#define stack_unlink(X)

#define stack_pop_n_elems_keep_top(X)   stack_unlink(X)

#define stack_pop_keep_top()

#define stack_pop_2_elems_keep_top()

#define stack_pop_to_no_free(X)   move_svalue(X, --Pike_sp)

#define stack_pop_to(X)

#define push_program(P)

#define push_int(I)

#define push_undefined()

#define push_obj_index(I)

#define push_mapping(M)

#define push_array(A)

#define push_empty_array()   ref_push_array(&empty_array)

#define push_multiset(L)

#define push_string(S)

#define push_empty_string()   ref_push_string(empty_pike_string)

#define push_type_value(S)

#define push_object(O)

#define push_object_inherit(O, INH_NUM)

#define push_float(F)

#define push_text(T)

#define push_constant_text(T)

#define push_constant_string_code(STR, CODE)

#define push_function(OBJ, FUN)

#define ref_push_program(P)

#define ref_push_mapping(M)

#define ref_push_array(A)

#define ref_push_multiset(L)

#define ref_push_string(S)

#define ref_push_type_value(S)

#define ref_push_object(O)

#define ref_push_object_inherit(O, INH_NUM)

#define ref_push_function(OBJ, FUN)

#define push_svalue(S)

#define stack_dup()   push_svalue(Pike_sp-1)

#define stack_swap()

#define push_zeroes(N)

#define push_undefines(N)

#define free_pike_frame(F)   do{ struct pike_frame *f_=(F); if(!sub_ref(f_)) really_free_pike_frame(f_); }while(0)

#define free_pike_scope(F)   do{ struct pike_frame *f_=(F); if(!sub_ref(f_)) really_free_pike_scope(f_); }while(0)

#define POP_PIKE_FRAME()

#define APPLY_MASTER(FUN, ARGS)

#define SAFE_APPLY_MASTER(FUN, ARGS)

#define SAFE_APPLY_HANDLER(FUN, HANDLER, COMPAT, ARGS)

#define check_threads_etc()

#define fast_check_threads_etc(X)

#define apply_low(O, FUN, ARGS)   mega_apply(APPLY_LOW, (ARGS), (void*)(O),(void*)(ptrdiff_t)(FUN))

#define strict_apply_svalue(SVAL, ARGS)   mega_apply(APPLY_SVALUE, (ARGS), (void*)(SVAL),0)

#define apply_current(FUN, ARGS)

#define Pike_sp   Pike_interpreter.stack_pointer

#define Pike_fp   Pike_interpreter.frame_pointer

#define Pike_mark_sp   Pike_interpreter.mark_stack_pointer

#define CURRENT_STORAGE   (dmalloc_touch(struct pike_frame *,Pike_fp)->current_storage)

#define PIKE_STACK_MMAPPED

#define PIKE_STACK_REQUIRE_BEGIN(num, base)

#define PIKE_STACK_REQUIRE_END()

Enumerations

enum apply_type { APPLY_STACK, APPLY_SVALUE, APPLY_SVALUE_STRICT, APPLY_LOW }

Functions

void push_sp_mark (void)

ptrdiff_t pop_sp_mark (void)

void gc_mark_stack_external (struct pike_frame *frame, struct svalue *stack_p, struct svalue *stack)

PMOD_EXPORT int low_init_interpreter (struct Pike_interpreter *interpreter)

PMOD_EXPORT void init_interpreter (void)

void lvalue_to_svalue_no_free (struct svalue *to, struct svalue *lval)

PMOD_EXPORT void assign_lvalue (struct svalue *lval, struct svalue *from)

PMOD_EXPORT union anything * get_pointer_if_this_type (struct svalue *lval, TYPE_T t)

void print_return_value (void)

void reset_evaluator (void)

void dump_backlog (void)

BLOCK_ALLOC (pike_frame, 128)

PMOD_EXPORT void find_external_context (struct external_variable_context *loc, int arg2)

void really_free_pike_scope (struct pike_frame *scope)

int low_mega_apply (enum apply_type type, INT32 args, void *arg1, void *arg2)

void low_return (void)

void low_return_pop (void)

void unlink_previous_frame (void)

void mega_apply (enum apply_type type, INT32 args, void *arg1, void *arg2)

PMOD_EXPORT void f_call_function (INT32 args)

PMOD_EXPORT void call_handle_error (void)

PMOD_EXPORT int apply_low_safe_and_stupid (struct object *o, INT32 offset)

PMOD_EXPORT void safe_apply_low (struct object *o, int fun, int args)

PMOD_EXPORT void safe_apply_low2 (struct object *o, int fun, int args, int handle_errors)

PMOD_EXPORT void safe_apply_low3 (struct object *o, int fun, int args, char *error)

PMOD_EXPORT void safe_apply (struct object *o, const char *fun, INT32 args)

PMOD_EXPORT int low_unsafe_apply_handler (const char *fun, struct object *handler, struct object *compat, INT32 args)

PMOD_EXPORT void low_safe_apply_handler (const char *fun, struct object *handler, struct object *compat, INT32 args)

PMOD_EXPORT int safe_apply_handler (const char *fun, struct object *handler, struct object *compat, INT32 args, TYPE_FIELD rettypes)

PMOD_EXPORT void apply_lfun (struct object *o, int fun, int args)

PMOD_EXPORT void apply_shared (struct object *o, struct pike_string *fun, int args)

PMOD_EXPORT void apply (struct object *o, const char *fun, int args)

PMOD_EXPORT void apply_svalue (struct svalue *s, INT32 args)

PMOD_EXPORT void safe_apply_svalue (struct svalue *s, INT32 args, int handle_errors)

PMOD_EXPORT void apply_external (int depth, int fun, INT32 args)

PMOD_EXPORT void slow_check_stack (void)

PMOD_EXPORT void custom_check_stack (ptrdiff_t amount, const char *fmt,...) ATTRIBUTE((format(printf

PMOD_EXPORT void cleanup_interpret (void)

PMOD_EXPORT void low_cleanup_interpret (struct Pike_interpreter *interpreter)

void really_clean_up_interpret (void)

Variables

PMOD_EXPORT const char Pike_check_stack_errmsg []

PMOD_EXPORT const char Pike_check_mark_stack_errmsg []

PMOD_EXPORT const char Pike_check_c_stack_errmsg []

PMOD_EXPORT const char msg_pop_neg []

PMOD_EXPORT int d_flag

PMOD_EXPORT int Pike_stack_size

PMOD_EXPORT struct callback_list evaluator_callbacks

PMOD_EXPORT struct Pike_interpreter Pike_interpreter

Define Documentation

#define apply_current ( FUN,
ARGS )

Value:
apply_low(Pike_fp->current_object, \ (FUN) + Pike_fp->context.identifier_level, \ (ARGS))

#define apply_low ( O,
FUN,
ARGS ) mega_apply(APPLY_LOW, (ARGS), (void*)(O),(void*)(ptrdiff_t)(FUN))

#define APPLY_MASTER ( FUN,
ARGS )

Value:
do{ \ static int fun_, master_cnt=0; \ struct object *master_ob=master(); \ if(master_cnt != master_ob->prog->id) \ { \ fun_=find_identifier(FUN,master_ob->prog); \ master_cnt = master_ob->prog->id; \ } \ apply_low(master_ob, fun_, ARGS); \ }while(0)

#define check__positive ( X,
Y )

#define check_c_stack ( X )

Value:
do { \ ptrdiff_t x_= ((char *)&x_) + \ STACK_DIRECTION * (Pike_interpreter.c_stack_margin + (X)) - \ Pike_interpreter.stack_top ; \ x_*=STACK_DIRECTION; \ if(x_>0) \ low_error(Pike_check_c_stack_errmsg); \ }while(0)

#define check_mark_stack ( X )

Value:
do { \ if(Pike_mark_sp - Pike_interpreter.mark_stack + (X) >= Pike_stack_size) \ ((void (*)(const char*, ...))Pike_error)(Pike_check_mark_stack_errmsg); \ }while(0)

#define check_stack ( X )

Value:
do { \ if(low_stack_check(X)) \ ((void (*)(const char *, ...))Pike_error)( \ Pike_check_stack_errmsg, \ PTRDIFF_T_TO_LONG(Pike_sp - Pike_interpreter.evaluator_stack), \ PTRDIFF_T_TO_LONG(Pike_stack_size), \ PTRDIFF_T_TO_LONG(X)); \ }while(0)

#define check_threads_etc ( )

Value:
do { \ DO_IF_INTERNAL_PROFILING (evaluator_callback_calls++); \ call_callback(& evaluator_callbacks, NULL); \ }while(0)

#define CURRENT_STORAGE (dmalloc_touch(struct pike_frame *,Pike_fp)->current_storage)

#define debug_check_stack ( )

#define fast_check_threads_etc ( X )

Value:
do { \ static int div_; if(!(div_++& ((1<<(X))-1))) check_threads_etc(); } while(0)

#define fatal_check_c_stack ( X )

Value:
do { \ ptrdiff_t x_= \ ((char *)&x_) + STACK_DIRECTION * (X) - Pike_interpreter.stack_top ; \ x_*=STACK_DIRECTION; \ if(x_>0) { \ ((void (*)(const char*, ...))Pike_fatal)(Pike_check_c_stack_errmsg); \ } \ }while(0)

#define free_pike_frame ( F ) do{ struct pike_frame *f_=(F); if(!sub_ref(f_)) really_free_pike_frame(f_); }while(0)

#define free_pike_scope ( F ) do{ struct pike_frame *f_=(F); if(!sub_ref(f_)) really_free_pike_scope(f_); }while(0)

#define low_stack_check ( X )

Value:
(Pike_sp - Pike_interpreter.evaluator_stack + \ Pike_interpreter.svalue_stack_margin + (X) >= Pike_stack_size)

#define MAYBE_CAST_TO_LONG ( X ) ((long)(X))

#define Pike_fp Pike_interpreter.frame_pointer

#define PIKE_FRAME_MALLOCED_LOCALS 0x8000

#define PIKE_FRAME_RETURN_INTERNAL 1

#define PIKE_FRAME_RETURN_POP 2

#define Pike_mark_sp Pike_interpreter.mark_stack_pointer

#define Pike_sp Pike_interpreter.stack_pointer

#define PIKE_STACK_MMAPPED

#define PIKE_STACK_REQUIRE_BEGIN ( num,
base )

Value:
do { \ struct Pike_stack *old_stack_; \ if(Pike_interpreter.current_stack->top - Pike_sp < num) \ { \ old_stack_=Pike_interpreter.current_stack; \ old_stack_->save_ptr=Pike_sp; \ Pike_interpreter.current_stack=allocate_array(MAXIMUM(num, 8192)); \ while(old_sp > base) *(Pike_sp++) = *--old_stack_->save_ptr; \ }

#define PIKE_STACK_REQUIRE_END ( )

Value:
while(Pike_sp > Pike_interpreter.current_stack->stack) \ *(old_stack_->save_ptr++) = *--Pike_sp; \ Pike_interpreter.current_stack=Pike_interpreter.current_stack->previous; \ }while(0)

#define pop_2_elems ( ) do { pop_stack(); pop_stack(); }while(0)

#define pop_n_elems ( X )

Value:
do { \ ptrdiff_t x_=(X); \ if(x_) { \ struct svalue *_sp_; \ check__positive(x_, (msg_pop_neg, x_)); \ _sp_ = Pike_sp = Pike_sp - x_; \ debug_check_stack(); \ free_mixed_svalues(_sp_, x_); \ } \ } while (0)

#define POP_PIKE_FRAME ( )

#define pop_stack ( ) do{ free_svalue(--Pike_sp); debug_check_stack(); }while(0)

#define push_array ( A )

Value:
do{ \ struct array *_=(A); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.array=_ ; \ _sp_->type=PIKE_T_ARRAY; \ }while(0)

#define push_constant_string_code ( STR,
CODE )

Value:
do{ \ struct pike_string *STR; \ REF_MAKE_CONST_STRING_CODE (STR, CODE); \ push_string (STR); \ }while(0)

#define push_constant_text ( T )

Value:
do{ \ struct svalue *_sp_ = Pike_sp++; \ _sp_->subtype=0; \ REF_MAKE_CONST_STRING(_sp_->u.string,T); \ _sp_->type=PIKE_T_STRING; \ }while(0)

#define push_empty_array ( ) ref_push_array(&empty_array)

#define push_empty_string ( ) ref_push_string(empty_pike_string)

#define push_float ( F )

Value:
do{ \ FLOAT_TYPE _=(F); \ struct svalue *_sp_ = Pike_sp++; \ _sp_->u.float_number=_; \ _sp_->type=PIKE_T_FLOAT; \ }while(0)

#define push_function ( OBJ,
FUN )

Value:
do { \ struct object *_=(OBJ); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.object=_; \ _sp_->subtype=(FUN); \ _sp_->type=PIKE_T_FUNCTION; \ } while (0)

#define push_int ( I )

Value:
do{ \ INT_TYPE _=(I); \ struct svalue *_sp_ = Pike_sp++; \ _sp_->u.integer=_; \ _sp_->type=PIKE_T_INT; \ _sp_->subtype=NUMBER_NUMBER; \ }while(0)

#define push_mapping ( M )

Value:
do{ \ struct mapping *_=(M); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.mapping=_; \ _sp_->type=PIKE_T_MAPPING; \ }while(0)

#define push_multiset ( L )

Value:
do{ \ struct multiset *_=(L); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.multiset=_; \ _sp_->type=PIKE_T_MULTISET; \ }while(0)

#define push_obj_index ( I )

Value:
do{ \ int _=(I); \ struct svalue *_sp_ = Pike_sp++; \ _sp_->u.identifier=_; \ _sp_->type=T_OBJ_INDEX; \ }while(0)

#define push_object ( O )

Value:
do { \ struct object *_=(O); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.object=_; \ _sp_->type=PIKE_T_OBJECT; \ _sp_->subtype = 0; \ }while(0)

#define push_object_inherit ( O,
INH_NUM )

Value:
do { \ struct object *_ = (O); \ struct svalue *_sp_ = Pike_sp++; \ int _inh_ = (INH_NUM); \ debug_malloc_touch(_); \ _sp_->u.object = _; \ _sp_->type = PIKE_T_OBJECT; \ _sp_->subtype = _inh_; \ }while(0)

#define push_program ( P )

Value:
do{ \ struct program *_=(P); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.program=_; \ _sp_++->type=PIKE_T_PROGRAM; \ }while(0)

#define push_string ( S )

Value:
do { \ struct pike_string *_=(S); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ DO_IF_DEBUG(if(_->size_shift & ~3) { \ Pike_fatal("Pushing string with bad shift: %d\n", \ _->size_shift); \ }); \ _sp_->subtype=0; \ _sp_->u.string=_; \ _sp_->type=PIKE_T_STRING; \ }while(0)

#define push_svalue ( S )

Value:
do { \ const struct svalue *_=(S); \ struct svalue *_sp_ = Pike_sp++; \ assign_svalue_no_free(_sp_,_); \ }while(0)

#define push_text ( T )

Value:
do { \ const char *_ = (T); \ struct svalue *_sp_ = Pike_sp++; \ _sp_->subtype=0; \ _sp_->u.string=make_shared_binary_string(_,strlen(_)); \ debug_malloc_touch(_sp_->u.string); \ _sp_->type=PIKE_T_STRING; \ }while(0)

#define push_type_value ( S )

Value:
do{ \ struct pike_type *_=(S); \ struct svalue *_sp_ = Pike_sp++; \ debug_malloc_touch(_); \ _sp_->u.type=_; \ _sp_->type=PIKE_T_TYPE; \ }while(0)

#define push_undefined ( )

Value:
do{ \ struct svalue *_sp_ = Pike_sp++; \ _sp_->u.integer=0; \ _sp_->type=PIKE_T_INT; \ _sp_->subtype=NUMBER_UNDEFINED; \ }while(0)

#define push_undefines ( N )

Value:
do{ \ struct svalue *s_=Pike_sp; \ ptrdiff_t num_= (N); \ for(;num_-- > 0;s_++) \ { \ s_->type=PIKE_T_INT; \ s_->subtype=NUMBER_UNDEFINED; \ s_->u.integer=0; \ } \ Pike_sp=s_; \ }while(0)

#define push_zeroes ( N )

Value:
do{ \ struct svalue *s_=Pike_sp; \ ptrdiff_t num_= (N); \ for(;num_-- > 0;s_++) \ { \ s_->type=PIKE_T_INT; \ s_->subtype=NUMBER_NUMBER; \ s_->u.integer=0; \ } \ Pike_sp=s_; \ }while(0)

#define ref_push_array ( A )

Value:
do{ \ struct array *_=(A); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.array=_ ; \ _sp_->type=PIKE_T_ARRAY; \ }while(0)

#define ref_push_function ( OBJ,
FUN )

Value:
do { \ struct object *_=(OBJ); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.object=_; \ _sp_->subtype=(FUN); \ _sp_->type=PIKE_T_FUNCTION; \ } while (0)

#define ref_push_mapping ( M )

Value:
do{ \ struct mapping *_=(M); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.mapping=_; \ _sp_->type=PIKE_T_MAPPING; \ }while(0)

#define ref_push_multiset ( L )

Value:
do{ \ struct multiset *_=(L); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.multiset=_; \ _sp_->type=PIKE_T_MULTISET; \ }while(0)

#define ref_push_object ( O )

Value:
do{ \ struct object *_=(O); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.object=_; \ _sp_->type=PIKE_T_OBJECT; \ _sp_->subtype = 0; \ }while(0)

#define ref_push_object_inherit ( O,
INH_NUM )

Value:
do{ \ struct object *_ = (O); \ struct svalue *_sp_ = Pike_sp++; \ int _inh_ = (INH_NUM); \ add_ref(_); \ _sp_->u.object = _; \ _sp_->type = PIKE_T_OBJECT; \ _sp_->subtype = _inh_; \ }while(0)

#define ref_push_program ( P )

Value:
do{ \ struct program *_=(P); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.program=_; \ _sp_->type=PIKE_T_PROGRAM; \ }while(0)

#define ref_push_string ( S )

Value:
do{ \ struct pike_string *_=(S); \ struct svalue *_sp_ = Pike_sp++; \ DO_IF_DEBUG(if(_->size_shift & ~3) { \ Pike_fatal("Pushing string with bad shift: %d\n", \ _->size_shift); \ }); \ add_ref(_); \ _sp_->subtype=0; \ _sp_->u.string=_; \ _sp_->type=PIKE_T_STRING; \ }while(0)

#define ref_push_type_value ( S )

Value:
do{ \ struct pike_type *_=(S); \ struct svalue *_sp_ = Pike_sp++; \ add_ref(_); \ _sp_->u.type=_; \ _sp_->type=PIKE_T_TYPE; \ }while(0)

#define SAFE_APPLY_HANDLER ( FUN,
HANDLER,
COMPAT,
ARGS )

Value:
do { \ static int h_fun_=-1, h_id_=0; \ static int c_fun_=-1, c_fun_id_=0; \ struct object *h_=(HANDLER), *c_=(COMPAT); \ if (h_ && h_->prog) { \ if (h_->prog->id != h_id_) { \ h_fun_ = find_identifier(fun, h_->prog); \ h_id_ = h_->prog->id; \ } \ if (h_fun_ != -1) { \ safe_apply_low(h_, h_fun_, ARGS); \ break; \ } \ } \ if (c_ && c_->prog) { \ if (c_->prog->id != c_id_) { \ c_fun_ = find_identifier(fun, c_->prog); \ c_id_ = c_->prog->id; \ } \ if (c_fun_ != -1) { \ safe_apply_low(c_, c_fun_, ARGS); \ break; \ } \ } \ SAFE_APPLY_MASTER(FUN, ARGS); \ } while(0)

#define SAFE_APPLY_MASTER ( FUN,
ARGS )

Value:
do{ \ static int fun_, master_cnt=0; \ struct object *master_ob=master(); \ if(master_cnt != master_ob->prog->id) \ { \ fun_=find_identifier(FUN,master_ob->prog); \ master_cnt = master_ob->prog->id; \ } \ safe_apply_low2(master_ob, fun_, ARGS, 1); \ }while(0)

#define stack_dup ( ) push_svalue(Pike_sp-1)

#define STACK_LEVEL_CHECK ( depth )

#define STACK_LEVEL_DONE ( depth ) } while(0)

#define STACK_LEVEL_START ( depth ) do {

#define stack_pop_2_elems_keep_top ( )

Value:
do { \ struct svalue *_sp_ = Pike_sp = Pike_sp - 2; \ free_svalue (_sp_ - 1); \ free_svalue (_sp_); \ move_svalue (_sp_ - 1, _sp_ + 1); \ debug_check_stack(); \ } while (0)

#define stack_pop_keep_top ( )

Value:
do { \ struct svalue *_sp_ = --Pike_sp; \ free_svalue (_sp_ - 1); \ move_svalue (_sp_ - 1, _sp_); \ debug_check_stack(); \ } while (0)

#define stack_pop_n_elems_keep_top ( X ) stack_unlink(X)

#define stack_pop_to ( X )

Value:
do { \ struct svalue *_=(X); \ free_svalue(_); \ stack_pop_to_no_free(_); \ }while(0)

#define stack_pop_to_no_free ( X ) move_svalue(X, --Pike_sp)

#define stack_swap ( )

Value:
do { \ struct svalue *_sp_ = Pike_sp; \ struct svalue _=_sp_[-1]; \ _sp_[-1]=_sp_[-2]; \ _sp_[-2]=_; \ } while(0)

#define stack_unlink ( X )

Value:
do { \ ptrdiff_t x2_ = (X); \ if (x2_) { \ struct svalue *_sp_ = --Pike_sp; \ free_svalue (_sp_ - x2_); \ move_svalue (_sp_ - x2_, _sp_); \ pop_n_elems (x2_ - 1); \ } \ }while(0)

#define strict_apply_svalue ( SVAL,
ARGS ) mega_apply(APPLY_SVALUE, (ARGS), (void*)(SVAL),0)

Enumeration Type Documentation

enum apply_type

Enumeration values:

APPLY_STACK

APPLY_SVALUE

APPLY_SVALUE_STRICT

APPLY_LOW

Function Documentation

PMOD_EXPORT void apply ( struct object * o,

const char * fun,

int args

)

PMOD_EXPORT void apply_external ( int depth,

int fun,

INT32 args

)

PMOD_EXPORT void apply_lfun ( struct object * o,

int fun,

int args

)

PMOD_EXPORT int apply_low_safe_and_stupid ( struct object * o,

INT32 offset

)

PMOD_EXPORT void apply_shared ( struct object * o,

struct pike_string * fun,

int args

)

PMOD_EXPORT void apply_svalue ( struct svalue * s,

INT32 args

)

PMOD_EXPORT void assign_lvalue ( struct svalue * lval,

struct svalue * from

)

BLOCK_ALLOC ( pike_frame ,

128

)

PMOD_EXPORT void call_handle_error ( void )

PMOD_EXPORT void cleanup_interpret ( void )

PMOD_EXPORT void custom_check_stack ( ptrdiff_t amount,

const char * fmt,

...

)

void dump_backlog ( void )

PMOD_EXPORT void f_call_function ( INT32 args )

PMOD_EXPORT void find_external_context ( struct external_variable_context * loc,

int arg2

)

void gc_mark_stack_external ( struct pike_frame * frame,

struct svalue * stack_p,

struct svalue * stack

)

PMOD_EXPORT union anything* get_pointer_if_this_type ( struct svalue * lval,

TYPE_T t

)

PMOD_EXPORT void init_interpreter ( void )

PMOD_EXPORT void low_cleanup_interpret ( struct Pike_interpreter * interpreter )

PMOD_EXPORT int low_init_interpreter ( struct Pike_interpreter * interpreter )

int low_mega_apply ( enum apply_type type,

INT32 args,

void * arg1,

void * arg2

)

void low_return ( void )

void low_return_pop ( void )

PMOD_EXPORT void low_safe_apply_handler ( const char * fun,

struct object * handler,

struct object * compat,

INT32 args

)

PMOD_EXPORT int low_unsafe_apply_handler ( const char * fun,

struct object * handler,

struct object * compat,

INT32 args

)

void lvalue_to_svalue_no_free ( struct svalue * to,

struct svalue * lval

)

void mega_apply ( enum apply_type type,

INT32 args,

void * arg1,

void * arg2

)

ptrdiff_t pop_sp_mark ( void )

void print_return_value ( void )

void push_sp_mark ( void )

void really_clean_up_interpret ( void )

void really_free_pike_scope ( struct pike_frame * scope )

void reset_evaluator ( void )

PMOD_EXPORT void safe_apply ( struct object * o,

const char * fun,

INT32 args

)

PMOD_EXPORT int safe_apply_handler ( const char * fun,

struct object * handler,

struct object * compat,

INT32 args,

TYPE_FIELD rettypes

)

PMOD_EXPORT void safe_apply_low ( struct object * o,

int fun,

int args

)

PMOD_EXPORT void safe_apply_low2 ( struct object * o,

int fun,

int args,

int handle_errors

)

PMOD_EXPORT void safe_apply_low3 ( struct object * o,

int fun,

int args,

char * error

)

PMOD_EXPORT void safe_apply_svalue ( struct svalue * s,

INT32 args,

int handle_errors

)

PMOD_EXPORT void slow_check_stack ( void )

void unlink_previous_frame ( void )

Variable Documentation

PMOD_EXPORT int d_flag

PMOD_EXPORT struct callback_list evaluator_callbacks

PMOD_EXPORT const char msg_pop_neg[]

PMOD_EXPORT const char Pike_check_c_stack_errmsg[]

PMOD_EXPORT const char Pike_check_mark_stack_errmsg[]

PMOD_EXPORT const char Pike_check_stack_errmsg[]

PMOD_EXPORT struct Pike_interpreter Pike_interpreter

PMOD_EXPORT int Pike_stack_size

Generated on Fri Jul 22 23:44:29 2005 for Pike by

1.3.9.1


Classes
struct	Pike_interpreter
struct	pike_frame
struct	external_variable_context
struct	Pike_stack
Defines
#define	PIKE_FRAME_RETURN_INTERNAL 1
#define	PIKE_FRAME_RETURN_POP 2
#define	PIKE_FRAME_MALLOCED_LOCALS 0x8000
#define	check__positive(X, Y)
#define	debug_check_stack()
#define	low_stack_check(X)
#define	check_stack(X)
#define	check_mark_stack(X)
#define	check_c_stack(X)
#define	fatal_check_c_stack(X)
#define	STACK_LEVEL_START(depth) do {
#define	STACK_LEVEL_DONE(depth) } while(0)
#define	STACK_LEVEL_CHECK(depth)
#define	pop_stack() do{ free_svalue(--Pike_sp); debug_check_stack(); }while(0)
#define	pop_2_elems() do { pop_stack(); pop_stack(); }while(0)
#define	MAYBE_CAST_TO_LONG(X) ((long)(X))
#define	pop_n_elems(X)
#define	stack_unlink(X)
#define	stack_pop_n_elems_keep_top(X) stack_unlink(X)
#define	stack_pop_keep_top()
#define	stack_pop_2_elems_keep_top()
#define	stack_pop_to_no_free(X) move_svalue(X, --Pike_sp)
#define	stack_pop_to(X)
#define	push_program(P)
#define	push_int(I)
#define	push_undefined()
#define	push_obj_index(I)
#define	push_mapping(M)
#define	push_array(A)
#define	push_empty_array() ref_push_array(&empty_array)
#define	push_multiset(L)
#define	push_string(S)
#define	push_empty_string() ref_push_string(empty_pike_string)
#define	push_type_value(S)
#define	push_object(O)
#define	push_object_inherit(O, INH_NUM)
#define	push_float(F)
#define	push_text(T)
#define	push_constant_text(T)
#define	push_constant_string_code(STR, CODE)
#define	push_function(OBJ, FUN)
#define	ref_push_program(P)
#define	ref_push_mapping(M)
#define	ref_push_array(A)
#define	ref_push_multiset(L)
#define	ref_push_string(S)
#define	ref_push_type_value(S)
#define	ref_push_object(O)
#define	ref_push_object_inherit(O, INH_NUM)
#define	ref_push_function(OBJ, FUN)
#define	push_svalue(S)
#define	stack_dup() push_svalue(Pike_sp-1)
#define	stack_swap()
#define	push_zeroes(N)
#define	push_undefines(N)
#define	free_pike_frame(F) do{ struct pike_frame *f_=(F); if(!sub_ref(f_)) really_free_pike_frame(f_); }while(0)
#define	free_pike_scope(F) do{ struct pike_frame *f_=(F); if(!sub_ref(f_)) really_free_pike_scope(f_); }while(0)
#define	POP_PIKE_FRAME()
#define	APPLY_MASTER(FUN, ARGS)
#define	SAFE_APPLY_MASTER(FUN, ARGS)
#define	SAFE_APPLY_HANDLER(FUN, HANDLER, COMPAT, ARGS)
#define	check_threads_etc()
#define	fast_check_threads_etc(X)
#define	apply_low(O, FUN, ARGS) mega_apply(APPLY_LOW, (ARGS), (void)(O),(void)(ptrdiff_t)(FUN))
#define	strict_apply_svalue(SVAL, ARGS) mega_apply(APPLY_SVALUE, (ARGS), (void*)(SVAL),0)
#define	apply_current(FUN, ARGS)
#define	Pike_sp Pike_interpreter.stack_pointer
#define	Pike_fp Pike_interpreter.frame_pointer
#define	Pike_mark_sp Pike_interpreter.mark_stack_pointer
#define	CURRENT_STORAGE (dmalloc_touch(struct pike_frame *,Pike_fp)->current_storage)
#define	PIKE_STACK_MMAPPED
#define	PIKE_STACK_REQUIRE_BEGIN(num, base)
#define	PIKE_STACK_REQUIRE_END()
Enumerations
enum	apply_type { APPLY_STACK, APPLY_SVALUE, APPLY_SVALUE_STRICT, APPLY_LOW }
Functions
void	push_sp_mark (void)
ptrdiff_t	pop_sp_mark (void)
void	gc_mark_stack_external (struct pike_frame frame, struct svalue stack_p, struct svalue *stack)
PMOD_EXPORT int	low_init_interpreter (struct Pike_interpreter *interpreter)
PMOD_EXPORT void	init_interpreter (void)
void	lvalue_to_svalue_no_free (struct svalue to, struct svalue lval)
PMOD_EXPORT void	assign_lvalue (struct svalue lval, struct svalue from)
PMOD_EXPORT union anything *	get_pointer_if_this_type (struct svalue *lval, TYPE_T t)
void	print_return_value (void)
void	reset_evaluator (void)
void	dump_backlog (void)
	BLOCK_ALLOC (pike_frame, 128)
PMOD_EXPORT void	find_external_context (struct external_variable_context *loc, int arg2)
void	really_free_pike_scope (struct pike_frame *scope)
int	low_mega_apply (enum apply_type type, INT32 args, void arg1, void arg2)
void	low_return (void)
void	low_return_pop (void)
void	unlink_previous_frame (void)
void	mega_apply (enum apply_type type, INT32 args, void arg1, void arg2)
PMOD_EXPORT void	f_call_function (INT32 args)
PMOD_EXPORT void	call_handle_error (void)
PMOD_EXPORT int	apply_low_safe_and_stupid (struct object *o, INT32 offset)
PMOD_EXPORT void	safe_apply_low (struct object *o, int fun, int args)
PMOD_EXPORT void	safe_apply_low2 (struct object *o, int fun, int args, int handle_errors)
PMOD_EXPORT void	safe_apply_low3 (struct object o, int fun, int args, char error)
PMOD_EXPORT void	safe_apply (struct object o, const char fun, INT32 args)
PMOD_EXPORT int	low_unsafe_apply_handler (const char fun, struct object handler, struct object *compat, INT32 args)
PMOD_EXPORT void	low_safe_apply_handler (const char fun, struct object handler, struct object *compat, INT32 args)
PMOD_EXPORT int	safe_apply_handler (const char fun, struct object handler, struct object *compat, INT32 args, TYPE_FIELD rettypes)
PMOD_EXPORT void	apply_lfun (struct object *o, int fun, int args)
PMOD_EXPORT void	apply_shared (struct object o, struct pike_string fun, int args)
PMOD_EXPORT void	apply (struct object o, const char fun, int args)
PMOD_EXPORT void	apply_svalue (struct svalue *s, INT32 args)
PMOD_EXPORT void	safe_apply_svalue (struct svalue *s, INT32 args, int handle_errors)
PMOD_EXPORT void	apply_external (int depth, int fun, INT32 args)
PMOD_EXPORT void	slow_check_stack (void)
PMOD_EXPORT void	custom_check_stack (ptrdiff_t amount, const char *fmt,...) ATTRIBUTE((format(printf
PMOD_EXPORT void	cleanup_interpret (void)
PMOD_EXPORT void	low_cleanup_interpret (struct Pike_interpreter *interpreter)
void	really_clean_up_interpret (void)
Variables
PMOD_EXPORT const char	Pike_check_stack_errmsg []
PMOD_EXPORT const char	Pike_check_mark_stack_errmsg []
PMOD_EXPORT const char	Pike_check_c_stack_errmsg []
PMOD_EXPORT const char	msg_pop_neg []
PMOD_EXPORT int	d_flag
PMOD_EXPORT int	Pike_stack_size
PMOD_EXPORT struct callback_list	evaluator_callbacks
PMOD_EXPORT struct Pike_interpreter	Pike_interpreter