read_blif.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "globals.h"
#include "read_blif.h"
#include "util.h"
#include "string_cache.h"
#include "netlist_utils.h"
#include "errors.h"
#include "types.h"

Include dependency graph for read_blif.c:

Go to the source code of this file.

Defines
#define	TOKENS   " \t\n"
Functions
void	create_top_driver_nets (char *instance_name_prefix)
void	look_for_clocks ()
void	add_top_input_nodes ()
void	create_top_output_nodes ()
static void	read_tokens (char *buffer, int *done, char *blif_file)
static void	dum_parse (char *buffer)
void	create_internal_node_and_driver ()
short	assign_node_type_from_node_name (char *output_name)
short	read_bit_map_find_unknown_gate (int input_count, nnode_t *node)
void	create_latch_node_and_driver (char *blif_file)
void	create_hard_block_nodes ()
void	hook_up_nets ()
char *	search_clock_name (char *blif_file)
void	read_blif (char *blif_file)
Variables
static FILE *	blif
int	linenum
STRING_CACHE *	output_nets_sc
STRING_CACHE *	input_nets_sc
const char *	GND = "gnd"
const char *	VCC = "vcc"
const char *	HBPAD = "unconn"
char *	blif_one_string = "ONE_VCC_CNS"
char *	blif_zero_string = "ZERO_GND_ZERO"
char *	blif_pad_string = "ZERO_PAD_ZERO"
char *	default_clock_name = "top^clock"
netlist_t *	blif_netlist
static short	skip_reading_bit_map = FALSE

---

Define Documentation

#define TOKENS   " \t\n"

Definition at line 38 of file read_blif.c.

---

Function Documentation

void add_top_input_nodes

(

)

Definition at line 1252 of file read_blif.c.

