codegen.c File Reference

#include <stdio.h>
#include <assert.h>
#include "defines.h"
#include "codegen.h"
#include "util.h"
#include "vector.h"
#include "func_unit.h"
#include "expr.h"
#include "obfuscate.h"

Functions
static void	codegen_create_expr_helper (char **code, int code_index, char *first, char **left, unsigned int left_depth, bool first_same_line, char *middle, char **right, unsigned int right_depth, bool last_same_line, char *last)
static void	codegen_create_expr (char ***code, unsigned int *code_depth, int curr_line, char *first, char **left, unsigned int left_depth, expression *left_exp, char *middle, char **right, unsigned int right_depth, expression *right_exp, char *last)
void	codegen_gen_expr (expression *expr, exp_op_type parent_op, char ***code, unsigned int *code_depth, func_unit *funit)
	Creates Verilog code string from specified expression tree.
Variables
bool	flag_use_line_width
int	line_width
char	user_msg [USER_MSG_LENGTH]
const exp_info	exp_op_info [EXP_OP_NUM]

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

4/11/2002

This file and its functions are used solely by the Covered report command. When the user specifies that Covered should report detailed or verbose reports, it is necessary to output the Verilog code associated with line and combinational logic coverage. However, the actual Verilog code read from the file is not stored internally anywhere inside of the Covered. By doing this, Covered can do two things: (1) save on memory that otherwise need to be stored or save on processing (have to reparse the code for reports) and (2) allows Covered to "clean up the source code making it easier to read (hopefully) and easier to underline missed combinational logic cases.

What the code generator does then is to recreate the source Verilog from the internally stored expression tree. This allows associated Verilog code with uncovered logic to quickly and efficiently be display to the user. The code generator is used in combination with the underlining facility (located in the comb.c file).

---

Function Documentation

static void codegen_create_expr	(	char ***	code,
		unsigned int *	code_depth,
		int	curr_line,
		char *	first,
		char **	left,
		unsigned int	left_depth,
		expression *	left_exp,
		char *	middle,
		char **	right,
		unsigned int	right_depth,
		expression *	right_exp,
		char *	last
	)			[static]

Allocates enough memory in code array to store all code lines for the current expression. Calls the helper function to actually generate code lines (to populate the code array).

Parameters:

	code	Pointer to an array of strings which will contain generated code lines
	code_depth	Pointer to number of strings contained in code array
	curr_line	Line number of current expression
	first	String value coming before left expression string
	left	Array of strings for left expression code
	left_depth	Number of strings contained in left array
	left_exp	Pointer to left expression
	middle	String value coming after left expression string
	right	Array of strings for right expression code
	right_depth	Number of strings contained in right array
	right_exp	Pointer to right expression
	last	String value coming after right expression string

References codegen_create_expr_helper(), expression_get_first_line_expr(), expression_get_last_line_expr(), flag_use_line_width, expression_s::line, line_width, malloc_safe, PROFILE, and TRUE.

Referenced by codegen_gen_expr().

  { PROFILE(CODEGEN_CREATE_EXPR);

  int          total_len = 0;    /* Total length of first, left, middle, right, and last strings */
  unsigned int i;                /* Loop iterator */ 
  expression*  last_exp;         /* Last expression of left expression tree */
  expression*  first_exp;        /* First expression of right expression tree */
  int          left_line_start;  /* Line number of first expression of left expression tree */
  int          left_line_end;    /* Line number of last expression of left expression tree */
  int          right_line;       /* Line number of first expression of right expression tree */

/*
  printf( "-----------------------------------------------------------------\n" );
  printf( "codegen_create_expr, curr_line: %d, first: %s, middle: %s, last: %s\n", curr_line, first, middle, last );
  printf( "left code (%d):\n", left_depth );
  for( i=0; i<left_depth; i++ ) {
    printf( "  .%s.\n", left[i] );
  }
  printf( "right_code (%d):\n", right_depth );
  for( i=0; i<right_depth; i++ ) {
    printf( "  .%s.\n", right[i] );
  }
*/

  *code_depth = 0;

  if( (left_depth > 0) || (right_depth > 0) ) {

    /* Allocate enough storage in code array for these lines */
    if( left_depth > 0 ) {
      *code_depth += left_depth;
    }
    if( right_depth > 0 ) {
      *code_depth += right_depth;
    }

    /* Calculate last and first expression values */
    if( left_exp != NULL ) {
      first_exp       = expression_get_first_line_expr( left_exp );
      left_line_start = first_exp->line;
      last_exp        = expression_get_last_line_expr( left_exp );
      left_line_end   = last_exp->line;
    } else {
      left_line_start = 0;
      left_line_end   = 0;
    }
    if( right_exp != NULL ) {
      first_exp  = expression_get_first_line_expr( right_exp );
      right_line = first_exp->line;
    } else {
      right_line = 0;
    }

    if( flag_use_line_width ) {

      if( first != NULL   ) { total_len += strlen( first );                }
      if( left_depth > 0  ) { total_len += strlen( left[left_depth - 1] ); }
      if( middle != NULL  ) { total_len += strlen( middle );               }
      if( right_depth > 0 ) { total_len += strlen( right[0] );             }
      if( last != NULL    ) { total_len += strlen( last );                 }

      if( (left_depth > 0) && (right_depth > 0) && (total_len <= line_width) ) {
        *code_depth -= 1;
      }

    } else {

      // printf( "left_line_start: %d, left_line_end: %d, right_line: %d, curr_line: %d\n", left_line_start, left_line_end, right_line, curr_line );

      if( (left_depth > 0) && (right_depth > 0) && (left_line_end == right_line) ) {
        *code_depth -= 1;
      }
      if( (left_depth > 0) && (left_line_start > curr_line) ) {
        *code_depth += 1;
      }
      if( (left_depth == 0) && (right_depth > 0) && (right_line != curr_line) ) {
        *code_depth += 1;
      }

    }

    *code = (char**)malloc_safe( sizeof( char* ) * (*code_depth) );
    for( i=0; i<(*code_depth); i++ ) {
      (*code)[i] = NULL;
    }

    /* Now generate expression string array */
    if( flag_use_line_width ) {
      codegen_create_expr_helper( *code, 0, first, left, left_depth, TRUE, middle,
                                  right, right_depth, (total_len <= line_width), last );
    } else {
      codegen_create_expr_helper( *code, 0, first, left, left_depth, (curr_line >= left_line_start), middle,
                                  right, right_depth, (left_line_end == right_line), last );
    }

/*
    printf( "CODE (%d):\n", *code_depth );
    for( i=0; i<(*code_depth); i++ ) {
      printf( "%s\n", (*code)[i] );
    }
*/

  }

}

