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

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step1.y] - Blame information for rev 6

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


/* -----------------------------------------------------------------------------
 *
 *  SystemC to Verilog Translator v0.2
 *  Provided by OpenSoc Design
 *
 *  www.opensocdesign.com
 *
 * -----------------------------------------------------------------------------
 *  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 
#include 
 
#include "list.h"
 
/* Global var to store Regs */
RegsList *regslist;
/* Global var to store Defines */
DefinesList *defineslist;
 
 
int processfound = 0;
int switchfound = 0;
int switchparenthesis = 0;
char *processname, *processname2;
char *fileregs;
char *filename ;
int openedkeys = 0;
int newline = 0;
int reg_found = 0;
int regs_end;
int i = 0; //for loops counter
FILE *file;
FILE *regs_file;
char *regname, *regname2;
char *lastword; // Stores last WORD for use it in WRITE
char *file_defines;
FILE *FILE_DEFINES;
char *file_writes;
FILE *FILE_WRITES; //FILE to store .write to know if it is a wire or reg
int definefound = 0;
int defineinvocationfound = 0;
int opencorchfound = 0;
 
int openedcase = 0;
 
int default_break_found = 0;
int default_found;
 
//Directives variables
int translate;
int verilog;
int writemethod;
 
void yyerror(const char *str)
{
        fprintf(stderr,"error: %s\n",str);
}
 
int yywrap()
{
        return 1;
}
 
main()
{
        regslist = (RegsList *)malloc(sizeof(RegsList));
        InitializeRegsList(regslist);
        defineslist = (DefinesList *)malloc(sizeof(DefinesList));
        InitializeDefinesList(defineslist);
 
        processname = (char *)malloc(256*sizeof(int));
        processname2 = (char *)malloc(256*sizeof(int));
        fileregs = (char *)malloc(256*sizeof(int));
 
        file_defines = (char *)malloc(256*sizeof(int));
        strcpy(file_defines, (char *)"file_defines.sc2v");
        FILE_DEFINES = fopen(file_defines,(char *)"w");
 
        file_writes = (char *)malloc(256*sizeof(int));
        strcpy(file_writes, (char *)"file_writes.sc2v");
        FILE_WRITES = fopen(file_writes,(char *)"w");
                        if(FILE_WRITES!=NULL)
                                printf("\nopening file => filename = %s\n",file_writes);
 
    translate=1;
        verilog=0;
        writemethod=0;
 
        yyparse();
        fclose(FILE_WRITES);
        fclose(FILE_DEFINES);
}
 
%}
 
%token NUMBER WORD SC_INT SC_UINT BOOL BIGGER LOWER OPENKEY CLOSEKEY WRITE WORD SYMBOL NEWLINE ENUM INCLUDE
%token COLON SEMICOLON RANGE OPENPAR CLOSEPAR TWODOUBLEPOINTS OPENCORCH CLOSECORCH SWITCH CASE DEFAULT BREAK
%token SC_BIGINT SC_BIGUINT HEXA DEFINE READ TRANSLATEOFF TRANSLATEON VERILOGBEGIN VERILOGEND TAB DOLLAR INTCONV
%token VOID TTRUE TFALSE
%token PIFDEF PENDDEF PELSE
 
%%
 
commands: /* empty */
        | commands command
        ;
 
 
command:
    voidword
        |
    include
        |
    dollar
        |
        intconv
        |
        tab
        |
        read
        |
        sc_int
        |
        sc_uint
        |
        sc_bigint
        |
        sc_biguint
        |
        number
        |
        bool
        |
        word
        |
        symbol
        |
        write
        |
        newline
        |
        openkey
        |
        closekey
        |
        colon
        |
        semicolon
        |
        range
        |
        openpar
        |
        closepar
        |
        void
        |
        opencorch
        |
        closecorch
        |
        bigger
        |
        lower
        |
        switch
        |
        case_only
        |
    case_number
        |
        case_word
        |
        case_default
        |
        break
        |
        hexa
        |
        define
        |
        translateoff
        |
        translateon
        |
        verilogbegin
        |
        verilogend
        |
        ifdef
        |
        endif
        |
        pelse
        |
        ttrue
        |
        tfalse
        ;
 
 
 
voidword:
    VOID
        {
        if(verilog==1)
          fprintf(file," void");
        };
 
 
include:
    INCLUDE
        {
        if(verilog==1)
          fprintf(file," #include");
        };
 
 
dollar:
    DOLLAR
        {
        if(verilog==1)
          fprintf(file," $");
        };
 
intconv:
    INTCONV
        {
        if(verilog==1)
          fprintf(file," (int)");
        };
 
tab:
    TAB
        {
        if(verilog==1)
          fprintf(file," \t");
        };
 
