WebSVN – Vertical – Diff – /branches/metal/vertlib/print_vlog.c

 /*
  * $Id: print_vlog.c,v 1.2 2004/06/22 21:44:14 mjames Exp $
+ *
  * $Log: print_vlog.c,v $
  * Revision 1.2  2004/06/22 21:44:14  mjames
  * Firrst build most files
+ *
  * Mike put it here
+ *
+ *
  * Revision 1.21  2000/10/04  10:37:08  10:37:08  mjames (Mike James)
  * Modified for Vertical2 : support COMPONENTS and SIGNALS
  *
  * Revision 1.21  2000/10/04  10:37:08  10:37:08  mjames (Mike James)
  * Part of Release PSAVAT01
  *
  * Revision 1.20  2000/10/02  11:04:18  11:04:18  mjames (Mike James)
  * new_vhdl
  *
  * Revision 1.19  2000/09/27  14:42:18  14:42:18  mjames (Mike James)
  * Part of Release Sep_27_ST_2000
  *
  * Revision 1.18  2000/09/21  10:15:48  10:15:48  mjames (Mike James)
  * Part of Release Sep21Alpha
  *
  * Revision 1.17  2000/08/25  09:57:14  09:57:14  mjames (Mike James)
  * Part of Release Aug25_alpha
  *
  * Revision 1.16  2000/08/16  08:57:30  08:57:30  mjames (Mike James)
  * Part of Release CD01_Aug2000
  *
  * Revision 1.15  2000/08/14  14:45:12  14:45:12  mjames (Mike James)
  * Part of Release Aug_14_2000
  *
  * Revision 1.14  2000/08/14  14:43:27  14:43:27  mjames (Mike James)
  * Added power pins
  *
  * Revision 1.13  2000/08/11  14:17:18  14:17:18  mjames (Mike James)
  * Failed to suppress declaring internal components
  * when printing verilog.
  *
  * Revision 1.12  2000/08/11  08:30:32  08:30:32  mjames (Mike James)
  * Part of Release Aug_11_2000
  *
  * Revision 1.11  2000/08/09  10:31:47  10:31:47  mjames (Mike James)
  * Part of Release Aug__9_2000
  *
  * Revision 1.10  2000/05/31  11:42:57  11:42:57  mjames (Mike James)
  * Part of Release May_31_2000
  *
  * Revision 1.9  2000/05/08  17:01:38  17:01:38  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.8  2000/05/08  16:59:31  16:59:31  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.7  2000/05/08  16:57:07  16:57:07  mjames (Mike James)
  * Part of Release May__8_2000
  *
  * Revision 1.6  2000/03/08  16:19:23  16:19:23  mjames (Mike James)
  * New version including PC
  *
  * Revision 1.3  2000/01/20  15:58:47  15:58:47  mjames (Mike James)
  * Part of Release R22
  *
  * Revision 1.2  99/12/22  11:15:28  11:15:28  mjames (Mike James)
  * Part of Release Dec_22_1999
  *
  * Revision 1.1  99/11/23  13:52:43  13:52:43  mjames (Mike James)
  * Initial revision
  *
  */
+#include <stdio.h>
+#include <string.h>
-#include "cmdlog.h"
+#include <stdlib.h>
-#include "cmdparse.h"
+#include <ctype.h>
-#include "database.h"
+#include <time.h>
+#include <regex.h>
+#include "vertcl_main.h"
 #include "expression.h"
 #include "generic.h"
-#include "print_vhdl.h"
+#include "database.h"
 #include "printout.h"
+#include "print_vhdl.h"
 #include "sorting.h"
-#include "vertcl_main.h"
+#include "cmdparse.h"
+#include "cmdlog.h"
-#include <ctype.h>
-#include <regex.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
 /* ********************************************************************** */
 /* Decoding pin direction in VLOG */
-static char *decode_pin_VLOG[] = {"inout", /* was -NONE- */
+static char * decode_pin_VLOG[]=
+{
-                                  "inout", /* was in */
+  "inout", /* was -NONE- */
-                                  "out",
+  "inout", /* was in */
+  "out",
-                                  "out", /* buffer is a sort of Output pin */
+  "out", /* buffer is a sort of Output pin */
-                                  "inout",
+  "inout",
-                                  "inout",  /* config is a sort of input pin */
+  "inout",  /* config is a sort of input pin */
-                                  "inout"}; /* power is a sort of input pin */
+  "inout"}; /* power is a sort of input pin */
 /* ********************************************************************** */
 /* VHDL output of the entities                                            */
 /* ********************************************************************** */
-static char illegal[] = "-+:|/.\\$ ";
+static char illegal[]="-+:|/.\\$ ";
-static char replace[] = "NPCxxxxS_";
+static char replace[]="NPCxxxxS_";
-char *make_VLOG_name (char *buffer, char *str)
+char * make_VLOG_name(char * buffer,char * str)
 {
-        int i, l, j;
+  int i,l,j;
-        l = strlen (str);
+  l=strlen(str);
-        if (isdigit (str[0]))
+  if (isdigit(str[0]))
-        {
+    {
-                l += 1;
+    l += 1;
-                sprintf (buffer, "\%s", str); /* might as well use the verilog quotation method
+    sprintf(buffer,"\%s",str);   /* might as well use the verilog quotation method in this case */
-                                                 in this case */
-        }
+    }
-        else
+  else
-                strcpy (buffer, str);
+    strcpy(buffer,str);
-        /* spot illegal strings in the net name */
+/* spot illegal strings in the net name */
-        for (i = 0; i < l; i++)
+  for(i=0;i<l;i++){
-        {
-                for (j = 0; j < sizeof (illegal); j++)
+    for(j=0;j<sizeof(illegal);j++)
-                        if (buffer[i] == illegal[j])
+      if (buffer[i]==illegal[j])
-                                buffer[i] = replace[j];
+        buffer[i]=replace[j];
-        }
+    }
-        i = l - 1;
+  i=l-1;
-        /* convert pin indices back from Altera form if we are looking at FIT files */
+  /* convert pin indices back from Altera form if we are looking at FIT files */
-        if (l)
-        {
+  if(l){
-                /* name ends in underscore, this forces mapping name_nn_ --> name(nn) */
+    /* name ends in underscore, this forces mapping name_nn_ --> name(nn) */
-                if (buffer[i] == '_')
+    if(buffer[i] =='_'){
-                {
-                        buffer[i--] = ']';
+      buffer[i--]=']';
-                        while (i >= 0 && buffer[i] != '_')
+      while(i>=0 && buffer[i] != '_')
-                                i--;
+        i--;
-                        if (i >= 0)
+      if(i>=0)
-                                buffer[i] = '[';
+        buffer[i] = '[';
-                }
+      }
-        }
+  }
-        return buffer;
+  return buffer;
+}
 /* ********************************************************************** */
 /* decodes the 'vector' part of a bus , if known                           */
