f6f02d1995-10-16Fredrik Hübinette (Hubbe) /*\
06983f1996-09-22Fredrik Hübinette (Hubbe) ||| This file a part of Pike, and is copyright by Fredrik Hubinette ||| Pike is distributed as GPL (General Public License)
f6f02d1995-10-16Fredrik Hübinette (Hubbe) ||| See the files COPYING and DISCLAIMER for more information. \*/
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "global.h"
31df251998-04-13Henrik Grubbström (Grubba) RCSID("$Id: program.c,v 1.78 1998/04/13 15:34:31 grubba Exp $");
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "program.h" #include "object.h" #include "dynamic_buffer.h"
06983f1996-09-22Fredrik Hübinette (Hubbe) #include "pike_types.h"
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "stralloc.h" #include "las.h" #include "language.h" #include "lex.h"
bb55f81997-03-16Fredrik Hübinette (Hubbe) #include "pike_macros.h"
5267b71995-08-09Fredrik Hübinette (Hubbe) #include "fsort.h" #include "error.h" #include "docode.h" #include "interpret.h" #include "hashtable.h"
2acdd31995-10-29Fredrik Hübinette (Hubbe) #include "main.h"
624d091996-02-24Fredrik Hübinette (Hubbe) #include "gc.h"
07513e1996-10-04Fredrik Hübinette (Hubbe) #include "threads.h"
0683be1997-01-26Fredrik Hübinette (Hubbe) #include "constants.h"
9c6f7d1997-04-15Fredrik Hübinette (Hubbe) #include "operators.h"
3eb19a1998-01-30Henrik Grubbström (Grubba) #include "builtin_functions.h"
1994981998-04-07Fredrik Hübinette (Hubbe) #include "stuff.h"
8aeeb21996-11-19Fredrik Hübinette (Hubbe)  #include <errno.h>
5267b71995-08-09Fredrik Hübinette (Hubbe) #include <fcntl.h>
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  #undef ATTRIBUTE #define ATTRIBUTE(X)
189fd01997-01-28Fredrik Hübinette (Hubbe) /* * Define the size of the cache that is used for method lookup. */ #define FIND_FUNCTION_HASHSIZE 4711
5c8e891995-10-29Fredrik Hübinette (Hubbe) #define STRUCT #include "compilation.h" #define DECLARE #include "compilation.h"
5267b71995-08-09Fredrik Hübinette (Hubbe) 
5580691996-06-21Fredrik Hübinette (Hubbe)  char *lfun_names[] = { "__INIT", "create", "destroy", "`+", "`-", "`&", "`|", "`^", "`<<", "`>>", "`*", "`/", "`%", "`~", "`==", "`<", "`>", "__hash", "cast", "`!",
774b061996-08-03Fredrik Hübinette (Hubbe)  "`[]", "`[]=",
dffa011997-01-15Fredrik Hübinette (Hubbe)  "`->", "`->=",
0683be1997-01-26Fredrik Hübinette (Hubbe)  "_sizeof", "_indices", "_values", "`()",
1b89ad1997-10-10Fredrik Hübinette (Hubbe)  "``+", "``-", "``&", "``|", "``^", "``<<", "``>>", "``*", "``/", "``%",
5580691996-06-21Fredrik Hübinette (Hubbe) };
5267b71995-08-09Fredrik Hübinette (Hubbe) struct program *first_program = 0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) static int current_program_id=0;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) struct program *new_program=0;
6d22541998-01-28Fredrik Hübinette (Hubbe) struct object *fake_object=0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) struct program *malloc_size_program=0;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) int compiler_pass; int compilation_depth;
48cffa1998-01-22Henrik Grubbström (Grubba) long local_class_counter;
9649491998-02-27Fredrik Hübinette (Hubbe) int catch_level;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) struct compiler_frame *compiler_frame=0;
5267b71995-08-09Fredrik Hübinette (Hubbe) static INT32 last_line = 0; static INT32 last_pc = 0;
06983f1996-09-22Fredrik Hübinette (Hubbe) static struct pike_string *last_file = 0;
591c0c1997-01-19Fredrik Hübinette (Hubbe) dynamic_buffer used_modules;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* So what if we don't have templates? / Hubbe */ #ifdef DEBUG #define CHECK_FOO(NUMTYPE,TYPE,NAME) \ if(malloc_size_program-> PIKE_CONCAT(num_,NAME) < new_program-> PIKE_CONCAT(num_,NAME)) \ fatal("new_program->num_" #NAME " is out of order\n"); \ if(new_program->flags & PROGRAM_OPTIMIZED) \ fatal("Tried to reallocate fixed program.\n") #else #define CHECK_FOO(NUMTYPE,TYPE,NAME) #endif #define FOO(NUMTYPE,TYPE,NAME) \
d429a71998-02-24Fredrik Hübinette (Hubbe) void PIKE_CONCAT(add_to_,NAME) (TYPE ARG) { \
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  CHECK_FOO(NUMTYPE,TYPE,NAME); \
d429a71998-02-24Fredrik Hübinette (Hubbe)  if(malloc_size_program->PIKE_CONCAT(num_,NAME) == \ new_program->PIKE_CONCAT(num_,NAME)) { \
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  void *tmp; \
d429a71998-02-24Fredrik Hübinette (Hubbe)  malloc_size_program->PIKE_CONCAT(num_,NAME) *= 2; \ malloc_size_program->PIKE_CONCAT(num_,NAME)++; \
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  tmp=realloc((char *)new_program->NAME, \ sizeof(TYPE) * \
d429a71998-02-24Fredrik Hübinette (Hubbe)  malloc_size_program->PIKE_CONCAT(num_,NAME)); \
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(!tmp) fatal("Out of memory.\n"); \ new_program->NAME=tmp; \ } \
d429a71998-02-24Fredrik Hübinette (Hubbe)  new_program->NAME[new_program->PIKE_CONCAT(num_,NAME)++]=(ARG); \
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) } #include "program_areas.h"
d429a71998-02-24Fredrik Hübinette (Hubbe) #define FOO(NUMTYPE,TYPE,NAME) \ void PIKE_CONCAT(low_add_to_,NAME) (struct program_state *state, \ TYPE ARG) { \ if(state->malloc_size_program->PIKE_CONCAT(num_,NAME) == \ state->new_program->PIKE_CONCAT(num_,NAME)) { \ void *tmp; \ state->malloc_size_program->PIKE_CONCAT(num_,NAME) *= 2; \ state->malloc_size_program->PIKE_CONCAT(num_,NAME)++; \ tmp=realloc((char *)state->new_program->NAME, \ sizeof(TYPE) * \ state->malloc_size_program->PIKE_CONCAT(num_,NAME)); \ if(!tmp) fatal("Out of memory.\n"); \ state->new_program->NAME=tmp; \ } \ state->new_program->NAME[state->new_program->PIKE_CONCAT(num_,NAME)++]=(ARG); \ } #include "program_areas.h"
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void ins_int(INT32 i, void (*func)(char tmp)) { int e; for(e=0;e<(long)sizeof(i);e++) func(EXTRACT_UCHAR(((char *)&i)+e)); } void ins_short(INT16 i, void (*func)(char tmp)) { int e; for(e=0;e<(long)sizeof(i);e++) func(EXTRACT_UCHAR(((char *)&i)+e)); }
5f8eb71997-02-18Fredrik Hübinette (Hubbe) 
591c0c1997-01-19Fredrik Hübinette (Hubbe) void use_module(struct svalue *s)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
5c0a101997-02-06Fredrik Hübinette (Hubbe)  if( (1<<s->type) & (BIT_MAPPING | BIT_OBJECT)) { assign_svalue_no_free((struct svalue *) low_make_buf_space(sizeof(struct svalue), &used_modules), s); }else{ yyerror("Module is neither mapping nor object"); }
591c0c1997-01-19Fredrik Hübinette (Hubbe) }
b8cda21997-01-21Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) int low_find_shared_string_identifier(struct pike_string *name, struct program *prog); struct node_s *find_module_identifier(struct pike_string *ident)
591c0c1997-01-19Fredrik Hübinette (Hubbe) { JMP_BUF tmp;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  node *ret;
5c0a101997-02-06Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(SETJMP(tmp))
591c0c1997-01-19Fredrik Hübinette (Hubbe)  { ONERROR tmp; SET_ONERROR(tmp,exit_on_error,"Error in handle_error in master object!"); assign_svalue_no_free(sp++, & throw_value); APPLY_MASTER("handle_error", 1); pop_stack(); UNSET_ONERROR(tmp); yyerror("Couldn't index module."); }else{ struct svalue *modules=(struct svalue *)used_modules.s.str;
0683be1997-01-26Fredrik Hübinette (Hubbe)  int e=used_modules.s.len / sizeof(struct svalue);
591c0c1997-01-19Fredrik Hübinette (Hubbe)  while(--e>=0) { push_svalue(modules+e);
61e9a01998-01-25Fredrik Hübinette (Hubbe)  ref_push_string(ident);
591c0c1997-01-19Fredrik Hübinette (Hubbe)  f_index(2);
5c0a101997-02-06Fredrik Hübinette (Hubbe)  if(!IS_UNDEFINED(sp-1))
591c0c1997-01-19Fredrik Hübinette (Hubbe)  {
5c0a101997-02-06Fredrik Hübinette (Hubbe) /* fprintf(stderr,"MOD: %s, %d %d\n",ident->str, current_line, sp[-1].type); */
591c0c1997-01-19Fredrik Hübinette (Hubbe)  UNSETJMP(tmp);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  ret=mksvaluenode(sp-1); pop_stack(); return ret;
591c0c1997-01-19Fredrik Hübinette (Hubbe)  }
5c0a101997-02-06Fredrik Hübinette (Hubbe)  pop_stack();
591c0c1997-01-19Fredrik Hübinette (Hubbe)  } } UNSETJMP(tmp);
b8cda21997-01-21Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  struct program_state *p=previous_program_state; int n; for(n=0;n<compilation_depth;n++,p=p->previous)
b8cda21997-01-21Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  int i=low_find_shared_string_identifier(ident, p->new_program);
b8cda21997-01-21Fredrik Hübinette (Hubbe)  if(i!=-1) { struct identifier *id;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  id=ID_FROM_INT(p->new_program, i);
6149c61998-01-27Fredrik Hübinette (Hubbe) #if 0
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(IDENTIFIER_IS_CONSTANT(id->identifier_flags))
b8cda21997-01-21Fredrik Hübinette (Hubbe)  {
6d22541998-01-28Fredrik Hübinette (Hubbe)  struct svalue *s=PROG_FROM_INT(p->new_program, i)->constants+ id->func.offset; if(s->type != T_PROGRAM) { ret=mksvaluenode(s); return ret; }
b8cda21997-01-21Fredrik Hübinette (Hubbe)  }
6149c61998-01-27Fredrik Hübinette (Hubbe) #endif
6d22541998-01-28Fredrik Hübinette (Hubbe)  return mkexternalnode(n, i, id);
b8cda21997-01-21Fredrik Hübinette (Hubbe)  } } } return 0; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) struct program *parent_compilation(int level) { int n; struct program_state *p=previous_program_state; for(n=0;n<level;n++) { if(n>=compilation_depth) return 0; p=p->previous; if(!p) return 0; } return p->new_program; } #define ID_TO_PROGRAM_CACHE_SIZE 512 struct program *id_to_program_cache[ID_TO_PROGRAM_CACHE_SIZE];
b8cda21997-01-21Fredrik Hübinette (Hubbe) struct program *id_to_program(INT32 id) { struct program *p;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  INT32 h; if(!id) return 0; h=id & (ID_TO_PROGRAM_CACHE_SIZE-1); if((p=id_to_program_cache[h]))
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(p->id==id) return p;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
b8cda21997-01-21Fredrik Hübinette (Hubbe)  if(id)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  { for(p=first_program;p;p=p->next) { if(id==p->id) { id_to_program_cache[h]=p; return p; } } }
591c0c1997-01-19Fredrik Hübinette (Hubbe)  return 0; }
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* Here starts routines which are used to build new programs */
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* Re-allocate all the memory in the program in one chunk. because: * 1) The individual blocks are munch bigger than they need to be * 2) cuts down on malloc overhead (maybe) * 3) localizes memory access (decreases paging)
5267b71995-08-09Fredrik Hübinette (Hubbe)  */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void optimize_program(struct program *p) { SIZE_T size=0; char *data; /* Already done (shouldn't happen, but who knows?) */ if(p->flags & PROGRAM_OPTIMIZED) return; #define FOO(NUMTYPE,TYPE,NAME) \
1994981998-04-07Fredrik Hübinette (Hubbe)  size=DO_ALIGN(size, ALIGNOF(TYPE)); \ size+=p->PIKE_CONCAT(num_,NAME)*sizeof(p->NAME[0]);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #include "program_areas.h" data=malloc(size); if(!data) return; /* We are out of memory, but we don't care! */ size=0; #define FOO(NUMTYPE,TYPE,NAME) \
1994981998-04-07Fredrik Hübinette (Hubbe)  size=DO_ALIGN(size, ALIGNOF(TYPE)); \
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  MEMCPY(data+size,p->NAME,p->PIKE_CONCAT(num_,NAME)*sizeof(p->NAME[0])); \ free((char *)p->NAME); \ p->NAME=(TYPE *)(data+size); \
1994981998-04-07Fredrik Hübinette (Hubbe)  size+=p->PIKE_CONCAT(num_,NAME)*sizeof(p->NAME[0]);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #include "program_areas.h" p->total_size=size + sizeof(struct program); p->flags |= PROGRAM_OPTIMIZED;
5267b71995-08-09Fredrik Hübinette (Hubbe) }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* internal function to make the index-table */ static int funcmp(const void *a,const void *b) { return my_order_strcmp(ID_FROM_INT(new_program, *(unsigned short *)a)->name, ID_FROM_INT(new_program, *(unsigned short *)b)->name); } void fixate_program(void) { INT32 i,e,t; if(new_program->flags & PROGRAM_FIXED) return; #ifdef DEBUG if(new_program->flags & PROGRAM_OPTIMIZED) fatal("Cannot fixate optimized program\n"); #endif /* Ok, sort for binsearch */ for(e=i=0;i<(int)new_program->num_identifier_references;i++) { struct reference *funp; struct identifier *fun; funp=new_program->identifier_references+i; if(funp->id_flags & (ID_HIDDEN|ID_STATIC)) continue; if(funp->id_flags & ID_INHERITED) { if(funp->id_flags & ID_PRIVATE) continue; fun=ID_FROM_PTR(new_program, funp); /* if(fun->func.offset == -1) continue; * prototype */ /* check for multiple definitions */ for(t=i+1;t>=0 && t<(int)new_program->num_identifier_references;t++) { struct reference *funpb; struct identifier *funb; funpb=new_program->identifier_references+t; if(funpb->id_flags & (ID_HIDDEN|ID_STATIC)) continue; funb=ID_FROM_PTR(new_program,funpb); /* if(funb->func.offset == -1) continue; * prototype */ if(fun->name==funb->name) t=-10; } if(t<0) continue; } add_to_identifier_index(i); } fsort((void *)new_program->identifier_index, new_program->num_identifier_index, sizeof(unsigned short),(fsortfun)funcmp); for(i=0;i<NUM_LFUNS;i++) new_program->lfuns[i]=find_identifier(lfun_names[i],new_program); new_program->flags |= PROGRAM_FIXED; }
5267b71995-08-09Fredrik Hübinette (Hubbe) 
ea32c11998-04-13Henrik Grubbström (Grubba) /* * Error handler. * * This function should not normally be called, * but is here for safety reasons. */ void restore_threads_disabled(void *arg) { fprintf(stderr, "restore_threads_disabled(): threads_disabled:%d, compilation_depth:%d\n", threads_disabled, compilation_depth); #ifdef DEBUG fatal("restore_threads_disabled() called\n"); #endif /* DEBUG */ if (threads_disabled) threads_disabled--; co_signal(&threads_disabled_change); }
5267b71995-08-09Fredrik Hübinette (Hubbe) /* * Start building a new program */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void low_start_new_program(struct program *p, struct pike_string *name, int flags)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
6d22541998-01-28Fredrik Hübinette (Hubbe)  int e,id=0;
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
07513e1996-10-04Fredrik Hübinette (Hubbe)  threads_disabled++;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  compilation_depth++;
ea32c11998-04-13Henrik Grubbström (Grubba)  /* fprintf(stderr, "low_start_new_program(): compilation_depth:%d\n", compilation_depth); */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(!p) { p=ALLOC_STRUCT(program); MEMSET(p, 0, sizeof(struct program)); p->refs=1; p->id=++current_program_id; if((p->next=first_program)) first_program->prev=p; first_program=p; }else{ p->refs++; } if(name) { struct svalue s; s.type=T_PROGRAM; s.u.program=p;
6d22541998-01-28Fredrik Hübinette (Hubbe)  id=add_constant(name, &s, flags);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  }
5c8e891995-10-29Fredrik Hübinette (Hubbe) #define PUSH #include "compilation.h"
b8cda21997-01-21Fredrik Hübinette (Hubbe) 
36feac1997-03-06Fredrik Hübinette (Hubbe)  init_type_stack();
591c0c1997-01-19Fredrik Hübinette (Hubbe)  low_reinit_buf(& used_modules);
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(p && (p->flags & PROGRAM_FINISHED))
0683be1997-01-26Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  yyerror("Pass2: Program already done"); p=0; } malloc_size_program = ALLOC_STRUCT(program);
6d22541998-01-28Fredrik Hübinette (Hubbe) #ifdef DEBUG fake_object=(struct object *)xalloc(sizeof(struct object) + 256*sizeof(struct svalue)); /* Stipple to find illegal accesses */ MEMSET(fake_object,0x55,sizeof(struct object) + 256*sizeof(struct svalue)); #else fake_object=ALLOC_STRUCT(object); #endif
a3c6ad1998-01-29Fredrik Hübinette (Hubbe)  GC_ALLOC();
6d22541998-01-28Fredrik Hübinette (Hubbe)  fake_object->next=fake_object; fake_object->prev=fake_object; fake_object->refs=1; fake_object->parent=0; fake_object->parent_identifier=0; fake_object->prog=p; p->refs++; if(name) { if((fake_object->parent=previous_program_state->fake_object)) fake_object->parent->refs++; fake_object->parent_identifier=id; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_program=p; if(new_program->program) { #define FOO(NUMTYPE,TYPE,NAME) \ malloc_size_program->PIKE_CONCAT(num_,NAME)=new_program->PIKE_CONCAT(num_,NAME); #include "program_areas.h" }else{ static struct pike_string *s; struct inherit i; #define START_SIZE 64 #define FOO(NUMTYPE,TYPE,NAME) \ malloc_size_program->PIKE_CONCAT(num_,NAME)=START_SIZE; \ new_program->NAME=(TYPE *)xalloc(sizeof(TYPE) * START_SIZE); #include "program_areas.h" i.prog=new_program; i.identifier_level=0; i.storage_offset=0; i.inherit_level=0; i.parent=0; i.parent_identifier=0;
61e9a01998-01-25Fredrik Hübinette (Hubbe)  i.parent_offset=1;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  i.name=0; add_to_inherits(i);
0683be1997-01-26Fredrik Hübinette (Hubbe)  } { struct svalue tmp; tmp.type=T_MAPPING;
94a2971997-03-01Henrik Grubbström (Grubba) #ifdef __CHECKER__ tmp.subtype=0; #endif /* __CHECKER__ */
0683be1997-01-26Fredrik Hübinette (Hubbe)  tmp.u.mapping=get_builtin_constants(); use_module(& tmp); }
2acdd31995-10-29Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  init_node=0;
0683be1997-01-26Fredrik Hübinette (Hubbe)  num_parse_error=0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  push_compiler_frame();
5267b71995-08-09Fredrik Hübinette (Hubbe) }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void start_new_program(void) {
ea32c11998-04-13Henrik Grubbström (Grubba)  /* fprintf(stderr, "start_new_program(): threads_disabled:%d, compilation_depth:%d\n", threads_disabled, compilation_depth); */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  low_start_new_program(0,0,0); } void really_free_program(struct program *p)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
5c8e891995-10-29Fredrik Hübinette (Hubbe)  unsigned INT16 e;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(id_to_program_cache[p->id & (ID_TO_PROGRAM_CACHE_SIZE-1)]==p) id_to_program_cache[p->id & (ID_TO_PROGRAM_CACHE_SIZE-1)]=0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  for(e=0; e<p->num_strings; e++) free_string(p->strings[e]); for(e=0; e<p->num_identifiers; e++) { free_string(p->identifiers[e].name); free_string(p->identifiers[e].type); } for(e=0; e<p->num_constants; e++) free_svalue(p->constants+e); for(e=1; e<p->num_inherits; e++)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  {
3c0c281998-01-26Fredrik Hübinette (Hubbe)  if(p->inherits[e].name) free_string(p->inherits[e].name); if(e) { free_program(p->inherits[e].prog); if(p->inherits[e].parent) free_object(p->inherits[e].parent); }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  }
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(p->prev) p->prev->next=p->next; else first_program=p->next; if(p->next) p->next->prev=p->prev;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(p->flags & PROGRAM_OPTIMIZED) { if(p->program) free(p->program); #define FOO(NUMTYPE,TYPE,NAME) p->NAME=0; #include "program_areas.h" }else{ #define FOO(NUMTYPE,TYPE,NAME) \ if(p->NAME) { free((char *)p->NAME); p->NAME=0; } #include "program_areas.h" }
5267b71995-08-09Fredrik Hübinette (Hubbe)  free((char *)p);
624d091996-02-24Fredrik Hübinette (Hubbe)  GC_FREE();
5267b71995-08-09Fredrik Hübinette (Hubbe) }
2acdd31995-10-29Fredrik Hübinette (Hubbe) #ifdef DEBUG void dump_program_desc(struct program *p) { int e,d,q; /* fprintf(stderr,"Program '%s':\n",p->name->str); */ /* fprintf(stderr,"All inherits:\n"); for(e=0;e<p->num_inherits;e++) { fprintf(stderr,"%3d:",e); for(d=0;d<p->inherits[e].inherit_level;d++) fprintf(stderr," "); fprintf(stderr,"%s\n",p->inherits[e].prog->name->str); } */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  fprintf(stderr,"All identifiers:\n");
2acdd31995-10-29Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_identifier_references;e++) { fprintf(stderr,"%3d:",e); for(d=0;d<INHERIT_FROM_INT(p,e)->inherit_level;d++) fprintf(stderr," ");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  fprintf(stderr,"%s;\n",ID_FROM_INT(p,e)->name->str);
2acdd31995-10-29Fredrik Hübinette (Hubbe)  } fprintf(stderr,"All sorted identifiers:\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(q=0;q<(int)p->num_identifier_index;q++)
2acdd31995-10-29Fredrik Hübinette (Hubbe)  { e=p->identifier_index[q]; fprintf(stderr,"%3d (%3d):",e,q); for(d=0;d<INHERIT_FROM_INT(p,e)->inherit_level;d++) fprintf(stderr," ");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  fprintf(stderr,"%s;\n", ID_FROM_INT(p,e)->name->str);
2acdd31995-10-29Fredrik Hübinette (Hubbe)  } } #endif
be478c1997-08-30Henrik Grubbström (Grubba) static void toss_compilation_resources(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
a3c6ad1998-01-29Fredrik Hübinette (Hubbe)  if(fake_object) { free_program(fake_object->prog); fake_object->prog=0; free_object(fake_object); fake_object=0; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  free_program(new_program); new_program=0;
591c0c1997-01-19Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(malloc_size_program)
591c0c1997-01-19Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  free((char *)malloc_size_program); malloc_size_program=0;
591c0c1997-01-19Fredrik Hübinette (Hubbe)  }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  while(compiler_frame) pop_compiler_frame();
591c0c1997-01-19Fredrik Hübinette (Hubbe)  if(last_file) { free_string(last_file); last_file=0; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  { struct svalue *modules=(struct svalue *)used_modules.s.str; INT32 e;
591c0c1997-01-19Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=0;e<(long)(used_modules.s.len / sizeof(struct svalue));e++) free_svalue(modules+e); toss_buffer(&used_modules); }
5267b71995-08-09Fredrik Hübinette (Hubbe) }
e964ae1998-04-08Fredrik Hübinette (Hubbe) int sizeof_variable(int run_time_type)
1994981998-04-07Fredrik Hübinette (Hubbe) { switch(run_time_type) { case T_FUNCTION: case T_MIXED: return sizeof(struct svalue); case T_INT: return sizeof(INT_TYPE); case T_FLOAT: return sizeof(FLOAT_TYPE); default: return sizeof(char *); } } static int alignof_variable(int run_time_type) { switch(run_time_type) { case T_FUNCTION: case T_MIXED: #ifdef HAVE_ALIGNOF return ALIGNOF(struct svalue); #else
7da9c01998-04-07Fredrik Hübinette (Hubbe)  return ALIGNOF(union anything);
1994981998-04-07Fredrik Hübinette (Hubbe) #endif case T_INT: return ALIGNOF(INT_TYPE); case T_FLOAT: return ALIGNOF(FLOAT_TYPE); default: return ALIGNOF(char *); } }
0d202a1995-10-20Fredrik Hübinette (Hubbe) #ifdef DEBUG
624d091996-02-24Fredrik Hübinette (Hubbe) void check_program(struct program *p)
0d202a1995-10-20Fredrik Hübinette (Hubbe) { INT32 size,e; unsigned INT32 checksum; if(p->refs <=0) fatal("Program has zero refs.\n"); if(p->next && p->next->prev != p) fatal("Program ->next->prev != program.\n"); if(p->prev) { if(p->prev->next != p) fatal("Program ->prev->next != program.\n"); }else{ if(first_program != p) fatal("Program ->prev == 0 but first_program != program.\n"); }
d2c6081996-11-07Fredrik Hübinette (Hubbe)  if(p->id > current_program_id || p->id <= 0)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  fatal("Program id is wrong.\n"); if(p->storage_needed < 0) fatal("Program->storage_needed < 0.\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(p->num_identifier_index > p->num_identifier_references) fatal("Too many identifier index entries in program!\n");
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_constants;e++)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  check_svalue(p->constants + e);
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_strings;e++)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  check_string(p->strings[e]);
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_identifiers;e++)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  { check_string(p->identifiers[e].name); check_string(p->identifiers[e].type);
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(p->identifiers[e].identifier_flags & ~15)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  fatal("Unknown flags in identifier flag field.\n"); if(p->identifiers[e].run_time_type!=T_MIXED) check_type(p->identifiers[e].run_time_type);
2f1b9e1998-04-06Fredrik Hübinette (Hubbe)  if(IDENTIFIER_IS_VARIABLE(p->identifiers[e].identifier_flags)) {
1994981998-04-07Fredrik Hübinette (Hubbe)  if(p->identifiers[e].func.offset & (alignof_variable(p->identifiers[e].run_time_type)-1))
2f1b9e1998-04-06Fredrik Hübinette (Hubbe)  {
1994981998-04-07Fredrik Hübinette (Hubbe)  fatal("Variable %s offset is not properly aligned (%d).\n",p->identifiers[e].name->str,p->identifiers[e].func.offset);
2f1b9e1998-04-06Fredrik Hübinette (Hubbe)  } }
0d202a1995-10-20Fredrik Hübinette (Hubbe)  }
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_identifier_references;e++)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  { if(p->identifier_references[e].inherit_offset > p->num_inherits) fatal("Inherit offset is wrong!\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
0d202a1995-10-20Fredrik Hübinette (Hubbe)  if(p->identifier_references[e].identifier_offset > p->inherits[p->identifier_references[e].inherit_offset].prog->num_identifiers) fatal("Identifier offset is wrong!\n"); }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_identifier_index;e++)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  { if(p->identifier_index[e] > p->num_identifier_references) fatal("Program->identifier_indexes[%ld] is wrong\n",(long)e); }
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_inherits;e++)
0d202a1995-10-20Fredrik Hübinette (Hubbe)  { if(p->inherits[e].storage_offset < 0) fatal("Inherit->storage_offset is wrong.\n");
1994981998-04-07Fredrik Hübinette (Hubbe)  if(p->inherits[e].storage_offset & (ALIGN_BOUND-1)) { fatal("inherit[%d].storage_offset is not properly aligned.\n",e); }
0d202a1995-10-20Fredrik Hübinette (Hubbe)  } } #endif
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) struct program *end_first_pass(int finish)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
0ffa001998-01-13Fredrik Hübinette (Hubbe)  int e;
5267b71995-08-09Fredrik Hübinette (Hubbe)  struct program *prog;
0ffa001998-01-13Fredrik Hübinette (Hubbe)  struct pike_string *s; MAKE_CONSTANT_SHARED_STRING(s,"__INIT"); /* Collect references to inherited __INIT functions */
ae7ee51998-04-10Henrik Grubbström (Grubba)  for(e=new_program->num_inherits-1;e;e--)
0ffa001998-01-13Fredrik Hübinette (Hubbe)  { int id; if(new_program->inherits[e].inherit_level!=1) continue;
d429a71998-02-24Fredrik Hübinette (Hubbe)  id=low_reference_inherited_identifier(0, e, s);
0ffa001998-01-13Fredrik Hübinette (Hubbe)  if(id!=-1) { init_node=mknode(F_ARG_LIST, mkcastnode(void_type_string,
87c9d21998-04-09Fredrik Hübinette (Hubbe)  mkapplynode(mkidentifiernode(id),0)), init_node);
0ffa001998-01-13Fredrik Hübinette (Hubbe)  } }
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* * Define the __INIT function, but only if there was any code * to initialize. */
0ffa001998-01-13Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(init_node)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { union idptr tmp;
329cc01997-02-17Fredrik Hübinette (Hubbe)  dooptcode(s, mknode(F_ARG_LIST, init_node,mknode(F_RETURN,mkintnode(0),0)), function_type_string, 0);
a8ef6e1996-12-03Fredrik Hübinette (Hubbe)  init_node=0;
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  free_string(s);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  pop_compiler_frame(); /* Pop __INIT local variables */
36feac1997-03-06Fredrik Hübinette (Hubbe)  exit_type_stack();
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(num_parse_error > 0)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { prog=0; }else{
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  prog=new_program; prog->refs++;
5580691996-06-21Fredrik Hübinette (Hubbe) 
0d202a1995-10-20Fredrik Hübinette (Hubbe) #ifdef DEBUG
624d091996-02-24Fredrik Hübinette (Hubbe)  check_program(prog);
2acdd31995-10-29Fredrik Hübinette (Hubbe)  if(l_flag) dump_program_desc(prog);
0d202a1995-10-20Fredrik Hübinette (Hubbe) #endif
5580691996-06-21Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_program->flags |= PROGRAM_PASS_1_DONE; if(finish) { fixate_program(); optimize_program(new_program); new_program->flags |= PROGRAM_FINISHED; }
06983f1996-09-22Fredrik Hübinette (Hubbe)  GC_ALLOC();
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  toss_compilation_resources();
5267b71995-08-09Fredrik Hübinette (Hubbe) 
5c8e891995-10-29Fredrik Hübinette (Hubbe) #define POP #include "compilation.h"
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  compilation_depth--;
07513e1996-10-04Fredrik Hübinette (Hubbe)  threads_disabled--;
ef1e931998-03-26Henrik Grubbström (Grubba)  co_signal(&threads_disabled_change);
ea32c11998-04-13Henrik Grubbström (Grubba)  /* fprintf(stderr, "end_first_pass(): compilation_depth:%d\n", compilation_depth); */
a8ef6e1996-12-03Fredrik Hübinette (Hubbe)  free_all_nodes();
5267b71995-08-09Fredrik Hübinette (Hubbe)  return prog; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* * Finish this program, returning the newly built program */
3c0c281998-01-26Fredrik Hübinette (Hubbe) struct program *debug_end_program(void)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) { return end_first_pass(1); }
5267b71995-08-09Fredrik Hübinette (Hubbe) /* * Allocate needed for this program in the object structure. * An offset to the data is returned. */
1994981998-04-07Fredrik Hübinette (Hubbe) SIZE_T low_add_storage(SIZE_T size, SIZE_T alignment)
5267b71995-08-09Fredrik Hübinette (Hubbe) { SIZE_T offset;
1994981998-04-07Fredrik Hübinette (Hubbe)  offset=DO_ALIGN(new_program->storage_needed, alignment); new_program->storage_needed = offset + size; #ifdef DEBUG if(alignment <=0) fatal("Alignment must be at least 1\n"); if(new_program->storage_needed<0) fatal("add_storage failed horribly!\n"); #endif
5267b71995-08-09Fredrik Hübinette (Hubbe)  return offset; }
1994981998-04-07Fredrik Hübinette (Hubbe) SIZE_T add_storage(SIZE_T storage) { return low_add_storage(storage, storage>ALIGN_BOUND? ALIGN_BOUND : storage ? (1<<my_log2(storage)) : 1); }
5267b71995-08-09Fredrik Hübinette (Hubbe) /* * set a callback used to initialize clones of this program * the init function is called at clone time */
06983f1996-09-22Fredrik Hübinette (Hubbe) void set_init_callback(void (*init)(struct object *))
5267b71995-08-09Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_program->init=init;
5267b71995-08-09Fredrik Hübinette (Hubbe) } /* * set a callback used to de-initialize clones of this program * the exit function is called at destruct */
06983f1996-09-22Fredrik Hübinette (Hubbe) void set_exit_callback(void (*exit)(struct object *))
5267b71995-08-09Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_program->exit=exit;
5267b71995-08-09Fredrik Hübinette (Hubbe) }
d4828c1997-07-17Fredrik Hübinette (Hubbe) /* * This callback is called to allow the object to mark all internal * structures as 'used'. */ void set_gc_mark_callback(void (*m)(struct object *)) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  new_program->gc_marked=m;
d4828c1997-07-17Fredrik Hübinette (Hubbe) }
f0c3d31998-04-05Fredrik Hübinette (Hubbe) /* * Called for all objects and inherits in first pass of gc() */ void set_gc_check_callback(void (*m)(struct object *)) { new_program->gc_check=m; }
d429a71998-02-24Fredrik Hübinette (Hubbe) int low_reference_inherited_identifier(struct program_state *q, int e,
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  struct pike_string *name)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
d429a71998-02-24Fredrik Hübinette (Hubbe)  struct program *np=q?q->new_program:new_program;
5267b71995-08-09Fredrik Hübinette (Hubbe)  struct reference funp; struct program *p; int i,d;
d429a71998-02-24Fredrik Hübinette (Hubbe)  p=np->inherits[e].prog;
5267b71995-08-09Fredrik Hübinette (Hubbe)  i=find_shared_string_identifier(name,p); if(i==-1) return i;
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(p->identifier_references[i].id_flags & ID_HIDDEN)
5267b71995-08-09Fredrik Hübinette (Hubbe)  return -1; funp=p->identifier_references[i];
0d202a1995-10-20Fredrik Hübinette (Hubbe)  funp.inherit_offset+=e;
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  funp.id_flags|=ID_HIDDEN;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
d429a71998-02-24Fredrik Hübinette (Hubbe)  for(d=0;d<(int)np->num_identifier_references;d++)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { struct reference *fp;
d429a71998-02-24Fredrik Hübinette (Hubbe)  fp=np->identifier_references+d;
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(!MEMCMP((char *)fp,(char *)&funp,sizeof funp)) return d; }
d429a71998-02-24Fredrik Hübinette (Hubbe)  if(q) low_add_to_identifier_references(q,funp); else add_to_identifier_references(funp); return np->num_identifier_references -1;
5267b71995-08-09Fredrik Hübinette (Hubbe) }
d429a71998-02-24Fredrik Hübinette (Hubbe) static int middle_reference_inherited_identifier( struct program_state *state, struct pike_string *super_name, struct pike_string *function_name)
5267b71995-08-09Fredrik Hübinette (Hubbe) { int e,i;
d429a71998-02-24Fredrik Hübinette (Hubbe)  struct program *p=state?state->new_program:new_program;
5267b71995-08-09Fredrik Hübinette (Hubbe)  #ifdef DEBUG if(function_name!=debug_findstring(function_name)) fatal("reference_inherited_function on nonshared string.\n"); #endif
d429a71998-02-24Fredrik Hübinette (Hubbe)  for(e=p->num_inherits-1;e>0;e--)
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
d429a71998-02-24Fredrik Hübinette (Hubbe)  if(p->inherits[e].inherit_level!=1) continue; if(!p->inherits[e].name) continue;
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(super_name)
d429a71998-02-24Fredrik Hübinette (Hubbe)  if(super_name != p->inherits[e].name)
5267b71995-08-09Fredrik Hübinette (Hubbe)  continue;
d429a71998-02-24Fredrik Hübinette (Hubbe)  i=low_reference_inherited_identifier(state,e,function_name);
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(i==-1) continue; return i; } return -1; }
d429a71998-02-24Fredrik Hübinette (Hubbe) node *reference_inherited_identifier(struct pike_string *super_name, struct pike_string *function_name) { int i,n; struct program_state *p=previous_program_state; i=middle_reference_inherited_identifier(0, super_name, function_name); if(i!=-1) return mkidentifiernode(i); for(n=0;n<compilation_depth;n++,p=p->previous) { i=middle_reference_inherited_identifier(p,super_name, function_name); if(i!=-1) return mkexternalnode(n,i,ID_FROM_INT(p->new_program, i)); } return 0; }
06983f1996-09-22Fredrik Hübinette (Hubbe) void rename_last_inherit(struct pike_string *n)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(new_program->inherits[new_program->num_inherits].name) free_string(new_program->inherits[new_program->num_inherits].name); copy_shared_string(new_program->inherits[new_program->num_inherits].name, n);
5267b71995-08-09Fredrik Hübinette (Hubbe) } /* * make this program inherit another program */
61e9a01998-01-25Fredrik Hübinette (Hubbe) void low_inherit(struct program *p, struct object *parent, int parent_identifier, int parent_offset, INT32 flags, struct pike_string *name)
5267b71995-08-09Fredrik Hübinette (Hubbe) { int e, inherit_offset, storage_offset; struct inherit inherit;
06983f1996-09-22Fredrik Hübinette (Hubbe)  struct pike_string *s;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(!p) { yyerror("Illegal program pointer."); return; }
5267b71995-08-09Fredrik Hübinette (Hubbe) 
bcf9461998-01-27Fredrik Hübinette (Hubbe)  if(!(p->flags & (PROGRAM_FINISHED | PROGRAM_PASS_1_DONE))) { yyerror("Cannot inherit program which is not fully compiled yet."); return; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  inherit_offset = new_program->num_inherits;
1994981998-04-07Fredrik Hübinette (Hubbe)  storage_offset=add_storage(p->storage_needed);
5267b71995-08-09Fredrik Hübinette (Hubbe) 
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(e=0; e<(int)p->num_inherits; e++)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { inherit=p->inherits[e]; inherit.prog->refs++;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  inherit.identifier_level += new_program->num_identifier_references;
5267b71995-08-09Fredrik Hübinette (Hubbe)  inherit.storage_offset += storage_offset; inherit.inherit_level ++;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(!e) {
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(parent)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  {
9e52381998-03-01Fredrik Hübinette (Hubbe)  if(parent->next == parent) { struct object *o; for(o=fake_object->parent;o!=parent;o=o->parent) { #ifdef DEBUG if(!o) fatal("low_inherit with odd fake_object as parent!\n"); #endif inherit.parent_offset++; } }else{ inherit.parent=parent; inherit.parent_identifier=parent_identifier; inherit.parent_offset=0; }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  }else{ inherit.parent_offset+=parent_offset;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  }
1994981998-04-07Fredrik Hübinette (Hubbe)  }else{ if(parent && parent->next != parent && inherit.parent_offset) { struct object *par=parent; int e,pid=parent_identifier; for(e=1;e<inherit.parent_offset;e++) { struct inherit *in; if(!par->prog) { par=0; pid=0; break; } in=INHERIT_FROM_INT(par->prog, pid); if(in->parent_offset) { pid=par->parent_identifier; par=par->parent; e-=in->parent_offset-1; }else{ pid=in->parent_identifier; par=in->parent; } } inherit.parent=par; inherit.parent_identifier=pid; inherit.parent_offset=0; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  } if(inherit.parent) inherit.parent->refs++;
d2c6081996-11-07Fredrik Hübinette (Hubbe)  if(name) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(e==0) {
3c0c281998-01-26Fredrik Hübinette (Hubbe)  copy_shared_string(inherit.name,name);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  } else if(inherit.name) { struct pike_string *s; s=begin_shared_string(inherit.name->len + name->len + 2); MEMCPY(s->str,name->str,name->len); MEMCPY(s->str+name->len,"::",2); MEMCPY(s->str+name->len+2,inherit.name->str,inherit.name->len); inherit.name=end_shared_string(s); } else { inherit.name=0; } }else{ inherit.name=0;
d2c6081996-11-07Fredrik Hübinette (Hubbe)  }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_inherits(inherit);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for (e=0; e < (int)p->num_identifier_references; e++)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { struct reference fun;
06983f1996-09-22Fredrik Hübinette (Hubbe)  struct pike_string *name;
5267b71995-08-09Fredrik Hübinette (Hubbe)  fun = p->identifier_references[e]; /* Make a copy */ name=ID_FROM_PTR(p,&fun)->name; fun.inherit_offset += inherit_offset;
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if (fun.id_flags & ID_NOMASK)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { int n; n = isidentifier(name);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if (n != -1 && ID_FROM_INT(new_program,n)->func.offset != -1)
5267b71995-08-09Fredrik Hübinette (Hubbe)  my_yyerror("Illegal to redefine 'nomask' function/variable \"%s\"",name->str); }
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(fun.id_flags & ID_PRIVATE) fun.id_flags|=ID_HIDDEN;
5580691996-06-21Fredrik Hübinette (Hubbe) 
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if (fun.id_flags & ID_PUBLIC) fun.id_flags |= flags & ~ID_PRIVATE;
5267b71995-08-09Fredrik Hübinette (Hubbe)  else
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  fun.id_flags |= flags;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  fun.id_flags |= ID_INHERITED;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_identifier_references(fun);
5267b71995-08-09Fredrik Hübinette (Hubbe)  } }
61e9a01998-01-25Fredrik Hübinette (Hubbe) void do_inherit(struct svalue *s, INT32 flags, struct pike_string *name) { struct program *p=program_from_svalue(s); low_inherit(p, s->type == T_FUNCTION ? s->u.object : 0, s->subtype, 0, flags, name); } void compiler_do_inherit(node *n, INT32 flags, struct pike_string *name) {
2416d81998-01-27Fredrik Hübinette (Hubbe)  if(!n) { yyerror("Unable to inherit"); return; }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  switch(n->token) { case F_EXTERNAL: { struct identifier *i; struct program *p=parent_compilation(n->u.integer.a); INT32 numid=n->u.integer.b; if(!p) { yyerror("Failed to resolv external constant.\n"); return; } i=ID_FROM_INT(p, numid); if(IDENTIFIER_IS_CONSTANT(i->identifier_flags)) {
2416d81998-01-27Fredrik Hübinette (Hubbe)  struct svalue *s=PROG_FROM_INT(p, numid)->constants + i->func.offset;
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(s->type != T_PROGRAM) {
2416d81998-01-27Fredrik Hübinette (Hubbe)  do_inherit(s,flags,name);
61e9a01998-01-25Fredrik Hübinette (Hubbe)  return; }else{ p=s->u.program; } }else{ yyerror("Inherit identifier is not a constant program"); return; } low_inherit(p, 0, 0, n->u.integer.a, flags, name); break; } default: resolv_program(n); do_inherit(sp-1, flags, name); pop_stack(); } }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void simple_do_inherit(struct pike_string *s, INT32 flags, struct pike_string *name)
5267b71995-08-09Fredrik Hübinette (Hubbe) { reference_shared_string(s); push_string(s);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  ref_push_string(lex.current_file);
5267b71995-08-09Fredrik Hübinette (Hubbe)  SAFE_APPLY_MASTER("handle_inherit", 2); if(sp[-1].type != T_PROGRAM) { my_yyerror("Couldn't find file to inherit %s",s->str); pop_stack(); return; } if(name) { free_string(s); s=name; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  do_inherit(sp-1, flags, s);
d2c6081996-11-07Fredrik Hübinette (Hubbe)  free_string(s);
5267b71995-08-09Fredrik Hübinette (Hubbe)  pop_stack(); } /* * Return the index of the identifier found, otherwise -1. */
06983f1996-09-22Fredrik Hübinette (Hubbe) int isidentifier(struct pike_string *s)
5267b71995-08-09Fredrik Hübinette (Hubbe) { INT32 e;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=new_program->num_identifier_references-1;e>=0;e--)
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(new_program->identifier_references[e].id_flags & ID_HIDDEN) continue;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(ID_FROM_INT(new_program, e)->name == s)
5267b71995-08-09Fredrik Hübinette (Hubbe)  return e; } return -1; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* argument must be a shared string */
d4828c1997-07-17Fredrik Hübinette (Hubbe) int low_define_variable(struct pike_string *name, struct pike_string *type, INT32 flags, INT32 offset, INT32 run_time_type) { int n;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
d4828c1997-07-17Fredrik Hübinette (Hubbe)  struct identifier dummy; struct reference ref;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  #ifdef DEBUG if(new_program->flags & (PROGRAM_FIXED | PROGRAM_OPTIMIZED)) fatal("Attempting to add variable to fixed program\n");
22edc21998-01-29Fredrik Hübinette (Hubbe)  if(compiler_pass==2) fatal("Internal error: Not allowed to add more identifiers during second compiler pass.\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif
d4828c1997-07-17Fredrik Hübinette (Hubbe)  copy_shared_string(dummy.name, name); copy_shared_string(dummy.type, type);
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  dummy.identifier_flags = 0;
d4828c1997-07-17Fredrik Hübinette (Hubbe)  dummy.run_time_type=run_time_type; dummy.func.offset=offset;
be478c1997-08-30Henrik Grubbström (Grubba) #ifdef PROFILING
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  dummy.num_calls=0;
a2a8801998-03-18Per Hedbor  dummy.total_time=0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif
be478c1997-08-30Henrik Grubbström (Grubba) 
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  ref.id_flags=flags;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  ref.identifier_offset=new_program->num_identifiers;
d4828c1997-07-17Fredrik Hübinette (Hubbe)  ref.inherit_offset=0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_identifiers(dummy); n=new_program->num_identifier_references; add_to_identifier_references(ref);
d4828c1997-07-17Fredrik Hübinette (Hubbe)  return n; } int map_variable(char *name, char *type, INT32 flags, INT32 offset, INT32 run_time_type) { int ret; struct pike_string *n,*t; n=make_shared_string(name); t=parse_type(type); run_time_type=compile_type_to_runtime_type(t); ret=low_define_variable(n,t,flags,offset,run_time_type); free_string(n); free_string(t); return ret; }
5267b71995-08-09Fredrik Hübinette (Hubbe) /* argument must be a shared string */
06983f1996-09-22Fredrik Hübinette (Hubbe) int define_variable(struct pike_string *name, struct pike_string *type,
5267b71995-08-09Fredrik Hübinette (Hubbe)  INT32 flags) {
61e9a01998-01-25Fredrik Hübinette (Hubbe)  int n, run_time_type;
5267b71995-08-09Fredrik Hübinette (Hubbe)  #ifdef DEBUG if(name!=debug_findstring(name)) fatal("define_variable on nonshared string.\n"); #endif if(type == void_type_string) yyerror("Variables can't be of type void"); n = isidentifier(name);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(new_program->flags & PROGRAM_PASS_1_DONE) { if(n==-1) yyerror("Pass2: Variable disappeared!"); else return n; } #ifdef DEBUG if(new_program->flags & (PROGRAM_FIXED | PROGRAM_OPTIMIZED)) fatal("Attempting to add variable to fixed program\n"); #endif
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(n != -1) {
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if (IDENTIFIERP(n)->id_flags & ID_NOMASK)
5267b71995-08-09Fredrik Hübinette (Hubbe)  my_yyerror("Illegal to redefine 'nomask' variable/functions \"%s\"", name->str);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(PROG_FROM_INT(new_program, n) == new_program)
27bd811996-10-09Fredrik Hübinette (Hubbe)  my_yyerror("Variable '%s' defined twice.",name->str);
5267b71995-08-09Fredrik Hübinette (Hubbe) 
22edc21998-01-29Fredrik Hübinette (Hubbe)  if(!(IDENTIFIERP(n)->id_flags & ID_INLINE) || compiler_pass!=1)
61e9a01998-01-25Fredrik Hübinette (Hubbe)  { if(ID_FROM_INT(new_program, n)->type != type) my_yyerror("Illegal to redefine inherited variable with different type."); if(ID_FROM_INT(new_program, n)->identifier_flags != flags) my_yyerror("Illegal to redefine inherited variable with different type."); return n; } }
5267b71995-08-09Fredrik Hübinette (Hubbe) 
61e9a01998-01-25Fredrik Hübinette (Hubbe)  run_time_type=compile_type_to_runtime_type(type);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
61e9a01998-01-25Fredrik Hübinette (Hubbe)  switch(run_time_type) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  case T_FUNCTION: case T_PROGRAM: run_time_type = T_MIXED;
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  n=low_define_variable(name,type,flags,
1994981998-04-07Fredrik Hübinette (Hubbe)  low_add_storage(sizeof_variable(run_time_type), alignof_variable(run_time_type)),
61e9a01998-01-25Fredrik Hübinette (Hubbe)  run_time_type);
5267b71995-08-09Fredrik Hübinette (Hubbe)  return n; }
5740881998-01-01Fredrik Hübinette (Hubbe) int simple_add_variable(char *name, char *type, INT32 flags) { INT32 ret; struct pike_string *name_s, *type_s; name_s=make_shared_string(name); type_s=parse_type(type); ret=define_variable(name_s, type_s, flags); free_string(name_s); free_string(type_s); return ret; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) /* FIXME: add_constant with c==0 means declaration */
d2c6081996-11-07Fredrik Hübinette (Hubbe) int add_constant(struct pike_string *name, struct svalue *c, INT32 flags) { int n;
2d12341997-03-10Fredrik Hübinette (Hubbe)  struct identifier dummy; struct reference ref;
d2c6081996-11-07Fredrik Hübinette (Hubbe)  #ifdef DEBUG if(name!=debug_findstring(name))
e43ca21996-11-15Fredrik Hübinette (Hubbe)  fatal("define_constant on nonshared string.\n");
d2c6081996-11-07Fredrik Hübinette (Hubbe) #endif n = isidentifier(name);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(new_program->flags & PROGRAM_PASS_1_DONE) { if(n==-1) { yyerror("Pass2: Constant disappeared!"); }else{ #if 1 struct identifier *id; id=ID_FROM_INT(new_program,n); if(id->func.offset>=0) { struct pike_string *s; struct svalue *c=PROG_FROM_INT(new_program,n)->constants+ id->func.offset; s=get_type_of_svalue(c); free_string(id->type); id->type=s; } #endif return n; } } #ifdef DEBUG if(new_program->flags & (PROGRAM_FIXED | PROGRAM_OPTIMIZED)) fatal("Attempting to add constant to fixed program\n");
22edc21998-01-29Fredrik Hübinette (Hubbe)  if(compiler_pass==2) fatal("Internal error: Not allowed to add more identifiers during second compiler pass.\n");
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif
2d12341997-03-10Fredrik Hübinette (Hubbe)  copy_shared_string(dummy.name, name); dummy.type = get_type_of_svalue(c);
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  dummy.identifier_flags = IDENTIFIER_CONSTANT;
2d12341997-03-10Fredrik Hübinette (Hubbe)  dummy.run_time_type=c->type; dummy.func.offset=store_constant(c, 0);
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  ref.id_flags=flags;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  ref.identifier_offset=new_program->num_identifiers;
2d12341997-03-10Fredrik Hübinette (Hubbe)  ref.inherit_offset=0;
a2a8801998-03-18Per Hedbor #ifdef PROFILING
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  dummy.num_calls=0;
a2a8801998-03-18Per Hedbor  dummy.total_time=0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif add_to_identifiers(dummy);
2d12341997-03-10Fredrik Hübinette (Hubbe) 
d2c6081996-11-07Fredrik Hübinette (Hubbe)  if(n != -1) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(IDENTIFIERP(n)->id_flags & ID_NOMASK)
d2c6081996-11-07Fredrik Hübinette (Hubbe)  my_yyerror("Illegal to redefine 'nomask' identifier \"%s\"", name->str);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(PROG_FROM_INT(new_program, n) == new_program)
d2c6081996-11-07Fredrik Hübinette (Hubbe)  my_yyerror("Identifier '%s' defined twice.",name->str);
61e9a01998-01-25Fredrik Hübinette (Hubbe)  if(!(IDENTIFIERP(n)->id_flags & ID_INLINE)) { /* override */ new_program->identifier_references[n]=ref; return n; }
d2c6081996-11-07Fredrik Hübinette (Hubbe)  }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  n=new_program->num_identifier_references; add_to_identifier_references(ref);
d2c6081996-11-07Fredrik Hübinette (Hubbe)  return n; }
0683be1997-01-26Fredrik Hübinette (Hubbe) int simple_add_constant(char *name, struct svalue *c, INT32 flags) { INT32 ret; struct pike_string *id; id=make_shared_string(name); ret=add_constant(id, c, flags); free_string(id); return ret; }
e43ca21996-11-15Fredrik Hübinette (Hubbe) int add_integer_constant(char *name, INT32 i, INT32 flags) { struct svalue tmp; tmp.u.integer=i; tmp.type=T_INT; tmp.subtype=NUMBER_NUMBER;
0683be1997-01-26Fredrik Hübinette (Hubbe)  return simple_add_constant(name, &tmp, flags);
e43ca21996-11-15Fredrik Hübinette (Hubbe) }
0683be1997-01-26Fredrik Hübinette (Hubbe) int add_float_constant(char *name, double f, INT32 flags) { struct svalue tmp; tmp.type=T_FLOAT; tmp.u.float_number=f; tmp.subtype=0; return simple_add_constant(name, &tmp, flags); } int add_string_constant(char *name, char *str, INT32 flags) { INT32 ret; struct svalue tmp; tmp.type=T_STRING; tmp.subtype=0; tmp.u.string=make_shared_string(str); ret=simple_add_constant(name, &tmp, flags); free_svalue(&tmp); return ret; }
e43ca21996-11-15Fredrik Hübinette (Hubbe) 
5c0a101997-02-06Fredrik Hübinette (Hubbe) int add_program_constant(char *name, struct program *p, INT32 flags) { INT32 ret; struct svalue tmp; tmp.type=T_PROGRAM; tmp.subtype=0; tmp.u.program=p; ret=simple_add_constant(name, &tmp, flags); return ret; }
f0c3d31998-04-05Fredrik Hübinette (Hubbe) int add_object_constant(char *name, struct object *o, INT32 flags) { INT32 ret; struct svalue tmp; tmp.type=T_OBJECT; tmp.subtype=0; tmp.u.object=o; ret=simple_add_constant(name, &tmp, flags); return ret; }
c152401997-02-10Fredrik Hübinette (Hubbe) int add_function_constant(char *name, void (*cfun)(INT32), char * type, INT16 flags) { struct svalue s; struct pike_string *n; INT32 ret; s.type=T_FUNCTION; s.subtype=FUNCTION_BUILTIN; s.u.efun=make_callable(cfun, name, type, flags, 0, 0); ret=simple_add_constant(name, &s, 0); free_svalue(&s); return ret; }
3c0c281998-01-26Fredrik Hübinette (Hubbe) int debug_end_class(char *name, INT32 flags)
5c0a101997-02-06Fredrik Hübinette (Hubbe) { INT32 ret; struct svalue tmp; tmp.type=T_PROGRAM; tmp.subtype=0; tmp.u.program=end_program();
f839fa1997-02-28Fredrik Hübinette (Hubbe)  if(!tmp.u.program) fatal("Failed to initialize class '%s'\n",name);
5c0a101997-02-06Fredrik Hübinette (Hubbe)  ret=simple_add_constant(name, &tmp, flags); free_svalue(&tmp); return ret; }
5267b71995-08-09Fredrik Hübinette (Hubbe) /* * define a new function * if func isn't given, it is supposed to be a prototype. */
06983f1996-09-22Fredrik Hübinette (Hubbe) INT32 define_function(struct pike_string *name, struct pike_string *type,
5267b71995-08-09Fredrik Hübinette (Hubbe)  INT16 flags, INT8 function_flags, union idptr *func) { struct identifier *funp,fun; struct reference ref; INT32 i;
a2a8801998-03-18Per Hedbor #ifdef PROFILING fun.num_calls=0; fun.total_time=0; #endif
5267b71995-08-09Fredrik Hübinette (Hubbe)  i=isidentifier(name); if(i >= 0) { /* already defined */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  funp=ID_FROM_INT(new_program, i); ref=new_program->identifier_references[i];
5267b71995-08-09Fredrik Hübinette (Hubbe) 
2acdd31995-10-29Fredrik Hübinette (Hubbe)  if(ref.inherit_offset == 0) /* not inherited */
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
2acdd31995-10-29Fredrik Hübinette (Hubbe)  if(!(!func || func->offset == -1) && !(funp->func.offset == -1)) { my_yyerror("Redeclaration of function %s.",name->str); return i; }
5267b71995-08-09Fredrik Hübinette (Hubbe)  /* match types against earlier prototype or vice versa */
0d202a1995-10-20Fredrik Hübinette (Hubbe)  if(!match_types(type, funp->type))
5267b71995-08-09Fredrik Hübinette (Hubbe)  { my_yyerror("Prototype doesn't match for function %s.",name->str); } }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if((ref.id_flags & ID_NOMASK) && !(funp->func.offset == -1))
5267b71995-08-09Fredrik Hübinette (Hubbe)  { my_yyerror("Illegal to redefine 'nomask' function %s.",name->str); }
22edc21998-01-29Fredrik Hübinette (Hubbe)  if(!(ref.id_flags & ID_INLINE) || compiler_pass!=1)
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
61e9a01998-01-25Fredrik Hübinette (Hubbe)  /* We modify the old definition if it is in this program */ if(ref.inherit_offset==0) { if(func) funp->func = *func; else funp->func.offset = -1; funp->identifier_flags=function_flags; }else{ /* Otherwise we make a new definition */ copy_shared_string(fun.name, name); copy_shared_string(fun.type, type); fun.run_time_type=T_FUNCTION; fun.identifier_flags=function_flags; if(func) fun.func = *func; else fun.func.offset = -1; ref.identifier_offset=new_program->num_identifiers; add_to_identifiers(fun); } ref.inherit_offset = 0; ref.id_flags = flags; new_program->identifier_references[i]=ref; return i;
5267b71995-08-09Fredrik Hübinette (Hubbe)  }
61e9a01998-01-25Fredrik Hübinette (Hubbe)  }
5267b71995-08-09Fredrik Hübinette (Hubbe) 
22edc21998-01-29Fredrik Hübinette (Hubbe) #ifdef DEBUG if(compiler_pass==2) fatal("Internal error: Not allowed to add more identifiers during second compiler pass.\n"); #endif
61e9a01998-01-25Fredrik Hübinette (Hubbe)  /* define a new function */
5267b71995-08-09Fredrik Hübinette (Hubbe) 
61e9a01998-01-25Fredrik Hübinette (Hubbe)  copy_shared_string(fun.name, name); copy_shared_string(fun.type, type); fun.identifier_flags=function_flags; fun.run_time_type=T_FUNCTION; if(func) fun.func = *func; else fun.func.offset = -1; i=new_program->num_identifiers; add_to_identifiers(fun); ref.id_flags = flags; ref.identifier_offset = i; ref.inherit_offset = 0; i=new_program->num_identifier_references; add_to_identifier_references(ref);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe)  return i; } /* * lookup the number of a function in a program given the name in * a shared_string */
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) int low_find_shared_string_identifier(struct pike_string *name, struct program *prog)
5267b71995-08-09Fredrik Hübinette (Hubbe) { int max,min,tst; struct reference *funp; struct identifier *fun;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(prog->flags & PROGRAM_FIXED)
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  unsigned short *funindex = prog->identifier_index; #ifdef DEBUG if(!funindex) fatal("No funindex in fixed program\n"); #endif max = prog->num_identifier_index;
5267b71995-08-09Fredrik Hübinette (Hubbe)  min = 0; while(max != min) { tst=(max + min) >> 1; fun = ID_FROM_INT(prog, funindex[tst]); if(is_same_string(fun->name,name)) return funindex[tst]; if(my_order_strcmp(fun->name, name) > 0) max=tst; else min=tst+1; } }else{ int i,t;
5c8e891995-10-29Fredrik Hübinette (Hubbe)  for(i=0;i<(int)prog->num_identifier_references;i++)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { funp = prog->identifier_references + i;
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(funp->id_flags & ID_HIDDEN) continue;
5267b71995-08-09Fredrik Hübinette (Hubbe)  fun = ID_FROM_PTR(prog, funp);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  /* if(fun->func.offset == -1) continue; * Prototype */
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(!is_same_string(fun->name,name)) continue;
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(funp->id_flags & ID_INHERITED)
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(funp->id_flags & ID_PRIVATE) continue;
b8048b1997-09-07Fredrik Hübinette (Hubbe)  for(t=0; t>=0 && t<(int)prog->num_identifier_references; t++)
5267b71995-08-09Fredrik Hübinette (Hubbe)  {
b8048b1997-09-07Fredrik Hübinette (Hubbe)  struct reference *funpb; struct identifier *funb; if(t==i) continue; funpb=prog->identifier_references+t;
7fda7a1997-09-08Fredrik Hübinette (Hubbe)  if(funpb->id_flags & (ID_HIDDEN|ID_STATIC)) continue; if((funpb->id_flags & ID_INHERITED) && t<i) continue;
b8048b1997-09-07Fredrik Hübinette (Hubbe)  funb=ID_FROM_PTR(prog,funpb); /* if(funb->func.offset == -1) continue; * prototype */ if(fun->name==funb->name) t=-10;
5267b71995-08-09Fredrik Hübinette (Hubbe)  } if(t < 0) continue; } return i; } } return -1; } #ifdef FIND_FUNCTION_HASHSIZE #if FIND_FUNCTION_HASHSIZE == 0 #undef FIND_FUNCTION_HASHSIZE #endif #endif #ifdef FIND_FUNCTION_HASHSIZE struct ff_hash {
06983f1996-09-22Fredrik Hübinette (Hubbe)  struct pike_string *name;
5267b71995-08-09Fredrik Hübinette (Hubbe)  int id; int fun; }; static struct ff_hash cache[FIND_FUNCTION_HASHSIZE]; #endif
06983f1996-09-22Fredrik Hübinette (Hubbe) int find_shared_string_identifier(struct pike_string *name,
5267b71995-08-09Fredrik Hübinette (Hubbe)  struct program *prog) { #ifdef FIND_FUNCTION_HASHSIZE
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(prog -> flags & PROGRAM_FIXED)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { unsigned int hashval; hashval=my_hash_string(name); hashval+=prog->id;
f90e541995-08-17Fredrik Hübinette (Hubbe)  hashval^=(unsigned long)prog;
5267b71995-08-09Fredrik Hübinette (Hubbe)  hashval-=name->str[0]; hashval%=FIND_FUNCTION_HASHSIZE; if(is_same_string(cache[hashval].name,name) && cache[hashval].id==prog->id) return cache[hashval].fun; if(cache[hashval].name) free_string(cache[hashval].name); copy_shared_string(cache[hashval].name,name); cache[hashval].id=prog->id; return cache[hashval].fun=low_find_shared_string_identifier(name,prog); } #endif /* FIND_FUNCTION_HASHSIZE */ return low_find_shared_string_identifier(name,prog); } int find_identifier(char *name,struct program *prog) {
06983f1996-09-22Fredrik Hübinette (Hubbe)  struct pike_string *n;
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(!prog)
24697f1997-03-12Henrik Grubbström (Grubba)  error("Lookup of identifier %s in destructed object.\n", name);
5267b71995-08-09Fredrik Hübinette (Hubbe)  n=findstring(name); if(!n) return -1; return find_shared_string_identifier(n,prog); }
06983f1996-09-22Fredrik Hübinette (Hubbe) int store_prog_string(struct pike_string *str)
5267b71995-08-09Fredrik Hübinette (Hubbe) { unsigned int i;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for (i=0;i<new_program->num_strings;i++) if (new_program->strings[i] == str)
5267b71995-08-09Fredrik Hübinette (Hubbe)  return i; reference_shared_string(str);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_strings(str);
5267b71995-08-09Fredrik Hübinette (Hubbe)  return i; }
5683de1995-11-06Fredrik Hübinette (Hubbe) int store_constant(struct svalue *foo, int equal)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  struct svalue tmp;
5267b71995-08-09Fredrik Hübinette (Hubbe)  unsigned int e;
5683de1995-11-06Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=0;e<new_program->num_constants;e++) { struct svalue *s=new_program->constants + e; if(equal ? is_equal(s,foo) : is_eq(s,foo))
5267b71995-08-09Fredrik Hübinette (Hubbe)  return e;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  }
5267b71995-08-09Fredrik Hübinette (Hubbe)  assign_svalue_no_free(&tmp,foo);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_constants(tmp);
5267b71995-08-09Fredrik Hübinette (Hubbe)  return e; } /* * Line number support routines, now also tells what file we are in */ static int get_small_number(char **q) { int ret; switch(ret=(*(signed char **)q)++[0]) { case -127: ret=EXTRACT_WORD((unsigned char*)*q); *q+=2; return ret; case -128: ret=EXTRACT_INT((unsigned char*)*q); *q+=4; return ret; default: return ret; } } void start_line_numbering(void) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(last_file)
ea32c11998-04-13Henrik Grubbström (Grubba)  { free_string(last_file); last_file=0; }
5267b71995-08-09Fredrik Hübinette (Hubbe)  last_pc=last_line=0; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) static void insert_small_number(INT32 a)
5267b71995-08-09Fredrik Hübinette (Hubbe) { if(a>-127 && a<127) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_linenumbers(a);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }else if(a>=-32768 && a<32768){
aeeef31998-01-16Fredrik Hübinette (Hubbe)  add_to_linenumbers(-127);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  ins_short(a, add_to_linenumbers);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }else{
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_linenumbers(-128); ins_int(a, add_to_linenumbers);
5267b71995-08-09Fredrik Hübinette (Hubbe)  } }
06983f1996-09-22Fredrik Hübinette (Hubbe) void store_linenumber(INT32 current_line, struct pike_string *current_file)
5267b71995-08-09Fredrik Hübinette (Hubbe) { if(last_line!=current_line || last_file != current_file) { if(last_file != current_file) { char *tmp; if(last_file) free_string(last_file);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  add_to_linenumbers(127); for(tmp=current_file->str; *tmp; tmp++) add_to_linenumbers(*tmp); add_to_linenumbers(0);
5267b71995-08-09Fredrik Hübinette (Hubbe)  copy_shared_string(last_file, current_file); }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  insert_small_number(PC-last_pc); insert_small_number(current_line-last_line);
5267b71995-08-09Fredrik Hübinette (Hubbe)  last_line=current_line; last_pc=PC; } } /* * return the file in which we were executing. * pc should be the program counter, prog the current * program, and line will be initialized to the line * in that file. */ char *get_line(unsigned char *pc,struct program *prog,INT32 *linep) {
9e52381998-03-01Fredrik Hübinette (Hubbe)  static char *file, *cnt; static INT32 off,line,pid; INT32 offset;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
5683de1995-11-06Fredrik Hübinette (Hubbe)  if (prog == 0) return "Unkown program";
5267b71995-08-09Fredrik Hübinette (Hubbe)  offset = pc - prog->program;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(prog == new_program)
5267b71995-08-09Fredrik Hübinette (Hubbe)  { linep[0]=0; return "Optimizer"; }
9e52381998-03-01Fredrik Hübinette (Hubbe)  if(prog->id != pid || offset < off) { cnt=prog->linenumbers; off=line=0; file="Line not found"; pid=prog->id; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if (offset > (INT32)prog->num_program || offset<0) return file;
5267b71995-08-09Fredrik Hübinette (Hubbe)  while(cnt < prog->linenumbers + prog->num_linenumbers) {
f0c3d31998-04-05Fredrik Hübinette (Hubbe)  int oline;
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(*cnt == 127) { file=cnt+1; cnt=file+strlen(file)+1; } off+=get_small_number(&cnt);
f0c3d31998-04-05Fredrik Hübinette (Hubbe)  oline=line;
5267b71995-08-09Fredrik Hübinette (Hubbe)  line+=get_small_number(&cnt);
f0c3d31998-04-05Fredrik Hübinette (Hubbe)  if(off > offset) { linep[0]=oline; return file; }
5267b71995-08-09Fredrik Hübinette (Hubbe)  } linep[0]=line; return file; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) void my_yyerror(char *fmt,...) ATTRIBUTE((format(printf,1,2)))
5267b71995-08-09Fredrik Hübinette (Hubbe) { va_list args;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  char buf[8192];
5267b71995-08-09Fredrik Hübinette (Hubbe)  va_start(args,fmt); VSPRINTF(buf,fmt,args);
197d171996-05-16Fredrik Hübinette (Hubbe)  if((long)strlen(buf) >= (long)sizeof(buf))
5267b71995-08-09Fredrik Hübinette (Hubbe)  fatal("Buffer overflow in my_yyerror."); yyerror(buf); va_end(args); }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) struct program *compile(struct pike_string *prog)
5267b71995-08-09Fredrik Hübinette (Hubbe) { struct program *p;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  struct lex save_lex; int save_depth=compilation_depth; void yyparse(void);
ea32c11998-04-13Henrik Grubbström (Grubba)  ONERROR just_in_case;
624d091996-02-24Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  save_lex=lex;
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  lex.end=prog->str+prog->len; lex.current_line=1; lex.current_file=make_shared_string("-"); lex.pragmas=0;
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
ea32c11998-04-13Henrik Grubbström (Grubba)  threads_disabled++; SET_ONERROR(just_in_case, restore_threads_disabled, NULL); /* fprintf(stderr, "compile() Enter: threads_disabled:%d, compilation_depth:%d\n", threads_disabled, compilation_depth); */
2acdd31995-10-29Fredrik Hübinette (Hubbe)  start_new_program();
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  compilation_depth=0;
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  start_line_numbering();
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  compiler_pass=1; lex.pos=prog->str; yyparse(); /* Parse da program */
5267b71995-08-09Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  p=end_first_pass(0); if(p && !num_parse_error) { low_start_new_program(p,0,0);
61e9a01998-01-25Fredrik Hübinette (Hubbe)  free_program(p); p=0;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  compiler_pass=2; lex.pos=prog->str; yyparse(); /* Parse da program again */ p=end_program(); }
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
ea32c11998-04-13Henrik Grubbström (Grubba)  threads_disabled--;
31df251998-04-13Henrik Grubbström (Grubba)  /* fprintf(stderr, "compile() Leave: threads_disabled:%d, compilation_depth:%d\n", threads_disabled, compilation_depth); */
ea32c11998-04-13Henrik Grubbström (Grubba)  co_signal(&threads_disabled_change); UNSET_ONERROR(just_in_case);
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  free_string(lex.current_file); lex=save_lex;
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  compilation_depth=save_depth;
5c8e891995-10-29Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe)  if(!p) error("Compilation failed.\n"); return p; }
e964ae1998-04-08Fredrik Hübinette (Hubbe) int add_function(char *name,void (*cfun)(INT32),char *type,INT16 flags)
5267b71995-08-09Fredrik Hübinette (Hubbe) {
e964ae1998-04-08Fredrik Hübinette (Hubbe)  int ret;
06983f1996-09-22Fredrik Hübinette (Hubbe)  struct pike_string *name_tmp,*type_tmp;
5267b71995-08-09Fredrik Hübinette (Hubbe)  union idptr tmp; name_tmp=make_shared_string(name); type_tmp=parse_type(type); if(cfun) { tmp.c_fun=cfun;
e964ae1998-04-08Fredrik Hübinette (Hubbe)  ret=define_function(name_tmp, type_tmp, flags, IDENTIFIER_C_FUNCTION, &tmp);
5267b71995-08-09Fredrik Hübinette (Hubbe)  }else{
e964ae1998-04-08Fredrik Hübinette (Hubbe)  ret=define_function(name_tmp, type_tmp, flags, IDENTIFIER_C_FUNCTION, 0);
5267b71995-08-09Fredrik Hübinette (Hubbe)  } free_string(name_tmp); free_string(type_tmp);
e964ae1998-04-08Fredrik Hübinette (Hubbe)  return ret;
5267b71995-08-09Fredrik Hübinette (Hubbe) } #ifdef DEBUG
be478c1997-08-30Henrik Grubbström (Grubba) void check_all_programs(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) { struct program *p; for(p=first_program;p;p=p->next)
624d091996-02-24Fredrik Hübinette (Hubbe)  check_program(p);
5d0e211997-04-10Fredrik Hübinette (Hubbe)  #ifdef FIND_FUNCTION_HASHSIZE { unsigned long e; for(e=0;e<FIND_FUNCTION_HASHSIZE;e++) { if(cache[e].name) { check_string(cache[e].name); if(cache[e].id<0 || cache[e].id > current_program_id)
1f64351997-04-14Fredrik Hübinette (Hubbe)  fatal("Error in find_function_cache[%ld].id\n",(long)e);
5d0e211997-04-10Fredrik Hübinette (Hubbe) 
d2a0841997-04-10Fredrik Hübinette (Hubbe)  if(cache[e].fun < -1 || cache[e].fun > 65536)
1f64351997-04-14Fredrik Hübinette (Hubbe)  fatal("Error in find_function_cache[%ld].fun\n",(long)e);
5d0e211997-04-10Fredrik Hübinette (Hubbe)  } } } #endif
5267b71995-08-09Fredrik Hübinette (Hubbe) } #endif
be478c1997-08-30Henrik Grubbström (Grubba) void cleanup_program(void)
5267b71995-08-09Fredrik Hübinette (Hubbe) { int e;
61e9a01998-01-25Fredrik Hübinette (Hubbe) #ifdef FIND_FUNCTION_HASHSIZE
5267b71995-08-09Fredrik Hübinette (Hubbe)  for(e=0;e<FIND_FUNCTION_HASHSIZE;e++) { if(cache[e].name) { free_string(cache[e].name); cache[e].name=0; } } #endif
61e9a01998-01-25Fredrik Hübinette (Hubbe) 
5267b71995-08-09Fredrik Hübinette (Hubbe) }
624d091996-02-24Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #ifdef GC2
c94c371996-03-28Fredrik Hübinette (Hubbe) void gc_mark_program_as_referenced(struct program *p)
624d091996-02-24Fredrik Hübinette (Hubbe) {
c94c371996-03-28Fredrik Hübinette (Hubbe)  if(gc_mark(p))
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  { int e;
c94c371996-03-28Fredrik Hübinette (Hubbe)  gc_mark_svalues(p->constants, p->num_constants);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=0;e<p->num_inherits;e++) { if(p->inherits[e].parent) gc_mark_object_as_referenced(p->inherits[e].parent); if(e) gc_mark_program_as_referenced(p->inherits[e].prog); } }
624d091996-02-24Fredrik Hübinette (Hubbe) }
be478c1997-08-30Henrik Grubbström (Grubba) void gc_check_all_programs(void)
624d091996-02-24Fredrik Hübinette (Hubbe) {
c94c371996-03-28Fredrik Hübinette (Hubbe)  struct program *p; for(p=first_program;p;p=p->next)
9367351997-01-27Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  int e;
0b69441998-01-19Fredrik Hübinette (Hubbe)  debug_gc_check_svalues(p->constants, p->num_constants, T_PROGRAM, p);
9367351997-01-27Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=0;e<p->num_inherits;e++) { if(p->inherits[e].parent) {
3568101997-10-16Fredrik Hübinette (Hubbe) #ifdef DEBUG
0b69441998-01-19Fredrik Hübinette (Hubbe)  if(debug_gc_check(p->inherits[e].parent,T_PROGRAM,p)==-2)
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  fprintf(stderr,"(program at 0x%lx -> inherit[%d].parent)\n", (long)p, e); #else
0b69441998-01-19Fredrik Hübinette (Hubbe)  debug_gc_check(p->inherits[e].parent, T_PROGRAM, p);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif } if(d_flag && p->inherits[e].name)
0b69441998-01-19Fredrik Hübinette (Hubbe)  debug_gc_check(p->inherits[e].name, T_PROGRAM, p);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  if(e)
0b69441998-01-19Fredrik Hübinette (Hubbe)  debug_gc_check(p->inherits[e].prog, T_PROGRAM, p);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  }
0b69441998-01-19Fredrik Hübinette (Hubbe) #ifdef DEBUG
9367351997-01-27Fredrik Hübinette (Hubbe)  if(d_flag) { int e; for(e=0;e<(int)p->num_strings;e++)
0b69441998-01-19Fredrik Hübinette (Hubbe)  debug_gc_check(p->strings[e], T_PROGRAM, p);
9367351997-01-27Fredrik Hübinette (Hubbe)  for(e=0;e<(int)p->num_identifiers;e++) {
0b69441998-01-19Fredrik Hübinette (Hubbe)  debug_gc_check(p->identifiers[e].name, T_PROGRAM, p); debug_gc_check(p->identifiers[e].type, T_PROGRAM, p);
9367351997-01-27Fredrik Hübinette (Hubbe)  } }
0b69441998-01-19Fredrik Hübinette (Hubbe) #endif
9367351997-01-27Fredrik Hübinette (Hubbe)  }
c94c371996-03-28Fredrik Hübinette (Hubbe) }
be478c1997-08-30Henrik Grubbström (Grubba) void gc_mark_all_programs(void)
c94c371996-03-28Fredrik Hübinette (Hubbe) { struct program *p; for(p=first_program;p;p=p->next) if(gc_is_referenced(p)) gc_mark_program_as_referenced(p); }
be478c1997-08-30Henrik Grubbström (Grubba) void gc_free_all_unreferenced_programs(void)
c94c371996-03-28Fredrik Hübinette (Hubbe) { struct program *p,*next;
624d091996-02-24Fredrik Hübinette (Hubbe)  for(p=first_program;p;p=next) {
c94c371996-03-28Fredrik Hübinette (Hubbe)  if(gc_do_free(p))
624d091996-02-24Fredrik Hübinette (Hubbe)  {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  int e;
624d091996-02-24Fredrik Hübinette (Hubbe)  p->refs++;
c94c371996-03-28Fredrik Hübinette (Hubbe)  free_svalues(p->constants, p->num_constants, -1);
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  for(e=0;e<p->num_inherits;e++) { if(p->inherits[e].parent) { free_object(p->inherits[e].parent); p->inherits[e].parent=0; } }
624d091996-02-24Fredrik Hübinette (Hubbe)  next=p->next; free_program(p); }else{ next=p->next; } } }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe) #endif /* GC2 */
c3c7031996-12-04Fredrik Hübinette (Hubbe)  void count_memory_in_programs(INT32 *num_, INT32 *size_) { INT32 size=0, num=0; struct program *p; for(p=first_program;p;p=p->next) { num++; size+=p->total_size; } *num_=num; *size_=size; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  void push_compiler_frame(void) { struct compiler_frame *f; f=ALLOC_STRUCT(compiler_frame); f->current_type=0; f->current_return_type=0; f->current_number_of_locals=0; f->max_number_of_locals=0; f->previous=compiler_frame; compiler_frame=f; } void pop_local_variables(int level)
329cc01997-02-17Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  while(compiler_frame->current_number_of_locals > level) { int e; e=--(compiler_frame->current_number_of_locals); free_string(compiler_frame->variable[e].name); free_string(compiler_frame->variable[e].type); }
329cc01997-02-17Fredrik Hübinette (Hubbe) }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  void pop_compiler_frame(void)
329cc01997-02-17Fredrik Hübinette (Hubbe) {
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  struct compiler_frame *f; int e; f=compiler_frame; #ifdef DEBUG if(!f) fatal("Popping out of compiler frames\n"); #endif
329cc01997-02-17Fredrik Hübinette (Hubbe) 
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  pop_local_variables(0); if(f->current_type) free_string(f->current_type); if(f->current_return_type) free_string(f->current_return_type); compiler_frame=f->previous; free((char *)f);
329cc01997-02-17Fredrik Hübinette (Hubbe) }
cff0d71997-03-23Fredrik Hübinette (Hubbe)  #define GET_STORAGE_CACHE_SIZE 1024 static struct get_storage_cache { INT32 oid, pid, offset; } get_storage_cache[GET_STORAGE_CACHE_SIZE];
6bc9281998-04-10Fredrik Hübinette (Hubbe) int low_get_storage(struct program *o, struct program *p)
cff0d71997-03-23Fredrik Hübinette (Hubbe) { INT32 oid,pid, offset; unsigned INT32 hval;
6bc9281998-04-10Fredrik Hübinette (Hubbe)  if(!o) return 0; oid=o->id;
cff0d71997-03-23Fredrik Hübinette (Hubbe)  pid=p->id;
535d171997-09-11Fredrik Hübinette (Hubbe)  hval=oid*9248339 + pid;
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  hval%=GET_STORAGE_CACHE_SIZE;
535d171997-09-11Fredrik Hübinette (Hubbe) #ifdef DEBUG if(hval>GET_STORAGE_CACHE_SIZE) fatal("hval>GET_STORAGE_CACHE_SIZE"); #endif
cff0d71997-03-23Fredrik Hübinette (Hubbe)  if(get_storage_cache[hval].oid == oid && get_storage_cache[hval].pid == pid) { offset=get_storage_cache[hval].offset; }else{ INT32 e; offset=-1;
6bc9281998-04-10Fredrik Hübinette (Hubbe)  for(e=0;e<o->num_inherits;e++)
cff0d71997-03-23Fredrik Hübinette (Hubbe)  {
6bc9281998-04-10Fredrik Hübinette (Hubbe)  if(o->inherits[e].prog==p)
cff0d71997-03-23Fredrik Hübinette (Hubbe)  {
6bc9281998-04-10Fredrik Hübinette (Hubbe)  offset=o->inherits[e].storage_offset;
cff0d71997-03-23Fredrik Hübinette (Hubbe)  break; } } get_storage_cache[hval].oid=oid; get_storage_cache[hval].pid=pid; get_storage_cache[hval].offset=offset; }
6bc9281998-04-10Fredrik Hübinette (Hubbe)  return offset; } char *get_storage(struct object *o, struct program *p) { int offset= low_get_storage(o->prog, p);
cff0d71997-03-23Fredrik Hübinette (Hubbe)  if(offset == -1) return 0; return o->storage + offset; }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  struct program *low_program_from_function(struct program *p, INT32 i) { struct svalue *f; struct identifier *id=ID_FROM_INT(p, i); if(!IDENTIFIER_IS_CONSTANT(id->identifier_flags)) return 0; if(id->func.offset==-1) return 0; f=PROG_FROM_INT(p,i)->constants + id->func.offset; if(f->type!=T_PROGRAM) return 0; return f->u.program; } struct program *program_from_function(struct svalue *f) { struct identifier *id; if(f->type != T_FUNCTION) return 0; if(f->subtype == FUNCTION_BUILTIN) return 0; if(!f->u.object->prog) return 0; return low_program_from_function(f->u.object->prog, f->subtype); } struct program *program_from_svalue(struct svalue *s) { switch(s->type) {
bcf9461998-01-27Fredrik Hübinette (Hubbe)  case T_OBJECT: { struct program *p; push_svalue(s); f_object_program(1); p=program_from_svalue(sp-1); pop_stack(); return p; /* We trust that there is a reference somewhere... */ }
b1f4eb1998-01-13Fredrik Hübinette (Hubbe)  case T_FUNCTION: return program_from_function(s); case T_PROGRAM: return s->u.program; default: return 0; } } #define FIND_CHILD_HASHSIZE 5003 struct find_child_cache_s { INT32 pid,cid,id; }; static struct find_child_cache_s find_child_cache[FIND_CHILD_HASHSIZE]; int find_child(struct program *parent, struct program *child) { INT32 h=(parent->id * 9248339 + child->id) % FIND_CHILD_HASHSIZE; if(find_child_cache[h].pid == parent->id && find_child_cache[h].cid == child->id) { return find_child_cache[h].id; }else{ INT32 i; for(i=0;i<parent->num_identifier_references;i++) { if(low_program_from_function(parent, i)==child) { find_child_cache[h].pid=parent->id; find_child_cache[h].cid=child->id; find_child_cache[h].id=i; return i; } } } return -1; } void yywarning(char *fmt, ...) ATTRIBUTE((format(printf,1,2))) { char buf[4711]; va_list args; va_start(args,fmt); VSPRINTF(buf, fmt, args); va_end(args); if(strlen(buf)>sizeof(buf)) fatal("Buffer overfloat in yywarning!\n"); if(get_master()) { ref_push_string(lex.current_file); push_int(lex.current_line); push_text(buf); SAFE_APPLY_MASTER("compile_warning",3); pop_stack(); } }