read:
        READ OPENPAR CLOSEPAR
                {
                if(verilog==1)
                  fprintf(file,".read()");
 
                }
 
define:
        DEFINE WORD OPENPAR CLOSEPAR
                {
                  if(translate==1 && verilog==0){
                        InsertDefine(defineslist, (char *)$2);
                        definefound = 1;
                        fprintf(FILE_DEFINES,"`define %s ",(char *)$2);
                  }else if(verilog==1)
                    fprintf(file,"#define %s ()",(char *)$2);
                }
void:
        WORD TWODOUBLEPOINTS WORD OPENPAR CLOSEPAR
                {
                if(translate==1&& verilog==0){
                        strcpy(processname ,(char *)$4);
                        strcpy(processname2 ,(char *)$4);
                        strcat(processname2, (char *)".sc2v");
                        strcpy(fileregs ,(char *)$4);
                        strcat(fileregs, (char *)"_regs.sc2v");
                        /*
                        strcpy(file_writes, (char *)$4);
                        strcat(file_writes, (char *)"_writes.sc2v");
                        */
                }else if(verilog==1)
                  fprintf(file," %s::%s()",(char *)$1,(char *)$3);
 
                }
sc_int:
        SC_INT LOWER NUMBER BIGGER
                {
        if(translate==1&& verilog==0){
                        if(processfound)
                        {
                                fprintf(regs_file,"reg[%d:0] ",(-1 + $3));
                                reg_found = 1;
                        }
                }else if(verilog==1)
                  fprintf(file,"sc_int<%d>",$3);
 
                }
                ;
 
sc_uint:
        SC_UINT LOWER NUMBER BIGGER
                {
                if(translate==1&& verilog==0){
                        if(processfound)
                        {
                                fprintf(regs_file,"reg[%d:0] ",(-1 + $3));
                                reg_found = 1;
                        }
                }else if(verilog==1)
                  fprintf(file,"sc_uint<%d>",$3);
                }
                ;
 
sc_bigint:
        SC_BIGINT LOWER NUMBER BIGGER
                {
                if(translate==1&& verilog==0){
                        if(processfound)
                        {
                                fprintf(regs_file,"reg[%d:0] ",(-1 + $3));
                                reg_found = 1;
                        }
                }else if(verilog==1)
                 fprintf(file,"sc_bigint<%d> ",$3);
                }
                ;
 
sc_biguint:
        SC_BIGUINT LOWER NUMBER BIGGER
                {
                if(translate==1&& verilog==0){
                        if(processfound)
                        {
                                fprintf(regs_file,"reg[%d:0] ",(-1 + $3));
                                reg_found = 1;
                        }
                }else if(verilog==1)
                  fprintf(file,"sc_biguint<%d> ",$3);
                }
                ;
 
bool:
                BOOL
                        {
                    if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(regs_file,"reg ");
                                        reg_found = 1;
                                }
                        }else if(verilog==1)
                       fprintf(file,"bool");
                        }
                        ;
 
range:
                RANGE OPENPAR NUMBER COLON NUMBER CLOSEPAR
                        {
                    if(translate==1&& verilog==0){
                                if(processfound)
                                        fprintf(file,"[%d:%d]",$3,$5);
                                else if(definefound)
                                        fprintf(FILE_DEFINES,"[%d:%d]",$3,$5);
                        }else if(verilog==1)
                      fprintf(file,".range(%d,%d)",$3,$5);
                        }
                        ;
 
number:
                NUMBER
                        {
                        if(translate==1&& verilog==0){
                                if(processfound)
                                        if(reg_found)
                                        {
                                            if(opencorchfound)
                                                fprintf(regs_file,"%d:0", -1 + $1);
                                            else
                                                fprintf(regs_file,"%d",$1);
                                        }
                                        else
                                                fprintf(file,"%d",$1);
                                else if(definefound)
                                        fprintf(FILE_DEFINES,"%d",$1);
                        }else if(verilog==1)
                       fprintf(file,"%d",$1);
                        }
                        ;