-int decode_VLOG_bus (FILE *f, vhdl_t *vhdl)
+int decode_VLOG_bus(FILE * f,vhdl_t * vhdl) {
-{
-        if (!vhdl)
+  if(!vhdl)
-                vhdl = default_vhdl_datatype;
+     vhdl=default_vhdl_datatype;
-        if (vhdl->is_vector)
+  if(vhdl->is_vector) {
-        {
-                int bus_high, bus_low;
+    int bus_high,bus_low;
-                bus_high = 0;
+    bus_high=0;
-                bus_low = 0;
+    bus_low =0;
-                eval_vhdl_expression (vhdl->expr, &bus_high, &bus_low);
+    eval_vhdl_expression(vhdl->expr,&bus_high,&bus_low);
-                if (bus_high == bus_low)
+    if(bus_high==bus_low)
-                        return fprintf (f, "[%d]", bus_high);
+      return fprintf(f,"[%d]",           bus_high);
-                else
+    else
-                        return fprintf (f, "[%d:%d]", bus_high, bus_low);
+      return fprintf(f,"[%d:%d]", bus_high, bus_low);
-        }
+    }
-        return 0;
+  return 0;
-}
+  }
 /* ********************************************************************** */
 /* ?? looks like hangover from VHDL */
 #if defined NEED_VLOG_TYPE
-void decode_VLOG_type (FILE *f, vhdl_t *vhdl)
+void decode_VLOG_type(FILE * f,vhdl_t * vhdl)
+{
-        /* avoid crashing on a null pointer */
+/* avoid crashing on a null pointer */
-        if (!vhdl)
+  if(!vhdl)
-                vhdl = default_vhdl_datatype;
+    vhdl=default_vhdl_datatype;
-        fprintf (f, "%s ", vhdl->basetype);
+  fprintf (f,"%s ",vhdl->basetype);
-        decode_VLOG_bus (f, vhdl);
+  decode_VLOG_bus(f,vhdl);
-}
+  }
 #endif
 /* ********************************************************************** */
 /* Certify specific stuff */
 /* this copies declaration directives over */
-void assign_declaration_directives (socket_t *skt, generic_info_t *list)
+void assign_declaration_directives(socket_t * skt,generic_info_t * list) {
-{
-        while (list)
+  while(list) {
-        {
-                if (list->g_type == IS_DECLARATION_DIRECTIVE)
+    if (list->g_type ==   IS_DECLARATION_DIRECTIVE)
-                        set_generic_value (&(skt->generics), list);
+      set_generic_value(&(skt->generics), list) ;
-                if (list->g_type == IS_INSTANCE_DIRECTIVE)
+    if (list->g_type ==   IS_INSTANCE_DIRECTIVE)
-                        set_generic_value (&(skt->generics), list);
+      set_generic_value(&(skt->generics), list) ;
-                list = list->next;
+    list = list->next;
-        }
+    }
-}
+  }
-/* ********************************************************************** */
-/* print out a VLOG component declaration */
-void print_VLOG_component (FILE *f, socket_t *dev, int All)
-{
-        node_t *n;
-        char printed = 0;
-        char nam[MAXIDLEN], typ[MAXIDLEN];
-        generic_info_t *g_list = dev->generics;
-        make_VLOG_name (typ, check_null_str (dev->type));
-        fprintf (f, "\nmodule  %s (\n", typ);
-        /* sort the identifiers of the nodes */
-        sort_nodes (dev, NO_EXTRACT_XY);
-        n = dev->nodes;
-        while (n)
-        {
-                /* print the pin ID if it is connected to a net and the net is routable */
-                if (All || (n->net && n->net->how_routed != Not_Routable))
-                {
-                        char nam1[MAXIDLEN];
-                        if (printed)
-                                fprintf (f, ",\n");
-                        printed = 1;
-                        sprintf (nam1, "%s", check_null_str (n->identifier));
-                        fprintf (f, "  %s", make_VLOG_name (nam, nam1));
-                }
-                n = n->sktnext; /* traverse to next pin on socket */
-        };
-        fprintf (f, " );\n\n");
-        /* list any declaration directives */
-        while (g_list)
-        {
-                if (g_list->g_type == IS_DECLARATION_DIRECTIVE)
-                {
-                        if (!g_list->expr || ISNULLSTR (g_list->expr->left.s))
-                                fprintf (f, "/* synthesis %s */\n", g_list->name);
-                        else
-                                fprintf (
-                                    f,
-                                    "/* synthesis %s = %s*/\n",
-                                    g_list->name,
-                                    check_null_str (g_list->expr->left.s));
-                }
-                g_list = g_list->next;
-        }
-        n = dev->nodes;
-        while (n)
-        {
-                if (dev->is_template || (n->net && n->net->how_routed != Not_Routable))
-                {
-                        fprintf (
-                            f,
-                            " %8s %s ",
-                            decode_pin_VLOG[(int) n->pindir],
-                            make_VLOG_name (nam, check_null_str (n->identifier)));
-                        decode_VLOG_bus (f, n->vhdltype);
-                        fprintf (f, ";\n");
-                }
-                n = n->sktnext; /* traverse to next pin on socket */
-        };
-        fprintf (f, "endmodule\n\n");
-}
 /* ********************************************************************** */
