oaverilogscanner.lpp

openaccess与verilog互相转化时所用的源代码

%{
// *****************************************************************************
// *****************************************************************************
// oaVerilogScanner.lpp
//
// This file contains the scanner for the Verilog Language IEEE Std 1364-2001.
// Compile with the following:
//     flex++ -t -PvliYY -S$(SRCDIR)/Scanner.skl
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2003-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: sailajad $
//  $Revision: 1.37 $
//  $Date: 2005/08/05 21:48:55 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************

#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#ifndef WIN32
#include <inttypes.h>
#include <unistd.h>
#endif


#include "oaVerilogInPvt.h"

BEGIN_VERILOG_NAMESPACE



/* YYRULE_RETURN_ACTION is the action to preform when we have a token*/
#define YYRULE_RETURN_TEXT_ACTION(token) return token
#define YYRULE_RETURN_ACTION(token) return token

/* NOTE: Implementations may limit the maximum number of levels to which 
 *       include files can be nested,but the limit shall be at least 15.
 */

/* From the flex manual
 * Redefining YY_BREAK allows, for example,
 * C++ users to #define YY_BREAK to do nothing (while being very careful
 * that every rule ends with a "break" or a "return"!) to avoid suffering
 * from unreachable statement warnings where because a rule's action ends
 *  with "return", the YY_BREAK is inaccessible.
 */
#if defined(__cplusplus)
#define YY_BREAK
#endif /* __cplusplus */

#define YYLVAL (*yylval)
#define VARIABLE_TOKEN_ACTION YYLVAL.oaStringStype() = new oaString(yytext);
#define NUMBER_TOKEN_ACTION  YYLVAL.oaStringStype() = cleanNumber(yytext);

#define CONSTANT_TOKEN_ACTION ;

#define OPERATOR_TOKEN_ACTION VARIABLE_TOKEN_ACTION

#define ECHO

/* Code executed at the beginning of each rule, after yytext and yyleng
 * have been set up.
 */
#define YY_USER_ACTION  YYLVAL.clear();

%}

%a 2000
%e 1500
%k 1000
%n 500
%p 4000

/* exclusive start conditions */
%x COMMENT
%x QSTRING
%x NUMBER_B
%x NUMBER_H
%x NUMBER_D
%x NUMBER_O
%x INCLUDE
%x LIBRARYID
%x LIBRARY
%x TIC_INCLUDE
%x TIC_LINE_NUMBER
%x TIC_LINE_FILE
%x TIC_LINE_LEVEL
/* non-exclusive start conditions */
%s UNDEF
%s MODULE
%s UDP
%s TABLE
%s SPECIFY

%s CONFIG
/* %s TASK */
/* %s CASE */ 
/* %s FUNCTION */
/* %s GENERATE */

