dsym.h

Go to the documentation of this file.

#ifndef DSYM_H
#define DSYM_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>=====================================*/

#include "stdtypes.h"
#include "sym.h"
#include "type.h"
#include "const.h"
#include "symtable.h"
#include "typetable.h"

#ifndef NULL
#define NULL 0
#endif


class sym_const : public sym {
private:
    pConst konst;

public:
    sym_const(STRING n) : sym( n )
    { 
        konst = NULL; 
    }

    sym_const()
    {
        konst = NULL;
    }

    const uint get_sy_kind(void) { return sy_const; }

    void set_const( pConst c )
    {
        konst = c;
    }
    const pConst get_const(void)
    {
        return konst;
    }
}; // sym_const



class sym_type : public sym {
private:
    pType ty;

public:
    sym_type(STRING n ) : sym( n )
    {
        ty = NULL;
    } // sym_type constructor

    sym_type()
    {
        ty = NULL;
    }

    const uint get_sy_kind(void) { return sy_type; }

    const pType get_ty_type(void) 
    { 
        return ty; 
    } // get_type
    void set_ty_type( pType t ) 
    { 
        assert( t != NULL );
        ty = t;
    } // set_type

}; // sym_type



enum { sy_bad_alloc,
       sy_static_id,
       sy_frame_id 
     };

enum { sy_bad_ident_type,
       sy_signal,
       sy_variable };

class sym_ident : public sym_scoped {
private:
    pType ty;
    uint id_alloc : 3,    // sy_static_id, sy_frame_id, ...
         id_kind  : 3,    // sy_signal, sy_variable
         unused   : 26; 
public:
    sym_ident(STRING n) : sym_scoped( n )
    {
        ty = NULL;
        id_alloc = sy_bad_alloc;
        id_kind = sy_bad_ident_type;
    }

    sym_ident()
    {
        ty = NULL;
        id_alloc = sy_bad_alloc;
        id_kind = sy_bad_ident_type;
    }

    const uint get_sy_kind(void) { return sy_ident; }
    
    void set_alloc( uint alloc )
    {
        id_alloc = alloc;
    } // set_offset
    const uint get_alloc(void)
    {
        return id_alloc;
    }

    void set_id_kind( uint kind )
    {
        id_kind = kind;
    }
    const uint get_id_kind(void)
    {
        return id_kind;
    }

    void set_id_type( pType t ) 
    { 
        assert( t != NULL );
        ty = t;
    } // set_type
    const pType get_id_type(void) 
    { 
        return ty; 
    } // get_type
}; // sym_ident



class sym_scope : public sym_scoped {
private:
    sym *find_in_scope( sym *pSym, STRING sym_name );

private:
    sym_scope( const sym_scope &s )
    {
        assert( FALSE );
    }

protected:
    symtable symtab;
    typetable typtab;

public:
    //
    // constructors
    // 
    sym_scope(STRING n ) : sym_scoped( n )
    {
    }

    sym_scope()
    {
    }

    void dealloc(void)
    {
        symtab.dealloc();
        typtab.~typetable();
    }
    //upwards lookup starting from 'this' scope
    sym *LookupFromScope(STRING s);

    sym *LookupFromScope(const char *pChar )
    {
        STRING local_str;

        local_str.SetText( pChar );
        return LookupFromScope( local_str );
    }

    symtable *get_symtab(void)
    {
        return &symtab;
    }

    typetable *get_typtab(void)
    {
        return &typtab;
    }

    Boolean has_scope()
    {
        return TRUE;
    }
};  // sym_scope


class sym_subprog : public sym_scope {
private:
  pType ty;
  NODE *tree;

public:
  FIFO_LIST<sym_ident *> arg_list;

public:
    sym_subprog(STRING n ) : sym_scope( n )
    {
        tree = NULL;
        ty = NULL;
    }

    sym_subprog()
    {
        tree = NULL;
        ty = NULL;
    }

    const uint get_sy_kind(void) { return sy_subprog; }

    void set_statement( NODE *s )
    {
        tree = s;
    }
    const NODE *get_statement(void)
    {
        return tree;
    }

    void set_func_type( pType t )
    {
        ty = t;
    }

    const pType get_func_type(void)
    {
        return ty;
    }

};   // sym_subprog


class sym_process : public sym_scope {
public:
    LIST<sym_ident *> active_list;  // process activation list

public:
    sym_process(STRING n ) : sym_scope( n )
    {
    }
    sym_process()
    {
    }

    const uint get_sy_kind(void) { return sy_process; }
};


class sym_component : public sym_scope {
private:
    pool mem;  // memory pool for this component

private:
    // No copy constructor allowed
    sym_component( const sym_component &c )
    {
        assert( FALSE );
    }

    void proc_list_dealloc(void);

private:
    LIST<sym *> proc_list;  // list of processes
    LIST<NODE *> sigass_list;       // list of signal assignments

public:
    sym_component( STRING n ) : sym_scope( n )
    {
        init();
    }
    sym_component()
    {
        init();
    }

    ~sym_component()
    {
        dealloc();
    }

    const uint get_sy_kind(void) { return sy_component; }

    void init(void)
    {
        mem.new_pool();   
        symtab.set_pool( &mem );
        typtab.set_pool( &mem );
        
    }
    void dealloc(void)
    {
        sym_scope::dealloc();  
        proc_list_dealloc();
        sigass_list.dealloc();
        mem.delete_pool();  
    }


    void *GetMem( uint num_bytes )
    {
        void *pMem;

        pMem = mem.GetMem( num_bytes );
        return pMem;
    }

    LIST<sym *> *get_proc_list(void)
    {
        return &proc_list;
    }
    LIST<NODE *> *get_sigass_list(void)
    {
        return &sigass_list;
    }
}; // sym_component


#endif

---