-/* Printout an instance of a component */
+/* print out a VLOG component declaration */
-/* ********************************************************************** */
-void print_VLOG_instance (FILE *f, socket_t *dev, int All)
-{
-        node_t *n;
-        int need_term = 0;
-        char nam[MAXIDLEN], id[MAXIDLEN];
-        generic_info_t *g_list = dev->generics;
-        make_VLOG_name (nam, check_null_str (dev->type));
-        make_VLOG_name (id, check_null_str (dev->identifier));
-        fprintf (f, "\n\n/* Component instance */\n");
-        fprintf (f, "%s %s ", nam, id);
-        while (g_list)
-        {
-                if (g_list->g_type == IS_INSTANCE_DIRECTIVE)
-                {
-                        if (!g_list->expr || ISNULLSTR (g_list->expr->left.s))
-                                fprintf (f, "/* synthesis %s */\n", g_list->name);
-                        else
-                                fprintf (
-                                    f,
-                                    "/* synthesis %s = %s*/\n",
-                                    g_list->name,
-                                    check_null_str (g_list->expr->left.s));
-                }
-                g_list = g_list->next;
-        }
-        fprintf (f, "   (\n");
-        sort_nodes (dev, NO_EXTRACT_XY);
-        n = dev->nodes;
+void print_VLOG_component(FILE * f,socket_t * dev, int All)
+{
+  node_t * n;
+  char printed = 0;
+    char nam[MAXIDLEN],typ[MAXIDLEN];
+  generic_info_t * g_list= dev->generics;
+  make_VLOG_name(typ,check_null_str(dev->type));
+  fprintf(f,"\nmodule  %s (\n",typ);
+  /* sort the identifiers of the nodes */
+  sort_nodes(dev,NO_EXTRACT_XY);
+  n=dev->nodes;
-        while (n)
+  while(n)
+  {
+    /* print the pin ID if it is connected to a net and the net is routable */
+    if(All || (n->net && n->net->how_routed != Not_Routable )){
+      char nam1[MAXIDLEN];
+      if (printed)
+        fprintf(f,",\n");
+      printed = 1;
+      sprintf(nam1,"%s",check_null_str(n->identifier));
+      fprintf(f,"  %s",
+                make_VLOG_name(nam,nam1));
+      }
+    n=n->sktnext; /* traverse to next pin on socket */
+  };
+  fprintf(f," );\n\n");
+/* list any declaration directives */
+  while(g_list) {
+    if (g_list->g_type ==   IS_DECLARATION_DIRECTIVE) {
+       if (!g_list->expr || ISNULLSTR(g_list->expr->left.s))
+          fprintf(f,"/* synthesis %s */\n",
+                  g_list->name);
+       else
+          fprintf(f,"/* synthesis %s = %s*/\n",
+                  g_list->name,
+                  check_null_str(g_list->expr->left.s));
-        {
+       }
+    g_list = g_list->next;
+    }
+  n=dev->nodes;
+  while(n)
+  {
+    if(dev->is_template || (n->net  && n->net->how_routed != Not_Routable  )){
+      fprintf(f," %8s %s ",
-                char nam1[MAXIDLEN], nam2[MAXIDLEN];
+                decode_pin_VLOG[(int)n->pindir],
-                /* is there need to add a buffer signal prefix */
+                make_VLOG_name(nam,check_null_str(n->identifier)));
+      decode_VLOG_bus(f,n->vhdltype);
+      fprintf(f,";\n");
+      }
+    n=n->sktnext; /* traverse to next pin on socket */
+  };
+  fprintf(f,"endmodule\n\n");
-                if (n->net && n->net->how_routed != Not_Routable)
-                {
-                        if (need_term)
-                                fprintf (f, ",\n");
-                        else
-                                fprintf (f, "\n");
-                        need_term = 1;
-                        if (n->net_assigned && n->in_use && !ISNULLSTR (n->identifier))
-                        {
-                                fprintf (
-                                    f,
-                                    "   .%s(%s",
-                                    make_VLOG_name (nam1, check_null_str (n->identifier)),
-                                    make_VLOG_name (
-                                        nam2, check_null_str (n->net->name))); /* was
-                                                                                  identifier */
-                                decode_VLOG_bus (f, n->vhdltype);
-                                fprintf (f, ")");
-                        }
-                        else
-                        {
-                                /* No assigned net : pin exists  */
-                                fprintf (
-                                    f,
-                                    "   .%s()",
-                                    make_VLOG_name (nam1, check_null_str (n->identifier)));
-                        }
-                }
-                else
-                {
-                        if (n->net && n->net->how_routed != Not_Routable)
-                        {
-                                /* If we are printing comments then dont need a comma next time
-                                 */
-                                if (need_term)
-                                        fprintf (f, ",\n");
-                                else
-                                        fprintf (f, "\n");
-                                need_term = 1;
-                                fprintf (
-                                    f,
-                                    "   .pin_%s()",
-                                    make_VLOG_name (nam1, check_null_str (n->identifier)));
-                        }
-                }
-                n = n->sktnext; /* traverse to next pin on socket */
-        };
-        fprintf (f, "\n   );\n\n");
+}
 /* ********************************************************************** */
-void print_VLOG_sigs (FILE *f)
-{
-        net_t *net = named_list;
-        int width = 0;
-        char nam[MAXIDLEN], *sig_prefix;
-        while (net)
-        {
-                if (net->needs_buff_sig)
-                        sig_prefix = BUFPREFIX;
-                else
-                        sig_prefix = "";
-                if ((net->how_routed != Not_Routable) &&
-                    ((net->bundle_member) || ((net->inside_partition) && net->has_external)))
-                { /* May 21 2001 only print nets that connect to 'external' tagged modules */
-                        /* add to this those in a bundled connection */
-                        width += fprintf (
-                            f, " wire %s%s;", sig_prefix, make_VLOG_name (nam, net->name));
-                        if (strcmp (nam, net->name) != 0) /* names changed by printout */
-                                width += fprintf (f, "/* \"%s\" */", net->name);
-                }
-                else
-                {
-                        if (level & 1)
-                        {
-                                fprintf (
+/* Printout an instance of a component */
-                                    f,
-                                    "  /* wire %s%s; ",
-                                    sig_prefix,
-                                    make_VLOG_name (nam, net->name));
-                                fprintf (f, " */");
-                        }
-                }
-                if (level & 1)
-                {
-                        fprintf (
-                            f,
-                            " /* partition : %s %s %s %s %s*/\n",
-                            net->inside_partition ? "used in," : "unused in,",
-                            net->leaves_partition ? "leaves," : "buried,",
-                            net->needs_buff_sig ? ", buffered," : "",
-                            net->has_external ? "external skt" : "internal skt",
-                            net->bundle_member ? "bundle member" : " not bundled");
-                }
-                if ((level & 1) || (width > MAXWIDTH))
-                {
-                        width = 0;
-                        fprintf (f, "\n  ");
-                }
-                net = net->next;
-        }
-}
 /* ********************************************************************** */
-void print_VLOG_assignments (FILE *f)
+void print_VLOG_instance(FILE * f,socket_t * dev, int All)
+{
+  node_t * n;
-        net_t *net = named_list;
+  int need_term = 0;
+  char nam[MAXIDLEN],id[MAXIDLEN];
-        socket_t *socket = socket_head;
+  generic_info_t * g_list= dev->generics;
+  make_VLOG_name(nam,check_null_str(dev->type));
+  make_VLOG_name(id ,check_null_str(dev->identifier));
-        fprintf (f, "/* Bundle signals */\n\n");
+  fprintf(f,"\n\n/* Component instance */\n");
+  fprintf(f,"%s %s ",nam,id);
-        while (socket)
+  while(g_list) {
+    if (g_list->g_type ==   IS_INSTANCE_DIRECTIVE) {
+       if (!g_list->expr || ISNULLSTR(g_list->expr->left.s))
+          fprintf(f,"/* synthesis %s */\n",
+                  g_list->name);
-        {
+       else
-                node_t *nodes = socket->nodes;
+          fprintf(f,"/* synthesis %s = %s*/\n",
-                if (socket->highest_bundle &&
+                  g_list->name,
-                    (socket->bundle_width > MINBUNDLE)) /* will not do assigns on small bundles
+                  check_null_str(g_list->expr->left.s));
+       }
+    g_list = g_list->next;
+    }
+  fprintf(f,"   (\n");
+  sort_nodes(dev,NO_EXTRACT_XY);
+  n=dev->nodes;
+  while(n)
+  {
+    char nam1[MAXIDLEN] , nam2[MAXIDLEN];
-                                                         */
+      /* is there need to add a buffer signal prefix */
+      if(n->net && n->net->how_routed != Not_Routable  ){
+        if(need_term)
-                        while (nodes)
+          fprintf(f,",\n");
+        else
+          fprintf(f,"\n");
-                        {
+        need_term = 1;
+        if(n->net_assigned && n->in_use && !ISNULLSTR(n->identifier) )  {
+          fprintf(f,"   .%s(%s",
-                                /*      if (strcmp("X6",socket->identifier)==0)              */
+                 make_VLOG_name(nam1,check_null_str(n->identifier)),
-                                /*        {                                                  */
+                 make_VLOG_name(nam2,check_null_str(n->net->name))); /* was identifier */
+          decode_VLOG_bus(f,n->vhdltype);
+          fprintf(f,")");
+           }
+        else {
+        /* No assigned net : pin exists  */
+           fprintf(f,"   .%s()",
-                                /*        printf("-- X6 index = %d\n",nodes->bundle_index);  */
+                 make_VLOG_name(nam1,check_null_str(n->identifier)));
+          }
+        }
+    else {
+      if (n->net && n->net->how_routed !=Not_Routable) {
-                                /*        }                                                  */
+    /* If we are printing comments then dont need a comma next time */
+        if(need_term)
+          fprintf(f,",\n");
+        else
+          fprintf(f,"\n");
+        need_term = 1;
+        fprintf(f,"   .pin_%s()",
-                                if (nodes->bundle_index >= 0)
+            make_VLOG_name(nam1,check_null_str(n->identifier)));
+        }
+      }
+    n=n->sktnext; /* traverse to next pin on socket */
+  };
+  fprintf(f,"\n   );\n\n");
+}
+/* ********************************************************************** */
+void print_VLOG_sigs(FILE * f)
+{
+  net_t * net = named_list;
+  int width = 0;
+  char  nam[MAXIDLEN], * sig_prefix;
+  while(net){
+   if(net->needs_buff_sig)
+     sig_prefix = BUFPREFIX;
+   else
+     sig_prefix = "";
+   if((net->how_routed != Not_Routable) &&
+     ((net->bundle_member) || ((net->inside_partition) && net->has_external)) ) { /* May 21 2001 only print nets that connect to 'external' tagged modules */
+ /* add to this those in a bundled connection */
+      width+= fprintf(f," wire %s%s;",
-                                {
+                 sig_prefix,
-                                        char nam[MAXIDLEN];
+                 make_VLOG_name(nam,net->name));
+      if (strcmp(nam,net->name)!=0) /* names changed by printout */
-                                        net_t *net = nodes->net;
+         width+= fprintf(f,"/* \"%s\" */",net->name);
+      }
+    else {
+      if(level & 1)
+        {
+        fprintf(f,"  /* wire %s%s; ",
+                 sig_prefix,
-                                        make_VLOG_name (nam, net->name);
+                 make_VLOG_name(nam,net->name));
+        fprintf(f," */");
+        }
+      }
+    if (level & 1)
+      {
+      fprintf(f," /* partition : %s %s %s %s %s*/\n",
+            net->inside_partition?"used in,":"unused in,",
-                                        fprintf (
+            net->leaves_partition?"leaves,":"buried,",
-                                            f,
+            net->needs_buff_sig?", buffered,":"",
-                                            " assign %s[%d] = %s;\n",
+            net->has_external?"external skt":"internal skt",
+            net->bundle_member?"bundle member":" not bundled");
+      }
+    if((level &1) || (width>MAXWIDTH))
+      {
+      width = 0;
+      fprintf(f,"\n  ");
+      }
+    net=net->next;
+  }
+}
+/* ********************************************************************** */
+void print_VLOG_assignments(FILE * f)
+{
+  net_t * net = named_list;
+  socket_t * socket = socket_head;
+  fprintf(f,"/* Bundle signals */\n\n");
+  while(socket)
+    {
+    node_t * nodes = socket->nodes;
+    if (socket->highest_bundle  && (socket->bundle_width > MINBUNDLE)) /* will not do assigns on small bundles */
+    while(nodes)
+      {
+/*      if (strcmp("X6",socket->identifier)==0)              */
-                                            socket->identifier,
+/*        {                                                  */
-                                            nodes->bundle_index,
+/*        printf("-- X6 index = %d\n",nodes->bundle_index);  */
-                                            nam);
+/*        }                                                  */
+      if (nodes->bundle_index >= 0)
+        {
+        char  nam[MAXIDLEN];
-                                }
+        net_t * net = nodes->net;
+        make_VLOG_name(nam,net->name);
+        fprintf(f," assign %s[%d] = %s;\n",
-                                nodes = nodes->sktnext;
+               socket->identifier,nodes->bundle_index,nam);
-                        }
+        }
-                /*    else
+      nodes = nodes->sktnext;
+      }
+/*    else
-                      fprintf(f,"-- %s;\n",
+      fprintf(f,"-- %s;\n",
-                               net->name);
+               net->name);
-                */
+*/
-                socket = socket->next;
+    socket = socket->next;
-        }
+    }
-        fprintf (f, "/* end bundle signals */ \n\n");
+  fprintf(f,"/* end bundle signals */ \n\n");
 #if defined USE_PREV
-        fprintf (f, "/* Bundle signals */\n\n");
+  fprintf(f,"/* Bundle signals */\n\n");
-        while (net)
+  while(net)
-        {
+    {
-                if (net->bundle_parent)
+    if (net->bundle_parent)
-                {
+      {
-                        char nam[MAXIDLEN];
+      char  nam[MAXIDLEN];
-                        make_VLOG_name (nam, net->name);
+      make_VLOG_name(nam,net->name);
-                        fprintf (
-                            f,
-                            " assign %s[%d] = %s;\n",
+      fprintf(f," assign %s[%d] = %s;\n",
-                            net->bundle_parent->identifier,
+               net->bundle_parent->identifier,net->bundle_index,nam);
-                            net->bundle_index,
-                            nam);
-                }
+      }
-                /*    else
+/*    else
-                      fprintf(f,"-- %s;\n",
+      fprintf(f,"-- %s;\n",
-                               net->name);
+               net->name);
-                */
+*/
-                net = net->next;
+    net=net->next;
-        }
+    }
-        fprintf (f, "/* end bundle signals */ \n\n");
+  fprintf(f,"/* end bundle signals */ \n\n");
 #endif
-        net = named_list;
+  net = named_list;
-        fprintf (f, "/* Buffered signals */\n\n");
+  fprintf(f,"/* Buffered signals */\n\n");
-        while (net)
+  while(net)
-        {
+    {
-                if (net->inside_partition && net->needs_buff_sig)
+    if(net->inside_partition && net->needs_buff_sig)
-                {
+      {
-                        char nam[MAXIDLEN];
+      char  nam[MAXIDLEN];
-                        make_VLOG_name (nam, net->name);
+      make_VLOG_name(nam,net->name);
-                        fprintf (f, " assign " BUFPREFIX "%s = %s;\n", nam, nam);
+      fprintf(f," assign "BUFPREFIX"%s = %s;\n",
-                }
+               nam,nam);
-                net = net->next;
+      }
-        }
+    net=net->next;
+    }
-        fprintf (f, "/* end Buffered signals */ \n\n");
-}
+  fprintf(f,"/* end Buffered signals */ \n\n");
+  }
-/* ********************************************************************** */
+/* ********************************************************************** */
-void print_VLOG_entity (FILE *f, char *entityname)
-{
+void print_VLOG_entity(FILE * f,char * entityname)
-        net_t *net;
+{
-        int need_term = 0;
+  net_t * net;
-        int width = 0;
+  int need_term = 0;
-        socket_t *skt;
+  int width     = 0;
-        char nam[MAXIDLEN];
+  socket_t * skt;
+  char nam[MAXIDLEN];
-        fprintf (f, "\nmodule %s ", entityname);
+  fprintf(f,"\nmodule %s ",entityname);
-        fprintf (f, "(\n  ");
-        skt = socket_head;
+  fprintf(f,"(\n  ");
-        /* bundles of pins are replaced by signals named the same as a socket which
-           they are bundled through , unless the bundles are too small in which case they
-           are replaced by separate wires */
+  skt = socket_head;
-        while (skt)
+/* bundles of pins are replaced by signals named the same as a socket which
-        {
+   they are bundled through , unless the bundles are too small in which case they
-                if (skt->highest_bundle)
+   are replaced by separate wires */
-                {
+  while(skt)
-                        if (skt->bundle_width > MINBUNDLE)
+    {
-                        {
+    if(skt->highest_bundle)
-                                if (need_term)
+      {
-                                {
+      if (skt->bundle_width > MINBUNDLE)
-                                        width += fprintf (f, ", ");
+        {
-                                        need_term = 0;
+        if(need_term)
-                                }
+          {
-                                if (width > MAXWIDTH)
+          width+= fprintf(f,", ");
-                                {
+          need_term = 0;
-                                        width = 0;
+          }
-                                        fprintf (f, "\n  ");
+        if(width>MAXWIDTH)
-                                }
+          {
-                                width += fprintf (f, "%s", skt->identifier);
+          width = 0;
-                                need_term = 1;
+          fprintf(f,"\n  ");
-                        }
+          }
-                        else
+        width+= fprintf(f,"%s",skt->identifier);
-                        /* if the 'bundle' has less than MINBUNDLE pins, */
+        need_term  = 1;
-                        /* list out all of the nets in turn as pins      */
+        }
-                        {
+      else
-                                node_t *node;
+/* if the 'bundle' has less than MINBUNDLE pins, */
-                                node = skt->nodes;
+/* list out all of the nets in turn as pins      */
-                                while (node)
+        {
-                                {
+        node_t * node;
-                                        net = node->net;
+        node = skt-> nodes;
-                                        /*
+        while (node)
-                                            printf("node %s\n",node->identifier);
+         {
-                                        */
+         net = node->net;
-                                        if (net && (net->how_routed != Not_Routable) &&
+/*
-                                            net->bundle_member)
+    printf("node %s\n",node->identifier);
-                                        {
+*/
-                                                if (need_term)
+         if(net && (net->how_routed != Not_Routable) && net->bundle_member)
-                                                {
+           {
-                                                        width += fprintf (f, ", ");
+           if(need_term)
-                                                        need_term = 0;
+             {
-                                                }
+             width+= fprintf(f,", ");
-                                                if (width > 60)
+             need_term = 0;
-                                                {
+             }
-                                                        width = 0;
+           if(width>60)
-                                                        fprintf (f, "\n  ");
+             {
-                                                }
+             width = 0;
-                                                width += fprintf (f, "%s", net->identifier);
+             fprintf(f,"\n  ");
-                                                need_term = 1;
+             }
-                                        }
+           width+= fprintf(f,"%s",net->identifier);
-                                        node = node->sktnext;
+           need_term = 1;
-                                }
+           }
-                        }
+         node = node->sktnext;
-                }
+         }
-                skt = skt->next;
+        }
-        }
+      }
-        net = named_list;
+    skt = skt->next;
+    }
-        while (net)
-        {
-                /* print out only unbundled nets as ports of the pcb */
+  net = named_list;
-                if (net->leaves_partition && !net->bundle_member)
-                {
+  while(net){
-                        if (need_term)
+    /* print out only unbundled nets as ports of the pcb */
-                        {
+    if(net->leaves_partition && !net->bundle_member)
-                                width += fprintf (f, ", ");
+      {
-                        }
+      if(need_term)
-                        if (width > MAXWIDTH)
+        {
-                        {
+        width+= fprintf(f,", ");
-                                width = 0;
+        }
-                                fprintf (f, "\n  ");
+       if(width>MAXWIDTH)
-                        }
+        {
-                        width += fprintf (f, " %s", make_VLOG_name (nam, net->name));
+        width = 0;
-                        /*        width+= decode_VLOG_bus(f,net->vhdltype); Not used in verilog
+        fprintf(f,"\n  ");
-                         */
+        }
-                        if (strcmp (nam, net->name) != 0) /* names changed by printout */
+        width+= fprintf(f," %s",
-                                width += fprintf (f, " /* \"%s\" */", net->name);
+               make_VLOG_name(nam,net->name));
+/*        width+= decode_VLOG_bus(f,net->vhdltype); Not used in verilog */
-                        need_term = 1;
+      if (strcmp(nam,net->name)!=0) /* names changed by printout */
-                }
+        width+=fprintf(f," /* \"%s\" */",net->name);
-                net = net->next;
-        }
+      need_term = 1;
-        /* terminate port list */
+      }
-        fprintf (f, ");\n");
+    net=net->next;
-        fprintf (f, "/* synthesis syn_partition = \"board\" */ \n\n");
+    }
+/* terminate port list */
-        need_term = 0;
+  fprintf(f,");\n");
-        skt = socket_head;
+  fprintf(f,"/* synthesis syn_partition = \"board\" */ \n\n");
-        /* now write out the verilog types of ll of the ports*/
+  need_term = 0;
-        while (skt)
+  skt = socket_head;
-        {
-                if (skt->highest_bundle)
-                {
+/* now write out the verilog types of ll of the ports*/
-                        /* big bundles are listed as a single item */
-                        if (skt->bundle_width > MINBUNDLE)
+  while(skt)
-                        {
+    {
-                                fprintf (
+    if(skt->highest_bundle)
-                                    f,
+      {
-                                    "  inout [%d:%d] %s; // row(%d:%d) col(%d:%d) \n",
+/* big bundles are listed as a single item */
-                                    skt->highest_bundle,
+      if (skt->bundle_width > MINBUNDLE)
-                                    skt->lowest_bundle,
+        {
-                                    skt->identifier,
+        fprintf(f,"  inout [%d:%d] %s; // row(%d:%d) col(%d:%d) \n",skt->highest_bundle,skt->lowest_bundle,skt->identifier,
-                                    skt->min_pin_row,
+              skt->min_pin_row, skt->max_pin_row,
-                                    skt->max_pin_row,
+              skt->min_pin_col,  skt->max_pin_col);
-                                    skt->min_pin_col,
+        }
-                                    skt->max_pin_col);
+      else
-                        }
+/* small bundles are enumerated as induvidual wires */
-                        else
+        {
-                        /* small bundles are enumerated as induvidual wires */
+        node_t * node;
-                        {
+        node = skt-> nodes;
-                                node_t *node;
+        while (node)
-                                node = skt->nodes;
+          {
-                                while (node)
+          net = node->net;
-                                {
+/*
-                                        net = node->net;
+    printf("node %s\n",node->identifier);
-                                        /*
+*/
-                                            printf("node %s\n",node->identifier);
+          if(net && net->bundle_member)
-                                        */
+            {
-                                        if (net && net->bundle_member)
+            fprintf(f,"  %s ",
-                                        {
+              decode_pin_VLOG[net->ext_dir]);
-                                                fprintf (
+              decode_VLOG_bus(f,net->vhdltype);
-                                                    f, "  %s ", decode_pin_VLOG[net->ext_dir]);
+              fprintf(f," %s;\n",
-                                                decode_VLOG_bus (f, net->vhdltype);
+               make_VLOG_name(nam,net->name));
-                                                fprintf (
+            }
-                                                    f,
+         node = node->sktnext;
-                                                    " %s;\n",
+         }
-                                                    make_VLOG_name (nam, net->name));
+        }
-                                        }
+      }
-                                        node = node->sktnext;
-                                }
+    skt = skt->next;
-                        }
+    }
-                }
+  net = named_list;
+  while(net){
+    char nam[MAXIDLEN];
+    if(net->leaves_partition && !net->bundle_member){
+      fprintf(f,"  %s ",
+               decode_pin_VLOG[net->ext_dir]);
+      decode_VLOG_bus(f,net->vhdltype);
+      fprintf(f," %s;\n",
+               make_VLOG_name(nam,net->identifier));
+      }
+    net=net->next;
-                skt = skt->next;
-        }
+    }
+  fprintf(f,"\n");
-        net = named_list;
+  }
-        while (net)
-        {
-                char nam[MAXIDLEN];
-                if (net->leaves_partition && !net->bundle_member)
-                {
-                        fprintf (f, "  %s ", decode_pin_VLOG[net->ext_dir]);
-                        decode_VLOG_bus (f, net->vhdltype);
-                        fprintf (f, " %s;\n", make_VLOG_name (nam, net->identifier));
-                }
-                net = net->next;
-        }
-        fprintf (f, "\n");
-}
 /* ********************************************************************** */
 /* generate default VLOG Libraries */
 /* ********************************************************************** */
-void print_VLOG_libs (FILE *f)
+void print_VLOG_libs(FILE * f)
+{
-        fprintf (f, "/* Default text */\n\n");
+  fprintf(f,"/* Default text */\n\n");
+}
 /* **********************************************************************
  * clear verilog 'type seen' flags (providing a single declaration for all
  * instances of a given type
  * **********************************************************************
  * Using this as a means to avoid duplicate components: only print those
  * not seen before */
-void clr_type_seen (void)
+void clr_type_seen(void) {
-{
-        socket_t *skt;
+  socket_t * skt;
-        skt = template_head;
+  skt = template_head;
-        while (skt)
+  while(skt){
-        {
-                skt->socket_type_seen = 0;
+    skt->socket_type_seen = 0;
-                skt = skt->next;
+    skt = skt->next;
-        }
+    }
-}
+ }
 /* **********************************************************************
  * set verilog 'type seen' flags  for all instances of a given type
  * ********************************************************************** */
-void set_type_seen (char *type)
+void set_type_seen(char * type) {
-{
-        socket_t *skt;
+  socket_t * skt;
-        skt = socket_head;
+  skt = socket_head;
-        while (skt)
+  while(skt){
-        {
-                if (strcmp (type, skt->type) == 0)
+    if(strcmp(type,skt->type)==0)
-                        skt->socket_type_seen = 1;
+       skt->socket_type_seen = 1;
-                skt = skt->next;
+    skt = skt->next;
-        }
+    }
-}
+ }
 /* ********************************************************************** */
 /* declare all used modules (once !!)  */
 /* ********************************************************************** */
 /* to do: fix up a generic giving an alternative verilog line for the
    FPGA declaration case eg 'include something.v
 Need to
    bundle a socket then del external it for port bundling
 */
-void print_VLOG_declarations (FILE *f, char *entityname)
+void print_VLOG_declarations(FILE * f,char * entityname) {
-{
-        socket_t *skt;
+  socket_t * skt;
-        skt = socket_head;
+  skt = socket_head;
-        clr_type_seen ();
+  clr_type_seen();
-        skt = socket_head;
+  skt = socket_head;
-        /* list out templates for those sockets selected, and which have not been
+  /* list out templates for those sockets selected, and which have not been
-           converted into a bundle */
+     converted into a bundle */
-        while (skt)
+    while(skt){
-        {
-                if (skt->is_external && skt->highest_bundle == 0)
+    if(skt->is_external && skt->highest_bundle==0 ) {
-                {
-                        /* suppress printout of duplicate components .... */
+  /* suppress printout of duplicate components .... */
-                        if (skt->template_socket)
+      if(skt->template_socket)
-                        {
+        {
-                                if (skt->template_socket->socket_type_seen == 0)
+        if( skt->template_socket->socket_type_seen == 0)
-                                {
+          {
-                                        if (!skt->is_FPGA)
+          if (!skt->is_FPGA)
-                                        { /* only printout component decls for non-FPGA:
+            { /* only printout component decls for non-FPGA: Certify
-                                         Certify has its own private store of these
-                                         declarations
+             has its own private store of these declarations
-                                         and it is fiddly to match these exactly. */
+             and it is fiddly to match these exactly. */
-                                                fprintf (
-                                                    f, "\n// defined by component template\n");
+            fprintf(f,"\n// defined by component template\n");
-                                                print_VLOG_component (
-                                                    f, skt->template_socket, 1);
+            print_VLOG_component(f,skt->template_socket,1);
-                                        }
+            }
-                                        else
+          else
-                                        {
+            {
-                                                generic_info_t *info = get_generic_ref (
-                                                    &skt->generics, "fpga_file");
+            generic_info_t * info = get_generic_ref(&skt->generics,"fpga_file");
-                                                fprintf (
-                                                    f,
-                                                    "\n/* socket '%s' is an FPGA: component "
-                                                    "declaration skipped */\n",
+            fprintf(f,"\n/* socket '%s' is an FPGA: component declaration skipped */\n",skt->identifier);
-                                                    skt->identifier);
-                                                if (info && info->g_type == IS_ATTRIBUTE)
+            if(info && info->g_type == IS_ATTRIBUTE)
-                                                {
+              {
-                                                        fprintf (
-                                                            f,
-                                                            "/* replacement for declaration "
-                                                            "*/\n%s\n",
+              fprintf(f,"/* replacement for declaration */\n%s\n",
-                                                            info->expr->left.s
+              info->expr->left.s?info->expr->left.s:"");
-                                                                ? info->expr->left.s
-                                                                : "");
-                                                }
+              }
-                                        }
+            }
-                                        skt->template_socket->socket_type_seen = 1;
+          skt->template_socket->socket_type_seen = 1;
-                                }
+          }
-                        }
+        }
-                        else
+      else
-                        {
+        {
-                                /* no components, use socket/entity as its own component */
+        /* no components, use socket/entity as its own component */
-                                if (!skt->is_FPGA)
+        if (!skt->is_FPGA)
-                                {
+          {
-                                        print_VLOG_component (f, skt, 1);
+          print_VLOG_component(f,skt,1);
-                                }
+          }
-                                else
+        else
-                                {
+          {
-                                        generic_info_t *info =
-                                            get_generic_ref (&skt->generics, "fpga_file");
+          generic_info_t * info = get_generic_ref(&skt->generics,"fpga_file");
-                                        fprintf (
-                                            f,
-                                            "\n/* socket '%s' is an FPGA: socket declaration "
+          fprintf(f,"\n/* socket '%s' is an FPGA: socket declaration skipped */\n",skt->identifier);
-                                            "skipped */\n",
-                                            skt->identifier);
-                                        if (info && info->g_type == IS_ATTRIBUTE)
+          if(info && info->g_type == IS_ATTRIBUTE)
-                                        {
+            {
-                                                fprintf (
-                                                    f,
-                                                    "/* replacement for declaration */\n%s\n",
+            fprintf(f,"/* replacement for declaration */\n%s\n",
-                                                    info->expr->left.s ? info->expr->left.s
+            info->expr->left.s?info->expr->left.s:"");
-                                                                       : "");
-                                        }
+            }
-                                }
+          }
-                        }
+        }
-                }
+      }
-                skt = skt->next;
+    skt = skt->next;
-        }
+    }
-}
+  }
 /* ********************************************************************** */
 /* generate a VLOG architecture  */
 /* ********************************************************************** */
