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

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step1.y] - Blame information for rev 12

Go to most recent revision | Details | Compare with Previous | 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 
#include 
 
#include "list.h"
 
/* Global var to store Regs */
  RegsList *regslist;
/* Global var to store Defines */
  DefinesList *defineslist;
 
 
  int processfound = 0;
  int switchfound = 0;
  int switchparenthesis[256];
  int ifdeffound = 0;
  char *processname, *processname2;
  char *fileregs;
  char *filename;
  int openedkeys = 0;
  int newline = 0;
  int reg_found = 0;
  int regs_end;
  int i = 0;                    //for loops counter
  FILE *file;
  FILE *regs_file;
  char *regname, *regname2;
  char *lastword;               // Stores last WORD for use it in WRITE
  char *file_defines;
  FILE *FILE_DEFINES;
  char *file_writes;
  FILE *FILE_WRITES;            //FILE to store .write to know if it is a wire or reg
  int definefound = 0;
  int defineinvocationfound = 0;
  int opencorchfound = 0;
  int defineparenthesis = 0;
 
  int openedcase = 0;
 
  int default_break_found = 0;
  int default_found;
 
//Directives variables
  int translate;
  int verilog;
  int writemethod;
 
  void yyerror (const char *str)
  {
    fprintf (stderr, "error: %s\n", str);
  }
 
  int yywrap ()
  {
    return 1;
  }
 
  main ()
  {
    int i;
 
    regslist = (RegsList *) malloc (sizeof (RegsList));
    InitializeRegsList (regslist);
    defineslist = (DefinesList *) malloc (sizeof (DefinesList));
    InitializeDefinesList (defineslist);
 
    processname = (char *) malloc (256 * sizeof (int));
    processname2 = (char *) malloc (256 * sizeof (int));
    fileregs = (char *) malloc (256 * sizeof (int));
 
    file_defines = (char *) malloc (256 * sizeof (int));
    strcpy (file_defines, (char *) "file_defines.sc2v");
    FILE_DEFINES = fopen (file_defines, (char *) "w");
 
    file_writes = (char *) malloc (256 * sizeof (int));
    strcpy (file_writes, (char *) "file_writes.sc2v");
    FILE_WRITES = fopen (file_writes, (char *) "w");
    if (FILE_WRITES != NULL)
      printf ("\nopening file => filename = %s\n", file_writes);
 
    lastword = malloc (sizeof (char) * 256);
 
    for (i = 0; i < 256; i++)
      switchparenthesis[i] = 0;
 
    translate = 1;
    verilog = 0;
    writemethod = 0;
 
    yyparse ();
    fclose (FILE_WRITES);
    fclose (FILE_DEFINES);
  }
 
%}
 
%token NUMBER WORD SC_INT SC_UINT BOOL BIGGER LOWER OPENKEY CLOSEKEY WRITE WORD SYMBOL NEWLINE ENUM INCLUDE
%token COLON SEMICOLON RANGE OPENPAR CLOSEPAR TWODOUBLEPOINTS OPENCORCH CLOSECORCH SWITCH CASE DEFAULT BREAK
%token SC_BIGINT SC_BIGUINT HEXA DEFINE READ TRANSLATEOFF TRANSLATEON VERILOGBEGIN VERILOGEND TAB DOLLAR INTCONV
%token VOID TTRUE TFALSE
%token PIFDEF PENDDEF PELSE
 
%% commands:/* empty */
|commands command;
 
 
command:
  voidword
  |
  include
  |
  dollar
  |
  intconv
  |
  tab
  |
  read
  |
  sc_int
  |
  sc_uint
  |
  sc_bigint
  |
  sc_biguint
  |
  number
  |
  bool
  |
  word
  |
  symbol
  |
  write
  |
  newline
  |
  openkey
  |
  closekey
  |
  colon
  |
  semicolon
  |
  range
  |
  openpar
  |
  closepar
  |
  void
  |
  opencorch
  |
  closecorch
  |
  bigger
  |
  lower
  |
  switch
  |
  case_only
  |
  case_number
  |
  case_word
  |
  case_default
  |
  break
  |
  hexa
  |
  definemacro
  |
  defineword
  |
  definenumber
  |
  translateoff
  |
  translateon
  |
  verilogbegin
  |
  verilogend
  |
  ifdef
  |
  endif
  |
  pelse
  |
  ttrue
  |
  tfalse;
 
 
 
voidword:
VOID
{
  defineparenthesis = 0;
  if (verilog == 1)
    fprintf (file, " void");
};
 
 
include:
INCLUDE
{
  defineparenthesis = 0;
  if (verilog == 1)
    fprintf (file, " #include");
};
 
 
dollar:
DOLLAR
{
  defineparenthesis = 0;
  if (verilog == 1)
    fprintf (file, " $");
};
 