word:
                WORD
                        {
                    if(translate==1&& verilog==0){
                          if(processfound)
                          {
                             if(openedcase)
                             {
                                fprintf(file," :\n");
 
                                    for(i = 0; i < openedkeys; i++)
                                            fprintf(file,"   ");
 
                                    fprintf(file,"begin\n");
                                    openedcase = 0;
                             }
 
                                 lastword=malloc(sizeof(char)*strlen((char *)$1));
                             strcpy(lastword, (char *)$1);
 
                             if(reg_found)
                             {
                              strcpy(regname ,(char *)$1);
                              strcpy(regname2 ,(char *)$1);
                              strcat(regname2, processname);
                              fprintf(regs_file,"%s",regname2);
                              InsertReg(regslist, regname, regname2);
                             }
                             else
                             {
                               if(newline)
                                   {
                                   for(i = 0; i < openedkeys; i++)
                                         fprintf(file,"   ");
                                   }
                                   regname2 = IsReg(regslist, (char *)$1);
                                   if(regname2 == NULL)
                                   {
                                         if(IsDefine(defineslist, (char *)$1))
                                         {
                                           fprintf(file,"`%s", (char *)$1);
                                           defineinvocationfound = 1;
                                         }
                                         else
                                         {
                                           fprintf(file,"%s ",(char *)$1);
                                         }
                                   }
                                   else
                                         fprintf(file,"%s",regname2);
 
                                   newline = 0;
                             }
                          }
                          else if(definefound)
                          {
                                if(IsDefine(defineslist, (char *)$1))
                                {
                                        fprintf(FILE_DEFINES,"`%s",(char *)$1);
                                }
                                else
                                {
                                        fprintf(FILE_DEFINES,"%s ",(char *)$1);
                                }
                          }
                        }else if(verilog==1)
                       fprintf(file," %s",(char *)$1);
                    };
 
symbol:
                SYMBOL
                        {
                        if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                   if(reg_found)
                                        fprintf(regs_file,"%s",(char *)$1);
                                   else
                                        fprintf(file,"%s",(char *)$1);
                                }
                                else if(definefound)
                                {
                                   fprintf(FILE_DEFINES,"%s",(char *)$1);
                                }
                        }else if(verilog==1)
                       fprintf(file,"%s",(char *)$1);
                        };
 
 
write:
                WRITE
                        {
                        if(translate==1&& verilog==0){
                writemethod=1;
                                if(processfound)
                                {
                                        fprintf(file," = ");
                                        fprintf(FILE_WRITES, "%s\n", lastword);
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES," = ");
                                }
                                free(lastword);
 
                        }else if(verilog==1){
                            fprintf(file,".write");
                         }
                        };
 
newline:
                NEWLINE
                        {
                    if(translate==1&& verilog==0){
                                if(processfound & !reg_found & !openedcase)
                                {
                                        fprintf(file,"\n");
                                        newline = 1;
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"\n");
                                }
 
                        }else if(verilog==1)
                       fprintf(file,"\n");
                        };
 
colon:
                COLON
                        {
                        if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                  if(reg_found)
                                  {
                                        fprintf(regs_file,",");
                                  }
                                  else
                                        fprintf(file,",");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,",");
                                }
                        }else if(verilog==1)
                       fprintf(file,",");
                        };
 
semicolon:
                SEMICOLON
                        {
                    if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                  if(reg_found)
                                  {
                                        fprintf(regs_file,";\n");
                                        reg_found = 0;
                                  }
                                  else if(defineinvocationfound)
                                  {
                                        defineinvocationfound = 0;
                                  }
                                  else
                                  {
                                        fprintf(file,";");
                                  }
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,";");
                                }
                        }else if(verilog==1)
                       fprintf(file,";");
                        };
 
openpar:
                OPENPAR
                        {
            if(translate==1 && verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"(");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"(");
                                }
                        }else if(verilog==1)
                       fprintf(file,"(");
                        };
 
closepar:
                CLOSEPAR
                        {
                    if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,")");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,")");
                                }
                        }else if(verilog==1)
                       fprintf(file,")");
                        };
 
opencorch:
                OPENCORCH
                        {
                        if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                  if(reg_found)
                                  {
                                        fprintf(regs_file,"[");
                                        opencorchfound = 1;
                                  }
                                  else
                                        fprintf(file,"[");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"[");
 
                                }
                        }else if(verilog==1)
                       fprintf(file,"[");
                        };
 
closecorch:
                CLOSECORCH
                        {
                    if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                  if(reg_found)
                                  {
                                        fprintf(regs_file,"]");
                                        opencorchfound = 0;
                                  }
                                  else
                                        fprintf(file,"]");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"]");
                                }
                        }else if(verilog==1)
                       fprintf(file,"]");
                        };
 
 
openkey:
                OPENKEY
                        {
                    if(translate==1 && verilog==0){
                                openedkeys++;
                                if(openedkeys==1 & !definefound)
                                {
                                        printf("opening file => filename = %s\n",processname2);
                                        file = fopen(processname2,(char *)"w");
                                        printf("opening file => filename = %s\n",fileregs);
                                        regs_file = fopen(fileregs,(char *)"w");
                                        processfound = 1;
                                        regslist = (RegsList *)malloc(sizeof(RegsList));
                                        InitializeRegsList(regslist);
                                        regname = (char *)malloc(256*sizeof(int));
                                        regname2 = (char *)malloc(256*sizeof(int));
                                }
                                if(processfound)
                                        if(openedkeys != switchparenthesis)
                                        {
                                            fprintf(file,"\n");
                                                for(i = 0; i < openedkeys; i++)
                                                        fprintf(file,"   ");
                                                fprintf(file,"begin\n");
                                                newline = 1;
                                        }
 
                        }else if(verilog==1)
                       fprintf(file,"{");
                        }
                        ;
 
