URL https://opencores.org/ocsvn/sc2v/sc2v/trunk

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step2.y] - Blame information for rev 39

Details | Compare with Previous | View Log


/* -----------------------------------------------------------------------------
 *
 *  SystemC to Verilog Translator v0.4
 *  Provided by Universidad Rey Juan Carlos
 *
 * -----------------------------------------------------------------------------
 *  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 
#include 
#include 
 
#include "sc2v_step2.h"
 
 
  char *enumname;
 
  int reading_enumerates = 0;
  int lineno = 1;
 
/*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
  int portsign ;
 
/* Global var to store last signal type*/
  int lastsignalsize;
  int signalactive = 0;
  int signalsign ;
 
 
/* 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;
 
/* Global var to store last function found*/
  char *functionname;
  int outputlenght = 0;
  int fsgnflag = 0;
 
  int translate;
 
 
  void yyerror (const char *str)
  {
    fprintf (stderr, "line: %d error: %s\n", lineno, str);
  }
 
  int yywrap ()
  {
    return 1;
  }
 
 
  main ()
  {
 
    /*Initialize lists */
    writeslist = NULL;
    portlist = NULL;;
    signalslist = NULL;
    sensibilitylist = NULL;
    processlist = NULL;
    instanceslist = NULL;
    enumlistlist = NULL;
    funcinputslist = NULL;
    functionslist = NULL;
 
    translate = 1;
 
    fprintf (stderr, "\nSystemC to Verilog Translator v0.6\n\n");
    fprintf (stderr, "Parsing header file.......\n\n");
 
    FILE *yyin = stdin;
    FILE *yyout = stdout;
 
    yyparse ();
 
    printf ("module %s(", module_name);
    EnumeratePorts (portlist);
    printf (");\n");
 
    ShowPortList (portlist);
    printf ("\n");
    RegOutputs (portlist,instanceslist);
    printf ("\n");
 
    ShowEnumListList (enumlistlist);
 
    writeslist = ReadWritesFile (writeslist, (char *) "file_writes.sc2v");
 
    ShowSignalsList (signalslist, writeslist);
 
    printf ("\n");
 
    ShowInstancedModules (instanceslist);
    printf ("\n");
 
    ShowDefines ((char *) "file_defines.sc2v");
 
    ShowFunctionCode (functionslist);
 
    ShowProcessCode (processlist);
    printf ("\n");
 
    printf ("endmodule\n");
 
    fprintf (stderr, "\nDone\n");
  }
 
%}
 
%error-verbose
 
%token NUMBER SC_MODULE WORD OPENPAR CLOSEPAR SC_IN SC_OUT BOOL ENUM
%token MENOR MAYOR SC_REG SC_SGNREG SC_METHOD SENSITIVE_POS SENSITIVE_NEG SENSITIVE POS NEG
%token SENSIBLE CLOSEKEY OPENKEY SEMICOLON COLON SC_SIGNAL ARROW EQUALS NEW QUOTE
%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF OPENCORCH CLOSECORCH
 
%% commands:    /* empty */
|commands command;
 
command:
module
  |
  in_bool
  |
  in_sc_reg
  |
  in_sc_reg_sgn
  |
  out_bool
  |
  out_sc_reg
  |
   out_sc_reg_sgn
  |
  sc_method
  |
  sensitive_pos
  |
  sensitive_neg
  |
  sensitive
  |
  sensible_word_colon
  |
  sensible_word_semicolon
  |
  sensible_word_pos_colon
  |
  sensible_word_pos_semicolon
  |
  sensible_word_neg_colon
  |
  sensible_word_neg_semicolon
  |
  sensible_par_colon
  |
  sensible_par_pos
  |
  sensible_par_neg
  |
  closekey
  |
  word_semicolon
  |
  word_colon
  |
  word_closekey
  |
  word_closekey_word
  |
  signal_bool
  |
  signal_reg
  |
  signal_reg_sgn
  |
  instantation
  |
  port_binding
  |
  sc_ctor
  |
  void
  |
  inst_decl
  |
  multiple_inst_decl
  |
  multiple_inst_decl_cont
  |
  multiple_inst_decl_end
  |
  closekey_semicolon
  |
  enumerates
  |
  enumerates_type
  |
  declaration
  |
  declaration_sc_signal
  |
  multiple_declaration
  |
  multiple_sc_signal_declaration
  |
  translateoff
  |
  translateon
  |
  function
  |
  functioninputs
  |
  finishfunctioninputs
  |
  function_sgn
  |
  functioninputs_sgn
  |
  finishfunctioninputs_sgn
  |
  boolfunction
  |
  boolfunctioninputs
  |
  arraycolon
  |
  arraysemicolon
  |
  boolfinishfunctioninputs;
 
