/* -----------------------------------------------------------------------------
|
/* -----------------------------------------------------------------------------
|
*
|
*
|
* SystemC to Verilog Translator v0.2
|
* SystemC to Verilog Translator v0.2
|
* Provided by OpenSoc Design
|
* Provided by OpenSoc Design
|
*
|
*
|
* www.opensocdesign.com
|
* www.opensocdesign.com
|
*
|
*
|
* -----------------------------------------------------------------------------
|
* -----------------------------------------------------------------------------
|
* This program is free software; you can redistribute it and/or modify
|
* 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
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
* (at your option) any later version.
|
*
|
*
|
* This program is distributed in the hope that it will be useful,
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU Library General Public License for more details.
|
* GNU Library General Public License for more details.
|
*
|
*
|
* You should have received a copy of the GNU General Public License
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
*/
|
|
|
%{
|
%{
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
|
|
#include "list.h"
|
#include "list.h"
|
|
|
|
|
/*Global var to read from file_writes.sc2v*/
|
/*Global var to read from file_writes.sc2v*/
|
WritesList *writeslist;
|
WritesList *writeslist;
|
|
|
/*Global var to store ports*/
|
/*Global var to store ports*/
|
PortList *portlist;
|
PortList *portlist;
|
|
|
/* Global var to store signals*/
|
/* Global var to store signals*/
|
SignalsList *signalslist;
|
SignalsList *signalslist;
|
|
|
/* Global var to store sensitivity list*/
|
/* Global var to store sensitivity list*/
|
SensibilityList *sensibilitylist;
|
SensibilityList *sensibilitylist;
|
|
|
/* Global var to store instantiated modules*/
|
/* Global var to store instantiated modules*/
|
InstancesList *instanceslist;
|
InstancesList *instanceslist;
|
|
|
/* Global var to store process list*/
|
/* Global var to store process list*/
|
ProcessList *processlist;
|
ProcessList *processlist;
|
|
|
/*List of enumerates*/
|
/*List of enumerates*/
|
EnumeratesList *enumerateslist;
|
EnumeratesList *enumerateslist;
|
EnumListList *enumlistlist;
|
EnumListList *enumlistlist;
|
char *enumname;
|
char *enumname;
|
int reading_enumerates=0;
|
int reading_enumerates=0;
|
|
|
/*Multiple Declarations*/
|
/*Multiple Declarations*/
|
int multipledec;
|
int multipledec;
|
char *storedtype;
|
char *storedtype;
|
|
|
/* Global var to store process module name*/
|
/* Global var to store process module name*/
|
char *module_name;
|
char *module_name;
|
int module_name_found = 0;
|
int module_name_found = 0;
|
|
|
/* Global var to store last port type*/
|
/* Global var to store last port type*/
|
char *lastportkind;
|
char *lastportkind;
|
int lastportsize;
|
int lastportsize;
|
int activeport = 0; // 1 -> reading port list
|
int activeport = 0; // 1 -> reading port list
|
|
|
/* Global var to store last signal type*/
|
/* Global var to store last signal type*/
|
int lastsignalsize;
|
int lastsignalsize;
|
int signalactive = 0;
|
int signalactive = 0;
|
|
|
/* Global var to store last SC_METHOD found*/
|
/* Global var to store last SC_METHOD found*/
|
char *active_method;
|
char *active_method;
|
char *active_method_type;
|
char *active_method_type;
|
int method_found;
|
int method_found;
|
|
|
/* Global var to store last sensitivity found*/
|
/* Global var to store last sensitivity found*/
|
char *last_sensibility;
|
char *last_sensibility;
|
int sensibility_active = 0;
|
int sensibility_active = 0;
|
|
|
|
|
int translate;
|
int translate;
|
|
|
void yyerror(const char *str)
|
void yyerror(const char *str)
|
{
|
{
|
fprintf(stderr,"error: %s\n",str);
|
fprintf(stderr,"error: %s\n",str);
|
}
|
}
|
|
|
int yywrap()
|
int yywrap()
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
main()
|
main()
|
{
|
{
|
/*Initialize lists*/
|
/*Initialize lists*/
|
|
|
writeslist = (WritesList *)malloc(sizeof(WritesList));
|
writeslist = (WritesList *)malloc(sizeof(WritesList));
|
InitializeWritesList(writeslist);
|
InitializeWritesList(writeslist);
|
|
|
portlist = (PortList *)malloc(sizeof(PortList));
|
portlist = (PortList *)malloc(sizeof(PortList));
|
InitializePortList(portlist);
|
InitializePortList(portlist);
|
|
|
signalslist = (SignalsList *)malloc(sizeof(SignalsList));
|
signalslist = (SignalsList *)malloc(sizeof(SignalsList));
|
InitializeSignalsList(signalslist);
|
InitializeSignalsList(signalslist);
|
|
|
sensibilitylist = (SensibilityList *)malloc(sizeof(SensibilityList));
|
sensibilitylist = (SensibilityList *)malloc(sizeof(SensibilityList));
|
InitializeSensibilityList(sensibilitylist);
|
InitializeSensibilityList(sensibilitylist);
|
|
|
instanceslist = (InstancesList *)malloc(sizeof(InstancesList));
|
instanceslist = (InstancesList *)malloc(sizeof(InstancesList));
|
InitializeInstancesList(instanceslist);
|
InitializeInstancesList(instanceslist);
|
|
|
processlist = (ProcessList *)malloc(sizeof(ProcessList));
|
processlist = (ProcessList *)malloc(sizeof(ProcessList));
|
InitializeProcessList(processlist);
|
InitializeProcessList(processlist);
|
|
|
enumlistlist = (EnumListList *)malloc(sizeof(EnumListList));
|
enumlistlist = (EnumListList *)malloc(sizeof(EnumListList));
|
InitializeEnumListList(enumlistlist);
|
InitializeEnumListList(enumlistlist);
|
|
|
translate=1;
|
translate=1;
|
|
|
yyparse();
|
yyparse();
|
|
|
printf("module %s(",module_name);
|
printf("module %s(",module_name);
|
EnumeratePorts(portlist);
|
EnumeratePorts(portlist);
|
printf(");\n");
|
printf(");\n");
|
|
|
ShowPortList(portlist);
|
ShowPortList(portlist);
|
printf("\n");
|
printf("\n");
|
RegOutputs(portlist);
|
RegOutputs(portlist);
|
printf("\n");
|
printf("\n");
|
|
|
ShowEnumListList(enumlistlist);
|
ShowEnumListList(enumlistlist);
|
|
|
ReadWritesFile(writeslist, (char *)"file_writes.sc2v");
|
ReadWritesFile(writeslist, (char *)"file_writes.sc2v");
|
|
|
ShowSignalsList(signalslist, writeslist);
|
ShowSignalsList(signalslist, writeslist);
|
printf("\n");
|
printf("\n");
|
|
|
ShowInstancedModules(instanceslist);
|
ShowInstancedModules(instanceslist);
|
printf("\n");
|
printf("\n");
|
|
|
ShowDefines((char *)"file_defines.sc2v");
|
ShowDefines((char *)"file_defines.sc2v");
|
|
|
ShowProcessCode(processlist);
|
ShowProcessCode(processlist);
|
printf("\n");
|
printf("\n");
|
|
|
printf("endmodule\n");
|
printf("endmodule\n");
|
}
|
}
|
|
|
%}
|
%}
|
|
|
%token NUMBER SC_MODULE WORD OPENPAR CLOSEPAR SC_IN SC_OUT SEMICOLON BOOL ENUM
|
%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 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 SENSIBLE CLOSEKEY OPENKEY SEMICOLON COLON SC_SIGNAL ARROW EQUALS NEW QUOTE
|
%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF
|
%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF
|
|
|
%%
|
%%
|
|
|
commands: /* empty */
|
commands: /* empty */
|
| commands command
|
| commands command
|
;
|
;
|
|
|
|
|
command:
|
command:
|
module
|
module
|
|
|
|
|
in_bool
|
in_bool
|
|
|
|
|
in_sc_int
|
in_sc_int
|
|
|
|
|
in_sc_uint
|
in_sc_uint
|
|
|
|
|
out_bool
|
out_bool
|
|
|
|
|
out_sc_int
|
out_sc_int
|
|
|
|
|
out_sc_uint
|
out_sc_uint
|
|
|
|
|
sc_method
|
sc_method
|
|
|
|
|
sensitive_pos
|
sensitive_pos
|
|
|
|
|
sensitive_neg
|
sensitive_neg
|
|
|
|
|
sensitive
|
sensitive
|
|
|
|
|
sensible_word_colon
|
sensible_word_colon
|
|
|
|
|
sensible_word_semicolon
|
sensible_word_semicolon
|
|
|
|
|
sensible_par_colon
|
sensible_par_colon
|
|
|
|
|
sensible_par_pos
|
sensible_par_pos
|
|
|
|
|
sensible_par_neg
|
sensible_par_neg
|
|
|
|
|
closekey
|
closekey
|
|
|
|
|
word_semicolon
|
word_semicolon
|
|
|
|
|
word_colon
|
word_colon
|
|
|
|
|
word_closekey
|
word_closekey
|
|
|
|
|
word_closekey_word
|
word_closekey_word
|
|
|
|
|
signal_bool
|
signal_bool
|
|
|
|
|
signal_uint
|
signal_uint
|
|
|
|
|
signal_int
|
signal_int
|
|
|
|
|
instantation
|
instantation
|
|
|
|
|
port_binding
|
port_binding
|
|
|
|
|
sc_ctor
|
sc_ctor
|
|
|
|
|
void
|
void
|
|
|
|
|
inst_decl
|
inst_decl
|
|
|
|
|
closekey_semicolon
|
closekey_semicolon
|
|
|
|
|
enumerates
|
enumerates
|
|
|
|
|
enumerates_type
|
enumerates_type
|
|
|
|
|
declaration
|
declaration
|
|
|
|
|
declaration_sc_signal
|
declaration_sc_signal
|
|
|
|
|
multiple_declaration
|
multiple_declaration
|
|
|
|
|
multiple_sc_signal_declaration
|
multiple_sc_signal_declaration
|
|
|
|
|
translateoff
|
translateoff
|
|
|
|
|
translateon
|
translateon
|
;
|
;
|
|
|
module:
|
module:
|
SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
|
SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
if(module_name_found)
|
if(module_name_found)
|
{
|
{
|
fprintf(stderr,"error: two or more modules found in the file\n");
|
fprintf(stderr,"error: two or more modules found in the file\n");
|
exit(1);
|
exit(1);
|
}
|
}
|
else
|
else
|
{
|
{
|
module_name = (char *)malloc(256*sizeof(char));
|
module_name = (char *)malloc(256*sizeof(char));
|
strcpy(module_name, (char *)$3);
|
strcpy(module_name, (char *)$3);
|
module_name_found = 1;
|
module_name_found = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
;
|
;
|
|
|
in_sc_uint:
|
in_sc_uint:
|
SC_IN MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
|
SC_IN MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
activeport = 1;
|
activeport = 1;
|
lastportsize = $5;
|
lastportsize = $5;
|
lastportkind = (char *)"input";
|
lastportkind = (char *)"input";
|
}
|
}
|
};
|
};
|
|
|
in_sc_int:
|
in_sc_int:
|
SC_IN MENOR SC_INT MENOR NUMBER MAYOR MAYOR
|
SC_IN MENOR SC_INT MENOR NUMBER MAYOR MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
activeport = 1;
|
activeport = 1;
|
lastportsize = $5;
|
lastportsize = $5;
|
lastportkind = (char *)"input";
|
lastportkind = (char *)"input";
|
}
|
}
|
};
|
};
|
|
|
|
|
in_bool:
|
in_bool:
|
SC_IN MENOR BOOL MAYOR
|
SC_IN MENOR BOOL MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
activeport = 1;
|
activeport = 1;
|
lastportsize = 0;
|
lastportsize = 0;
|
lastportkind = (char *)"input";
|
lastportkind = (char *)"input";
|
}
|
}
|
};
|
};
|
|
|
signal_bool:
|
signal_bool:
|
SC_SIGNAL MENOR BOOL MAYOR
|
SC_SIGNAL MENOR BOOL MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
signalactive = 1;
|
signalactive = 1;
|
lastsignalsize = 0;
|
lastsignalsize = 0;
|
}
|
}
|
};
|
};
|
|
|
signal_uint:
|
signal_uint:
|
SC_SIGNAL MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
|
SC_SIGNAL MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
signalactive = 1;
|
signalactive = 1;
|
lastsignalsize = $5;
|
lastsignalsize = $5;
|
}
|
}
|
};
|
};
|
|
|
signal_int:
|
signal_int:
|
SC_SIGNAL MENOR SC_INT MENOR NUMBER MAYOR MAYOR
|
SC_SIGNAL MENOR SC_INT MENOR NUMBER MAYOR MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
signalactive = 1;
|
signalactive = 1;
|
lastsignalsize = $5;
|
lastsignalsize = $5;
|
}
|
}
|
};
|
};
|
|
|
out_bool:
|
out_bool:
|
SC_OUT MENOR BOOL MAYOR
|
SC_OUT MENOR BOOL MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
activeport = 1;
|
activeport = 1;
|
lastportsize = 0;
|
lastportsize = 0;
|
lastportkind = (char *)"output";
|
lastportkind = (char *)"output";
|
}
|
}
|
};
|
};
|
|
|
out_sc_uint:
|
out_sc_uint:
|
SC_OUT MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
|
SC_OUT MENOR SC_UINT MENOR NUMBER MAYOR MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
activeport = 1;
|
activeport = 1;
|
lastportsize = $5;
|
lastportsize = $5;
|
lastportkind = (char *)"output";
|
lastportkind = (char *)"output";
|
}
|
}
|
};
|
};
|
|
|
out_sc_int:
|
out_sc_int:
|
SC_OUT MENOR SC_INT MENOR NUMBER MAYOR MAYOR
|
SC_OUT MENOR SC_INT MENOR NUMBER MAYOR MAYOR
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
activeport = 1;
|
activeport = 1;
|
lastportsize = $5;
|
lastportsize = $5;
|
lastportkind = (char *)"output";
|
lastportkind = (char *)"output";
|
}
|
}
|
};
|
};
|
|
|
sc_method:
|
sc_method:
|
SC_METHOD OPENPAR WORD CLOSEPAR SEMICOLON
|
SC_METHOD OPENPAR WORD CLOSEPAR SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
if(method_found)
|
if(method_found)
|
{
|
{
|
InsertProcess(processlist, active_method, sensibilitylist, active_method_type);
|
InsertProcess(processlist, active_method, sensibilitylist, active_method_type);
|
}
|
}
|
active_method = (char *)$3;
|
active_method = (char *)$3;
|
method_found = 1;
|
method_found = 1;
|
/* New sensitivity list */
|
/* New sensitivity list */
|
sensibilitylist = (SensibilityList *)malloc(sizeof(SensibilityList));
|
sensibilitylist = (SensibilityList *)malloc(sizeof(SensibilityList));
|
InitializeSensibilityList(sensibilitylist);
|
InitializeSensibilityList(sensibilitylist);
|
}
|
}
|
};
|
};
|
|
|
sensible_par_neg:
|
sensible_par_neg:
|
SENSITIVE_NEG OPENPAR WORD CLOSEPAR SEMICOLON
|
SENSITIVE_NEG OPENPAR WORD CLOSEPAR SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
active_method_type = (char *)"seq"; //comb
|
active_method_type = (char *)"seq"; //comb
|
InsertSensibility(sensibilitylist, (char *)$3, "negedge");
|
InsertSensibility(sensibilitylist, (char *)$3, "negedge");
|
}
|
}
|
};
|
};
|
|
|
sensible_par_pos:
|
sensible_par_pos:
|
SENSITIVE_POS OPENPAR WORD CLOSEPAR SEMICOLON
|
SENSITIVE_POS OPENPAR WORD CLOSEPAR SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
active_method_type = (char *)"seq"; //comb
|
active_method_type = (char *)"seq"; //comb
|
InsertSensibility(sensibilitylist, (char *)$3, "posedge");
|
InsertSensibility(sensibilitylist, (char *)$3, "posedge");
|
}
|
}
|
};
|
};
|
|
|
sensitive_pos:
|
sensitive_pos:
|
SENSITIVE_POS
|
SENSITIVE_POS
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
last_sensibility = (char *)"posedge";
|
last_sensibility = (char *)"posedge";
|
active_method_type = (char *)"seq"; //seq
|
active_method_type = (char *)"seq"; //seq
|
sensibility_active = 1;
|
sensibility_active = 1;
|
}
|
}
|
};
|
};
|
|
|
sensitive_neg:
|
sensitive_neg:
|
SENSITIVE_NEG
|
SENSITIVE_NEG
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
last_sensibility = (char *)"negedge";
|
last_sensibility = (char *)"negedge";
|
active_method_type = (char *)"seq"; //seq
|
active_method_type = (char *)"seq"; //seq
|
sensibility_active = 1;
|
sensibility_active = 1;
|
}
|
}
|
};
|
};
|
|
|
sensitive:
|
sensitive:
|
SENSITIVE
|
SENSITIVE
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
last_sensibility = (char *)" ";
|
last_sensibility = (char *)" ";
|
active_method_type = (char *)"comb"; //comb
|
active_method_type = (char *)"comb"; //comb
|
sensibility_active = 1;
|
sensibility_active = 1;
|
}
|
}
|
};
|
};
|
|
|
sensible_par_colon:
|
sensible_par_colon:
|
SENSITIVE OPENPAR WORD CLOSEPAR SEMICOLON
|
SENSITIVE OPENPAR WORD CLOSEPAR SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
active_method_type = (char *)"comb"; //comb
|
active_method_type = (char *)"comb"; //comb
|
InsertSensibility(sensibilitylist, (char *)$3, " ");
|
InsertSensibility(sensibilitylist, (char *)$3, " ");
|
}
|
}
|
};
|
};
|
|
|
|
|
sensible_word_colon:
|
sensible_word_colon:
|
SENSIBLE WORD
|
SENSIBLE WORD
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
|
InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
|
}
|
}
|
};
|
};
|
|
|
sensible_word_semicolon:
|
sensible_word_semicolon:
|
SENSIBLE WORD SEMICOLON
|
SENSIBLE WORD SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
|
InsertSensibility(sensibilitylist, (char *)$2, (char *)last_sensibility);
|
if(sensibility_active)
|
if(sensibility_active)
|
{
|
{
|
sensibility_active = 0;
|
sensibility_active = 0;
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
closekey:
|
closekey:
|
CLOSEKEY
|
CLOSEKEY
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
if(method_found)
|
if(method_found)
|
{
|
{
|
method_found = 0;
|
method_found = 0;
|
InsertProcess(processlist, active_method, sensibilitylist, active_method_type);
|
InsertProcess(processlist, active_method, sensibilitylist, active_method_type);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
word_semicolon:
|
word_semicolon:
|
WORD SEMICOLON
|
WORD SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
if(activeport)
|
if(activeport)
|
{
|
{
|
InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
|
InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
|
activeport = 0;
|
activeport = 0;
|
}
|
}
|
else if(signalactive)
|
else if(signalactive)
|
{
|
{
|
InsertSignal(signalslist, (char *)$1, lastsignalsize);
|
InsertSignal(signalslist, (char *)$1, lastsignalsize);
|
signalactive = 0;
|
signalactive = 0;
|
}else if(multipledec){
|
}else if(multipledec){
|
int length,list_pos;
|
int length,list_pos;
|
length=0;
|
length=0;
|
list_pos=0;
|
list_pos=0;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
list_pos=findEnumList(enumlistlist, storedtype);
|
list_pos=findEnumList(enumlistlist, storedtype);
|
if(list_pos>-1){
|
if(list_pos>-1){
|
//Calculate the number of bits needed to represent the enumerate
|
//Calculate the number of bits needed to represent the enumerate
|
length=findEnumerateLength(enumlistlist,list_pos);
|
length=findEnumerateLength(enumlistlist,list_pos);
|
|
|
InsertSignal(signalslist, (char *)$1,length);
|
InsertSignal(signalslist, (char *)$1,length);
|
InsertWrite(writeslist,(char *)$1);
|
InsertWrite(writeslist,(char *)$1);
|
free(storedtype);
|
free(storedtype);
|
multipledec=0;
|
multipledec=0;
|
}else{
|
}else{
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
return(1);
|
return(1);
|
}
|
}
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
word_colon:
|
word_colon:
|
WORD COLON
|
WORD COLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
if(activeport)
|
if(activeport)
|
{
|
{
|
InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
|
InsertPort(portlist, (char *)$1, lastportkind, lastportsize);
|
}
|
}
|
else if(signalactive)
|
else if(signalactive)
|
{
|
{
|
InsertSignal(signalslist, (char *)$1, lastsignalsize);
|
InsertSignal(signalslist, (char *)$1, lastsignalsize);
|
}
|
}
|
else if(reading_enumerates)
|
else if(reading_enumerates)
|
{
|
{
|
InsertEnumerates(enumerateslist, (char *)$1);
|
InsertEnumerates(enumerateslist, (char *)$1);
|
|
|
}else if(multipledec){
|
}else if(multipledec){
|
int length,list_pos;
|
int length,list_pos;
|
length=0;
|
length=0;
|
list_pos=0;
|
list_pos=0;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
list_pos=findEnumList(enumlistlist, storedtype);
|
list_pos=findEnumList(enumlistlist, storedtype);
|
if(list_pos>-1){
|
if(list_pos>-1){
|
//Calculate the number of bits needed to represent the enumerate
|
//Calculate the number of bits needed to represent the enumerate
|
length=findEnumerateLength(enumlistlist,list_pos);
|
length=findEnumerateLength(enumlistlist,list_pos);
|
|
|
InsertSignal(signalslist, (char *)$1,length);
|
InsertSignal(signalslist, (char *)$1,length);
|
InsertWrite(writeslist,(char *)$1);
|
InsertWrite(writeslist,(char *)$1);
|
multipledec=1;
|
multipledec=1;
|
}else{
|
}else{
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
return(1);
|
return(1);
|
}
|
}
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
word_closekey_word:
|
word_closekey_word:
|
WORD CLOSEKEY WORD SEMICOLON
|
WORD CLOSEKEY WORD SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
//Finish enumerate var declaration
|
//Finish enumerate var declaration
|
if(reading_enumerates)
|
if(reading_enumerates)
|
{
|
{
|
InsertEnumerates(enumerateslist, (char *)$1);
|
InsertEnumerates(enumerateslist, (char *)$1);
|
InsertEnumList(enumlistlist,enumerateslist,(char *)$4,0); //Insert also the variable name
|
InsertEnumList(enumlistlist,enumerateslist,(char *)$4,0); //Insert also the variable name
|
reading_enumerates=0;
|
reading_enumerates=0;
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
word_closekey:
|
word_closekey:
|
WORD CLOSEKEY SEMICOLON
|
WORD CLOSEKEY SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
//Finish enumerate type declaration
|
//Finish enumerate type declaration
|
if(reading_enumerates)
|
if(reading_enumerates)
|
{
|
{
|
InsertEnumerates(enumerateslist, (char *)$1);
|
InsertEnumerates(enumerateslist, (char *)$1);
|
InsertEnumList(enumlistlist,enumerateslist,enumname,1); //Insert also the variable name
|
InsertEnumList(enumlistlist,enumerateslist,enumname,1); //Insert also the variable name
|
free(enumname);
|
|
reading_enumerates=0;
|
reading_enumerates=0;
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
|
|
instantation:
|
instantation:
|
WORD EQUALS NEW WORD OPENPAR QUOTE WORD QUOTE CLOSEPAR SEMICOLON
|
WORD EQUALS NEW WORD OPENPAR QUOTE WORD QUOTE CLOSEPAR SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
InsertInstance(instanceslist, (char *)$1, (char *)$4);
|
InsertInstance(instanceslist, (char *)$1, (char *)$4);
|
}
|
}
|
};
|
};
|
|
|
port_binding:
|
port_binding:
|
WORD ARROW WORD OPENPAR WORD CLOSEPAR SEMICOLON
|
WORD ARROW WORD OPENPAR WORD CLOSEPAR SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
if(instanceslist->last == NULL)
|
if(instanceslist->last == NULL)
|
{
|
{
|
fprintf(stderr,"error: no instances found\n");
|
fprintf(stderr,"error: no instances found\n");
|
}
|
}
|
else
|
else
|
{
|
{
|
InstanceNode *aux;
|
InstanceNode *aux;
|
aux = instanceslist->first;
|
aux = instanceslist->first;
|
while(1)
|
while(1)
|
{
|
{
|
if(strcmp(aux->nameinstance, (char *)$1) == 0)
|
if(strcmp(aux->nameinstance, (char *)$1) == 0)
|
{
|
{
|
break;
|
break;
|
}
|
}
|
else
|
else
|
{
|
{
|
if(aux->next == NULL)
|
if(aux->next == NULL)
|
{
|
{
|
fprintf(stderr,"error: instance %s not found\n",$1);
|
fprintf(stderr,"error: instance %s not found\n",$1);
|
exit(1);
|
exit(1);
|
}
|
}
|
else
|
else
|
{
|
{
|
aux = aux->next;
|
aux = aux->next;
|
}
|
}
|
}
|
}
|
}
|
}
|
InsertBind(aux->bindslist, (char *)$3, (char *)$5);
|
InsertBind(aux->bindslist, (char *)$3, (char *)$5);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
sc_ctor:
|
sc_ctor:
|
SC_CTOR OPENPAR WORD CLOSEPAR OPENKEY
|
SC_CTOR OPENPAR WORD CLOSEPAR OPENKEY
|
{
|
{
|
|
|
};
|
};
|
|
|
void:
|
void:
|
VOID WORD OPENPAR CLOSEPAR SEMICOLON
|
VOID WORD OPENPAR CLOSEPAR SEMICOLON
|
{
|
{
|
|
|
};
|
};
|
|
|
inst_decl:
|
inst_decl:
|
WORD ASTERISCO WORD SEMICOLON
|
WORD ASTERISCO WORD SEMICOLON
|
{
|
{
|
|
|
};
|
};
|
|
|
closekey_semicolon: CLOSEKEY SEMICOLON
|
closekey_semicolon: CLOSEKEY SEMICOLON
|
{
|
{
|
|
|
};
|
};
|
|
|
enumerates:
|
enumerates:
|
ENUM OPENKEY
|
ENUM OPENKEY
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
//New enumerate list
|
//New enumerate list
|
enumerateslist = (EnumeratesList *)malloc(sizeof(EnumeratesList));
|
enumerateslist = (EnumeratesList *)malloc(sizeof(EnumeratesList));
|
InitializeEnumeratesList(enumerateslist);
|
InitializeEnumeratesList(enumerateslist);
|
reading_enumerates=1;
|
reading_enumerates=1;
|
}
|
}
|
};
|
};
|
|
|
enumerates_type:
|
enumerates_type:
|
ENUM WORD OPENKEY
|
ENUM WORD OPENKEY
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
//In this case we define type e.g. enum state_t {S0,S1,S2};
|
//In this case we define type e.g. enum state_t {S0,S1,S2};
|
enumerateslist = (EnumeratesList *)malloc(sizeof(EnumeratesList));
|
enumerateslist = (EnumeratesList *)malloc(sizeof(EnumeratesList));
|
InitializeEnumeratesList(enumerateslist);
|
InitializeEnumeratesList(enumerateslist);
|
enumname=malloc(sizeof(char)*strlen((char *)$2));
|
enumname=malloc(sizeof(char)*strlen((char *)$2));
|
strcpy(enumname,(char *)$2);
|
strcpy(enumname,(char *)$2);
|
reading_enumerates=1;
|
reading_enumerates=1;
|
}
|
}
|
};
|
};
|
|
|
declaration:
|
declaration:
|
WORD WORD SEMICOLON
|
WORD WORD SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
int length,list_pos;
|
int length,list_pos;
|
length=0;
|
length=0;
|
list_pos=0;
|
list_pos=0;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
list_pos=findEnumList(enumlistlist, (char *)$1);
|
list_pos=findEnumList(enumlistlist, (char *)$1);
|
if(list_pos>-1){
|
if(list_pos>-1){
|
//Calculate the number of bits needed to represent the enumerate
|
//Calculate the number of bits needed to represent the enumerate
|
length=findEnumerateLength(enumlistlist,list_pos);
|
length=findEnumerateLength(enumlistlist,list_pos);
|
|
|
InsertSignal(signalslist, (char *)$2,length);
|
InsertSignal(signalslist, (char *)$2,length);
|
InsertWrite(writeslist,(char *)$2);
|
InsertWrite(writeslist,(char *)$2);
|
}else{
|
}else{
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
return(1);
|
return(1);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
declaration_sc_signal:
|
declaration_sc_signal:
|
SC_SIGNAL MENOR WORD MAYOR WORD SEMICOLON
|
SC_SIGNAL MENOR WORD MAYOR WORD SEMICOLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
int length,list_pos;
|
int length,list_pos;
|
length=0;
|
length=0;
|
list_pos=0;
|
list_pos=0;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
list_pos=findEnumList(enumlistlist, (char *)$3);
|
list_pos=findEnumList(enumlistlist, (char *)$3);
|
if(list_pos>-1){
|
if(list_pos>-1){
|
//Calculate the number of bits needed to represent the enumerate
|
//Calculate the number of bits needed to represent the enumerate
|
length=findEnumerateLength(enumlistlist,list_pos);
|
length=findEnumerateLength(enumlistlist,list_pos);
|
|
|
InsertSignal(signalslist, (char *)$5,length);
|
InsertSignal(signalslist, (char *)$5,length);
|
InsertWrite(writeslist,(char *)$5);
|
InsertWrite(writeslist,(char *)$5);
|
}else{
|
}else{
|
fprintf(stderr,"\nType %s unknow\n",(char *)$3);
|
fprintf(stderr,"\nType %s unknow\n",(char *)$3);
|
return(1);
|
return(1);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
multiple_declaration:
|
multiple_declaration:
|
WORD WORD COLON
|
WORD WORD COLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
int length,list_pos;
|
int length,list_pos;
|
length=0;
|
length=0;
|
list_pos=0;
|
list_pos=0;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
list_pos=findEnumList(enumlistlist, (char *)$1);
|
list_pos=findEnumList(enumlistlist, (char *)$1);
|
if(list_pos>-1){
|
if(list_pos>-1){
|
//Calculate the number of bits needed to represent the enumerate
|
//Calculate the number of bits needed to represent the enumerate
|
length=findEnumerateLength(enumlistlist,list_pos);
|
length=findEnumerateLength(enumlistlist,list_pos);
|
storedtype=malloc(sizeof(char)*strlen((char *)$1));
|
storedtype=malloc(sizeof(char)*strlen((char *)$1));
|
strcpy(storedtype,(char *)$1);
|
strcpy(storedtype,(char *)$1);
|
InsertSignal(signalslist, (char *)$2,length);
|
InsertSignal(signalslist, (char *)$2,length);
|
InsertWrite(writeslist,(char *)$2);
|
InsertWrite(writeslist,(char *)$2);
|
multipledec=1;
|
multipledec=1;
|
}else{
|
}else{
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
fprintf(stderr,"\nType %s unknow\n",(char *)$1);
|
return(1);
|
return(1);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
multiple_sc_signal_declaration:
|
multiple_sc_signal_declaration:
|
SC_SIGNAL MENOR WORD MAYOR WORD COLON
|
SC_SIGNAL MENOR WORD MAYOR WORD COLON
|
{
|
{
|
if(translate==1){
|
if(translate==1){
|
int length,list_pos;
|
int length,list_pos;
|
length=0;
|
length=0;
|
list_pos=0;
|
list_pos=0;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
//Look in the enumerated list if it was declared e.j state_t state;
|
list_pos=findEnumList(enumlistlist, (char *)$3);
|
list_pos=findEnumList(enumlistlist, (char *)$3);
|
if(list_pos>-1){
|
if(list_pos>-1){
|
//Calculate the number of bits needed to represent the enumerate
|
//Calculate the number of bits needed to represent the enumerate
|
length=findEnumerateLength(enumlistlist,list_pos);
|
length=findEnumerateLength(enumlistlist,list_pos);
|
storedtype=malloc(sizeof(char)*strlen((char *)$3));
|
storedtype=malloc(sizeof(char)*strlen((char *)$3));
|
strcpy(storedtype,(char *)$3);
|
strcpy(storedtype,(char *)$3);
|
InsertSignal(signalslist, (char *)$5,length);
|
InsertSignal(signalslist, (char *)$5,length);
|
InsertWrite(writeslist,(char *)$5);
|
InsertWrite(writeslist,(char *)$5);
|
multipledec=1;
|
multipledec=1;
|
}else{
|
}else{
|
fprintf(stderr,"\nType %s unknow\n",(char *)$3);
|
fprintf(stderr,"\nType %s unknow\n",(char *)$3);
|
return(1);
|
return(1);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
translateoff:
|
translateoff:
|
TRANSLATEOFF
|
TRANSLATEOFF
|
{
|
{
|
translate=0;
|
translate=0;
|
fprintf(stderr,"Found Translate off directive \n");
|
fprintf(stderr,"Found Translate off directive \n");
|
};
|
};
|
|
|
translateon:
|
translateon:
|
TRANSLATEON
|
TRANSLATEON
|
{
|
{
|
translate=1;
|
translate=1;
|
fprintf(stderr,"Found Translate on directive \n");
|
fprintf(stderr,"Found Translate on directive \n");
|
};
|
};
|
|
|