static void codegen_create_expr_helper	(	char **	code,
		int	code_index,
		char *	first,
		char **	left,
		unsigned int	left_depth,
		bool	first_same_line,
		char *	middle,
		char **	right,
		unsigned int	right_depth,
		bool	last_same_line,
		char *	last
	)			[static]

Generates multi-line expression code strings from current, left, and right expressions.

Parameters:

	code	Array of strings containing generated code lines
	code_index	Index to current string in code array to set
	first	String value coming before left expression string
	left	Array of strings for left expression code
	left_depth	Number of strings contained in left array
	first_same_line	Set to TRUE if left expression is on the same line as the current expression
	middle	String value coming after left expression string
	right	Array of strings for right expression code
	right_depth	Number of strings contained in right array
	last_same_line	Set to TRUE if right expression is on the same line as the left expression
	last	String value coming after right expression string

References FALSE, free_safe, malloc_safe, PROFILE, and strdup_safe.

Referenced by codegen_create_expr().

  { PROFILE(CODEGEN_CREATE_EXPR_HELPER);

  char*        tmpstr;         /* Temporary string holder */
  unsigned int code_size = 0;  /* Length of current string to generate */
  unsigned int i;              /* Loop iterator */
  unsigned int rv;             /* Return value from snprintf calls */

  assert( left_depth > 0 );

  // TEMPORARY
/*
  printf( "code_index: %d, first: %s, left_depth: %d, first_same: %d, middle: %s, right_depth: %d, last_same: %d, last: %s\n",
          code_index, first, left_depth, first_same_line, middle, right_depth, last_same_line, last );
  printf( "left code:\n" );
  for( i=0; i<left_depth; i++ ) {
    printf( "  .%s.\n", left[i] );
  }
  printf( "right_code:\n" );
  for( i=0; i<right_depth; i++ ) {
    printf( "  .%s.\n", right[i] );
  }
*/

  if( first != NULL ) {
    code_size += strlen( first );
    // printf( "code size after first: %d\n", code_size );
  }
  if( first_same_line ) {
    code_size += strlen( left[0] );
    // printf( "code size after left[0]: %d\n", code_size );
  //  if( (left_depth == 1) && (middle != NULL) && (right_depth == 0) ) {
  //    code_size += strlen( middle );
  //    printf( "code size after middle: %d\n", code_size );
  //  }
  }
  if( code[code_index] != NULL ) {
    free_safe( code[code_index], (strlen( code[code_index] ) + 1) );
  }
  code[code_index]    = (char*)malloc_safe( code_size + 1 );
  //printf( "Allocated %d bytes for code[%d]\n", (code_size + 1), code_index );
  code[code_index][0] = '\0';

  if( first != NULL ) {
    rv = snprintf( code[code_index], (code_size + 1), "%s", first );
    assert( rv < (code_size + 1) );
  }
  if( first_same_line ) {
    tmpstr = strdup_safe( code[code_index] );
    rv = snprintf( code[code_index], (code_size + 1), "%s%s", tmpstr, left[0] );
    assert( rv < (code_size + 1) );
    free_safe( tmpstr, (strlen( tmpstr ) + 1) );
    free_safe( left[0], (strlen( left[0] ) + 1) );
    if( (left_depth == 1) && (middle != NULL) ) {
      code_size = strlen( code[code_index] ) + strlen( middle );
      tmpstr    = (char*)malloc_safe( code_size + 1 );
      rv = snprintf( tmpstr, (code_size + 1), "%s%s", code[code_index], middle );
      assert( rv < (code_size + 1) );
      if( right_depth > 0 ) {
        // printf( "A code[%d]:%s.\n", code_index, code[code_index] );
        codegen_create_expr_helper( code, code_index, tmpstr, right, right_depth, last_same_line, last, NULL, 0, FALSE, NULL );
        free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      } else {
        free_safe( code[code_index], (strlen( code[code_index] ) + 1) );
        code[code_index] = tmpstr;
      }
    } else {
      if( middle != NULL ) {
        for( i=1; i<(left_depth - 1); i++ ) {
          code[code_index+i] = left[i];
        }
        code_size = strlen( left[i] ) + strlen( middle );
        tmpstr    = (char*)malloc_safe( code_size + 1 );
        rv = snprintf( tmpstr, (code_size + 1), "%s%s", left[i], middle );
        assert( rv < (code_size + 1) );
        free_safe( left[i], (strlen( left[i] ) + 1) );
        if( right_depth > 0 ) {
          // printf( "B code[%d+%d]:%s.\n", code_index, i, code[code_index] );
          codegen_create_expr_helper( code, (code_index + i), tmpstr, right, right_depth, last_same_line, last, NULL, 0, FALSE, NULL );
          free_safe( tmpstr, (strlen( tmpstr ) + 1) );
        } else {
          code[code_index+i] = tmpstr;
        }
      } else {
        for( i=1; i<left_depth; i++ ) {
          code[code_index+i] = left[i];
        }
      }
    }
  } else {
    if( middle != NULL ) {
      // printf( "left_depth: %d, code_index: %d\n", left_depth, code_index );
      for( i=0; i<(left_depth - 1); i++ ) {
        code[code_index+1+i] = left[i];
        // printf( "= code[%d]: %s\n", (code_index+1+i), code[code_index+1+i] );
      }
      code_size = strlen( left[i] ) + strlen( middle );
      tmpstr    = (char*)malloc_safe( code_size + 1 );
      rv = snprintf( tmpstr, (code_size + 1), "%s%s", left[i], middle );
      assert( rv < (code_size + 1) );
      free_safe( left[i], (strlen( left[i] ) + 1) );
      if( right_depth > 0 ) {
        // printf( "C code[%d+%d]:%s.\n", code_index, i, code[code_index] );
        codegen_create_expr_helper( code, (code_index + i + 1), tmpstr, right, right_depth, last_same_line, last, NULL, 0, FALSE, NULL );
        free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      } else {
        code[code_index+i+1] = tmpstr;
      }
    } else {
      for( i=0; i<left_depth; i++ ) {
        code[code_index+i+1] = left[i];
      }
    }
  }

}