intconv:
INTCONV
{
  defineparenthesis = 0;
  if (verilog == 1)
    fprintf (file, " (int)");
};
 
tab:
TAB
{
  defineparenthesis = 0;
  if (verilog == 1)
    fprintf (file, " \t");
};
 
read:
READ OPENPAR CLOSEPAR
{
  defineparenthesis = 0;
  if (verilog == 1)
    fprintf (file, ".read()");
 
}
 
defineword:
DEFINE WORD WORD
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "`define %s %s\n", (char *) $2, (char *) $3);
          InsertDefine (defineslist, (char *) $2);
        }
      else
        {
          fprintf (FILE_DEFINES, "`define %s %s\n", (char *) $2, (char *) $3);
          InsertDefine (defineslist, (char *) $2);
        }
    }
  else if (verilog == 1)
    fprintf (file, "#define %s %s\n", (char *) $2, (char *) $3);
 
};
 
definenumber:
DEFINE WORD NUMBER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "`define %s %d\n", (char *) $2, (int) $3);
          InsertDefine (defineslist, (char *) $2);
        }
      else
        {
          fprintf (FILE_DEFINES, "`define %s %d\n", (char *) $2, (int) $3);
          InsertDefine (defineslist, (char *) $2);
        }
    }
  else if (verilog == 1)
    fprintf (file, "#define %s %d\n", (char *) $2, (int) $3);
 
};
 
 
definemacro:
DEFINE WORD OPENPAR CLOSEPAR
{
  defineparenthesis = 0;
  //Macro found
  if (translate == 1 && verilog == 0)
    {
      InsertDefine (defineslist, (char *) $2);
      definefound = 1;
      if (processfound)
        fprintf (file, "`define %s ", (char *) $2);
      else
        fprintf (FILE_DEFINES, "`define %s ", (char *) $2);
    }
  else if (verilog == 1)
    fprintf (file, "#define %s ()", (char *) $2);
}
 
void:
WORD TWODOUBLEPOINTS WORD OPENPAR CLOSEPAR
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      strcpy (processname, (char *) $4);
      strcpy (processname2, (char *) $4);
      strcat (processname2, (char *) ".sc2v");
      strcpy (fileregs, (char *) $4);
      strcat (fileregs, (char *) "_regs.sc2v");
    }
  else if (verilog == 1)
    fprintf (file, " %s::%s()", (char *) $1, (char *) $3);
 
}
 
sc_int:
SC_INT LOWER NUMBER BIGGER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (regs_file, "reg[%d:0] ", (-1 + $3));
          reg_found = 1;
        }
    }
  else if (verilog == 1)
    fprintf (file, "sc_int<%d>", $3);
 
}
 
;
 
sc_uint:
SC_UINT LOWER NUMBER BIGGER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (regs_file, "reg[%d:0] ", (-1 + $3));
          reg_found = 1;
        }
    }
  else if (verilog == 1)
    fprintf (file, "sc_uint<%d>", $3);
}
 
;
 
sc_bigint:
SC_BIGINT LOWER NUMBER BIGGER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (regs_file, "reg[%d:0] ", (-1 + $3));
          reg_found = 1;
        }
    }
  else if (verilog == 1)
    fprintf (file, "sc_bigint<%d> ", $3);
}
 
;
 
sc_biguint:
SC_BIGUINT LOWER NUMBER BIGGER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (regs_file, "reg[%d:0] ", (-1 + $3));
          reg_found = 1;
        }
    }
  else if (verilog == 1)
    fprintf (file, "sc_biguint<%d> ", $3);
}
 
;
 
bool:
BOOL
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (regs_file, "reg ");
          reg_found = 1;
        }
    }
  else if (verilog == 1)
    fprintf (file, "bool");
}
 
;
 
range:
RANGE OPENPAR NUMBER COLON NUMBER CLOSEPAR
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        fprintf (file, "[%d:%d]", $3, $5);
      else if (definefound)
        fprintf (FILE_DEFINES, "[%d:%d]", $3, $5);
    }
  else if (verilog == 1)
    fprintf (file, ".range(%d,%d)", $3, $5);
}
 
;
 
number:
NUMBER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        if (reg_found)
          {
            if (opencorchfound)
              fprintf (regs_file, "%d:0", -1 + $1);
            else
              fprintf (regs_file, "%d", $1);
          }
        else
          fprintf (file, "%d", $1);
      else if (definefound)
        fprintf (FILE_DEFINES, "%d", $1);
    }
  else if (verilog == 1)
    fprintf (file, "%d", $1);
}
 