{

#ifdef debug_mode
  printf("\n Reading the add_top_input_nodes");
#endif

  long sc_spot;// store the location of the string stored in string_cache
  char *ptr; 
  char buffer[BUFSIZE];
  npin_t *new_pin;
  nnet_t *new_net = NULL;
  nnode_t *new_node;
  char *temp_string;

  while (1)
        {
        /* keep reading the inputs till there is no more to read*/
                ptr = my_strtok (NULL, TOKENS, blif, buffer);
        
                if (ptr == NULL)
                        return;

        /* create a new top input node and net*/
        new_net= allocate_nnet();
        new_node = allocate_nnode();

        temp_string= make_full_ref_name(ptr, NULL, NULL,NULL, -1);
        sc_spot = sc_add_string(output_nets_sc, temp_string);
        if (output_nets_sc->data[sc_spot] != NULL)
             {
              error_message(NETLIST_ERROR,linenum,-1, "Net (%s) with the same name already created\n",ptr);     
             }
        
        /* store the data which is an idx here */
        output_nets_sc->data[sc_spot] = (void*)new_net;

        new_node->related_ast_node = NULL;
        new_node->type = INPUT_NODE;

        /* add the name of the input variable */ 
        new_node->name = temp_string;

        /* allocate the pins needed */
        allocate_more_node_output_pins(new_node, 1);
        add_output_port_information(new_node, 1);

        /* Create the pin connection for the net */
        new_pin = allocate_npin();

        /* hookup the pin, net, and node */
        add_a_output_pin_to_node_spot_idx(new_node, new_pin, 0);
        add_a_driver_pin_to_net(new_net, new_pin);

        /*adding the node to the blif_netlist input nodes
          add_node_to_netlist() function can also be used */
        
        blif_netlist->top_input_nodes = (nnode_t**)realloc(blif_netlist->top_input_nodes, sizeof(nnode_t*)*(blif_netlist->num_top_input_nodes+1));
        blif_netlist->top_input_nodes[blif_netlist->num_top_input_nodes] = new_node;
        blif_netlist->num_top_input_nodes++;
        
        }

#ifdef debug_mode
        printf("\n Exiting the add_top_input_nodes");
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

short assign_node_type_from_node_name

(

char *

output_name

)

Definition at line 208 of file read_blif.c.

{
        
#ifdef debug_mode
        printf("\n reading assign_node_type_from_node_name");
        printf("\n output_name : %s",output_name);
#endif

  int length_string;
  int start,end,i; //variable to extract the type
  int j=0;
  char *extracted_string;//stores the extracted string
  length_string=strlen(output_name);

  for(start=length_string-1;(start >=0) && (output_name[start]!='^');start--);
  for(end=length_string-1;(end>=0) && (output_name[end]!='~');end--);

  /* name convention does not match */

#ifdef debug_mode
        printf("\n Start= %d  end=%d  \n",start,end);
#endif
  
  if((start>=end) || (end==0))
          return GENERIC;
                
  extracted_string=(char*)malloc(sizeof(char)*((end-start+2)));
  for(i=start+1;i<end;i++)
  {
    extracted_string[j]=output_name[i];
    j++;
  }
  extracted_string[j]='\0';

#ifdef debug_mode
        printf("Extracted string: %s \n",extracted_string);
#endif

  /* Check if the type existe, return the type else return -1 */
  /* if construst use , as we have strings here */
  if(strcmp(extracted_string,"GT")==0)
        return GT;
  else if(strcmp(extracted_string,"LT")==0)
        return LT;
  else if(strcmp(extracted_string,"ADDER_FUNC")==0)
        return ADDER_FUNC;
  else if(strcmp(extracted_string,"CARRY_FUNC")==0)
        return CARRY_FUNC;
  else if(strcmp(extracted_string,"BITWISE_NOT")==0)
        return BITWISE_NOT;
  else if(strcmp(extracted_string,"LOGICAL_AND")==0)
        return LOGICAL_AND;
  else if(strcmp(extracted_string,"LOGICAL_OR")==0)
        return LOGICAL_OR;
  else if(strcmp(extracted_string,"LOGICAL_XOR")==0)
        return LOGICAL_XOR;
  else if(strcmp(extracted_string,"LOGICAL_XNOR")==0)
        return LOGICAL_XNOR; 
  else if(strcmp(extracted_string,"LOGICAL_NAND")==0)
        return LOGICAL_NAND;
  else if(strcmp(extracted_string,"LOGICAL_NOR")==0)
        return LOGICAL_NOR;
  else if(strcmp(extracted_string,"LOGICAL_EQUAL")==0)
        return LOGICAL_EQUAL;
  else if(strcmp(extracted_string,"NOT_EQUAL")==0)
        return NOT_EQUAL;
  else if(strcmp(extracted_string,"LOGICAL_NOT")==0)
        return LOGICAL_NOT; 
  else if(strcmp(extracted_string,"MUX_2")==0)
        return MUX_2;
  else if(strcmp(extracted_string,"FF_NODE")==0)
        return FF_NODE;
  else if(strcmp(extracted_string,"MULTIPLY")==0)
        return MULTIPLY;
  else if(strcmp(extracted_string,"HARD_IP")==0)
        return HARD_IP;
  else if(strcmp(extracted_string,"INPUT_NODE")==0)
        return INPUT_NODE;
  else if(strcmp(extracted_string,"OUTPUT_NODE")==0)
        return OUTPUT_NODE;
  else if(strcmp(extracted_string,"PAD_NODE")==0)
        return PAD_NODE;
  else if(strcmp(extracted_string,"CLOCK_NODE")==0)
        return CLOCK_NODE;
  else if(strcmp(extracted_string,"GND_NODE")==0)
        return GND_NODE;
  else if(strcmp(extracted_string,"VCC_NODE")==0)
        return VCC_NODE;
  else if(strcmp(extracted_string,"BITWISE_AND")==0)
        return BITWISE_AND;
  else if(strcmp(extracted_string,"BITWISE_NAND")==0)
        return BITWISE_NAND;
  else if(strcmp(extracted_string,"BITWISE_NOR")==0)
        return BITWISE_NOR;
  else if(strcmp(extracted_string,"BITWISE_XNOR")==0)
        return BITWISE_XNOR;
  else if(strcmp(extracted_string,"BITWISE_XOR")==0)
        return BITWISE_XOR;
  else if(strcmp(extracted_string,"BITWISE_OR")==0)
        return BITWISE_OR;
  else if(strcmp(extracted_string,"BUF_NODE")==0)
        return BUF_NODE; 
   else if(strcmp(extracted_string,"MULTI_PORT_MUX")==0)
        return MULTI_PORT_MUX;
  else if(strcmp(extracted_string,"SL")==0)
        return SL;
  else if(strcmp(extracted_string,"SR")==0)
        return SR;
  else if(strcmp(extracted_string,"CASE_EQUAL")==0)
        return CASE_EQUAL;
  else if(strcmp(extracted_string,"CASE_NOT_EQUAL")==0)
        return CASE_NOT_EQUAL;
  else if(strcmp(extracted_string,"DIVIDE")==0)
        return DIVIDE;
  else if(strcmp(extracted_string,"MODULO")==0)
        return MODULO;
  else if(strcmp(extracted_string,"GTE")==0)
        return GTE;
  else if(strcmp(extracted_string,"LTE")==0)
        return LTE; 
  else if(strcmp(extracted_string,"ADD")==0)
        return ADD; 
  else if(strcmp(extracted_string,"MINUS")==0)
        return MINUS;  
  else return GENERIC; /* If name type does not exits */


}

Here is the caller graph for this function:

void create_hard_block_nodes

(

)

Definition at line 603 of file read_blif.c.

{
  FILE *temp_search; // for searching the subckt model
  char buffer[BUFSIZE];
  char *name_subckt;
  char *temp1,*temp2;
  char **names_formal=NULL; // store the formal-actual parameter name
  char **names_actual=NULL;
  char **names_parameters=NULL;
  int count=0;
  char *ptr;
  int done=0;
  int input_count=0;
  long sc_spot;
  nnode_t *new_node = allocate_nnode();
  npin_t *new_pin;
  nnet_t *new_net;
  int input_port_count=0;
  int output_port_count=0;
  int i=0;
  fpos_t pos;// store the current position of the file pointer

        
  ptr= my_strtok (NULL, TOKENS, blif, buffer);
  name_subckt=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
  sprintf(name_subckt,"%s",ptr);

#ifdef debug_mode
  printf("\nname_subckt: %s",name_subckt);
#endif
 
  /* storing the names on the fornal-actual parameter */
        while ((ptr= my_strtok (NULL, TOKENS, blif, buffer)) != NULL)
        {

#ifdef debug_mode
          printf("\n ptr: %s",ptr);
#endif

          count++;
          names_parameters= (char**)realloc(names_parameters, sizeof(char*)*count);  
          names_parameters[count-1]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
          sprintf(names_parameters[count-1],"%s",ptr);
        }       
   
   names_actual=(char**)malloc(sizeof(char*)*count);
   names_formal=(char**)malloc(sizeof(char*)*count);

   while(i<count)
        {
          ptr=strtok(names_parameters[i],"=");
#ifdef debug_mode         
        printf("\n ptr: %s",ptr);
#endif

          names_actual[i]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
          sprintf(names_actual[i],"%s",ptr);
          ptr=strtok(NULL,"=");
          names_formal[i]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
          sprintf(names_formal[i],"%s",ptr);
          i++;
        }

        for(i=0;i<count;i++)
        {
        free(names_parameters[i]);

#ifdef debug_mode       
        printf("\n %s \t%s",names_actual[i],names_formal[i]);
#endif

        }
        free(names_parameters);   

  fgetpos(blif,&pos);
  temp_search=blif;

        while (1)
        {
          my_fgets(buffer, BUFSIZE,temp_search);
          if(feof(temp_search)!=0)
          {
                printf("Error : The '%s' subckt no found ",name_subckt);
                exit(-1);
          }
        ptr=my_strtok(buffer,TOKENS, temp_search, buffer);
#ifdef debug_mode       
        printf("\n ptr : %s",ptr);
#endif
        if (ptr==NULL)
          continue;
        if(strcmp(ptr,".model")!=0)
        continue;

        ptr=my_strtok(NULL,TOKENS, temp_search, buffer);
        if(strcmp(ptr,name_subckt)==0)
                break;
        
        }

  /* read the subckt model to find out the number of input pin*/
  /* count-input_count=number of output pin */
  /* Thus we can decide number of passed parameter are output parameter */

        while (!done && (my_fgets (buffer, BUFSIZE,temp_search) != NULL) )
        {
          ptr = my_strtok (buffer, TOKENS, temp_search, buffer);  

#ifdef debug_mode       
          printf("\n ptr: %s",ptr);  
#endif

          if(strcmp(ptr,".inputs")==0)
          {
                while ((ptr= my_strtok (NULL, TOKENS,temp_search, buffer)) != NULL)
                 input_count++;
                done=1;
          }
        }

#ifdef debug_mode
        printf("\n input_count %d",input_count);
        printf("\n count %d",count); 
#endif

  /* calculate the number of input and output port size */
  if(input_count>0)
  {
  input_port_count=1;

          for(i=0;i<input_count-1;i++)
          {  
             ptr=strtok(names_actual[i+1],"~");
             temp2=ptr;
             ptr=strtok(names_actual[i],"~");           
             temp1=ptr;

#ifdef debug_mode
                printf("\n %s \t %s",temp1,temp2);
#endif
        
                if(strcmp(temp1,temp2)!=0)
                {
                add_input_port_information(new_node,input_port_count);
                input_port_count=1;
                }
                else
                input_port_count++;
          }
        add_input_port_information(new_node,input_port_count);  
  }

  if(count-input_count>0)
  {
  output_port_count=1;

          for(i=input_count;i<count-input_count-1;i++)
          {  
             ptr=strtok(names_actual[i+1],"~");
             temp2=ptr;
             ptr=strtok(names_actual[i],"~");           
             temp1=ptr;

#ifdef debug_mode
                printf("\n %s \t %s",temp1,temp2);
#endif

                if(strcmp(temp1,temp2)!=0)
                {
                add_output_port_information(new_node,output_port_count);
                output_port_count=1;
                }
                else
                output_port_count++;
          }     
        add_output_port_information(new_node,output_port_count);
  }

  /* creating the node */
  // new_node->related_ast_node = NULL;
  if(strcmp(name_subckt,"multiply")==0)
   new_node->type=MULTIPLY;
  else
   new_node->type=MEMORY;
   
  /* allocate the output pin (there is always one output pin) */
    allocate_more_node_output_pins(new_node,count-input_count);

  /* allocate the input pin (= input_count-1)*/
         if (input_count > 0) // check if there is any input pins       
        {  
          allocate_more_node_input_pins(new_node, input_count);  
        }
  
  /* add names and type information to the created input pins */
        for(i=0;i<input_count;i++)
        {
          new_node->input_pins[i]=allocate_npin();
          new_node->input_pins[i]->name=names_formal[i];
          new_node->input_pins[i]->type=INPUT;
          ptr=strtok(names_actual[i],"~");
          new_node->input_pins[i]->mapping=(char*)malloc(sizeof(char)*(strlen(ptr)+1));         
          sprintf(new_node->input_pins[i]->mapping,"%s",ptr);
        }
         
  /* Check this , I am not sure (simulator needs this information) */
  new_node->related_ast_node=(ast_node_t *)calloc(1, sizeof(ast_node_t));
  new_node->related_ast_node->children=(ast_node_t **)calloc(1,sizeof(ast_node_t *)); 
  new_node->related_ast_node->children[0]=(ast_node_t *)calloc(1, sizeof(ast_node_t));
  new_node->related_ast_node->children[0]->types.identifier=(char*)calloc(1,sizeof(char)*(strlen(name_subckt)+1));
  sprintf(new_node->related_ast_node->children[0]->types.identifier,"%s",name_subckt);

  /* add a name for the node,same as the subckt name */
  new_node->name = make_full_ref_name(name_subckt,NULL, NULL, NULL,-1);  

  /*add this node to blif_netlist as an internal node */
  blif_netlist->internal_nodes = (nnode_t**)realloc(blif_netlist->internal_nodes, sizeof(nnode_t*)*(blif_netlist->num_internal_nodes+1));
  blif_netlist->internal_nodes[blif_netlist->num_internal_nodes] =new_node;
  blif_netlist->num_internal_nodes++;
 
  /*add name information and a net(driver) for the output */
        for(i=0;i<count-input_count;i++)
        {
        
        new_pin=allocate_npin();
        new_net=allocate_nnet();
        new_net->name=names_formal[i+input_count];
        new_pin->name=names_formal[i+input_count];
        new_pin->type=OUTPUT;
        ptr=strtok(names_actual[i+input_count],"~");

#ifdef debug_mode
        printf("\n ptr  %s\n",ptr);
#endif

        add_a_output_pin_to_node_spot_idx(new_node, new_pin,i);
        new_node->output_pins[i]->mapping=(char*)malloc(sizeof(char)*(strlen(ptr)+1));          
        sprintf(new_node->output_pins[i]->mapping,"%s",ptr);
        add_a_output_pin_to_node_spot_idx(new_node, new_pin,i);
        add_a_driver_pin_to_net(new_net,new_pin);
                
  /*list this output in output_nets_sc */
        sc_spot = sc_add_string(output_nets_sc,names_formal[i+input_count]);
                if (output_nets_sc->data[sc_spot] != NULL)
                {
                error_message(NETLIST_ERROR,linenum, -1,"Net (%s) with the same name already created\n",ptr);   
                }
          /* store the data which is an idx here */
        output_nets_sc->data[sc_spot] = (void*)new_net;
        }

  /* Free the char**   */
  free(names_formal); 
  free(names_actual);
  free(names_parameters);
  fsetpos(blif,&pos);

#ifdef debug_mode
  printf("\n exiting the create_hard_block module");
#endif
         
}

Here is the call graph for this function:

Here is the caller graph for this function:

void create_internal_node_and_driver

(

)

Definition at line 871 of file read_blif.c.

{

#ifdef debug_mode
        printf("\n reading create_internal_node_driver");
#endif

  long sc_spot;
  nnode_t *new_node = allocate_nnode();
  npin_t *new_pin;
  nnet_t *new_net;
  short node_type;
  char buffer[BUFSIZE];
  char *ptr;
  char ** names=NULL;// stores the names of the input and the output, last name stored would be of the output
  int input_count=0;
  int i;

  /* Storing the names of the input and the final output in array names */
        while ((ptr= my_strtok (NULL, TOKENS, blif, buffer)) != NULL)
        {
          input_count++;
          names= (char**)realloc(names, sizeof(char*)* input_count);  
          names[input_count-1]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
          sprintf(names[input_count-1],"%s",ptr);
        }
  
  /* assigning the new_node */
  new_node->related_ast_node = NULL;
  /* gnd vcc unconn already created as top module so ignore them */
  if( (strcmp(names[input_count-1],"gnd")==0) ||  (strcmp(names[input_count-1],"vcc")==0) ||  (strcmp(names[input_count-1],"unconn")==0))
        {
        skip_reading_bit_map=TRUE;
        return;
        }

#ifdef debug_mode
  printf("\nnames %s",names[input_count-1]); 
#endif


  /* assign the node type by seeing the name */
  node_type=assign_node_type_from_node_name(names[input_count-1]);
  
#ifdef debug_mode
        printf("\n exiting assign_node_type_from_node_name\n");
        printf("\n node_type= %d\n",node_type);  
#endif          
        
        if(node_type!=GENERIC)
        {
          new_node->type=node_type;
          skip_reading_bit_map=TRUE;
        }
 /* Check for GENERIC type , change the node by reading the bit map */
        else if(node_type == GENERIC)
        {
          new_node->type=read_bit_map_find_unknown_gate(input_count-1,new_node);
          skip_reading_bit_map=TRUE;

#ifdef debug_mode
        printf("\n exiting read_bit_map_find_unknown_gate \n");
        printf("\n node_type= %d\n",new_node->type);  
#endif

        }
 
  /* allocate the input pin (= input_count-1)*/
         if (input_count-1 > 0) // check if there is any input pins     
        {  
          allocate_more_node_input_pins(new_node, input_count-1);

 /* add the port information */
                if(new_node->type==MUX_2)
                {
                        add_input_port_information(new_node, (input_count-1)/2);
                        add_input_port_information(new_node, (input_count-1)/2);
                }
                else
                {
                  for(i=0;i<input_count-1;i++)
                  { 
                        add_input_port_information(new_node, 1);
                  }  
                }
        }
  /* add names and type information to the created input pins */
        for(i=0;i<=input_count-2;i++)
        {
          new_pin=allocate_npin();
          new_pin->name=names[i];
          new_pin->type=INPUT;
          add_a_input_pin_to_node_spot_idx(new_node, new_pin, i);
        }

  /* add information for the intermediate VCC and GND node (appears in ABC )*/
  if(new_node->type==GND_NODE)
  {
         allocate_more_node_input_pins(new_node,1);
         add_input_port_information(new_node, 1);
         new_pin=allocate_npin();
         new_pin->name=(char *)GND;
         new_pin->type=INPUT;
         add_a_input_pin_to_node_spot_idx(new_node, new_pin,0);  
  }
  
  if(new_node->type==VCC_NODE)
  {
         allocate_more_node_input_pins(new_node,1);
         add_input_port_information(new_node, 1);
         new_pin=allocate_npin();
         new_pin->name=(char *)VCC;
         new_pin->type=INPUT;
         add_a_input_pin_to_node_spot_idx(new_node, new_pin,0);  
  }


  /* allocate the output pin (there is always one output pin) */
  allocate_more_node_output_pins(new_node, 1);
  add_output_port_information(new_node, 1);

 /* add a name for the node, keeping the name of the node same as the output */
  new_node->name = make_full_ref_name(names[input_count-1],NULL, NULL, NULL,-1);   
  
  /*add this node to blif_netlist as an internal node */
  blif_netlist->internal_nodes = (nnode_t**)realloc(blif_netlist->internal_nodes, sizeof(nnode_t*)*(blif_netlist->num_internal_nodes+1));
  blif_netlist->internal_nodes[blif_netlist->num_internal_nodes] =new_node;
  blif_netlist->num_internal_nodes++;
 

  /*add name information and a net(driver) for the output */
  new_pin=allocate_npin();
  new_net=allocate_nnet();
  new_net->name=new_node->name;
  new_pin->name=new_node->name;
  new_pin->type=OUTPUT;
  add_a_output_pin_to_node_spot_idx(new_node, new_pin, 0);
  add_a_driver_pin_to_net(new_net,new_pin);
  
  /*list this output in output_nets_sc */
   sc_spot = sc_add_string(output_nets_sc,new_node->name );
        if (output_nets_sc->data[sc_spot] != NULL)
        {
          error_message(NETLIST_ERROR,linenum,-1, "Net (%s) with the same name already created\n",ptr); 
        }
        
  /* store the data which is an idx here */
  output_nets_sc->data[sc_spot] = (void*)new_net;

  /* Free the char** names */
  free(names);

#ifdef debug_mode
        printf("\n exiting create_internal_node_driver");
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void create_latch_node_and_driver

(

char *

blif_file

)

Definition at line 342 of file read_blif.c.

{

#ifdef debug_mode
        printf("\n Reading the create_latch_node and driver ");
#endif
  
  long sc_spot;
  nnode_t *new_node = allocate_nnode();
  npin_t *new_pin;
  nnet_t *new_net;
  char buffer[BUFSIZE];
  char *ptr;
  int input_token_count=0;/*to keep track whether controlling clock is specified or not */
                          /*input_token_count=3 it is not and =5 it is */
  int i;
  char ** names=NULL;// Store the names of the tokens
  char *clock_name; // Needed if the control (clock) not specified      

  /* Storing the names of the input and the final output in array names */
        while ((ptr= my_strtok (NULL, TOKENS, blif, buffer)) != NULL)
        {
#ifdef debug_mode
          printf("\n\t ptr=%s",ptr);
#endif
          input_token_count++;
          names= (char**)realloc(names, sizeof(char*)* input_token_count);  
          names[input_token_count-1]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
          sprintf(names[input_token_count-1],"%s",ptr);
        }


  /* assigning the new_node */

#ifdef debug_mode
printf("\n\tinput_token_count=%d\n",input_token_count);
#endif

        if(input_token_count!=5)
        {
                /* supported added for the ABC .latch output without control */
                if(input_token_count==3)
                {
                        clock_name=search_clock_name(blif_file);
                        input_token_count=5;
                        names= (char**)realloc(names, sizeof(char*)* input_token_count);  
                        if(clock_name!=NULL)
                        {
                          names[3]=(char*)malloc(sizeof(char)*(strlen(clock_name)+1));
                          sprintf(names[3],"%s",clock_name);
                        }
                        else
                        names[3]=NULL;                  

                        names[4]=(char*)malloc(sizeof(char)*(1+1));
                        sprintf(names[4],"%s",names[2]);
                        sprintf(names[2],"re");

                }

                else
                {       
                  printf("This .latch Format not supported \n\t required format :.latch <input> <output> [<type> <control/clock>] <initial val>");
                  exit(-1);
                }
        }

  new_node->related_ast_node = NULL;
  new_node->type=FF_NODE;
  
  /* allocate the output pin (there is always one output pin) */
  allocate_more_node_output_pins(new_node, 1);
  add_output_port_information(new_node, 1);

  /* allocate the input pin */
  allocate_more_node_input_pins(new_node,2);/* input[1] is clock */ 
  
  /* add the port information */
  for(i=0;i<2;i++)
  {
    add_input_port_information(new_node,1); 
  }

  /* add names and type information to the created input pins */
  new_pin=allocate_npin();
  new_pin->name=names[0];
  new_pin->type=INPUT;
  add_a_input_pin_to_node_spot_idx(new_node, new_pin,0);

  new_pin=allocate_npin();
  new_pin->name=names[3];
  new_pin->type=INPUT;
  add_a_input_pin_to_node_spot_idx(new_node, new_pin,1);


  /* add a name for the node, keeping the name of the node same as the output */
  new_node->name = make_full_ref_name(names[1],NULL, NULL, NULL,-1);  
        

  /*add this node to blif_netlist as an ff (flip-flop) node */
  blif_netlist->ff_nodes = (nnode_t**)realloc(blif_netlist->ff_nodes, sizeof(nnode_t*)*(blif_netlist->num_ff_nodes+1));
  blif_netlist->ff_nodes[blif_netlist->num_ff_nodes] =new_node;
  blif_netlist->num_ff_nodes++;

  /*add name information and a net(driver) for the output */
  new_pin=allocate_npin();
  new_net=allocate_nnet();
  new_net->name=new_node->name;
  new_pin->name=new_node->name;
  new_pin->type=OUTPUT;
  add_a_output_pin_to_node_spot_idx(new_node, new_pin, 0);
  add_a_driver_pin_to_net(new_net,new_pin);
  
  /*list this output in output_nets_sc */
   sc_spot = sc_add_string(output_nets_sc,new_node->name);


        if (output_nets_sc->data[sc_spot] != NULL)
        {
          error_message(NETLIST_ERROR,linenum,-1, "Net (%s) with the same name already created\n",ptr); 
        }

  /* store the data which is an idx here */
  output_nets_sc->data[sc_spot] = (void*)new_net;

  /* Free the char** names */
  free(names);

#ifdef debug_mode
        printf("\n exiting the create_latch_node and driver ");
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void create_top_driver_nets

(

char *

instance_name_prefix

)

Definition at line 1417 of file read_blif.c.

{

#ifdef debug_mode
        printf("\nin top level driver net function");
#endif

        npin_t *new_pin;
        long sc_spot;// store the location of the string stored in string_cache
/* create the constant nets */

        /* ZERO net */ 
        /* description given for the zero net is same for other two */
        blif_netlist->zero_net = allocate_nnet(); // allocate memory to net pointer
        blif_netlist->gnd_node = allocate_nnode(); // allocate memory to node pointer
        blif_netlist->gnd_node->type = GND_NODE;  // mark the type
        allocate_more_node_output_pins(blif_netlist->gnd_node, 1);// alloacate 1 output pin pointer to this node 
        add_output_port_information(blif_netlist->gnd_node, 1);// add port info. this port has 1 pin ,till now number of port for this is one
        new_pin = allocate_npin();
        add_a_output_pin_to_node_spot_idx(blif_netlist->gnd_node, new_pin, 0);// add this pin to output pin pointer array of this node
        add_a_driver_pin_to_net(blif_netlist->zero_net,new_pin);// add this pin to net as driver pin 

        /*ONE net*/

        blif_netlist->one_net = allocate_nnet();
        blif_netlist->vcc_node = allocate_nnode();
        blif_netlist->vcc_node->type = VCC_NODE;
        allocate_more_node_output_pins(blif_netlist->vcc_node, 1);
        add_output_port_information(blif_netlist->vcc_node, 1);
        new_pin = allocate_npin();
        add_a_output_pin_to_node_spot_idx(blif_netlist->vcc_node, new_pin, 0);
        add_a_driver_pin_to_net(blif_netlist->one_net, new_pin);

        /* Pad net */

        blif_netlist->pad_net = allocate_nnet();
        blif_netlist->pad_node = allocate_nnode();
        blif_netlist->pad_node->type = PAD_NODE;
        allocate_more_node_output_pins(blif_netlist->pad_node, 1);
        add_output_port_information(blif_netlist->pad_node, 1);
        new_pin = allocate_npin();
        add_a_output_pin_to_node_spot_idx(blif_netlist->pad_node, new_pin, 0);
        add_a_driver_pin_to_net(blif_netlist->pad_net, new_pin);

        
        /* CREATE the driver for the ZERO */
        blif_zero_string = make_full_ref_name(instance_name_prefix, NULL, NULL, zero_string, -1);
        blif_netlist->gnd_node->name = (char *)GND;

        sc_spot = sc_add_string(output_nets_sc, (char *)GND);
        if (output_nets_sc->data[sc_spot] != NULL)
        {
                error_message(NETLIST_ERROR,-1,-1, "Error in Odin\n");
        }

        /* store the data which is an idx here */
        output_nets_sc->data[sc_spot] = (void*)blif_netlist->zero_net;
        blif_netlist->zero_net->name =blif_zero_string;

        /* CREATE the driver for the ONE and store twice */
        blif_one_string = make_full_ref_name(instance_name_prefix, NULL, NULL, one_string, -1);
        blif_netlist->vcc_node->name = (char *)VCC;

        sc_spot = sc_add_string(output_nets_sc, (char *)VCC);
        if (output_nets_sc->data[sc_spot] != NULL)
        {
                error_message(NETLIST_ERROR,-1,-1, "Error in Odin\n");
        }
        /* store the data which is an idx here */
        output_nets_sc->data[sc_spot] = (void*)blif_netlist->one_net;
        blif_netlist->one_net->name =blif_one_string;

        /* CREATE the driver for the PAD */
        blif_pad_string = make_full_ref_name(instance_name_prefix, NULL, NULL, pad_string, -1);
        blif_netlist->pad_node->name = (char *)HBPAD;

        sc_spot = sc_add_string(output_nets_sc, (char *)HBPAD);
        if (output_nets_sc->data[sc_spot] != NULL)
        {
                error_message(NETLIST_ERROR, -1,-1, "Error in Odin\n");
        }
        /* store the data which is an idx here */
        output_nets_sc->data[sc_spot] = (void*)blif_netlist->pad_net;
        blif_netlist->pad_net->name = blif_pad_string;

#ifdef debug_mode
        printf("\nexiting the top level driver net module");
#endif

}

Here is the call graph for this function:

void create_top_output_nodes

(

)

Definition at line 1325 of file read_blif.c.

{

#ifdef debug_mode
  printf("\n reading the create_top_output_nodes\n");
#endif

  char *ptr; 
  char buffer[BUFSIZE];
  npin_t *new_pin;
  nnode_t *new_node;
  char *temp_string;

  while (1)
        {
        /* keep reading the outputs till there is no more to read*/
                ptr = my_strtok (NULL, TOKENS, blif, buffer);

                if (ptr == NULL)
                        return;

        /* create a new top output node and */
        new_node = allocate_nnode();

        temp_string= make_full_ref_name(ptr, NULL, NULL,NULL, -1);;
        
        /* Create the pin connection for the net */
        new_pin = allocate_npin();
        new_pin->name=temp_string;      
        
        /*add_a_fanout_pin_to_net((nnet_t*)output_nets_sc->data[sc_spot], new_pin);*/

        new_node->related_ast_node = NULL;
        new_node->type = OUTPUT_NODE;

        /* add the name of the output variable */ 
        new_node->name = temp_string;

        /* allocate the input pin needed */
        allocate_more_node_input_pins(new_node, 1);
        add_input_port_information(new_node, 1);

        

        /* hookup the pin, net, and node */
        add_a_input_pin_to_node_spot_idx(new_node, new_pin, 0);
                

        /*adding the node to the blif_netlist output nodes
          add_node_to_netlist() function can also be used */
        
        blif_netlist->top_output_nodes = (nnode_t**)realloc(blif_netlist->top_output_nodes, sizeof(nnode_t*)*(blif_netlist->num_top_output_nodes+1));
        blif_netlist->top_output_nodes[blif_netlist->num_top_output_nodes] = new_node;
        blif_netlist->num_top_output_nodes++;
        
        }

#ifdef debug_mode
         printf("\n exiting the create_top_output_nodes");
#endif

} 

Here is the call graph for this function:

static void dum_parse

(

char *

buffer

)

[static]

Definition at line 1511 of file read_blif.c.

{
        /* Continue parsing to the end of this (possibly continued) line. */
        while (my_strtok (NULL, TOKENS, blif, buffer) != NULL);
}

Here is the caller graph for this function:

void hook_up_nets

(

)

Definition at line 1523 of file read_blif.c.

{
  int i,j;
  char * name_pin;
  int input_pin_count=0;
  npin_t * input_pin;
  nnet_t * output_net;
  nnode_t * node;
  long sc_spot;

  /* hook all the input pins in all the internal nodes to the net */
  for(i=0;i<blif_netlist->num_internal_nodes;i++)
  {     
        node=blif_netlist->internal_nodes[i];
        input_pin_count=node->num_input_pins;
        for(j=0;j<input_pin_count;j++)
        {
                input_pin=node->input_pins[j];
                name_pin=input_pin->name;
                sc_spot=sc_lookup_string(output_nets_sc,name_pin);
                if(sc_spot==(-1))
                {
                        printf("Error :Could not hook the pin %s not available ",name_pin);
                        exit(-1);
                }
                output_net=(nnet_t*)output_nets_sc->data[sc_spot];
                /* add the pin to this net as fanout pin */

                add_a_fanout_pin_to_net(output_net,input_pin);
        }
  }     

  /* hook all the ff nodes' input pin to the nets */
    for(i=0;i<blif_netlist->num_ff_nodes;i++)
  {     
        node=blif_netlist->ff_nodes[i];
        input_pin_count=node->num_input_pins;
        for(j=0;j<input_pin_count;j++)
        {
                input_pin=node->input_pins[j];
                name_pin=input_pin->name;
                sc_spot=sc_lookup_string(output_nets_sc,name_pin);
                if(sc_spot==(-1))
                {                       
                        printf("Error :Could not hook the pin %s not available ",name_pin);
                        exit(-1);
                }
                output_net=(nnet_t*)output_nets_sc->data[sc_spot];
                /* add the pin to this net as fanout pin */
                add_a_fanout_pin_to_net(output_net,input_pin);  
                
        }
  }

  /* hook the top output nodes input pins */
  for(i=0;i<blif_netlist->num_top_output_nodes;i++)
  {
        node=blif_netlist->top_output_nodes[i];
        input_pin_count=node->num_input_pins;
        for(j=0;j<input_pin_count;j++)
        {
                input_pin=node->input_pins[j];
                name_pin=input_pin->name;
                sc_spot=sc_lookup_string(output_nets_sc,name_pin);
                if(sc_spot==(-1))
                {
                        printf("Error:Could not hook the pin %s not available ",name_pin);
                        exit(-1);
                }
                output_net=(nnet_t*)output_nets_sc->data[sc_spot];
                /* add the pin to this net as fanout pin */
                add_a_fanout_pin_to_net(output_net,input_pin);

        }

  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void look_for_clocks

(

)

Definition at line 1393 of file read_blif.c.

{
        int i; 
        for (i = 0; i < blif_netlist->num_ff_nodes; i++)
        {
                if (blif_netlist->ff_nodes[i]->input_pins[1]->net->driver_pin->node->type != CLOCK_NODE)
                {
                        blif_netlist->ff_nodes[i]->input_pins[1]->net->driver_pin->node->type = CLOCK_NODE;
                }
        }

}

short read_bit_map_find_unknown_gate	(	int	input_count,
		nnode_t *	node
	)

Definition at line 1035 of file read_blif.c.

{

#ifdef debug_mode
        printf(" Reading the read_bit_map_find_unknown_gate \n");
#endif
        
  FILE * temp_fpointer;
  char buffer[BUFSIZE];
  fpos_t pos;// store the current position of the file pointer
  char *ptr;
  int i,j;
  int line_count_bitmap=0; //stores the number of lines in a particular bit map
  char ** bit_map=NULL;
  char output_bit_map[10];// to distinguish whether for the bit_map output is 1 or 0  
                
  fgetpos(blif,&pos);
  temp_fpointer=blif;

  if(input_count==0)
  {
        my_fgets (buffer, BUFSIZE, temp_fpointer);
        ptr = my_strtok(buffer,"\t\n",temp_fpointer, buffer);
        fsetpos(blif,&pos);
        if(strcmp(ptr," 0")==0)
        return GND_NODE;
        else if(strcmp(ptr," 1")==1)
        return VCC_NODE;
        else if(ptr==NULL)
        return GND_NODE;
        else
        return VCC_NODE;
  }
        
  while(1)
  {
        my_fgets (buffer, BUFSIZE, temp_fpointer);
        if(!(buffer[0]=='0' || buffer[0]=='1' || buffer[0]=='-'))
                break;

        line_count_bitmap++;
   
   ptr = my_strtok(buffer,TOKENS,temp_fpointer, buffer); /* extract the input only*/
   bit_map=(char**)realloc(bit_map,sizeof(char*)*line_count_bitmap);
   bit_map[line_count_bitmap-1]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
   sprintf(bit_map[line_count_bitmap-1],"%s",ptr);
   ptr = my_strtok(NULL,TOKENS,temp_fpointer, buffer);
   sprintf(output_bit_map,"%s",ptr);     
  }
  
#ifdef debug_mode
        printf(" Line_count_bitmap = %d \n",line_count_bitmap);
        printf(" input_count= %d \n",input_count);
        printf("Printing the extracted bit map \n");
        for(i=0;i<line_count_bitmap;i++)
        printf("\t: %s \n",bit_map[i]);
#endif

  fsetpos(blif,&pos);

  /* check if the node type is known */ 
  
  /* Single line bit map : */

  if(line_count_bitmap==1)
  {
          /* GT */
          if(strcmp(bit_map[0],"100")==0)
                return GT;

          /* LT */
          if(strcmp(bit_map[0],"010")==0)
                return LT;

          /* LOGICAL_AND and LOGICAL_NAND for ABC*/
          for(i=0;i<input_count && bit_map[0][i]=='1';i++);
          if(i==input_count)
          {
                if(strcmp(output_bit_map,"1")==0)
                return LOGICAL_AND;
                else if (strcmp(output_bit_map,"0")==0)
                return LOGICAL_NAND;
           }
        
          /* BITWISE_NOT */
          if(strcmp(bit_map[0],"0")==0)
                return BITWISE_NOT;

          /* LOGICAL_NOR and LOGICAL_OR for ABC */
          for(i=0;i<input_count && bit_map[0][i]=='0';i++);
          if(i==input_count)
          {
                if(strcmp(output_bit_map,"1")==0)
                return LOGICAL_NOR;
                else if (strcmp(output_bit_map,"0")==0)
                return LOGICAL_OR;
          }

          
          

  }     

  /* Assumption that bit map is in order when read from blif */
  
  else if(line_count_bitmap==2)
  {

#ifdef debug_mode
        printf(" check : %d \n",strcmp(bit_map[0],"01"));
        printf(" check : %d \n",strcmp(bit_map[1],"10"));
#endif

        /* LOGICAL_XOR */
        if((strcmp(bit_map[0],"01")==0) && (strcmp(bit_map[1],"10")==0))
                return  LOGICAL_XOR;

        /* LOGICAL_XNOR */
        if((strcmp(bit_map[0],"00")==0) && (strcmp(bit_map[1],"11")==0))                        return  LOGICAL_XNOR;
 }        


  else if (line_count_bitmap==4)
  {
        /* ADDER_FUNC */
        if((strcmp(bit_map[0],"001")==0) && (strcmp(bit_map[1],"010")==0) && (strcmp(bit_map[2],"100")==0) && (strcmp(bit_map[3],"111")==0))
                return ADDER_FUNC;
        
        /* CARRY_FUNC */
        if((strcmp(bit_map[0],"011")==0) && (strcmp(bit_map[1],"100")==0) && (strcmp(bit_map[2],"110")==0) && (strcmp(bit_map[3],"111")==0))
                return  CARRY_FUNC;
  
        /* LOGICAL_XOR */
        if((strcmp(bit_map[0],"001")==0) && (strcmp(bit_map[1],"010")==0) && (strcmp(bit_map[2],"100")==0) && (strcmp(bit_map[3],"111")==0))
                return  LOGICAL_XOR;

        /* LOGICAL_XNOR */
        if((strcmp(bit_map[0],"000")==0) && (strcmp(bit_map[1],"011")==0) && (strcmp(bit_map[2],"101")==0) && (strcmp(bit_map[3],"110")==0))
                return  LOGICAL_XNOR;


  }
  
  if(line_count_bitmap==input_count)
  {
        /* LOGICAL_OR */
        for(i=0;i<line_count_bitmap;i++)
        {
                if(bit_map[i][i]=='1')
                {
                        for(j=1;j<input_count;j++)
                        {
                                if(bit_map[i][(i+j)% input_count]!='-')
                                        break;
                        }
                        if(j!=input_count)
                        break;
                }
                else break;
        }       
        if(i==line_count_bitmap)
                return LOGICAL_OR;

        /* LOGICAL_NAND */

        for(i=0;i<line_count_bitmap;i++)
        {
                if(bit_map[i][i]=='0')
                {
                        for(j=1;j<input_count;j++)
                        {
                                if(bit_map[i][(i+j)% input_count]!='-')
                                        break;
                        }
                        if(j!=input_count)
                        break;
                }
                else break;
        }       
        if(i==line_count_bitmap)
                return LOGICAL_NAND;
  }

  /* MUX_2 */   
  if(line_count_bitmap*2==input_count);
  {
        for(i=0;i<line_count_bitmap;i++)
        {
          if((bit_map[i][i]=='1') && (bit_map[i][i+line_count_bitmap] =='1'))
          {
                for(j=1;j<line_count_bitmap;j++)
                {
                        if((bit_map[i][(i+j)%line_count_bitmap]!='-') || (bit_map[i][((i+j)%line_count_bitmap)+line_count_bitmap]!='-'))
                                break;  
                }
                if(j!=input_count)
                break;
          }
          else break;
        }
        if(i==line_count_bitmap)
                return MUX_2;
  }

         /* assigning the bit_map to the node if it is GENERIC */
        
        node->bit_map=bit_map;
        node->bit_map_line_count=line_count_bitmap;
        return GENERIC;

}

Here is the caller graph for this function:

void read_blif

(

char *

blif_file

)

Definition at line 74 of file read_blif.c.

{

      int done;
      char buffer[BUFSIZE]; /* for storing the tokens */

      /* initialize the string caches that hold the aliasing of module nets and input pins */
      output_nets_sc = sc_new_string_cache();
      input_nets_sc = sc_new_string_cache();

      blif_netlist = allocate_netlist();
      /*Opening the blif file */
      blif = my_fopen (blif_file, "r", 0);
     

#ifdef debug_mode
        printf("reading top level module");
#endif

      /* create the top level module */     
      create_top_driver_nets("top");

      /* Extracting the netlist by reading the blif file */

        linenum = 0;
        done = 0;
        while (!done && (my_fgets(buffer, BUFSIZE, blif) != NULL) )
        {       
                read_tokens(buffer,&done,blif_file);/* read one token at a time */
        }

        fclose (blif);
        
#ifdef debug_mode  
        printf("\nreading look_for_clock\n");
#endif
      /* now look for high-level signals */
        
        look_for_clocks(); 
        /* not need as simulator does't propogates clock signal */ 
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void read_tokens	(	char *	buffer,
		int *	done,
		char *	blif_file
	)			[static]

Definition at line 122 of file read_blif.c.

{
        
        /* Figures out which, if any token is at the start of this line and *
         * takes the appropriate action.                                    */
        char *ptr; // pointer to the tokens

        ptr = my_strtok (buffer, TOKENS, blif, buffer); // ptr has the token now compare it with the standards tokens

#ifdef debug_mode
        printf("\nreading the read_tokens : %s",ptr);
#endif
        
        if (ptr == NULL)
                return;
                

        if((skip_reading_bit_map==TRUE) &&((ptr == NULL) && ((ptr[0] == '0') || (ptr[0] == '1') || (ptr[0] == '-'))))
        {
          dum_parse(buffer);
          return ;
        }
        
        skip_reading_bit_map= FALSE;    
        if (strcmp (ptr, ".inputs") == 0) 
        {
        /* Create an input node */
           add_top_input_nodes();// create the top input nodes
           return;
        }       

        if (strcmp (ptr, ".outputs") == 0)
        {
        /* Create output nodes */
           create_top_output_nodes();// create the top output nodes
           return;
        }

        if (strcmp (ptr, ".names") == 0)
        {
          /* create the internal node for a .name (gate)*/      
          create_internal_node_and_driver();
          return;
        }

        if(strcmp(ptr,".latch") == 0)
        {
        /* create the ff node */        
        create_latch_node_and_driver(blif_file);
        return;
        }

        if(strcmp(ptr,".subckt") == 0)
        {
#ifdef debug_mode
        printf("\n reading the subckt module \n");
#endif  
        /* create the ff node */        
        create_hard_block_nodes();
        return;
        }

        if(strcmp(ptr,".end")==0)
        {
        /* marks the end of the main module of the blif */
        /* call functions to hook up the nets */
        hook_up_nets();
        *done=1;
        return;
        }

        if(strcmp(ptr,".model")==0)
        {
        /* not need for now */
        dum_parse(buffer);
        return;
        }
        
}

Here is the call graph for this function:

Here is the caller graph for this function:

char * search_clock_name

(

char *

blif_file

)

Definition at line 481 of file read_blif.c.

{
  FILE * temp_read_blif;
  int found=0;
  char *ptr;
  char buffer[BUFSIZE];
  char ** input_names=NULL;
  int input_names_count=0;
  int i=0;
  temp_read_blif=fopen(blif_file,"r"); 

#ifdef debug_mode
        printf("Control for the .latch not mentioned, searching for the clock\n");
#endif

  while(1)
  {
        if(found==1)
        break;

        my_fgets(buffer,BUFSIZE,temp_read_blif);
#ifdef debug_mode
        printf(" buffer : %s \n",buffer);
#endif

        if(feof(temp_read_blif)!=0)// not sure if this is needed 
        break;
        
        ptr= my_strtok(buffer,TOKENS,temp_read_blif,buffer);
#ifdef debug_mode
        printf(" ptr : %s \n",ptr);
#endif  

        if(ptr==NULL)
        continue;

        if(strcmp(ptr,".end")==0)
        break;

        

        if(strcmp(ptr,".inputs")==0)
        {
          /* store the inputs in array of string */
          while(1)
          {
                ptr=my_strtok (NULL, TOKENS,temp_read_blif, buffer);

#ifdef debug_mode
        printf(" ptr : %s \n",ptr);
#endif          
                if(ptr==NULL)
                break;
                if(strcmp(ptr,"top^reset_n")!=0)
                {
                input_names_count++;
                input_names=(char**)realloc(input_names,sizeof(char*) * input_names_count);
                input_names[input_names_count-1]=(char*)malloc(sizeof(char)*(strlen(ptr)+1));
                sprintf(input_names[input_names_count-1],"%s",ptr);
                }

          }

        continue;
        }

        if(strcmp(ptr,".names")==0 || strcmp(ptr,".latch")==0)
        {
          while(1)
          {

#ifdef debug_mode
        printf(" ptr : %s \n",ptr);
#endif                  
                ptr=my_strtok (NULL, TOKENS,temp_read_blif, buffer);
                
                if(ptr==NULL)
                  break;

                for(i=0;i<input_names_count;i++)
                {
                        if(strcmp(ptr,input_names[i])==0)
                        {                               
                          free(input_names[i]); 
                          input_names[i]=input_names[input_names_count-1];
                          input_names_count--;  
                        }
                }
          }
        continue;
        }
        
        if(input_names_count==1)
        {
                found=1;
                break;
        }
                
  } 
  fclose(temp_read_blif);


  if(found==1)
  {
#ifdef debug_mode
        printf("Clock name found: %s\n",input_names[0]);
#endif
        return input_names[0];
  }
  else
  {
        return default_clock_name;      
  }     

}

Here is the caller graph for this function:

---

Variable Documentation

FILE* blif [static]

Definition at line 41 of file read_blif.c.

netlist_t* blif_netlist

Definition at line 56 of file read_blif.c.

char* blif_one_string = "ONE_VCC_CNS"

Definition at line 51 of file read_blif.c.

char* blif_pad_string = "ZERO_PAD_ZERO"

Definition at line 53 of file read_blif.c.

char* blif_zero_string = "ZERO_GND_ZERO"

Definition at line 52 of file read_blif.c.

char* default_clock_name = "top^clock"

Definition at line 54 of file read_blif.c.

const char* GND = "gnd"

Definition at line 47 of file read_blif.c.

const char* HBPAD = "unconn"

Definition at line 49 of file read_blif.c.

STRING_CACHE* input_nets_sc

Definition at line 45 of file read_blif.c.

int linenum

Definition at line 42 of file read_blif.c.

STRING_CACHE* output_nets_sc

Definition at line 44 of file read_blif.c.

short skip_reading_bit_map = FALSE [static]

Definition at line 58 of file read_blif.c.

const char* VCC = "vcc"

Definition at line 48 of file read_blif.c.