sym.h

Go to the documentation of this file.

#ifndef SYM_H
#define SYM_H

/*
   include dependencies:

   stdlib.h     -- for NULL
   stdtypes.h
   string.h
   type.h
   str.h        -- definition for STRING

 */

#include "typedefs.h"
#include "list.h"
#include "const.h"


/*===============================<o>=====================================

Copyright 1996, 1997, 2004 Ian Kaplan, Bear Products International,
www.bearcave.com.

All Rights Reserved

You may use this software in software components for which you do
not collect money (e.g., non-commercial software).  All commercial
use is reserved.

===============================<o>=====================================*/


class src_ref {
    ushort file_num;   // handle in the file name table
    ushort offset;     // char offset within the line
    uint line_num;     // line number within the file
}; // src_ref


enum { bad_symbol,
       sy_ident,
       sy_type,
       sy_const,          // an enumeration value, a defined constant
       sy_subprog,
       sy_component,      // an elaborated entity/architecture pair
       sy_package,        // both declaration parts and body
       sy_process,
       sy_block_label    // its not clear this is needed
    };

class symtable;
class typetable;

class sym {
private:
    STRING name;       // Symbol name, entered into the string table
    src_ref  m_sr;     // source location for the declaration
    uint m_referenced : 1,  // symbol was referenced
         m_unused     : 31;

public:
    sym(STRING n )
    {
        name = n;
        m_referenced = FALSE;
    } // sym constructor

    sym( )
    {
        name.SetText( NULL );
        m_referenced = FALSE;
    } // sym constructor


    void *operator new( unsigned int num_bytes )
    {
        assert( FALSE );
        return NULL;
    }

    //
    // Overloaded new
    //
    void *operator new( unsigned int num_bytes, pool *mem_pool )
    {
        return mem_pool->GetMem( num_bytes );
    }

    // Memory is recovered by deleting the memory pool.  So delete
    // should do nothing.
    void operator delete( void *addr ) {/* do nothing */}

    STRING get_name(void) { return name; }
    void set_name( const STRING str ) { name = str; }

    void set_referenced(void) { m_referenced = TRUE; }
    void unset_referenced(void) { m_referenced = FALSE; }
    const Boolean is_referenced(void) { return m_referenced; }
    
    //
    // Virtual functions common to all classes
    //
    virtual const uint get_sy_kind(void) { return bad_symbol; }

    //
    // Virtual functions for derived classes
    //
    // -- sym_scoped subclass
    //
    virtual void set_scope( pSym scope )
    {
        assert( FALSE );
    }
    //
    // get_scope default class
    //
    // Return null if there is no scope, since this
    // is one way to test this characteristic of
    // a symbol.
    virtual const pSym get_parent_scope(void) 
    {
        return NULL;
    }
    //
    // -- sym_const subclass
    //
    virtual void set_const( pConst c )
    {
        assert( FALSE );
    }
    virtual const pConst get_const(void)
    {
        assert( NULL );
        return NULL;
    }
    //
    // -- sym_type subclass
    //
    virtual void set_ty_type( pType t ) 
    { 
        assert( NULL );
    } // set_type
    virtual const pType get_ty_type(void) 
    { 
        assert( FALSE );
        return NULL; 
    } // get_type
    //
    // -- sym_ident subclass
    //
    virtual void set_alloc( uint alloc )
    {
        assert( FALSE );
    } // set_offset
    virtual const uint get_alloc(void)
    {
        assert( FALSE );
        return 0;
    }
    virtual void set_id_kind( uint kind )
    {
        assert( FALSE );
    }
    virtual const uint get_id_kind(void)
    {
        assert( FALSE );
        return 0;
    }
    virtual void set_id_type( pType t ) 
    { 
        assert( FALSE );
    } // set_id_type
    virtual const pType get_id_type(void) 
    { 
        assert( FALSE );
        return NULL; 
    }
    //
    // -- sym_scope subclass
    //
    virtual sym *LookupFromScope(STRING s)
    {
        assert( FALSE );
        return NULL;
    }
    virtual sym *LookupFromScope(const char *pChar )
    {
        assert( FALSE );
        return NULL;
    }
    virtual symtable *get_symtab(void)
    {
        assert( FALSE );
        return NULL;
    }

    virtual typetable *get_typtab(void)
    {
        assert( FALSE );
        return NULL;
    }
    virtual Boolean has_scope()
    {
        // return false for any symbol that is not of
        // the sym_scope sub-class
        return FALSE;
    }
    //
    // -- sym_subprog subclass
    //
    virtual void set_statement( NODE *s )
    {
        assert( FALSE );
    }
    virtual const NODE *get_statement(void)
    {
        assert( FALSE );
        return NULL;
    }

    virtual void set_func_type( pType t )
    {
        assert( FALSE );
    }
    virtual const pType get_func_type(void)
    {
        assert( FALSE );
        return NULL;
    }
    //
    // -- sym_component subclass
    //
    virtual void init(void)
    {
        // its ok to do nothing if there's nothing to initialize
    }
    virtual void dealloc(void)
    {
        // its ok to do nothing if there's nothing to deallocate
    }
    // Allocate memory from the pool that is local to the 
    // component.
    virtual void *GetMem( uint num_bytes )
    {
        assert( FALSE );
        return NULL;
    }

    virtual LIST<sym *> *get_proc_list(void)
    {
        assert( FALSE );
        return NULL;
    }
    virtual LIST<NODE *> *get_sigass_list(void)
    {
        assert( FALSE );
        return NULL;
    }
};  // class sym



class sym_scoped : public sym {
private:
    pSym parent_scope;

public:
    sym_scoped(STRING n) : sym( n )
    { 
        parent_scope = NULL; 
    }

    sym_scoped()
    {
        parent_scope = NULL;
    }

    void set_scope( pSym scope )
    {
        parent_scope = scope;
    }
    const pSym get_parent_scope(void) 
    {
        return parent_scope;
    }
}; // sym_scoped


#endif

---