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

Subversion Repositories sc2v

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

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);
 
        lastword=malloc(sizeof(char)*256);
 
        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;
                             }
 
                             strcpy(lastword, (char *)$1);
 
                             if(reg_found)
                             {
 
                              regname=malloc(sizeof(char)*(strlen((char *)$1)+1));
                              regname2=malloc(sizeof(char)*(strlen((char *)$1)+strlen(processname))+1);
 
                              strcpy(regname ,(char *)$1);
                              strcpy(regname2 ,(char *)$1);
                              strcat(regname2, processname);
                              fprintf(regs_file,"%s",regname2);
                              InsertReg(regslist, regname, regname2);
                              free(regname);
                              free(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," = ");
                                }
 
                        }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
99	10	jcastillo	`if(FILE_WRITES!=NULL)`
100			`printf("\nopening file => filename = %s\n",file_writes);`
101
102			`lastword=malloc(sizeof(char)*256);`
103
104			`translate=1;`
105	4	jcastillo	`verilog=0;`
106			`writemethod=0;`
107
108	2	jcastillo	`yyparse();`
109			`fclose(FILE_WRITES);`
110			`fclose(FILE_DEFINES);`
111			`}`
112
113			`%}`
114
115	4	jcastillo	`%token NUMBER WORD SC_INT SC_UINT BOOL BIGGER LOWER OPENKEY CLOSEKEY WRITE WORD SYMBOL NEWLINE ENUM INCLUDE`
116			`%token COLON SEMICOLON RANGE OPENPAR CLOSEPAR TWODOUBLEPOINTS OPENCORCH CLOSECORCH SWITCH CASE DEFAULT BREAK`
117			`%token SC_BIGINT SC_BIGUINT HEXA DEFINE READ TRANSLATEOFF TRANSLATEON VERILOGBEGIN VERILOGEND TAB DOLLAR INTCONV`
118	6	jcastillo	`%token VOID TTRUE TFALSE`
119	4	jcastillo	`%token PIFDEF PENDDEF PELSE`
120	2	jcastillo
121			`%%`
122
123			`commands: /* empty */`
124			`\| commands command`
125			`;`
126
127
128			`command:`
129	4	jcastillo	`voidword`
130			`\|`
131			`include`
132			`\|`
133			`dollar`
134			`\|`
135			`intconv`
136			`\|`
137			`tab`
138			`\|`
139	2	jcastillo	`read`
140			`\|`
141			`sc_int`
142			`\|`
143			`sc_uint`
144			`\|`
145			`sc_bigint`
146			`\|`
147			`sc_biguint`
148			`\|`
149			`number`
150			`\|`
151			`bool`
152			`\|`
153			`word`
154			`\|`
155			`symbol`
156			`\|`
157			`write`
158			`\|`
159			`newline`
160			`\|`
161			`openkey`
162			`\|`
163			`closekey`
164			`\|`
165			`colon`
166			`\|`
167			`semicolon`
168			`\|`
169			`range`
170			`\|`
171			`openpar`
172			`\|`
173			`closepar`
174			`\|`
175			`void`
176			`\|`
177			`opencorch`
178			`\|`
179			`closecorch`
180			`\|`
181	4	jcastillo	`bigger`
182	2	jcastillo	`\|`
183	4	jcastillo	`lower`
184	2	jcastillo	`\|`
185			`switch`
186			`\|`
187	4	jcastillo	`case_only`
188	2	jcastillo	`\|`
189	4	jcastillo	`case_number`
190			`\|`
191			`case_word`
192			`\|`
193	2	jcastillo	`case_default`
194			`\|`
195			`break`
196			`\|`
197			`hexa`
198			`\|`
199			`define`
200	4	jcastillo	`\|`
201			`translateoff`
202			`\|`
203			`translateon`
204			`\|`
205			`verilogbegin`
206			`\|`
207			`verilogend`
208			`\|`
209			`ifdef`
210			`\|`
211			`endif`
212			`\|`
213	6	jcastillo	`pelse`
214			`\|`
215			`ttrue`
216			`\|`
217			`tfalse`
218	2	jcastillo	`;`
219
220	4	jcastillo
221
222			`voidword:`
223			`VOID`
224			`{`
225			`if(verilog==1)`
226			`fprintf(file," void");`
227			`};`
228
229
230			`include:`
231			`INCLUDE`
232			`{`
233			`if(verilog==1)`
234			`fprintf(file," #include");`
235			`};`
236
237
238			`dollar:`
239			`DOLLAR`
240			`{`
241			`if(verilog==1)`
242			`fprintf(file," $");`
243			`};`
244
245			`intconv:`
246			`INTCONV`
247			`{`
248			`if(verilog==1)`
249			`fprintf(file," (int)");`
250			`};`
251
252			`tab:`
253			`TAB`
254			`{`
255			`if(verilog==1)`
256			`fprintf(file," \t");`
257			`};`
258
259	2	jcastillo	`read:`
260			`READ OPENPAR CLOSEPAR`
261			`{`
262	4	jcastillo	`if(verilog==1)`
263			`fprintf(file,".read()");`
264	2	jcastillo
265			`}`
266	4	jcastillo
267	2	jcastillo	`define:`
268			`DEFINE WORD OPENPAR CLOSEPAR`
269			`{`
270	4	jcastillo	`if(translate==1 && verilog==0){`
271	2	jcastillo	`InsertDefine(defineslist, (char *)$2);`
272			`definefound = 1;`
273			fprintf(FILE_DEFINES,"`define %s ",(char *)$2);
274	4	jcastillo	`}else if(verilog==1)`
275			`fprintf(file,"#define %s ()",(char *)$2);`
276	2	jcastillo	`}`
277			`void:`
278	4	jcastillo	`WORD TWODOUBLEPOINTS WORD OPENPAR CLOSEPAR`
279	2	jcastillo	`{`
280	4	jcastillo	`if(translate==1&& verilog==0){`
281	2	jcastillo	`strcpy(processname ,(char *)$4);`
282			`strcpy(processname2 ,(char *)$4);`
283			`strcat(processname2, (char *)".sc2v");`
284			`strcpy(fileregs ,(char *)$4);`
285			`strcat(fileregs, (char *)"_regs.sc2v");`
286			`/*`
287			`strcpy(file_writes, (char *)$4);`
288			`strcat(file_writes, (char *)"_writes.sc2v");`
289			`*/`
290	4	jcastillo	`}else if(verilog==1)`
291			`fprintf(file," %s::%s()",(char )$1,(char )$3);`
292
293	2	jcastillo	`}`
294			`sc_int:`
295	4	jcastillo	`SC_INT LOWER NUMBER BIGGER`
296			`{`
297			`if(translate==1&& verilog==0){`
298	2	jcastillo	`if(processfound)`
299			`{`
300			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
301			`reg_found = 1;`
302			`}`
303	4	jcastillo	`}else if(verilog==1)`
304			`fprintf(file,"sc_int<%d>",$3);`
305
306	2	jcastillo	`}`
307			`;`
308
309			`sc_uint:`
310	4	jcastillo	`SC_UINT LOWER NUMBER BIGGER`
311	2	jcastillo	`{`
312	4	jcastillo	`if(translate==1&& verilog==0){`
313	2	jcastillo	`if(processfound)`
314			`{`
315			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
316			`reg_found = 1;`
317			`}`
318	4	jcastillo	`}else if(verilog==1)`
319			`fprintf(file,"sc_uint<%d>",$3);`
320	2	jcastillo	`}`
321			`;`
322
323			`sc_bigint:`
324	4	jcastillo	`SC_BIGINT LOWER NUMBER BIGGER`
325	2	jcastillo	`{`
326	4	jcastillo	`if(translate==1&& verilog==0){`
327	2	jcastillo	`if(processfound)`
328			`{`
329			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
330			`reg_found = 1;`
331			`}`
332	4	jcastillo	`}else if(verilog==1)`
333			`fprintf(file,"sc_bigint<%d> ",$3);`
334	2	jcastillo	`}`
335			`;`
336
337			`sc_biguint:`
338	4	jcastillo	`SC_BIGUINT LOWER NUMBER BIGGER`
339	2	jcastillo	`{`
340	4	jcastillo	`if(translate==1&& verilog==0){`
341	2	jcastillo	`if(processfound)`
342			`{`
343			`fprintf(regs_file,"reg[%d:0] ",(-1 + $3));`
344			`reg_found = 1;`
345			`}`
346	4	jcastillo	`}else if(verilog==1)`
347			`fprintf(file,"sc_biguint<%d> ",$3);`
348	2	jcastillo	`}`
349			`;`
350
351			`bool:`
352			`BOOL`
353			`{`
354	4	jcastillo	`if(translate==1&& verilog==0){`
355	2	jcastillo	`if(processfound)`
356			`{`
357			`fprintf(regs_file,"reg ");`
358			`reg_found = 1;`
359			`}`
360	4	jcastillo	`}else if(verilog==1)`
361			`fprintf(file,"bool");`
362	2	jcastillo	`}`
363			`;`
364
365			`range:`
366			`RANGE OPENPAR NUMBER COLON NUMBER CLOSEPAR`
367			`{`
368	4	jcastillo	`if(translate==1&& verilog==0){`
369	2	jcastillo	`if(processfound)`
370			`fprintf(file,"[%d:%d]",$3,$5);`
371			`else if(definefound)`
372			`fprintf(FILE_DEFINES,"[%d:%d]",$3,$5);`
373	4	jcastillo	`}else if(verilog==1)`
374			`fprintf(file,".range(%d,%d)",$3,$5);`
375	2	jcastillo	`}`
376			`;`
377
378			`number:`
379			`NUMBER`
380			`{`
381	4	jcastillo	`if(translate==1&& verilog==0){`
382	2	jcastillo	`if(processfound)`
383			`if(reg_found)`
384			`{`
385			`if(opencorchfound)`
386			`fprintf(regs_file,"%d:0", -1 + $1);`
387			`else`
388			`fprintf(regs_file,"%d",$1);`
389			`}`
390			`else`
391			`fprintf(file,"%d",$1);`
392			`else if(definefound)`
393			`fprintf(FILE_DEFINES,"%d",$1);`
394	4	jcastillo	`}else if(verilog==1)`
395			`fprintf(file,"%d",$1);`
396	2	jcastillo	`}`
397			`;`
398			`word:`
399			`WORD`
400			`{`
401	4	jcastillo	`if(translate==1&& verilog==0){`
402	2	jcastillo	`if(processfound)`
403			`{`
404			`if(openedcase)`
405			`{`
406			`fprintf(file," :\n");`
407	4	jcastillo
408			`for(i = 0; i < openedkeys; i++)`
409			`fprintf(file," ");`
410
411			`fprintf(file,"begin\n");`
412			`openedcase = 0;`
413	2	jcastillo	`}`
414	10	jcastillo
415			`strcpy(lastword, (char *)$1);`
416	2	jcastillo
417			`if(reg_found)`
418			`{`
419	10	jcastillo
420			`regname=malloc(sizeof(char)(strlen((char )$1)+1));`
421			`regname2=malloc(sizeof(char)(strlen((char )$1)+strlen(processname))+1);`
422
423	2	jcastillo	`strcpy(regname ,(char *)$1);`
424	10	jcastillo	`strcpy(regname2 ,(char *)$1);`
425	2	jcastillo	`strcat(regname2, processname);`
426			`fprintf(regs_file,"%s",regname2);`
427			`InsertReg(regslist, regname, regname2);`
428	10	jcastillo	`free(regname);`
429			`free(regname2);`
430	2	jcastillo	`}`
431			`else`
432			`{`
433	4	jcastillo	`if(newline)`
434			`{`
435			`for(i = 0; i < openedkeys; i++)`
436			`fprintf(file," ");`
437			`}`
438			`regname2 = IsReg(regslist, (char *)$1);`
439			`if(regname2 == NULL)`
440			`{`
441			`if(IsDefine(defineslist, (char *)$1))`
442			`{`
443			fprintf(file,"`%s", (char *)$1);
444			`defineinvocationfound = 1;`
445			`}`
446			`else`
447			`{`
448	6	jcastillo	`fprintf(file,"%s ",(char *)$1);`
449	4	jcastillo	`}`
450			`}`
451			`else`
452			`fprintf(file,"%s",regname2);`
453
454			`newline = 0;`
455	2	jcastillo	`}`
456	10	jcastillo
457	2	jcastillo	`}`
458			`else if(definefound)`
459			`{`
460			`if(IsDefine(defineslist, (char *)$1))`
461			`{`
462	4	jcastillo	fprintf(FILE_DEFINES,"`%s",(char *)$1);
463	2	jcastillo	`}`
464			`else`
465			`{`
466			`fprintf(FILE_DEFINES,"%s ",(char *)$1);`
467			`}`
468			`}`
469	4	jcastillo	`}else if(verilog==1)`
470			`fprintf(file," %s",(char *)$1);`
471			`};`
472	2	jcastillo
473			`symbol:`
474			`SYMBOL`
475			`{`
476	4	jcastillo	`if(translate==1&& verilog==0){`
477	2	jcastillo	`if(processfound)`
478			`{`
479			`if(reg_found)`
480			`fprintf(regs_file,"%s",(char *)$1);`
481			`else`
482			`fprintf(file,"%s",(char *)$1);`
483			`}`
484			`else if(definefound)`
485			`{`
486			`fprintf(FILE_DEFINES,"%s",(char *)$1);`
487			`}`
488	4	jcastillo	`}else if(verilog==1)`
489			`fprintf(file,"%s",(char *)$1);`
490			`};`
491	2	jcastillo
492
493			`write:`
494			`WRITE`
495			`{`
496	4	jcastillo	`if(translate==1&& verilog==0){`
497	10	jcastillo	`writemethod=1;`
498	2	jcastillo	`if(processfound)`
499			`{`
500			`fprintf(file," = ");`

Browse

Tools

Subversion Repositories sc2v

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