Newline        [\n]
Space          [\r\t\b ]
Alpha          [[:alpha:]]
AlphaU         [[:alpha:]_]
AlphaNum       [[:alnum:]]
AlphaNumU      [[:alnum:]_]
AlphaNumUD     [[:alnum:]_$]
DecimalDigit   [[:digit:]]
DecimalDigitU  [[:digit:]_]
BinaryDigit    [01]
BinaryDigitU   [01_]
OctalDigit     [0-7]
OctalDigitU    [0-7_]
HexDigit       [[:xdigit:]]
HexDigitU      [[:xdigit:]_]
DigitDC        [Xx]
DigitHI        [Zz?]
BinBase        '[Bb]
HexBase        '[Hh]
DecBase        '[Dd]
OctBase        '[Oo]
DecimalPoint   \.
DecimalValue   {DecimalDigit}{DecimalDigitU}*
BinaryValue    ({BinaryDigit}|{DigitDC}|{DigitHI})({BinaryDigitU}|{DigitDC}|{DigitHI})*
OctalValue     ({OctalDigit}|{DigitDC}|{DigitHI})({OctalDigitU}|{DigitDC}|{DigitHI})*
HexValue       ({HexDigit}|{DigitDC}|{DigitHI})({HexDigitU}|{DigitDC}|{DigitHI})*
SciNot         [eE]
FloatValue     {DecimalValue}({DecimalPoint}{DecimalValue}|({DecimalPoint}{DecimalValue})?{SciNot}[+-]?{DecimalValue})
EdgeDesc       01|10|[01][Xx]|[Xx][10]
EdgeSym        [RrFrPpNn*]
LevelSym       [01XxBb?]
OutputSym      [01Xx]
Allchar        [[:alnum:]\`~!@#\$\%\^&\*\(\)_\+\-=\{\}\[\]|\\:;\"'\<,\>\.\?\/]
PathChars      [[:alnum:]\`~!@#\$\%\^&\*\(\)_\+\-=\{\}\[\]|\\:;\"'\<,\>\.\?\/]

%option case-sensitive
%option stack

%option yyclass="Scanner"
%option backup

%%


<INITIAL,MODULE,UDP,TABLE,INCLUDE,LIBRARYID,LIBRARY,SPECIFY,CONFIG>{Newline} {
      fileLineNumber[includeStackPtr]++;
      CONSTANT_TOKEN_ACTION;
      break;
   }

<INITIAL,UNDEF,MODULE,UDP,TABLE,INCLUDE,LIBRARYID,LIBRARY,TIC_INCLUDE,TIC_LINE_NUMBER,TIC_LINE_FILE,TIC_LINE_LEVEL,SPECIFY,CONFIG>{Space}+ {
      CONSTANT_TOKEN_ACTION;
      break;
   }

<INITIAL,MODULE,UDP,TABLE,INCLUDE,LIBRARYID,LIBRARY,SPECIFY,CONFIG>"/*" {
      yy_push_state(COMMENT);
      CONSTANT_TOKEN_ACTION;
      break;
   }

<COMMENT>[^*\n]* {
      /* eat anything that's not a '*' */
      CONSTANT_TOKEN_ACTION;
      break;
   }

<COMMENT>[^*\n]*\n {
      fileLineNumber[includeStackPtr]++;
      CONSTANT_TOKEN_ACTION;
      break;
   }

<COMMENT>"*"+[^*/\n]* {
      /* eat up '*'s not followed by '/'s */
      CONSTANT_TOKEN_ACTION;
      break;
   }

<COMMENT>"*"+[^*/\n]*\n {
      fileLineNumber[includeStackPtr]++;
      CONSTANT_TOKEN_ACTION;
      break;
   }

<COMMENT>"*"+"/" {
      yy_pop_state();
      CONSTANT_TOKEN_ACTION;
      break;
   }

<INITIAL,MODULE,UDP,TABLE,SPECIFY,CONFIG>"//"[^\n]*\n {
      fileLineNumber[includeStackPtr]++;
      CONSTANT_TOKEN_ACTION;
      break;
   }

<INITIAL,MODULE,UDP,TABLE,SPECIFY,CONFIG>"//"[^\n]* {
      CONSTANT_TOKEN_ACTION;
      break;
   }

<MODULE,UDP,SPECIFY>"#" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPOUND);
   }
<MODULE,UDP,SPECIFY>"@" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYAT);
   }
<MODULE,UDP,SPECIFY>"->" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYMINUSGREATER);
   }
<MODULE,UDP,SPECIFY>"=>" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEQUALGREATER);
   }
<MODULE,UDP,SPECIFY>"*>" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYASTERICGREATER);
   }
<MODULE,UDP,SPECIFY>"-:" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYMINUSCOLON);
   }
<MODULE,UDP,SPECIFY>"+:" {
      CONSTANT_TOKEN_ACTION;
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPLUSCOLON);
   }
<MODULE,UDP,SPECIFY>"(*" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLPARENASTERIC);
   }
<MODULE,UDP,SPECIFY>"*)" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYASTERICRPAREN);
   }
<MODULE,UDP,SPECIFY>"#(" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPOUNDLPAREN);
   }

<MODULE,UDP,SPECIFY>"=" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEQUAL);
   }
<MODULE,UDP,SPECIFY>"+" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPLUS);
   }
<MODULE,UDP,TABLE,SPECIFY>"-" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYMINUS);
   }
<MODULE,UDP,SPECIFY>"!" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEXCLAM);
   }
<MODULE,UDP,SPECIFY>"~" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYTILDE);
   }
<MODULE,UDP,SPECIFY>"&" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYAMPER);
   }
<MODULE,UDP,SPECIFY>"~&" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYTILDEAMPER);
   }
<MODULE,UDP,SPECIFY>"|" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYVERTBAR);
   }
<MODULE,UDP,SPECIFY>"~|" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYTILDEVERTBAR);
   }
<MODULE,UDP,SPECIFY>"^" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYCARET);
   }
<MODULE,UDP,SPECIFY>"~^" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYTILDECARET);
   }
<MODULE,UDP,SPECIFY>"^~" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYCARETTILDE);
   }

<MODULE,UDP,SPECIFY>"*" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYASTERIC);
   }
<MODULE,UDP,SPECIFY>"/" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYSLASH);
   }
<MODULE,UDP,SPECIFY>"%" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPERCENT);
   }
<MODULE,UDP,SPECIFY>"==" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEQUALEQUAL);
   }
<MODULE,UDP,SPECIFY>"!=" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEXCLAMEQUAL);
   }
<MODULE,UDP,SPECIFY>"===" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEQUALEQUALEQUAL);
   }
<MODULE,UDP,SPECIFY>"!==" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYEXCLAMEQUALEQUAL);
   }
<MODULE,UDP,SPECIFY>"&&" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYAMPERAMPER);
   }
<MODULE,UDP,SPECIFY>"||" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYVERTBARVERTBAR);
   }
<MODULE,UDP,SPECIFY>"<" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLESS);
   }
<MODULE,UDP,SPECIFY>"<=" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLESSEQUAL);
   }
<MODULE,UDP,SPECIFY>">" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYGREATER);
   }
<MODULE,UDP,SPECIFY>">=" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYGREATEREQUAL);
   }
<MODULE,UDP,SPECIFY>">>" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYGREATERGREATER);
   }
<MODULE,UDP,SPECIFY>"<<" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLESSLESS);
   }
<MODULE,UDP,SPECIFY>">>>" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYGREATERGREATERGREATER);
   }
<MODULE,UDP,SPECIFY>"<<<" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLESSLESSLESS);
   }
<MODULE,UDP,SPECIFY>"**" {
      OPERATOR_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYASTERICASTERIC);
   }

<MODULE,UDP,TABLE,SPECIFY>"?" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYQUESTION);
   }
<MODULE,UDP,TABLE,SPECIFY>":" {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYCOLON);
   }

<INITIAL>config {
      yy_push_state(CONFIG);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYCONFIG);
   }
<INITIAL>macromodule {
      yy_push_state(MODULE);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYMACROMODULE);
   }
<INITIAL>module {
      yy_push_state(MODULE);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYMODULE);
   }
<INITIAL>primitive {
      yy_push_state(UDP);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPRIMITIVE);
   }
<INITIAL>include {
      yy_push_state(INCLUDE);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYINCLUDE);
   }
<INITIAL>library {
      yy_push_state(LIBRARY);
      yy_push_state(LIBRARYID);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLIBRARY);
   }

<CONFIG>config {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYCONFIG);
   }
<CONFIG>design {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDESIGN);
   }
<CONFIG>liblist {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYLIBLIST);
   }
<CONFIG>instance {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYINSTANCE);
   }
<CONFIG>use {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYUSE);
   }
<CONFIG>cell {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYCELL);
   }
<CONFIG>endconfig {
      yy_pop_state();
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYENDCONFIG);
   }

<SPECIFY>\$fullskew {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_FULLSKEW);
   } 
<SPECIFY>\$hold {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_HOLD);
   } 
<SPECIFY>\$nochange {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_NOCHANGE);
   } 
<SPECIFY>\$period {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_PERIOD);
   } 
<SPECIFY>\$recovery {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_RECOVERY);
   } 
<SPECIFY>\$recrem {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_RECREM);
   } 
<SPECIFY>\$removal {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_REMOVAL);
   } 
<SPECIFY>\$setup {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_SETUP);
   } 
<SPECIFY>\$setuphold {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_SETUPHOLD);
   } 
<SPECIFY>\$skew {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_SKEW);
   } 
<SPECIFY>\$timeskew {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_TIMESKEW);
   } 
<SPECIFY>\$width {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYDOLLAR_WIDTH);
   } 
<SPECIFY>pulsestyle_onevent {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPULSESTYLE_ONEVENT);
   }
<SPECIFY>pulsestyle_ondetect {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYPULSESTYLE_ONDETECT);
   }
<SPECIFY>showcancelled {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYSHOWCANCELLED);
   }
<SPECIFY>noshowcancelled {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYNOSHOWCANCELLED);
   }
<SPECIFY>endspecify {
      yy_pop_state();
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYENDSPECIFY);
   }

<TABLE>endtable {
      yy_pop_state();
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYENDTABLE);
   }

<MODULE>endmodule {
      yy_pop_state();
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYENDMODULE);
   }

<UDP>table {
      yy_push_state(TABLE);
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYTABLE);
   }
<UDP>endprimitive {
      yy_pop_state();
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYENDPRIMITIVE);
   }

<MODULE,UDP,SPECIFY>always {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYALWAYS);
   }
<MODULE,UDP,SPECIFY>and {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYAND);
   }
<MODULE,UDP,SPECIFY>assign {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYASSIGN);
   }
<MODULE,UDP,SPECIFY>automatic {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYAUTOMATIC);
   }
<MODULE,UDP,SPECIFY>begin {
      CONSTANT_TOKEN_ACTION;
      YYRULE_RETURN_ACTION(YYBEGIN);
   }
<MODULE,UDP,SPECIFY>bufif0 {