closekey:
                CLOSEKEY
                        {
            if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        if(openedkeys==switchparenthesis & switchfound == 1)
                                        {
                                                fprintf(file,"\n");
                                                if(default_found & !default_break_found)
                                                {
                                                for(i = 0; i < openedkeys; i++)
                                                        fprintf(file,"   ");
                                                fprintf(file,"end\n");
                                                default_found = 0;
                                                }
                                                for(i = 0; i < openedkeys; i++)
                                                        fprintf(file,"   ");
                                                fprintf(file,"endcase\n");
                                                newline = 1;
                                                switchfound = 0;
                                                switchparenthesis = 0;
                                        }
                                        else
                                        {
                                                fprintf(file,"\n");
                                                for(i = 0; i < openedkeys; i++)
                                                        fprintf(file,"   ");
                                                fprintf(file,"end\n");
                                                newline = 1;
                                        }
                                }
 
                                openedkeys--;
                                if(definefound)
                                {
                                        definefound = 0;
                                        fprintf(FILE_DEFINES,"\n//Dummy Comment\n");
                                }
                                else if(openedkeys==0)
                                {
                                        fclose(file);
                                        fclose(regs_file);
                                        free(regslist);
                                        free(regname);
                                        free(regname2);
                                        processfound = 0;
                                }
                        }else if(verilog==1)
                       fprintf(file,"}");
                        };
 
 
bigger:
                BIGGER
                        {
            if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,">");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,">");
                                }
                        }else if(verilog==1)
                       fprintf(file,">");
                        };
 
lower:
                LOWER
                        {
                        if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"<");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"<");
                                }
                        }else if(verilog==1)
                       fprintf(file,"<");
                        };
 
 
switch:
                SWITCH
                        {
                        if(translate==1&& verilog==0){
                          if(processfound)
                                {
                                        fprintf(file,"\n");
                                        for(i = 0; i < openedkeys; i++)
                                                fprintf(file,"   ");
                                        fprintf(file,"case");
                                        switchfound = 1;
                                        switchparenthesis = openedkeys + 1;
                                }
                        }else if(verilog==1)
                       fprintf(file,"switch");
                        };
 
case_number:
                CASE NUMBER SYMBOL
                        {
                        if(translate==1&& verilog==0){
                          if(processfound)
                          {
                                for(i = 0; i < openedkeys; i++)
                                        fprintf(file,"   ");
                                if(openedcase)
                                        fprintf(file,", %d",$2);
                                else
                                        fprintf(file,"%d",$2);
 
                                newline = 1;
                                openedcase = 1;
 
                          }
                        }else if(verilog==1)
                       fprintf(file,"case %d %s",$2,(char *)$3);
                        };
case_word:
                CASE WORD SYMBOL
                        {
                        if(translate==1&& verilog==0){
                          if(processfound)
                          {
                                for(i = 0; i < openedkeys; i++)
                                        fprintf(file,"   ");
                                if(openedcase)
                                        fprintf(file,", %s",(char *)$2);
                                else
                                        fprintf(file,"%s",(char *)$2);
 
                                newline = 1;
                                openedcase = 1;
 
                          }
                        }else if(verilog==1)
                       fprintf(file,"case %s %s",(char *)$2,(char *)$3);
                        };
 
case_default:
                DEFAULT SYMBOL
                        {
                        if(translate==1&& verilog==0){
                          if(processfound)
                          {
                                for(i = 0; i < openedkeys; i++)
                                        fprintf(file,"   ");
                                fprintf(file,"default:\n");
                                for(i = 0; i < openedkeys; i++)
                                        fprintf(file,"   ");
                                fprintf(file,"begin\n");
                                newline = 1;
                                default_found = 1;
                          }
                        }else if(verilog==1)
                       fprintf(file,"default %s",(char *)$2);
                        };
 
case_only:
        CASE OPENPAR
                {
                //This rule occurs when in Verilog mode a case appears
                if(verilog==1)
                  fprintf(file,"case(");
        };
 
break:
                BREAK SEMICOLON
                        {
                        if(translate==1&& verilog==0){
                         if(processfound)
                         {
                                if(newline == 0)
                                        fprintf(file,"\n");
                                for(i = 0; i < openedkeys; i++)
                                        fprintf(file,"   ");
                                fprintf(file,"end\n");
                                if(default_found)
                                        {
                                                default_break_found = 1;
                                        }
                         }
                        }else if(verilog==1)
                       fprintf(file,"break;");
                        };
 