module:
SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY
{
 
  if (translate == 1)
    {
 
      if (module_name_found)
        {
          fprintf (stderr,
                   "line: %d error: two or more modules found in the file\n",
                   lineno);
          exit (1);
        }
      else
        {
          module_name = (char *) malloc (256 * sizeof (char));
          strcpy (module_name, (char *) $3);
          module_name_found = 1;
        }
    }
 
};
 
 
in_sc_reg:
SC_IN MENOR SC_REG MENOR NUMBER MAYOR MAYOR
{
  if (translate == 1)
    {
      activeport = 1;
      lastportsize = $5;
      lastportkind = (char *) "input";
      portsign = 0;
    }
};
 
in_sc_reg_sgn:
SC_IN MENOR SC_SGNREG MENOR NUMBER MAYOR MAYOR
{
  if (translate == 1)
    {
      activeport = 1;
      lastportsize = $5;
      lastportkind = (char *) "input";
      portsign = 1;
    }
};
 
 
in_bool:
SC_IN MENOR BOOL MAYOR
{
  if (translate == 1)
    {
      activeport = 1;
      lastportsize = 0;
      lastportkind = (char *) "input";
      portsign = 0;
    }
};
 
 
signal_bool:
SC_SIGNAL MENOR BOOL MAYOR
{
  if (translate == 1)
    {
      signalactive = 1;
      lastsignalsize = 0;
    }
};
 
 
signal_reg:
SC_SIGNAL MENOR SC_REG MENOR NUMBER MAYOR MAYOR
{
  if (translate == 1)
    {
      signalactive = 1;
      lastsignalsize = $5;
      signalsign = 0;
    }
};
 
signal_reg_sgn:
SC_SIGNAL MENOR SC_SGNREG MENOR NUMBER MAYOR MAYOR
{
  if (translate == 1)
    {
      signalactive = 1;
      lastsignalsize = $5;
      signalsign = 1;
    }
};
 
out_bool:
SC_OUT MENOR BOOL MAYOR
{
  if (translate == 1)
    {
      activeport = 1;
      lastportsize = 0;
      lastportkind = (char *) "output";
      portsign = 0;
    }
};
 
out_sc_reg:
SC_OUT MENOR SC_REG MENOR NUMBER MAYOR MAYOR
{
  if (translate == 1)
    {
      activeport = 1;
      lastportsize = $5;
      lastportkind = (char *) "output";
      portsign = 0;
    }
 
};
 
out_sc_reg_sgn:
SC_OUT MENOR SC_SGNREG MENOR NUMBER MAYOR MAYOR
{
  if (translate == 1)
    {
      activeport = 1;
      lastportsize = $5;
      lastportkind = (char *) "output";
      portsign = 1;
    }
 
};
 
 
sc_method:
SC_METHOD OPENPAR WORD CLOSEPAR SEMICOLON
{
 
  if (translate == 1)
    {
      if (method_found)
        {
          processlist =
            InsertProcess (processlist, active_method, sensibilitylist,
                           active_method_type);
        }
      active_method = (char *) $3;
      method_found = 1;
      /* New sensitivity list */
      sensibilitylist = NULL;
    }
};
 
 
 
sensible_par_neg:
SENSITIVE_NEG OPENPAR WORD CLOSEPAR SEMICOLON
{
  if (translate == 1)
    {
      active_method_type = (char *) "seq";      //comb
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $3, "negedge");
    }
};
 
 
 
sensible_par_pos:
SENSITIVE_POS OPENPAR WORD CLOSEPAR SEMICOLON
{
  if (translate == 1)
    {
      active_method_type = (char *) "seq";      //comb
      sensibilitylist =
        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
      sensibilitylist = InsertSensibility (sensibilitylist, (char *) $3, " ");
    }
};
 
 
 
 
sensible_word_colon:
SENSIBLE WORD
{
  if (translate == 1)
    {
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $2,
                           (char *) last_sensibility);
    }
};
 
 
sensible_word_pos_colon:
SENSIBLE WORD POS
{
  if (translate == 1)
    {
      last_sensibility = (char *) "posedge";
      active_method_type = (char *) "seq";      //seq
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $2,
                           (char *) last_sensibility);
    }
};
 
