URL https://opencores.org/ocsvn/sc2v/sc2v/trunk

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step2.c] - Blame information for rev 39

Go to most recent revision | Details | Compare with Previous | View Log


/* -----------------------------------------------------------------------------
 *
 *  SystemC to Verilog Translator v0.4
 *  Provided by Universidad Rey Juan Carlos
 *
 * -----------------------------------------------------------------------------
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
 
#include "sc2v_step2.h"
 
void
ShowDefines (char *filedefines)
{
 
  int readok;
 
  char *auxchar;
  FILE *file;
 
  file = fopen (filedefines, (char *) "r");
 
  while (1){
    readok = fread ((void *) &auxchar, sizeof (char), 1, file);
    if (readok){
          printf ("%c", auxchar);
        }else{
          break;
        }
  }
}
 
WriteNode *
InsertWrite (WriteNode * list, char *name)
{
  WriteNode *wl;
 
  wl = (WriteNode *) malloc (sizeof (WriteNode));
  strcpy (wl->name, name);
  SGLIB_LIST_ADD (WriteNode, list, wl, next);
  return (list);
}
 
int
IsWrite (WriteNode * list, char *name)
{
  WriteNode *wll;
  SGLIB_LIST_MAP_ON_ELEMENTS (WriteNode, list, wll, next,
  {
        if ((strcmp (name, (char *) wll->name) == 0)) return (1);
    }
  );
  return (0);
}
 
void
ShowWritesList (WriteNode * list)
{
  WriteNode *wll;
  SGLIB_LIST_MAP_ON_ELEMENTS (WriteNode, list, wll, next,{
        printf ("%s\n", wll->name);
    }
  );
  return;
}
 
 
 
WriteNode *
ReadWritesFile (WriteNode *list,char *name)
{
 
  char *leido;
  int ret;
  FILE *file_writes;
  file_writes = fopen (name, (char *) "r");
 
  leido = (char *) malloc (256 * sizeof (char));
 
  while (1){
      ret = fscanf (file_writes, "%s", leido);
      if (ret == EOF)
        break;
      list = InsertWrite (list, leido);
  }
  return(list);
}
 
PortNode *
InsertPort (PortNode * list, char *name, char *tipo, int size, int pflag)
{
  PortNode *pl;
  pl = (PortNode *) malloc (sizeof (PortNode));
  strcpy (pl->name, name);
  strcpy (pl->tipo, tipo);
  pl->size = size;
  pl->pflag = pflag;
  SGLIB_LIST_ADD (PortNode, list, pl, next);
  return (list);
}
 
void
ShowPortList (PortNode * list)
{
 
  PortNode *pll;
 
  SGLIB_LIST_MAP_ON_ELEMENTS (PortNode, list, pll, next,
  {
        printf ("%s ", pll->tipo);
        if (pll->pflag == 1) printf("signed ");
        if (pll->size != 0 && pll->size != 1)
        {
          printf ("[%d:0] ", (-1 + pll->size));}
        printf ("%s;\n", pll->name);
        }
  );
  return;
}
 
void
RegOutputs (PortNode * list, InstanceNode *instances)
{
 
  PortNode *pll;
  SGLIB_LIST_MAP_ON_ELEMENTS (PortNode, list, pll, next,
  {
        if (strcmp (pll->tipo, "output") == 0)
        {
         if(!IsWire(pll->name,instances)){
           if (pll->pflag == 1) printf("reg signed "); else printf ("reg ");
          if (pll->size != 0 && pll->size != 1)
          {
            printf ("[%d:0] ", (-1 + pll->size));}
            printf ("%s;\n", pll->name);}
          }
         }
  );
  return;
}
 
void
EnumeratePorts (PortNode *list)
{
  PortNode *pll;
 
  SGLIB_LIST_MAP_ON_ELEMENTS (PortNode, list, pll, next,
  {
        if (pll->next == NULL)
        {
          printf ("%s", pll->name); break;
        }
        else
        {
          printf ("%s,", pll->name);}
        }
  );
  return;
}
 
SignalNode *
InsertSignal (SignalNode * list, char *name, int size, int arraysize,int sflag)
{
  SignalNode *sl;
 
  sl = (SignalNode *) malloc (sizeof (SignalNode));
  strcpy (sl->name, name);
  sl->size = size;
  sl->arraysize=arraysize;
  sl->sflag=sflag;
  SGLIB_LIST_ADD (SignalNode, list, sl, next);
  return (list);
 
}
 
 
void
ShowSignalsList (SignalNode * list, WriteNode * writeslist)
{
  SignalNode *sll;
  SGLIB_LIST_MAP_ON_ELEMENTS (SignalNode, list, sll, next,
  {
        if (IsWrite (writeslist, sll->name))
        {
          if (sll->sflag==1) printf("reg signed "); else printf ("reg ");
          if (sll->size != 0 && sll->size != 1)
          {
            printf ("[%d:0] ", (-1 + sll->size));
          }
          printf ("%s", sll->name);
        }
        else
        {
          if (sll->sflag==1) printf("wire signed "); else printf ("wire ");
          if (sll->size != 0 && sll->size != 1)
          {
                printf ("[%d:0] ", (-1 + sll->size));
          }
          printf ("%s", sll->name);
        }
        if(sll->arraysize !=0)
          printf("[%d:0]", (-1 + sll->arraysize));
        printf(";\n");
  }
  );
  return;
}
 
 
/* Decides if a signal is a wire or a reg*/
int
IsWire (char *name, InstanceNode * list)
{
 
  InstanceNode *ill;
  SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, list, ill, next,
  {
    BindNode * bll;
        SGLIB_LIST_MAP_ON_ELEMENTS (BindNode,ill->bindslist, bll, next,
        {
        if ((strcmp(name,bll->namebind)==0))
        {
         return 1;
        }
        }
        );}
  );
  return 0;
}
 
 
 