;
word:
WORD
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (openedcase)
            {
              fprintf (file, " :\n");
 
              for (i = 0; i < openedkeys; i++)
                fprintf (file, "   ");
 
              fprintf (file, "begin\n");
              openedcase = 0;
            }
 
          strcpy (lastword, (char *) $1);
 
          if (reg_found)
            {
 
              regname = malloc (sizeof (char) * (strlen ((char *) $1) + 1));
              regname2 =
                malloc (sizeof (char) *
                        (strlen ((char *) $1) + strlen (processname)) + 1);
 
              strcpy (regname, (char *) $1);
              strcpy (regname2, (char *) $1);
              strcat (regname2, processname);
              fprintf (regs_file, "%s", regname2);
              InsertReg (regslist, regname, regname2);
              free (regname);
              free (regname2);
            }
          else
            {
              if (newline)
                {
                  for (i = 0; i < openedkeys; i++)
                    fprintf (file, "   ");
                }
              regname2 = IsReg (regslist, (char *) $1);
              if (regname2 == NULL)
                {
                  if (IsDefine (defineslist, (char *) $1))
                    {
                      if (ifdeffound == 0)
                        {
                          fprintf (file, "`%s", (char *) $1);
                          defineinvocationfound = 1;
                        }
                      else
                        {
                          fprintf (file, "%s", (char *) $1);
                          ifdeffound = 0;
                        }
                    }
                  else
                    {
                      fprintf (file, "%s ", (char *) $1);
                    }
                }
              else
                fprintf (file, "%s", regname2);
 
              newline = 0;
            }
 
        }
      else if (definefound)
        {
          if (IsDefine (defineslist, (char *) $1))
            {
 
              fprintf (FILE_DEFINES, "`%s", (char *) $1);
            }
          else
            {
              fprintf (FILE_DEFINES, "%s ", (char *) $1);
            }
        }
    }
  else if (verilog == 1)
    fprintf (file, " %s", (char *) $1);
};
 
symbol:
SYMBOL
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (reg_found)
            fprintf (regs_file, "%s", (char *) $1);
          else
            fprintf (file, "%s", (char *) $1);
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "%s", (char *) $1);
        }
    }
  else if (verilog == 1)
    fprintf (file, "%s", (char *) $1);
};
 
 
write:
WRITE
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      writemethod = 1;
      if (processfound)
        {
          fprintf (file, " <= ");
          fprintf (FILE_WRITES, "%s\n", lastword);
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, " <= ");
        }
 
    }
  else if (verilog == 1)
    {
      fprintf (file, ".write");
    }
};
 
newline:
NEWLINE
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound & !reg_found & !openedcase)
        {
          fprintf (file, "\n");
          newline = 1;
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "\n");
        }
 
    }
  else if (verilog == 1)
    fprintf (file, "\n");
};
 
colon:
COLON
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (reg_found)
            {
              fprintf (regs_file, ",");
            }
          else
            fprintf (file, ",");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, ",");
        }
    }
  else if (verilog == 1)
    fprintf (file, ",");
};
 
semicolon:
SEMICOLON
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (reg_found)
            {
              fprintf (regs_file, ";\n");
              reg_found = 0;
            }
          else
            {
              if (defineinvocationfound == 0)
                fprintf (file, ";");
            }
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, ";");
        }
    }
  else if (verilog == 1)
    fprintf (file, ";");
 
  defineinvocationfound = 0;
};
 
 
openpar:
OPENPAR
{
  defineparenthesis = 1;
  if (translate == 1 && verilog == 0 && defineinvocationfound == 0)
    {
      if (processfound)
        {
          fprintf (file, "(");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "(");
        }
 
    }
  else if (verilog == 1)
    {
      fprintf (file, "(");
    }
}
 
closepar:
CLOSEPAR
{
  if (translate == 1 && verilog == 0)
    {
 
      if (processfound)
        {
          if (defineparenthesis == 0)
            {
              fprintf (file, ")");
              defineinvocationfound = 0;
            }
 
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, ")");
        }
    }
  else if (verilog == 1)
    fprintf (file, ")");
 
};
 
 
opencorch:
OPENCORCH
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (reg_found)
            {
              fprintf (regs_file, "[");
              opencorchfound = 1;
            }
          else
            fprintf (file, "[");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "[");
 
        }
    }
  else if (verilog == 1)
    fprintf (file, "[");
};
 