hexa:
                HEXA
                        {
                    if(translate==1&& verilog==0){
                        if(processfound)
                        {
                                fprintf(file,"'h");
                        }
                        else if(definefound)
                        {
                                fprintf(FILE_DEFINES,"'h");
                        }
                        }else if(verilog==1)
                       fprintf(file,"0x");
                        };
 
translateoff:
        TRANSLATEOFF
                {
                  translate=0;
                  fprintf(stderr,"Found Translate off directive \n");
        };
 
translateon:
        TRANSLATEON
                {
                  translate=1;
                  fprintf(stderr,"Found Translate on directive \n");
        };
 
verilogbegin:
        VERILOGBEGIN
                {
                  verilog=1;
                  fprintf(stderr,"Found Verilog Begin directive \n");
        };
 
verilogend:
        VERILOGEND
                {
                  verilog=0;
                  fprintf(stderr,"Found Verilog End directive \n");
        };
 
ifdef:
       PIFDEF
           {
            if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"`ifdef");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"`ifdef");
                                }
                        }else if(verilog==1)
                       fprintf(file,"#ifdef");
                        };
endif:
       PENDDEF
           {
            if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"`endif");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"`endif");
                                }
                        }else if(verilog==1)
                       fprintf(file,"#endif");
                        };
pelse:
       PELSE
           {
            if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"`else");
                                }
                                else if(definefound)
                                {
                                        fprintf(FILE_DEFINES,"`else");
                                }
                        }else if(verilog==1)
                       fprintf(file,"#else");
                        };
ttrue:
      TTRUE
          {
                if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"1");
                                }
                        }else if(verilog==1)
                       fprintf(file,"1");
                        };
 
 
tfalse:
      TFALSE
          {
                if(translate==1&& verilog==0){
                                if(processfound)
                                {
                                        fprintf(file,"0");
                                }
                        }else if(verilog==1)
                       fprintf(file,"0");
                        };

