verilog_ast.h

Go to the documentation of this file.

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#include "verilog_ast_common.h"

#ifndef VERILOG_AST_H
#define VERILOG_AST_H

extern int yylineno;

typedef struct ast_node_t ast_node;

typedef struct ast_identifier_t * ast_identifier;

typedef struct ast_concatenation_t ast_concatenation;
 
typedef struct ast_expression_t ast_expression;
typedef struct ast_function_call_t ast_function_call;

typedef struct ast_module_item_t ast_module_item;
    
typedef enum ast_operator_e{
    OPERATOR_STAR    , 
    OPERATOR_PLUS    , 
    OPERATOR_MINUS   , 
    OPERATOR_ASL     , 
    OPERATOR_ASR     , 
    OPERATOR_LSL     , 
    OPERATOR_LSR     , 
    OPERATOR_DIV     , 
    OPERATOR_POW     , 
    OPERATOR_MOD     , 
    OPERATOR_GTE     , 
    OPERATOR_LTE     , 
    OPERATOR_GT      , 
    OPERATOR_LT      , 
    OPERATOR_L_NEG   , 
    OPERATOR_L_AND   , 
    OPERATOR_L_OR    , 
    OPERATOR_C_EQ    , 
    OPERATOR_L_EQ    , 
    OPERATOR_C_NEQ   , 
    OPERATOR_L_NEQ   , 
    OPERATOR_B_NEG   , 
    OPERATOR_B_AND   , 
    OPERATOR_B_OR    , 
    OPERATOR_B_XOR   , 
    OPERATOR_B_EQU   , 
    OPERATOR_B_NAND  , 
    OPERATOR_B_NOR   , 
    OPERATOR_TERNARY , 
    OPERATOR_NONE = 0
} ast_operator;

typedef char * ast_string       ;
typedef struct ast_assignment_t ast_assignment;
typedef struct ast_single_assignment_t ast_single_assignment;
typedef struct ast_generate_block_t ast_generate_block;
typedef struct ast_delay3_t ast_delay3;
typedef struct ast_delay2_t ast_delay2;
typedef struct ast_delay_value_t ast_delay_value  ;
typedef struct ast_pull_strength_t ast_drive_strength;
typedef void * ast_macro_use    ;
typedef void * ast_minmax_exp   ;
typedef struct ast_number_t ast_number ;
typedef struct ast_range_t ast_range ;
typedef struct ast_block_item_declaration_t ast_block_item_declaration;
typedef void * ast_tf_input_declaration;
typedef struct ast_statement_t ast_statement;
typedef struct ast_module_declaration_t ast_module_declaration;

typedef enum  ast_boolean_e
{
    AST_TRUE=1,
    AST_FALSE=0
} ast_boolean;

typedef enum ast_edge_e{
    EDGE_POS,   
    EDGE_NEG,   
    EDGE_NONE,  
    EDGE_ANY    
} ast_edge;

typedef enum ast_port_direction_e{
    PORT_INPUT,     
    PORT_OUTPUT,    
    PORT_INOUT,     
    PORT_NONE,  
} ast_port_direction;

typedef int ast_line;
typedef char * ast_file;

typedef struct ast_metadata_t{
    ast_line line;  
    ast_file file;  
} ast_metadata;

//-------------- Numbers ---------------------------------------

typedef enum ast_number_base_e{
    BASE_BINARY,
    BASE_OCTAL,
    BASE_DECIMAL,
    BASE_HEX
} ast_number_base;

typedef enum ast_number_representation_e{
    REP_BITS,       
    REP_INTEGER,    
    REP_FLOAT       
} ast_number_representation;

struct ast_number_t{
    ast_metadata    meta;   
    unsigned int    width; 
    ast_number_base base; 
    ast_number_representation   representation; 
    union{
        char * as_bits;
        float  as_float;
        int    as_int;
    };
};

ast_number * ast_new_number(
    ast_number_base base,   
    ast_number_representation representation,   
    char  * digits  
);

char * ast_number_tostring(
    ast_number * n
);


//-------------- attributes ------------------------------------

typedef struct ast_node_attributes_t ast_node_attributes;
struct ast_node_attributes_t
{
    ast_metadata    meta;   
    ast_identifier        attr_name;    
    ast_expression      * attr_value;   

    ast_node_attributes * next;         
};


ast_node_attributes * ast_new_attributes(
    ast_identifier name, 
    ast_expression * value
);

void ast_append_attribute(ast_node_attributes * parent, 
                          ast_node_attributes * toadd);

// -------------------------------- Concatenations ---------------------------

typedef enum ast_concatenation_type_e
{
    CONCATENATION_EXPRESSION,           
    CONCATENATION_CONSTANT_EXPRESSION,  
    CONCATENATION_NET,                  
    CONCATENATION_VARIABLE,             
    CONCATENATION_MODULE_PATH           
} ast_concatenation_type;

struct ast_concatenation_t{
    ast_metadata    meta;   
    ast_concatenation_type   type;  
    ast_expression         * repeat;
    ast_list               * items; 
};

ast_concatenation * ast_new_concatenation(ast_concatenation_type type,
                                          ast_expression * repeat,
                                          void * first_value);

ast_concatenation * ast_new_empty_concatenation(ast_concatenation_type type);

void                ast_extend_concatenation(ast_concatenation * element,
                                             ast_expression * repeat,
                                             void * data);


// -------------------------------- L Value ------------------------

typedef enum ast_lvalue_type_e
{
    SPECPARAM_ID,
    PARAM_ID,
    NET_IDENTIFIER,     
    VAR_IDENTIFIER,     
    GENVAR_IDENTIFIER,  
    NET_CONCATENATION,  
    VAR_CONCATENATION   
} ast_lvalue_type;

typedef union ast_lvalue_data_u
{
    ast_identifier      identifier;     
    ast_concatenation * concatenation;  
} ast_lvalue_data ;

typedef struct ast_lvalue_t
{
    ast_metadata    meta;   
    ast_lvalue_data data; 
    ast_lvalue_type type; 
} ast_lvalue;

ast_lvalue * ast_new_lvalue_id(ast_lvalue_type type, ast_identifier id);

ast_lvalue * ast_new_lvalue_concat(ast_lvalue_type type, ast_concatenation*id);

// -------------------------------- Function Calls ---------------------------

struct ast_function_call_t {
    ast_metadata    meta;   
    ast_boolean         constant;   
    ast_boolean         system;     
    ast_identifier      function;   
    ast_list        *   arguments;  
    ast_node_attributes * attributes;
};


ast_function_call * ast_new_function_call(ast_identifier  id,
                                          ast_boolean     constant,
                                          ast_boolean     system,
                                          ast_node_attributes * attr,
                                          ast_list      * arguments);


// -------------------------------- Primaries ----------------------

typedef enum ast_primary_type_e
{
    CONSTANT_PRIMARY,
    PRIMARY,
    MODULE_PATH_PRIMARY
} ast_primary_type;


typedef enum ast_primary_value_type_e
{
    PRIMARY_NUMBER,
    PRIMARY_IDENTIFIER,
    PRIMARY_CONCATENATION,
    PRIMARY_FUNCTION_CALL,
    PRIMARY_MINMAX_EXP,
    PRIMARY_MACRO_USAGE    
} ast_primary_value_type;

typedef union ast_primary_value_e
{
    ast_number        * number;         
    ast_identifier      identifier;     
    ast_concatenation * concatenation;  
    ast_function_call * function_call;  
    ast_expression    * minmax;
    ast_macro_use       macro;          
    char              * string;
} ast_primary_value;

typedef struct ast_primary_t
{
    ast_metadata    meta;   
    ast_primary_type        primary_type;   
    ast_primary_value_type  value_type;     
    ast_primary_value       value;          
} ast_primary;


