169 lines
5.4 KiB
C
169 lines
5.4 KiB
C
/****************************************************************
|
|
* *
|
|
* Copyright 2001, 2011 Fidelity Information Services, Inc *
|
|
* *
|
|
* This source code contains the intellectual property *
|
|
* of its copyright holder(s), and is made available *
|
|
* under a license. If you do not know the terms of *
|
|
* the license, please stop and do not read further. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
#include "mdef.h"
|
|
|
|
#include "gtm_string.h"
|
|
|
|
#include "rtnhdr.h"
|
|
#include "mv_stent.h" /* this includes lv_val.h which also includes hashtab_mname.h and hashtab.h */
|
|
#include "stack_frame.h"
|
|
#include "mdq.h"
|
|
|
|
#define MVST_STAB_SIZE (SIZEOF(*mv_chain) - SIZEOF(mv_chain->mv_st_cont) + SIZEOF(mv_chain->mv_st_cont.mvs_stab))
|
|
|
|
GBLREF symval *curr_symval;
|
|
|
|
GBLREF mv_stent *mv_chain;
|
|
GBLREF unsigned char *stackbase, *stacktop, *msp, *stackwarn;
|
|
GBLREF stack_frame *frame_pointer;
|
|
|
|
int4 symbinit(void)
|
|
{
|
|
unsigned char *msp_save;
|
|
mv_stent *mv_st_ent, *mvst_tmp, *mvst_prev;
|
|
stack_frame *fp,*fp_prev,*fp_fix;
|
|
symval *ptr;
|
|
int4 shift_size, ls_size, temp_size;
|
|
int size;
|
|
unsigned char *old_sp, *top, *l_syms;
|
|
error_def(ERR_STACKOFLOW);
|
|
error_def(ERR_STACKCRIT);
|
|
|
|
if (frame_pointer->type & SFT_COUNT)
|
|
{
|
|
temp_size = frame_pointer->rvector->temp_size;
|
|
size = frame_pointer->vartab_len;
|
|
ls_size = size * SIZEOF(ht_ent_mname *);
|
|
if (frame_pointer->l_symtab != (ht_ent_mname **)((char *)frame_pointer - temp_size - ls_size))
|
|
{
|
|
msp_save = msp;
|
|
msp -= ls_size;
|
|
if (msp <= stackwarn)
|
|
{
|
|
if (msp <= stacktop)
|
|
{
|
|
msp = msp_save;
|
|
rts_error(VARLSTCNT(1) ERR_STACKOFLOW);
|
|
} else
|
|
rts_error(VARLSTCNT(1) ERR_STACKCRIT);
|
|
}
|
|
frame_pointer->l_symtab = (ht_ent_mname **)msp;
|
|
}
|
|
PUSH_MV_STENT(MVST_STAB);
|
|
mv_st_ent = mv_chain;
|
|
l_syms = (unsigned char *)frame_pointer->l_symtab;
|
|
shift_size = 0;
|
|
} else
|
|
{
|
|
fp = frame_pointer;
|
|
fp_prev = fp->old_frame_pointer;
|
|
assert(fp_prev);
|
|
while (!(fp_prev->type & SFT_COUNT))
|
|
{
|
|
fp = fp_prev;
|
|
fp_prev = fp->old_frame_pointer;
|
|
assert(fp_prev);
|
|
}
|
|
top = (unsigned char *)(fp + 1);
|
|
old_sp = msp;
|
|
temp_size = fp_prev->rvector->temp_size;
|
|
size = fp_prev->vartab_len;
|
|
ls_size = size * SIZEOF(ht_ent_mname *);
|
|
shift_size = MVST_STAB_SIZE;
|
|
if (fp_prev->l_symtab != (ht_ent_mname **)((char *)fp_prev - ls_size - temp_size))
|
|
shift_size += ls_size;
|
|
msp -= shift_size;
|
|
if (msp <= stackwarn)
|
|
{
|
|
if (msp <= stacktop)
|
|
{
|
|
msp = old_sp;
|
|
rts_error(VARLSTCNT(1) ERR_STACKOFLOW);
|
|
} else
|
|
rts_error(VARLSTCNT(1) ERR_STACKCRIT);
|
|
}
|
|
memcpy(msp, old_sp, top - (unsigned char *)old_sp);
|
|
if (shift_size > MVST_STAB_SIZE)
|
|
fp_prev->l_symtab = (ht_ent_mname **)(top - shift_size);
|
|
l_syms = (unsigned char *)fp_prev->l_symtab;
|
|
mv_st_ent = (mv_stent *)(top - MVST_STAB_SIZE);
|
|
mv_st_ent->mv_st_type = MVST_STAB;
|
|
ADJUST_FRAME_POINTER(frame_pointer, shift_size);
|
|
for (fp_fix = frame_pointer; fp_fix != fp_prev ;fp_fix = fp_fix->old_frame_pointer)
|
|
{
|
|
if ((unsigned char *)fp_fix->l_symtab < top && (unsigned char *)fp_fix->l_symtab > stacktop)
|
|
{
|
|
fp_fix->l_symtab = (ht_ent_mname **)((char *)fp_fix->l_symtab - shift_size);
|
|
if ((unsigned char *)fp_fix->l_symtab < (unsigned char *)fp_fix)
|
|
memset((unsigned char *)fp_fix->l_symtab, 0, fp_fix->vartab_len * SIZEOF(ht_ent_mname *));
|
|
}
|
|
if (fp_fix->temps_ptr < top && fp_fix->temps_ptr > stacktop)
|
|
fp_fix->temps_ptr -= shift_size;
|
|
if (fp_fix->vartab_ptr < (char *)top && fp_fix->vartab_ptr > (char *)stacktop)
|
|
fp_fix->vartab_ptr -= shift_size;
|
|
if ((unsigned char *)fp_fix->old_frame_pointer < top && (unsigned char *)fp_fix->old_frame_pointer
|
|
> stacktop)
|
|
{
|
|
ADJUST_FRAME_POINTER(fp_fix->old_frame_pointer, shift_size);
|
|
}
|
|
}
|
|
if ((unsigned char *)mv_chain >= top)
|
|
{
|
|
mv_st_ent->mv_st_next = (uint4)((char *)mv_chain - (char *)mv_st_ent);
|
|
mv_chain = mv_st_ent;
|
|
} else
|
|
{
|
|
fp = (stack_frame *)((char *)fp - shift_size);
|
|
mv_chain = (mv_stent *)((char *)mv_chain - shift_size);
|
|
mvst_tmp = mv_chain;
|
|
mvst_prev = (mv_stent *)((char *)mvst_tmp + mvst_tmp->mv_st_next);
|
|
while (mvst_prev < (mv_stent *)fp)
|
|
{
|
|
mvst_tmp = mvst_prev;
|
|
mvst_prev = (mv_stent *)((char *)mvst_tmp + mvst_tmp->mv_st_next);
|
|
}
|
|
mvst_tmp->mv_st_next = (uint4)((char *)mv_st_ent - (char *)mvst_tmp);
|
|
mv_st_ent->mv_st_next = (uint4)((char *)mvst_prev - (char *)mv_st_ent + shift_size);
|
|
}
|
|
}
|
|
mv_st_ent->mv_st_cont.mvs_stab = (symval *)NULL; /* special case this so failed initialization can be detected */
|
|
|
|
memset(l_syms, 0, ls_size);
|
|
size++;
|
|
ptr = (symval *)malloc(SIZEOF(symval));
|
|
/* the order of initialization of fields mirrors the layout of the fields in the symval structure definition */
|
|
ptr->ident = MV_SYM;
|
|
ptr->sbs_depth = 0;
|
|
ptr->tp_save_all = 0;
|
|
ptr->xnew_var_list = NULL;
|
|
ptr->xnew_ref_list = NULL;
|
|
init_hashtab_mname(&ptr->h_symtab, size, HASHTAB_NO_COMPACT, HASHTAB_NO_SPARE_TABLE);
|
|
ptr->lv_first_block = NULL;
|
|
lv_newblock(ptr, size);
|
|
ptr->lvtree_first_block = NULL;
|
|
ptr->lvtreenode_first_block = NULL;
|
|
ptr->lv_flist = NULL;
|
|
ptr->lvtree_flist = NULL;
|
|
ptr->lvtreenode_flist = NULL;
|
|
ptr->last_tab = curr_symval;
|
|
/* if we get here, our initialization must have been successful */
|
|
if (curr_symval)
|
|
ptr->symvlvl = curr_symval->symvlvl + 1;
|
|
else
|
|
ptr->symvlvl = 1;
|
|
GTMTRIG_ONLY(ptr->trigr_symval = FALSE);
|
|
ptr->alias_activity = FALSE;
|
|
curr_symval = ptr;
|
|
mv_st_ent->mv_st_cont.mvs_stab = ptr;
|
|
return shift_size;
|
|
}
|