Line No.	Rev	Author	Line
1	2	jcastillo	`/* -----------------------------------------------------------------------------`
2			`*`
3	4	jcastillo	`* SystemC to Verilog Translator v0.2`
4	2	jcastillo	`* Provided by OpenSoc Design`
5			`*`
6			`* www.opensocdesign.com`
7			`*`
8			`* -----------------------------------------------------------------------------`
9			`* This program is free software; you can redistribute it and/or modify`
10			`* it under the terms of the GNU General Public License as published by`
11			`* the Free Software Foundation; either version 2 of the License, or`
12			`* (at your option) any later version.`
13			`*`
14			`* This program is distributed in the hope that it will be useful,`
15			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`* GNU Library General Public License for more details.`
18			`*`
19			`* You should have received a copy of the GNU General Public License`
20			`* along with this program; if not, write to the Free Software`
21			`* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
22			`*/`
23
24
25			`%{`
26			`#include`
27			`#include`
28
29			`#include "list.h"`
30
31			`/* Global var to store Regs */`
32			`RegsList *regslist;`
33			`/* Global var to store Defines */`
34			`DefinesList *defineslist;`
35
36
37			`int processfound = 0;`
38			`int switchfound = 0;`
39			`int switchparenthesis = 0;`
40			`char processname, processname2;`
41			`char *fileregs;`
42			`char *filename ;`
43			`int openedkeys = 0;`
44			`int newline = 0;`
45			`int reg_found = 0;`
46			`int regs_end;`
47			`int i = 0; //for loops counter`
48			`FILE *file;`
49			`FILE *regs_file;`
50			`char regname, regname2;`
51			`char *lastword; // Stores last WORD for use it in WRITE`
52			`char *file_defines;`
53			`FILE *FILE_DEFINES;`
54			`char *file_writes;`
55			`FILE *FILE_WRITES; //FILE to store .write to know if it is a wire or reg`
56			`int definefound = 0;`
57			`int defineinvocationfound = 0;`
58			`int opencorchfound = 0;`
59
60			`int openedcase = 0;`
61
62			`int default_break_found = 0;`
63			`int default_found;`
64
65	4	jcastillo	`//Directives variables`
66			`int translate;`
67			`int verilog;`
68			`int writemethod;`
69
70	2	jcastillo	`void yyerror(const char *str)`
71			`{`
72			`fprintf(stderr,"error: %s\n",str);`
73			`}`
74
75			`int yywrap()`
76			`{`
77			`return 1;`
78			`}`
79
80			`main()`
81			`{`
82			`regslist = (RegsList *)malloc(sizeof(RegsList));`
83			`InitializeRegsList(regslist);`
84			`defineslist = (DefinesList *)malloc(sizeof(DefinesList));`
85			`InitializeDefinesList(defineslist);`
86
87			`processname = (char )malloc(256sizeof(int));`
88			`processname2 = (char )malloc(256sizeof(int));`
89			`fileregs = (char )malloc(256sizeof(int));`
90
91			`file_defines = (char )malloc(256sizeof(int));`
92			`strcpy(file_defines, (char *)"file_defines.sc2v");`
93			`FILE_DEFINES = fopen(file_defines,(char *)"w");`
94
95			`file_writes = (char )malloc(256sizeof(int));`
96			`strcpy(file_writes, (char *)"file_writes.sc2v");`
97			`FILE_WRITES = fopen(file_writes,(char *)"w");`
98			`if(FILE_WRITES!=NULL)`
99			`printf("\nopening file => filename = %s\n",file_writes);`
100
101	4	jcastillo	`translate=1;`
102			`verilog=0;`
103			`writemethod=0;`
104
105	2	jcastillo	`yyparse();`
106			`fclose(FILE_WRITES);`
107			`fclose(FILE_DEFINES);`
108			`}`
109
110			`%}`
111
112	4	jcastillo	`%token NUMBER WORD SC_INT SC_UINT BOOL BIGGER LOWER OPENKEY CLOSEKEY WRITE WORD SYMBOL NEWLINE ENUM INCLUDE`
113			`%token COLON SEMICOLON RANGE OPENPAR CLOSEPAR TWODOUBLEPOINTS OPENCORCH CLOSECORCH SWITCH CASE DEFAULT BREAK`
114			`%token SC_BIGINT SC_BIGUINT HEXA DEFINE READ TRANSLATEOFF TRANSLATEON VERILOGBEGIN VERILOGEND TAB DOLLAR INTCONV`
115	6	jcastillo	`%token VOID TTRUE TFALSE`
116	4	jcastillo	`%token PIFDEF PENDDEF PELSE`
117	2	jcastillo
118			`%%`
119
120			`commands: /* empty */`
121			`\| commands command`
122			`;`
123
124
125			`command:`
126	4	jcastillo	`voidword`
127			`\|`
128			`include`
129			`\|`
130			`dollar`
131			`\|`
132			`intconv`
133			`\|`
134			`tab`
135			`\|`
136	2	jcastillo	`read`
137			`\|`
138			`sc_int`
139			`\|`
140			`sc_uint`
141			`\|`
142			`sc_bigint`
143			`\|`
144			`sc_biguint`
145			`\|`
146			`number`
147			`\|`
148			`bool`
149			`\|`
150			`word`
151			`\|`
152			`symbol`
153			`\|`
154			`write`
155			`\|`
156			`newline`
157			`\|`
158			`openkey`
159			`\|`
160			`closekey`
161			`\|`
162			`colon`
163			`\|`
164			`semicolon`
165			`\|`
166			`range`
167			`\|`
168			`openpar`
169			`\|`
170			`closepar`
171			`\|`
172			`void`
173			`\|`
174			`opencorch`
175			`\|`
176			`closecorch`
177			`\|`
178	4	jcastillo	`bigger`
179	2	jcastillo	`\|`
180	4	jcastillo	`lower`
181	2	jcastillo	`\|`
182			`switch`
183			`\|`
184	4	jcastillo	`case_only`
185	2	jcastillo	`\|`
186	4	jcastillo	`case_number`
187			`\|`
188			`case_word`
189			`\|`
190	2	jcastillo	`case_default`
191			`\|`
192			`break`
193			`\|`
194			`hexa`
195			`\|`
196			`define`
197	4	jcastillo	`\|`
198			`translateoff`
199			`\|`
200			`translateon`
201			`\|`
202			`verilogbegin`
203			`\|`
204			`verilogend`
205			`\|`
206			`ifdef`
207			`\|`
208			`endif`
209			`\|`
210	6	jcastillo	`pelse`
211			`\|`
212			`ttrue`
213			`\|`
214			`tfalse`
215	2	jcastillo	`;`
216
217	4	jcastillo
218
219			`voidword:`
220			`VOID`
221			`{`
222			`if(verilog==1)`
223			`fprintf(file," void");`
224			`};`
225
226
227			`include:`
228			`INCLUDE`
229			`{`
230			`if(verilog==1)`
231			`fprintf(file," #include");`
232			`};`
233
234
235			`dollar:`
236			`DOLLAR`
237			`{`
238			`if(verilog==1)`
239			`fprintf(file," $");`
240			`};`
241
242			`intconv:`
243			`INTCONV`
244			`{`
245			`if(verilog==1)`
246			`fprintf(file," (int)");`
247			`};`
248
249			`tab:`
250			`TAB`
251			`{`
252			`if(verilog==1)`
253			`fprintf(file," \t");`
254			`};`
255
256	2	jcastillo	`read:`
257			`READ OPENPAR CLOSEPAR`
258			`{`
259	4	jcastillo	`if(verilog==1)`
260			`fprintf(file,".read()");`
261	2	jcastillo
262			`}`
263	4	jcastillo
264	2	jcastillo	`define:`
265			`DEFINE WORD OPENPAR CLOSEPAR`
266			`{`
267	4	jcastillo	`if(translate==1 && verilog==0){`
268	2	jcastillo	`InsertDefine(defineslist, (char *)$2);`
269			`definefound = 1;`
270			fprintf(FILE_DEFINES,"`define %s ",(char *)$2);
271	4	jcastillo	`}else if(verilog==1)`
272			`fprintf(file,"#define %s ()",(char *)$2);`
273	2	jcastillo	`}`
274			`void:`
275	4	jcastillo	`WORD TWODOUBLEPOINTS WORD OPENPAR CLOSEPAR`
276	2	jcastillo	`{`
277	4	jcastillo	`if(translate==1&& verilog==0){`
278	2	jcastillo	`strcpy(processname ,(char *)$4);`
279			`strcpy(processname2 ,(char *)$4);`
280			`strcat(processname2, (char *)".sc2v");`
281			`strcpy(fileregs ,(char *)$4);`
282			`strcat(fileregs, (char *)"_regs.sc2v");`
283			`/*`
284			`strcpy(file_writes, (char *)$4);`
285			`strcat(file_writes, (char *)"_writes.sc2v");`
286			`*/`
287	4	jcastillo	`}else if(verilog==1)`
288			`fprintf(file," %s::%s()",(char )$1,(char )$3);`
289
290	2	jcastillo	`}`
291			`sc_int:`
292	4	jcastillo	`SC_INT LOWER NUMBER BIGGER`
293			`{`
294			`if(translate==1&& verilog==0){`
295	2	jcastillo	`if(processfound)`
296			`{`
297			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
298			`reg_found = 1;`
299			`}`
300	4	jcastillo	`}else if(verilog==1)`
301			`fprintf(file,"sc_int<%d>",$3);`
302
303	2	jcastillo	`}`
304			`;`
305
306			`sc_uint:`
307	4	jcastillo	`SC_UINT LOWER NUMBER BIGGER`
308	2	jcastillo	`{`
309	4	jcastillo	`if(translate==1&& verilog==0){`
310	2	jcastillo	`if(processfound)`
311			`{`
312			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
313			`reg_found = 1;`
314			`}`
315	4	jcastillo	`}else if(verilog==1)`
316			`fprintf(file,"sc_uint<%d>",$3);`
317	2	jcastillo	`}`
318			`;`
319
320			`sc_bigint:`
321	4	jcastillo	`SC_BIGINT LOWER NUMBER BIGGER`
322	2	jcastillo	`{`
323	4	jcastillo	`if(translate==1&& verilog==0){`
324	2	jcastillo	`if(processfound)`
325			`{`
326			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
327			`reg_found = 1;`
328			`}`
329	4	jcastillo	`}else if(verilog==1)`
330			`fprintf(file,"sc_bigint<%d> ",$3);`
331	2	jcastillo	`}`
332			`;`
333
334			`sc_biguint:`
335	4	jcastillo	`SC_BIGUINT LOWER NUMBER BIGGER`
336	2	jcastillo	`{`
337	4	jcastillo	`if(translate==1&& verilog==0){`
338	2	jcastillo	`if(processfound)`
339			`{`
340			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
341			`reg_found = 1;`
342			`}`
343	4	jcastillo	`}else if(verilog==1)`
344			`fprintf(file,"sc_biguint<%d> ",$3);`
345	2	jcastillo	`}`
346			`;`
347
348			`bool:`
349			`BOOL`
350			`{`
351	4	jcastillo	`if(translate==1&& verilog==0){`
352	2	jcastillo	`if(processfound)`
353			`{`
354			`fprintf(regs_file,"reg ");`
355			`reg_found = 1;`
356			`}`
357	4	jcastillo	`}else if(verilog==1)`
358			`fprintf(file,"bool");`
359	2	jcastillo	`}`
360			`;`
361
362			`range:`
363			`RANGE OPENPAR NUMBER COLON NUMBER CLOSEPAR`
364			`{`
365	4	jcastillo	`if(translate==1&& verilog==0){`
366	2	jcastillo	`if(processfound)`
367			`fprintf(file,"[%d:%d]",$3,$5);`
368			`else if(definefound)`
369			`fprintf(FILE_DEFINES,"[%d:%d]",$3,$5);`
370	4	jcastillo	`}else if(verilog==1)`
371			`fprintf(file,".range(%d,%d)",$3,$5);`
372	2	jcastillo	`}`
373			`;`
374
375			`number:`
376			`NUMBER`
377			`{`
378	4	jcastillo	`if(translate==1&& verilog==0){`
379	2	jcastillo	`if(processfound)`
380			`if(reg_found)`
381			`{`
382			`if(opencorchfound)`
383			`fprintf(regs_file,"%d:0", -1 + $1);`
384			`else`
385			`fprintf(regs_file,"%d",$1);`
386			`}`
387			`else`
388			`fprintf(file,"%d",$1);`
389			`else if(definefound)`
390			`fprintf(FILE_DEFINES,"%d",$1);`
391	4	jcastillo	`}else if(verilog==1)`
392			`fprintf(file,"%d",$1);`
393	2	jcastillo	`}`
394			`;`
395			`word:`
396			`WORD`
397			`{`
398	4	jcastillo	`if(translate==1&& verilog==0){`
399	2	jcastillo	`if(processfound)`
400			`{`
401			`if(openedcase)`
402			`{`
403			`fprintf(file," :\n");`
404	4	jcastillo
405			`for(i = 0; i < openedkeys; i++)`
406			`fprintf(file," ");`
407
408			`fprintf(file,"begin\n");`
409			`openedcase = 0;`
410	2	jcastillo	`}`
411	4	jcastillo
412			`lastword=malloc(sizeof(char)strlen((char )$1));`
413	2	jcastillo	`strcpy(lastword, (char *)$1);`
414
415			`if(reg_found)`
416			`{`
417			`strcpy(regname ,(char *)$1);`
418			`strcpy(regname2 ,(char *)$1);`
419			`strcat(regname2, processname);`
420			`fprintf(regs_file,"%s",regname2);`
421			`InsertReg(regslist, regname, regname2);`
422			`}`
423			`else`
424			`{`
425	4	jcastillo	`if(newline)`
426			`{`
427			`for(i = 0; i < openedkeys; i++)`
428			`fprintf(file," ");`
429			`}`
430			`regname2 = IsReg(regslist, (char *)$1);`
431			`if(regname2 == NULL)`
432			`{`
433			`if(IsDefine(defineslist, (char *)$1))`
434			`{`
435			fprintf(file,"`%s", (char *)$1);
436			`defineinvocationfound = 1;`
437			`}`
438			`else`
439			`{`
440	6	jcastillo	`fprintf(file,"%s ",(char *)$1);`
441	4	jcastillo	`}`
442			`}`
443			`else`
444			`fprintf(file,"%s",regname2);`
445
446			`newline = 0;`
447	2	jcastillo	`}`
448			`}`
449			`else if(definefound)`
450			`{`
451			`if(IsDefine(defineslist, (char *)$1))`
452			`{`
453	4	jcastillo	fprintf(FILE_DEFINES,"`%s",(char *)$1);
454	2	jcastillo	`}`
455			`else`
456			`{`
457			`fprintf(FILE_DEFINES,"%s ",(char *)$1);`
458			`}`
459			`}`
460	4	jcastillo	`}else if(verilog==1)`
461			`fprintf(file," %s",(char *)$1);`
462			`};`
463	2	jcastillo
464			`symbol:`
465			`SYMBOL`
466			`{`
467	4	jcastillo	`if(translate==1&& verilog==0){`
468	2	jcastillo	`if(processfound)`
469			`{`
470			`if(reg_found)`
471			`fprintf(regs_file,"%s",(char *)$1);`
472			`else`
473			`fprintf(file,"%s",(char *)$1);`
474			`}`
475			`else if(definefound)`
476			`{`
477			`fprintf(FILE_DEFINES,"%s",(char *)$1);`
478			`}`
479	4	jcastillo	`}else if(verilog==1)`
480			`fprintf(file,"%s",(char *)$1);`
481			`};`
482	2	jcastillo
483
484			`write:`
485			`WRITE`
486			`{`
487	4	jcastillo	`if(translate==1&& verilog==0){`
488			`writemethod=1;`
489	2	jcastillo	`if(processfound)`
490			`{`
491			`fprintf(file," = ");`
492			`fprintf(FILE_WRITES, "%s\n", lastword);`
493			`}`
494			`else if(definefound)`
495			`{`
496			`fprintf(FILE_DEFINES," = ");`
497			`}`
498	4	jcastillo	`free(lastword);`
499
500			`}else if(verilog==1){`

Browse

Tools

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step1.y] - Blame information for rev 6