closecorch:
CLOSECORCH
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (reg_found)
            {
              fprintf (regs_file, "]");
              opencorchfound = 0;
            }
          else
            fprintf (file, "]");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "]");
        }
    }
  else if (verilog == 1)
    fprintf (file, "]");
};
 
 
openkey:
OPENKEY
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      openedkeys++;
      if (!definefound)
        {
          if (openedkeys == 1)
            {
              printf ("opening file => filename = %s\n", processname2);
              file = fopen (processname2, (char *) "w");
              printf ("opening file => filename = %s\n", fileregs);
              regs_file = fopen (fileregs, (char *) "w");
              processfound = 1;
              regslist = (RegsList *) malloc (sizeof (RegsList));
              InitializeRegsList (regslist);
            }
          if (processfound)
            if (openedkeys != switchparenthesis[switchfound])
              {
                fprintf (file, "\n");
                for (i = 0; i < openedkeys; i++)
                  fprintf (file, "   ");
                fprintf (file, "begin\n");
                newline = 1;
              }
        }
    }
  else if (verilog == 1)
    fprintf (file, "{");
};
 
closekey:
CLOSEKEY
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound && !definefound)
        {
          if (openedkeys == switchparenthesis[switchfound] && switchfound > 0)
            {
              fprintf (file, "\n");
              if (default_found & !default_break_found)
                {
                  for (i = 0; i < openedkeys - 1; i++)
                    fprintf (file, "   ");
                  fprintf (file, "end\n");
                  default_found = 0;
                }
              for (i = 0; i < openedkeys - 1; i++)
                fprintf (file, "   ");
              fprintf (file, "endcase\n");
              newline = 1;
              switchparenthesis[switchfound] = 0;
              switchfound--;
 
            }
          else
            {
              fprintf (file, "\n");
              for (i = 0; i < openedkeys; i++)
                fprintf (file, "   ");
              fprintf (file, "end\n");
              newline = 1;
            }
        }
 
      openedkeys--;
      if (definefound)
        {
          definefound = 0;
          if (processfound)
            fprintf (file, "\n//Dummy Comment\n");
          else
            fprintf (FILE_DEFINES, "\n//Dummy Comment\n");
        }
      else if (openedkeys == 0)
        {
          fclose (file);
          fclose (regs_file);
          free (regslist);
          processfound = 0;
        }
    }
  else if (verilog == 1)
    fprintf (file, "}");
};
 
 
bigger:
BIGGER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, ">");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, ">");
        }
    }
  else if (verilog == 1)
    fprintf (file, ">");
};
 
lower:
LOWER
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "<");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "<");
        }
    }
  else if (verilog == 1)
    fprintf (file, "<");
};
 
 
switch:
SWITCH
  {
    defineparenthesis = 0;
    if (translate == 1 && verilog == 0)
      {
        if (processfound)
          {
            fprintf (file, "\n");
            for (i = 0; i < openedkeys; i++)
              fprintf (file, "   ");
            fprintf (file, "case");
            switchfound++;
            switchparenthesis[switchfound] = openedkeys + 1;
          }
      }
    else if (verilog == 1)
      fprintf (file, "switch");
  };
 
case_number:
CASE NUMBER SYMBOL
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          for (i = 0; i < openedkeys; i++)
            fprintf (file, "   ");
          if (openedcase)
            fprintf (file, ", %d", $2);
          else
            fprintf (file, "%d", $2);
 
          newline = 1;
          openedcase = 1;
 
        }
    }
  else if (verilog == 1)
    fprintf (file, "case %d %s", $2, (char *) $3);
};
 
case_word:
CASE WORD SYMBOL
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          for (i = 0; i < openedkeys; i++)
            fprintf (file, "   ");
          if (openedcase)
            fprintf (file, ", %s", (char *) $2);
          else
            fprintf (file, "%s", (char *) $2);
 
          newline = 1;
          openedcase = 1;
 
        }
    }
  else if (verilog == 1)
    fprintf (file, "case %s %s", (char *) $2, (char *) $3);
};
 
case_default:
DEFAULT SYMBOL
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          for (i = 0; i < openedkeys; i++)
            fprintf (file, "   ");
          fprintf (file, "default:\n");
          for (i = 0; i < openedkeys; i++)
            fprintf (file, "   ");
          fprintf (file, "begin\n");
          newline = 1;
          default_found = 1;
        }
    }
  else if (verilog == 1)
    fprintf (file, "default %s", (char *) $2);
};
 
case_only:
CASE OPENPAR
{
  defineparenthesis = 0;
  //This rule occurs when in Verilog mode a case appears
  if (verilog == 1)
    fprintf (file, "case(");
};
 
