ODIN_II/SRC/node_creation_library.c - third_party/vtr-verilog-to-routing - Git at Google

 /*
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
 files (the "Software"), to deal in the Software without
 restriction, including without limitation the rights to use,
 copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following
 conditions:

 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 */
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include "types.h"
 #include "globals.h"
 #include "netlist_utils.h"
 #include "odin_util.h"
 #include "node_creation_library.h"
 #include "util.h"

 long unique_node_name_id = 0;

 /*-----------------------------------------------------------------------
  * (function: get_a_pad_pin)
  * 	this allows us to attach to the constant netlist driving hb_pad
  *---------------------------------------------------------------------*/
 npin_t *get_a_pad_pin(netlist_t *netlist)
 {
 	npin_t *pad_fanout_pin = allocate_npin();
 	pad_fanout_pin->name = pad_string;
 	add_a_fanout_pin_to_net(netlist->pad_net, pad_fanout_pin);
 	return pad_fanout_pin;
 }

 /*-----------------------------------------------------------------------
  * (function: get_a_zero_pin)
  * 	this allows us to attach to the constant netlist driving zero
  *---------------------------------------------------------------------*/
 npin_t *get_a_zero_pin(netlist_t *netlist)
 {
 	npin_t *zero_fanout_pin = allocate_npin();
 	zero_fanout_pin->name = zero_string;
 	add_a_fanout_pin_to_net(netlist->zero_net, zero_fanout_pin);
 	return zero_fanout_pin;
 }

 /*---------------------------------------------------------------------------------------------
  * (function: get_a_one_pin)
  * 	this allows us to attach to the constant netlist driving one
  *-------------------------------------------------------------------------------------------*/
 npin_t *get_a_one_pin(netlist_t *netlist)
 {
 	npin_t *one_fanout_pin = allocate_npin();
 	one_fanout_pin->name = one_string;
 	add_a_fanout_pin_to_net(netlist->one_net, one_fanout_pin);
 	return one_fanout_pin;
 }


 /*---------------------------------------------------------------------------------------------
  * (function: make_not_gate_with_input)
  * 	Creates a not gate and attaches it to the inputs
  *-------------------------------------------------------------------------------------------*/
 nnode_t *make_not_gate_with_input(npin_t *input_pin, nnode_t *node, short mark)
 {
 	nnode_t *logic_node;

 	logic_node = make_not_gate(node, mark);

 	/* add the input ports as needed */
 	add_a_input_pin_to_node_spot_idx(logic_node, input_pin, 0);

 	return logic_node;

 }

 /*-------------------------------------------------------------------------
  * (function: make_not_gate)
  * 	Just make a not gate
  *-----------------------------------------------------------------------*/
 nnode_t *make_not_gate(nnode_t *node, short mark)
 {
 	nnode_t *logic_node;

 	logic_node = allocate_nnode();
 	logic_node->traverse_visited = mark;
 	logic_node->type = LOGICAL_NOT;
 	logic_node->name = node_name(logic_node, node->name);
 	logic_node->related_ast_node = node->related_ast_node;

 	allocate_more_node_input_pins(logic_node, 1);
 	allocate_more_node_output_pins(logic_node, 1);

 	return logic_node;

 }

 /*---------------------------------------------------------------------------------------------
  * (function: make_1port_gate)
  * 	Make a 1 port gate with variable sizes
  *-------------------------------------------------------------------------------------------*/
 nnode_t *make_1port_gate(operation_list type, int width_input, int width_output, nnode_t *node, short mark)
 {
 	nnode_t *logic_node;

 	logic_node = allocate_nnode();
 	logic_node->traverse_visited = mark;
 	logic_node->type = type;
 	logic_node->name = node_name(logic_node, node->name);
 	logic_node->related_ast_node = node->related_ast_node;

 	/* add the input ports as needed */
 	allocate_more_node_input_pins(logic_node, width_input);
 	add_input_port_information(logic_node, width_input);
 	/* add output */
 	allocate_more_node_output_pins(logic_node, width_output);
 	add_output_port_information(logic_node, width_output);

 	return logic_node;
 }
 /*---------------------------------------------------------------------------------------------
  * (function: make_1port_logic_gate)
  * 	Make a gate with variable sized inputs and 1 output
  *-------------------------------------------------------------------------------------------*/
 nnode_t *make_1port_logic_gate(operation_list type, int width, nnode_t *node, short mark)
 {
 	nnode_t *logic_node;

 	logic_node = make_1port_gate(type, width, 1, node, mark);

 	return logic_node;
 }

 /*---------------------------------------------------------------------------------------------
  * (function: make_1port_logic_gate_with_inputs)
  * 	Make a gate with variable sized inputs, 1 output, and connect to the supplied inputs
  *-------------------------------------------------------------------------------------------*/
 nnode_t *make_1port_logic_gate_with_inputs(operation_list type, int width, signal_list_t *pin_list, nnode_t *node, short mark)
 {
 	nnode_t *logic_node;
 	int i;

 	logic_node = make_1port_gate(type, width, 1, node, mark);

 	/* hookup all the pins */
 	for (i = 0; i < width; i++)
 	{
 		add_a_input_pin_to_node_spot_idx(logic_node, pin_list->signal_list[i], i);
 	}

 	return logic_node;
 }

 /*---------------------------------------------------------------------------------------------
  * (function: make_3port_logic_gates)
  * 	Make a 3 port gate all variable port widths.
  *-------------------------------------------------------------------------------------------*/
 nnode_t *make_3port_gate(operation_list type, int width_port1, int width_port2, int width_port3, int width_output, nnode_t *node, short mark)
 {
 	nnode_t *logic_node = allocate_nnode();
 	logic_node->traverse_visited = mark;
 	logic_node->type = type;
 	logic_node->name = node_name(logic_node, node->name);
 	logic_node->related_ast_node = node->related_ast_node;

 	/* add the input ports as needed */
 	allocate_more_node_input_pins(logic_node, width_port1);
 	add_input_port_information(logic_node, width_port1);
 	allocate_more_node_input_pins(logic_node, width_port2);
 	add_input_port_information(logic_node, width_port2);
 	allocate_more_node_input_pins(logic_node, width_port3);
 	add_input_port_information(logic_node, width_port3);
 	/* add output */
 	allocate_more_node_output_pins(logic_node, width_output);
 	add_output_port_information(logic_node, width_output);

 	return logic_node;
 }


 /*---------------------------------------------------------------------------------------------
  * (function: make_2port_logic_gates)
  * 	Make a 2 port gate with variable sizes.  The first port will be input_pins index 0..width_port1.
  *-------------------------------------------------------------------------------------------*/
 nnode_t *make_2port_gate(operation_list type, int width_port1, int width_port2, int width_output, nnode_t *node, short mark)
 {
 	nnode_t *logic_node = allocate_nnode();
 	logic_node->traverse_visited = mark;
 	logic_node->type = type;
 	logic_node->name = node_name(logic_node, node->name);
 	logic_node->related_ast_node = node->related_ast_node;

 	/* add the input ports as needed */
 	allocate_more_node_input_pins(logic_node, width_port1);
 	add_input_port_information(logic_node, width_port1);
 	allocate_more_node_input_pins(logic_node, width_port2);
 	add_input_port_information(logic_node, width_port2);
 	/* add output */
 	allocate_more_node_output_pins(logic_node, width_output);
 	add_output_port_information(logic_node, width_output);

 	return logic_node;
 }

 /* string conversions */
 char *MULTI_PORT_MUX_string = "MULTI_PORT_MUX";
 char *FF_NODE_string = "FF_NODE";
 char *BUF_NODE_string = "BUF_NODE";
 char *INPUT_NODE_string = "INPUT_NODE";
 char *CLOCK_NODE_string = "CLOCK_NODE";
 char *OUTPUT_NODE_string = "OUTPUT_NODE";
 char *GND_NODE_string = "GND_NODE";
 char *VCC_NODE_string = "VCC_NODE";
 char *ADD_string = "ADD";
 char *MINUS_string = "MINUS";
 char *BITWISE_NOT_string = "BITWISE_NOT";
 char *BITWISE_AND_string = "BITWISE_AND";
 char *BITWISE_OR_string = "BITWISE_OR";
 char *BITWISE_NAND_string = "BITWISE_NAND";
 char *BITWISE_NOR_string = "BITWISE_NOR";
 char *BITWISE_XNOR_string = "BITWISE_XNOR";
 char *BITWISE_XOR_string = "BITWISE_XOR";
 char *LOGICAL_NOT_string = "LOGICAL_NOT";
 char *LOGICAL_OR_string = "LOGICAL_OR";
 char *LOGICAL_AND_string = "LOGICAL_AND";
 char *LOGICAL_NAND_string = "LOGICAL_NAND";
 char *LOGICAL_NOR_string = "LOGICAL_NOR";
 char *LOGICAL_XOR_string = "LOGICAL_XOR";
 char *LOGICAL_XNOR_string = "LOGICAL_XNOR";
 char *MULTIPLY_string = "MULTIPLY";
 char *DIVIDE_string = "DIVIDE";
 char *MODULO_string = "MODULO";
 char *LT_string = "LT";
 char *GT_string = "GT";
 char *LOGICAL_EQUAL_string = "LOGICAL_EQUAL";
 char *NOT_EQUAL_string = "NOT_EQUAL";
 char *LTE_string = "LTE";
 char *GTE_string = "GTE";
 char *SR_string = "SR";
 char *SL_string = "SL";
 char *CASE_EQUAL_string = "CASE_EQUAL";
 char *CASE_NOT_EQUAL_string = "CASE_NOT_EQUAL";
 char *ADDER_FUNC_string = "ADDER_FUNC";
 char *CARRY_FUNC_string = "CARRY_FUNC";
 char *MUX_2_string = "MUX_2";
 char *HARD_IP_string = "HARD_IP";
 char *MEMORY_string = "MEMORY";

 /*---------------------------------------------------------------------------------------------
  * (function: node_name_based_on_op)
  * 	Get the string version of a node
  *-------------------------------------------------------------------------------------------*/
 char *node_name_based_on_op(nnode_t *node)
 {
 	char *return_string;

 	switch(node->type)
 	{
 		case MULTI_PORT_MUX:
 			return_string = MULTI_PORT_MUX_string;
 			break;
 		case FF_NODE:
 			return_string = FF_NODE_string;
 			break;
 		case BUF_NODE:
 			return_string = BUF_NODE_string;
 			break;
 		case CLOCK_NODE:
 			return_string = CLOCK_NODE_string;
 			break;
 		case INPUT_NODE:
 			return_string = INPUT_NODE_string;
 			break;
 		case OUTPUT_NODE:
 			return_string = OUTPUT_NODE_string;
 			break;
 		case GND_NODE:
 			return_string = GND_NODE_string;
 			break;
 		case VCC_NODE:
 			return_string = VCC_NODE_string;
 			break;
 		case ADD:
 			return_string = ADD_string;
 			break;
 		case MINUS:
 			return_string = MINUS_string;
 			break;
 		case BITWISE_NOT:
 			return_string = BITWISE_NOT_string;
 			break;
 		case BITWISE_AND:
 			return_string = BITWISE_AND_string;
 			break;
 		case BITWISE_OR:
 			return_string = BITWISE_OR_string;
 			break;
 		case BITWISE_NAND:
 			return_string = BITWISE_NAND_string;
 			break;
 		case BITWISE_NOR:
 			return_string = BITWISE_NOR_string;
 			break;
 		case BITWISE_XNOR:
 			return_string = BITWISE_XNOR_string;
 			break;
 		case BITWISE_XOR:
 			return_string = BITWISE_XOR_string;
 			break;
 		case LOGICAL_NOT:
 			return_string = LOGICAL_NOT_string;
 			break;
 		case LOGICAL_OR:
 			return_string = LOGICAL_OR_string;
 			break;
 		case LOGICAL_AND:
 			return_string = LOGICAL_AND_string;
 			break;
 		case LOGICAL_NOR:
 			return_string = LOGICAL_NOR_string;
 			break;
 		case LOGICAL_NAND:
 			return_string = LOGICAL_NAND_string;
 			break;
 		case LOGICAL_XOR:
 			return_string = LOGICAL_XOR_string;
 			break;
 		case LOGICAL_XNOR:
 			return_string = LOGICAL_XNOR_string;
 			break;
 		case MULTIPLY:
 			return_string = MULTIPLY_string;
 			break;
 		case DIVIDE:
 			return_string = DIVIDE_string;
 			break;
 		case MODULO:
 			return_string = MODULO_string;
 			break;
 		case LT:
 			return_string = LT_string;
 			break;
 		case GT:
 			return_string = GT_string;
 			break;
 		case LOGICAL_EQUAL:
 			return_string = LOGICAL_EQUAL_string;
 			break;
 		case NOT_EQUAL:
 			return_string = NOT_EQUAL_string;
 			break;
 		case LTE:
 			return_string = LTE_string;
 			break;
 		case GTE:
 			return_string = GTE_string;
 			break;
 		case SR:
 			return_string = SR_string;
 			break;
 		case SL:
 			return_string = SL_string;
 			break;
 		case CASE_EQUAL:
 			return_string = CASE_EQUAL_string;
 			break;
 		case CASE_NOT_EQUAL:
 			return_string = CASE_NOT_EQUAL_string;
 			break;
 		case ADDER_FUNC:
 			return_string = ADDER_FUNC_string;
 			break;
 		case CARRY_FUNC:
 			return_string = CARRY_FUNC_string;
 			break;
 		case MUX_2:
 			return_string = MUX_2_string;
 			break;
 		case MEMORY:
 			return_string = MEMORY_string;
 			break;
 		case HARD_IP:
 			return_string = HARD_IP_string;
 			break;
 		default:
 			return_string = NULL;
 			oassert(FALSE);
 			break;
 	}
 	return return_string;
 }

 /*----------------------------------------------------------------------------
  * (function: hard_node_name)
  * 	This creates the unique node name for a hard block
  *--------------------------------------------------------------------------*/
 char *hard_node_name(nnode_t *node, char *instance_name_prefix, char *hb_name, char *hb_inst)
 {
 	char *return_node_name;

 	/* create the unique name for this node */
 	return_node_name = make_full_ref_name(instance_name_prefix, hb_name, hb_inst, NULL, -1);

 	unique_node_name_id ++;

 	return return_node_name;
 }

 /*---------------------------------------------------------------------------------------------
  * (function: node_name)
  * 	This creates the unique node name
  *-------------------------------------------------------------------------------------------*/
 char *node_name(nnode_t *node, char *instance_name_prefix)
 {
 	char *return_node_name;

 	/* create the unique name for this node */
 	return_node_name = make_full_ref_name(instance_name_prefix, NULL, NULL, node_name_based_on_op(node), unique_node_name_id);

 	//oassert(unique_node_name_id != 199803);

 	unique_node_name_id++;

 	return return_node_name;
 }

 /*-------------------------------------------------------------------------
  * (function: make_mult_block)
  * 	Just make a multiplier hard block
  *-----------------------------------------------------------------------*/
 nnode_t *make_mult_block(nnode_t *node, short mark)
 {
 	nnode_t *logic_node;

 	logic_node = allocate_nnode();
 	logic_node->traverse_visited = mark;
 	logic_node->type = MULTIPLY;
 	logic_node->name = node_name(logic_node, node->name);
 	logic_node->related_ast_node = node->related_ast_node;
 	logic_node->input_port_sizes = node->input_port_sizes;
 	logic_node->num_input_port_sizes = node->num_input_port_sizes;
 	logic_node->output_port_sizes = node->output_port_sizes;
 	logic_node->num_output_port_sizes = node->num_output_port_sizes;

 	allocate_more_node_input_pins(logic_node, node->num_input_pins);
 	allocate_more_node_output_pins(logic_node, node->num_output_pins);

 	return logic_node;
 }
	/*
	Permission is hereby granted, free of charge, to any person
	obtaining a copy of this software and associated documentation
	files (the "Software"), to deal in the Software without
	restriction, including without limitation the rights to use,
	copy, modify, merge, publish, distribute, sublicense, and/or sell
	copies of the Software, and to permit persons to whom the
	Software is furnished to do so, subject to the following
	conditions:

	The above copyright notice and this permission notice shall be
	included in all copies or substantial portions of the Software.

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	OTHER DEALINGS IN THE SOFTWARE.
	*/
	#include <string.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stdarg.h>
	#include "types.h"
	#include "globals.h"
	#include "netlist_utils.h"
	#include "odin_util.h"
	#include "node_creation_library.h"
	#include "util.h"

	long unique_node_name_id = 0;

	/*-----------------------------------------------------------------------
	* (function: get_a_pad_pin)
	* this allows us to attach to the constant netlist driving hb_pad
	---------------------------------------------------------------------/
	npin_t get_a_pad_pin(netlist_t netlist)
	{
	npin_t *pad_fanout_pin = allocate_npin();
	pad_fanout_pin->name = pad_string;
	add_a_fanout_pin_to_net(netlist->pad_net, pad_fanout_pin);
	return pad_fanout_pin;
	}

	/*-----------------------------------------------------------------------
	* (function: get_a_zero_pin)
	* this allows us to attach to the constant netlist driving zero
	---------------------------------------------------------------------/
	npin_t get_a_zero_pin(netlist_t netlist)
	{
	npin_t *zero_fanout_pin = allocate_npin();
	zero_fanout_pin->name = zero_string;
	add_a_fanout_pin_to_net(netlist->zero_net, zero_fanout_pin);
	return zero_fanout_pin;
	}

	/*---------------------------------------------------------------------------------------------
	* (function: get_a_one_pin)
	* this allows us to attach to the constant netlist driving one
	-------------------------------------------------------------------------------------------/
	npin_t get_a_one_pin(netlist_t netlist)
	{
	npin_t *one_fanout_pin = allocate_npin();
	one_fanout_pin->name = one_string;
	add_a_fanout_pin_to_net(netlist->one_net, one_fanout_pin);
	return one_fanout_pin;
	}


	/*---------------------------------------------------------------------------------------------
	* (function: make_not_gate_with_input)
	* Creates a not gate and attaches it to the inputs
	-------------------------------------------------------------------------------------------/
	nnode_t make_not_gate_with_input(npin_t input_pin, nnode_t *node, short mark)
	{
	nnode_t *logic_node;

	logic_node = make_not_gate(node, mark);

	/* add the input ports as needed */
	add_a_input_pin_to_node_spot_idx(logic_node, input_pin, 0);

	return logic_node;

	}

	/*-------------------------------------------------------------------------
	* (function: make_not_gate)
	* Just make a not gate
	-----------------------------------------------------------------------/
	nnode_t make_not_gate(nnode_t node, short mark)
	{
	nnode_t *logic_node;

	logic_node = allocate_nnode();
	logic_node->traverse_visited = mark;
	logic_node->type = LOGICAL_NOT;
	logic_node->name = node_name(logic_node, node->name);
	logic_node->related_ast_node = node->related_ast_node;

	allocate_more_node_input_pins(logic_node, 1);
	allocate_more_node_output_pins(logic_node, 1);

	return logic_node;

	}

	/*---------------------------------------------------------------------------------------------
	* (function: make_1port_gate)
	* Make a 1 port gate with variable sizes
	-------------------------------------------------------------------------------------------/
	nnode_t make_1port_gate(operation_list type, int width_input, int width_output, nnode_t node, short mark)
	{
	nnode_t *logic_node;

	logic_node = allocate_nnode();
	logic_node->traverse_visited = mark;
	logic_node->type = type;
	logic_node->name = node_name(logic_node, node->name);
	logic_node->related_ast_node = node->related_ast_node;

	/* add the input ports as needed */
	allocate_more_node_input_pins(logic_node, width_input);
	add_input_port_information(logic_node, width_input);
	/* add output */
	allocate_more_node_output_pins(logic_node, width_output);
	add_output_port_information(logic_node, width_output);

	return logic_node;
	}
	/*---------------------------------------------------------------------------------------------
	* (function: make_1port_logic_gate)
	* Make a gate with variable sized inputs and 1 output
	-------------------------------------------------------------------------------------------/
	nnode_t make_1port_logic_gate(operation_list type, int width, nnode_t node, short mark)
	{
	nnode_t *logic_node;

	logic_node = make_1port_gate(type, width, 1, node, mark);

	return logic_node;
	}

	/*---------------------------------------------------------------------------------------------
	* (function: make_1port_logic_gate_with_inputs)
	* Make a gate with variable sized inputs, 1 output, and connect to the supplied inputs
	-------------------------------------------------------------------------------------------/
	nnode_t make_1port_logic_gate_with_inputs(operation_list type, int width, signal_list_t pin_list, nnode_t *node, short mark)
	{
	nnode_t *logic_node;
	int i;

	logic_node = make_1port_gate(type, width, 1, node, mark);

	/* hookup all the pins */
	for (i = 0; i < width; i++)
	{
	add_a_input_pin_to_node_spot_idx(logic_node, pin_list->signal_list[i], i);
	}

	return logic_node;
	}

	/*---------------------------------------------------------------------------------------------
	* (function: make_3port_logic_gates)
	* Make a 3 port gate all variable port widths.
	-------------------------------------------------------------------------------------------/
	nnode_t make_3port_gate(operation_list type, int width_port1, int width_port2, int width_port3, int width_output, nnode_t node, short mark)
	{
	nnode_t *logic_node = allocate_nnode();
	logic_node->traverse_visited = mark;
	logic_node->type = type;
	logic_node->name = node_name(logic_node, node->name);
	logic_node->related_ast_node = node->related_ast_node;

	/* add the input ports as needed */
	allocate_more_node_input_pins(logic_node, width_port1);
	add_input_port_information(logic_node, width_port1);
	allocate_more_node_input_pins(logic_node, width_port2);
	add_input_port_information(logic_node, width_port2);
	allocate_more_node_input_pins(logic_node, width_port3);
	add_input_port_information(logic_node, width_port3);
	/* add output */
	allocate_more_node_output_pins(logic_node, width_output);
	add_output_port_information(logic_node, width_output);

	return logic_node;
	}


	/*---------------------------------------------------------------------------------------------
	* (function: make_2port_logic_gates)
	* Make a 2 port gate with variable sizes. The first port will be input_pins index 0..width_port1.
	-------------------------------------------------------------------------------------------/
	nnode_t make_2port_gate(operation_list type, int width_port1, int width_port2, int width_output, nnode_t node, short mark)
	{
	nnode_t *logic_node = allocate_nnode();
	logic_node->traverse_visited = mark;
	logic_node->type = type;
	logic_node->name = node_name(logic_node, node->name);
	logic_node->related_ast_node = node->related_ast_node;

	/* add the input ports as needed */
	allocate_more_node_input_pins(logic_node, width_port1);
	add_input_port_information(logic_node, width_port1);
	allocate_more_node_input_pins(logic_node, width_port2);
	add_input_port_information(logic_node, width_port2);
	/* add output */
	allocate_more_node_output_pins(logic_node, width_output);
	add_output_port_information(logic_node, width_output);

	return logic_node;
	}

	/* string conversions */
	char *MULTI_PORT_MUX_string = "MULTI_PORT_MUX";
	char *FF_NODE_string = "FF_NODE";
	char *BUF_NODE_string = "BUF_NODE";
	char *INPUT_NODE_string = "INPUT_NODE";
	char *CLOCK_NODE_string = "CLOCK_NODE";
	char *OUTPUT_NODE_string = "OUTPUT_NODE";
	char *GND_NODE_string = "GND_NODE";
	char *VCC_NODE_string = "VCC_NODE";
	char *ADD_string = "ADD";
	char *MINUS_string = "MINUS";
	char *BITWISE_NOT_string = "BITWISE_NOT";
	char *BITWISE_AND_string = "BITWISE_AND";
	char *BITWISE_OR_string = "BITWISE_OR";
	char *BITWISE_NAND_string = "BITWISE_NAND";
	char *BITWISE_NOR_string = "BITWISE_NOR";
	char *BITWISE_XNOR_string = "BITWISE_XNOR";
	char *BITWISE_XOR_string = "BITWISE_XOR";
	char *LOGICAL_NOT_string = "LOGICAL_NOT";
	char *LOGICAL_OR_string = "LOGICAL_OR";
	char *LOGICAL_AND_string = "LOGICAL_AND";
	char *LOGICAL_NAND_string = "LOGICAL_NAND";
	char *LOGICAL_NOR_string = "LOGICAL_NOR";
	char *LOGICAL_XOR_string = "LOGICAL_XOR";
	char *LOGICAL_XNOR_string = "LOGICAL_XNOR";
	char *MULTIPLY_string = "MULTIPLY";
	char *DIVIDE_string = "DIVIDE";
	char *MODULO_string = "MODULO";
	char *LT_string = "LT";
	char *GT_string = "GT";
	char *LOGICAL_EQUAL_string = "LOGICAL_EQUAL";
	char *NOT_EQUAL_string = "NOT_EQUAL";
	char *LTE_string = "LTE";
	char *GTE_string = "GTE";
	char *SR_string = "SR";
	char *SL_string = "SL";
	char *CASE_EQUAL_string = "CASE_EQUAL";
	char *CASE_NOT_EQUAL_string = "CASE_NOT_EQUAL";
	char *ADDER_FUNC_string = "ADDER_FUNC";
	char *CARRY_FUNC_string = "CARRY_FUNC";
	char *MUX_2_string = "MUX_2";
	char *HARD_IP_string = "HARD_IP";
	char *MEMORY_string = "MEMORY";

	/*---------------------------------------------------------------------------------------------
	* (function: node_name_based_on_op)
	* Get the string version of a node
	-------------------------------------------------------------------------------------------/
	char node_name_based_on_op(nnode_t node)
	{
	char *return_string;

	switch(node->type)
	{
	case MULTI_PORT_MUX:
	return_string = MULTI_PORT_MUX_string;
	break;
	case FF_NODE:
	return_string = FF_NODE_string;
	break;
	case BUF_NODE:
	return_string = BUF_NODE_string;
	break;
	case CLOCK_NODE:
	return_string = CLOCK_NODE_string;
	break;
	case INPUT_NODE:
	return_string = INPUT_NODE_string;
	break;
	case OUTPUT_NODE:
	return_string = OUTPUT_NODE_string;
	break;
	case GND_NODE:
	return_string = GND_NODE_string;
	break;
	case VCC_NODE:
	return_string = VCC_NODE_string;
	break;
	case ADD:
	return_string = ADD_string;
	break;
	case MINUS:
	return_string = MINUS_string;
	break;
	case BITWISE_NOT:
	return_string = BITWISE_NOT_string;
	break;
	case BITWISE_AND:
	return_string = BITWISE_AND_string;
	break;
	case BITWISE_OR:
	return_string = BITWISE_OR_string;
	break;
	case BITWISE_NAND:
	return_string = BITWISE_NAND_string;
	break;
	case BITWISE_NOR:
	return_string = BITWISE_NOR_string;
	break;
	case BITWISE_XNOR:
	return_string = BITWISE_XNOR_string;
	break;
	case BITWISE_XOR:
	return_string = BITWISE_XOR_string;
	break;
	case LOGICAL_NOT:
	return_string = LOGICAL_NOT_string;
	break;
	case LOGICAL_OR:
	return_string = LOGICAL_OR_string;
	break;
	case LOGICAL_AND:
	return_string = LOGICAL_AND_string;
	break;
	case LOGICAL_NOR:
	return_string = LOGICAL_NOR_string;
	break;
	case LOGICAL_NAND:
	return_string = LOGICAL_NAND_string;
	break;
	case LOGICAL_XOR:
	return_string = LOGICAL_XOR_string;
	break;
	case LOGICAL_XNOR:
	return_string = LOGICAL_XNOR_string;
	break;
	case MULTIPLY:
	return_string = MULTIPLY_string;
	break;
	case DIVIDE:
	return_string = DIVIDE_string;
	break;
	case MODULO:
	return_string = MODULO_string;
	break;
	case LT:
	return_string = LT_string;
	break;
	case GT:
	return_string = GT_string;
	break;
	case LOGICAL_EQUAL:
	return_string = LOGICAL_EQUAL_string;
	break;
	case NOT_EQUAL:
	return_string = NOT_EQUAL_string;
	break;
	case LTE:
	return_string = LTE_string;
	break;
	case GTE:
	return_string = GTE_string;
	break;
	case SR:
	return_string = SR_string;
	break;
	case SL:
	return_string = SL_string;
	break;
	case CASE_EQUAL:
	return_string = CASE_EQUAL_string;
	break;
	case CASE_NOT_EQUAL:
	return_string = CASE_NOT_EQUAL_string;
	break;
	case ADDER_FUNC:
	return_string = ADDER_FUNC_string;
	break;
	case CARRY_FUNC:
	return_string = CARRY_FUNC_string;
	break;
	case MUX_2:
	return_string = MUX_2_string;
	break;
	case MEMORY:
	return_string = MEMORY_string;
	break;
	case HARD_IP:
	return_string = HARD_IP_string;
	break;
	default:
	return_string = NULL;
	oassert(FALSE);
	break;
	}
	return return_string;
	}

	/*----------------------------------------------------------------------------
	* (function: hard_node_name)
	* This creates the unique node name for a hard block
	--------------------------------------------------------------------------/
	char hard_node_name(nnode_t node, char instance_name_prefix, char hb_name, char *hb_inst)
	{
	char *return_node_name;

	/* create the unique name for this node */
	return_node_name = make_full_ref_name(instance_name_prefix, hb_name, hb_inst, NULL, -1);

	unique_node_name_id ++;

	return return_node_name;
	}

	/*---------------------------------------------------------------------------------------------
	* (function: node_name)
	* This creates the unique node name
	-------------------------------------------------------------------------------------------/
	char node_name(nnode_t node, char *instance_name_prefix)
	{
	char *return_node_name;

	/* create the unique name for this node */
	return_node_name = make_full_ref_name(instance_name_prefix, NULL, NULL, node_name_based_on_op(node), unique_node_name_id);

	//oassert(unique_node_name_id != 199803);

	unique_node_name_id++;

	return return_node_name;
	}

	/*-------------------------------------------------------------------------
	* (function: make_mult_block)
	* Just make a multiplier hard block
	-----------------------------------------------------------------------/
	nnode_t make_mult_block(nnode_t node, short mark)
	{
	nnode_t *logic_node;

	logic_node = allocate_nnode();
	logic_node->traverse_visited = mark;
	logic_node->type = MULTIPLY;
	logic_node->name = node_name(logic_node, node->name);
	logic_node->related_ast_node = node->related_ast_node;
	logic_node->input_port_sizes = node->input_port_sizes;
	logic_node->num_input_port_sizes = node->num_input_port_sizes;
	logic_node->output_port_sizes = node->output_port_sizes;
	logic_node->num_output_port_sizes = node->num_output_port_sizes;

	allocate_more_node_input_pins(logic_node, node->num_input_pins);
	allocate_more_node_output_pins(logic_node, node->num_output_pins);

	return logic_node;
	}