Subversion Repositories sc2v

/* -----------------------------------------------------------------------------
 *
 *  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 <stdio.h>
#include <string.h>
#include <math.h>

#include "list.h"


/*Global var to read from file_writes.sc2v*/
WritesList *writeslist;

/*Global var to store ports*/
PortList *portlist;

/* Global var to store signals*/
SignalsList *signalslist;

/* Global var to store sensitivity list*/
SensibilityList *sensibilitylist;

/* Global var to store instantiated modules*/
InstancesList *instanceslist;

/* Global var to store process list*/
ProcessList *processlist;

/*List of enumerates*/
EnumeratesList *enumerateslist;
EnumListList   *enumlistlist;
char           *enumname;
int            reading_enumerates=0;

/*Multiple Declarations*/
int            multipledec;
char           *storedtype;

/* Global var to store process module name*/
char *module_name;
int module_name_found = 0;

/* Global var to store last port type*/
char *lastportkind;
int lastportsize;
int activeport = 0;     // 1 -> reading port list

/* Global var to store last signal type*/
int lastsignalsize;
int signalactive = 0;

/* Global var to store last SC_METHOD found*/
char *active_method;
char *active_method_type;
int method_found;

/* Global var to store last sensitivity found*/
char *last_sensibility;
int sensibility_active = 0;


int translate;
        
void yyerror(const char *str)
{
        fprintf(stderr,"error: %s\n",str);
}

int yywrap()
{
        return 1;
}

main()
{       
    /*Initialize lists*/
        
        writeslist = (WritesList *)malloc(sizeof(WritesList));
        InitializeWritesList(writeslist);
        
        portlist = (PortList *)malloc(sizeof(PortList));
        InitializePortList(portlist);
        
        signalslist = (SignalsList *)malloc(sizeof(SignalsList));
        InitializeSignalsList(signalslist);
        
        sensibilitylist = (SensibilityList *)malloc(sizeof(SensibilityList));
        InitializeSensibilityList(sensibilitylist);
        
        instanceslist = (InstancesList *)malloc(sizeof(InstancesList));
        InitializeInstancesList(instanceslist);

    processlist = (ProcessList *)malloc(sizeof(ProcessList));
        InitializeProcessList(processlist);
        
        enumlistlist = (EnumListList *)malloc(sizeof(EnumListList));
        InitializeEnumListList(enumlistlist);
        
        translate=1;
        
        yyparse();
        
        printf("module %s(",module_name);
        EnumeratePorts(portlist);
        printf(");\n");
        
        ShowPortList(portlist);
        printf("\n");
        RegOutputs(portlist);
        printf("\n");
        
    ShowEnumListList(enumlistlist);    
        
        ReadWritesFile(writeslist, (char *)"file_writes.sc2v");
                        
        ShowSignalsList(signalslist, writeslist);
        printf("\n");
        
        ShowInstancedModules(instanceslist);
        printf("\n");
        
        ShowDefines((char *)"file_defines.sc2v");
        
        ShowProcessCode(processlist);
        printf("\n");
        
        printf("endmodule\n");
}

%}

%token NUMBER SC_MODULE WORD OPENPAR CLOSEPAR SC_IN SC_OUT SEMICOLON BOOL ENUM
%token MENOR MAYOR SC_INT SC_UINT SC_METHOD SENSITIVE_POS SENSITIVE_NEG SENSITIVE 
%token SENSIBLE CLOSEKEY OPENKEY SEMICOLON COLON SC_SIGNAL ARROW EQUALS NEW QUOTE
%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF 

%%

commands: /* empty */
        | commands command
        ;


command:
        module
        |
        in_bool
        |
        in_sc_int
        |
        in_sc_uint
        |
        out_bool
        |
        out_sc_int
        |
        out_sc_uint
        |
        sc_method
        |
        sensitive_pos
        |
        sensitive_neg
        |
        sensitive
        |
        sensible_word_colon
        |
        sensible_word_semicolon
        |
        sensible_par_colon
        |
        sensible_par_pos
        |
        sensible_par_neg
        |
        closekey
        |
        word_semicolon
        |
        word_colon
        |
        word_closekey
        |
        word_closekey_word
        |
        signal_bool
        |
        signal_uint
        |
        signal_int
        |
        instantation
        |
        port_binding
        |
        sc_ctor
        |
        void
        |
        inst_decl
        |
        closekey_semicolon
        |
        enumerates
        |
        enumerates_type
        |
        declaration
        |
        declaration_sc_signal
        |
        multiple_declaration
        |
        multiple_sc_signal_declaration  
        |
        translateoff
        |
        translateon
        ;