sensible_word_neg_colon:
SENSIBLE WORD POS
{
  if (translate == 1)
    {
      last_sensibility = (char *) "negedge";
      active_method_type = (char *) "seq";      //seq
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $2,
                           (char *) last_sensibility);
    }
};
 
sensible_word_semicolon:
SENSIBLE WORD SEMICOLON
{
  if (translate == 1)
    {
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $2,
                           (char *) last_sensibility);
      if (sensibility_active)
        {
          sensibility_active = 0;
        }
    }
};
 
sensible_word_pos_semicolon:
SENSIBLE WORD POS SEMICOLON
{
  if (translate == 1)
    {
      last_sensibility = (char *) "posedge";
      active_method_type = (char *) "seq";      //seq
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $2,
                           (char *) last_sensibility);
      if (sensibility_active)
        {
          sensibility_active = 0;
        }
    }
};
 
sensible_word_neg_semicolon:
SENSIBLE WORD POS SEMICOLON
{
  if (translate == 1)
    {
      last_sensibility = (char *) "negedge";
      active_method_type = (char *) "seq";      //seq
      sensibilitylist =
        InsertSensibility (sensibilitylist, (char *) $2,
                           (char *) last_sensibility);
      if (sensibility_active)
        {
          sensibility_active = 0;
        }
    }
};
 
closekey:
CLOSEKEY
{
  if (translate == 1)
    {
      if (method_found)
        {
          method_found = 0;
          processlist =
          InsertProcess (processlist, active_method, sensibilitylist,
                           active_method_type);
        }
    }
};
 
arraysemicolon:
WORD OPENCORCH NUMBER CLOSECORCH SEMICOLON
{
if (signalactive)
        {
          signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,$3, signalsign);
          signalactive = 0;
        }
}
 
arraycolon:
WORD OPENCORCH NUMBER CLOSECORCH COLON
{
if (signalactive)
        {
          signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,$3,signalsign);
          signalactive = 0;
        }
}
 
word_semicolon:
WORD SEMICOLON
{
  if (translate == 1)
    {
      if (activeport)
        {
          portlist =
            InsertPort (portlist, (char *) $1, lastportkind, lastportsize,portsign);
          activeport = 0;
        }
      else if (signalactive)
        {
          signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize,0,signalsign);
          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);
              signalslist = InsertSignal (signalslist, (char *) $1, length, 0,0);
              writeslist = InsertWrite (writeslist, (char *) $1);
              free (storedtype);
              multipledec = 0;
            }
          else
            {
              fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
                       (char *) $1);
              return (1);
            }
        }
    }
 
};
 
 
word_colon:
WORD COLON
{
 
  if (translate == 1)
    {
      if (activeport)
        {
          portlist = InsertPort (portlist, (char *) $1, lastportkind, lastportsize, portsign);
        }
      else if (signalactive)
        {
          signalslist = InsertSignal (signalslist, (char *) $1, lastsignalsize, 0,signalsign);
        }
      else if (reading_enumerates)
        {
          enumerateslist = 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);
              signalslist = InsertSignal (signalslist, (char *) $1, length, 0, 0);
              writeslist = InsertWrite (writeslist, (char *) $1);
              multipledec = 1;
            }
          else
            {
              fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
                       (char *) $1);
              return (1);
            }
        }
    }
 
};
 
 
 