void codegen_gen_expr	(	expression *	expr,
		exp_op_type	parent_op,
		char ***	code,
		unsigned int *	code_depth,
		func_unit *	funit
	)

Creates Verilog code string from specified expression tree.

Parameters:

	expr	Pointer to root of expression tree to generate.
	parent_op	Operation of parent. If our op is the same, no surrounding parenthesis is needed.
	code	Pointer to array of strings that will contain code lines for the supplied expression.
	code_depth	Pointer to number of strings contained in code array.
	funit	Pointer to functional unit containing the specified expression.

Generates Verilog code from specified expression tree. This Verilog snippet is used by the verbose coverage reporting functions for showing Verilog examples that were missed during simulation. This code handles multi-line Verilog output by storing its information into the code and code_depth parameters.

Parameters:

	expr	Pointer to root of expression tree to generate
	parent_op	Operation of parent. If our op is the same, no surrounding parenthesis is needed
	code	Pointer to array of strings that will contain code lines for the supplied expression
	code_depth	Pointer to number of strings contained in code array
	funit	Pointer to functional unit containing the specified expression

References codegen_create_expr(), codegen_gen_expr(), vsuppl_u::data_type, DECIMAL, expression_s::elem, ESUPPL_IS_ROOT, ESUPPL_STATIC_BASE, ESUPPL_WAS_SWAPPED, EXP_OP_ADD, EXP_OP_ADD_A, EXP_OP_AEDGE, EXP_OP_ALS_A, EXP_OP_ALSHIFT, EXP_OP_ALWAYS_COMB, EXP_OP_ALWAYS_LATCH, EXP_OP_AND, EXP_OP_AND_A, EXP_OP_ARS_A, EXP_OP_ARSHIFT, EXP_OP_ASSIGN, EXP_OP_BASSIGN, EXP_OP_CASE, EXP_OP_CASEX, EXP_OP_CASEZ, EXP_OP_CEQ, EXP_OP_CNE, EXP_OP_CONCAT, EXP_OP_COND, EXP_OP_COND_SEL, EXP_OP_DASSIGN, EXP_OP_DEFAULT, EXP_OP_DELAY, EXP_OP_DIM, EXP_OP_DISABLE, EXP_OP_DIV_A, EXP_OP_DIVIDE, EXP_OP_DLY_ASSIGN, EXP_OP_DLY_OP, EXP_OP_EOR, EXP_OP_EQ, EXP_OP_EXPAND, EXP_OP_EXPONENT, EXP_OP_FORK, EXP_OP_FUNC_CALL, EXP_OP_GE, EXP_OP_GT, EXP_OP_IDEC, EXP_OP_IF, EXP_OP_IINC, EXP_OP_JOIN, EXP_OP_LAND, EXP_OP_LAST, EXP_OP_LE, EXP_OP_LIST, EXP_OP_LOR, EXP_OP_LS_A, EXP_OP_LSHIFT, EXP_OP_LT, EXP_OP_MBIT_NEG, EXP_OP_MBIT_POS, EXP_OP_MBIT_SEL, EXP_OP_MLT_A, EXP_OP_MOD, EXP_OP_MOD_A, EXP_OP_MULTIPLY, EXP_OP_NAND, EXP_OP_NASSIGN, EXP_OP_NB_CALL, EXP_OP_NE, EXP_OP_NEDGE, EXP_OP_NEGATE, EXP_OP_NOR, EXP_OP_NXOR, EXP_OP_OR, EXP_OP_OR_A, EXP_OP_PARAM, EXP_OP_PARAM_MBIT, EXP_OP_PARAM_MBIT_NEG, EXP_OP_PARAM_MBIT_POS, EXP_OP_PARAM_SBIT, EXP_OP_PASSIGN, EXP_OP_PDEC, EXP_OP_PEDGE, EXP_OP_PINC, EXP_OP_PLIST, EXP_OP_RASSIGN, EXP_OP_REPEAT, EXP_OP_RPT_DLY, EXP_OP_RS_A, EXP_OP_RSHIFT, EXP_OP_SASSIGN, EXP_OP_SB2R, EXP_OP_SB2SR, EXP_OP_SBIT_SEL, EXP_OP_SCLOG2, EXP_OP_SI2R, EXP_OP_SIG, EXP_OP_SLIST, EXP_OP_SR2B, EXP_OP_SR2I, EXP_OP_SRANDOM, EXP_OP_SSIGNED, EXP_OP_SSR2B, EXP_OP_SSRANDOM, EXP_OP_STATIC, EXP_OP_STESTARGS, EXP_OP_STIME, EXP_OP_SUB_A, EXP_OP_SUBTRACT, EXP_OP_SUNSIGNED, EXP_OP_SURAND_RANGE, EXP_OP_SURANDOM, EXP_OP_SVALARGS, EXP_OP_TASK_CALL, EXP_OP_TRIGGER, EXP_OP_UAND, EXP_OP_UINV, EXP_OP_UNAND, EXP_OP_UNOR, EXP_OP_UNOT, EXP_OP_UNXOR, EXP_OP_UOR, EXP_OP_UXOR, EXP_OP_WAIT, EXP_OP_WHILE, EXP_OP_XOR, EXP_OP_XOR_A, expr_stmt_u::expr, FALSE, free_safe, expression_s::funit, expression_s::left, expression_s::line, malloc_safe, func_unit_s::name, expression_s::name, expression_s::op, expression_s::parent, esuppl_u::parenthesis, esuppl_u::part, vsuppl_u::part, PROFILE, QSTRING, vector_s::r32, vector_s::r64, expression_s::right, scope_extract_back(), scope_gen_printable(), expression_s::sig, rv32_s::str, rv64_s::str, strdup_safe, expression_s::suppl, vector_s::suppl, user_msg, vector_s::value, expression_s::value, VDATA_R32, VDATA_R64, vector_to_int(), and vector_to_string().