char * ast_primary_tostring(
    ast_primary * p
);

ast_primary * ast_new_constant_primary(ast_primary_value_type type);

ast_primary * ast_new_primary_function_call(ast_function_call * call);

ast_primary * ast_new_primary(ast_primary_value_type type);

ast_primary * ast_new_module_path_primary(ast_primary_value_type type);

// -------------------------------- Expressions --------------------

typedef enum ast_expression_type_e
{
    PRIMARY_EXPRESSION,                 
    UNARY_EXPRESSION,                   
    BINARY_EXPRESSION,                  
    RANGE_EXPRESSION_UP_DOWN,           
    RANGE_EXPRESSION_INDEX,             
    MINTYPMAX_EXPRESSION,               
    CONDITIONAL_EXPRESSION,             
    MODULE_PATH_PRIMARY_EXPRESSION,
    MODULE_PATH_BINARY_EXPRESSION,
    MODULE_PATH_UNARY_EXPRESSION,
    MODULE_PATH_CONDITIONAL_EXPRESSION,
    MODULE_PATH_MINTYPMAX_EXPRESSION,
    STRING_EXPRESSION                 
} ast_expression_type;


char * ast_operator_tostring(ast_operator op);

struct ast_expression_t
{
    ast_metadata    meta;   
    ast_expression_type type;           
    ast_node_attributes * attributes;   
    ast_expression * left;              
    ast_expression * right;             
    ast_expression * aux;               
    ast_primary    * primary;           
    ast_operator     operation;         
    ast_boolean      constant;          
    ast_string       string;            
};

char * ast_expression_tostring(
    ast_expression * exp
);

ast_expression * ast_new_expression_primary(ast_primary * p);

ast_expression * ast_new_binary_expression(ast_expression * left,
                                           ast_expression * right,
                                           ast_operator     operation,
                                           ast_node_attributes * attr,
                                           ast_boolean      constant);

ast_expression * ast_new_unary_expression(ast_primary    * operand,
                                          ast_operator     operation,
                                          ast_node_attributes * attr,
                                          ast_boolean       constant);

ast_expression * ast_new_range_expression(ast_expression * left,
                                          ast_expression * right);

ast_expression * ast_new_index_expression(ast_expression * left);

ast_expression * ast_new_string_expression(ast_string string);


ast_expression * ast_new_conditional_expression(ast_expression * condition,
                                                ast_expression * if_true,
                                                ast_expression * if_false,
                                                ast_node_attributes * attr);

ast_expression * ast_new_mintypmax_expression(ast_expression * min,
                                              ast_expression * typ,
                                              ast_expression * max);

// -------------------------------- Specify Blocks ---------------------------

typedef enum ast_path_declaration_type_e{
    SIMPLE_PARALLEL_PATH,
    SIMPLE_FULL_PATH,
    EDGE_SENSITIVE_PARALLEL_PATH,
    EDGE_SENSITIVE_FULL_PATH,
    STATE_DEPENDENT_PARALLEL_PATH,
    STATE_DEPENDENT_FULL_PATH,
    STATE_DEPENDENT_EDGE_PARALLEL_PATH,
    STATE_DEPENDENT_EDGE_FULL_PATH,
} ast_path_declaration_type;


typedef struct ast_simple_parallel_path_declaration_t{
    ast_metadata    meta;   
    ast_identifier      input_terminal;
    ast_operator        polarity;
    ast_identifier      output_terminal;
    ast_list        *   delay_value;
} ast_simple_parallel_path_declaration;


typedef struct ast_simple_full_path_declaration_t{
    ast_metadata    meta;   
    ast_list        *   input_terminals;
    ast_operator        polarity;
    ast_list        *   output_terminals;
    ast_list        *   delay_value;
} ast_simple_full_path_declaration;


typedef struct ast_edge_sensitive_parallel_path_declaration_t {
    ast_metadata    meta;   
    ast_edge            edge;               
    ast_identifier      input_terminal;     
    ast_operator        polarity;           
    ast_identifier      output_terminal;    
    ast_expression  *   data_source;        
    ast_list        *   delay_value;        
} ast_edge_sensitive_parallel_path_declaration;

typedef struct ast_edge_sensitive_full_path_declaration_t {
    ast_metadata    meta;   
    ast_edge            edge;               
    ast_list        *   input_terminal;     
    ast_operator        polarity;           
    ast_list        *   output_terminal;    
    ast_expression  *   data_source;        
    ast_list        *   delay_value;        
} ast_edge_sensitive_full_path_declaration;

typedef struct ast_path_declaration_t{
    ast_metadata    meta;   
    ast_path_declaration_type   type;
    ast_expression        * state_expression; 
    union {
        ast_simple_parallel_path_declaration         * parallel;
        ast_simple_full_path_declaration             * full;
        ast_edge_sensitive_parallel_path_declaration * es_parallel;
        ast_edge_sensitive_full_path_declaration     * es_full;
    };
} ast_path_declaration;

ast_path_declaration * ast_new_path_declaration(ast_path_declaration_type type);

ast_simple_parallel_path_declaration * ast_new_simple_parallel_path_declaration
(
    ast_identifier      input_terminal,
    ast_operator        polarity,
    ast_identifier      output_terminal,
    ast_list        *   delay_value
);


ast_simple_full_path_declaration * ast_new_simple_full_path_declaration
(
    ast_list        *   input_terminals,
    ast_operator        polarity,
    ast_list        *   output_terminals,
    ast_list        *   delay_value
);

ast_edge_sensitive_parallel_path_declaration * 
  ast_new_edge_sensitive_parallel_path_declaration(
    ast_edge            edge,               
    ast_identifier      input_terminal,     
    ast_operator        polarity,           
    ast_identifier      output_terminal,    
    ast_expression  *   data_source,        
    ast_list        *   delay_value         
);

ast_edge_sensitive_full_path_declaration * 
  ast_new_edge_sensitive_full_path_declaration(
    ast_edge            edge,               
    ast_list        *   input_terminal,     
    ast_operator        polarity,           
    ast_list        *   output_terminal,    
    ast_expression  *   data_source,        
    ast_list        *   delay_value         
); 


// -------------------------------- Task Enable Statements -------------------

typedef struct ast_task_enable_statement_t{
    ast_metadata    meta;   
    ast_list        * expressions;  
    ast_identifier    identifier;   
    ast_boolean       is_system;    
} ast_task_enable_statement;

ast_task_enable_statement * ast_new_task_enable_statement(
    ast_list        * expressions,
    ast_identifier    identifier, 
    ast_boolean       is_system   
);

// -------------------------------- Loop Statements --------------------------

typedef enum ast_loop_type_e{
    LOOP_FOREVER,
    LOOP_REPEAT,
    LOOP_WHILE,
    LOOP_FOR,
    LOOP_GENERATE
} ast_loop_type;

typedef struct ast_loop_statement_t{
    ast_metadata    meta;   
    ast_loop_type   type;            
    union{
        ast_statement * inner_statement; 
        ast_list      * generate_items; 
    };
    ast_expression * condition;      
    ast_single_assignment * initial;       
    ast_single_assignment * modify;        
} ast_loop_statement;


ast_loop_statement * ast_new_forever_loop_statement(
    ast_statement * inner_statement
);

ast_loop_statement * ast_new_for_loop_statement(
    ast_statement  * inner_statements,
    ast_single_assignment * initial_condition,
    ast_single_assignment * modify_assignment,
    ast_expression * continue_condition
);

ast_loop_statement * ast_new_generate_loop_statement(
    ast_list              * inner_statements,
    ast_single_assignment * initial_condition,
    ast_single_assignment * modify_assignment,
    ast_expression        * continue_condition
);

ast_loop_statement * ast_new_while_loop_statement(
    ast_statement  * inner_statement,
    ast_expression * continue_condition
);