break:
BREAK SEMICOLON
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          if (newline == 0)
            fprintf (file, "\n");
          for (i = 0; i < openedkeys; i++)
            fprintf (file, "   ");
          fprintf (file, "end\n");
          if (default_found)
            {
              default_break_found = 1;
            }
        }
    }
  else if (verilog == 1)
    fprintf (file, "break;");
};
 
hexa:
HEXA
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "'h");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "'h");
        }
    }
  else if (verilog == 1)
    fprintf (file, "0x");
};
 
translateoff:
TRANSLATEOFF
{
  defineparenthesis = 0;
  translate = 0;
  fprintf (stderr, "Found Translate off directive \n");
};
 
translateon:
TRANSLATEON
{
  defineparenthesis = 0;
  translate = 1;
  fprintf (stderr, "Found Translate on directive \n");
};
 
verilogbegin:
VERILOGBEGIN
{
  defineparenthesis = 0;
  verilog = 1;
  fprintf (stderr, "Found Verilog Begin directive \n");
};
 
verilogend:
VERILOGEND
{
  defineparenthesis = 0;
  verilog = 0;
  fprintf (stderr, "Found Verilog End directive \n");
};
 
ifdef:
PIFDEF
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          ifdeffound = 1;
          fprintf (file, "`ifdef");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "`ifdef");
        }
    }
  else if (verilog == 1)
    fprintf (file, "#ifdef");
};
 
endif:
PENDDEF
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "`endif");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "`endif");
        }
    }
  else if (verilog == 1)
    fprintf (file, "#endif");
};
 
pelse:
PELSE
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "`else");
        }
      else if (definefound)
        {
          fprintf (FILE_DEFINES, "`else");
        }
    }
  else if (verilog == 1)
    fprintf (file, "#else");
};
 
ttrue:
TTRUE
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "1");
        }
    }
  else if (verilog == 1)
    fprintf (file, "1");
};
 
 
tfalse:
TFALSE
{
  defineparenthesis = 0;
  if (translate == 1 && verilog == 0)
    {
      if (processfound)
        {
          fprintf (file, "0");
        }
    }
  else if (verilog == 1)
    fprintf (file, "0");
};

