/*
 * Do a lookup in the current scope only, i.e., do not follow the parent link
 * out, even if we should otherwise.
 */
SymtabEntry *LookupModStringThisScope(char *s)
{
    int i;
    SymtabEntry *p;
    
    s = *hash(s);
    i = ((int) s & CurSymtab->Mask) % CurSymtab->Size;
    for (p = CurSymtab->Entries[i]; p != NIL; p = p->Next)
	if (p->Symbol == s)
	  if (p->Class != C_Obj)
	    return (p);
    return null;
}

void InstallConst(char* name, char* typename, long val)
{
    nodep n,nn;
    SymtabEntry *sym;
    SymtabEntry *entryPtr;    

    n = NewNode(DECL_NODE, YCONST);
    n->components.type.type.qualident.type = (nn = NewNode(ATOM_NODE, null));
    nn->components.atom.val.text = name;
    nn->components.atom.next = null;

    /* Look up the type. If it exists, then enter the constant */
    entryPtr = ModLookupString(typename);
    if( entryPtr != NULL )
      Enter(sym = HashAllocSymtabEntry(name, C_Const, entryPtr->Type, 0));
    else
      return;
    
    if(strcmp(typename,"boolean"))
        sym->Info.Const.val = (nodep) val;
    else
        sym->Info.Const.value.BoolVal = val;
}

/*
 * Enter a list of vars in the cur symtab.
 */
void EnterModVars(nodep idlist, TypeStruct type)
{
    nodep a;
    TypeStruct t;

    /*
     * Compute the type.  If the declared type is as an ident, then lookup
     * the type ident and use that (note that LookupType transparently
     * handles the case of a forward type reference).  If type is not an ident,
     * then just use its parse tree as the type value.
     */
    if (isTypeIdent(type))
	t = LookupType(type->components.type.type.qualident.type);
    else
	t = type;

    /*
     * Enter each var if its name is not already declared in this scope.
     */
    for (a=idlist; a; a=a->components.atom.next) {
	if (! LookupModStringThisScope(a->components.atom.val.text))
	    Enter(HashAllocSymtabEntry(a->components.atom.val.text,
				       C_Var, t, CurSymtab->Level));
	else
	    error("Redeclaration of %s\n", a->components.atom.val.text);
    }
}

/*
 * Leave a proc level after the proc has been fully parsed.  Patch in the
 * return type if necessary, and also attach the statement body of the
 * procedure.
 */
void ExitModProc(TypeStruct type, nodep body)
{
    CurSymtab->ParentEntry->Type = type;
    if (CurSymtab->ParentEntry->Flags != 2)
       CurSymtab->ParentEntry->Info.Proc.Body.Tree = body;
    CurSymtab = CurSymtab->ParentTab;
}

/*
  EnterModModule() - Enter a module into the symbol table
 */
void EnterModModule( char* name, SymClasses moduleType )
{
    int size;
    SymtabEntry *sym;

    switch (moduleType) {
	case YMODULE: size = 256; break;
	case YDEF: size = 32; break;
	case YPROCEDURE: size = 64; break;
    }
    Enter(sym=HashAllocSymtabEntry(name, C_Module, null, CurSymtab->Level+1));
    NewLevel(sym, size, 0, null);
			/* ^^^^ NOTE.  Should be changed. */
    GlobalLevel = 1;			/* see translator.h for explanation */
}