module:
        SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
        {       
        if(translate==1){
                if(module_name_found)
                        {
                        fprintf(stderr,"error: two or more modules found in the file\n");
                        exit(1);
                        }
                else
                        {
                        module_name = (char *)malloc(256*sizeof(char));
                        strcpy(module_name, (char *)$3);
                        module_name_found = 1;
                        }
        }
        }
        ;

in_sc_uint:
        SC_IN MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
        {
        if(translate==1){
                activeport = 1;
                lastportsize = $5;
                lastportkind = (char *)"input";
        }
        };

in_sc_int:
        SC_IN MENOR SC_INT MENOR NUMBER MAYOR MAYOR
        {
        if(translate==1){
                activeport = 1;
                lastportsize = $5;
                lastportkind = (char *)"input";
        }
        };


in_bool:
        SC_IN MENOR BOOL MAYOR
        {
        if(translate==1){
                activeport = 1;
                lastportsize = 0;
                lastportkind = (char *)"input";         
        }
        };

signal_bool:
                SC_SIGNAL MENOR BOOL MAYOR
                {
                if(translate==1){
                        signalactive = 1;
                        lastsignalsize = 0;
                }
                };
                
signal_uint:
                SC_SIGNAL MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
                {
                if(translate==1){
                        signalactive = 1;
                        lastsignalsize = $5;
                }
                };
                
signal_int:
                SC_SIGNAL MENOR SC_INT MENOR NUMBER MAYOR MAYOR
                {
                if(translate==1){
                        signalactive = 1;
                        lastsignalsize = $5;
                }
                };
                
out_bool:
        SC_OUT MENOR BOOL MAYOR
        {
        if(translate==1){
                activeport = 1;
                lastportsize = 0;
                lastportkind = (char *)"output";
        }
        };

out_sc_uint:
        SC_OUT MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
        {
        if(translate==1){
                activeport = 1;
                lastportsize = $5;
                lastportkind = (char *)"output";
        }
        };

out_sc_int:
        SC_OUT MENOR SC_INT MENOR NUMBER MAYOR MAYOR
        {
        if(translate==1){
                activeport = 1;
                lastportsize = $5;
                lastportkind = (char *)"output";
        }
        };

sc_method:
        SC_METHOD OPENPAR WORD CLOSEPAR SEMICOLON
        {
        if(translate==1){
                if(method_found)
                        {
                        InsertProcess(processlist, active_method, sensibilitylist, active_method_type);                 
                        }
                active_method = (char *)$3;
                method_found = 1;
                /* New sensitivity list */
                sensibilitylist = (SensibilityList *)malloc(sizeof(SensibilityList));
                InitializeSensibilityList(sensibilitylist);
        }       
        };

sensible_par_neg:
        SENSITIVE_NEG OPENPAR WORD CLOSEPAR SEMICOLON
        {
        if(translate==1){
            active_method_type = (char *)"seq"; //comb
                InsertSensibility(sensibilitylist, (char *)$3, "negedge");
        }
        };

sensible_par_pos:
        SENSITIVE_POS OPENPAR WORD CLOSEPAR SEMICOLON
        {
        if(translate==1){
            active_method_type = (char *)"seq"; //comb
                InsertSensibility(sensibilitylist, (char *)$3, "posedge");
        }
        };
        
sensitive_pos:
        SENSITIVE_POS
        {
        if(translate==1){
                last_sensibility = (char *)"posedge";
                active_method_type = (char *)"seq"; //seq
                sensibility_active = 1;
        }
        };
        
sensitive_neg:
        SENSITIVE_NEG
        {
        if(translate==1){
                last_sensibility = (char *)"negedge";
                active_method_type = (char *)"seq"; //seq
                sensibility_active = 1; 
        }
        };
        
sensitive:
        SENSITIVE
        {
        if(translate==1){
                last_sensibility = (char *)" "; 
                active_method_type = (char *)"comb"; //comb
                sensibility_active = 1;
        }
        };

sensible_par_colon:
        SENSITIVE OPENPAR WORD CLOSEPAR SEMICOLON
        {
        if(translate==1){
            active_method_type = (char *)"comb"; //comb
                InsertSensibility(sensibilitylist, (char *)$3, " ");
        }
        };


sensible_word_colon:
        SENSIBLE WORD
        {
        if(translate==1){
                InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
        }
        };

sensible_word_semicolon:        
        SENSIBLE WORD SEMICOLON
        {
        if(translate==1){
                InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
                if(sensibility_active)
                        {
                        sensibility_active = 0;
                        }
        }
        };