Line No.	Rev	Author	Line
1	2	jcastillo	`/* -----------------------------------------------------------------------------`
2			`*`
3	4	jcastillo	`* SystemC to Verilog Translator v0.2`
4	2	jcastillo	`* Provided by OpenSoc Design`
5			`*`
6			`* www.opensocdesign.com`
7			`*`
8			`* -----------------------------------------------------------------------------`
9			`* This program is free software; you can redistribute it and/or modify`
10			`* it under the terms of the GNU General Public License as published by`
11			`* the Free Software Foundation; either version 2 of the License, or`
12			`* (at your option) any later version.`
13			`*`
14			`* This program is distributed in the hope that it will be useful,`
15			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`* GNU Library General Public License for more details.`
18			`*`
19			`* You should have received a copy of the GNU General Public License`
20			`* along with this program; if not, write to the Free Software`
21			`* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
22			`*/`
23
24
25			`%{`
26			`#include`
27			`#include`
28
29			`#include "list.h"`
30
31			`/* Global var to store Regs */`
32	12	jcastillo	`RegsList *regslist;`
33	2	jcastillo	`/* Global var to store Defines */`
34	12	jcastillo	`DefinesList *defineslist;`
35	2	jcastillo
36
37	12	jcastillo	`int processfound = 0;`
38			`int switchfound = 0;`
39			`int switchparenthesis[256];`
40			`int ifdeffound = 0;`
41			`char processname, processname2;`
42			`char *fileregs;`
43			`char *filename;`
44			`int openedkeys = 0;`
45			`int newline = 0;`
46			`int reg_found = 0;`
47			`int regs_end;`
48			`int i = 0; //for loops counter`
49			`FILE *file;`
50			`FILE *regs_file;`
51			`char regname, regname2;`
52			`char *lastword; // Stores last WORD for use it in WRITE`
53			`char *file_defines;`
54			`FILE *FILE_DEFINES;`
55			`char *file_writes;`
56			`FILE *FILE_WRITES; //FILE to store .write to know if it is a wire or reg`
57			`int definefound = 0;`
58			`int defineinvocationfound = 0;`
59			`int opencorchfound = 0;`
60			`int defineparenthesis = 0;`
61	2	jcastillo
62	12	jcastillo	`int openedcase = 0;`
63	2	jcastillo
64	12	jcastillo	`int default_break_found = 0;`
65			`int default_found;`
66	2	jcastillo
67	4	jcastillo	`//Directives variables`
68	12	jcastillo	`int translate;`
69			`int verilog;`
70			`int writemethod;`
71	4	jcastillo
72	12	jcastillo	`void yyerror (const char *str)`
73			`{`
74			`fprintf (stderr, "error: %s\n", str);`
75			`}`
76	2	jcastillo
77	12	jcastillo	`int yywrap ()`
78			`{`
79			`return 1;`
80			`}`
81	2	jcastillo
82	12	jcastillo	`main ()`
83			`{`
84			`int i;`
85	10	jcastillo
86	12	jcastillo	`regslist = (RegsList *) malloc (sizeof (RegsList));`
87			`InitializeRegsList (regslist);`
88			`defineslist = (DefinesList *) malloc (sizeof (DefinesList));`
89			`InitializeDefinesList (defineslist);`
90	2	jcastillo
91	12	jcastillo	`processname = (char ) malloc (256 sizeof (int));`
92			`processname2 = (char ) malloc (256 sizeof (int));`
93			`fileregs = (char ) malloc (256 sizeof (int));`
94
95			`file_defines = (char ) malloc (256 sizeof (int));`
96			`strcpy (file_defines, (char *) "file_defines.sc2v");`
97			`FILE_DEFINES = fopen (file_defines, (char *) "w");`
98
99			`file_writes = (char ) malloc (256 sizeof (int));`
100			`strcpy (file_writes, (char *) "file_writes.sc2v");`
101			`FILE_WRITES = fopen (file_writes, (char *) "w");`
102			`if (FILE_WRITES != NULL)`
103			`printf ("\nopening file => filename = %s\n", file_writes);`
104
105			`lastword = malloc (sizeof (char) * 256);`
106
107			`for (i = 0; i < 256; i++)`
108			`switchparenthesis[i] = 0;`
109
110			`translate = 1;`
111			`verilog = 0;`
112			`writemethod = 0;`
113
114			`yyparse ();`
115			`fclose (FILE_WRITES);`
116			`fclose (FILE_DEFINES);`
117			`}`
118
119	2	jcastillo	`%}`
120
121	12	jcastillo	`%token NUMBER WORD SC_INT SC_UINT BOOL BIGGER LOWER OPENKEY CLOSEKEY WRITE WORD SYMBOL NEWLINE ENUM INCLUDE`
122			`%token COLON SEMICOLON RANGE OPENPAR CLOSEPAR TWODOUBLEPOINTS OPENCORCH CLOSECORCH SWITCH CASE DEFAULT BREAK`
123			`%token SC_BIGINT SC_BIGUINT HEXA DEFINE READ TRANSLATEOFF TRANSLATEON VERILOGBEGIN VERILOGEND TAB DOLLAR INTCONV`
124			`%token VOID TTRUE TFALSE`
125			`%token PIFDEF PENDDEF PELSE`
126	2	jcastillo
127	12	jcastillo	`%% commands:/* empty */`
128			`\|commands command;`
129	2	jcastillo
130
131			`command:`
132	12	jcastillo	`voidword`
133			`\|`
134			`include`
135			`\|`
136			`dollar`
137			`\|`
138			`intconv`
139			`\|`
140			`tab`
141			`\|`
142			`read`
143			`\|`
144			`sc_int`
145			`\|`
146			`sc_uint`
147			`\|`
148			`sc_bigint`
149			`\|`
150			`sc_biguint`
151			`\|`
152			`number`
153			`\|`
154			`bool`
155			`\|`
156			`word`
157			`\|`
158			`symbol`
159			`\|`
160			`write`
161			`\|`
162			`newline`
163			`\|`
164			`openkey`
165			`\|`
166			`closekey`
167			`\|`
168			`colon`
169			`\|`
170			`semicolon`
171			`\|`
172			`range`
173			`\|`
174			`openpar`
175			`\|`
176			`closepar`
177			`\|`
178			`void`
179			`\|`
180			`opencorch`
181			`\|`
182			`closecorch`
183			`\|`
184			`bigger`
185			`\|`
186			`lower`
187			`\|`
188			`switch`
189			`\|`
190			`case_only`
191			`\|`
192			`case_number`
193			`\|`
194			`case_word`
195			`\|`
196			`case_default`
197			`\|`
198			`break`
199			`\|`
200			`hexa`
201			`\|`
202			`definemacro`
203			`\|`
204			`defineword`
205			`\|`
206			`definenumber`
207			`\|`
208			`translateoff`
209			`\|`
210			`translateon`
211			`\|`
212			`verilogbegin`
213			`\|`
214			`verilogend`
215			`\|`
216			`ifdef`
217			`\|`
218			`endif`
219			`\|`
220			`pelse`
221			`\|`
222			`ttrue`
223			`\|`
224			`tfalse;`
225	2	jcastillo
226	4	jcastillo
227	12	jcastillo
228	4	jcastillo	`voidword:`
229	12	jcastillo	`VOID`
230			`{`
231			`defineparenthesis = 0;`
232			`if (verilog == 1)`
233			`fprintf (file, " void");`
234			`};`
235	4	jcastillo
236	12	jcastillo
237	4	jcastillo	`include:`
238	12	jcastillo	`INCLUDE`
239			`{`
240			`defineparenthesis = 0;`
241			`if (verilog == 1)`
242			`fprintf (file, " #include");`
243			`};`
244	4	jcastillo
245
246			`dollar:`
247	12	jcastillo	`DOLLAR`
248			`{`
249			`defineparenthesis = 0;`
250			`if (verilog == 1)`
251			`fprintf (file, " $");`
252			`};`
253	4	jcastillo
254			`intconv:`
255	12	jcastillo	`INTCONV`
256			`{`
257			`defineparenthesis = 0;`
258			`if (verilog == 1)`
259			`fprintf (file, " (int)");`
260			`};`
261	4	jcastillo
262			`tab:`
263	12	jcastillo	`TAB`
264			`{`
265			`defineparenthesis = 0;`
266			`if (verilog == 1)`
267			`fprintf (file, " \t");`
268			`};`
269
270	2	jcastillo	`read:`
271	12	jcastillo	`READ OPENPAR CLOSEPAR`
272			`{`
273			`defineparenthesis = 0;`
274			`if (verilog == 1)`
275			`fprintf (file, ".read()");`
276	4	jcastillo
277	12	jcastillo	`}`
278
279			`defineword:`
280			`DEFINE WORD WORD`
281			`{`
282			`defineparenthesis = 0;`
283			`if (translate == 1 && verilog == 0)`
284			`{`
285			`if (processfound)`
286			`{`
287			fprintf (file, "`define %s %s\n", (char ) $2, (char ) $3);
288			`InsertDefine (defineslist, (char *) $2);`
289			`}`
290			`else`
291			`{`
292			fprintf (FILE_DEFINES, "`define %s %s\n", (char ) $2, (char ) $3);
293			`InsertDefine (defineslist, (char *) $2);`
294			`}`
295			`}`
296			`else if (verilog == 1)`
297			`fprintf (file, "#define %s %s\n", (char ) $2, (char ) $3);`
298
299			`};`
300
301			`definenumber:`
302			`DEFINE WORD NUMBER`
303			`{`
304			`defineparenthesis = 0;`
305			`if (translate == 1 && verilog == 0)`
306			`{`
307			`if (processfound)`
308			`{`
309			fprintf (file, "`define %s %d\n", (char *) $2, (int) $3);
310			`InsertDefine (defineslist, (char *) $2);`
311			`}`
312			`else`
313			`{`
314			fprintf (FILE_DEFINES, "`define %s %d\n", (char *) $2, (int) $3);
315			`InsertDefine (defineslist, (char *) $2);`
316			`}`
317			`}`
318			`else if (verilog == 1)`
319			`fprintf (file, "#define %s %d\n", (char *) $2, (int) $3);`
320
321			`};`
322
323
324			`definemacro:`
325			`DEFINE WORD OPENPAR CLOSEPAR`
326			`{`
327			`defineparenthesis = 0;`
328			`//Macro found`
329			`if (translate == 1 && verilog == 0)`
330			`{`
331			`InsertDefine (defineslist, (char *) $2);`
332			`definefound = 1;`
333			`if (processfound)`
334			fprintf (file, "`define %s ", (char *) $2);
335			`else`
336			fprintf (FILE_DEFINES, "`define %s ", (char *) $2);
337			`}`
338			`else if (verilog == 1)`
339			`fprintf (file, "#define %s ()", (char *) $2);`
340			`}`
341
342	2	jcastillo	`void:`
343	12	jcastillo	`WORD TWODOUBLEPOINTS WORD OPENPAR CLOSEPAR`
344			`{`
345			`defineparenthesis = 0;`
346			`if (translate == 1 && verilog == 0)`
347			`{`
348			`strcpy (processname, (char *) $4);`
349			`strcpy (processname2, (char *) $4);`
350			`strcat (processname2, (char *) ".sc2v");`
351			`strcpy (fileregs, (char *) $4);`
352			`strcat (fileregs, (char *) "_regs.sc2v");`
353			`}`
354			`else if (verilog == 1)`
355			`fprintf (file, " %s::%s()", (char ) $1, (char ) $3);`
356
357			`}`
358
359	2	jcastillo	`sc_int:`
360	12	jcastillo	`SC_INT LOWER NUMBER BIGGER`
361			`{`
362			`defineparenthesis = 0;`
363			`if (translate == 1 && verilog == 0)`
364			`{`
365			`if (processfound)`
366			`{`
367			`fprintf (regs_file, "reg[%d:0] ", (-1 + $3));`
368			`reg_found = 1;`
369			`}`
370			`}`
371			`else if (verilog == 1)`
372			`fprintf (file, "sc_int<%d>", $3);`
373	2	jcastillo
374	12	jcastillo	`}`
375
376			`;`
377
378	2	jcastillo	`sc_uint:`
379	12	jcastillo	`SC_UINT LOWER NUMBER BIGGER`
380			`{`
381			`defineparenthesis = 0;`
382			`if (translate == 1 && verilog == 0)`
383			`{`
384			`if (processfound)`
385			`{`
386			`fprintf (regs_file, "reg[%d:0] ", (-1 + $3));`
387			`reg_found = 1;`
388			`}`
389			`}`
390			`else if (verilog == 1)`
391			`fprintf (file, "sc_uint<%d>", $3);`
392			`}`
393
394			`;`
395
396	2	jcastillo	`sc_bigint:`
397	12	jcastillo	`SC_BIGINT LOWER NUMBER BIGGER`
398			`{`
399			`defineparenthesis = 0;`
400			`if (translate == 1 && verilog == 0)`
401			`{`
402			`if (processfound)`
403			`{`
404			`fprintf (regs_file, "reg[%d:0] ", (-1 + $3));`
405			`reg_found = 1;`
406			`}`
407			`}`
408			`else if (verilog == 1)`
409			`fprintf (file, "sc_bigint<%d> ", $3);`
410			`}`
411	2	jcastillo
412	12	jcastillo	`;`
413
414	2	jcastillo	`sc_biguint:`
415	12	jcastillo	`SC_BIGUINT LOWER NUMBER BIGGER`
416			`{`
417			`defineparenthesis = 0;`
418			`if (translate == 1 && verilog == 0)`
419			`{`
420			`if (processfound)`
421			`{`
422			`fprintf (regs_file, "reg[%d:0] ", (-1 + $3));`
423			`reg_found = 1;`
424			`}`
425			`}`
426			`else if (verilog == 1)`
427			`fprintf (file, "sc_biguint<%d> ", $3);`
428			`}`
429	2	jcastillo
430	12	jcastillo	`;`
431
432	2	jcastillo	`bool:`
433	12	jcastillo	`BOOL`
434			`{`
435			`defineparenthesis = 0;`
436			`if (translate == 1 && verilog == 0)`
437			`{`
438			`if (processfound)`
439			`{`
440			`fprintf (regs_file, "reg ");`
441			`reg_found = 1;`
442			`}`
443			`}`
444			`else if (verilog == 1)`
445			`fprintf (file, "bool");`
446			`}`
447	2	jcastillo
448	12	jcastillo	`;`
449
450	2	jcastillo	`range:`
451	12	jcastillo	`RANGE OPENPAR NUMBER COLON NUMBER CLOSEPAR`
452			`{`
453			`defineparenthesis = 0;`
454			`if (translate == 1 && verilog == 0)`
455			`{`
456			`if (processfound)`
457			`fprintf (file, "[%d:%d]", $3, $5);`
458			`else if (definefound)`
459			`fprintf (FILE_DEFINES, "[%d:%d]", $3, $5);`
460			`}`
461			`else if (verilog == 1)`
462			`fprintf (file, ".range(%d,%d)", $3, $5);`
463			`}`
464
465			`;`
466
467			`number:`
468			`NUMBER`
469			`{`
470			`defineparenthesis = 0;`
471			`if (translate == 1 && verilog == 0)`
472			`{`
473			`if (processfound)`
474			`if (reg_found)`
475			`{`
476			`if (opencorchfound)`
477			`fprintf (regs_file, "%d:0", -1 + $1);`
478			`else`
479			`fprintf (regs_file, "%d", $1);`
480			`}`
481			`else`
482			`fprintf (file, "%d", $1);`
483			`else if (definefound)`
484			`fprintf (FILE_DEFINES, "%d", $1);`
485			`}`
486			`else if (verilog == 1)`
487			`fprintf (file, "%d", $1);`
488			`}`
489
490			`;`
491			`word:`
492			`WORD`
493			`{`
494			`defineparenthesis = 0;`
495			`if (translate == 1 && verilog == 0)`
496			`{`
497			`if (processfound)`
498			`{`
499			`if (openedcase)`
500			`{`

Browse

Tools

Subversion Repositories sc2v

[/] [sc2v/] [trunk/] [src/] [sc2v_step1.y] - Blame information for rev 12