ast_loop_statement * ast_new_repeat_loop_statement(
    ast_statement  * inner_statement,
    ast_expression * continue_condition
);


// -------------------------------- Case Statements --------------------------

typedef enum ast_case_statement_type_e{
    CASE,
    CASEX,
    CASEZ
} ast_case_statement_type;

typedef struct ast_case_item_t{
    ast_metadata    meta;   
    ast_list    * conditions; 
    ast_statement * body;     
    ast_boolean     is_default; 
} ast_case_item;

typedef struct ast_case_statement_t{
    ast_metadata    meta;   
    ast_expression  * expression;   
    ast_list        * cases;        
    ast_statement   * default_item; 
    ast_case_statement_type type;   
    ast_boolean       is_function;  
} ast_case_statement;

ast_case_item * ast_new_case_item(ast_list      * conditions,
                                  ast_statement * body);


ast_case_statement * ast_new_case_statement(ast_expression * expression,
                                            ast_list       * cases,
                                            ast_case_statement_type type);


// -------------------------------- IF Else Statements -----------------------

typedef struct ast_conditional_statement_t {
    ast_metadata    meta;   
    ast_statement   * statement; 
    ast_expression  * condition; 
} ast_conditional_statement;

typedef struct ast_if_else_t{
    ast_metadata    meta;   
    ast_list * conditional_statements; 
    ast_statement * else_condition;    
} ast_if_else;


ast_conditional_statement * ast_new_conditional_statement(
    ast_statement * statement,
    ast_expression * condition
);

ast_if_else * ast_new_if_else(
    ast_conditional_statement * if_condition,
    ast_statement             * else_condition
);


void  ast_extend_if_else(
    ast_if_else                 * conditional_statements,
    ast_list                    * new_statement
);


// -------------------------------- Timing Control Statements ----------------

typedef struct ast_wait_statement_t{
    ast_metadata    meta;   
    ast_expression * expression; 
    ast_statement  * statement;  
} ast_wait_statement;

typedef enum ast_event_expression_type_e{
    EVENT_EXPRESSION,   
    EVENT_POSEDGE,      
    EVENT_NEGEDGE,      
    EVENT_SEQUENCE      
} ast_event_expression_type;

typedef struct ast_event_expression_t ast_event_expression;
    ast_metadata    meta;   
struct ast_event_expression_t {
    ast_event_expression_type type;
    union{
        ast_expression * expression; 
        ast_list       * sequence;   
    };
};

// or triggers on anything.
typedef enum ast_event_control_type_e{
    EVENT_CTRL_NONE,
    EVENT_CTRL_ANY,
    EVENT_CTRL_TRIGGERS

} ast_event_control_type;

typedef struct ast_event_control_t{
    ast_metadata    meta;   
    ast_event_control_type type;
    ast_event_expression * expression;
} ast_event_control;

typedef enum ast_timing_control_statement_type_e{
    TIMING_CTRL_DELAY_CONTROL,
    TIMING_CTRL_EVENT_CONTROL,
    TIMING_CTRL_EVENT_CONTROL_REPEAT
} ast_timing_control_statement_type;

typedef enum ast_delay_ctrl_type_e{
    DELAY_CTRL_VALUE,
    DELAY_CTRL_MINTYPMAX
} ast_delay_ctrl_type;

typedef struct ast_delay_ctrl_t{
    ast_metadata    meta;   
    ast_delay_ctrl_type type;
    union{
        ast_delay_value * value;
        ast_expression  * mintypmax;
    };
} ast_delay_ctrl;

typedef struct ast_timing_control_statement_t{
    ast_metadata    meta;   
    ast_timing_control_statement_type type;
    union{
        ast_delay_ctrl    * delay;
        ast_event_control * event_ctrl;
    };
    ast_expression    * repeat;     
    ast_statement     * statement;  
} ast_timing_control_statement;

ast_wait_statement * ast_new_wait_statement(
    ast_expression * wait_for,
    ast_statement  * statement
);

ast_event_expression * ast_new_event_expression(
    ast_edge trigger_edge,
    ast_expression * expression
);

ast_event_expression * ast_new_event_expression_sequence(
    ast_event_expression * left,
    ast_event_expression * right
);

ast_event_control * ast_new_event_control(
    ast_event_control_type type,
    ast_event_expression * expression
);

ast_delay_ctrl * ast_new_delay_ctrl_value(ast_delay_value * value);

ast_delay_ctrl * ast_new_delay_ctrl_mintypmax(
    ast_expression * mintypmax 
);

ast_timing_control_statement * ast_new_timing_control_statement_delay(
    ast_timing_control_statement_type   type,
    ast_statement                     * statement,
    ast_delay_ctrl                    * delay_ctrl
);


ast_timing_control_statement * ast_new_timing_control_statement_event(
    ast_timing_control_statement_type   type,
    ast_expression                    * repeat,
    ast_statement                     * statement,
    ast_event_control                 * event_ctrl
);

// -------------------------------- Fork Join Sequential ---------------------

typedef struct ast_disable_statement_t{
    ast_metadata    meta;   
    ast_identifier   id;
} ast_disable_statement;

ast_disable_statement * ast_new_disable_statement(ast_identifier   id);


typedef enum ast_block_type_e{
    BLOCK_SEQUENTIAL,
    BLOCK_SEQUENTIAL_INITIAL,
    BLOCK_SEQUENTIAL_ALWAYS,
    BLOCK_FUNCTION_SEQUENTIAL,
    BLOCK_PARALLEL,
} ast_block_type;

typedef struct ast_statement_block_t{
    ast_metadata    meta;   
    ast_block_type   type;
    ast_identifier   block_identifier;
    ast_list       * declarations;
    ast_list       * statements;
    ast_timing_control_statement * trigger; //<! Use if this is an always block
} ast_statement_block;

ast_statement_block * ast_new_statement_block(
    ast_block_type   type,
    ast_identifier   block_identifier,
    ast_list       * declarations,
    ast_list       * statements
);

// -------------------------------- Procedural Blocks and Assignments --------

typedef enum ast_assignment_type_e{
    ASSIGNMENT_CONTINUOUS,  
    ASSIGNMENT_BLOCKING,    
    ASSIGNMENT_NONBLOCKING, 
    ASSIGNMENT_HYBRID, 
} ast_assignment_type;

struct ast_single_assignment_t{
    ast_metadata    meta;   
    ast_lvalue      * lval;         
    ast_expression  * expression;   
    ast_drive_strength * drive_strength; 
    ast_delay3         * delay; 
};

ast_single_assignment * ast_new_single_assignment(
    ast_lvalue         * lval,          
    ast_expression     * expression 
);

typedef struct ast_continuous_assignment_t{
    ast_metadata    meta;   
    ast_list          * assignments; 
} ast_continuous_assignment;

typedef struct ast_procedural_assignment_t{
    ast_metadata    meta;   
    ast_lvalue      * lval;
    ast_expression  * expression;
    ast_timing_control_statement * delay_or_event;
} ast_procedural_assignment;

typedef enum ast_hybrid_assignment_type_e{
    HYBRID_ASSIGNMENT_ASSIGN,
    HYBRID_ASSIGNMENT_DEASSIGN,
    HYBRID_ASSIGNMENT_FORCE_NET,
    HYBRID_ASSIGNMENT_FORCE_VAR,
    HYBRID_ASSIGNMENT_RELEASE_VAR,
    HYBRID_ASSIGNMENT_RELEASE_NET,
}ast_hybrid_assignment_type;

typedef struct ast_hybrid_assignment_t{
    ast_metadata    meta;   
    union
    {
        ast_single_assignment * assignment; 
        ast_lvalue            * lval; 
    };
    ast_hybrid_assignment_type type; 
} ast_hybrid_assignment;

