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