SensibilityNode *
InsertSensibility (SensibilityNode * list, char *name, char *tipo)
{
  SensibilityNode *sl;
  sl = (SensibilityNode *) malloc (sizeof (SensibilityNode));
  strcpy (sl->name, name);
  strcpy (sl->tipo, tipo);
  SGLIB_LIST_ADD (SensibilityNode, list, sl, next);
  return (list);
}
 
void
ShowSensibilityList (SensibilityNode * list)
{
  SensibilityNode *sll;
  SGLIB_LIST_MAP_ON_ELEMENTS (SensibilityNode, list, sll, next,
  {
        if (!strcmp (sll->tipo, "posedge")|| !strcmp (sll->tipo,"negedge"))
          printf (" %s",sll->tipo);
        if (sll->next == NULL)
        {
          printf (" %s", sll->name); break;
        }
        else
        {
          printf (" %s or", sll->name);}
    }
  );
  return;
}
 
 
ProcessNode *
InsertProcess (ProcessNode * list, char *name,
               SensibilityNode * SensibilityList, char *tipo)
{
  ProcessNode *pl;
  pl = (ProcessNode *) malloc (sizeof (ProcessNode));
  strcpy (pl->name, name);
  strcpy (pl->tipo, tipo);
  pl->list = SensibilityList;
  SGLIB_LIST_ADD (ProcessNode, list, pl, next);
  return (list);
}
 
 
void
ShowProcessList (ProcessNode * list)
{
  ProcessNode *pll;
  SGLIB_LIST_MAP_ON_ELEMENTS (ProcessNode, list, pll, next,
  {
        printf ("%s: always @(", pll->name);
        ShowSensibilityList (pll->list); printf (")\n");
  }
  );
  return;
}
 
 
void
ShowProcessCode (ProcessNode * list)
{
  FILE *archivo;
  int readok;
  char lookahead;
  char *filename;
  char auxchar;
  char begin[10];
 
  ProcessNode *pll;
  SGLIB_LIST_MAP_ON_ELEMENTS (ProcessNode, list, pll, next,
  {
    fprintf(stderr,"Writing process code => %s\n",pll->name);
        printf ("//%s:\n", pll->name);
        filename =(char *) malloc (256 * sizeof (char));
        strcpy (filename, pll->name);
        strcat (filename, (char *) "_regs.sc2v");
        archivo = fopen (filename, (char *) "r");
        while (1)
        {
          readok =fread ((void *) &auxchar, sizeof (char), 1,archivo);
          if (readok) printf ("%c", auxchar);
          else
            break;
        }
    fclose (archivo);
    printf ("always @(");
 
    ShowSensibilityList (pll->list);
    printf (" )\n");
    printf ("   begin\n");
    strcpy (filename, pll->name);
    strcat (filename, (char *) ".sc2v");
    archivo = fopen (filename, (char *) "r");
 
        /*Read the initial begin of the file */
    fscanf (archivo, "%s", begin);
    readok =fread ((void *) &auxchar, sizeof (char), 1,archivo);
 
        /*Trim the beggining of the file */
        while (auxchar == '\n' || auxchar == ' ' || auxchar == '\t')
            readok =fread ((void *) &auxchar, sizeof (char), 1,archivo); printf ("\n   %c", auxchar);
 
        while (1){
          readok = fread ((void *) &auxchar, sizeof (char), 1,archivo);
          if (readok){
             if (strcmp (pll->tipo, "comb") == 0 && auxchar == '<')
                 {
                   readok = fread ((void *) &lookahead, sizeof (char), 1, archivo);
                   if (readok){
                          if (lookahead == '='){
                              auxchar = lookahead;
                          }else{
                              printf ("%c", auxchar);
                              auxchar = lookahead;
                          }
                   }
             }
                 printf ("%c", auxchar);
          }
      else
      {
        break;
          }
    }
 
    fclose (archivo);
    }
  );
 
}
 