struct ast_assignment_t{
    ast_metadata    meta;   
    ast_assignment_type type;  
    union{
        ast_continuous_assignment * continuous; 
        ast_procedural_assignment * procedural; 
        ast_hybrid_assignment     * hybrid; 
    };
};

ast_assignment * ast_new_hybrid_assignment(
    ast_hybrid_assignment_type type,    
    ast_single_assignment * assignment  
);

ast_assignment * ast_new_hybrid_lval_assignment(
    ast_hybrid_assignment_type type, 
    ast_lvalue * lval   
);

ast_assignment * ast_new_blocking_assignment(
    ast_lvalue * lval, 
    ast_expression  * expression,   
    ast_timing_control_statement* delay_or_event 
);

ast_assignment * ast_new_nonblocking_assignment(
    ast_lvalue * lval,  
    ast_expression  * expression,   
    ast_timing_control_statement * delay_or_event 
);


ast_assignment * ast_new_continuous_assignment(
    ast_list * assignments, 
    ast_drive_strength * strength, 
    ast_delay3 * delay  
);


typedef enum ast_statement_type_e{
    STM_GENERATE=0,           
    STM_ASSIGNMENT=1,         
    STM_CASE=2,               
    STM_CONDITIONAL=3,        
    STM_DISABLE=4,            
    STM_EVENT_TRIGGER=5,      
    STM_LOOP=6,               
    STM_BLOCK=7,              
    STM_BLOCK_ALWAYS=8,       
    STM_BLOCK_INITIAL=9,      
    STM_TIMING_CONTROL=10,    
    STM_FUNCTION_CALL=11,     
    STM_TASK_ENABLE=12,       
    STM_WAIT=13,              
    STM_MODULE_ITEM=14        
} ast_statement_type;


struct ast_statement_t{
    ast_metadata    meta;   
    ast_statement_type      type;
    ast_boolean             is_function_statement;
    ast_node_attributes   * attributes;
    ast_boolean             is_generate_statement;
    union{
        ast_wait_statement              * wait;
        ast_task_enable_statement       * task_enable;
        ast_function_call               * function_call;
        ast_timing_control_statement    * timing_control;
        ast_statement_block             * block;
        ast_loop_statement              * loop;
        ast_event_expression            * event;
        ast_disable_statement           * disable;
        ast_conditional_statement       * conditional;
        ast_case_statement              * case_statement;
        ast_assignment                  * assignment;
        ast_generate_block              * generate_block;
        ast_module_item                 * module_item;
        void                            * data;
    };
};

ast_statement * ast_new_statement(
    ast_node_attributes * attr,
    ast_boolean         is_function_statement,
    void             *  data,
    ast_statement_type  type
);


typedef struct ast_pulse_control_specparam_t{
    ast_metadata    meta;   
    ast_expression * reject_limit;
    ast_expression * error_limit;
    ast_identifier   input_terminal;
    ast_identifier   output_terminal;
} ast_pulse_control_specparam;

ast_pulse_control_specparam * ast_new_pulse_control_specparam(
    ast_expression * reject_limit,
    ast_expression * error_limit
);

struct ast_range_t{
    ast_expression * upper;
    ast_expression * lower;
};

ast_range * ast_new_range(
    ast_expression * upper,
    ast_expression * lower
);


// -------------------------------- UDP Blocks -------------------------------

typedef enum ast_udp_init_val_e{
    UDP_INIT_1,
    UDP_INIT_0,
    UDP_INIT_X
} ast_udp_init_val;

typedef enum ast_level_symbol_e{
    LEVEL_0,
    LEVEL_1,
    LEVEL_B,
    LEVEL_X,
    LEVEL_Q 
} ast_level_symbol;

typedef enum ast_udp_body_type_e{
    UDP_BODY_SEQUENTIAL,
    UDP_BODY_COMBINATORIAL
} ast_udp_body_type;


typedef enum ast_udp_seqential_entry_prefix_e{
    PREFIX_EDGES,
    PREFIX_LEVELS
} ast_udp_seqential_entry_prefix;

typedef enum ast_udp_next_state_e{
    UDP_NEXT_STATE_X,
    UDP_NEXT_STATE_0,
    UDP_NEXT_STATE_1,
    UDP_NEXT_STATE_DC, 
    UDP_NEXT_STATE_QM  
} ast_udp_next_state;

typedef struct ast_udp_port_t{
    ast_metadata    meta;   
    ast_port_direction    direction;
    union{
        ast_identifier        identifier;  
        ast_list            * identifiers; 
    };
    ast_node_attributes * attributes;
    ast_boolean           reg;  
    ast_expression      * default_value;
} ast_udp_port;

typedef struct ast_udp_initial_statement_t{
    ast_metadata    meta;   
    ast_identifier    output_port;
    ast_number      * initial_value;
} ast_udp_initial_statement;

typedef struct ast_udp_body_t{
    ast_metadata    meta;   
    ast_list *        entries;    
    ast_udp_initial_statement * initial; 
    ast_udp_body_type body_type;
} ast_udp_body;

typedef struct ast_udp_combinatorial_entry_t{
    ast_metadata    meta;   
    ast_list * input_levels;
    ast_udp_next_state  output_symbol;
} ast_udp_combinatorial_entry;

typedef struct ast_udp_sequential_entry_t{
    ast_metadata    meta;   
    ast_udp_seqential_entry_prefix entry_prefix;
    union {
        ast_list * edges; 
        ast_list * levels;  
    };
    ast_level_symbol   current_state;
    ast_udp_next_state output;
} ast_udp_sequential_entry;

typedef struct ast_udp_declaration_t{
    ast_metadata    meta;   
    ast_identifier        identifier;
    ast_node_attributes * attributes;
    ast_list            * ports;
    ast_list            * body_entries;    
    ast_udp_initial_statement * initial; 
    ast_udp_body_type     body_type;
} ast_udp_declaration;

typedef struct ast_udp_instance_t{
    ast_metadata    meta;   
    ast_identifier        identifier;
    ast_range           * range;
    ast_lvalue          * output;
    ast_list            * inputs;
} ast_udp_instance;

typedef struct ast_udp_instantiation_t{
    ast_metadata    meta;   
    ast_list            * instances; 
    ast_identifier        identifier;
    ast_drive_strength  * drive_strength;
    ast_delay2          * delay;
} ast_udp_instantiation;


ast_udp_initial_statement * ast_new_udp_initial_statement(
    ast_identifier   output_port,
    ast_number     * initial_value
);


ast_udp_body * ast_new_udp_sequential_body(
    ast_udp_initial_statement * initial_statement,
    ast_list                  * sequential_entries
);

ast_udp_body * ast_new_udp_combinatoral_body(
    ast_list                  * combinatorial_entries
);

ast_udp_combinatorial_entry * ast_new_udp_combinatoral_entry(
    ast_list * input_levels,
    ast_udp_next_state output_symbol
);

ast_udp_sequential_entry * ast_new_udp_sequential_entry(
    ast_udp_seqential_entry_prefix prefix_type,
    ast_list    *                  levels_or_edges,
    ast_level_symbol               current_state,
    ast_udp_next_state             output
);

ast_udp_port * ast_new_udp_port(
    ast_port_direction    direction,
    ast_identifier        identifier, 
    ast_node_attributes * attributes,
    ast_boolean           reg,
    ast_expression      * default_value
);

ast_udp_port * ast_new_udp_input_port(
    ast_list            * identifiers,
    ast_node_attributes * attributes
);

ast_udp_declaration * ast_new_udp_declaration(
    ast_node_attributes * attributes,
    ast_identifier        identifier,
    ast_list            * ports,
    ast_udp_body        * body
);

