Subversion Repositories sc2v

/* -----------------------------------------------------------------------------
 *
 *  SystemC to Verilog Translator v0.1
 *  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 "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;


/* 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;




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

int yywrap()
{
        return 1;
}

main()
{       
        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);
        
                        
        yyparse();
        printf("module %s(",module_name);
        EnumeratePorts(portlist);
        printf(");\n");
        
        ShowPortList(portlist);
        printf("\n");
        RegOutputs(portlist);
        printf("\n");
                
        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 
%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

%%

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
        |
        closekey
        |
        word_semicolon
        |
        word_colon
        |
        signal_bool
        |
        signal_uint
        |
        signal_int
        |
        instantation
        |
        port_binding
        |
        sc_ctor
        |
        void
        |
        inst_decl
        |
        closekey_semicolon
        ;

module:
        SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
        {       
                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
        {
                activeport = 1;
                lastportsize = $5;
                lastportkind = (char *)"input";
        }
        ;

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


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

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

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

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

sc_method:
        SC_METHOD OPENPAR WORD CLOSEPAR SEMICOLON
        {
                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);
        }       
        ;
        
sensitive_pos:
        SENSITIVE_POS
        {
                last_sensibility = (char *)"posedge";
                active_method_type = (char *)"seq"; //seq
                sensibility_active = 1;
        }
        ;
        
sensitive_neg:
        SENSITIVE_NEG
        {
                last_sensibility = (char *)"negedge";
                active_method_type = (char *)"seq"; //seq
                sensibility_active = 1; 
        }
        ;
        
sensitive:
        SENSITIVE
        {
                last_sensibility = (char *)" "; 
                active_method_type = (char *)"comb"; //comb
                sensibility_active = 1;
        }
        ;
sensible_word_colon:
        SENSIBLE WORD
        {
                InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
        }
        ;

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

closekey:
        CLOSEKEY
        {
                if(method_found)
                        {
                        method_found = 0;
                        InsertProcess(processlist, active_method, sensibilitylist, active_method_type);
                        }
        }
        ;
word_semicolon:
        WORD SEMICOLON
        {
                        if(activeport)
                        {
                                InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
                                activeport = 0;
                        }
                        else if(signalactive)
                        {
                                InsertSignal(signalslist, (char *)$1, lastsignalsize);
                                signalactive = 0;
                        }
        }
        ;

word_colon:
                WORD COLON
                {
                        if(activeport)
                        {
                                InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
                        }
                        else if(signalactive)
                        {
                                InsertSignal(signalslist, (char *)$1, lastsignalsize);                          
                        }
                }
                ;

instantation:
                WORD EQUALS NEW WORD OPENPAR QUOTE WORD QUOTE CLOSEPAR SEMICOLON
                {
                        InsertInstance(instanceslist, (char *)$1, (char *)$4);
                }
                ;
                
port_binding:
                WORD ARROW WORD OPENPAR WORD CLOSEPAR SEMICOLON
                {                                                                               
                        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
                {
                
                }
                ;