InstanceNode *
InsertInstance (InstanceNode * list, char *nameinstance, char *namemodulo)
{
  InstanceNode *il;
  il = (InstanceNode *) malloc (sizeof (InstanceNode));
  strcpy (il->nameinstance, nameinstance);
  strcpy (il->namemodulo, namemodulo);
  il->bindslist = NULL;
  SGLIB_LIST_ADD (InstanceNode, list, il, next);
  return (list);
}
 
BindNode *
InsertBind (BindNode * list, char *nameport, char *namebind)
{
  BindNode *bl;
  bl = (BindNode *) malloc (sizeof (BindNode));
  strcpy (bl->nameport, nameport);
  strcpy (bl->namebind, namebind);
  SGLIB_LIST_ADD (BindNode, list, bl, next);
  return (list);
 
}
 
 
void
ShowInstancedModules (InstanceNode * list)
{
  InstanceNode *ill;
  SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, list, ill, next,
  {
        printf ("%s %s (", ill->namemodulo,ill->nameinstance);
        BindNode * bll;
        SGLIB_LIST_MAP_ON_ELEMENTS (BindNode,ill->bindslist, bll,next,
        {
          printf (".%s(%s)",bll->nameport,bll->namebind);
          if (bll->next == NULL)
            printf (");\n");
          else
            printf (", ");}
    );}
  );
}
 
 
EnumeratesNode *InsertEnumerates (EnumeratesNode * list, char *name)
{
 
  EnumeratesNode *el;
  el = (EnumeratesNode *) malloc (sizeof (EnumeratesNode));
  strcpy (el->name, name);
  SGLIB_LIST_ADD (EnumeratesNode, list, el, next);
  return (list);
}
 
 
int
ShowEnumeratesList (EnumeratesNode *list)
{
 
  EnumeratesNode *ell;
  int i = 0;
 
  printf ("parameter  %s = 0", list->name);
 
  if(list->next!=NULL){
    list=list->next;
    printf(",\n");
    i=1;
    SGLIB_LIST_MAP_ON_ELEMENTS (EnumeratesNode,list, ell,next,
    {
      if(ell->next==NULL)
          {
                printf("           %s = %d;\n\n",ell->name,i);
                return(i);
          }
          else
          {
            printf("           %s = %d,\n",ell->name,i);
          }
          i++;
        }
        );
  }else{
    printf(";\n\n");
        return(i);
  }
}
 
EnumListNode *
InsertEnumList (EnumListNode * list, EnumeratesNode * enumlist, char *name,int istype)
{
  EnumListNode *el;
  el = (EnumListNode *) malloc (sizeof (EnumListNode));
  strcpy (el->name, name);
  el->istype=istype;
  el->list=enumlist;
  SGLIB_LIST_ADD (EnumListNode, list, el, next);
  return (list);
}
 
void
ShowEnumListList (EnumListNode * list)
{
 
  int items;
  EnumListNode *ell;
  double bits, bits_round;
  int bits_i;
 
  SGLIB_LIST_MAP_ON_ELEMENTS(EnumListNode,list, ell,next,
  {
 
          items = ShowEnumeratesList (ell->list);
 
          //Calculate the number of bits needed to represent the enumerate
          bits = log ((double) (items + 1)) / log (2.0);
          bits_i = bits;
          bits_round = bits_i;
          if (bits_round != bits)
            bits_i++;
          if (bits_i == 0)
            bits_i = 1;
 
          if (!(ell->istype))
            {
            if ((bits_i - 1) != 0)
                  printf ("reg [%d:0] %s;\n\n", bits_i - 1, ell->name);
            else
                  printf ("reg %s;\n\n", ell->name);
            }
 
  }
  );
}
 
 
int
findEnumList (EnumListNode * list, char *name)
{
 
  int i = 0;
  EnumListNode *ell;
 
  SGLIB_LIST_MAP_ON_ELEMENTS (EnumListNode,list, ell,next,
  {
          //printf("%s %s %d %d\n", aux->name,name,aux->istype,i);
          if ((strcmp (ell->name, name) == 0) && ((ell->istype) == 1))
          {
         return i;
      }
 
          i++;
   }
   );
   return -1;
}
 
 
int
findEnumerateLength (EnumListNode * list, int offset)
{
 
  int i,j = 0;
  double bits, bits_round;
  int bits_i;
 
  EnumListNode *ell;
  EnumeratesNode *enumll;
 
  j=0;
  i=0;
 
  SGLIB_LIST_MAP_ON_ELEMENTS (EnumListNode,list, ell,next,
  {
    i++;
    if(i==offset+1){
      SGLIB_LIST_MAP_ON_ELEMENTS (EnumeratesNode,ell->list, enumll,next,
      {
            j++;
          });
        }
  });
 
   //Calculate the number of bits needed to represent the enumerate
   bits = log ((double) (j)) / log (2.0);
   bits_i = bits;
   bits_round = bits_i;
 
   if (bits_round != bits)
    bits_i++;
   if (bits_i == 0)
        bits_i = 1;
 
   return bits_i;
 
 }
 
 /* Functions for functions inputs list*/
