| /* C++ parsers require Bison 3 */ | |
| %require "3.0" | |
| %language "C++" | |
| /* Write-out tokens header file */ | |
| %defines | |
| /* Use Bison's 'variant' to store values. | |
| * This allows us to use non POD types (e.g. | |
| * with constructors/destrictors), which is | |
| * not possible with the default mode which | |
| * uses unions. | |
| */ | |
| %define api.value.type variant | |
| /* | |
| * Use the 'complete' symbol type (i.e. variant) | |
| * in the lexer | |
| */ | |
| %define api.token.constructor | |
| /* | |
| * Add a prefix the make_* functions used to | |
| * create the symbols | |
| */ | |
| %define api.token.prefix {TOKEN_} | |
| /* | |
| * Use a re-entrant (no global vars) parser | |
| */ | |
| /*%define api.pure full*/ | |
| /* Wrap everything in our namespace */ | |
| %define api.namespace {blifparse} | |
| /* Name the parser class */ | |
| %define parser_class_name {Parser} | |
| /* Match the flex prefix */ | |
| %define api.prefix {blifparse_} | |
| /* Extra checks for correct usage */ | |
| %define parse.assert | |
| /* Enable debugging info */ | |
| %define parse.trace | |
| /* Better error reporting */ | |
| %define parse.error verbose | |
| /* | |
| * Fixes inaccuracy in verbose error reporting. | |
| * May be slow for some grammars. | |
| */ | |
| /*%define parse.lac full*/ | |
| /* Track locations */ | |
| /*%locations*/ | |
| /* Generate a table of token names */ | |
| %token-table | |
| %lex-param {Lexer& lexer} | |
| %parse-param {Lexer& lexer} | |
| %parse-param {Callback& callback} | |
| %code requires { | |
| #include <memory> | |
| #include "blifparse.hpp" | |
| #include "blif_lexer_fwd.hpp" | |
| } | |
| %code top { | |
| #include "blif_lexer.hpp" | |
| //Bison calls blifparse_lex() to get the next token. | |
| //We use the Lexer class as the interface to the lexer, so we | |
| //re-defined the function to tell Bison how to get the next token. | |
| static blifparse::Parser::symbol_type blifparse_lex(blifparse::Lexer& lexer) { | |
| return lexer.next_token(); | |
| } | |
| } | |
| %{ | |
| #include <stdio.h> | |
| #include "assert.h" | |
| #include "blifparse.hpp" | |
| #include "blif_common.hpp" | |
| #include "blif_error.hpp" | |
| using namespace blifparse; | |
| %} | |
| /* Declare constant */ | |
| %token DOT_NAMES ".names" | |
| %token DOT_LATCH ".latch" | |
| %token DOT_MODEL ".model" | |
| %token DOT_SUBCKT ".subckt" | |
| %token DOT_INPUTS ".inputs" | |
| %token DOT_OUTPUTS ".outputs" | |
| %token DOT_CLOCK ".clock" | |
| %token DOT_END ".end" | |
| %token DOT_BLACKBOX ".blackbox" | |
| %token LATCH_FE "fe" | |
| %token LATCH_RE "re" | |
| %token LATCH_AH "ah" | |
| %token LATCH_AL "al" | |
| %token LATCH_AS "as" | |
| %token NIL "NIL" | |
| %token LATCH_INIT_2 "2" | |
| %token LATCH_INIT_3 "3" | |
| %token LOGIC_FALSE "0" | |
| %token LOGIC_TRUE "1" | |
| %token LOGIC_DONT_CARE "-" | |
| %token EQ "=" | |
| %token EOL "end-of-line" | |
| %token EOF 0 "end-of-file" | |
| /*BLIF extensions */ | |
| %token DOT_CONN ".conn" | |
| %token DOT_ATTR ".attr" | |
| %token DOT_PARAM ".param" | |
| %token DOT_CNAME ".cname" | |
| /* declare variable tokens */ | |
| %token <std::string> STRING | |
| /* declare types */ | |
| %type <SubCkt> subckt | |
| %type <Names> names | |
| %type <std::vector<std::string>> string_list | |
| %type <std::vector<LogicValue>> so_cover_row | |
| %type <LogicValue> logic_value | |
| %type <LogicValue> latch_init | |
| %type <std::string> latch_control | |
| %type <LatchType> latch_type | |
| /* BLIF Extensions */ | |
| %type <Conn> conn | |
| %type <Cname> cname | |
| %type <Attr> attr | |
| %type <Param> param | |
| /* Top level rule */ | |
| %start blif_data | |
| %% | |
| blif_data: /*empty*/ { } | |
| | blif_data DOT_MODEL STRING EOL { callback.lineno(lexer.lineno()-1); callback.begin_model($3); } | |
| | blif_data DOT_INPUTS string_list EOL { callback.lineno(lexer.lineno()-1); callback.inputs($3); } | |
| | blif_data DOT_OUTPUTS string_list EOL { callback.lineno(lexer.lineno()-1); callback.outputs($3); } | |
| | blif_data names { callback.lineno(lexer.lineno()-1); callback.names($2.nets, $2.so_cover); } | |
| | blif_data subckt EOL { | |
| if($2.ports.size() != $2.nets.size()) { | |
| blif_error_wrap(callback ,lexer.lineno()-1, lexer.text(), | |
| "Mismatched subckt port and net connection(s) size do not match" | |
| " (%zu ports, %zu nets)", $2.ports.size(), $2.nets.size()); | |
| } | |
| callback.lineno(lexer.lineno()-1); | |
| callback.subckt($2.model, $2.ports, $2.nets); | |
| } | |
| | blif_data latch EOL { /*callback already called */ } | |
| | blif_data DOT_BLACKBOX EOL { callback.lineno(lexer.lineno()-1); callback.blackbox(); } | |
| | blif_data DOT_END EOL { callback.lineno(lexer.lineno()-1); callback.end_model(); } | |
| | blif_data conn EOL { callback.lineno(lexer.lineno()-1); callback.conn($2.src, $2.dst); } | |
| | blif_data cname EOL { callback.lineno(lexer.lineno()-1); callback.cname($2.name); } | |
| | blif_data attr EOL { callback.lineno(lexer.lineno()-1); callback.attr($2.name, $2.value); } | |
| | blif_data param EOL { callback.lineno(lexer.lineno()-1); callback.param($2.name, $2.value); } | |
| | blif_data EOL { /* eat end-of-lines */} | |
| ; | |
| names: DOT_NAMES string_list EOL { $$ = Names(); $$.nets = $2; } | |
| | names so_cover_row EOL { | |
| $$ = std::move($1); | |
| if($$.nets.size() != $2.size()) { | |
| blif_error_wrap(callback, lexer.lineno()-1, lexer.text(), | |
| "Mismatched .names single-output cover row." | |
| " names connected to %zu net(s), but cover row has %zu element(s)", | |
| $$.nets.size(), $2.size()); | |
| } | |
| $$.so_cover.push_back($2); | |
| } | |
| ; | |
| subckt: DOT_SUBCKT STRING { $$ = SubCkt(); $$.model = $2; } | |
| | subckt STRING EQ STRING { $$ = std::move($1); $$.ports.push_back($2); $$.nets.push_back($4); } | |
| ; | |
| latch: DOT_LATCH STRING STRING { | |
| //Input and output only | |
| callback.lineno(lexer.lineno()); | |
| callback.latch($2, $3, LatchType::UNSPECIFIED, "", LogicValue::UNKOWN); | |
| } | |
| | DOT_LATCH STRING STRING latch_type latch_control { | |
| //Input, output, type and control | |
| callback.lineno(lexer.lineno()); | |
| callback.latch($2, $3, $4, $5, LogicValue::UNKOWN); | |
| } | |
| | DOT_LATCH STRING STRING latch_type latch_control latch_init { | |
| //Input, output, type, control and init-value | |
| callback.lineno(lexer.lineno()); | |
| callback.latch($2, $3, $4, $5, $6); | |
| } | |
| | DOT_LATCH STRING STRING latch_init { | |
| //Input, output, and init-value | |
| callback.lineno(lexer.lineno()); | |
| callback.latch($2, $3, LatchType::UNSPECIFIED, "", $4); | |
| } | |
| ; | |
| latch_init: LOGIC_TRUE { $$ = LogicValue::TRUE; } | |
| | LOGIC_FALSE { $$ = LogicValue::FALSE; } | |
| | LATCH_INIT_2 { $$ = LogicValue::DONT_CARE; } | |
| | LATCH_INIT_3 { $$ = LogicValue::UNKOWN; } | |
| ; | |
| latch_control: STRING { $$ = $1;} | |
| | NIL { $$ = ""; } | |
| ; | |
| latch_type: LATCH_FE { $$ = LatchType::FALLING_EDGE; } | |
| | LATCH_RE { $$ = LatchType::RISING_EDGE; } | |
| | LATCH_AH { $$ = LatchType::ACTIVE_HIGH; } | |
| | LATCH_AL { $$ = LatchType::ACTIVE_LOW; } | |
| | LATCH_AS { $$ = LatchType::ASYNCHRONOUS; } | |
| ; | |
| so_cover_row: logic_value { $$ = std::vector<LogicValue>(); $$.push_back($1); } | |
| | so_cover_row logic_value { $$ = std::move($1); $$.push_back($2); } | |
| ; | |
| logic_value: LOGIC_TRUE { $$ = LogicValue::TRUE; } | |
| | LOGIC_FALSE { $$ = LogicValue::FALSE; } | |
| | LOGIC_DONT_CARE { $$ = LogicValue::DONT_CARE; } | |
| ; | |
| string_list: /*empty*/ { $$ = std::vector<std::string>(); } | |
| | string_list STRING { $$ = std::move($1); $$.push_back($2); } | |
| ; | |
| /* | |
| * BLIF Extensions | |
| */ | |
| conn: DOT_CONN STRING STRING { $$ = Conn(); $$.src = $2; $$.dst = $3; } | |
| cname: DOT_CNAME STRING { $$ = Cname(); $$.name = $2; } | |
| attr: DOT_ATTR STRING STRING { $$ = Attr(); $$.name = $2; $$.value = $3; } | |
| | DOT_ATTR STRING { $$ = Attr(); $$.name = $2; $$.value = ""; } | |
| param: DOT_PARAM STRING STRING { $$ = Param(); $$.name = $2; $$.value = $3; } | |
| | DOT_PARAM STRING { $$ = Param(); $$.name = $2; $$.value = ""; } | |
| %% | |
| void blifparse::Parser::error(const std::string& msg) { | |
| blif_error_wrap(callback, lexer.lineno(), lexer.text(), msg.c_str()); | |
| } |