closekey:
        CLOSEKEY
        {
        if(translate==1){
                if(method_found)
                        {
                        method_found = 0;
                        InsertProcess(processlist, active_method, sensibilitylist, active_method_type);
                        }
        }       
        };
        
word_semicolon:
        WORD SEMICOLON
        {
        if(translate==1){
                        if(activeport)
                        {
                                InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
                                activeport = 0;
                        }
                        else if(signalactive)
                        {
                                InsertSignal(signalslist, (char *)$1, lastsignalsize);
                                signalactive = 0;
                        }else if(multipledec){ 
                          int length,list_pos;                          
                      length=0;
                      list_pos=0;
                      //Look in the enumerated list if it was declared e.j state_t state;
                      list_pos=findEnumList(enumlistlist, storedtype);
                      if(list_pos>-1){
                        //Calculate the number of bits needed to represent the enumerate
                length=findEnumerateLength(enumlistlist,list_pos);
                          
                        InsertSignal(signalslist, (char *)$1,length);
                            InsertWrite(writeslist,(char *)$1);
                                free(storedtype);
                            multipledec=0;
              }else{
                fprintf(stderr,"\nType %s unknow\n",(char *)$1);
                return(1);
              }                 
                   }
        }
        };

word_colon:
                WORD COLON
                {
                if(translate==1){
                        if(activeport)
                        {
                                InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
                        }
                        else if(signalactive)
                        {
                                InsertSignal(signalslist, (char *)$1, lastsignalsize);                          
                        }
                        else if(reading_enumerates)
                        {
                            InsertEnumerates(enumerateslist, (char *)$1);
                         
                        }else if(multipledec){ 
                          int length,list_pos;                          
                      length=0;
                      list_pos=0;
                      //Look in the enumerated list if it was declared e.j state_t state;
                      list_pos=findEnumList(enumlistlist, storedtype);
                      if(list_pos>-1){
                        //Calculate the number of bits needed to represent the enumerate
                length=findEnumerateLength(enumlistlist,list_pos);
                          
                        InsertSignal(signalslist, (char *)$1,length);
                            InsertWrite(writeslist,(char *)$1);
                            multipledec=1;
              }else{
                fprintf(stderr,"\nType %s unknow\n",(char *)$1);
                return(1);
              }                 
                   }
                }
                };

word_closekey_word:
        WORD CLOSEKEY WORD SEMICOLON
                {
                if(translate==1){
                  //Finish enumerate var declaration
                  if(reading_enumerates)
                  {
                    InsertEnumerates(enumerateslist, (char *)$1);
                        InsertEnumList(enumlistlist,enumerateslist,(char *)$4,0); //Insert also the variable name
                    reading_enumerates=0;
                  }
                }
                };

word_closekey:
        WORD CLOSEKEY SEMICOLON
                {
                if(translate==1){
                  //Finish enumerate type declaration
                  if(reading_enumerates)
                  {
                    InsertEnumerates(enumerateslist, (char *)$1);
                        InsertEnumList(enumlistlist,enumerateslist,enumname,1); //Insert also the variable name
                    reading_enumerates=0;
                  }
                }
                };


instantation:
                WORD EQUALS NEW WORD OPENPAR QUOTE WORD QUOTE CLOSEPAR SEMICOLON
                {
                if(translate==1){
                        InsertInstance(instanceslist, (char *)$1, (char *)$4);
                }
                };
                
port_binding:
                WORD ARROW WORD OPENPAR WORD CLOSEPAR SEMICOLON
                {
        if(translate==1){               
                        if(instanceslist->last == NULL)
                        {
                                fprintf(stderr,"error: no instances found\n");
                        }
                        else
                        {
                                InstanceNode *aux;
                                aux = instanceslist->first;
                                while(1)
                                {
                                        if(strcmp(aux->nameinstance, (char *)$1) == 0)
                                        {
                                                break;
                                        }
                                        else
                                        {
                                                if(aux->next == NULL)
                                                {
                                                        fprintf(stderr,"error: instance %s not found\n",$1);
                                                        exit(1);
                                                }
                                                else
                                                {
                                                        aux = aux->next;
                                                }
                                        }
                                }
                                InsertBind(aux->bindslist, (char *)$3, (char *)$5);
                        }
                }
                };

sc_ctor:
                SC_CTOR OPENPAR WORD CLOSEPAR OPENKEY
                {
                                
                };
                
void:
                VOID WORD OPENPAR CLOSEPAR SEMICOLON
                {
                
                };
                
