/*
 * Implementation of estymtab.h.
 */

#include <stdio.h>
#include <string.h>
#include <strings.h>
#include "esymtab.h"


EntitySymtab::EntitySymtab() {
    Size = 1000;
    symt = AllocSymtab(Size);
}

void EntitySymtab::EnterSym(EntityStruct* es) {
/*
 * Call HashAllocSymtabEntry and Enter to do the work.  Use the Chain
 * field to point to the EntityStruct itself.
 */
    SymtabEntry *sym, *esym;

    esym = es->GetSym();

    EnterIn(sym = HashAllocSymtabEntry(
	es->GetName(), esym->Class, esym->Type, esym->Level), symt);

    sym->Chain = (SymtabEntry*) es;
}


EntityStruct* EntitySymtab::LookupSym(char* name) {
    SymtabEntry* sym = LookupStringIn(name, symt);

    return sym ? (EntityStruct*) sym->Chain : (EntityStruct*) null;
}

EntityStruct* EntitySymtab::LookupAmbigSym(SymtabEntry* sym) {
    EntityStruct* es;

    es = this->LookupSym(sym->Symbol);
    if (es)
	return es;
    else
	return this->LookupSym(BuildDisambiguatedStr(sym, 0));
/*
    return es = LookupSym(sym->Symbol) ? es :
	LookupSym(BuildDisambiguatedStr(sym));
 */
}



char* EntitySymtab::BuildDisambiguatedStr(SymtabEntry* e, int alt_count) {
    /* 16jan07 gfisher: this is a no-op for now, and most likely forever. */
    return e->Symbol;
}

char* EntitySymtab::BuildDisambiguatedHtmlStr(SymtabEntry* e, int alt_count) {
    return BuildDisambiguatedStr1(e, alt_count, "&nbsp;");
}

char* EntitySymtab::BuildDisambiguatedStr1(SymtabEntry* e, int alt_count, char*
	space_char) {
    SymtabEntry* parentSym;
    char* s;

    // return e->Symbol;

    switch (e->Class) {
	case C_Obj:
	    if (parentSym = e->Info.Obj.parent)
		break;
	    else
		return e->Symbol;
	case C_Op:
	    if (parentSym = e->Info.Op.parent)
		break;
	    else
		return e->Symbol;
	case C_Parm:
	case C_Module:
	    return e->Symbol;
    }

//  char* s = (char *) malloc(strlen(e->Symbol) + strlen(parentSym->Symbol) +
//	strlen(" (in Module )" + 1));

    if (alt_count == 0) {
	s = new char[strlen(e->Symbol) + strlen(parentSym->Symbol) +
	    strlen("&nbsp;(in&nbsp;Module&nbsp;)") + 1];
	sprintf(s, "%s%sin%sModule%s%s%c", e->Symbol, "_", "_",
	    "_", parentSym->Symbol, '\0');
    }
    else {
	if (e->Class == C_Obj) {
	    if (alt_count > 999) alt_count = 999;  // Presumably never happens
	    s = new char[strlen(e->Symbol) + strlen(",&nbsp;alt&nbsp;") + 4];
	    sprintf(s, "%s_%salt%s%d%c", e->Symbol, "_", "_",
		alt_count, '\0');
	}
	else  /* (e->Class == C_Obj) */ {
	    if (alt_count > 999) alt_count = 999;  // Presumably never happens
	    s = new char[strlen(e->Symbol) +
		strlen("&nbsp;(overload&nbsp;)") + 4];
	    sprintf(s, "%s%s(overload%s%d)%c", e->Symbol, space_char,
		space_char, alt_count, '\0');
	}
    }

    SetSymFlag(e, isAmbig);

    return s;
}

EntityStruct* EntitySymtab::Enum() {
    SymtabEntry* sym;

    CurSymtab = symt;	/* YEOWWW!  We better know what we're doing here. */
    return (sym = NextEntry()) ? (EntityStruct*) sym->Chain : null;
}