| Line 1... |
Line 1... |
/* -----------------------------------------------------------------------------
|
/* -----------------------------------------------------------------------------
|
*
|
*
|
* SystemC to Verilog Translator v0.1
|
* SystemC to Verilog Translator v0.2
|
* Provided by OpenSoc Design
|
* Provided by OpenSoc Design
|
*
|
*
|
* www.opensocdesign.com
|
* www.opensocdesign.com
|
*
|
*
|
* -----------------------------------------------------------------------------
|
* -----------------------------------------------------------------------------
|
| Line 22... |
Line 22... |
*/
|
*/
|
|
|
%{
|
%{
|
#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*/
|
| Line 44... |
Line 45... |
InstancesList *instanceslist;
|
InstancesList *instanceslist;
|
|
|
/* Global var to store process list*/
|
/* Global var to store process list*/
|
ProcessList *processlist;
|
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*/
|
/* Global var to store process module name*/
|
char *module_name;
|
char *module_name;
|
int module_name_found = 0;
|
int module_name_found = 0;
|
|
|
| Line 68... |
Line 78... |
/* 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;
|
|
|
|
|
void yyerror(const char *str)
|
void yyerror(const char *str)
|
{
|
{
|
fprintf(stderr,"error: %s\n",str);
|
fprintf(stderr,"error: %s\n",str);
|
}
|
}
|
| Line 83... |
Line 92... |
return 1;
|
return 1;
|
}
|
}
|
|
|
main()
|
main()
|
{
|
{
|
|
/*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));
|
|
InitializeEnumListList(enumlistlist);
|
|
|
|
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);
|
|
|
ReadWritesFile(writeslist, (char *)"file_writes.sc2v");
|
ReadWritesFile(writeslist, (char *)"file_writes.sc2v");
|
|
|
ShowSignalsList(signalslist, writeslist);
|
ShowSignalsList(signalslist, writeslist);
|
printf("\n");
|
printf("\n");
|
|
|
| Line 125... |
Line 148... |
printf("endmodule\n");
|
printf("endmodule\n");
|
}
|
}
|
|
|
%}
|
%}
|
|
|
%token NUMBER SC_MODULE WORD OPENPAR CLOSEPAR SC_IN SC_OUT SEMICOLON BOOL
|
%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
|
%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF
|
|
|
%%
|
%%
|
|
|
commands: /* empty */
|
commands: /* empty */
|
| commands command
|
| commands command
|
| Line 164... |
Line 187... |
|
|
|
|
sensible_word_colon
|
sensible_word_colon
|
|
|
|
|
sensible_word_semicolon
|
sensible_word_semicolon
|
|
|
|
|
|
sensible_par_colon
|
|
|
|
|
sensible_par_pos
|
|
|
|
|
sensible_par_neg
|
|
|
|
closekey
|
closekey
|
|
|
|
|
word_semicolon
|
word_semicolon
|
|
|
|
|
word_colon
|
word_colon
|
|
|
|
|
|
word_closekey
|
|
|
|
|
word_closekey_word
|
|
|
|
signal_bool
|
signal_bool
|
|
|
|
|
signal_uint
|
signal_uint
|
|
|
|
|
signal_int
|
signal_int
|
| Line 187... |
Line 220... |
void
|
void
|
|
|
|
|
inst_decl
|
inst_decl
|
|
|
|
|
closekey_semicolon
|
closekey_semicolon
|
|
|
|
|
enumerates
|
|
|
|
|
enumerates_type
|
|
|
|
|
declaration
|
|
|
|
|
declaration_sc_signal
|
|
|
|
|
multiple_declaration
|
|
|
|
|
multiple_sc_signal_declaration
|
|
|
|
|
translateoff
|
|
|
|
|
translateon
|
;
|
;
|
|
|
module:
|
module:
|
SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
|
SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
|
{
|
{
|
|
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);
|
}
|
}
|
| Line 204... |
Line 254... |
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){
|
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){
|
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){
|
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){
|
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){
|
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){
|
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){
|
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){
|
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){
|
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(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:
|
|
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:
|
SENSITIVE_POS
|
SENSITIVE_POS
|
{
|
{
|
|
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){
|
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){
|
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:
|
|
SENSITIVE OPENPAR WORD CLOSEPAR SEMICOLON
|
|
{
|
|
if(translate==1){
|
|
active_method_type = (char *)"comb"; //comb
|
|
InsertSensibility(sensibilitylist, (char *)$3, " ");
|
|
}
|
|
};
|
|
|
|
|
sensible_word_colon:
|
sensible_word_colon:
|
SENSIBLE WORD
|
SENSIBLE WORD
|
{
|
{
|
|
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){
|
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(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(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){
|
|
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:
|
WORD COLON
|
WORD COLON
|
{
|
{
|
|
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)
|
|
{
|
|
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
|
|
free(enumname);
|
|
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){
|
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(instanceslist->last == NULL)
|
if(instanceslist->last == NULL)
|
{
|
{
|
fprintf(stderr,"error: no instances found\n");
|
fprintf(stderr,"error: no instances found\n");
|
}
|
}
|
else
|
else
|
| Line 422... |
Line 595... |
}
|
}
|
}
|
}
|
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:
|
|
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");
|
|
};
|