ast_udp_instance * ast_new_udp_instance(
    ast_identifier        identifier,
    ast_range           * range,
    ast_lvalue          * output,
    ast_list            * inputs
);

ast_udp_instantiation * ast_new_udp_instantiation(
    ast_list            * instances,
    ast_identifier        identifier, 
    ast_drive_strength  * drive_strength,
    ast_delay2          * delay
);


// -------------------------------- Generate Statements ----------------------

struct ast_generate_block_t{
    ast_metadata    meta;   
    ast_identifier   identifier;
    ast_list       * generate_items;
};

ast_generate_block * ast_new_generate_block(
    ast_identifier   identifier,
    ast_list       * generate_items
);

ast_statement * ast_new_generate_item(
    ast_statement_type type,
    void    *          construct
);

// -------------------------------- Module Instantiation ---------------------

typedef struct ast_module_instantiation_t {
    ast_metadata    meta;   
    ast_boolean     resolved; 
    union{
        ast_identifier  module_identifer; 
        ast_module_declaration * declaration; 
    };
    ast_list              * module_parameters;
    ast_list              * module_instances;
} ast_module_instantiation;

ast_module_instantiation * ast_new_module_instantiation(
    ast_identifier          module_identifer,
    ast_list              * module_parameters,
    ast_list              * module_instances
);

typedef struct ast_module_instance_t{
    ast_metadata    meta;   
    ast_identifier          instance_identifier;
    ast_list              * port_connections;
} ast_module_instance;


ast_module_instance * ast_new_module_instance(
    ast_identifier          instance_identifier,
    ast_list              * port_connections
);

typedef struct ast_port_connection_t{
    ast_metadata    meta;   
    ast_identifier   port_name;
    ast_expression * expression;
} ast_port_connection;

ast_port_connection * ast_new_named_port_connection(
    ast_identifier   port_name,
    ast_expression * expression
);

// -------------------------------- Primitives -------------------------------

typedef enum ast_switchtype_e{
    SWITCH_CMOS,
    SWITCH_RCMOS,
    SWITCH_NMOS,
    SWITCH_PMOS,
    SWITCH_RNMOS,
    SWITCH_RPMOS,
    SWITCH_TRAN,
    SWITCH_RTRAN
} ast_switchtype;

typedef struct ast_switch_gate_t{
    ast_metadata    meta;   
    ast_switchtype type;
    union {
        ast_delay3 * delay3;
        ast_delay2 * delay2; 
    };
} ast_switch_gate;

ast_switch_gate * ast_new_switch_gate_d3(
    ast_switchtype type,
    ast_delay3     * delay
);

ast_switch_gate * ast_new_switch_gate_d2(
    ast_switchtype type,
    ast_delay2     * delay
);

typedef enum ast_primitive_strength_e{
    STRENGTH_HIGHZ0,
    STRENGTH_HIGHZ1,
    STRENGTH_SUPPLY0,
    STRENGTH_STRONG0,
    STRENGTH_PULL0,
    STRENGTH_WEAK0,
    STRENGTH_SUPPLY1,
    STRENGTH_STRONG1,
    STRENGTH_PULL1,
    STRENGTH_WEAK1,
    STRENGTH_NONE
} ast_primitive_strength;

typedef enum ast_pull_direction_e{
    PULL_UP,
    PULL_DOWN,
    PULL_NONE
 }ast_pull_direction;

 typedef struct ast_pull_strength_t{
    ast_metadata    meta;   
    ast_primitive_strength strength_1;
    ast_primitive_strength strength_2;
 } ast_pull_strength;

ast_pull_strength * ast_new_pull_stregth(
    ast_primitive_strength strength_1,
    ast_primitive_strength strength_2
);

typedef struct ast_primitive_pull_strength_t{
    ast_metadata    meta;   
    ast_pull_direction       direction;
    ast_primitive_strength   strength_1;
    ast_primitive_strength   strength_0;
} ast_primitive_pull_strength;

ast_primitive_pull_strength * ast_new_primitive_pull_strength(
    ast_pull_direction       direction,
    ast_primitive_strength   strength_1,
    ast_primitive_strength   strength_0
);

typedef struct ast_pull_gate_instance_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_lvalue        * output_terminal;
} ast_pull_gate_instance;

typedef struct ast_pass_switch_instance_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_lvalue        * terminal_1;
    ast_lvalue        * terminal_2;
} ast_pass_switch_instance;

typedef enum ast_gatetype_n_input_e{
    N_IN_AND,
    N_IN_NAND,
    N_IN_NOR,
    N_IN_OR ,
    N_IN_XOR,
    N_IN_XNOR
} ast_gatetype_n_input;

typedef struct ast_n_input_gate_instances_t{
    ast_metadata    meta;   
    ast_gatetype_n_input    type;
    ast_delay3            * delay;
    ast_drive_strength    * drive_strength;
    ast_list              * instances;
} ast_n_input_gate_instances;

ast_n_input_gate_instances * ast_new_n_input_gate_instances(
    ast_gatetype_n_input    type,
    ast_delay3            * delay,
    ast_drive_strength    * drive_strength,
    ast_list              * instances
);

typedef struct ast_n_input_gate_instance_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_list          * input_terminals;
    ast_lvalue        * output_terminal;
} ast_n_input_gate_instance;

typedef enum ast_enable_gatetype_e{
    EN_BUFIF0,
    EN_BUFIF1,
    EN_NOTIF0,
    EN_NOTIF1 
} ast_enable_gatetype;

typedef struct ast_enable_gate_instances{
    ast_metadata    meta;   
    ast_enable_gatetype     type;
    ast_delay3            * delay;
    ast_drive_strength    * drive_strength;
    ast_list              * instances;
} ast_enable_gate_instances;

ast_enable_gate_instances * ast_new_enable_gate_instances(
    ast_gatetype_n_input    type,
    ast_delay3            * delay,
    ast_drive_strength    * drive_strength,
    ast_list              * instances
);

typedef struct ast_enable_gate_instance_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_lvalue        * output_terminal;
    ast_expression    * enable_terminal;
    ast_expression    * input_terminal;
} ast_enable_gate_instance;

typedef struct ast_mos_switch_instance_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_lvalue        * output_terminal;
    ast_expression    * enable_terminal;
    ast_expression    * input_terminal;
} ast_mos_switch_instance;

typedef struct ast_cmos_switch_instance_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_lvalue        * output_terminal;
    ast_expression    * ncontrol_terminal;
    ast_expression    * pcontrol_terminal;
    ast_expression    * input_terminal;
} ast_cmos_switch_instance;

typedef struct ast_pass_enable_switch_t{
    ast_metadata    meta;   
    ast_identifier      name;
    ast_lvalue        * terminal_1;
    ast_lvalue        * terminal_2;
    ast_expression    * enable;
} ast_pass_enable_switch;

typedef enum ast_pass_enable_switchtype_e{
    PASS_EN_TRANIF0,
    PASS_EN_TRANIF1,
    PASS_EN_RTRANIF0,
    PASS_EN_RTRANIF1 
} ast_pass_enable_switchtype;

typedef struct ast_pass_enable_switches_t{
    ast_metadata    meta;   
    ast_pass_enable_switchtype    type;
    ast_delay2                  * delay;
    ast_list                    * switches;
} ast_pass_enable_switches;

typedef enum ast_n_output_gatetype_e{
    N_OUT_BUF,
    N_OUT_NOT
} ast_n_output_gatetype;

typedef struct ast_n_output_gate_instance_t{
    ast_metadata    meta;   
    ast_identifier                name;
    ast_list                    * outputs;
    ast_expression              * input;
} ast_n_output_gate_instance;

typedef struct ast_n_output_gate_instances_t{
    ast_metadata    meta;   
    ast_n_output_gatetype         type;
    ast_delay2                  * delay;
    ast_drive_strength          * drive_strength;
    ast_list                    * instances;
} ast_n_output_gate_instances;