word_closekey_word:
WORD CLOSEKEY WORD SEMICOLON
{
  if (translate == 1)
    {
 
      //Finish enumerate var declaration
      if (reading_enumerates)
        {
          enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
          enumlistlist = 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)
 
        {
 
          enumerateslist = InsertEnumerates (enumerateslist, (char *) $1);
 
          enumlistlist = 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)
    {
      instanceslist =
        InsertInstance (instanceslist, (char *) $1, (char *) $4);
    }
};
 
 
 
port_binding:
WORD ARROW WORD OPENPAR WORD CLOSEPAR SEMICOLON
{
 
  if (translate == 1)
    {
 
      if (instanceslist == NULL)
        {
          fprintf (stderr, "line: %d error: no instances found\n", lineno);
        }
      else
        {
 
          InstanceNode *ill;
          SGLIB_LIST_MAP_ON_ELEMENTS (InstanceNode, instanceslist, ill, next,
                                      {
                                      if (strcmp
                                          (ill->nameinstance,
                                           (char *) $1) == 0)
                                      {
                                      ill->bindslist =
                                      InsertBind (ill->bindslist, (char *) $3,
                                                  (char *) $5); break;}
                                      }
          );
        }
 
    }
};
 
 
sc_ctor:
SC_CTOR OPENPAR WORD CLOSEPAR OPENKEY
{
 
 
};
 
 
void:
VOID WORD OPENPAR CLOSEPAR SEMICOLON
{
 
};
 
 
inst_decl:
WORD ASTERISCO WORD SEMICOLON
{
/*Ignore*/
 
};
multiple_inst_decl:
WORD ASTERISCO WORD COLON
{
/*Ignore*/
 
};
multiple_inst_decl_cont:
ASTERISCO WORD COLON
{
/*Ignore*/
 
};
multiple_inst_decl_end:
ASTERISCO WORD SEMICOLON
{
/*Ignore*/
 
};
 
closekey_semicolon:
CLOSEKEY SEMICOLON
{
 if (translate == 1)
    {
      if (method_found)
        {
          method_found = 0;
          processlist =
          InsertProcess (processlist, active_method, sensibilitylist,
                           active_method_type);
        }
    }
};
 
 
 
enumerates:
ENUM OPENKEY
{
 
  if (translate == 1)
    {
 
      //New enumerate list
      enumerateslist = NULL;
 
      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 = NULL;
 
      enumname = (char *) 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);
          signalslist = InsertSignal (signalslist, (char *) $2, length, 0,0);
          writeslist = InsertWrite (writeslist, (char *) $2);
        }
      else
        {
          fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
                   (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);
 
 
          signalslist = InsertSignal (signalslist, (char *) $5, length, 0,signalsign);
 
          writeslist = InsertWrite (writeslist, (char *) $5);
 
        }
      else
        {
 
          fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
                   (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 = (char *) malloc (sizeof (char) * strlen ((char *) $1));
 
          strcpy (storedtype, (char *) $1);
 
          signalslist = InsertSignal (signalslist, (char *) $2, length,0,0);
 
          writeslist = InsertWrite (writeslist, (char *) $2);
 
          multipledec = 1;
 
        }
      else
        {
 
          fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
                   (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 = (char *) malloc (sizeof (char) * strlen ((char *) $3));
          strcpy (storedtype, (char *) $3);
          signalslist = InsertSignal (signalslist, (char *) $5, length, 0,0);
          writeslist = InsertWrite (writeslist, (char *) $5);
          multipledec = 1;
        }
      else
        {
          fprintf (stderr, "\nline: %d Type %s unknow\n", lineno,
                   (char *) $3);
          return (1);
        }
    }
};
 
 
 
translateoff:
TRANSLATEOFF
{
  translate = 0;
  fprintf (stderr, "line: %d Found Translate off directive \n", lineno);
};
 
 
 
translateon:
TRANSLATEON
{
  translate = 1;
  fprintf (stderr, "line: %d Found Translate on directive \n", lineno);
};
 
function:
SC_REG MENOR NUMBER MAYOR WORD OPENPAR
{
  fprintf (stderr, "line: %d Found Function Declaration \n", lineno);
  /* New inputs list */
  functionname = (char *) $5;
  outputlenght = $3;
  funcinputslist = NULL;
  fsgnflag = 0;
};
 
function_sgn:
SC_SGNREG MENOR NUMBER MAYOR WORD OPENPAR
{
  fprintf (stderr, "line: %d Found {signed} Function Declaration \n", lineno);
  /* New inputs list */
  functionname = (char *) $5;
  outputlenght = $3;
  funcinputslist = NULL;
  fsgnflag = 1;
 
};
 
functioninputs:
SC_REG MENOR NUMBER MAYOR WORD COLON
{
  funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3,0);
};
 
functioninputs_sgn:
SC_SGNREG MENOR NUMBER MAYOR WORD COLON
{
  funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3,1);
};
 
finishfunctioninputs:
SC_REG MENOR NUMBER MAYOR WORD CLOSEPAR SEMICOLON
{
  funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3,0);
  functionslist =
    InsertFunction (functionslist, functionname, funcinputslist,
                    outputlenght,fsgnflag);
};
 
finishfunctioninputs_sgn:
SC_SGNREG MENOR NUMBER MAYOR WORD CLOSEPAR SEMICOLON
{
  funcinputslist = InsertFunctionInput (funcinputslist, (char *) $5, $3, 1);
  functionslist =
    InsertFunction (functionslist, functionname, funcinputslist,
                    outputlenght, fsgnflag);
};
 
