I64 HashTypeNum(CHash *tmph) {//Return bit num of hash type, limited to just types. if (tmph) return Bsf(tmph->type&HTG_TYPE_MASK); else return -1; } I64 HashVal(CHash *tmph) {//Returns most likely desired value. switch [HashTypeNum(tmph)] { case HTt_EXPORT_SYS_SYM: return tmph(CHashExport *)->val; case HTt_IMPORT_SYS_SYM: return tmph(CHashImport *)->module_base; case HTt_DEFINE_STR: case HTt_CLASS: case HTt_INTERNAL_TYPE: case HTt_WORD: case HTt_DICT_WORD: case HTt_OPCODE: case HTt_HELP_FILE: return tmph; case HTt_GLBL_VAR: if (tmph(CHashGlblVar *)->flags&GVF_EXTERN) return &tmph(CHashGlblVar *)->data_addr; else return tmph(CHashGlblVar *)->data_addr; case HTt_FUN: if (Bt(&tmph(CHashFun *)->flags,Cf_EXTERN)) return tmph; else return tmph(CHashFun *)->exe_addr; case HTt_REG: return tmph(CHashReg *)->reg_num|tmph(CHashReg *)->reg_type<<8; case HTt_KEYWORD: case HTt_ASM_KEYWORD: case HTt_MODULE: case HTt_FILE: case HTt_FRAME_PTR: return tmph(CHashGeneric *)->user_data0; case -1: //nobound switch case HTt_TYPES_NUM: //nobound switch default: return 0; } } CHashTable *HashTableNew(I64 size,CTask *mem_task=NULL) {//New hash table, power-of-two in size. CHashTable *table; table=CAlloc(sizeof(CHashTable),mem_task); table->body=CAlloc(size<<3,mem_task); table->mask=size-1; return table; } U0 HashDel(CHashSrcSym *tmph) {//Free a std TempleOS system hash entry. if (!tmph) return; if (!(tmph->type&HTT_DICT_WORD)) Free(tmph->str); if (tmph->type & HTG_SRC_SYM) { Free(tmph->src_link); Free(tmph->idx); Free(tmph->import_name); LinkedLstDel(tmph->ie_lst); if (tmph->type & (HTT_FUN | HTT_EXPORT_SYS_SYM)) Free(tmph->dbg_info); if (tmph->type & (HTT_FUN | HTT_CLASS)) //Assumes code not on heap, so doesn't Free. //ClassMemberLstDel() is an import to the Kernel module ClassMemberLstDel(tmph); else if (tmph->type&HTT_DEFINE_STR) Free(tmph(CHashDefineStr *)->data); else if (tmph->type & HTT_GLBL_VAR) { if (!(tmph(CHashGlblVar *)->flags&GVF_ALIAS)) Free(tmph(CHashGlblVar *)->data_addr); LinkedLstDel(tmph(CHashGlblVar *)->dim.next); if (tmph(CHashGlblVar *)->fun_ptr) HashDel(tmph(CHashGlblVar *)->fun_ptr -tmph(CHashGlblVar *)->fun_ptr->ptr_stars_cnt); } } else if (tmph->type & HTT_FILE) Free(tmph(CHashGeneric *)->user_data0); Free(tmph); } U0 HashTableDel(CHashTable *table) {//Free std system hash table, calling HashDel() on entries. I64 i; CHashSrcSym *tmph,*tmph1; if (!table) return; for (i=0;i<=table->mask;i++) { tmph=table->body[i]; while (tmph) { tmph1=tmph->next; HashDel(tmph); tmph=tmph1; } } Free(table->body); Free(table); } I64 HashTablePurge(CHashTable *table) {//Eliminate ExportSysSyms that have been usurped. I64 i,res=0; CHashSrcSym *tmph,*tmph1,*tmph2; if (!table) return 0; PUSHFD CLI //Precaution for (i=0;i<=table->mask;i++) { tmph=table->body[i]; while (tmph) { tmph1=tmph->next; //We delete only older ones if (tmph->type&(HTT_FUN|HTT_GLBL_VAR)) { tmph2=tmph->next; //Older always later in chain while (tmph2) { if ((tmph2->type&HTT_EXPORT_SYS_SYM || tmph2->type&HTG_TYPE_MASK==HTT_INVALID) && !StrCmp(tmph2->str,tmph->str)) { if (tmph2->type&HTG_TYPE_MASK==HTT_INVALID) tmph2->type=HTT_KEYWORD;//Won't delete HTT_INVALID HashRemDel(tmph2,table); res++; break; } tmph2=tmph2->next; } } tmph=tmph1; } } POPFD return res; } CHashGeneric *HashGenericAdd(U8 *name,I64 type, I64 u0=0,I64 u1=0,I64 u2=0,CTask *task=NULL) {//Add any type to task hash_table, 3 user_data values. if (!task) task=Fs; CHashGeneric *res=CAlloc(sizeof(CHashGeneric),task); res->type=type; res->user_data0=u0; res->user_data1=u1; res->user_data2=u2; res->str=StrNew(name,task); HashAdd(res,task->hash_table); return res; } U0 HashSrcFileSet(CCmpCtrl *cc,CHashSrcSym *h,I64 line_num_offset=0) {//Set CHashSrcSym link and help_index by cur cc pos. CLexFile *tmpf=cc->lex_include_stk; I64 line_num=tmpf->line_num+line_num_offset; if (line_num<1) line_num=1; Free(h->src_link); h->src_link=MStrPrint("FL:%s,%d",tmpf->full_name,line_num); if (Bt(&cc->opts,OPTf_KEEP_PRIVATE)) h->type|=HTF_PRIVATE; Free(h->idx); if (cc->cur_help_idx && *cc->cur_help_idx) h->idx=StrNew(cc->cur_help_idx); else h->idx=NULL; } CHashGeneric *HashPublic(U8 *st,I64 mask,Bool val=TRUE) {//Mark a hash entry as public and HashSrcFileSet(). CHashGeneric *res; if (res=HashFind(st,Fs->hash_table,mask)) { if (val) res->type|=HTF_PUBLIC; else res->type&=~HTF_PUBLIC; if (res->type&HTG_SRC_SYM) HashSrcFileSet(Fs->last_cc,res); return res; } else return NULL; } I64 HashLstAdd(U8 *lst,I64 type,CHashTable *table) {//Add a list to a hash table. I64 i=0; CHashGeneric *tmph; if (lst) { while (*lst) { if (*lst=='@') lst++; else i++; tmph=CAlloc(sizeof(CHashGeneric)); tmph->user_data0=i-1; tmph->str=StrNew(lst); tmph->type=type; HashAdd(tmph,table); while (*lst++); } } return i; } I64 HashDefineLstAdd(U8 *dname,I64 type,CHashTable *table) {//Add define list to a hash table. See ::/Adam/DolDoc/DocInit.HC. CHashDefineStr *tmph; if (tmph=HashFind(dname,Fs->hash_table,HTT_DEFINE_STR)) return HashLstAdd(tmph->data,type,table); else return 0; } I64 FramePtr(U8 *name,CTask *task=NULL) {//Find entry in task->hash_table, Return user_data. CHashGeneric *tmph; if (!task) task=Fs; if (tmph=HashFind(name,task->hash_table,HTT_FRAME_PTR)) return tmph->user_data0; else return 0; } CHashGeneric *FramePtrAdd(U8 *name,I64 val=0,CTask *task=NULL) {//Add named value to task->hash_table. return HashGenericAdd(name,HTT_FRAME_PTR,val,0,0,task); } I64 FramePtrSet(U8 *name,I64 val,CTask *task=NULL) {//Find hash entry in task->hash_table. Change user_data0. CHashGeneric *tmph; if (!task) task=Fs; if (tmph=HashFind(name,task->hash_table,HTT_FRAME_PTR)) return LXchgI64(&tmph->user_data0,val); else return 0; } I64 FramePtrDel(U8 *name,CTask *task=NULL) {//Remove entry and delete. CHashGeneric *tmph; I64 res=0; if (!task) task=Fs; if (tmph=HashFind(name,task->hash_table,HTT_FRAME_PTR)) { res=tmph->user_data0; HashRemDel(tmph,task->hash_table); } return res; }