Subversion Repositories c16

// Name.cc

#include <stdio.h>

#include "Name.hh"

#include "Node.hh"

Name * Name::externs  = 0;

Name * Name::statics  = 0;

Name * Name::enums    = 0;

Name * Name::locals   = 0;

Name * Name::autos    = 0;

TypedefName * TypedefName::typedefs = 0;

StructName  * StructName::structs = 0;

const bool DEBUG = false;

//-----------------------------------------------------------------------------

TypeName * TypedefName::Find(const char * na)

{

   for (TypedefName * n = typedefs; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return n->decl;

       }

   return 0;

}

//-----------------------------------------------------------------------------

bool TypedefName::IsDefined(const char * na)

{

   for (TypedefName * n = typedefs; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return true;

       }

   return false;

}

//-----------------------------------------------------------------------------

void TypedefName::Add(const char * na, TypeName * decl)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to typedefs\n", na);

   typedefs = new TypedefName(na, typedefs, decl);

}

//=============================================================================

StructDeclarationList * StructName::Find(const char * na)

{

   for (StructName * n = structs; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return n->sdlist;

       }

   return 0;

}

//-----------------------------------------------------------------------------

bool StructName::IsDefined(const char * na)

{

   for (StructName * n = structs; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return true;

       }

   return false;

}

//-----------------------------------------------------------------------------

void StructName::Add(const char * na, StructDeclarationList * sdl)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to structs\n", na);

   structs = new StructName(na, structs, sdl);

}

//=============================================================================

void Name::RemoveAuto()

{

   while (autos)

       {

          Name * tl = autos->tail;

          delete autos;

          autos = tl;

       }

}

//-----------------------------------------------------------------------------

void Name::AutoToLocal()

{

   while (autos)

      {

        Name * n = autos;

        autos = autos->tail;

        AutoToLocal();

        n->tail = locals;

        locals = n;

      }

}

//-----------------------------------------------------------------------------

TypeName * Name::FindType(const char * na)

{

Name * np = FindDeclared(na);

   if (np == 0)   return 0;

   return np->decl;

}

//-----------------------------------------------------------------------------

int Name::FindPos(const char * na)

{

Name * np = FindDeclared(na);

   if (np == 0)   return 1;   // +1 indicates error !

   return np->stack_position;

}

//-----------------------------------------------------------------------------

bool Name::FindEnum(const char * na, int & value)

{

   for (Name * n = enums; n; n = n->tail)

       {

          if (strcmp(na, n->name))   continue;

          value = n->stack_position;

          return true;

       }

   return false;

}

//-----------------------------------------------------------------------------

Name * Name::FindDeclared(const char * na)

{

   for (Name * n = autos; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return n;

       }

   for (Name * n = locals; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return n;

       }

   for (Name * n = statics; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return n;

       }

   for (Name * n = externs; n; n = n->tail)

       {

          if (!strcmp(na, n->name))   return n;

       }

   return 0;

}

//-----------------------------------------------------------------------------

void Name::Print(FILE * out)

{

   fprintf(out, "'%s' %d\n", name, stack_position);

}

//-----------------------------------------------------------------------------

void Name::PrintAll(FILE * out)

{

   fprintf(out, "Auto:\n");

   for (Name * n = autos; n; n = n->tail)     n->Print(out);

   fprintf(out, "Local:\n");

   for (Name * n = locals; n; n = n->tail)    n->Print(out);

   fprintf(out, "Static:\n");

   for (Name * n = statics; n; n = n->tail)   n->Print(out);

   fprintf(out, "Extern:\n");

   for (Name * n = externs; n; n = n->tail)   n->Print(out);

}

//-----------------------------------------------------------------------------

void Name::AddExtern(const char * na, TypeName * decl)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to externs\n", na);

   externs = new Name(na, externs, decl, 0);

}

//-----------------------------------------------------------------------------

void Name::AddStatic(const char * na, TypeName * decl)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to statics\n", na);

   statics = new Name(na, statics, decl, 0);

}

//-----------------------------------------------------------------------------

void Name::AddLocal(const char * na, TypeName * decl)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to locals\n", na);

   locals = new Name(na, locals, decl, 0);

}

//-----------------------------------------------------------------------------

void Name::AddEnum(const char * na, int spos)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to enums\n", na);

   enums = new Name(na, enums, 0, spos);

}

//-----------------------------------------------------------------------------

void Name::AddAuto(const char * na, TypeName * decl, int spos)

{

   if (DEBUG)   fprintf(stderr, "Adding \"%s\" to autos\n", na);

   autos = new Name(na, autos, decl, spos);

}

//-----------------------------------------------------------------------------

void Name::SetAutoPos(const char * na, int spos)

{

   for (Name * n = autos; n; n = n->tail)

       {

          if (!strcmp(na, n->name))

             {

               if (DEBUG)   fprintf(stderr,

                                    "Setting Stack Position of \"%s\" to %d\n",

                                    na, spos);

               assert(n->stack_position == 0);

               assert(spos != 0);

               assert(spos != 1);

               n->stack_position = spos;

               return;

             }

       }

   assert(0);

}

//-----------------------------------------------------------------------------