ast_n_output_gate_instance * ast_new_n_output_gate_instance(
    ast_identifier                name,
    ast_list                    * outputs,
    ast_expression              * input
);

ast_n_output_gate_instances * ast_new_n_output_gate_instances(
    ast_n_output_gatetype         type,
    ast_delay2                  * delay,
    ast_drive_strength          * drive_strength,
    ast_list                    * instances
);

ast_pass_enable_switches * ast_new_pass_enable_switches(
    ast_pass_enable_switchtype    type,
    ast_delay2                  * delay,
    ast_list                    * switches 
);

ast_pass_enable_switch * ast_new_pass_enable_switch(
    ast_identifier      name,
    ast_lvalue        * terminal_1,
    ast_lvalue        * terminal_2,
    ast_expression    * enable
);

ast_pull_gate_instance * ast_new_pull_gate_instance(
    ast_identifier      name,
    ast_lvalue        * output_terminal
);

ast_pass_switch_instance * ast_new_pass_switch_instance(
    ast_identifier      name,
    ast_lvalue        * terminal_1,
    ast_lvalue        * terminal_2
);

ast_n_input_gate_instance * ast_new_n_input_gate_instance(
    ast_identifier      name,
    ast_list          * input_terminals,
    ast_lvalue        * output_terminal
);

ast_enable_gate_instance * ast_new_enable_gate_instance(
    ast_identifier      name,
    ast_lvalue        * output_terminal,
    ast_expression    * enable_terminal,
    ast_expression    * input_terminal
);

ast_mos_switch_instance * ast_new_mos_switch_instance(
    ast_identifier      name,
    ast_lvalue        * output_terminal,
    ast_expression    * enable_terminal,
    ast_expression    * input_terminal
);

ast_cmos_switch_instance * ast_new_cmos_switch_instance(
    ast_identifier      name,
    ast_lvalue        * output_terminal,
    ast_expression    * ncontrol_terminal,
    ast_expression    * pcontrol_terminal,
    ast_expression    * input_terminal
);

typedef struct ast_switches_t{
    ast_metadata    meta;   
    ast_switch_gate * type;
    ast_list        * switches;
} ast_switches;

ast_switches * ast_new_switches(ast_switch_gate * type, ast_list * switches);

typedef enum ast_gate_type_e{
    GATE_CMOS,      
    GATE_MOS,       
    GATE_PASS,      
    GATE_ENABLE,    
    GATE_N_OUT,     
    GATE_N_IN,      
    GATE_PASS_EN,   
    GATE_PULL_UP,   
    GATE_PULL_DOWN  
} ast_gate_type;


typedef struct ast_gate_instantiation_t{
    ast_metadata    meta;   
    ast_gate_type type;
    union{
        ast_switches * switches;
        ast_pass_enable_switches * pass_en;
        ast_enable_gate_instances * enable;
        ast_n_input_gate_instances * n_in;
        ast_n_output_gate_instances * n_out;
        struct{
            ast_primitive_pull_strength   * pull_strength;
            ast_list                      * pull_gates;
        };
    };
} ast_gate_instantiation;

ast_gate_instantiation * ast_new_gate_instantiation(ast_gate_type type);

// -------------------------------- Delays -----------------------------------

typedef enum ast_delay_value_type_e{
    DELAY_VAL_PARAMETER,
    DELAY_VAL_SPECPARAM,
    DELAY_VAL_NUMBER,
    DELAY_VAL_MINTYPMAX
} ast_delay_value_type;

typedef struct ast_delay_value_t{
    ast_metadata    meta;   
    ast_delay_value_type type;
    union{
        ast_identifier parameter_id;
        ast_identifier specparam_id;
        ast_number  *  unsigned_number;
        ast_minmax_exp mintypmax;
        void        *  data;
    };
} ast_delay_value;

struct ast_delay3_t{
    ast_metadata    meta;   
    ast_delay_value * min;
    ast_delay_value * max;
    ast_delay_value * avg;
};

struct ast_delay2_t{
    ast_metadata    meta;   
    ast_delay_value * min;
    ast_delay_value * max;
};

ast_delay_value * ast_new_delay_value(
    ast_delay_value_type type,
    void * data
);

ast_delay3 * ast_new_delay3(
    ast_delay_value * min,
    ast_delay_value * avg,
    ast_delay_value * max
);

ast_delay2 * ast_new_delay2(
    ast_delay_value * min,
    ast_delay_value * max
);


// -------------------------------- Strengths --------------------------------

typedef enum ast_charge_strength_e{
    CHARGE_SMALL,   
    CHARGE_MEDIUM,  
    CHARGE_LARGE,   
    CHARGE_DEFAULT  
} ast_charge_strength;

// -------------------------------- Nets and Variables -----------------------

// -------------------------------- Port Declarations ------------------------

typedef enum ast_net_type_e{
    NET_TYPE_SUPPLY0,   
    NET_TYPE_SUPPLY1,   
    NET_TYPE_TRI,       
    NET_TYPE_TRIAND,    
    NET_TYPE_TRIOR,     
    NET_TYPE_TRIREG,    
    NET_TYPE_WIRE,      
    NET_TYPE_WAND,      
    NET_TYPE_WOR,       
    NET_TYPE_NONE       
} ast_net_type;

typedef struct ast_port_declaration_t{
    ast_metadata    meta;   
    ast_port_direction  direction;      
    ast_net_type        net_type;       
    ast_boolean         net_signed;     
    ast_boolean         is_reg;         
    ast_boolean         is_variable;    
    ast_range         * range;          
    ast_list          * port_names;     
} ast_port_declaration;

ast_port_declaration * ast_new_port_declaration(
    ast_port_direction  direction,      
    ast_net_type        net_type,       
    ast_boolean         net_signed,     
    ast_boolean         is_reg,         
    ast_boolean         is_variable,    
    ast_range         * range,          
    ast_list          * port_names      
);

// -------------------------------- Type Declarations ------------------------

typedef enum ast_declaration_type_e{
    DECLARE_EVENT,
    DECLARE_GENVAR,
    DECLARE_INTEGER,
    DECLARE_TIME,
    DECLARE_REALTIME,
    DECLARE_REAL,
    DECLARE_NET,
    DECLARE_REG,
    DECLARE_UNKNOWN 
} ast_declaration_type;

typedef struct ast_type_declaration_t{
    ast_metadata    meta;   
    ast_declaration_type  type;
    ast_net_type          net_type;
    ast_list            * identifiers;
    ast_delay3          * delay;
    ast_drive_strength  * drive_strength;
    ast_charge_strength   charge_strength;
    ast_boolean           vectored;
    ast_boolean           scalared;
    ast_boolean           is_signed;
    ast_range           * range;
} ast_type_declaration;

typedef struct ast_net_declaration_t{
    ast_metadata         meta;       
    ast_net_type         type;       
    ast_identifier       identifier; 
    ast_delay3         * delay;      
    ast_drive_strength * drive;      
    ast_range          * range;      
    ast_boolean          vectored;
    ast_boolean          scalared;
    ast_boolean          is_signed;
    ast_expression     * value;      
} ast_net_declaration;


typedef struct ast_reg_declaration_t{
    ast_metadata         meta;       
    ast_identifier       identifier; 
    ast_range          * range;      
    ast_boolean          is_signed;
    ast_expression     * value;      
} ast_reg_declaration;

typedef struct ast_var_declaration_t{
    ast_metadata        meta;       
    ast_identifier      identifier; 
    ast_declaration_type type;      
} ast_var_declaration;

ast_list * ast_new_net_declaration(
    ast_type_declaration * type_dec
);

ast_list * ast_new_reg_declaration(
    ast_type_declaration * type_dec
);