FunctionInputNode *InsertFunctionInput (FunctionInputNode * list, char *name, int lenght, int flag){
  FunctionInputNode *fl;
  fl = (FunctionInputNode *) malloc (sizeof (FunctionInputNode));
  strcpy (fl->name, name);
  fl->lenght=lenght;
  fl->sgnflag=flag;
  SGLIB_LIST_ADD (FunctionInputNode, list, fl, next);
  return (list);
}
 
void ShowFunctionInputs (FunctionInputNode * list){
 
  FunctionInputNode *fll;
 
  SGLIB_LIST_REVERSE(FunctionInputNode,list, next);
 
  SGLIB_LIST_MAP_ON_ELEMENTS (FunctionInputNode,list, fll,next,
  {
    if(fll->sgnflag==0)
    {
    if(fll->lenght!=1)
     printf("input [%d:0] %s;\n",(fll->lenght)-1,fll->name);
    else
     printf("input %s;\n",fll->name);
     } else {
     if(fll->lenght!=1)
     printf("input signed [%d:0] %s;\n",(fll->lenght)-1,fll->name);
    else
     printf("input signed %s;\n",fll->name);
     }
  });
}
 
/* Functions for functions list*/
FunctionNode *InsertFunction (FunctionNode *list, char *name,FunctionInputNode *InputsList,int outputlenght,int flag){
  FunctionNode *fl;
  fl = (FunctionNode *) malloc (sizeof (FunctionNode));
  strcpy (fl->name, name);
  fl->outputlenght=outputlenght;
  fl->list = InputsList;
  fl->sgnflag=flag;
  SGLIB_LIST_ADD (FunctionNode, list, fl, next);
  return (list);
}
 
void ShowFunctionCode (FunctionNode *list){
 
  FILE *archivo;
  int readok;
  char *filename;
  char auxchar;
  char begin[10];
 
  FunctionNode *fll;
 
  SGLIB_LIST_MAP_ON_ELEMENTS (FunctionNode,list, fll,next,
  {
   if(fll->sgnflag==0)
   {
        if(fll->outputlenght!=1)
     printf("function [%d:0] %s;\n\n",(fll->outputlenght)-1,fll->name);
    else
         printf("function %s;\n\n",fll->name);
        } else {
   if(fll->outputlenght!=1)
     printf("function signed [%d:0] %s;\n\n",(fll->outputlenght)-1,fll->name);
    else
         printf("function signed %s;\n\n",fll->name);
   }
 
        ShowFunctionInputs(fll->list);
 
        //Show Registers
        filename =(char *) malloc (256 * sizeof (char));
        strcpy (filename, fll->name);
        strcat (filename, (char *) "_regs.sc2v");
        archivo = fopen (filename, (char *) "r");
        if(archivo==NULL){
                fprintf(stderr,"Error opening file %s\n",filename);
                exit(1);
        }
        printf("\n");
        while (1)
        {
          readok =fread ((void *) &auxchar, sizeof (char), 1,archivo);
          if (readok) printf ("%c", auxchar);
          else{
                break;
          }
        }
    fclose (archivo);
 
        printf ("\n   begin\n");
    strcpy (filename, fll->name);
    strcat (filename, (char *) ".sc2v");
    archivo = fopen (filename, (char *) "r");
 
        /*Read the initial begin of the file */
    fscanf (archivo, "%s", begin);
    readok =fread ((void *) &auxchar, sizeof (char), 1,archivo);
 
        /*Trim the beggining of the file */
        while (auxchar == '\n' || auxchar == ' ' || auxchar == '\t')
            readok =fread ((void *) &auxchar, sizeof (char), 1,archivo); printf ("\n   %c", auxchar);
 
        while (1){
          readok = fread ((void *) &auxchar, sizeof (char), 1,archivo);
          if (readok)
             printf ("%c", auxchar);
          else
         break;
        }
    printf("endfunction\n\n");
 
    fclose (archivo);
 
  });
 
}

