/*
 * 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) {
    return BuildDisambiguatedStr1(e, alt_count, " ");
}

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

char* EntitySymtab::BuildDisambiguatedStr1(SymtabEntry* e, int alt_count,
        const 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("(inModule)") +	// "(inModule)" raw chars
	    strlen(e->Symbol) +		// e->Symbol
	    strlen(space_char) +	// space_char
	    strlen(space_char) +	// space_char
	    strlen(space_char) +	// space_char
	    strlen(parentSym->Symbol) +	// parentSym->Symbol
	    10];			// '\0' + padding
	sprintf(s, "%s%s(in%sModule%s%s)%c",
	    e->Symbol,
	    space_char,
	    space_char,
	    space_char,
	    parentSym->Symbol,
	    '\0');
/*
	printf("computed size = %d, ",
       	    strlen("(inModule)") +	// "(inModule)" raw chars
	    strlen(e->Symbol) +		// e->Symbol
	    strlen(space_char) +	// space_char
	    strlen(space_char) +	// space_char
	    strlen(space_char) +	// space_char
	    strlen(parentSym->Symbol) +	// parentSym->Symbol
	    1);				// '\0'
	printf("actual size = %d\n", strlen(s));
 */
    }
    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, space_char, space_char,
		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;
}