ast_list * ast_new_var_declaration(
    ast_type_declaration * type_dec
);


ast_type_declaration * ast_new_type_declaration(ast_declaration_type type);

// -------------------------------- Module Parameters ------------------------

typedef enum ast_parameter_type_e{
    PARAM_INTEGER,
    PARAM_REAL,
    PARAM_REALTIME,
    PARAM_TIME,
    PARAM_GENERIC,  
    PARAM_SPECPARAM
} ast_parameter_type;

typedef struct ast_parameter_declarations_t{
    ast_metadata    meta;   
    ast_list        * assignments;
    ast_boolean       signed_values; 
    ast_boolean       local;        
    ast_range       * range; 
    ast_parameter_type  type;
} ast_parameter_declarations;

ast_parameter_declarations * ast_new_parameter_declarations(
    ast_list        * assignments,
    ast_boolean       signed_values,
    ast_boolean       local,
    ast_range       * range,
    ast_parameter_type  type 
);

// --------------------------- Block Item Declaration ------------------------

typedef struct ast_block_reg_declaration_t{
    ast_metadata    meta;   
    ast_boolean   is_signed;     
    ast_range   * range;         
    ast_list    * identifiers;   
} ast_block_reg_declaration;

ast_block_reg_declaration * ast_new_block_reg_declaration(
    ast_boolean   is_signed,    
    ast_range   * range,        
    ast_list    * identifiers   
);

typedef enum ast_block_item_declaration_type_e{
    BLOCK_ITEM_REG, 
    BLOCK_ITEM_PARAM,
    BLOCK_ITEM_TYPE 
} ast_block_item_declaration_type;

struct ast_block_item_declaration_t{
    ast_metadata    meta;   
    ast_block_item_declaration_type type;
    ast_node_attributes             * attributes;
    union{
        ast_block_reg_declaration * reg; 
        ast_type_declaration * event_or_var;
        ast_parameter_declarations *  parameters; 
    };
};

ast_block_item_declaration * ast_new_block_item_declaration(
    ast_block_item_declaration_type type, 
    ast_node_attributes             * attributes 
);


// -------------------------------- Function Declaration ---------------------

typedef enum ast_task_port_type_e{
    PORT_TYPE_TIME,     
    PORT_TYPE_REAL,     
    PORT_TYPE_REALTIME, 
    PORT_TYPE_INTEGER,  
    PORT_TYPE_NONE,     
} ast_task_port_type;

typedef struct ast_range_or_type_t{
    ast_metadata    meta;   
    ast_boolean is_range;   
    union{
        ast_range * range;  
        ast_task_port_type type; 
    };
} ast_range_or_type;

ast_range_or_type * ast_new_range_or_type(ast_boolean is_range);


typedef struct ast_function_declaration_t{
    ast_metadata    meta;   
    ast_boolean         automatic;         
    ast_boolean         is_signed;         
    ast_boolean         function_or_block; 
    ast_range_or_type  *rot;               
    ast_identifier      identifier;        
    ast_list           *item_declarations; 
    ast_statement      *statements;        
} ast_function_declaration;

ast_function_declaration * ast_new_function_declaration(
    ast_boolean         automatic,         
    ast_boolean         is_signed,         
    ast_boolean         function_or_block, 
    ast_range_or_type  *rot,               
    ast_identifier      identifier,        
    ast_list           *item_declarations, 
    ast_statement      *statements         
);

/*
@brief Fully describes a set of task arguments with the same properties.
*/
typedef struct ast_task_port_t{
    ast_metadata    meta;   
    ast_port_direction direction;   
    ast_boolean        reg;         
    ast_boolean        is_signed;   
    ast_range        * range;       
    ast_task_port_type type;        
    ast_list         * identifiers; 
} ast_task_port;


/*
@brief Creates and returns a new representation of a task or function
argument.
*/
ast_task_port * ast_new_task_port(
    ast_port_direction direction,   
    ast_boolean        reg,         
    ast_boolean        is_signed,   
    ast_range        * range,       
    ast_task_port_type type,        
    ast_list         * identifiers 
);

typedef struct ast_function_item_declaration_t{
    ast_metadata    meta;   
    ast_boolean is_port_declaration; 
    union{
        ast_block_item_declaration  * block_item; 
        ast_task_port               * port_declaration; 
    };
} ast_function_item_declaration;

ast_function_item_declaration * ast_new_function_item_declaration();

// -------------------------------- Task Declaration -------------------------

typedef struct ast_task_declaration_t{
    ast_metadata    meta;   
    ast_boolean         automatic;      
    ast_identifier      identifier;     
    ast_list        *   ports;          
    ast_list        *   declarations;   
    ast_statement   *   statements;     
} ast_task_declaration;

ast_task_declaration * ast_new_task_declaration(
    ast_boolean         automatic,      
    ast_identifier      identifier,     
    ast_list        *   ports,          
    ast_list        *   declarations,   
    ast_statement   *   statements      
);



// -------------------------------- Module Items -----------------------------

typedef enum ast_module_item_type_e{
    MOD_ITEM_PORT_DECLARATION, 
    MOD_ITEM_GENERATED_INSTANTIATION,
    MOD_ITEM_PARAMETER_DECLARATION, 
    MOD_ITEM_SPECIFY_BLOCK,
    MOD_ITEM_SPECPARAM_DECLARATION,
    MOD_ITEM_PARAMETER_OVERRIDE,
    MOD_ITEM_CONTINOUS_ASSIGNMENT, 
    MOD_ITEM_GATE_INSTANTIATION,
    MOD_ITEM_UDP_INSTANTIATION,
    MOD_ITEM_MODULE_INSTANTIATION,
    MOD_ITEM_INITIAL_CONSTRUCT,
    MOD_ITEM_ALWAYS_CONSTRUCT,
    MOD_ITEM_NET_DECLARATION,
    MOD_ITEM_REG_DECLARATION,
    MOD_ITEM_INTEGER_DECLARATION,
    MOD_ITEM_REAL_DECLARATION,
    MOD_ITEM_TIME_DECLARATION,
    MOD_ITEM_REALTIME_DECLARATION,
    MOD_ITEM_EVENT_DECLARATION,
    MOD_ITEM_GENVAR_DECLARATION,
    MOD_ITEM_TASK_DECLARATION,
    MOD_ITEM_FUNCTION_DECLARATION
} ast_module_item_type;

struct ast_module_item_t{
    ast_metadata    meta;   
    ast_module_item_type type;
    ast_node_attributes *attributes;
    union{
        ast_port_declaration        * port_declaration;
        ast_generate_block          * generated_instantiation;
        ast_parameter_declarations  * parameter_declaration;
        ast_list                    * specify_block;
        ast_parameter_declarations  * specparam_declaration;
        ast_list                    * parameter_override;
        ast_continuous_assignment   * continuous_assignment;
        ast_gate_instantiation      * gate_instantiation;
        ast_udp_instantiation       * udp_instantiation;
        ast_module_instantiation    * module_instantiation;
        ast_statement               * always_construct;
        ast_statement               * initial_construct;
        ast_type_declaration        * net_declaration;
        ast_type_declaration        * reg_declaration;
        ast_type_declaration        * integer_declaration;
        ast_type_declaration        * real_declaration;
        ast_type_declaration        * time_declaration;
        ast_type_declaration        * realtime_declaration;
        ast_type_declaration        * event_declaration;
        ast_type_declaration        * genvar_declaration;
        ast_task_declaration        * task_declaration;
        ast_function_declaration    * function_declaration;
    };
};

ast_module_item * ast_new_module_item(
    ast_node_attributes * attributes,
    ast_module_item_type  type
);

ast_statement_block * ast_extract_statement_block(
    ast_statement_type  type,
    ast_statement     * body
);

// -------------------------------- Module Declarations ----------------------