Referenced by codegen_gen_expr(), combination_display_verbose(), combination_get_expression(), fsm_display_verbose(), fsm_get_coverage(), and line_display_verbose().

  { PROFILE(CODEGEN_GEN_EXPR);

  char**       right_code;               /* Pointer to the code that is generated by the right side of the expression */
  char**       left_code;                /* Pointer to the code that is generated by the left side of the expression */
  unsigned int left_code_depth  = 0;     /* Depth of left code string array */
  unsigned int right_code_depth = 0;     /* Depth of right code string array */
  char         code_format[20];          /* Format for creating my_code string */
  char*        tmpstr;                   /* Temporary string holder */
  char*        before;                   /* String before operation */
  char*        after;                    /* String after operation */
  func_unit*   tfunit;                   /* Temporary pointer to functional unit */
  char*        pname            = NULL;  /* Printable version of signal name */
  unsigned int rv;                       /* Return value from calls to snprintf */

  if( expr != NULL ) {

    /* Only traverse left and right expression trees if we are not an SLIST-type */
    if( (expr->op != EXP_OP_SLIST) && (expr->op != EXP_OP_ALWAYS_COMB) && (expr->op != EXP_OP_ALWAYS_LATCH) ) {

      codegen_gen_expr( expr->left,  expr->op, &left_code,  &left_code_depth,  funit );
      codegen_gen_expr( expr->right, expr->op, &right_code, &right_code_depth, funit );

    }

    if( (expr->op == EXP_OP_LAST) || (expr->op == EXP_OP_NB_CALL) || (expr->op == EXP_OP_JOIN) || (expr->op == EXP_OP_FORK) ||
        ((parent_op == EXP_OP_REPEAT) && (expr->parent->expr->left == expr)) ) {

      /* Do nothing. */
      *code_depth = 0;

    } else if( expr->op == EXP_OP_STATIC ) {

      unsigned int data_type = expr->value->suppl.part.data_type;

      *code       = (char**)malloc_safe( sizeof( char* ) );
      *code_depth = 1;

      if( data_type == VDATA_R64 ) {

        assert( expr->value->value.r64->str != NULL );
        (*code)[0] = strdup_safe( expr->value->value.r64->str );

      } else if( data_type == VDATA_R32 ) {

        assert( expr->value->value.r32->str != NULL );
        (*code)[0] = strdup_safe( expr->value->value.r32->str );

      } else {

        if( ESUPPL_STATIC_BASE( expr->suppl ) == DECIMAL ) {

          rv = snprintf( code_format, 20, "%d", vector_to_int( expr->value ) );
          assert( rv < 20 );
          if( (strlen( code_format ) == 1) && (expr->parent->expr->op == EXP_OP_NEGATE) ) {
            strcat( code_format, " " );
          }
          (*code)[0] = strdup_safe( code_format );

        } else if( ESUPPL_STATIC_BASE( expr->suppl ) == QSTRING ) {

          unsigned int slen;
          tmpstr = vector_to_string( expr->value, QSTRING, FALSE, 0 );
          slen   = strlen( tmpstr ) + 3;
          (*code)[0] = (char*)malloc_safe( slen );
          rv = snprintf( (*code)[0], slen, "\"%s\"", tmpstr );
          assert( rv < slen );
          free_safe( tmpstr, (strlen( tmpstr ) + 1) );

        } else { 

          (*code)[0] = vector_to_string( expr->value, ESUPPL_STATIC_BASE( expr->suppl ), FALSE, 0 );

        }
   
      }

    } else if( (expr->op == EXP_OP_SIG) || (expr->op == EXP_OP_PARAM) ) {

      tmpstr = scope_gen_printable( expr->name );

      switch( strlen( tmpstr ) ) {
        case 0 :  assert( strlen( tmpstr ) > 0 );  break;
        case 1 :
          *code       = (char**)malloc_safe( sizeof( char* ) );
          (*code)[0]  = (char*)malloc_safe( 4 );
          *code_depth = 1;
          rv = snprintf( (*code)[0], 4, " %s ", tmpstr );
          assert( rv < 4 );
          break;
        case 2 :
          *code       = (char**)malloc_safe( sizeof( char* ) );
          (*code)[0]  = (char*)malloc_safe( 4 );
          *code_depth = 1;
          rv = snprintf( (*code)[0], 4, " %s", tmpstr );
          assert( rv < 4 );
          break;
        default :
          *code       = (char**)malloc_safe( sizeof( char* ) );
          (*code)[0]  = strdup_safe( tmpstr );
          *code_depth = 1;
          break;
      }

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );

    } else if( (expr->op == EXP_OP_SBIT_SEL) || (expr->op == EXP_OP_PARAM_SBIT) ) {

      if( (ESUPPL_IS_ROOT( expr->suppl ) == 0) &&
          (expr->parent->expr->op == EXP_OP_DIM) &&
          (expr->parent->expr->right == expr) ) {
        tmpstr = (char*)malloc_safe( 2 );
        rv = snprintf( tmpstr, 2, "[" );
        assert( rv < 2 );
      } else {
        unsigned int slen;
        pname  = scope_gen_printable( expr->name );
        slen   = strlen( pname ) + 2;
        tmpstr = (char*)malloc_safe( slen );
        rv = snprintf( tmpstr, slen, "%s[", pname );
        assert( rv < slen );
      }

      codegen_create_expr( code, code_depth, expr->line, tmpstr, left_code, left_code_depth,
                           expr->left, "]", NULL, 0, NULL, NULL );

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( (expr->op == EXP_OP_MBIT_SEL) || (expr->op == EXP_OP_PARAM_MBIT) ) {

      if( (ESUPPL_IS_ROOT( expr->suppl ) == 0) &&
          (expr->parent->expr->op == EXP_OP_DIM) &&
          (expr->parent->expr->right == expr) ) {
        tmpstr = (char*)malloc_safe( 2 );
        rv = snprintf( tmpstr, 2, "[" );
        assert( rv < 2 );
      } else {
        unsigned int slen;
        pname  = scope_gen_printable( expr->name );
        slen   = strlen( pname ) + 2;
        tmpstr = (char*)malloc_safe( slen );
        rv = snprintf( tmpstr, slen, "%s[", pname );
        assert( rv < slen );
      }

      if( ESUPPL_WAS_SWAPPED( expr->suppl ) ) {
        codegen_create_expr( code, code_depth, expr->line, tmpstr,
                             right_code, right_code_depth, expr->right, ":",
                             left_code, left_code_depth, expr->left, "]" );
      } else {
        codegen_create_expr( code, code_depth, expr->line, tmpstr,
                             left_code, left_code_depth, expr->left, ":",
                             right_code, right_code_depth, expr->right, "]" );
      }

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( (expr->op == EXP_OP_MBIT_POS) || (expr->op == EXP_OP_PARAM_MBIT_POS) ) {

      if( (ESUPPL_IS_ROOT( expr->suppl ) == 0) &&
          (expr->parent->expr->op == EXP_OP_DIM) &&
          (expr->parent->expr->right == expr) ) {
        tmpstr = (char*)malloc_safe( 2 );
        rv = snprintf( tmpstr, 2, "[" );
        assert( rv < 2 );
      } else {
        unsigned int slen;
        pname  = scope_gen_printable( expr->name );
        slen   = strlen( pname ) + 2;
        tmpstr = (char*)malloc_safe( slen );
        rv = snprintf( tmpstr, slen, "%s[", pname );
        assert( rv < slen );
      }

      codegen_create_expr( code, code_depth, expr->line, tmpstr, left_code, left_code_depth, expr->left, "+:",
                           right_code, right_code_depth, expr->right, "]" );

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( (expr->op == EXP_OP_MBIT_NEG) || (expr->op == EXP_OP_PARAM_MBIT_NEG) ) {

      if( (ESUPPL_IS_ROOT( expr->suppl ) == 0) &&
          (expr->parent->expr->op == EXP_OP_DIM) &&
          (expr->parent->expr->right == expr) ) {
        tmpstr = (char*)malloc_safe( 2 );
        rv = snprintf( tmpstr, 2, "[" );
        assert( rv < 2 );
      } else {
        unsigned int slen;
        pname  = scope_gen_printable( expr->name );
        slen   = strlen( pname ) + 2;
        tmpstr = (char*)malloc_safe( slen );
        rv = snprintf( tmpstr, slen, "%s[", pname );
        assert( rv < slen );
      }

      codegen_create_expr( code, code_depth, expr->line, tmpstr, left_code, left_code_depth, expr->left, "-:",
                           right_code, right_code_depth, expr->right, "]" );

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( (expr->op == EXP_OP_FUNC_CALL) || (expr->op == EXP_OP_TASK_CALL) ) {

      assert( expr->elem.funit != NULL );

      tfunit = expr->elem.funit;
      after = (char*)malloc_safe( strlen( tfunit->name ) + 1 );
      scope_extract_back( tfunit->name, after, user_msg );
      pname = scope_gen_printable( after );
      if( (expr->op == EXP_OP_TASK_CALL) && (expr->left == NULL) ) {
        *code       = (char**)malloc_safe( sizeof( char* ) );
        (*code)[0]  = strdup_safe( pname );
        *code_depth = 1;
      } else {
        unsigned int slen;
        tmpstr = (char*)malloc_safe( strlen( pname ) + 3 );
        slen   = strlen( pname ) + 3;
        rv = snprintf( tmpstr, slen, "%s( ", pname );
        assert( rv < slen );
        codegen_create_expr( code, code_depth, expr->line, tmpstr, left_code, left_code_depth, expr->left, " )", NULL, 0, NULL, NULL );
        free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      }
      free_safe( after, (strlen( tfunit->name ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( expr->op == EXP_OP_TRIGGER ) {
      unsigned int slen;
      assert( expr->sig != NULL );
      pname  = scope_gen_printable( expr->name );
      slen   = strlen( pname ) + 3;
      tmpstr = (char*)malloc_safe( slen );
      rv = snprintf( tmpstr, slen, "->%s", pname );
      assert( rv < slen );

      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( tmpstr );
      *code_depth = 1;

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( expr->op == EXP_OP_DISABLE ) {
      unsigned int slen;
      assert( expr->elem.funit != NULL );
      pname  = scope_gen_printable( expr->name );
      slen   = strlen( pname ) + 9;
      tmpstr = (char*)malloc_safe( slen );
      rv = snprintf( tmpstr, slen, "disable %s", pname );
      assert( rv < slen );

      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( tmpstr );
      *code_depth = 1;

      free_safe( tmpstr, (strlen( tmpstr ) + 1) );
      free_safe( pname, (strlen( pname ) + 1) );

    } else if( expr->op == EXP_OP_DEFAULT ) {

      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "default :" );
      *code_depth = 1;

    } else if( expr->op == EXP_OP_SLIST ) {

      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "@*" );
      *code_depth = 1;

    } else if( expr->op == EXP_OP_ALWAYS_COMB ) {
 
      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "always_comb" );
      *code_depth = 1;

    } else if( expr->op == EXP_OP_ALWAYS_LATCH ) {

      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "always_latch" );
      *code_depth = 1;

    } else if( expr->op == EXP_OP_STIME ) {
   
      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "$time" );
      *code_depth = 1;

    } else if( (expr->op == EXP_OP_SRANDOM) && (expr->left == NULL) ) {

      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "$random" );
      *code_depth = 1;

    } else if( (expr->op == EXP_OP_SURANDOM) && (expr->left == NULL) ) {
 
      *code       = (char**)malloc_safe( sizeof( char* ) );
      (*code)[0]  = strdup_safe( "$urandom" );
      *code_depth = 1;

    } else {

      if( expr->suppl.part.parenthesis ) {
        before = strdup_safe( "(" );
        after  = strdup_safe( ")" );
      } else {
        before = NULL;
        after  = NULL;
      }

      switch( expr->op ) {
        case EXP_OP_XOR      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " ^ ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_XOR_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " ^= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_MULTIPLY :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " * ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_MLT_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " *= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_DIVIDE   :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " / ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_DIV_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " /= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_MOD      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " % ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_MOD_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " %= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_ADD      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " + ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_ADD_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " += ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_SUBTRACT :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " - ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_SUB_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " -= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_EXPONENT :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " ** ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_AND      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " & ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_AND_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " &= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_OR       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " | ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_OR_A     :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " |= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_NAND     :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " ~& ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_NOR      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " ~| ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_NXOR     :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " ~^ ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_LT       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " < ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_GT       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " > ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_LSHIFT   :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " << ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_LS_A     :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " <<= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_ALSHIFT  :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " <<< ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_ALS_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " <<<= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_RSHIFT   :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " >> ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_RS_A     :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " >>= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_ARSHIFT  :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " >>> ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_ARS_A    :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " >>>= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_EQ       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " == ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_CEQ      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " === ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_LE       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " <= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_GE       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " >= ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_NE       :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " != ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_CNE      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " !== ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_LOR      :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " || ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_LAND     :
          codegen_create_expr( code, code_depth, expr->line, before, left_code, left_code_depth, expr->left, " && ",
                               right_code, right_code_depth, expr->right, after );
          break;
        case EXP_OP_COND     :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " ? ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_COND_SEL :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " : ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_UINV     :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(~" : "~"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UAND     :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(&" : "&"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UNOT     :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(!" : "!"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UOR      :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(|" : "|"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UXOR     :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(^" : "^"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UNAND    :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(~&" : "~&"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UNOR     :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(~|" : "~|"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_UNXOR    :
          codegen_create_expr( code, code_depth, expr->line, (expr->suppl.part.parenthesis ? "(~^" : "~^"), right_code, right_code_depth, expr->right, after,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_EXPAND   :
          codegen_create_expr( code, code_depth, expr->line, "{", left_code, left_code_depth, expr->left, "{",
                               right_code, right_code_depth, expr->right, "}}" );
          break;
        case EXP_OP_LIST     :
        case EXP_OP_PLIST    :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, ", ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_CONCAT   :
          codegen_create_expr( code, code_depth, expr->line, "{", right_code, right_code_depth, expr->right, "}",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_PEDGE    :
          if( (ESUPPL_IS_ROOT( expr->suppl ) == 1)       ||
              (expr->parent->expr->op == EXP_OP_RPT_DLY) || 
              (expr->parent->expr->op == EXP_OP_DLY_OP) ) {
            codegen_create_expr( code, code_depth, expr->line, "@(posedge ", right_code, right_code_depth, expr->right, ")",
                                 NULL, 0, NULL, NULL );
          } else {
            codegen_create_expr( code, code_depth, expr->line, "posedge ", right_code, right_code_depth, expr->right, NULL,
                                 NULL, 0, NULL, NULL );
          }
          break;
        case EXP_OP_NEDGE    :
          if( (ESUPPL_IS_ROOT( expr->suppl ) == 1)       ||
              (expr->parent->expr->op == EXP_OP_RPT_DLY) ||
              (expr->parent->expr->op == EXP_OP_DLY_OP) ) {
            codegen_create_expr( code, code_depth, expr->line, "@(negedge ", right_code, right_code_depth, expr->right, ")",
                                 NULL, 0, NULL, NULL );
          } else {
            codegen_create_expr( code, code_depth, expr->line, "negedge ", right_code, right_code_depth, expr->right, NULL,
                                 NULL, 0, NULL, NULL );
          }
          break;
        case EXP_OP_AEDGE    :
          if( (ESUPPL_IS_ROOT( expr->suppl ) == 1)       ||
              (expr->parent->expr->op == EXP_OP_RPT_DLY) ||
              (expr->parent->expr->op == EXP_OP_DLY_OP) ) {
            codegen_create_expr( code, code_depth, expr->line, "@(", right_code, right_code_depth, expr->right, ")",
                                 NULL, 0, NULL, NULL );
          } else {
            codegen_create_expr( code, code_depth, expr->line, NULL, right_code, right_code_depth, expr->right, NULL,
                                 NULL, 0, NULL, NULL );
          }
          break;
        case EXP_OP_EOR      :
          if( (ESUPPL_IS_ROOT( expr->suppl ) == 1)       ||
              (expr->parent->expr->op == EXP_OP_RPT_DLY) ||
              (expr->parent->expr->op == EXP_OP_DLY_OP) ) {
            codegen_create_expr( code, code_depth, expr->line, "@(", left_code, left_code_depth, expr->left, " or ",
                                 right_code, right_code_depth, expr->right, ")" );
          } else {
            codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " or ",
                                 right_code, right_code_depth, expr->right, NULL );
          }
          break;
        case EXP_OP_CASE     :
          codegen_create_expr( code, code_depth, expr->line, "case( ", left_code, left_code_depth, expr->left, " ) ",
                               right_code, right_code_depth, expr->right, " :" );
          break;
        case EXP_OP_CASEX    :
          codegen_create_expr( code, code_depth, expr->line, "casex( ", left_code, left_code_depth, expr->left, " ) ",
                               right_code, right_code_depth, expr->right, " :" );
          break;
        case EXP_OP_CASEZ    :
          codegen_create_expr( code, code_depth, expr->line, "casez( ", left_code, left_code_depth, expr->left, " ) ",
                               right_code, right_code_depth, expr->right, " :" );
          break;
        case EXP_OP_DELAY    :
          codegen_create_expr( code, code_depth, expr->line, "#(", right_code, right_code_depth, expr->right, ")",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_ASSIGN   :
          codegen_create_expr( code, code_depth, expr->line, "assign ", left_code, left_code_depth, expr->left, " = ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_DASSIGN  :
        case EXP_OP_RASSIGN  :
        case EXP_OP_BASSIGN  :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " = ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_NASSIGN  :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " <= ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_PASSIGN  :
        case EXP_OP_SASSIGN  :
          *code            = right_code;
          *code_depth      = right_code_depth;
          right_code_depth = 0;
          break;
        case EXP_OP_DLY_ASSIGN :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " = ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_DLY_OP   :
        case EXP_OP_RPT_DLY  :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, " ",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_IF       :
          codegen_create_expr( code, code_depth, expr->line, "if( ", right_code, right_code_depth, expr->right, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_REPEAT   :
          codegen_create_expr( code, code_depth, expr->line, "repeat( ", right_code, right_code_depth, expr->right, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_WHILE    :
          codegen_create_expr( code, code_depth, expr->line, "while( ", right_code, right_code_depth, expr->right, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_WAIT     :
          codegen_create_expr( code, code_depth, expr->line, "wait( ", right_code, right_code_depth, expr->right, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_NEGATE   :
          codegen_create_expr( code, code_depth, expr->line, "-", right_code, right_code_depth, expr->right, NULL,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_IINC     :
          codegen_create_expr( code, code_depth, expr->line, "++", left_code, left_code_depth, expr->left, NULL,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_PINC     :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, "++",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_IDEC     :
          codegen_create_expr( code, code_depth, expr->line, "--", left_code, left_code_depth, expr->left, NULL,
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_PDEC     :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, "--",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_DIM      :
          codegen_create_expr( code, code_depth, expr->line, NULL, left_code, left_code_depth, expr->left, "",
                               right_code, right_code_depth, expr->right, NULL );
          break;
        case EXP_OP_SSIGNED  :
          codegen_create_expr( code, code_depth, expr->line, "$signed( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SUNSIGNED  :
          codegen_create_expr( code, code_depth, expr->line, "$unsigned( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SCLOG2 :
          codegen_create_expr( code, code_depth, expr->line, "$clog2( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SRANDOM  :
          codegen_create_expr( code, code_depth, expr->line, "$random( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SURANDOM :
          codegen_create_expr( code, code_depth, expr->line, "$urandom( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SURAND_RANGE :
          codegen_create_expr( code, code_depth, expr->line, "$urandom_range( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SSRANDOM :
          codegen_create_expr( code, code_depth, expr->line, "$srandom( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SB2R :
          codegen_create_expr( code, code_depth, expr->line, "$bitstoreal( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SR2B :
          codegen_create_expr( code, code_depth, expr->line, "$realtobits( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SI2R :
          codegen_create_expr( code, code_depth, expr->line, "$itor( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SR2I :
          codegen_create_expr( code, code_depth, expr->line, "$rtoi( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SSR2B :
          codegen_create_expr( code, code_depth, expr->line, "$shortrealtobits( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SB2SR :
          codegen_create_expr( code, code_depth, expr->line, "$bitstoshortreal( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_STESTARGS :
          codegen_create_expr( code, code_depth, expr->line, "$test$plusargs( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        case EXP_OP_SVALARGS :
          codegen_create_expr( code, code_depth, expr->line, "$value$plusargs( ", left_code, left_code_depth, expr->left, " )",
                               NULL, 0, NULL, NULL );
          break;
        default:  break;
      }

      /* Deallocate before and after strings */
      free_safe( before, (strlen( before ) + 1) );
      free_safe( after, (strlen( after ) + 1) );

    }

    if( right_code_depth > 0 ) {
      free_safe( right_code, (sizeof( char* ) * right_code_depth) );
    }

    if( left_code_depth > 0 ) {
      free_safe( left_code, (sizeof( char* ) * left_code_depth) );
    }

  }

}

---

Variable Documentation

const exp_info exp_op_info[EXP_OP_NUM]

Array containing static information about expression operation types. NOTE: This structure MUST be updated if a new expression is added! The third argument is an initialization to the exp_info_s structure.

bool flag_use_line_width

If set to a boolean value of TRUE, displays combination logic output in a by-line-width format (instead of the user specified Verilog source format).

Referenced by codegen_create_expr(), and report_parse_args().

int line_width

Specifies the number of characters wide that an expression will allowed to be output for if the flag_use_line_width value is set to TRUE.

Referenced by codegen_create_expr(), combination_multi_expr_output(), combination_multi_expr_output_length(), report_output_exclusion_reason(), and report_parse_args().

char user_msg[USER_MSG_LENGTH]

Holds some output that will be displayed via the print_output command. This is created globally so that memory does not need to be reallocated for each function that wishes to use it.