-void print_VLOG_architecture (FILE *f, char *entityname)
-{
-        socket_t *skt;
-        print_VLOG_entity (f, entityname);
-        print_VLOG_sigs (f);
+void print_VLOG_architecture(FILE * f,char * entityname) {
-        skt = socket_head;
+  socket_t * skt;
+  print_VLOG_entity(f,entityname);
+  print_VLOG_sigs(f);
-        while (skt)
+  skt = socket_head;
-        {
+  while(skt){
-                if (skt->is_external && skt->highest_bundle == 0)
+    if(skt->is_external && skt->highest_bundle == 0)
-                        print_VLOG_instance (f, skt, 0);
+       print_VLOG_instance(f,skt,0);
-                skt = skt->next;
+    skt = skt->next;
-        }
+  }
-        print_VLOG_assignments (f);
+  print_VLOG_assignments(f);
-        fprintf (f, "endmodule\n\n");
+  fprintf(f,"endmodule\n\n");
-}
+  }
 /* ********************************************************************** */
 /* generate a VLOG file */
 /* ********************************************************************** */
-void produce_VLOG (FILE *f, char *entityname, char *template)
+void produce_VLOG(FILE * f,char * entityname,char *template) {
-{
-        char linebuff[256];
+  char linebuff[256];
-        int done_architecture = 0, done_declarations = 0;
+  int done_architecture=0,done_declarations=0;
-        if (!template || !template[0])
-        { /* check null pointer or empty string */
+  if(!template || !template[0]) { /* check null pointer or empty string */
-                fprintf (f, "// vertical verilog\n");
+    fprintf(f,"// vertical verilog\n");
-                print_VLOG_header (f, "WRITE VLOG");
+    print_VLOG_header(f,"WRITE VLOG");
-                print_VLOG_declarations (f, entityname);
+    print_VLOG_declarations(f,entityname);
-                print_VLOG_architecture (f, entityname);
+    print_VLOG_architecture(f,entityname);
-                fprintf (f, "\n// vertical end;\n");
+    fprintf(f,"\n// vertical end;\n");
-        }
+    }
-        else
-        { /* there is a template file */
+  else { /* there is a template file */
-                FILE *tp;
+    FILE * tp;
-                tp = fopen (template, "r");
+    tp=fopen(template,"r");
-                if (tp)
+    if(tp) {
-                {
-                        fprintf (f, "// vertical verilog\n");
+      fprintf(f,"// vertical verilog\n");
-                        print_VLOG_header (f, "WRITE VLOG");
+      print_VLOG_header(f,"WRITE VLOG");
-                        fprintf (f, "/* Using template  '%s' */\n", template);
+      fprintf(f,"/* Using template  '%s' */\n",template);
-                        while (!feof (tp))
+      while(!feof(tp)){
-                        {
-                                if (fgets (linebuff, 256, tp))
+        if(fgets(linebuff,256,tp)) {
-                                {
-                                        if (strstr (linebuff, "$DECL$"))
+          if(strstr(linebuff,"$DECL$")) {
-                                        {
-                                                print_VLOG_declarations (f, entityname);
+            print_VLOG_declarations(f,entityname);
-                                                done_declarations++;
+            done_declarations++;
-                                        }
+            }
-                                        else if (strstr (linebuff, "$ARCH$"))
+          else if (strstr(linebuff,"$ARCH$")){
-                                        {
-                                                print_VLOG_architecture (f, entityname);
+            print_VLOG_architecture(f,entityname);
-                                                done_architecture++;
+            done_architecture++;
-                                        }
+            }
-                                        else
+          else
-                                                fprintf (f, "%s", linebuff); /* it already has
+            fprintf(f,"%s",linebuff); /* it already has a '\n' on the end */
-                                                                                a '\n' on the
-                                                                                end */
-                                }
+          }
-                        }
+        }
-                        fprintf (f, "\n// vertical end;\n");
+      fprintf(f,"\n// vertical end;\n");
-                        fclose (tp);
+      fclose(tp);
-                        if (done_declarations != 1)
+      if(done_declarations!=1)
-                                Log (
-                                    LOG_ERROR,
-                                    "-- Error: %d  $DECL$ tags counted (need    1) in "
+        Log(LOG_ERROR,"-- Error: %d  $DECL$ tags counted (need  1) in template '%s'\n",template);
-                                    "template '%s'\n",
-                                    template);
-                        if (done_architecture != 1)
+      if(done_architecture!=1)
-                                Log (
-                                    LOG_ERROR,
-                                    "-- Error: %d  $ARCH$ tags counted (need    1) in "
+        Log(LOG_ERROR,"-- Error: %d  $ARCH$ tags counted (need  1) in template '%s'\n",template);
-                                    "template '%s'\n",
-                                    template);
-                }
-                else
+      }
-                        Log (
+    else
-                            LOG_ERROR,
-                            "-- Error: Cannot open VLOG  template '%s'\n",
+      Log(LOG_ERROR,"-- Error: Cannot open VLOG  template '%s'\n",template);
-                            template);
+    }
+  }
-        }
-}

Subversion Repositories Vertical

(root)/branches/metal/vertlib/print_vlog.c – Rev 2 → 11