void InstallProc(char *name, PreCompiled Func)
{
    SymtabEntry *sym, *ste;
    int (*pf)();
    int WriteInt();
    int WriteReal();
    int WriteChar();
    int WriteString();
    int WriteBool();
    int WriteLn();
    int New();
    void SetParmOffset();
    nodep nextnode, parmnode, savenode, namenode;

 /* Allocate a new symbol table entry for the proc, and attach a pointer to */
    /* C function that does it's work. */
    namenode = NewNode(ATOM_NODE, Yident);
    namenode->components.atom.val.text =  name;
    namenode->components.atom.next = null;
    Enter(sym= HashAllocSymtabEntry(
       namenode->components.atom.val.text, C_Proc, null, CurSymtab->Level+1));
    NewLevel(sym, 128, 0, null);
		       /* ^^^^ NOTE.  Should be changed. */
    sym->Flags |= isPreComp;
    switch (Func) {
	case writeInt:
          sym->Info.Proc.Body.PreComp = WriteInt;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("cardinal")+1));
	  strcpy(parmnode->components.atom.val.text, "cardinal");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("n")+1));
	  strcpy(parmnode->components.atom.val.text, "n");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  savenode = nextnode;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("integer")+1));
	  strcpy(parmnode->components.atom.val.text, "integer");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("x")+1));
	  strcpy(parmnode->components.atom.val.text, "x");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  nextnode->components.decl.next = savenode;
	  LinkFPSections(nextnode, savenode);
	  LinkFormals(nextnode);
	  ExitModProc(null,null);
	  SetParmOffset(namenode);
	  break;
	case writeReal:
          sym->Info.Proc.Body.PreComp = WriteReal;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("cardinal")+1));
	  strcpy(parmnode->components.atom.val.text, "cardinal");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("n")+1));
	  strcpy(parmnode->components.atom.val.text, "n");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  savenode = nextnode;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("real")+1));
	  strcpy(parmnode->components.atom.val.text, "real");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("x")+1));
	  strcpy(parmnode->components.atom.val.text, "x");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  nextnode->components.decl.next = savenode;
	  LinkFPSections(nextnode, savenode);
	  LinkFormals(nextnode);
	  ExitModProc(null,null);
	  SetParmOffset(namenode);
	  break;
	case writeChar:
          sym->Info.Proc.Body.PreComp = WriteChar;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("char")+1));
	  strcpy(parmnode->components.atom.val.text, "char");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("x")+1));
	  strcpy(parmnode->components.atom.val.text, "x");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  LinkFormals(nextnode);
	  ExitModProc(null,null);
	  SetParmOffset(namenode);
	  break;
	case writeString:
          sym->Info.Proc.Body.PreComp = WriteString;
	  ExitModProc(null,null);
	  break;
	case writeBool:
          sym->Info.Proc.Body.PreComp = WriteBool;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("boolean")+1));
	  strcpy(parmnode->components.atom.val.text, "boolean");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("x")+1));
	  strcpy(parmnode->components.atom.val.text, "x");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  LinkFormals(nextnode);
	  ExitModProc(null,null);
	  SetParmOffset(namenode);
	  break;
	case writeLn:
          sym->Info.Proc.Body.PreComp = WriteLn;
	  ExitModProc(null,null);
	  break;
	case new:
          sym->Info.Proc.Body.PreComp = New;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("pointer")+1));
	  strcpy(parmnode->components.atom.val.text, "pointer");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("p")+1));
	  strcpy(parmnode->components.atom.val.text, "p");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
/*	  savenode = nextnode;
	  parmnode = NewNode(ATOM_NODE, YQUALIFIED);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("integer")+1));
	  strcpy(parmnode->components.atom.val.text, "integer");  
	  parmnode->components.atom.next = null;
	  nextnode = NewNode(DECL_NODE, '(');
	  nextnode->components.decl.kind.parm.isarray = false;
	  nextnode->components.decl.kind.parm.type = parmnode;
	  parmnode = NewNode(ATOM_NODE, Yident);
	  parmnode->components.atom.val.text = (char*)malloc(strlen(("x")+1));
	  strcpy(parmnode->components.atom.val.text, "x");  
	  parmnode->components.atom.next = null;
	  nextnode->components.decl.kind.parm.isvar = false;
	  nextnode->components.decl.kind.parm.vars = parmnode;
	  EnterParms(parmnode, nextnode, null);
	  nextnode->components.decl.next = savenode;*/
/*	  LinkFPSections(nextnode, savenode); */
	  LinkFormals(nextnode);
	  ExitModProc(null,null);
	  SetParmOffset(namenode);
	  PushSymtab();
	  CurSymtab = sym->Info.Proc.Symtab;
	  ste = LookupModString("p");
	  ste->Flags |= varParm; 
	  ste->Flags |= isOpaque;
	  PopSymtab();
	  break;
	}			/* switch */
}

void SetVarOffset(nodep IdentList)
{
SymtabEntry* st;
int size;
nodep a;

	for (a = IdentList; a; a = a->components.atom.next)
	  {

  	  if (st = LookupModStringThisScope(a->components.atom.val.text))
	    {
	    size = TypeSize(st->Type);
	    st->Info.Var.Offset = CurSymtab->CurOffset;
	    CurSymtab->CurOffset += size;
	    }
	  }
}

void SetParmOffset(nodep name)
{
int size;
SymtabEntry* a;
SymtabEntry* sym;   

   sym = LookupModString(name->components.atom.val.text);
   for ( a = sym->Info.Proc.Parms; a; a = a->Info.Parm.Link)
     {
        size = TypeSize(a->Type);
        a->Info.Parm.Offset = sym->Info.Proc.Symtab->CurOffset;
        sym->Info.Proc.Symtab->CurOffset += size;
     }
}