boolfunction:
BOOL WORD OPENPAR
{
  fprintf (stderr, "line: %d Found Function Declaration \n", lineno);
  /* New inputs list */
  functionname = (char *) $2;
  outputlenght = 1;
  funcinputslist = NULL;
};
 
boolfunctioninputs:
BOOL WORD COLON
{
  funcinputslist = InsertFunctionInput (funcinputslist, (char *) $2,1,0);
};
 
boolfinishfunctioninputs:
BOOL WORD CLOSEPAR SEMICOLON
{
  funcinputslist = InsertFunctionInput (funcinputslist, (char *) $2,1,0);
  functionslist =
    InsertFunction (functionslist, functionname, funcinputslist,
                    outputlenght,0);
};
 
 

Line No.	Rev	Author	Line
1	2	jcastillo	`/* -----------------------------------------------------------------------------`
2			`*`
3	16	jcastillo	`* SystemC to Verilog Translator v0.4`
4	31	jcastillo	`* Provided by Universidad Rey Juan Carlos`
5	2	jcastillo	`*`
6			`* -----------------------------------------------------------------------------`
7			`* This program is free software; you can redistribute it and/or modify`
8			`* it under the terms of the GNU General Public License as published by`
9			`* the Free Software Foundation; either version 2 of the License, or`
10			`* (at your option) any later version.`
11			`*`
12			`* This program is distributed in the hope that it will be useful,`
13			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`* GNU Library General Public License for more details.`
16			`*`
17			`* You should have received a copy of the GNU General Public License`
18			`* along with this program; if not, write to the Free Software`
19			`* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
20			`*/`
21
22			`%{`
23	12	jcastillo
24	2	jcastillo	`#include`
25			`#include`
26	4	jcastillo	`#include`
27	2	jcastillo
28	14	jcastillo	`#include "sc2v_step2.h"`
29	2	jcastillo
30
31	12	jcastillo	`char *enumname;`
32
33			`int reading_enumerates = 0;`
34	16	jcastillo	`int lineno = 1;`
35	12	jcastillo
36	4	jcastillo	`/Multiple Declarations/`
37	12	jcastillo	`int multipledec;`
38			`char *storedtype;`
39
40
41	2	jcastillo	`/* Global var to store process module name*/`
42	12	jcastillo	`char *module_name;`
43			`int module_name_found = 0;`
44
45
46	2	jcastillo	`/* Global var to store last port type*/`
47	12	jcastillo	`char *lastportkind;`
48			`int lastportsize;`
49			`int activeport = 0; // 1 -> reading port list`
50	35	jcastillo	`int portsign ;`
51	12	jcastillo
52	2	jcastillo	`/* Global var to store last signal type*/`
53	12	jcastillo	`int lastsignalsize;`
54			`int signalactive = 0;`
55	35	jcastillo	`int signalsign ;`
56	12	jcastillo
57
58	2	jcastillo	`/* Global var to store last SC_METHOD found*/`
59	12	jcastillo	`char *active_method;`
60			`char *active_method_type;`
61			`int method_found;`
62
63
64	2	jcastillo	`/* Global var to store last sensitivity found*/`
65	12	jcastillo	`char *last_sensibility;`
66			`int sensibility_active = 0;`
67	2	jcastillo
68	16	jcastillo	`/* Global var to store last function found*/`
69			`char *functionname;`
70			`int outputlenght = 0;`
71	35	jcastillo	`int fsgnflag = 0;`
72	2	jcastillo
73	12	jcastillo	`int translate;`
74	4	jcastillo
75	2	jcastillo
76	12	jcastillo	`void yyerror (const char *str)`
77			`{`
78	15	jcastillo	`fprintf (stderr, "line: %d error: %s\n", lineno, str);`
79	12	jcastillo	`}`
80
81			`int yywrap ()`
82			`{`
83			`return 1;`
84			`}`
85
86
87			`main ()`
88			`{`
89
90			`/Initialize lists /`
91	14	jcastillo	`writeslist = NULL;`
92			`portlist = NULL;;`
93			`signalslist = NULL;`
94	16	jcastillo	`sensibilitylist = NULL;`
95			`processlist = NULL;`
96	14	jcastillo	`instanceslist = NULL;`
97			`enumlistlist = NULL;`
98	16	jcastillo	`funcinputslist = NULL;`
99			`functionslist = NULL;`
100	12	jcastillo
101			`translate = 1;`
102
103	35	jcastillo	`fprintf (stderr, "\nSystemC to Verilog Translator v0.6\n\n");`
104	16	jcastillo	`fprintf (stderr, "Parsing header file.......\n\n");`
105	15	jcastillo
106	16	jcastillo	`FILE *yyin = stdin;`
107			`FILE *yyout = stdout;`
108
109	12	jcastillo	`yyparse ();`
110
111			`printf ("module %s(", module_name);`
112			`EnumeratePorts (portlist);`
113			`printf (");\n");`
114
115			`ShowPortList (portlist);`
116			`printf ("\n");`
117	22	jcastillo	`RegOutputs (portlist,instanceslist);`
118	12	jcastillo	`printf ("\n");`
119
120			`ShowEnumListList (enumlistlist);`
121
122	16	jcastillo	`writeslist = ReadWritesFile (writeslist, (char *) "file_writes.sc2v");`
123	12	jcastillo
124	15	jcastillo	`ShowSignalsList (signalslist, writeslist);`
125
126	12	jcastillo	`printf ("\n");`
127
128			`ShowInstancedModules (instanceslist);`
129			`printf ("\n");`
130
131			`ShowDefines ((char *) "file_defines.sc2v");`
132
133	16	jcastillo	`ShowFunctionCode (functionslist);`
134
135	12	jcastillo	`ShowProcessCode (processlist);`
136			`printf ("\n");`
137
138			`printf ("endmodule\n");`
139
140	16	jcastillo	`fprintf (stderr, "\nDone\n");`
141	12	jcastillo	`}`
142
143	2	jcastillo	`%}`
144
145	39	vasiliev	`%error-verbose`
146
147	35	jcastillo	`%token NUMBER SC_MODULE WORD OPENPAR CLOSEPAR SC_IN SC_OUT BOOL ENUM`
148	39	vasiliev	`%token MENOR MAYOR SC_REG SC_SGNREG SC_METHOD SENSITIVE_POS SENSITIVE_NEG SENSITIVE POS NEG`
149	12	jcastillo	`%token SENSIBLE CLOSEKEY OPENKEY SEMICOLON COLON SC_SIGNAL ARROW EQUALS NEW QUOTE`
150	20	jcastillo	`%token SC_CTOR VOID ASTERISCO TRANSLATEON TRANSLATEOFF OPENCORCH CLOSECORCH`
151	2	jcastillo
152	12	jcastillo	`%% commands: /* empty */`
153			`\|commands command;`
154	2	jcastillo
155			`command:`
156	12	jcastillo	`module`
157			`\|`
158			`in_bool`
159			`\|`
160	16	jcastillo	`in_sc_reg`
161	12	jcastillo	`\|`
162	35	jcastillo	`in_sc_reg_sgn`
163			`\|`
164	12	jcastillo	`out_bool`
165			`\|`
166	16	jcastillo	`out_sc_reg`
167	12	jcastillo	`\|`
168	35	jcastillo	`out_sc_reg_sgn`
169			`\|`
170	12	jcastillo	`sc_method`
171			`\|`
172			`sensitive_pos`
173			`\|`
174			`sensitive_neg`
175			`\|`
176			`sensitive`
177			`\|`
178			`sensible_word_colon`
179			`\|`
180			`sensible_word_semicolon`
181			`\|`
182	39	vasiliev	`sensible_word_pos_colon`
183			`\|`
184			`sensible_word_pos_semicolon`
185			`\|`
186			`sensible_word_neg_colon`
187			`\|`
188			`sensible_word_neg_semicolon`
189			`\|`
190	12	jcastillo	`sensible_par_colon`
191			`\|`
192			`sensible_par_pos`
193			`\|`
194			`sensible_par_neg`
195			`\|`
196			`closekey`
197			`\|`
198			`word_semicolon`
199			`\|`
200			`word_colon`
201			`\|`
202			`word_closekey`
203			`\|`
204			`word_closekey_word`
205			`\|`
206			`signal_bool`
207			`\|`
208	16	jcastillo	`signal_reg`
209	12	jcastillo	`\|`
210	35	jcastillo	`signal_reg_sgn`
211			`\|`
212	12	jcastillo	`instantation`
213			`\|`
214			`port_binding`
215			`\|`
216			`sc_ctor`
217			`\|`
218			`void`
219			`\|`
220	24	jcastillo	`inst_decl`
221			`\|`
222	27	jcastillo	`multiple_inst_decl`
223			`\|`
224			`multiple_inst_decl_cont`
225			`\|`
226			`multiple_inst_decl_end`
227			`\|`
228	12	jcastillo	`closekey_semicolon`
229			`\|`
230			`enumerates`
231			`\|`
232			`enumerates_type`
233			`\|`
234			`declaration`
235			`\|`
236			`declaration_sc_signal`
237			`\|`
238			`multiple_declaration`
239	16	jcastillo	`\|`
240			`multiple_sc_signal_declaration`
241			`\|`
242			`translateoff`
243			`\|`
244			`translateon`
245			`\|`
246			`function`
247			`\|`
248			`functioninputs`
249			`\|`
250			`finishfunctioninputs`
251	20	jcastillo	`\|`
252	35	jcastillo	`function_sgn`
253			`\|`
254			`functioninputs_sgn`
255			`\|`
256			`finishfunctioninputs_sgn`
257			`\|`
258	20	jcastillo	`boolfunction`
259			`\|`
260			`boolfunctioninputs`
261			`\|`
262			`arraycolon`
263			`\|`
264			`arraysemicolon`
265			`\|`
266			`boolfinishfunctioninputs;`
267	2	jcastillo
268			`module:`
269	12	jcastillo	`SC_MODULE OPENPAR WORD CLOSEPAR OPENKEY`
270			`{`
271	2	jcastillo
272	12	jcastillo	`if (translate == 1)`
273			`{`
274
275			`if (module_name_found)`
276	2	jcastillo	`{`
277	16	jcastillo	`fprintf (stderr,`
278			`"line: %d error: two or more modules found in the file\n",`
279			`lineno);`
280	12	jcastillo	`exit (1);`
281	2	jcastillo	`}`
282	12	jcastillo	`else`
283	2	jcastillo	`{`
284	12	jcastillo	`module_name = (char ) malloc (256 sizeof (char));`
285			`strcpy (module_name, (char *) $3);`
286			`module_name_found = 1;`
287	2	jcastillo	`}`
288	12	jcastillo	`}`
289	2	jcastillo
290	12	jcastillo	`};`
291
292
293	16	jcastillo	`in_sc_reg:`
294			`SC_IN MENOR SC_REG MENOR NUMBER MAYOR MAYOR`
295	12	jcastillo	`{`
296			`if (translate == 1)`
297			`{`
298			`activeport = 1;`
299			`lastportsize = $5;`
300			`lastportkind = (char *) "input";`
301	35	jcastillo	`portsign = 0;`
302	12	jcastillo	`}`
303			`};`
304
305	35	jcastillo	`in_sc_reg_sgn:`
306			`SC_IN MENOR SC_SGNREG MENOR NUMBER MAYOR MAYOR`
307			`{`
308			`if (translate == 1)`
309			`{`
310			`activeport = 1;`
311			`lastportsize = $5;`
312			`lastportkind = (char *) "input";`
313			`portsign = 1;`
314			`}`
315			`};`
316	12	jcastillo
317	35	jcastillo
318	2	jcastillo	`in_bool:`
319	12	jcastillo	`SC_IN MENOR BOOL MAYOR`
320			`{`
321			`if (translate == 1)`
322			`{`
323			`activeport = 1;`
324			`lastportsize = 0;`
325			`lastportkind = (char *) "input";`
326	35	jcastillo	`portsign = 0;`
327	12	jcastillo	`}`
328			`};`
329
330
331	2	jcastillo	`signal_bool:`
332	12	jcastillo	`SC_SIGNAL MENOR BOOL MAYOR`
333			`{`
334			`if (translate == 1)`
335			`{`
336			`signalactive = 1;`
337			`lastsignalsize = 0;`
338			`}`
339			`};`
340
341
342	16	jcastillo	`signal_reg:`
343			`SC_SIGNAL MENOR SC_REG MENOR NUMBER MAYOR MAYOR`
344	12	jcastillo	`{`
345			`if (translate == 1)`
346			`{`
347			`signalactive = 1;`
348			`lastsignalsize = $5;`
349	35	jcastillo	`signalsign = 0;`
350	12	jcastillo	`}`
351			`};`
352
353	35	jcastillo	`signal_reg_sgn:`
354			`SC_SIGNAL MENOR SC_SGNREG MENOR NUMBER MAYOR MAYOR`
355			`{`
356			`if (translate == 1)`
357			`{`
358			`signalactive = 1;`
359			`lastsignalsize = $5;`
360			`signalsign = 1;`
361			`}`
362			`};`
363
364	2	jcastillo	`out_bool:`
365	12	jcastillo	`SC_OUT MENOR BOOL MAYOR`
366			`{`
367			`if (translate == 1)`
368			`{`
369			`activeport = 1;`
370			`lastportsize = 0;`
371			`lastportkind = (char *) "output";`
372	35	jcastillo	`portsign = 0;`
373	12	jcastillo	`}`
374			`};`
375
376	16	jcastillo	`out_sc_reg:`
377			`SC_OUT MENOR SC_REG MENOR NUMBER MAYOR MAYOR`
378	12	jcastillo	`{`
379			`if (translate == 1)`
380			`{`
381			`activeport = 1;`
382			`lastportsize = $5;`
383			`lastportkind = (char *) "output";`
384	35	jcastillo	`portsign = 0;`
385	12	jcastillo	`}`
386
387			`};`
388
389	35	jcastillo	`out_sc_reg_sgn:`
390			`SC_OUT MENOR SC_SGNREG MENOR NUMBER MAYOR MAYOR`
391			`{`
392			`if (translate == 1)`
393			`{`
394			`activeport = 1;`
395			`lastportsize = $5;`
396			`lastportkind = (char *) "output";`
397			`portsign = 1;`
398			`}`
399	12	jcastillo
400	35	jcastillo	`};`
401
402
403	2	jcastillo	`sc_method:`
404	12	jcastillo	`SC_METHOD OPENPAR WORD CLOSEPAR SEMICOLON`
405			`{`
406
407			`if (translate == 1)`
408			`{`
409			`if (method_found)`
410	2	jcastillo	`{`
411	16	jcastillo	`processlist =`
412			`InsertProcess (processlist, active_method, sensibilitylist,`
413			`active_method_type);`
414	12	jcastillo	`}`
415			`active_method = (char *) $3;`
416			`method_found = 1;`
417			`/* New sensitivity list */`
418	14	jcastillo	`sensibilitylist = NULL;`
419	12	jcastillo	`}`
420			`};`
421
422
423
424	4	jcastillo	`sensible_par_neg:`
425	12	jcastillo	`SENSITIVE_NEG OPENPAR WORD CLOSEPAR SEMICOLON`
426			`{`
427			`if (translate == 1)`
428			`{`
429			`active_method_type = (char *) "seq"; //comb`
430	16	jcastillo	`sensibilitylist =`
431			`InsertSensibility (sensibilitylist, (char *) $3, "negedge");`
432	12	jcastillo	`}`
433			`};`
434
435
436
437			`sensible_par_pos:`
438			`SENSITIVE_POS OPENPAR WORD CLOSEPAR SEMICOLON`
439			`{`
440			`if (translate == 1)`
441			`{`
442			`active_method_type = (char *) "seq"; //comb`
443	16	jcastillo	`sensibilitylist =`
444			`InsertSensibility (sensibilitylist, (char *) $3, "posedge");`
445	12	jcastillo	`}`
446			`};`
447
448
449
450			`sensitive_pos:`
451			`SENSITIVE_POS`
452			`{`
453			`if (translate == 1)`
454			`{`
455			`last_sensibility = (char *) "posedge";`
456			`active_method_type = (char *) "seq"; //seq`
457			`sensibility_active = 1;`
458			`}`
459			`};`
460
461			`sensitive_neg:`
462			`SENSITIVE_NEG`
463			`{`
464			`if (translate == 1)`
465			`{`
466			`last_sensibility = (char *) "negedge";`
467			`active_method_type = (char *) "seq"; //seq`
468			`sensibility_active = 1;`
469			`}`
470			`};`
471
472			`sensitive:`
473			`SENSITIVE`
474			`{`
475
476			`if (translate == 1)`
477			`{`
478			`last_sensibility = (char *) " ";`
479			`active_method_type = (char *) "comb"; //comb`
480			`sensibility_active = 1;`
481			`}`
482			`};`
483
484
485
486			`sensible_par_colon:`
487			`SENSITIVE OPENPAR WORD CLOSEPAR SEMICOLON`
488			`{`
489			`if (translate == 1)`
490			`{`
491			`active_method_type = (char *) "comb"; //comb`
492	16	jcastillo	`sensibilitylist = InsertSensibility (sensibilitylist, (char *) $3, " ");`
493	12	jcastillo	`}`
494			`};`
495
496
497
498
499			`sensible_word_colon:`
500			`SENSIBLE WORD`

Browse

Tools

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step2.y] - Blame information for rev 39