inst_decl:
                WORD ASTERISCO WORD SEMICOLON
                {
                
                };
                
closekey_semicolon:     CLOSEKEY SEMICOLON
                {
                
                };

enumerates:
         ENUM OPENKEY 
                 {
                 if(translate==1){
                   //New enumerate list
                   enumerateslist = (EnumeratesList *)malloc(sizeof(EnumeratesList));
                   InitializeEnumeratesList(enumerateslist);
           reading_enumerates=1;                 
                 }
                 };
                 
enumerates_type:
         ENUM WORD OPENKEY
                 {
                 if(translate==1){
                   //In this case we define type e.g. enum state_t {S0,S1,S2};
                   enumerateslist = (EnumeratesList *)malloc(sizeof(EnumeratesList));
                   InitializeEnumeratesList(enumerateslist);
                   enumname=malloc(sizeof(char)*strlen((char *)$2));
                   strcpy(enumname,(char *)$2);
           reading_enumerates=1;                 
                 }
                 };
                 
declaration:
         WORD WORD SEMICOLON
                 {
                 if(translate==1){              
           int length,list_pos;                         
                   length=0;
                   list_pos=0;
                   //Look in the enumerated list if it was declared e.j state_t state;
                   list_pos=findEnumList(enumlistlist, (char *)$1);
                   if(list_pos>-1){
                      //Calculate the number of bits needed to represent the enumerate
              length=findEnumerateLength(enumlistlist,list_pos);
                          
                      InsertSignal(signalslist, (char *)$2,length);
                          InsertWrite(writeslist,(char *)$2);
           }else{
              fprintf(stderr,"\nType %s unknow\n",(char *)$1);
              return(1);
           }                      
                 }  
                 };  

declaration_sc_signal:
         SC_SIGNAL MENOR WORD MAYOR WORD SEMICOLON
                 {
                 if(translate==1){              
           int length,list_pos;                         
                   length=0;
                   list_pos=0;
                   //Look in the enumerated list if it was declared e.j state_t state;
                   list_pos=findEnumList(enumlistlist, (char *)$3);
                   if(list_pos>-1){
                      //Calculate the number of bits needed to represent the enumerate
              length=findEnumerateLength(enumlistlist,list_pos);
                          
                      InsertSignal(signalslist, (char *)$5,length);
                          InsertWrite(writeslist,(char *)$5);
           }else{
              fprintf(stderr,"\nType %s unknow\n",(char *)$3);
              return(1);
           }                      
                 }  
                 };  

multiple_declaration:
         WORD WORD COLON
                 {
                 if(translate==1){              
           int length,list_pos;                         
                   length=0;
                   list_pos=0;
                   //Look in the enumerated list if it was declared e.j state_t state;
                   list_pos=findEnumList(enumlistlist, (char *)$1);
                   if(list_pos>-1){
                      //Calculate the number of bits needed to represent the enumerate
              length=findEnumerateLength(enumlistlist,list_pos);
                          storedtype=malloc(sizeof(char)*strlen((char *)$1));
                          strcpy(storedtype,(char *)$1);
                      InsertSignal(signalslist, (char *)$2,length);
                          InsertWrite(writeslist,(char *)$2);
                          multipledec=1;
           }else{
              fprintf(stderr,"\nType %s unknow\n",(char *)$1);
              return(1);
           }                      
                 }  
                 }; 

multiple_sc_signal_declaration:
         SC_SIGNAL MENOR WORD MAYOR WORD COLON
                 {
                 if(translate==1){              
           int length,list_pos;                         
                   length=0;
                   list_pos=0;
                   //Look in the enumerated list if it was declared e.j state_t state;
                   list_pos=findEnumList(enumlistlist, (char *)$3);
                   if(list_pos>-1){
                      //Calculate the number of bits needed to represent the enumerate
              length=findEnumerateLength(enumlistlist,list_pos);
                          storedtype=malloc(sizeof(char)*strlen((char *)$3));
                          strcpy(storedtype,(char *)$3);
                      InsertSignal(signalslist, (char *)$5,length);
                          InsertWrite(writeslist,(char *)$5);
                          multipledec=1;
           }else{
              fprintf(stderr,"\nType %s unknow\n",(char *)$3);
              return(1);
           }                      
                 }  
                 };
                 
translateoff:
        TRANSLATEOFF
                {
                  translate=0;
                  fprintf(stderr,"Found Translate off directive \n");
        };

translateon:
        TRANSLATEON
                {
                  translate=1;
                  fprintf(stderr,"Found Translate on directive \n");
        };