struct ast_module_declaration_t{
    ast_metadata    meta;   
    ast_node_attributes * attributes; 
    ast_identifier        identifier; 
    ast_list * always_blocks; 
    ast_list * continuous_assignments; 
    ast_list * event_declarations; 
    ast_list * function_declarations; 
    ast_list * gate_instantiations; 
    ast_list * genvar_declarations; 
    ast_list * generate_blocks; 
    ast_list * initial_blocks; 
    ast_list * integer_declarations; 
    ast_list * local_parameters; 
    ast_list * module_instantiations; 
    ast_list * module_parameters; 
    ast_list * module_ports; 
    ast_list * net_declarations; 
    ast_list * parameter_overrides; 
    ast_list * real_declarations; 
    ast_list * realtime_declarations; 
    ast_list * reg_declarations; 
    ast_list * specify_blocks; 
    ast_list * specparams; 
    ast_list * task_declarations; 
    ast_list * time_declarations; 
    ast_list * udp_instantiations; 

} ;

ast_module_declaration * ast_new_module_declaration(
    ast_node_attributes * attributes,
    ast_identifier        identifier,
    ast_list            * parameters,
    ast_list            * ports,
    ast_list            * constructs
);


// -------------------------------- Identifiers ------------------------------

typedef enum ast_identifier_type_e{
    ID_ARRAYED,
    ID_BLOCK,
    ID_CELL,
    ID_CONFIG,
    ID_ESCAPED_ARRAYED,
    ID_ESCAPED_HIERARCHICAL_BRANCH,
    ID_ESCAPED_HIERARCHICAL,
    ID_ESCAPED_HIERARCHICALS,
    ID_ESCAPED,
    ID_EVENT,
    ID_EVENT_TRIGGER,
    ID_FUNCTION,
    ID_GATE_INSTANCE,
    ID_GENERATE_BLOCK,
    ID_GENVAR,
    ID_HIERARCHICAL_BLOCK,
    ID_HIERARCHICAL_EVENT,
    ID_HIERARCHICAL_FUNCTION,
    ID_HIERARCHICAL,
    ID_HIERARCHICAL_NET,
    ID_HIERARCHICAL_TASK,
    ID_HIERARCHICAL_VARIABLE,
    ID_CSV,
    ID_INOUT_PORT,
    ID_INPUT,
    ID_INPUT_PORT,
    ID_INSTANCE,
    ID_LIBRARY,
    ID_MODULE,                      
    ID_MODULE_INSTANCE,             
    ID_NAME_OF_GATE_INSTANCE,
    ID_NAME_OF_INSTANCE,
    ID_NET,
    ID_OUTPUT,
    ID_OUTPUT_PORT,
    ID_PARAMETER,
    ID_PORT,
    ID_REAL,
    ID_SIMPLE_ARRAYED,
    ID_SIMPLE_HIERARCHICAL_BRANCH,
    ID_SIMPLE_HIERARCHICAL,
    ID_SIMPLE,
    ID_SPECPARAM,
    ID_SYSTEM_FUNCTION,
    ID_SYSTEM_TASK,
    ID_TASK,
    ID_TOPMODULE,
    ID_UNKNOWN,                     
    ID_UNEXPANDED_MACRO,            
    ID_UDP,                         
    ID_UDP_INSTANCE,                
    ID_VARIABLE,
} ast_identifier_type;

typedef enum ast_id_range_or_index_e{
    ID_HAS_RANGE,   
    ID_HAS_RANGES,   
    ID_HAS_INDEX,   
    ID_HAS_NONE     
} ast_id_range_or_index;

struct ast_identifier_t{
    ast_metadata    meta;   
    ast_identifier_type   type;         
    char                * identifier;   
    unsigned int          from_line;    
    ast_boolean           is_system;    
    ast_identifier        next;         
    ast_id_range_or_index range_or_idx; 
    union{
        ast_list        * ranges; 
        ast_range       * range; 
        ast_expression  * index; 
    };
};

char * ast_identifier_tostring(ast_identifier id);

int ast_identifier_cmp(
    ast_identifier a,
    ast_identifier b
);

ast_identifier ast_new_identifier(
    char         * identifier,  
    unsigned int   from_line    
);


ast_identifier ast_new_system_identifier(
    char         * identifier,  
    unsigned int   from_line    
);

ast_identifier ast_append_identifier(
    ast_identifier parent,
    ast_identifier child
);

void ast_identifier_set_range(
    ast_identifier    id,
    ast_range       * range
);

void ast_identifier_set_index(
    ast_identifier    id,
    ast_expression  * index
);

// -------------------------------- Configuration Source ---------------------

typedef struct ast_config_rule_statement_t{
    ast_metadata    meta;   
    ast_boolean    is_default;
    ast_boolean    multiple_clauses; //<! IFF TRUE use clauses, else clause_2
    ast_identifier clause_1;    
    union{
        ast_identifier clause_2;    
        ast_list     * clauses;     
    };
} ast_config_rule_statement;


ast_config_rule_statement * ast_new_config_rule_statement(
    ast_boolean    is_default,
    ast_identifier clause_1,    
    ast_identifier clause_2     
);

typedef struct ast_config_declaration_t{
    ast_metadata    meta;   
    ast_identifier  identifier;
    ast_identifier  design_statement;
    ast_list      * rule_statements;
} ast_config_declaration;

ast_config_declaration * ast_new_config_declaration(
    ast_identifier  identifier,
    ast_identifier  design_statement,
    ast_list      * rule_statements
);

// -------------------------------- Library Source Text ----------------------

typedef struct ast_library_declaration_t{
    ast_metadata    meta;   
    ast_identifier  identifier;
    ast_list      * file_paths;
    ast_list      * incdirs;
} ast_library_declaration;

ast_library_declaration * ast_new_library_declaration(
    ast_identifier  identifier,
    ast_list      * file_paths,
    ast_list      * incdirs
);

typedef enum ast_library_item_type_e{
    LIB_LIBRARY,
    LIB_INCLUDE,
    LIB_CONFIG
} ast_library_item_type;

typedef struct ast_library_descriptions_t{
    ast_metadata    meta;   
    ast_library_item_type type;
    union{
        ast_library_declaration * library;
        ast_config_declaration  * config;
        ast_string                include;
    };
} ast_library_descriptions;

ast_library_descriptions * ast_new_library_description(
    ast_library_item_type type
);

// -------------------------------- Compiler Directives ----------------------

// -------------------------------- Grammar Top Level ------------------------

typedef enum ast_source_item_type_e{
    SOURCE_MODULE = 0,  
    SOURCE_UDP    = 1   
} ast_source_item_type;

typedef struct ast_source_item_t{
    ast_metadata    meta;   
    ast_source_item_type type;  
    union{
        ast_module_declaration * module; 
        ast_udp_declaration    * udp;   
    };
} ast_source_item;

ast_source_item * ast_new_source_item(ast_source_item_type type);

typedef struct verilog_source_tree_t{
    ast_list    *   modules;
    ast_list    *   primitives;
    ast_list    *   configs;
    ast_list    *   libraries;
} verilog_source_tree;


extern verilog_source_tree * yy_verilog_source_tree;


verilog_source_tree * verilog_new_source_tree();

void verilog_free_source_tree(
    verilog_source_tree * tofree
);

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

typedef enum ast_node_type_e
{
    ATTRIBUTE_LIST, 
    EXPRESSION,     
    IDENTIFIER,     //<! An identifier.
    MODULE,         //<! A design module.
    NONE,           
} ast_node_type;

struct ast_node_t
{
    ast_node     * parent;      
    unsigned int   child_count; 
    ast_node     * children;    
    ast_node_attributes * attributes;
    ast_node_type  type;        
};

ast_node * ast_node_new();


#endif