/* -----------------------------------------------------------------------------
|
/* -----------------------------------------------------------------------------
|
*
|
*
|
* SystemC to Verilog Translator v0.4
|
* SystemC to Verilog Translator v0.4
|
* 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 "sc2v_step2.h"
|
#include "sc2v_step2.h"
|
|
|
|
|
char *enumname;
|
char *enumname;
|
|
|
int reading_enumerates = 0;
|
int reading_enumerates = 0;
|
int lineno = 1;
|
int lineno = 1;
|
|
|
/*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;
|
|
|
/* Global var to store last function found*/
|
/* Global var to store last function found*/
|
char *functionname;
|
char *functionname;
|
int outputlenght = 0;
|
int outputlenght = 0;
|
|
|
int translate;
|
int translate;
|
|
|
|
|
void yyerror (const char *str)
|
void yyerror (const char *str)
|
{
|
{
|
fprintf (stderr, "line: %d error: %s\n", lineno, str);
|
fprintf (stderr, "line: %d error: %s\n", lineno, str);
|
}
|
}
|
|
|
int yywrap ()
|
int yywrap ()
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
main ()
|
main ()
|
{
|
{
|
|
|
/*Initialize lists */
|
/*Initialize lists */
|
writeslist = NULL;
|
writeslist = NULL;
|
portlist = NULL;;
|
portlist = NULL;;
|
signalslist = NULL;
|
signalslist = NULL;
|
sensibilitylist = NULL;
|
sensibilitylist = NULL;
|
processlist = NULL;
|
processlist = NULL;
|
instanceslist = NULL;
|
instanceslist = NULL;
|
enumlistlist = NULL;
|
enumlistlist = NULL;
|
funcinputslist = NULL;
|
funcinputslist = NULL;
|
functionslist = NULL;
|
functionslist = NULL;
|
|
|
translate = 1;
|
translate = 1;
|
|
|
fprintf (stderr, "\nSystemC to Verilog Translator v0.4\n\n");
|
fprintf (stderr, "\nSystemC to Verilog Translator v0.4\n\n");
|
fprintf (stderr, "Parsing header file.......\n\n");
|
fprintf (stderr, "Parsing header file.......\n\n");
|
|
|
FILE *yyin = stdin;
|
FILE *yyin = stdin;
|
FILE *yyout = stdout;
|
FILE *yyout = stdout;
|
|
|
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,instanceslist);
|
RegOutputs (portlist,instanceslist);
|
printf ("\n");
|
printf ("\n");
|
|
|
ShowEnumListList (enumlistlist);
|
ShowEnumListList (enumlistlist);
|
|
|
writeslist = ReadWritesFile (writeslist, (char *) "file_writes.sc2v");
|
writeslist = 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");
|
|
|
ShowFunctionCode (functionslist);
|
ShowFunctionCode (functionslist);
|
|
|
ShowProcessCode (processlist);
|
ShowProcessCode (processlist);
|
printf ("\n");
|
printf ("\n");
|
|
|
printf ("endmodule\n");
|
printf ("endmodule\n");
|
|
|
fprintf (stderr, "\nDone\n");
|
fprintf (stderr, "\nDone\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_REG SC_METHOD SENSITIVE_POS SENSITIVE_NEG SENSITIVE
|
%token MENOR MAYOR SC_REG 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 OPENCORCH CLOSECORCH
|
%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF OPENCORCH CLOSECORCH
|
|
|
%% commands: /* empty */
|
%% commands: /* empty */
|
|commands command;
|
|commands command;
|
|
|
command:
|
command:
|
module
|
module
|
|
|
|
|
in_bool
|
in_bool
|
|
|
|
|
in_sc_reg
|
in_sc_reg
|
|
|
|
|
out_bool
|
out_bool
|
|
|
|
|
out_sc_reg
|
out_sc_reg
|
|
|
|
|
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_reg
|
signal_reg
|
|
|
|
|
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
|
|
|
|
|
function
|
function
|
|
|
|
|
functioninputs
|
functioninputs
|
|
|
|
|
finishfunctioninputs
|
finishfunctioninputs
|
|
|
|
|
boolfunction
|
boolfunction
|
|
|
|
|
boolfunctioninputs
|
boolfunctioninputs
|
|
|
|
|
arraycolon
|
arraycolon
|
|
|
|
|
arraysemicolon
|
arraysemicolon
|
|
|
|
|
boolfinishfunctioninputs;
|
boolfinishfunctioninputs;
|
|
|
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,
|
fprintf (stderr,
|
"line: %d error: two or more modules found in the file\n",
|
"line: %d error: two or more modules found in the file\n",
|
lineno);
|
lineno);
|
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_reg:
|
in_sc_reg:
|
SC_IN MENOR SC_REG MENOR NUMBER MAYOR MAYOR
|
SC_IN MENOR SC_REG 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_reg:
|
signal_reg:
|
SC_SIGNAL MENOR SC_REG MENOR NUMBER MAYOR MAYOR
|
SC_SIGNAL MENOR SC_REG 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_reg:
|
out_sc_reg:
|
SC_OUT MENOR SC_REG MENOR NUMBER MAYOR MAYOR
|
SC_OUT MENOR SC_REG 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)
|
{
|
{
|
processlist =
|
processlist =
|
InsertProcess (processlist, active_method, sensibilitylist,
|
InsertProcess (processlist, active_method, sensibilitylist,
|
active_method_type);
|
active_method_type);
|
}
|
}
|
active_method = (char *) $3;
|
active_method = (char *) $3;
|
method_found = 1;
|
method_found = 1;
|
/* New sensitivity list */
|
/* New sensitivity list */
|
sensibilitylist = NULL;
|
sensibilitylist = NULL;
|
}
|
}
|
};
|
};
|
|
|
|
|
|
|
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
|
sensibilitylist =
|
sensibilitylist =
|
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
|
sensibilitylist =
|
sensibilitylist =
|
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
|
sensibilitylist = InsertSensibility (sensibilitylist, (char *) $3, " ");
|
sensibilitylist = InsertSensibility (sensibilitylist, (char *) $3, " ");
|
}
|
}
|
};
|
};
|
|
|
|
|
|
|
|
|
sensible_word_colon:
|
sensible_word_colon:
|
SENSIBLE WORD
|
SENSIBLE WORD
|
{
|
{
|
if (translate == 1)
|
if (translate == 1)
|
{
|
{
|
sensibilitylist =
|
sensibilitylist =
|
InsertSensibility (sensibilitylist, (char *) $2,
|
InsertSensibility (sensibilitylist, (char *) $2,
|
(char *) last_sensibility);
|
(char *) last_sensibility);
|
}
|
}
|
};
|
};
|
|
|
|
|
|
|
sensible_word_semicolon:
|
sensible_word_semicolon:
|
SENSIBLE WORD SEMICOLON
|
SENSIBLE WORD SEMICOLON
|
{
|
{
|
if (translate == 1)
|
if (translate == 1)
|
{
|
{
|
sensibilitylist =
|
sensibilitylist =
|
InsertSensibility (sensibilitylist, (char *) $2,
|
InsertSensibility (sensibilitylist, (char *) $2,
|
(char *) last_sensibility);
|
(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;
|
processlist =
|
processlist =
|
InsertProcess (processlist, active_method, sensibilitylist,
|
InsertProcess (processlist, active_method, sensibilitylist,
|
active_method_type);
|
active_method_type);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
arraysemicolon:
|
arraysemicolon:
|
WORD OPENCORCH NUMBER CLOSECORCH SEMICOLON
|
WORD OPENCORCH NUMBER CLOSECORCH SEMICOLON
|
{
|
{
|
if (signalactive)
|
if (signalactive)
|
{
|
{
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,$3);
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,$3);
|
signalactive = 0;
|
signalactive = 0;
|
}
|
}
|
}
|
}
|
|
|
arraycolon:
|
arraycolon:
|
WORD OPENCORCH NUMBER CLOSECORCH COLON
|
WORD OPENCORCH NUMBER CLOSECORCH COLON
|
{
|
{
|
if (signalactive)
|
if (signalactive)
|
{
|
{
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,$3);
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,$3);
|
signalactive = 0;
|
signalactive = 0;
|
}
|
}
|
}
|
}
|
|
|
word_semicolon:
|
word_semicolon:
|
WORD SEMICOLON
|
WORD SEMICOLON
|
{
|
{
|
if (translate == 1)
|
if (translate == 1)
|
{
|
{
|
if (activeport)
|
if (activeport)
|
{
|
{
|
portlist =
|
portlist =
|
InsertPort (portlist, (char *) $1, lastportkind, lastportsize);
|
InsertPort (portlist, (char *) $1, lastportkind, lastportsize);
|
activeport = 0;
|
activeport = 0;
|
}
|
}
|
else if (signalactive)
|
else if (signalactive)
|
{
|
{
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,0);
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,0);
|
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);
|
signalslist = InsertSignal (signalslist, (char *) $1, length, 0);
|
signalslist = InsertSignal (signalslist, (char *) $1, length, 0);
|
writeslist = InsertWrite (writeslist, (char *) $1);
|
writeslist = InsertWrite (writeslist, (char *) $1);
|
free (storedtype);
|
free (storedtype);
|
multipledec = 0;
|
multipledec = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
(char *) $1);
|
(char *) $1);
|
return (1);
|
return (1);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
};
|
};
|
|
|
|
|
word_colon:
|
word_colon:
|
WORD COLON
|
WORD COLON
|
{
|
{
|
|
|
if (translate == 1)
|
if (translate == 1)
|
{
|
{
|
if (activeport)
|
if (activeport)
|
{
|
{
|
portlist = InsertPort (portlist, (char *) $1, lastportkind, lastportsize);
|
portlist = InsertPort (portlist, (char *) $1, lastportkind, lastportsize);
|
}
|
}
|
else if (signalactive)
|
else if (signalactive)
|
{
|
{
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize, 0);
|
signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize, 0);
|
}
|
}
|
else if (reading_enumerates)
|
else if (reading_enumerates)
|
{
|
{
|
enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
|
enumerateslist = 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);
|
signalslist = InsertSignal (signalslist, (char *) $1, length, 0);
|
signalslist = InsertSignal (signalslist, (char *) $1, length, 0);
|
writeslist = InsertWrite (writeslist, (char *) $1);
|
writeslist = InsertWrite (writeslist, (char *) $1);
|
multipledec = 1;
|
multipledec = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
(char *) $1);
|
(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)
|
{
|
{
|
enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
|
enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
|
enumlistlist = InsertEnumList (enumlistlist, enumerateslist, (char *) $4, 0); //Insert also the variable name
|
enumlistlist = 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)
|
|
|
{
|
{
|
|
|
enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
|
enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
|
|
|
enumlistlist = InsertEnumList (enumlistlist, enumerateslist, enumname, 1); //Insert also the variable name
|
enumlistlist = InsertEnumList (enumlistlist, enumerateslist, enumname, 1); //Insert also the variable name
|
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)
|
{
|
{
|
instanceslist =
|
instanceslist =
|
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 == NULL)
|
if (instanceslist == NULL)
|
{
|
{
|
fprintf (stderr, "line: %d error: no instances found\n", lineno);
|
fprintf (stderr, "line: %d error: no instances found\n", lineno);
|
}
|
}
|
else
|
else
|
{
|
{
|
|
|
InstanceNode *ill;
|
InstanceNode *ill;
|
SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, instanceslist, ill, next,
|
SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, instanceslist, ill, next,
|
{
|
{
|
if (strcmp
|
if (strcmp
|
(ill->nameinstance,
|
(ill->nameinstance,
|
(char *) $1) == 0)
|
(char *) $1) == 0)
|
{
|
{
|
ill->bindslist =
|
ill->bindslist =
|
InsertBind (ill->bindslist, (char *) $3,
|
InsertBind (ill->bindslist, (char *) $3,
|
(char *) $5); break;}
|
(char *) $5); break;}
|
}
|
}
|
);
|
);
|
}
|
}
|
|
|
}
|
}
|
};
|
};
|
|
|
|
|
sc_ctor:
|
sc_ctor:
|
SC_CTOR OPENPAR WORD CLOSEPAR OPENKEY
|
SC_CTOR OPENPAR WORD CLOSEPAR OPENKEY
|
{
|
{
|
|
|
|
|
};
|
};
|
|
|
|
|
void:VOID WORD OPENPAR CLOSEPAR SEMICOLON
|
void: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 = NULL;
|
enumerateslist = NULL;
|
|
|
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 = NULL;
|
enumerateslist = NULL;
|
|
|
enumname = (char *) malloc (sizeof (char) * strlen ((char *) $2));
|
enumname = (char *) 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);
|
signalslist = InsertSignal (signalslist, (char *) $2, length, 0);
|
signalslist = InsertSignal (signalslist, (char *) $2, length, 0);
|
writeslist = InsertWrite (writeslist, (char *) $2);
|
writeslist = InsertWrite (writeslist, (char *) $2);
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
(char *) $1);
|
(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);
|
|
|
|
|
signalslist = InsertSignal (signalslist, (char *) $5, length, 0);
|
signalslist = InsertSignal (signalslist, (char *) $5, length, 0);
|
|
|
writeslist = InsertWrite (writeslist, (char *) $5);
|
writeslist = InsertWrite (writeslist, (char *) $5);
|
|
|
}
|
}
|
else
|
else
|
{
|
{
|
|
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
(char *) $3);
|
(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 = (char *) malloc (sizeof (char) * strlen ((char *) $1));
|
storedtype = (char *) malloc (sizeof (char) * strlen ((char *) $1));
|
|
|
strcpy (storedtype, (char *) $1);
|
strcpy (storedtype, (char *) $1);
|
|
|
signalslist = InsertSignal (signalslist, (char *) $2, length,0);
|
signalslist = InsertSignal (signalslist, (char *) $2, length,0);
|
|
|
writeslist = InsertWrite (writeslist, (char *) $2);
|
writeslist = InsertWrite (writeslist, (char *) $2);
|
|
|
multipledec = 1;
|
multipledec = 1;
|
|
|
}
|
}
|
else
|
else
|
{
|
{
|
|
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
(char *) $1);
|
(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 = (char *) malloc (sizeof (char) * strlen ((char *) $3));
|
storedtype = (char *) malloc (sizeof (char) * strlen ((char *) $3));
|
strcpy (storedtype, (char *) $3);
|
strcpy (storedtype, (char *) $3);
|
signalslist = InsertSignal (signalslist, (char *) $5, length, 0);
|
signalslist = InsertSignal (signalslist, (char *) $5, length, 0);
|
writeslist = InsertWrite (writeslist, (char *) $5);
|
writeslist = InsertWrite (writeslist, (char *) $5);
|
multipledec = 1;
|
multipledec = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
|
(char *) $3);
|
(char *) $3);
|
return (1);
|
return (1);
|
}
|
}
|
}
|
}
|
};
|
};
|
|
|
|
|
|
|
translateoff:
|
translateoff:
|
TRANSLATEOFF
|
TRANSLATEOFF
|
{
|
{
|
translate = 0;
|
translate = 0;
|
fprintf (stderr, "line: %d Found Translate off directive \n", lineno);
|
fprintf (stderr, "line: %d Found Translate off directive \n", lineno);
|
};
|
};
|
|
|
|
|
|
|
translateon:
|
translateon:
|
TRANSLATEON
|
TRANSLATEON
|
{
|
{
|
translate = 1;
|
translate = 1;
|
fprintf (stderr, "line: %d Found Translate on directive \n", lineno);
|
fprintf (stderr, "line: %d Found Translate on directive \n", lineno);
|
};
|
};
|
|
|
function:
|
function:
|
SC_REG MENOR NUMBER MAYOR WORD OPENPAR
|
SC_REG MENOR NUMBER MAYOR WORD OPENPAR
|
{
|
{
|
fprintf (stderr, "line: %d Found Function Declaration \n", lineno);
|
fprintf (stderr, "line: %d Found Function Declaration \n", lineno);
|
/* New inputs list */
|
/* New inputs list */
|
functionname = (char *) $5;
|
functionname = (char *) $5;
|
outputlenght = $3;
|
outputlenght = $3;
|
funcinputslist = NULL;
|
funcinputslist = NULL;
|
};
|
};
|
|
|
functioninputs:
|
functioninputs:
|
SC_REG MENOR NUMBER MAYOR WORD COLON
|
SC_REG MENOR NUMBER MAYOR WORD COLON
|
{
|
{
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3);
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3);
|
};
|
};
|
|
|
finishfunctioninputs:
|
finishfunctioninputs:
|
SC_REG MENOR NUMBER MAYOR WORD CLOSEPAR SEMICOLON
|
SC_REG MENOR NUMBER MAYOR WORD CLOSEPAR SEMICOLON
|
{
|
{
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3);
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3);
|
functionslist =
|
functionslist =
|
InsertFunction (functionslist, functionname, funcinputslist,
|
InsertFunction (functionslist, functionname, funcinputslist,
|
outputlenght);
|
outputlenght);
|
};
|
};
|
|
|
boolfunction:
|
boolfunction:
|
BOOL WORD OPENPAR
|
BOOL WORD OPENPAR
|
{
|
{
|
fprintf (stderr, "line: %d Found Function Declaration \n", lineno);
|
fprintf (stderr, "line: %d Found Function Declaration \n", lineno);
|
/* New inputs list */
|
/* New inputs list */
|
functionname = (char *) $2;
|
functionname = (char *) $2;
|
outputlenght = 1;
|
outputlenght = 1;
|
funcinputslist = NULL;
|
funcinputslist = NULL;
|
};
|
};
|
|
|
boolfunctioninputs:
|
boolfunctioninputs:
|
BOOL WORD COLON
|
BOOL WORD COLON
|
{
|
{
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $2, 1);
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $2, 1);
|
};
|
};
|
|
|
boolfinishfunctioninputs:
|
boolfinishfunctioninputs:
|
BOOL WORD CLOSEPAR SEMICOLON
|
BOOL WORD CLOSEPAR SEMICOLON
|
{
|
{
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $2, 1);
|
funcinputslist = InsertFunctionInput (funcinputslist, (char *) $2, 1);
|
functionslist =
|
functionslist =
|
InsertFunction (functionslist, functionname, funcinputslist,
|
InsertFunction (functionslist, functionname, funcinputslist,
|
outputlenght);
|
outputlenght);
|
};
|
};
|
|
|