Line No.	Rev	Author	Line
1	14	jcastillo	`/* -----------------------------------------------------------------------------`
2			`*`
3	16	jcastillo	`* SystemC to Verilog Translator v0.4`
4	31	jcastillo	`* Provided by Universidad Rey Juan Carlos`
5	14	jcastillo	`*`
6			`* -----------------------------------------------------------------------------`
7			`* This program is free software; you can redistribute it and/or modify`
8			`* it under the terms of the GNU General Public License as published by`
9			`* the Free Software Foundation; either version 2 of the License, or`
10			`* (at your option) any later version.`
11			`*`
12			`* This program is distributed in the hope that it will be useful,`
13			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`* GNU Library General Public License for more details.`
16			`*`
17			`* You should have received a copy of the GNU General Public License`
18			`* along with this program; if not, write to the Free Software`
19			`* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
20			`*/`
21
22			`#include <stdlib.h>`
23			`#include <stdio.h>`
24			`#include <math.h>`
25
26			`#include "sc2v_step2.h"`
27
28			`void`
29			`ShowDefines (char *filedefines)`
30			`{`
31
32			`int readok;`
33
34			`char *auxchar;`
35			`FILE *file;`
36
37			`file = fopen (filedefines, (char *) "r");`
38
39			`while (1){`
40			`readok = fread ((void *) &auxchar, sizeof (char), 1, file);`
41			`if (readok){`
42			`printf ("%c", auxchar);`
43			`}else{`
44			`break;`
45			`}`
46			`}`
47			`}`
48
49			`WriteNode *`
50			`InsertWrite (WriteNode * list, char *name)`
51			`{`
52			`WriteNode *wl;`
53
54			`wl = (WriteNode *) malloc (sizeof (WriteNode));`
55			`strcpy (wl->name, name);`
56			`SGLIB_LIST_ADD (WriteNode, list, wl, next);`
57			`return (list);`
58			`}`
59
60			`int`
61			`IsWrite (WriteNode * list, char *name)`
62			`{`
63			`WriteNode *wll;`
64			`SGLIB_LIST_MAP_ON_ELEMENTS (WriteNode, list, wll, next,`
65			`{`
66			`if ((strcmp (name, (char *) wll->name) == 0)) return (1);`
67			`}`
68			`);`
69			`return (0);`
70			`}`
71
72			`void`
73			`ShowWritesList (WriteNode * list)`
74			`{`
75			`WriteNode *wll;`
76			`SGLIB_LIST_MAP_ON_ELEMENTS (WriteNode, list, wll, next,{`
77			`printf ("%s\n", wll->name);`
78			`}`
79			`);`
80			`return;`
81			`}`
82
83
84
85			`WriteNode *`
86			`ReadWritesFile (WriteNode list,char name)`
87			`{`
88
89			`char *leido;`
90			`int ret;`
91			`FILE *file_writes;`
92			`file_writes = fopen (name, (char *) "r");`
93
94			`leido = (char ) malloc (256 sizeof (char));`
95
96			`while (1){`
97			`ret = fscanf (file_writes, "%s", leido);`
98			`if (ret == EOF)`
99			`break;`
100			`list = InsertWrite (list, leido);`
101			`}`
102			`return(list);`
103			`}`
104
105			`PortNode *`
106	35	jcastillo	`InsertPort (PortNode * list, char name, char tipo, int size, int pflag)`
107	14	jcastillo	`{`
108			`PortNode *pl;`
109			`pl = (PortNode *) malloc (sizeof (PortNode));`
110			`strcpy (pl->name, name);`
111			`strcpy (pl->tipo, tipo);`
112			`pl->size = size;`
113	35	jcastillo	`pl->pflag = pflag;`
114	14	jcastillo	`SGLIB_LIST_ADD (PortNode, list, pl, next);`
115			`return (list);`
116			`}`
117
118			`void`
119			`ShowPortList (PortNode * list)`
120			`{`
121
122			`PortNode *pll;`
123	29	jcastillo
124	14	jcastillo	`SGLIB_LIST_MAP_ON_ELEMENTS (PortNode, list, pll, next,`
125			`{`
126			`printf ("%s ", pll->tipo);`
127	35	jcastillo	`if (pll->pflag == 1) printf("signed ");`
128	14	jcastillo	`if (pll->size != 0 && pll->size != 1)`
129			`{`
130			`printf ("[%d:0] ", (-1 + pll->size));}`
131	35	jcastillo	`printf ("%s;\n", pll->name);`
132	14	jcastillo	`}`
133			`);`
134			`return;`
135			`}`
136
137			`void`
138	22	jcastillo	`RegOutputs (PortNode * list, InstanceNode *instances)`
139	14	jcastillo	`{`
140
141			`PortNode *pll;`
142			`SGLIB_LIST_MAP_ON_ELEMENTS (PortNode, list, pll, next,`
143			`{`
144			`if (strcmp (pll->tipo, "output") == 0)`
145			`{`
146	22	jcastillo	`if(!IsWire(pll->name,instances)){`
147	35	jcastillo	`if (pll->pflag == 1) printf("reg signed "); else printf ("reg ");`
148	14	jcastillo	`if (pll->size != 0 && pll->size != 1)`
149			`{`
150			`printf ("[%d:0] ", (-1 + pll->size));}`
151			`printf ("%s;\n", pll->name);}`
152			`}`
153	22	jcastillo	`}`
154	14	jcastillo	`);`
155			`return;`
156			`}`
157
158			`void`
159	29	jcastillo	`EnumeratePorts (PortNode *list)`
160	14	jcastillo	`{`
161			`PortNode *pll;`
162	29	jcastillo
163	14	jcastillo	`SGLIB_LIST_MAP_ON_ELEMENTS (PortNode, list, pll, next,`
164			`{`
165			`if (pll->next == NULL)`
166			`{`
167			`printf ("%s", pll->name); break;`
168			`}`
169			`else`
170			`{`
171			`printf ("%s,", pll->name);}`
172			`}`
173			`);`
174			`return;`
175			`}`
176
177			`SignalNode *`
178	35	jcastillo	`InsertSignal (SignalNode * list, char *name, int size, int arraysize,int sflag)`
179	14	jcastillo	`{`
180			`SignalNode *sl;`
181
182			`sl = (SignalNode *) malloc (sizeof (SignalNode));`
183			`strcpy (sl->name, name);`
184			`sl->size = size;`
185	20	jcastillo	`sl->arraysize=arraysize;`
186	35	jcastillo	`sl->sflag=sflag;`
187	14	jcastillo	`SGLIB_LIST_ADD (SignalNode, list, sl, next);`
188			`return (list);`
189
190			`}`
191
192
193	15	jcastillo	`void`
194			`ShowSignalsList (SignalNode * list, WriteNode * writeslist)`
195	14	jcastillo	`{`
196			`SignalNode *sll;`
197			`SGLIB_LIST_MAP_ON_ELEMENTS (SignalNode, list, sll, next,`
198			`{`
199			`if (IsWrite (writeslist, sll->name))`
200			`{`
201	35	jcastillo	`if (sll->sflag==1) printf("reg signed "); else printf ("reg ");`
202	14	jcastillo	`if (sll->size != 0 && sll->size != 1)`
203			`{`
204			`printf ("[%d:0] ", (-1 + sll->size));`
205			`}`
206	20	jcastillo	`printf ("%s", sll->name);`
207	14	jcastillo	`}`
208			`else`
209			`{`
210	35	jcastillo	`if (sll->sflag==1) printf("wire signed "); else printf ("wire ");`
211	14	jcastillo	`if (sll->size != 0 && sll->size != 1)`
212			`{`
213			`printf ("[%d:0] ", (-1 + sll->size));`
214			`}`
215	20	jcastillo	`printf ("%s", sll->name);`
216	14	jcastillo	`}`
217	20	jcastillo	`if(sll->arraysize !=0)`
218	24	jcastillo	`printf("[%d:0]", (-1 + sll->arraysize));`
219	20	jcastillo	`printf(";\n");`
220	14	jcastillo	`}`
221			`);`
222			`return;`
223			`}`
224
225
226			`/* Decides if a signal is a wire or a reg*/`
227			`int`
228			`IsWire (char name, InstanceNode list)`
229			`{`
230
231			`InstanceNode *ill;`
232			`SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, list, ill, next,`
233			`{`
234			`BindNode * bll;`
235			`SGLIB_LIST_MAP_ON_ELEMENTS (BindNode,ill->bindslist, bll, next,`
236			`{`
237	19	jcastillo	`if ((strcmp(name,bll->namebind)==0))`
238	14	jcastillo	`{`
239			`return 1;`
240			`}`
241			`}`
242			`);}`
243			`);`
244			`return 0;`
245			`}`
246
247
248
249			`SensibilityNode *`
250			`InsertSensibility (SensibilityNode * list, char name, char tipo)`
251			`{`
252			`SensibilityNode *sl;`
253			`sl = (SensibilityNode *) malloc (sizeof (SensibilityNode));`
254			`strcpy (sl->name, name);`
255			`strcpy (sl->tipo, tipo);`
256			`SGLIB_LIST_ADD (SensibilityNode, list, sl, next);`
257			`return (list);`
258			`}`
259
260			`void`
261			`ShowSensibilityList (SensibilityNode * list)`
262			`{`
263			`SensibilityNode *sll;`
264			`SGLIB_LIST_MAP_ON_ELEMENTS (SensibilityNode, list, sll, next,`
265			`{`
266			`if (!strcmp (sll->tipo, "posedge")\|\| !strcmp (sll->tipo,"negedge"))`
267			`printf (" %s",sll->tipo);`
268			`if (sll->next == NULL)`
269			`{`
270			`printf (" %s", sll->name); break;`
271			`}`
272			`else`
273			`{`
274			`printf (" %s or", sll->name);}`
275			`}`
276			`);`
277			`return;`
278			`}`
279
280
281			`ProcessNode *`
282			`InsertProcess (ProcessNode * list, char *name,`
283			`SensibilityNode * SensibilityList, char *tipo)`
284			`{`
285			`ProcessNode *pl;`
286			`pl = (ProcessNode *) malloc (sizeof (ProcessNode));`
287			`strcpy (pl->name, name);`
288			`strcpy (pl->tipo, tipo);`
289			`pl->list = SensibilityList;`
290			`SGLIB_LIST_ADD (ProcessNode, list, pl, next);`
291			`return (list);`
292			`}`
293
294
295			`void`
296			`ShowProcessList (ProcessNode * list)`
297			`{`
298			`ProcessNode *pll;`
299			`SGLIB_LIST_MAP_ON_ELEMENTS (ProcessNode, list, pll, next,`
300			`{`
301			`printf ("%s: always @(", pll->name);`
302			`ShowSensibilityList (pll->list); printf (")\n");`
303			`}`
304			`);`
305			`return;`
306			`}`
307
308
309			`void`
310			`ShowProcessCode (ProcessNode * list)`
311			`{`
312			`FILE *archivo;`
313			`int readok;`
314			`char lookahead;`
315			`char *filename;`
316			`char auxchar;`
317			`char begin[10];`
318
319			`ProcessNode *pll;`
320			`SGLIB_LIST_MAP_ON_ELEMENTS (ProcessNode, list, pll, next,`
321			`{`
322			`fprintf(stderr,"Writing process code => %s\n",pll->name);`
323			`printf ("//%s:\n", pll->name);`
324			`filename =(char ) malloc (256 sizeof (char));`
325			`strcpy (filename, pll->name);`
326			`strcat (filename, (char *) "_regs.sc2v");`
327			`archivo = fopen (filename, (char *) "r");`
328			`while (1)`
329			`{`
330			`readok =fread ((void *) &auxchar, sizeof (char), 1,archivo);`
331			`if (readok) printf ("%c", auxchar);`
332			`else`
333			`break;`
334			`}`
335			`fclose (archivo);`
336			`printf ("always @(");`
337
338			`ShowSensibilityList (pll->list);`
339			`printf (" )\n");`
340			`printf (" begin\n");`
341			`strcpy (filename, pll->name);`
342			`strcat (filename, (char *) ".sc2v");`
343			`archivo = fopen (filename, (char *) "r");`
344
345			`/Read the initial begin of the file /`
346			`fscanf (archivo, "%s", begin);`
347			`readok =fread ((void *) &auxchar, sizeof (char), 1,archivo);`
348
349			`/Trim the beggining of the file /`
350			`while (auxchar == '\n' \|\| auxchar == ' ' \|\| auxchar == '\t')`
351			`readok =fread ((void *) &auxchar, sizeof (char), 1,archivo); printf ("\n %c", auxchar);`
352
353			`while (1){`
354			`readok = fread ((void *) &auxchar, sizeof (char), 1,archivo);`
355			`if (readok){`
356			`if (strcmp (pll->tipo, "comb") == 0 && auxchar == '<')`
357			`{`
358			`readok = fread ((void *) &lookahead, sizeof (char), 1, archivo);`
359			`if (readok){`
360			`if (lookahead == '='){`
361			`auxchar = lookahead;`
362			`}else{`
363			`printf ("%c", auxchar);`
364	19	jcastillo	`auxchar = lookahead;`
365	14	jcastillo	`}`
366			`}`
367			`}`
368			`printf ("%c", auxchar);`
369			`}`
370			`else`
371			`{`
372			`break;`
373			`}`
374			`}`
375
376			`fclose (archivo);`
377			`}`
378			`);`
379
380			`}`
381
382			`InstanceNode *`
383			`InsertInstance (InstanceNode * list, char nameinstance, char namemodulo)`
384			`{`
385			`InstanceNode *il;`
386			`il = (InstanceNode *) malloc (sizeof (InstanceNode));`
387			`strcpy (il->nameinstance, nameinstance);`
388			`strcpy (il->namemodulo, namemodulo);`
389			`il->bindslist = NULL;`
390			`SGLIB_LIST_ADD (InstanceNode, list, il, next);`
391			`return (list);`
392			`}`
393
394			`BindNode *`
395			`InsertBind (BindNode * list, char nameport, char namebind)`
396			`{`
397			`BindNode *bl;`
398			`bl = (BindNode *) malloc (sizeof (BindNode));`
399			`strcpy (bl->nameport, nameport);`
400			`strcpy (bl->namebind, namebind);`
401			`SGLIB_LIST_ADD (BindNode, list, bl, next);`
402			`return (list);`
403
404			`}`
405
406
407			`void`
408			`ShowInstancedModules (InstanceNode * list)`
409			`{`
410			`InstanceNode *ill;`
411			`SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, list, ill, next,`
412			`{`
413			`printf ("%s %s (", ill->namemodulo,ill->nameinstance);`
414			`BindNode * bll;`
415			`SGLIB_LIST_MAP_ON_ELEMENTS (BindNode,ill->bindslist, bll,next,`
416			`{`
417			`printf (".%s(%s)",bll->nameport,bll->namebind);`
418			`if (bll->next == NULL)`
419			`printf (");\n");`
420			`else`
421			`printf (", ");}`
422			`);}`
423			`);`
424			`}`
425
426
427			`EnumeratesNode InsertEnumerates (EnumeratesNode list, char *name)`
428			`{`
429
430			`EnumeratesNode *el;`
431			`el = (EnumeratesNode *) malloc (sizeof (EnumeratesNode));`
432			`strcpy (el->name, name);`
433			`SGLIB_LIST_ADD (EnumeratesNode, list, el, next);`
434			`return (list);`
435			`}`
436
437
438			`int`
439			`ShowEnumeratesList (EnumeratesNode *list)`
440			`{`
441
442			`EnumeratesNode *ell;`
443			`int i = 0;`
444
445			`printf ("parameter %s = 0", list->name);`
446	22	jcastillo
447			`if(list->next!=NULL){`
448	14	jcastillo	`list=list->next;`
449	22	jcastillo	`printf(",\n");`
450			`i=1;`
451	14	jcastillo	`SGLIB_LIST_MAP_ON_ELEMENTS (EnumeratesNode,list, ell,next,`
452			`{`
453	19	jcastillo	`if(ell->next==NULL)`
454			`{`
455			`printf(" %s = %d;\n\n",ell->name,i);`
456			`return(i);`
457			`}`
458			`else`
459			`{`
460			`printf(" %s = %d,\n",ell->name,i);`
461			`}`
462			`i++;`
463	14	jcastillo	`}`
464			`);`
465			`}else{`
466	19	jcastillo	`printf(";\n\n");`
467	14	jcastillo	`return(i);`
468			`}`
469			`}`
470
471			`EnumListNode *`
472			`InsertEnumList (EnumListNode * list, EnumeratesNode * enumlist, char *name,int istype)`
473			`{`
474			`EnumListNode *el;`
475			`el = (EnumListNode *) malloc (sizeof (EnumListNode));`
476			`strcpy (el->name, name);`
477			`el->istype=istype;`
478			`el->list=enumlist;`
479			`SGLIB_LIST_ADD (EnumListNode, list, el, next);`
480			`return (list);`
481			`}`
482
483			`void`
484			`ShowEnumListList (EnumListNode * list)`
485			`{`
486
487			`int items;`
488			`EnumListNode *ell;`
489			`double bits, bits_round;`
490			`int bits_i;`
491
492			`SGLIB_LIST_MAP_ON_ELEMENTS(EnumListNode,list, ell,next,`
493			`{`
494
495			`items = ShowEnumeratesList (ell->list);`
496
497			`//Calculate the number of bits needed to represent the enumerate`
498			`bits = log ((double) (items + 1)) / log (2.0);`
499			`bits_i = bits;`
500			`bits_round = bits_i;`

Browse

Tools

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step2.c] - Blame information for rev 39