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

las.h

Go to the documentation of this file.
00001 /*
00002 || This file is part of Pike. For copyright information see COPYRIGHT.
00003 || Pike is distributed under GPL, LGPL and MPL. See the file COPYING
00004 || for more information.
00005 || $Id: las.h,v 1.71 2005/02/18 13:50:12 grubba Exp $
00006 */
00007 
00008 #ifndef LAS_H
00009 #define LAS_H
00010 
00011 #include "global.h"
00012 #include "svalue.h"
00013 #include "dynamic_buffer.h"
00014 #include "block_alloc_h.h"
00015 
00016 #define MAX_GLOBAL_VARIABLES 1000
00017 typedef void (*c_fun)(INT32);
00018 
00019 
00020 /* Flags used by yytype_error() */
00021 #define YYTE_IS_WARNING 1
00022 
00023 void yytype_error(char *msg, struct pike_type *expected_t,
00024                   struct pike_type *got_t, unsigned int flags);
00025 void low_yyerror(struct pike_string *str);
00026 void yyerror(char *s);
00027 static void yyerror_reserved(char *keyword);
00028 int islocal(struct pike_string *str);
00029 int verify_declared(struct pike_string *str);
00030 void cleanup_compiler(void);
00031 
00032 
00033 extern int cumulative_parse_error;
00034 
00035 
00036 #ifndef STRUCT_NODE_S_DECLARED
00037 #define STRUCT_NODE_S_DECLARED
00038 struct node_s;
00039 typedef struct node_s node;
00040 #endif
00041 
00042 struct local_variable
00043 {
00044   struct pike_string *name;
00045   struct pike_type *type;
00046   node *def;
00047   struct pike_string *file;
00048   int line;
00049 };
00050 
00051 struct compiler_frame
00052 {
00053   struct compiler_frame *previous;
00054 
00055   struct pike_type *current_type;
00056   struct pike_type *current_return_type;
00057   int current_number_of_locals;
00058   int max_number_of_locals;
00059   int min_number_of_locals;
00060   int last_block_level; /* used to detect variables declared in same block */
00061   int num_args;
00062   int lexical_scope;
00063   int current_function_number;
00064   int recur_label;
00065   int is_inline;
00066   unsigned int opt_flags;
00067   struct local_variable variable[MAX_LOCAL];
00068 };
00069 
00070 /* Also used in struct node_identifier */
00071 union node_data
00072 {
00073   struct
00074   {
00075     int number;
00076     struct program *prog;
00077   } id;
00078   struct
00079   {
00080     int ident;
00081     struct compiler_frame *frame;
00082 #ifdef SHARED_NODES
00083     struct program *prog;
00084 #endif
00085   } trampoline;
00086   struct svalue sval;
00087   struct
00088   {
00089     struct node_s *a, *b;
00090   } node;
00091   struct
00092   {
00093     struct node_identifier *a, *b;
00094   } node_id;
00095   struct
00096   {
00097     int a, b;
00098   } integer;
00099 };
00100 
00101 struct node_s
00102 {
00103 #if defined(SHARED_NODES)
00104   unsigned INT32 refs;
00105   size_t hash;
00106   struct node_s *next;
00107 #endif /* SHARED_NODES */
00108   struct pike_string *current_file;
00109   struct pike_type *type;
00110   struct pike_string *name;
00111   struct node_s *parent;
00112   unsigned INT16 line_number;
00113   unsigned INT16 node_info;
00114   unsigned INT16 tree_info;
00115   /* The stuff from this point on is hashed. */
00116   unsigned INT16 token;
00117   union node_data u;
00118 };
00119 
00120 #ifdef SHARED_NODES_MK2
00121 
00122 struct node_identifier
00123 {
00124   ptrdiff_t refs;
00125   struct node_identifier *next;
00126   size_t hash;
00127   INT16 token;
00128   union node_data u;
00129 };
00130 
00131 struct node_hash_table
00132 {
00133   struct node_identifier **table;
00134   INT32 size;
00135 };
00136 
00137 extern struct node_hash_table node_hash;
00138 
00139 #endif /* SHARED_NODES_MK2 */
00140 
00141 #ifdef SHARED_NODES
00142 
00143 struct node_hash_table
00144 {
00145   node **table;
00146   INT32 size;
00147 };
00148 
00149 extern struct node_hash_table node_hash;
00150 
00151 #endif /* SHARED_NODES */
00152 
00153 #define OPT_OPTIMIZED       0x1    /* has been processed by optimize(),
00154                                     * only used in node_info
00155                                     */
00156 #define OPT_NOT_CONST       0x2    /* isn't constant */
00157 #define OPT_SIDE_EFFECT     0x4    /* has side effects */
00158 #define OPT_ASSIGNMENT      0x8    /* does assignments */
00159 #define OPT_TRY_OPTIMIZE    0x10   /* might be worth optimizing */
00160 #define OPT_EXTERNAL_DEPEND 0x20   /* the value depends on external
00161                                     * influences (such as read_file or so)
00162                                     */
00163 #define OPT_CASE            0x40   /* contains case(s) */
00164 #define OPT_CONTINUE        0x80   /* contains continue(s) */
00165 #define OPT_BREAK           0x100  /* contains break(s) */
00166 #define OPT_RETURN          0x200  /* contains return(s) */
00167 #define OPT_TYPE_NOT_FIXED  0x400  /* type-field might be wrong */
00168 #define OPT_WEAK_TYPE       0x800  /* don't warn even if strict types */
00169 #define OPT_APPLY           0x1000 /* contains apply */
00170 #define OPT_FLAG_NODE       0x2000 /* don't optimize away unless the
00171                                     * parent also is optimized away */
00172 #define OPT_DEFROSTED       0x4000 /* Node may be a duplicate */
00173 #define OPT_NOT_SHARED      0x8000 /* Node is not to be shared */
00174 
00175 
00176 /* This is a statement which got custom break/continue label handling.
00177  * Set in compiler_frame. Beware: This is not a node flag! -Hubbe */
00178 #define OPT_CUSTOM_LABELS   0x10000
00179 
00180 #define SCOPE_LOCAL 1
00181 #define SCOPE_SCOPED 2
00182 #define SCOPE_SCOPE_USED 4
00183 
00184 BLOCK_ALLOC_FILL_PAGES(node_s, 2);
00185 
00186 /* Prototypes begin here */
00187 int car_is_node(node *n);
00188 int cdr_is_node(node *n);
00189 void check_tree(node *n, int depth);
00190 INT32 count_args(node *n);
00191 struct pike_type *find_return_type(node *n);
00192 int check_tailrecursion(void);
00193 struct node_chunk;
00194 void free_all_nodes(void);
00195 void debug_free_node(node *n);
00196 node *debug_check_node_hash(node *n);
00197 node *debug_mknode(int token,node *a,node *b);
00198 node *debug_mkstrnode(struct pike_string *str);
00199 node *debug_mkintnode(INT_TYPE nr);
00200 node *debug_mknewintnode(INT_TYPE nr);
00201 node *debug_mkfloatnode(FLOAT_TYPE foo);
00202 node *debug_mkprgnode(struct program *p);
00203 node *debug_mkapplynode(node *func,node *args);
00204 node *debug_mkefuncallnode(char *function, node *args);
00205 node *debug_mkopernode(char *oper_id, node *arg1, node *arg2);
00206 node *debug_mklocalnode(int var, int depth);
00207 node *debug_mkidentifiernode(int i);
00208 node *debug_mktrampolinenode(int i, struct compiler_frame *depth);
00209 node *debug_mkexternalnode(struct program *prog, int i);
00210 node *debug_mkthisnode(struct program *parent_prog, int inherit_num);
00211 node *debug_mkcastnode(struct pike_type *type, node *n);
00212 node *debug_mksoftcastnode(struct pike_type *type, node *n);
00213 void resolv_constant(node *n);
00214 void resolv_class(node *n);
00215 void resolv_class(node *n);
00216 node *index_node(node *n, char *node_name, struct pike_string *id);
00217 int node_is_eq(node *a,node *b);
00218 node *debug_mktypenode(struct pike_type *t);
00219 node *debug_mkconstantsvaluenode(struct svalue *s);
00220 node *debug_mkliteralsvaluenode(struct svalue *s);
00221 node *debug_mksvaluenode(struct svalue *s);
00222 node *copy_node(node *n);
00223 node *defrost_node(node *n);
00224 void optimize_node(node *);
00225 int is_const(node *n);
00226 int node_is_tossable(node *n);
00227 int node_is_true(node *n);
00228 int node_is_false(node *n);
00229 int node_may_overload(node *n, int lfun);
00230 node **last_cmd(node **a);
00231 node **my_get_arg(node **a,int n);
00232 node **is_call_to(node *n, c_fun f);
00233 void print_tree(node *n);
00234 struct used_vars;
00235 void fix_type_field(node *n);
00236 struct timer_oflo;
00237 ptrdiff_t eval_low(node *n,int print_error);
00238 int dooptcode(struct pike_string *name,
00239               node *n,
00240               struct pike_type *type,
00241               int modifiers);
00242 void resolv_program(node *n);
00243 /* Prototypes end here */
00244 
00245 /* Handling of nodes */
00246 #define free_node(n)        debug_free_node(dmalloc_touch(node *,n))
00247 
00248 #define mknode(token, a, b) dmalloc_touch(node *, debug_mknode(token, dmalloc_touch(node *, a), dmalloc_touch(node *, b)))
00249 #define mkstrnode(str)      dmalloc_touch(node *, debug_mkstrnode(str))
00250 #define mkintnode(nr)       dmalloc_touch(node *, debug_mkintnode(nr))
00251 #define mknewintnode(nr)    dmalloc_touch(node *, debug_mknewintnode(nr))
00252 #define mkfloatnode(foo)    dmalloc_touch(node *, debug_mkfloatnode(foo))
00253 #define mkprgnode(p)        dmalloc_touch(node *, debug_mkprgnode(p))
00254 #define mkapplynode(func, args) dmalloc_touch(node *, debug_mkapplynode(dmalloc_touch(node *, func),dmalloc_touch(node *, args)))
00255 #define mkefuncallnode(function, args) dmalloc_touch(node *, debug_mkefuncallnode(function, dmalloc_touch(node *, args)))
00256 #define mkopernode(oper_id, arg1, arg2) dmalloc_touch(node *, debug_mkopernode(oper_id, dmalloc_touch(node *, arg1), dmalloc_touch(node *, arg2)))
00257 #define mklocalnode(var, depth) dmalloc_touch(node *, debug_mklocalnode(var, depth))
00258 #define mkidentifiernode(i) dmalloc_touch(node *, debug_mkidentifiernode(i))
00259 #define mktrampolinenode(i,f) dmalloc_touch(node *, debug_mktrampolinenode(i, f))
00260 #define mkexternalnode(parent_prog, i) dmalloc_touch(node *, debug_mkexternalnode(parent_prog, i))
00261 #define mkthisnode(parent_prog, i) dmalloc_touch(node *, debug_mkthisnode(parent_prog, i))
00262 #define mkcastnode(type, n) dmalloc_touch(node *, debug_mkcastnode(type, dmalloc_touch(node *, n)))
00263 #define mksoftcastnode(type, n) dmalloc_touch(node *, debug_mksoftcastnode(type, dmalloc_touch(node *, n)))
00264 #define mktypenode(t)       dmalloc_touch(node *, debug_mktypenode(t))
00265 #define mkconstantsvaluenode(s) dmalloc_touch(node *, debug_mkconstantsvaluenode(dmalloc_touch(struct svalue *, s)))
00266 #define mkliteralsvaluenode(s) dmalloc_touch(node *, debug_mkliteralsvaluenode(dmalloc_touch(struct svalue *, s)))
00267 #define mksvaluenode(s)     dmalloc_touch(node *, debug_mksvaluenode(dmalloc_touch(struct svalue *, s)))
00268 
00269 #define COPY_LINE_NUMBER_INFO(TO, FROM) do {                            \
00270     node *to_ = (TO), *from_ = (FROM);                                  \
00271     if (from_) {                                                        \
00272       to_->line_number = from_->line_number;                            \
00273       free_string (to_->current_file);                                  \
00274       copy_shared_string (to_->current_file, from_->current_file);      \
00275     }                                                                   \
00276   } while (0)
00277 
00278 
00279 #if defined(PIKE_DEBUG) && (defined(SHARED_NODES) || defined(SHARED_NODES_MK2))
00280 #define check_node_hash(X)      debug_check_node_hash(X)
00281 #else /* !PIKE_DEBUG || (!SHARED_NODES && !SHARED_NODES_MK2) */
00282 #define check_node_hash(X)      (X)
00283 #endif /* PIKE_DEBUG && (SHARED_NODES || SHARED_NODES_MK2) */
00284 
00285 /* lvalue variants of CAR(n) & CDR(n) */
00286 #define _CAR(n) (dmalloc_touch(node *,(n))->u.node.a)
00287 #define _CDR(n) (dmalloc_touch(node *,(n))->u.node.b)
00288 #define _CAAR(n) _CAR(_CAR(n))
00289 #define _CADR(n) _CAR(_CDR(n))
00290 #define _CDAR(n) _CDR(_CAR(n))
00291 #define _CDDR(n) _CDR(_CDR(n))
00292 
00293 #ifdef SHARED_NODES
00294 #define ADD_NODE_REF(n) do { if (n) add_ref(n); } while(0)
00295 #define ADD_NODE_REF2(n, code)  do { ADD_NODE_REF(n); code; } while(0)
00296 #else /* !SHARED_NODES */
00297 #define defrost_node(n) (n)
00298 #define ADD_NODE_REF(n) (n = 0)
00299 #define ADD_NODE_REF2(n, code)  do { code; n = 0;} while(0)
00300 #endif /* SHARED_NODES */
00301 
00302 #ifdef SHARED_NODES
00303 #define CAR(n)  (check_node_hash(dmalloc_touch(node *, (n)->u.node.a)))
00304 #define CDR(n)  (check_node_hash(dmalloc_touch(node *, (n)->u.node.b)))
00305 #else /* !SHARED_NODES */
00306 #define CAR(n) _CAR(n)
00307 #define CDR(n) _CDR(n)
00308 #endif /* SHARED_NODES */ 
00309 #define CAAR(n) CAR(CAR(n))
00310 #define CADR(n) CAR(CDR(n))
00311 #define CDAR(n) CDR(CAR(n))
00312 #define CDDR(n) CDR(CDR(n))
00313 #define CAAAR(n) CAR(CAR(CAR(n)))
00314 #define CAADR(n) CAR(CAR(CDR(n)))
00315 #define CADAR(n) CAR(CDR(CAR(n)))
00316 #define CADDR(n) CAR(CDR(CDR(n)))
00317 #define CDAAR(n) CDR(CAR(CAR(n)))
00318 #define CDADR(n) CDR(CAR(CDR(n)))
00319 #define CDDAR(n) CDR(CDR(CAR(n)))
00320 #define CDDDR(n) CDR(CDR(CDR(n)))
00321 #define CAAAAR(n) CAR(CAR(CAR(CAR(n))))
00322 #define CAAADR(n) CAR(CAR(CAR(CDR(n))))
00323 #define CAADAR(n) CAR(CAR(CDR(CAR(n))))
00324 #define CAADDR(n) CAR(CAR(CDR(CDR(n))))
00325 #define CADAAR(n) CAR(CDR(CAR(CAR(n))))
00326 #define CADADR(n) CAR(CDR(CAR(CDR(n))))
00327 #define CADDAR(n) CAR(CDR(CDR(CAR(n))))
00328 #define CADDDR(n) CAR(CDR(CDR(CDR(n))))
00329 #define CDAAAR(n) CDR(CAR(CAR(CAR(n))))
00330 #define CDAADR(n) CDR(CAR(CAR(CDR(n))))
00331 #define CDADAR(n) CDR(CAR(CDR(CAR(n))))
00332 #define CDADDR(n) CDR(CAR(CDR(CDR(n))))
00333 #define CDDAAR(n) CDR(CDR(CAR(CAR(n))))
00334 #define CDDADR(n) CDR(CDR(CAR(CDR(n))))
00335 #define CDDDAR(n) CDR(CDR(CDR(CAR(n))))
00336 #define CDDDDR(n) CDR(CDR(CDR(CDR(n))))
00337 #define CAAAAAR(n) CAR(CAR(CAR(CAR(CAR(n)))))
00338 #define CAAAADR(n) CAR(CAR(CAR(CAR(CDR(n)))))
00339 #define CAAADAR(n) CAR(CAR(CAR(CDR(CAR(n)))))
00340 #define CAAADDR(n) CAR(CAR(CAR(CDR(CDR(n)))))
00341 #define CAADAAR(n) CAR(CAR(CDR(CAR(CAR(n)))))
00342 #define CAADADR(n) CAR(CAR(CDR(CAR(CDR(n)))))
00343 #define CAADDAR(n) CAR(CAR(CDR(CDR(CAR(n)))))
00344 #define CAADDDR(n) CAR(CAR(CDR(CDR(CDR(n)))))
00345 #define CADAAAR(n) CAR(CDR(CAR(CAR(CAR(n)))))
00346 #define CADAADR(n) CAR(CDR(CAR(CAR(CDR(n)))))
00347 #define CADADAR(n) CAR(CDR(CAR(CDR(CAR(n)))))
00348 #define CADADDR(n) CAR(CDR(CAR(CDR(CDR(n)))))
00349 #define CADDAAR(n) CAR(CDR(CDR(CAR(CAR(n)))))
00350 #define CADDADR(n) CAR(CDR(CDR(CAR(CDR(n)))))
00351 #define CADDDAR(n) CAR(CDR(CDR(CDR(CAR(n)))))
00352 #define CADDDDR(n) CAR(CDR(CDR(CDR(CDR(n)))))
00353 #define CDAAAAR(n) CDR(CAR(CAR(CAR(CAR(n)))))
00354 #define CDAAADR(n) CDR(CAR(CAR(CAR(CDR(n)))))
00355 #define CDAADAR(n) CDR(CAR(CAR(CDR(CAR(n)))))
00356 #define CDAADDR(n) CDR(CAR(CAR(CDR(CDR(n)))))
00357 #define CDADAAR(n) CDR(CAR(CDR(CAR(CAR(n)))))
00358 #define CDADADR(n) CDR(CAR(CDR(CAR(CDR(n)))))
00359 #define CDADDAR(n) CDR(CAR(CDR(CDR(CAR(n)))))
00360 #define CDADDDR(n) CDR(CAR(CDR(CDR(CDR(n)))))
00361 #define CDDAAAR(n) CDR(CDR(CAR(CAR(CAR(n)))))
00362 #define CDDAADR(n) CDR(CDR(CAR(CAR(CDR(n)))))
00363 #define CDDADAR(n) CDR(CDR(CAR(CDR(CAR(n)))))
00364 #define CDDADDR(n) CDR(CDR(CAR(CDR(CDR(n)))))
00365 #define CDDDAAR(n) CDR(CDR(CDR(CAR(CAR(n)))))
00366 #define CDDDADR(n) CDR(CDR(CDR(CAR(CDR(n)))))
00367 #define CDDDDAR(n) CDR(CDR(CDR(CDR(CAR(n)))))
00368 #define CDDDDDR(n) CDR(CDR(CDR(CDR(CDR(n)))))
00369 #define CAAAAAAR(n) CAR(CAR(CAR(CAR(CAR(CAR(n))))))
00370 #define CAAAAADR(n) CAR(CAR(CAR(CAR(CAR(CDR(n))))))
00371 #define CAAAADAR(n) CAR(CAR(CAR(CAR(CDR(CAR(n))))))
00372 #define CAAAADDR(n) CAR(CAR(CAR(CAR(CDR(CDR(n))))))
00373 #define CAAADAAR(n) CAR(CAR(CAR(CDR(CAR(CAR(n))))))
00374 #define CAAADADR(n) CAR(CAR(CAR(CDR(CAR(CDR(n))))))
00375 #define CAAADDAR(n) CAR(CAR(CAR(CDR(CDR(CAR(n))))))
00376 #define CAAADDDR(n) CAR(CAR(CAR(CDR(CDR(CDR(n))))))
00377 #define CAADAAAR(n) CAR(CAR(CDR(CAR(CAR(CAR(n))))))
00378 #define CAADAADR(n) CAR(CAR(CDR(CAR(CAR(CDR(n))))))
00379 #define CAADADAR(n) CAR(CAR(CDR(CAR(CDR(CAR(n))))))
00380 #define CAADADDR(n) CAR(CAR(CDR(CAR(CDR(CDR(n))))))
00381 #define CAADDAAR(n) CAR(CAR(CDR(CDR(CAR(CAR(n))))))
00382 #define CAADDADR(n) CAR(CAR(CDR(CDR(CAR(CDR(n))))))
00383 #define CAADDDAR(n) CAR(CAR(CDR(CDR(CDR(CAR(n))))))
00384 #define CAADDDDR(n) CAR(CAR(CDR(CDR(CDR(CDR(n))))))
00385 #define CADAAAAR(n) CAR(CDR(CAR(CAR(CAR(CAR(n))))))
00386 #define CADAAADR(n) CAR(CDR(CAR(CAR(CAR(CDR(n))))))
00387 #define CADAADAR(n) CAR(CDR(CAR(CAR(CDR(CAR(n))))))
00388 #define CADAADDR(n) CAR(CDR(CAR(CAR(CDR(CDR(n))))))
00389 #define CADADAAR(n) CAR(CDR(CAR(CDR(CAR(CAR(n))))))
00390 #define CADADADR(n) CAR(CDR(CAR(CDR(CAR(CDR(n))))))
00391 #define CADADDAR(n) CAR(CDR(CAR(CDR(CDR(CAR(n))))))
00392 #define CADADDDR(n) CAR(CDR(CAR(CDR(CDR(CDR(n))))))
00393 #define CADDAAAR(n) CAR(CDR(CDR(CAR(CAR(CAR(n))))))
00394 #define CADDAADR(n) CAR(CDR(CDR(CAR(CAR(CDR(n))))))
00395 #define CADDADAR(n) CAR(CDR(CDR(CAR(CDR(CAR(n))))))
00396 #define CADDADDR(n) CAR(CDR(CDR(CAR(CDR(CDR(n))))))
00397 #define CADDDAAR(n) CAR(CDR(CDR(CDR(CAR(CAR(n))))))
00398 #define CADDDADR(n) CAR(CDR(CDR(CDR(CAR(CDR(n))))))
00399 #define CADDDDAR(n) CAR(CDR(CDR(CDR(CDR(CAR(n))))))
00400 #define CADDDDDR(n) CAR(CDR(CDR(CDR(CDR(CDR(n))))))
00401 #define CDAAAAAR(n) CDR(CAR(CAR(CAR(CAR(CAR(n))))))
00402 #define CDAAAADR(n) CDR(CAR(CAR(CAR(CAR(CDR(n))))))
00403 #define CDAAADAR(n) CDR(CAR(CAR(CAR(CDR(CAR(n))))))
00404 #define CDAAADDR(n) CDR(CAR(CAR(CAR(CDR(CDR(n))))))
00405 #define CDAADAAR(n) CDR(CAR(CAR(CDR(CAR(CAR(n))))))
00406 #define CDAADADR(n) CDR(CAR(CAR(CDR(CAR(CDR(n))))))
00407 #define CDAADDAR(n) CDR(CAR(CAR(CDR(CDR(CAR(n))))))
00408 #define CDAADDDR(n) CDR(CAR(CAR(CDR(CDR(CDR(n))))))
00409 #define CDADAAAR(n) CDR(CAR(CDR(CAR(CAR(CAR(n))))))
00410 #define CDADAADR(n) CDR(CAR(CDR(CAR(CAR(CDR(n))))))
00411 #define CDADADAR(n) CDR(CAR(CDR(CAR(CDR(CAR(n))))))
00412 #define CDADADDR(n) CDR(CAR(CDR(CAR(CDR(CDR(n))))))
00413 #define CDADDAAR(n) CDR(CAR(CDR(CDR(CAR(CAR(n))))))
00414 #define CDADDADR(n) CDR(CAR(CDR(CDR(CAR(CDR(n))))))
00415 #define CDADDDAR(n) CDR(CAR(CDR(CDR(CDR(CAR(n))))))
00416 #define CDADDDDR(n) CDR(CAR(CDR(CDR(CDR(CDR(n))))))
00417 #define CDDAAAAR(n) CDR(CDR(CAR(CAR(CAR(CAR(n))))))
00418 #define CDDAAADR(n) CDR(CDR(CAR(CAR(CAR(CDR(n))))))
00419 #define CDDAADAR(n) CDR(CDR(CAR(CAR(CDR(CAR(n))))))
00420 #define CDDAADDR(n) CDR(CDR(CAR(CAR(CDR(CDR(n))))))
00421 #define CDDADAAR(n) CDR(CDR(CAR(CDR(CAR(CAR(n))))))
00422 #define CDDADADR(n) CDR(CDR(CAR(CDR(CAR(CDR(n))))))
00423 #define CDDADDAR(n) CDR(CDR(CAR(CDR(CDR(CAR(n))))))
00424 #define CDDADDDR(n) CDR(CDR(CAR(CDR(CDR(CDR(n))))))
00425 #define CDDDAAAR(n) CDR(CDR(CDR(CAR(CAR(CAR(n))))))
00426 #define CDDDAADR(n) CDR(CDR(CDR(CAR(CAR(CDR(n))))))
00427 #define CDDDADAR(n) CDR(CDR(CDR(CAR(CDR(CAR(n))))))
00428 #define CDDDADDR(n) CDR(CDR(CDR(CAR(CDR(CDR(n))))))
00429 #define CDDDDAAR(n) CDR(CDR(CDR(CDR(CAR(CAR(n))))))
00430 #define CDDDDADR(n) CDR(CDR(CDR(CDR(CAR(CDR(n))))))
00431 #define CDDDDDAR(n) CDR(CDR(CDR(CDR(CDR(CAR(n))))))
00432 #define CDDDDDDR(n) CDR(CDR(CDR(CDR(CDR(CDR(n))))))
00433 
00434 #define GAUGE_RUSAGE_INDEX 0
00435 
00436 #define add_to_mem_block(N,Data,Size) low_my_binary_strcat(Data,Size,areas+N)
00437 #define IDENTIFIERP(i) (Pike_compiler->new_program->identifier_references+(i))
00438 #define INHERIT(i) (Pike_compiler->new_program->inherits+(i))
00439 #define PIKE_PC (Pike_compiler->new_program->num_program)
00440 
00441 #ifndef PIKE_DEBUG
00442 #define check_tree(X,Y)
00443 #endif
00444 
00445 #endif
Generated on Fri Jul 22 23:44:26 2005 for Pike by  doxygen 1.3.9.1