Branch: refs/heads/master Author: Jiřà Techet techet@gmail.com Committer: Jiřà Techet techet@gmail.com Date: Mon, 14 Mar 2022 19:10:07 UTC Commit: ddb05fff2d9bc8391a16e49c329d75e697b674f7 https://github.com/geany/geany/commit/ddb05fff2d9bc8391a16e49c329d75e697b674...
Log Message: ----------- Use uctags verilog parser
The new parser is token-based and appears to be significantly improved.
Modified Paths: -------------- ctags/Makefile.am ctags/parsers/geany_verilog.c ctags/parsers/verilog.c
Modified: ctags/Makefile.am 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -92,7 +92,7 @@ parsers = \ parsers/geany_tcl.c \ parsers/geany_tex.c \ parsers/txt2tags.c \ - parsers/geany_verilog.c \ + parsers/verilog.c \ parsers/geany_vhdl.c
# skip cmd.c and mini-geany.c which define main()
Modified: ctags/parsers/geany_verilog.c 332 lines changed, 0 insertions(+), 332 deletions(-) =================================================================== @@ -1,332 +0,0 @@ -/* -* Copyright (c) 2003, Darren Hiebert -* -* This source code is released for free distribution under the terms of the -* GNU General Public License version 2 or (at your option) any later version. -* -* This module contains functions for generating tags for the Verilog HDL -* (Hardware Description Language). -* -* Language definition documents: -* http://www.eg.bucknell.edu/~cs320/verilog/verilog-manual.html -* http://www.sutherland-hdl.com/on-line_ref_guide/vlog_ref_top.html -* http://www.verilog.com/VerilogBNF.html -* http://eesun.free.fr/DOC/VERILOG/verilog_manual1.html -*/ - -/* - * INCLUDE FILES - */ -#include "general.h" /* must always come first */ - -#include <string.h> -#include <setjmp.h> - -#include "debug.h" -#include "keyword.h" -#include "parse.h" -#include "read.h" -#include "vstring.h" -#include "geany_lcpp.h" -#include "routines.h" -#include "xtag.h" - -/* - * DATA DECLARATIONS - */ -typedef enum eException { ExceptionNone, ExceptionEOF } exception_t; - -typedef enum { - K_UNDEFINED = -1, - K_CONSTANT, - K_EVENT, - K_FUNCTION, - K_MODULE, - K_NET, - K_PORT, - K_REGISTER, - K_TASK -} verilogKind; - -/* - * DATA DEFINITIONS - */ -static int Ungetc; -static int Lang_verilog; -static jmp_buf Exception; - -static kindDefinition VerilogKinds [] = { - { true, 'c', "constant", "constants (define, parameter, specparam)" }, - { true, 'e', "event", "events" }, - { true, 'f', "function", "functions" }, - { true, 'm', "module", "modules" }, - { true, 'n', "net", "net data types" }, - { true, 'p', "port", "ports" }, - { true, 'r', "register", "register data types" }, - { true, 't', "task", "tasks" } -}; - -static keywordTable VerilogKeywordTable [] = { - { "`define", K_CONSTANT }, - { "event", K_EVENT }, - { "function", K_FUNCTION }, - { "inout", K_PORT }, - { "input", K_PORT }, - { "integer", K_REGISTER }, - { "module", K_MODULE }, - { "output", K_PORT }, - { "parameter", K_CONSTANT }, - { "real", K_REGISTER }, - { "realtime", K_REGISTER }, - { "reg", K_REGISTER }, - { "specparam", K_CONSTANT }, - { "supply0", K_NET }, - { "supply1", K_NET }, - { "task", K_TASK }, - { "time", K_REGISTER }, - { "tri0", K_NET }, - { "tri1", K_NET }, - { "triand", K_NET }, - { "tri", K_NET }, - { "trior", K_NET }, - { "trireg", K_NET }, - { "wand", K_NET }, - { "wire", K_NET }, - { "wor", K_NET } -}; - -/* - * FUNCTION DEFINITIONS - */ - -static void initialize (const langType language) -{ - size_t i; - const size_t count = ARRAY_SIZE (VerilogKeywordTable); - Lang_verilog = language; - for (i = 0 ; i < count ; ++i) - { - const keywordTable* const p = &VerilogKeywordTable [i]; - addKeyword (p->name, language, (int) p->id); - } -} - -static void vUngetc (int c) -{ - Assert (Ungetc == '\0'); - Ungetc = c; -} - -static int vGetc (void) -{ - int c; - if (Ungetc == '\0') - c = getcFromInputFile (); - else - { - c = Ungetc; - Ungetc = '\0'; - } - if (c == '/') - { - int c2 = getcFromInputFile (); - if (c2 == EOF) - longjmp (Exception, (int) ExceptionEOF); - else if (c2 == '/') /* strip comment until end-of-line */ - { - do - c = getcFromInputFile (); - while (c != '\n' && c != EOF); - } - else if (c2 == '*') /* strip block comment */ - { - c = lcppSkipOverCComment(); - } - else - { - ungetcToInputFile (c2); - } - } - else if (c == '"') /* strip string contents */ - { - int c2; - do - c2 = getcFromInputFile (); - while (c2 != '"' && c2 != EOF); - c = '@'; - } - if (c == EOF) - longjmp (Exception, (int) ExceptionEOF); - return c; -} - -static bool isIdentifierCharacter (const int c) -{ - return (bool)(isalnum (c) || c == '_' || c == '`'); -} - -static int skipWhite (int c) -{ - while (isspace (c)) - c = vGetc (); - return c; -} - -static int skipPastMatch (const char *const pair) -{ - const int begin = pair [0], end = pair [1]; - int matchLevel = 1; - int c; - do - { - c = vGetc (); - if (c == begin) - ++matchLevel; - else if (c == end) - --matchLevel; - } - while (matchLevel > 0); - return vGetc (); -} - -static bool readIdentifier (vString *const name, int c) -{ - vStringClear (name); - if (isIdentifierCharacter (c)) - { - while (isIdentifierCharacter (c)) - { - vStringPut (name, c); - c = vGetc (); - } - vUngetc (c); - } - return (bool)(name->length > 0); -} - -static void tagNameList (const verilogKind kind, int c) -{ - vString *name = vStringNew (); - bool repeat; - Assert (isIdentifierCharacter (c)); - do - { - repeat = false; - if (isIdentifierCharacter (c)) - { - readIdentifier (name, c); - makeSimpleTag (name, kind); - } - else - break; - c = skipWhite (vGetc ()); - if (c == '[') - c = skipPastMatch ("[]"); - c = skipWhite (c); - if (c == '=') - { - c = skipWhite (vGetc ()); - if (c == '{') - skipPastMatch ("{}"); - else - { - do - c = vGetc (); - while (c != ',' && c != ';'); - } - } - if (c == ',') - { - c = skipWhite (vGetc ()); - repeat = true; - } - else - repeat = false; - } while (repeat); - vStringDelete (name); - vUngetc (c); -} - -static void findTag (vString *const name) -{ - const verilogKind kind = (verilogKind) lookupKeyword (vStringValue (name), Lang_verilog); - if (kind == K_CONSTANT && vStringChar (name, 0) == '`') - { - /* Bug #961001: Verilog compiler directives are line-based. */ - int c = skipWhite (vGetc ()); - readIdentifier (name, c); - makeSimpleTag (name, kind); - /* Skip the rest of the line. */ - do { - c = vGetc(); - } while (c != '\n'); - vUngetc (c); - } - else if (kind != K_UNDEFINED) - { - int c = skipWhite (vGetc ()); - - /* Many keywords can have bit width. - * reg [3:0] net_name; - * inout [(`DBUSWIDTH-1):0] databus; - */ - if (c == '(') - c = skipPastMatch ("()"); - c = skipWhite (c); - if (c == '[') - c = skipPastMatch ("[]"); - c = skipWhite (c); - if (c == '#') - { - c = vGetc (); - if (c == '(') - c = skipPastMatch ("()"); - } - c = skipWhite (c); - if (isIdentifierCharacter (c)) - tagNameList (kind, c); - } -} - -static void findVerilogTags (void) -{ - vString *const name = vStringNew (); - volatile bool newStatement = true; - volatile int c = '\0'; - exception_t exception = (exception_t) setjmp (Exception); - - if (exception == ExceptionNone) while (c != EOF) - { - c = vGetc (); - switch (c) - { - case ';': - case '\n': - newStatement = true; - break; - - case ' ': - case '\t': - break; - - default: - if (newStatement && readIdentifier (name, c)) - findTag (name); - newStatement = false; - break; - } - } - vStringDelete (name); -} - -extern parserDefinition* VerilogParser (void) -{ - static const char *const extensions [] = { "v", NULL }; - parserDefinition* def = parserNew ("Verilog"); - def->kindTable = VerilogKinds; - def->kindCount = ARRAY_SIZE (VerilogKinds); - def->extensions = extensions; - def->parser = findVerilogTags; - def->initialize = initialize; - return def; -}
Modified: ctags/parsers/verilog.c 2024 lines changed, 2024 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,2024 @@ +/* + * Copyright (c) 2003, Darren Hiebert + * Copyright (c) 2017, Vitor Antunes + * Copyright (c) 2020, Hiroo Hayashi + * + * This source code is released for free distribution under the terms of the + * GNU General Public License version 2 or (at your option) any later version. + * + * This module contains functions for generating tags for the Verilog or + * SystemVerilog HDL (Hardware Description Language). + * + * References: + * IEEE Std 1800-2017, SystemVerilog Language Reference Manual + * https://ieeexplore.ieee.org/document/8299595 + * SystemVerilog IEEE Std 1800-2012 Grammer + * https://insights.sigasi.com/tech/systemverilog.ebnf/ + * Verilog Formal Syntax Specification + * http://www.verilog.com/VerilogBNF.html + */ + +/* + * INCLUDE FILES + */ +#include "general.h" /* must always come first */ + +#include <string.h> + +#include "debug.h" +#include "entry.h" +#include "keyword.h" +#include "options.h" +#include "parse.h" +#include "read.h" +#include "routines.h" +#include "xtag.h" +#include "ptrarray.h" + +/* + * MACROS + */ +#define NUMBER_LANGUAGES 2 /* Indicates number of defined indexes */ +#define IDX_SYSTEMVERILOG 0 +#define IDX_VERILOG 1 + +/* + * DATA DECLARATIONS + */ + +/* A callback function searching a symbol from the cork symbol table assumes + * this kind definitions are shared in Verilog and SystemVerilog parsers. + * If you will separate the definitions for the parsers, you must revise the + * code related to the symbol table. */ +typedef enum { + /* parser private items */ + K_IGNORE = -16, /* Verilog/SystemVerilog keywords to be ignored */ + K_DEFINE, + K_DIRECTIVE, + K_END, + K_END_DE, /* End of Design Elements */ + K_IDENTIFIER, + K_LOCALPARAM, + K_PARAMETER, + K_IMPORT, + K_WITH, + + K_UNDEFINED = KEYWORD_NONE, + /* the followings items are also used as indices for VerilogKinds[] and SystemVerilogKinds[] */ + K_CONSTANT= 0, + K_EVENT, + K_FUNCTION, + K_MODULE, + K_NET, + K_PORT, + K_REGISTER, + K_TASK, + K_BLOCK, + K_INSTANCE, + K_ASSERTION, + K_CLASS, + K_COVERGROUP, + K_ENUM, + K_INTERFACE, + K_MODPORT, + K_PACKAGE, + K_PROGRAM, + K_PROTOTYPE, + K_PROPERTY, + K_STRUCT, + K_TYPEDEF, + K_CHECKER, + K_CLOCKING, + K_SEQUENCE, + K_MEMBER, + K_IFCLASS, /* interface class */ + K_CONSTRAINT, + K_NETTYPE, +} verilogKind; + +typedef struct { + const char *keyword; + verilogKind kind; + short isValid [NUMBER_LANGUAGES]; +} keywordAssoc; + +typedef struct sTokenInfo { + verilogKind kind; + vString* name; /* the name of the token */ + unsigned long lineNumber; /* line number where token was found */ + MIOPos filePosition; /* file position where token was found */ + struct sTokenInfo* scope; /* context of keyword */ + int nestLevel; /* Current nest level */ + verilogKind lastKind; /* Kind of last found tag */ + vString* blockName; /* Current block name */ + vString* inheritance; /* Class inheritance */ + bool prototype; /* Is only a prototype */ + bool classScope; /* Context is local to the current sub-context */ + bool parameter; /* parameter which can be overridden */ + bool hasParamList; /* module definition has a parameter port list */ +} tokenInfo; + +typedef enum { + F_PARAMETER, +} verilogField; + +/* + * DATA DEFINITIONS + */ +static int Ungetc; +static int Lang_verilog; +static int Lang_systemverilog; + +static kindDefinition VerilogKinds [] = { + { true, 'c', "constant", "constants (define, parameter, specparam)" }, + { true, 'e', "event", "events" }, + { true, 'f', "function", "functions" }, + { true, 'm', "module", "modules" }, + { true, 'n', "net", "net data types" }, + { true, 'p', "port", "ports" }, + { true, 'r', "register", "variable data types" }, + { true, 't', "task", "tasks" }, + { true, 'b', "block", "blocks (begin, fork)" }, + { true, 'i', "instance", "instances of module" }, +}; + +static kindDefinition SystemVerilogKinds [] = { + { true, 'c', "constant", "constants (define, parameter, specparam, enum values)" }, + { true, 'e', "event", "events" }, + { true, 'f', "function", "functions" }, + { true, 'm', "module", "modules" }, + { true, 'n', "net", "net data types" }, + { true, 'p', "port", "ports" }, + { true, 'r', "register", "variable data types" }, + { true, 't', "task", "tasks" }, + { true, 'b', "block", "blocks (begin, fork)" }, + { true, 'i', "instance", "instances of module or interface" }, + { true, 'A', "assert", "assertions (assert, assume, cover, restrict)" }, + { true, 'C', "class", "classes" }, + { true, 'V', "covergroup","covergroups" }, + { true, 'E', "enum", "enumerators" }, + { true, 'I', "interface", "interfaces" }, + { true, 'M', "modport", "modports" }, + { true, 'K', "package", "packages" }, + { true, 'P', "program", "programs" }, + { false,'Q', "prototype", "prototypes (extern, pure)" }, + { true, 'R', "property", "properties" }, + { true, 'S', "struct", "structs and unions" }, + { true, 'T', "typedef", "type declarations" }, + { true, 'H', "checker", "checkers" }, + { true, 'L', "clocking", "clocking" }, + { true, 'q', "sequence", "sequences" }, + { true, 'w', "member", "struct and union members" }, + { true, 'l', "ifclass", "interface class" }, + { true, 'O', "constraint","constraints" }, + { true, 'N', "nettype", "nettype declarations" }, +}; + +static const keywordAssoc KeywordTable [] = { + /* SystemVerilog */ + /* | Verilog */ + /* keyword keyword ID | | */ + { "`define", K_DEFINE, { 1, 1 } }, + { "begin", K_BLOCK, { 1, 1 } }, + { "end", K_END, { 1, 1 } }, + { "endfunction", K_END_DE, { 1, 1 } }, + { "endmodule", K_END_DE, { 1, 1 } }, + { "endtask", K_END_DE, { 1, 1 } }, + { "event", K_EVENT, { 1, 1 } }, + { "fork", K_BLOCK, { 1, 1 } }, + { "function", K_FUNCTION, { 1, 1 } }, + { "genvar", K_REGISTER, { 1, 1 } }, + { "inout", K_PORT, { 1, 1 } }, + { "input", K_PORT, { 1, 1 } }, + { "integer", K_REGISTER, { 1, 1 } }, + { "join", K_END, { 1, 1 } }, + { "localparam", K_LOCALPARAM, { 1, 1 } }, + { "module", K_MODULE, { 1, 1 } }, + { "output", K_PORT, { 1, 1 } }, + { "parameter", K_PARAMETER, { 1, 1 } }, + { "real", K_REGISTER, { 1, 1 } }, + { "realtime", K_REGISTER, { 1, 1 } }, + { "reg", K_REGISTER, { 1, 1 } }, + { "signed", K_IGNORE, { 1, 1 } }, + { "specparam", K_CONSTANT, { 1, 1 } }, + { "supply0", K_NET, { 1, 1 } }, + { "supply1", K_NET, { 1, 1 } }, + { "task", K_TASK, { 1, 1 } }, + { "time", K_REGISTER, { 1, 1 } }, + { "tri", K_NET, { 1, 1 } }, + { "triand", K_NET, { 1, 1 } }, + { "trior", K_NET, { 1, 1 } }, + { "trireg", K_NET, { 1, 1 } }, + { "tri0", K_NET, { 1, 1 } }, + { "tri1", K_NET, { 1, 1 } }, + { "uwire", K_NET, { 1, 1 } }, + { "wand", K_NET, { 1, 1 } }, + { "wire", K_NET, { 1, 1 } }, + { "wor", K_NET, { 1, 1 } }, + { "assert", K_ASSERTION, { 1, 0 } }, + { "assume", K_ASSERTION, { 1, 0 } }, + { "bit", K_REGISTER, { 1, 0 } }, + { "byte", K_REGISTER, { 1, 0 } }, + { "chandle", K_REGISTER, { 1, 0 } }, + { "checker", K_CHECKER, { 1, 0 } }, + { "class", K_CLASS, { 1, 0 } }, + { "constraint", K_CONSTRAINT, { 1, 0 } }, + { "cover", K_ASSERTION, { 1, 0 } }, + { "clocking", K_CLOCKING, { 1, 0 } }, + { "covergroup", K_COVERGROUP, { 1, 0 } }, + { "endchecker", K_END_DE, { 1, 0 } }, + { "endclass", K_END_DE, { 1, 0 } }, + { "endclocking", K_END_DE, { 1, 0 } }, + { "endgroup", K_END_DE, { 1, 0 } }, + { "endinterface", K_END_DE, { 1, 0 } }, + { "endpackage", K_END_DE, { 1, 0 } }, + { "endprogram", K_END_DE, { 1, 0 } }, + { "endproperty", K_END_DE, { 1, 0 } }, + { "endsequence", K_END_DE, { 1, 0 } }, + { "enum", K_ENUM, { 1, 0 } }, + { "extern", K_PROTOTYPE, { 1, 0 } }, + { "import", K_IMPORT, { 1, 0 } }, + { "int", K_REGISTER, { 1, 0 } }, + { "interconnect", K_NET, { 1, 0 } }, + { "interface", K_INTERFACE, { 1, 0 } }, + { "join_any", K_END, { 1, 0 } }, + { "join_none", K_END, { 1, 0 } }, + { "logic", K_REGISTER, { 1, 0 } }, + { "longint", K_REGISTER, { 1, 0 } }, + { "modport", K_MODPORT, { 1, 0 } }, + { "package", K_PACKAGE, { 1, 0 } }, + { "program", K_PROGRAM, { 1, 0 } }, + { "property", K_PROPERTY, { 1, 0 } }, + { "pure", K_PROTOTYPE, { 1, 0 } }, + { "ref", K_PORT, { 1, 0 } }, + { "restrict", K_ASSERTION, { 1, 0 } }, + { "sequence", K_SEQUENCE, { 1, 0 } }, + { "shortint", K_REGISTER, { 1, 0 } }, + { "shortreal", K_REGISTER, { 1, 0 } }, + { "string", K_REGISTER, { 1, 0 } }, + { "struct", K_STRUCT, { 1, 0 } }, + { "type", K_REGISTER, { 1, 0 } }, + { "typedef", K_TYPEDEF, { 1, 0 } }, + { "union", K_STRUCT, { 1, 0 } }, + { "var", K_REGISTER, { 1, 0 } }, + { "void", K_REGISTER, { 1, 0 } }, + { "with", K_WITH, { 1, 0 } }, + { "nettype", K_NETTYPE, { 1, 0 } }, +// { "virtual", K_PROTOTYPE, { 1, 0 } }, // do not add for now +}; + +static tokenInfo *currentContext = NULL; +static ptrArray *tagContents; +static fieldDefinition *fieldTable = NULL; + +// IEEE Std 1364-2005 LRM, Appendix B "List of Keywords" +const static struct keywordGroup verilogKeywords = { + .value = K_IGNORE, + .addingUnlessExisting = true, + .keywords = { + "always", "and", "assign", "automatic", "begin", "buf", "bufif0", + "bufif1", "case", "casex", "casez", "cell", "cmos", "config", + "deassign", "default", "defparam", "design", "disable", "edge", + "else", "end", "endcase", "endconfig", "endfunction", "endgenerate", + "endmodule", "endprimitive", "endspecify", "endtable", "endtask", + "event", "for", "force", "forever", "fork", "function", "generate", + "genvar", "highz0", "highz1", "if", "ifnone", "incdir", "include", + "initial", "inout", "input", "instance", "integer", "join", "large", + "liblist", "library", "localparam", "macromodule", "medium", "module", + "nand", "negedge", "nmos", "nor", "noshowcancelled", "not", "notif0", + "notif1", "or", "output", "parameter", "pmos", "posedge", "primitive", + "pull0", "pull1", "pulldown", "pullup", "pulsestyle_onevent", + "pulsestyle_ondetect", "rcmos", "real", "realtime", "reg", "release", + "repeat", "rnmos", "rpmos", "rtran", "rtranif0", "rtranif1", + "scalared", "showcancelled", "signed", "small", "specify", + "specparam", "strong0", "strong1", "supply0", "supply1", "table", + "task", "time", "tran", "tranif0", "tranif1", "tri", "tri0", "tri1", + "triand", "trior", "trireg", "unsigned1", "use", "uwire", "vectored", + "wait", "wand", "weak0", "weak1", "while", "wire", "wor", "xnor", "xor", + NULL + }, +}; +// IEEE Std 1800-2017 LRM, Annex B "Keywords" +const static struct keywordGroup systemVerilogKeywords = { + .value = K_IGNORE, + .addingUnlessExisting = true, + .keywords = { + "accept_on", "alias", "always", "always_comb", "always_ff", + "always_latch", "and", "assert", "assign", "assume", "automatic", + "before", "begin", "bind", "bins", "binsof", "bit", "break", "buf", + "bufif0", "bufif1", "byte", "case", "casex", "casez", "cell", + "chandle", "checker", "class", "clocking", "cmos", "config", "const", + "constraint", "context", "continue", "cover", "covergroup", + "coverpoint", "cross", "deassign", "default", "defparam", "design", + "disable", "dist", "do", "edge", "else", "end", "endcase", + "endchecker", "endclass", "endclocking", "endconfig", "endfunction", + "endgenerate", "endgroup", "endinterface", "endmodule", "endpackage", + "endprimitive", "endprogram", "endproperty", "endspecify", + "endsequence", "endtable", "endtask", "enum", "event", "eventually", + "expect", "export", "extends", "extern", "final", "first_match", + "for", "force", "foreach", "forever", "fork", "forkjoin", "function", + "generate", "genvar", "global", "highz0", "highz1", "if", "iff", + "ifnone", "ignore_bins", "illegal_bins", "implements", "implies", + "import", "incdir", "include", "initial", "inout", "input", "inside", + "instance", "int", "integer", "interconnect", "interface", + "intersect", "join", "join_any", "join_none", "large", "let", + "liblist", "library", "local", "localparam", "logic", "longint", + "macromodule", "matches", "medium", "modport", "module", "nand", + "negedge", "nettype", "new", "nexttime", "nmos", "nor", + "noshowcancelled", "not", "notif0", "notif1", "null", "or", "output", + "package", "packed", "parameter", "pmos", "posedge", "primitive", + "priority", "program", "property", "protected", "pull0", "pull1", + "pulldown", "pullup", "pulsestyle_ondetect", "pulsestyle_onevent", + "pure", "rand", "randc", "randcase", "randsequence", "rcmos", "real", + "realtime", "ref", "reg", "reject_on", "release", "repeat", + "restrict", "return", "rnmos", "rpmos", "rtran", "rtranif0", + "rtranif1", "s_always", "s_eventually", "s_nexttime", "s_until", + "s_until_with", "scalared", "sequence", "shortint", "shortreal", + "showcancelled", "signed", "small", "soft", "solve", "specify", + "specparam", "static", "string", "strong", "strong0", "strong1", + "struct", "super", "supply0", "supply1", "sync_accept_on", + "sync_reject_on", "table", "tagged", "task", "this", "throughout", + "time", "timeprecision", "timeunit", "tran", "tranif0", "tranif1", + "tri", "tri0", "tri1", "triand", "trior", "trireg", "type", "typedef", + "union", "unique", "unique0", "unsigned", "until", "until_with", + "untyped", "use", "uwire", "var", "vectored", "virtual", "void", + "wait", "wait_order", "wand", "weak", "weak0", "weak1", "while", + "wildcard", "wire", "with", "within", "wor", "xnor", "xor", + NULL + }, +}; + +// IEEE Std 1364-2005 LRM, "19. Compiler directives" +const static struct keywordGroup verilogDirectives = { + .value = K_DIRECTIVE, + .addingUnlessExisting = true, + .keywords = { + "`begin_keywords", "`celldefine", "`default_nettype", "`define", + "`else", "`elsif", "`end_keywords", "`endcelldefine", "`endif", + "`ifdef", "`ifndef", "`include", "`line", "`nounconnected_drive", + "`pragma", "`resetall", "`timescale", "`unconnected_drive", "`undef", + NULL + }, +}; + +// IEEE Std 1800-2017 LRM, "22. Compiler directives" +const static struct keywordGroup systemVerilogDirectives = { + .value = K_DIRECTIVE, + .addingUnlessExisting = true, + .keywords = { + "`__LINE__", "`begin_keywords", "`celldefine", "`default_nettype", + "`define", "`else", "`elsif", "`end_keywords", "`endcelldefine", + "`endif", "`ifdef", "`ifndef", "`include", "`line", + "`nounconnected_drive", "`pragma", "`resetall", "`timescale", + "`unconnected_drive", "`undef", "`undefineall", + NULL + }, +}; + +// .enabled field cannot be shared by two languages +static fieldDefinition VerilogFields[] = { + { .name = "parameter", + .description = "parameter whose value can be overridden.", + .enabled = false, + .dataType = FIELDTYPE_BOOL }, +}; + +static fieldDefinition SystemVerilogFields[] = { + { .name = "parameter", + .description = "parameter whose value can be overridden.", + .enabled = false, + .dataType = FIELDTYPE_BOOL }, +}; + +/* + * PROTOTYPE DEFINITIONS + */ + +static bool isIdentifier (tokenInfo* token); +static int processDefine (tokenInfo *const token, int c); +static int processType (tokenInfo* token, int c, verilogKind* kind, bool* with); +static int pushEnumNames (tokenInfo* token, int c); +static int pushMembers (tokenInfo* token, int c); +static int readWordToken (tokenInfo *const token, int c); +static int readWordTokenNoSkip (tokenInfo *const token, int c); +static int skipBlockName (tokenInfo *const token, int c); +static int skipClockEvent (tokenInfo* token, int c); +static int skipDelay (tokenInfo* token, int c); +static int tagIdentifierList (tokenInfo *const token, int c, verilogKind kind, bool mayPortDecl); +static int tagNameList (tokenInfo* token, int c, verilogKind kind); + +/* + * FUNCTION DEFINITIONS + */ + +static short isContainer (verilogKind kind) +{ + switch (kind) + { + case K_MODULE: + case K_TASK: + case K_FUNCTION: + case K_BLOCK: + case K_CHECKER: + case K_CLASS: + case K_CLOCKING: + case K_COVERGROUP: + case K_IFCLASS: + case K_INTERFACE: + case K_PACKAGE: + case K_PROGRAM: + case K_PROPERTY: + case K_SEQUENCE: + case K_TYPEDEF: + case K_NETTYPE: + case K_ENUM: + case K_STRUCT: + return true; + default: + return false; + } +} + +static short isTempContext (tokenInfo const* token) +{ + switch (token->kind) + { + case K_TYPEDEF: + case K_NETTYPE: + case K_ENUM: + case K_STRUCT: + return true; + default: + return false; + } +} + +static void clearToken (tokenInfo *token) +{ + token->kind = K_UNDEFINED; // to be set by updateKind() + vStringClear (token->name); + token->lineNumber = getInputLineNumber (); + token->filePosition = getInputFilePosition (); + token->scope = NULL; + token->nestLevel = 0; + token->lastKind = K_UNDEFINED; + vStringClear (token->blockName); + vStringClear (token->inheritance); + token->prototype = false; + token->classScope = false; + token->parameter = false; + token->hasParamList = false; +} + +static tokenInfo *newToken (void) +{ + tokenInfo *const token = xMalloc (1, tokenInfo); + token->name = vStringNew (); + token->blockName = vStringNew (); + token->inheritance = vStringNew (); + clearToken (token); + return token; +} + +static tokenInfo *dupToken (tokenInfo *token) +{ + tokenInfo *dup = newToken (); + tokenInfo tmp = *dup; // save vStrings, name, blockName, and inheritance + *dup = *token; + // revert vStrings allocated for dup + dup->name = tmp.name; + dup->blockName = tmp.blockName; + dup->inheritance = tmp.inheritance; + // copy contents of vStrings + vStringCopy (dup->name, token->name); + vStringCopy (dup->blockName, token->blockName); + vStringCopy (dup->inheritance, token->inheritance); + return dup; +} + +static void deleteToken (tokenInfo * const token) +{ + if (token != NULL) + { + vStringDelete (token->name); + vStringDelete (token->blockName); + vStringDelete (token->inheritance); + eFree (token); + } +} + +static tokenInfo *pushToken (tokenInfo * const token, tokenInfo * const tokenPush) +{ + tokenPush->scope = token; + return tokenPush; +} + +static tokenInfo *popToken (tokenInfo * const token) +{ + tokenInfo *localToken; + if (token != NULL) + { + localToken = token->scope; + deleteToken (token); + return localToken; + } + return NULL; +} + +static void pruneTokens (tokenInfo * token) +{ + while ((token = popToken (token))) + ; +} + +static void swapToken (tokenInfo *t0, tokenInfo *t1) +{ + tokenInfo tmp = *t0; + *t0 = *t1; + *t1 = tmp; +} + +static const char *getNameForKind (const verilogKind kind) +{ + if (isInputLanguage (Lang_systemverilog)) + return (SystemVerilogKinds[kind]).name; + else /* isInputLanguage (Lang_verilog) */ + return (VerilogKinds[kind]).name; +} + +static char kindEnabled (const verilogKind kind) +{ + if (isInputLanguage (Lang_systemverilog)) + return SystemVerilogKinds[kind].enabled; + else /* isInputLanguage (Lang_verilog) */ + return VerilogKinds[kind].enabled; +} + +static void buildKeywordHash (const langType language, unsigned int idx) +{ + size_t i; + const size_t count = ARRAY_SIZE (KeywordTable); + for (i = 0 ; i < count ; ++i) + { + const keywordAssoc *p = &KeywordTable [i]; + if (p->isValid [idx]) + addKeyword (p->keyword, language, (int) p->kind); + } +} + +static void initializeVerilog (const langType language) +{ + Lang_verilog = language; + buildKeywordHash (language, IDX_VERILOG); + addKeywordGroup (&verilogKeywords, language); + addKeywordGroup (&verilogDirectives, language); + if (tagContents == NULL) + tagContents = ptrArrayNew ((ptrArrayDeleteFunc)deleteToken); + +} + +static void initializeSystemVerilog (const langType language) +{ + Lang_systemverilog = language; + buildKeywordHash (language, IDX_SYSTEMVERILOG); + addKeywordGroup (&systemVerilogKeywords, language); + addKeywordGroup (&systemVerilogDirectives, language); + if (tagContents == NULL) + tagContents = ptrArrayNew ((ptrArrayDeleteFunc)deleteToken); +} + +static void vUngetc (int c) +{ + Assert (Ungetc == '\0'); + Ungetc = c; +} + +/* Mostly copied from cppSkipOverCComment() in cpreprocessor.c. + * + * cppSkipOverCComment() uses the internal ungetc buffer of + * CPreProcessor. On the other hand, the Verilog parser uses + * getcFromInputFile() directly. getcFromInputFile() uses just + * another internal ungetc buffer. Using them mixed way will + * cause a trouble. */ +static int verilogSkipOverCComment (void) +{ + int c = getcFromInputFile (); + + while (c != EOF) + { + if (c != '*') + c = getcFromInputFile (); + else + { + const int next = getcFromInputFile (); + + if (next != '/') + c = next; + else + { + c = SPACE; /* replace comment with space */ + break; + } + } + } + return c; +} + +static int _vGetc (bool inSkipPastMatch) +{ + int c; + if (Ungetc == '\0') + c = getcFromInputFile (); + else + { + c = Ungetc; + Ungetc = '\0'; + } + if (c == '/') + { + int c2 = getcFromInputFile (); + if (c2 == EOF) + return EOF; + else if (c2 == '/') /* strip comment until end-of-line */ + { + do + c = getcFromInputFile (); + while (c != '\n' && c != EOF); + } + else if (c2 == '*') /* strip block comment */ + c = verilogSkipOverCComment (); + else + ungetcToInputFile (c2); + } + // replace a string with "@" only in skipPastMatch() + // because the string may contain parens, etc. + else if (inSkipPastMatch && c == '"') + { + int c2; + do + c2 = getcFromInputFile (); + while (c2 != '"' && c2 != EOF); + c = '@'; + } + return c; +} + +static int vGetc (void) +{ + return _vGetc (false); +} + +// Is the first charactor in an identifier? [a-zA-Z_`] +static bool isWordToken (const int c) +{ + return (isalpha (c) || c == '_' || c == '`'); +} + +// Is a charactor in an identifier? [a-zA-Z0-9_`$] +static bool isIdentifierCharacter (const int c) +{ + return (isalnum (c) || c == '_' || c == '`' || c == '$'); +} + +static int skipWhite (int c) +{ + while (isspace (c)) + c = vGetc (); + return c; +} + +static int skipPastMatch (const char *const pair) +{ + const int begin = pair [0], end = pair [1]; + int matchLevel = 1; + int c; + do + { + c = _vGetc (true); + if (c == begin) + ++matchLevel; + else if (c == end) + --matchLevel; + } + while (matchLevel > 0 && c != EOF); + return skipWhite (vGetc ()); +} + +static int skipDimension (int c) +{ + while (c == '[' && c != EOF) + c = skipPastMatch ("[]"); + return c; +} + +static int skipToSemiColon (int c) +{ + while (c != ';' && c != EOF) + c = vGetc (); + return c; // ';' or EOF +} + +static int skipString (int c) +{ + if (c == '"') + { + do + c = vGetc (); + while (c != '"' && c != EOF); + } + c = skipWhite (vGetc ()); + return c; +} + +static int skipExpression (int c) +{ + while (c != ',' && c != ';' && c != ')' && c != '}' && c != ']' && c != EOF) + { + if (c == '(') + c = skipPastMatch ("()"); + else if (c == '{') + c = skipPastMatch ("{}"); + else if (c == '[') + c = skipPastMatch ("[]"); + else if (c == '"') + c = skipString (c); + else + c = skipWhite (vGetc ()); + } + return c; +} + +// Skip to newline. The newline preceded by a backslash ( \ ) is ignored. +// Should be used after readWordTokenNoSkip() for compiler directives +static int skipToNewLine (int c) +{ + bool escape = false; + for ( ; (c != '\n' || escape) && c != EOF; c = vGetc ()) + escape = (c == '\'); + + return c; // '\n' or EOF +} + +static int skipMacro (int c, tokenInfo *token) +{ + tokenInfo *localToken = newToken (); // don't update token outside + while (c == '`') // to support back-to-back compiler directives + { + c = readWordTokenNoSkip (localToken, c); + /* Skip compiler directive other than `define */ + if (localToken->kind == K_DIRECTIVE) + { + c = skipToNewLine (c); + c = skipWhite (c); + } + /* Skip `define */ + else if (localToken->kind == K_DEFINE) + { + c = skipWhite (c); + c = processDefine (localToken, c); + } + /* return macro expansion */ + else + { + swapToken (token, localToken); + c = skipWhite (c); + if (c == '(') + c = skipPastMatch ("()"); + break; + } + } + deleteToken (localToken); + return c; +} + +static void _updateKind (tokenInfo *const token) +{ + verilogKind kind = (verilogKind) lookupKeyword (vStringValue (token->name), getInputLanguage () ); + token->kind = ((kind == K_UNDEFINED) && isIdentifier (token)) ? K_IDENTIFIER : kind; +} + +/* read an identifier, keyword, number, compiler directive, or macro identifier */ +static int _readWordToken (tokenInfo *const token, int c, bool skip) +{ + Assert (isWordToken (c)); + + clearToken (token); + do + { + vStringPut (token->name, c); + c = vGetc (); + } while (isIdentifierCharacter (c)); + _updateKind (token); + + if (skip) + return skipWhite (c); + else + return c; +} + +// read a word token starting with "c". +// returns the first charactor of the next token. +static int readWordToken (tokenInfo *const token, int c) +{ + return _readWordToken (token, c, true); +} + +// read a word token starting with "c". +// returns the next charactor of the token read. +// for compiler directives. Since they are line-based, skipWhite() cannot be used. +static int readWordTokenNoSkip (tokenInfo *const token, int c) +{ + return _readWordToken (token, c, false); +} + +/* check if an identifier: + * simple_identifier ::= [ a-zA-Z_ ] { [ a-zA-Z0-9_$ ] } */ +static bool isIdentifier (tokenInfo* token) +{ + if (token->kind == K_UNDEFINED) + { + for (int i = 0; i < vStringLength (token->name); i++) + { + int c = vStringChar (token->name, i); + if (i == 0) + { + if (c == '`' || !isWordToken (c)) + return false; + } + else + { + if (!isIdentifierCharacter (c)) + return false; + } + } + return true; + } + else + return false; +} + +static void createContext (verilogKind kind, vString* const name) +{ + tokenInfo *const scope = newToken (); + vStringCopy (scope->name, name); + scope->kind = kind; + + if (scope) + { + vString *contextName = vStringNew (); + + /* Determine full context name */ + if (currentContext->kind != K_UNDEFINED) + { + vStringCopy (contextName, currentContext->name); + vStringPut (contextName, '.'); + } + vStringCat (contextName, scope->name); + /* Create context */ + currentContext = pushToken (currentContext, scope); + vStringCopy (currentContext->name, contextName); + vStringDelete (contextName); + verbose ("Created new context %s (kind %d)\n", vStringValue (currentContext->name), currentContext->kind); + } +} + +static void dropContext () +{ + verbose ("Dropping context %s\n", vStringValue (currentContext->name)); + currentContext = popToken (currentContext); +} + +/* Drop context, but only if an end token is found */ +static int dropEndContext (tokenInfo *const token, int c) +{ + verbose ("current context %s; context kind %0d; nest level %0d\n", vStringValue (currentContext->name), currentContext->kind, currentContext->nestLevel); + if ((currentContext->kind == K_COVERGROUP && strcmp (vStringValue (token->name), "endgroup") == 0) + || (currentContext->kind == K_IFCLASS && strcmp (vStringValue (token->name), "endclass") == 0)) + { + dropContext (); + c = skipBlockName (token ,c); + } + else if (currentContext->kind != K_UNDEFINED) + { + vString *endTokenName = vStringNewInit ("end"); + vStringCatS (endTokenName, getNameForKind (currentContext->kind)); + if (strcmp (vStringValue (token->name), vStringValue (endTokenName)) == 0) + { + dropContext (); + c = skipBlockName (token ,c); + if (currentContext->classScope) + { + verbose ("Dropping local context %s\n", vStringValue (currentContext->name)); + currentContext = popToken (currentContext); + } + } + vStringDelete (endTokenName); + } + else + verbose ("Unexpected current context %s\n", vStringValue (currentContext->name)); + return c; +} + + +static void createTag (tokenInfo *const token, verilogKind kind) +{ + tagEntryInfo tag; + + if (kind == K_LOCALPARAM) + kind = K_CONSTANT; + else if (kind == K_PARAMETER) + { + kind = K_CONSTANT; + // See LRM 2017 6.20.1 Parameter declaration syntax + if (currentContext->kind != K_CLASS && currentContext->kind != K_PACKAGE && !currentContext->hasParamList) + token->parameter = true; + } + Assert (kind >= 0 && kind != K_UNDEFINED && kind != K_IDENTIFIER); + Assert (vStringLength (token->name) > 0); + + /* check if a container before kind is modified by prototype */ + /* BTW should we create a context for a prototype? */ + bool container = isContainer (kind); + + /* Determine if kind is prototype */ + if (currentContext->prototype) + kind = K_PROTOTYPE; + + /* Do nothing if tag kind is disabled */ + if (! kindEnabled (kind)) + { + verbose ("kind disabled\n"); + return; + } + + /* Create tag */ + initTagEntry (&tag, vStringValue (token->name), kind); + tag.lineNumber = token->lineNumber; + tag.filePosition = token->filePosition; + + verbose ("Adding tag %s (kind %d)", vStringValue (token->name), kind); + if (currentContext->kind != K_UNDEFINED) + { + verbose (" to context %s\n", vStringValue (currentContext->name)); + currentContext->lastKind = kind; + tag.extensionFields.scopeKindIndex = currentContext->kind; + tag.extensionFields.scopeName = vStringValue (currentContext->name); + } + verbose ("\n"); + if (vStringLength (token->inheritance) > 0) + { + tag.extensionFields.inheritance = vStringValue (token->inheritance); + verbose ("Class %s extends %s\n", vStringValue (token->name), tag.extensionFields.inheritance); + } + + if (token->parameter) + attachParserField (&tag, false, fieldTable [F_PARAMETER].ftype, ""); + + makeTagEntry (&tag); + + if (isXtagEnabled (XTAG_QUALIFIED_TAGS) && currentContext->kind != K_UNDEFINED) + { + vString *const scopedName = vStringNew (); + + vStringCopy (scopedName, currentContext->name); + vStringPut (scopedName, '.'); + vStringCat (scopedName, token->name); + tag.name = vStringValue (scopedName); + + markTagExtraBit (&tag, XTAG_QUALIFIED_TAGS); + makeTagEntry (&tag); + + vStringDelete (scopedName); + } + + /* Push token as context if it is a container */ + if (container) + { + createContext (kind, token->name); + + /* Put found contents in context */ + verbose ("Putting tagContents: %d element(s)\n", + ptrArrayCount (tagContents)); + for (unsigned int i = 0; i < ptrArrayCount (tagContents); i++) + { + tokenInfo *content = ptrArrayItem (tagContents, i); + createTag (content, content->kind); + } + + /* Drop temporary contexts */ + if (isTempContext (currentContext)) + dropContext (); + } + + /* Clear no longer required inheritance information */ + vStringClear (token->inheritance); +} + +static int skipBlockName (tokenInfo *const token, int c) +{ + if (c == ':') + { + c = skipWhite (vGetc ()); + if (isWordToken (c)) + c = readWordToken (token, c); + } + return c; +} + +// begin, fork +static int processBlock (tokenInfo *const token, int c) +{ + if (c == ':') // tag an optional block identifier + { + c = skipWhite (vGetc ()); + if (isWordToken (c)) + { + c = readWordToken (token, c); + verbose ("Found block: %s\n", vStringValue (token->name)); + createTag (token, K_BLOCK); + verbose ("Current context %s\n", vStringValue (currentContext->name)); + } + } + currentContext->nestLevel++; // increment after creating a context + return c; +} + +// end, join, join_any, join_none +static int processEnd (tokenInfo *const token, int c) +{ + if (currentContext->nestLevel > 0) // for sanity check + currentContext->nestLevel--; + if (currentContext->kind == K_BLOCK && currentContext->nestLevel == 0) + dropContext (); + + c = skipBlockName (token, c); + return c; +} + +static int processPortList (tokenInfo *token, int c, bool mayPortDecl) +{ + if (c == '(') + { + c = skipWhite (vGetc ()); // skip '(' + c = tagIdentifierList (token, c, K_PORT, mayPortDecl); + if (c == ')') // sanity check + c = skipWhite (vGetc ()); + else + verbose ("Unexpected input: %c\n", c); + } + return c; +} + +static int skipParameterAssignment (int c) +{ + if (c == '#') + { + c = skipWhite (vGetc ()); + if (c == '(') + c = skipPastMatch ("()"); + } + return c; +} + +// Functions are treated differently because they may also include the type of the return value. +// Tasks are treated in the same way, although not having a return value. +// +// function [ lifetime ] function_data_type_or_implicit [ interface_identifier . | class_scope ] function_identifier [ ( [ tf_port_list ] ) ] ; +// task [ lifetime ] task_body_declaration [ interface_identifier . | class_scope ] task_identifier [ ( [ tf_port_list ] ) ] ; +static int processFunction (tokenInfo *const token, int c) +{ + verilogKind kind = token->kind; // K_FUNCTION or K_TASK + + /* Search for function name + * Last identifier found before a '(' or a ';' is the function name */ + while (c != '(' && c != ';' && c != EOF) + { + if (isWordToken (c)) + c = readWordToken (token, c); + else + c = skipWhite (vGetc ()); + /* skip parameter assignment of a class type + * ex. function uvm_port_base #(IF) get_if(int index=0); */ + c = skipParameterAssignment (c); + + /* Identify class type prefixes and create respective context*/ + if (isInputLanguage (Lang_systemverilog) && c == ':') + { + c = vGetc (); + if (c == ':') + { + verbose ("Found function declaration with class type %s\n", vStringValue (token->name)); + createContext (K_CLASS, token->name); + currentContext->classScope = true; + } + else + vUngetc (c); + } + } + verbose ("Found function: %s\n", vStringValue (token->name)); + createTag (token, kind); + + /* Get port list from function */ + c = skipWhite (c); + c = processPortList (token, c, false); + return c; +} + +// ( enum | union ) [ enum_base_type ] { < enum_name_declaration > } { [ ... ] } +static int processEnum (tokenInfo *const token, int c) +{ + tokenInfo* enumToken = dupToken (token); // save enum token + + /* skip enum_base_type */ + while (isWordToken (c)) + c = readWordToken (token, c); + c = skipDimension (c); + + /* Search enum elements */ + c = pushEnumNames (token, c); + + /* Skip bus width definition */ + c = skipDimension (c); + + /* Following identifiers are tag names */ + verbose ("Find enum tags. Token %s kind %d\n", vStringValue (enumToken->name), enumToken->kind); + c = tagNameList (enumToken, c, enumToken->kind); + deleteToken (enumToken); + + // Clean up the tag content list at the end of the declaration to support multiple variables + // enum { ... } foo, bar; + ptrArrayClear (tagContents); + return c; +} + +// [ struct | union [ tagged ] ] [ packed [ signed | unsigned ] ] { struct_union_member { struct_union_member } } { [ ... ] } +static int processStruct (tokenInfo *const token, int c) +{ + verilogKind kind = token->kind; // K_STRUCT, K_TYPEDEF, or K_NETTYPE + + /* Skip packed, signed, and unsigned */ + while (isWordToken (c)) + c = readWordToken (token, c); + + /* create a list of members */ + c = pushMembers (token, c); + + /* Skip packed_dimension */ + c = skipDimension (c); + + /* Following identifiers are tag names */ + verbose ("Find struct|union tags. Token %s kind %d\n", vStringValue (token->name), token->kind); + c = tagNameList (token, c, kind); + ptrArrayClear (tagContents); + return c; +} + +// data_declaration ::= +// [ const ] [ var ] [ static | automatic ] data_type_or_implicit list_of_variable_decl_assignments ; +// | typedef data_type type_identifier { [ ... ] } ; +// | typedef interface_instance_identifier [ ... ] . type_identifier type_identifier ; // interface based typedef +// | typedef [ enum | struct | union | class | interface class ] type_identifier ; +// | import < package_import_item > ; +// | nettype data_type net_type_identifier [ with [ class_type :: | package_identifier :: | $unit :: ] tf_identifier ] ; +// | nettype [ class_type :: | package_identifier :: | $unit :: ] net_type_identifier net_type_identifier ; +static int processTypedef (tokenInfo *const token, int c) +{ + verilogKind kindSave = token->kind; // K_TYPEDEF or K_NETTYPE + verilogKind kind = K_UNDEFINED; + bool not_used; + if (isWordToken (c)) + { + c = readWordToken (token, c); + kind = token->kind; + } + // forward typedef (LRM 6.18) is tagged as prototype + // (I don't know why...) + switch (kind) + { + case K_CLASS: + case K_INTERFACE: + currentContext->prototype = true; + break; + case K_ENUM: + case K_STRUCT: + if (isWordToken (c)) + { + c = readWordToken (token, c); + if (token->kind == K_IDENTIFIER && c == ';') + currentContext->prototype = true; + } + break; + case K_IDENTIFIER: + // interface based typedef + c = skipDimension (c); + if (c == '.') + { + c = skipWhite (vGetc ()); + if (isWordToken (c)) + c = readWordToken (token, c); + } + if (c == ';') + currentContext->prototype = true; + break; + default: + ; // do nothing + } + c = processType (token, c, &kind, ¬_used); + + createTag (token, kindSave); + + ptrArrayClear (tagContents); + return c; +} + +static int processParameterList (tokenInfo *token, int c) +{ + bool parameter = true; // default "parameter" + + if (c != '#') + return c; + c = skipWhite (vGetc ()); + + if (c != '(') + return c; + c = skipWhite (vGetc ()); + + while (c != ')' && c != EOF) + { + if (isWordToken (c)) + { + c = readWordToken (token, c); + verbose ("Found parameter %s\n", vStringValue (token->name)); + if (token->kind == K_IDENTIFIER) + { + if (c == ',' || c == ')' || c == '=') // ignore user defined type + { + tokenInfo *param = dupToken (token); + param->kind = K_CONSTANT; + param->parameter = parameter; + ptrArrayAdd (tagContents, param); + if (c == '=') + c = skipExpression (vGetc ()); + else if (c == ',') + c = skipWhite (vGetc ()); + else // ')' + break; + } + } + else if (token->kind == K_PARAMETER) + parameter = true; + else if (token->kind == K_LOCALPARAM) + parameter = false; + } + else + c = skipWhite (vGetc ()); + // unpacked array is not allowed for a parameter + } + c = skipWhite (vGetc ()); // skip ')' + return c; +} + +// [ virtual ] class [ static | automatic ] class_identifier [ parameter_port_list ] +// [ extends class_type [ ( list_of_arguments ) ] ] [ implements < interface_class_type > ] ; +// interface class class_identifier [ parameter_port_list ] [ extends < interface_class_type > ] ; +static int processClass (tokenInfo *const token, int c, verilogKind kind) +{ + tokenInfo *classToken; + + /* Get identifiers */ + while (isWordToken (c)) + { + c = readWordToken (token, c); + // skip static or automatic + if (token->kind != K_IGNORE) + break; + } + + if (token->kind != K_IDENTIFIER) + { + verbose ("Unexpected input: class name is expected.\n"); + return c; + } + + /* save token */ + classToken = dupToken (token); + + /* Find class parameters list */ + c = processParameterList (token, c); + + /* Search for inheritance information */ + if (isWordToken (c)) + { + c = readWordToken (token, c); + if (strcmp (vStringValue (token->name), "extends") == 0) + { + if (isWordToken (c)) + c = readWordToken (token, c); + vStringCopy (classToken->inheritance, token->name); + verbose ("Inheritance %s\n", vStringValue (classToken->inheritance)); + } + } + // process implements: FIXME + + createTag (classToken, kind); + deleteToken (classToken); + ptrArrayClear (tagContents); + return c; +} + +// constraint_declaration ::= [ static ] constraint constraint_identifier '{' { constraint_block_item } '}' +// constraint_prototype ::= [ extern | pure ] [ static ] constraint constraint_identifier ; +static int processConstraint (tokenInfo *const token, int c) +{ + verilogKind kind; + if (isWordToken (c)) + c = readWordToken (token, c); + if (c == '{') + { + c = skipPastMatch ("{}"); + kind = K_CONSTRAINT; + } + else + kind = K_PROTOTYPE; + createTag (token, kind); + return c; +} + +static int processDefine (tokenInfo *const token, int c) +{ + /* Bug #961001: Verilog compiler directives are line-based. */ + if (isWordToken (c)) + { + c = readWordTokenNoSkip (token, c); + createTag (token, K_CONSTANT); + } + c = skipToNewLine (c); + c = skipWhite (c); + return c; +} + +// immediate_assertion_statement ::= +// ( assert | asume | cover ) [ #0 | final ] '(' expression ')' block +// concurrent_assertion_statement ::= +// ( assert | assume ) property ( property_spec ) action_block +// | expect ( property_spec ) action_block # ignore : processed as same as "if" +// | cover property ( property_spec ) statement_or_null +// | cover sequence ( [clocking_event ] [ disable iff ( expression_or_dist ) ] sequence_expr ) statement_or_null +// | restrict property ( property_spec ) ; +static int processAssertion (tokenInfo *const token, int c) +{ + if (vStringLength (currentContext->blockName) > 0) + { + vStringCopy (token->name, currentContext->blockName); + vStringClear (currentContext->blockName); // clear block name not to be reused + createTag (token, K_ASSERTION); + } + // skip final | property | sequence + if (isWordToken (c)) + c = readWordToken (token, c); + // skip #0 + c = skipDelay (token, c); + // skip ( ... ) + if (c == '(') + c = skipPastMatch ("()"); + return c; +} + +// non-ANSI type +// ( module | interface | program ) [ static | automatic ] identifier { package_import_declaration } [ parameter_port_list ] ( port { , port } ) ; +// ANSI type +// ( module | interface | program ) [ static | automatic ] identifier { package_import_declaration } [ parameter_port_list ] [ ( [ < { (* ... *) } ansi_port_declaration > ] ) ] ; +// +// interface class class_identifier [ parameter_port_list ] [ extends < interface_class_type > ] ; +static int processDesignElementL (tokenInfo *const token, int c) +{ + verilogKind kind = token->kind; + + while (isWordToken (c)) + { + c = readWordToken (token, c); + // interface class + if (token->kind == K_CLASS) + return processClass (token, c, K_IFCLASS); + // skip static or automatic + else if (token->kind != K_IGNORE) + break; + } + if (token->kind == K_IDENTIFIER) + createTag (token, kind); // identifier + + // skip package_import_declaration + while (isWordToken (c)) + { + c = readWordToken (token, c); + if (token->kind == K_IMPORT) + { + c = skipToSemiColon (c); + c = skipWhite (vGetc ()); // skip semicolon + } + else + { + verbose ("Unexpected input\n"); + return c; + } + } + if (c == '#') // parameter_port_list + { + c = processParameterList (token, c); + + /* Put found parameters in context */ + verbose ("Putting parameters: %d element(s)\n", + ptrArrayCount (tagContents)); + for (unsigned int i = 0; i < ptrArrayCount (tagContents); i++) + { + tokenInfo *content = ptrArrayItem (tagContents, i); + createTag (content, K_CONSTANT); + } + ptrArrayClear (tagContents); + // disable parameter property on parameter declaration statement + currentContext->hasParamList = true; + } + // Process ANSI/non-ANSI port list in main loop + c = processPortList (token, c, true); + return c; +} + +// ( checker | property | sequence ) identifier [ ( [ port_list ] ) ] ; +// covergroup identifier [ ( [ port_list ] ) ] [ coverage_event ] ; +// coverage_event ::= clocking_event | with function sample ( ... ) | @@( ... ) +// package identifier ; +// modport < identifier ( < ports_declaration > ) > ; +// [ default | global ] clocking [ identifier ] ( @ identifier | @ ( event_expression ) ) +static int processDesignElementS (tokenInfo *const token, int c) +{ + verilogKind kind = token->kind; + + if (isWordToken (c)) + c = readWordToken (token, c); + else + return c; + + createTag (token, kind); // identifier + + /* Get port list if required */ + if (c == '(') // port_list + { + if (kind == K_MODPORT) + c = skipPastMatch ("()"); // ignore port list + else + c = processPortList (token, c, false); + } + // skip clocking_event for clocking block or coverage_event for covergroup + // "with function sample ()" is processed in the main loop + if (c == '@') + c = skipClockEvent (token, c); + return c; +} + +static int skipDelay (tokenInfo* token, int c) +{ + if (c == '#') + { + c = skipWhite (vGetc ()); + if (c == '(') + c = skipPastMatch ("()"); + else if (c == '#') + // a dirty hack for "x ##delay1 y[*min:max];" + c = skipToSemiColon (vGetc ()); + else // time literals + { + while (isIdentifierCharacter (c) || c == '.') + c = vGetc (); + c = skipWhite (c); + } + } + return c; +} + +static int skipClockEvent (tokenInfo* token, int c) +{ + if (c == '@') + { + c = skipWhite (vGetc ()); + // for @@ ( ... ) : coverage_event + if (c == '@') + c = skipWhite (vGetc ()); + if (c == '(') + c = skipPastMatch ("()"); + else if (isWordToken (c)) + c = readWordToken (token, c); + } + return c; +} + +static int pushEnumNames (tokenInfo* token, int c) +{ + if (c == '{') + { + c = skipWhite (vGetc ()); + while (c != '}' && c != EOF) + { + if (!isWordToken (c)) + { + verbose ("Unexpected input: %c\n", c); + return c; + } + c = readWordToken (token, c); + + token->kind = K_CONSTANT; + ptrArrayAdd (tagContents, dupToken (token)); + verbose ("Pushed enum element "%s"\n", vStringValue (token->name)); + + /* Skip element ranges */ + /* TODO Implement element ranges */ + c = skipDimension (c); + + /* Skip value assignments */ + if (c == '=') + c = skipExpression (vGetc ()); + + /* Skip comma */ + if (c == ',') + c = skipWhite (vGetc ()); + } + c = skipWhite (vGetc ()); // skip '}' + } + return c; +} + +// create a list of struct/union members +static int pushMembers (tokenInfo* token, int c) +{ + if (c == '{') + { + c = skipWhite (vGetc ()); + while (c != '}' && c != EOF) + { + verilogKind kind = K_UNDEFINED; // set kind of context for processType() + bool not_used; + if (!isWordToken (c)) + { + verbose ("Unexpected input: %c\n", c); + return c; + } + c = readWordToken (token, c); + + c = processType (token, c, &kind, ¬_used); + while (true) + { + token->kind = K_MEMBER; + ptrArrayAdd (tagContents, dupToken (token)); + verbose ("Pushed struct/union member "%s"\n", vStringValue (token->name)); + + /* Skip unpacked dimensions */ + c = skipDimension (c); + + /* Skip value assignments */ + if (c == '=') + c = skipExpression (vGetc ()); + + if (c != ',' || c == EOF) + break; // should be ';' + + c = skipWhite (vGetc ()); // skip ',' + if (isWordToken (c)) + c = readWordToken (token, c); + else + { + verbose ("Unexpected input.\n"); + break; + } + } + /* Skip semicolon */ + if (c == ';') + c = skipWhite (vGetc ()); + /* End of enum elements list */ + } + c = skipWhite (vGetc ()); // skip '}' + } + return c; +} + +// input +// kind: kind of context +// output +// kind: kind of type +// token: identifier token (unless K_IDENTIFIER nor K_UNDEFINED) +static int processType (tokenInfo* token, int c, verilogKind* kind, bool* with) +{ + verilogKind actualKind = K_UNDEFINED; + tokenInfo *tokenSaved; + *with = false; + do + { + c = skipDimension (c); + c = skipDelay (token, c); // class parameter #(...) + if (c == '{') // skip enum, struct, or union member + { + if (*kind == K_ENUM) + c = pushEnumNames (token, c); + else if (*kind == K_STRUCT) + c = pushMembers (token, c); + else // for a nested structure + c = skipPastMatch ("{}"); + } + c = skipDimension (c); + c = skipMacro (c, token); + + // break on ',', ';', ')', '}', or other unexpected charactors + if (!isWordToken (c)) + break; + + tokenSaved = dupToken (token); + c = readWordToken (token, c); + // break on "with" + if (token->kind == K_WITH) + { + swapToken (token, tokenSaved); + deleteToken (tokenSaved); + *with = true; // inform to caller + break; + } + deleteToken (tokenSaved); + + // fix kind of user defined type + if (*kind == K_IDENTIFIER) + { + if (token->kind == K_NET) + actualKind = K_NET; + else if (token->kind == K_REGISTER) + actualKind = K_REGISTER; + else if (token->kind == K_PORT) + actualKind = K_PORT; + else if (token->kind == K_IDENTIFIER) + { // identifier of a user defined type + *kind = K_REGISTER; // FIXME: consider kind of the user defined type + break; + } + else + { + verbose ("Unexpected input\n"); // FIXME: x dist {}, with + break; + } + } + } while (c != '`' && c != EOF); // break on compiler directive + + // skip unpacked dimension (or packed dimension after type-words) + c = skipDimension (skipWhite (c)); + + if (*kind == K_UNDEFINED && *kind != K_PORT) + *kind = actualKind; + return c; +} + +// class_type ::= +// ps_class_identifier [ # ( ... ) ] { :: class_identifier [ # ( ... ) ] } +// "interface_identifier ." is also handled +static int skipClassType (tokenInfo* token, int c) +{ + while (c == '#' || c == ':' || c == '.') + { + if (c == '#') + { + c = skipWhite (vGetc ()); + // a dirty hack for "x ##delay1 y[*min:max];" + if (c == '#') + return skipToSemiColon (vGetc ()); + c = skipPastMatch ("()"); + } + else if (c == ':') + { + c = skipWhite (vGetc ()); + if (c != ':') + { + verbose ("Unexpected input.\n"); + vUngetc (c); + return ':'; + } + c = skipWhite (vGetc ()); + if (isWordToken (c)) + c = readWordToken (token, c); + } + else // c == '.' : interface_identifier . + { + c = skipWhite (vGetc ()); + if (isWordToken (c)) + c = readWordToken (token, c); + } + } + return c; +} + +// Tag a list of identifiers +// data_type :: = +// ... +// | virtual [ interface ] identifier [ # ( [ ... ] ) ] [ . identifier ] +// | [ class_type :: | identifier :: | $unit :: ] identifier { [ ... ] } +// | [ identifier :: | $unit :: ] identifier [ # ( ... ) ] { :: identifier [ # ( ... ) ] } +// | ... +// +// mayPortDecl: may be a ANSI port declaration. true for module, interface, or program. +static int tagIdentifierList (tokenInfo *const token, int c, verilogKind kind, bool mayPortDecl) +{ + bool first_port = true; + bool enableTag = true; + verilogKind localKind; + bool not_used; + + while (c != ')' && c != EOF) // skip empty port, "()" + { + // skip attribute_instance: (* ... *) + if (c == '(') + c = skipPastMatch ("()"); + + // skip port direction, "virtual", or "interface" + while (isWordToken (c)) + { + c = readWordToken (token, c); + if (token->kind == K_PORT || token->kind == K_IGNORE || token->kind == K_INTERFACE) + mayPortDecl = false; // now never be a non-ANSI port + else + break; + } + if (token->kind == K_IDENTIFIER) + c = skipClassType (token, c); + c = skipMacro (c, token); // `ifdef, `else, `endif, etc. (between identifiers) + + if (isWordToken (c)) + { + c = readWordToken (token, c); + if (token->kind == K_IDENTIFIER) + { + mayPortDecl = false; + c = skipClassType (token, c); + } + } + // aoid tagging enum and struct items + localKind = token->kind == K_ENUM || token->kind == K_STRUCT ? K_PORT : token->kind; + c = processType (token, c, &localKind, ¬_used); + + // LRM 23.2.2.3 Rules for determining port kind, data type, and direction + // If the direction, port kind, and data type are all omitted for + // the first port in the port list, ... non-ANSI style, ... + if (mayPortDecl && first_port) + { + first_port = false; + if (localKind == K_IDENTIFIER) + enableTag = false; // don't tag for non-ANSI port + } + if (enableTag && token->kind == K_IDENTIFIER) + createTag (token, kind); + + if (c == '=') + c = skipExpression (vGetc ()); + + c = skipMacro (c, token); // `ifdef, `else, `endif, etc. (before comma) + if (c != ',' || c == EOF) + break; + c = skipWhite (vGetc ()); // skip ',' + c = skipMacro (c, token); // `ifdef, `else, `endif, etc. (after comma) + } + return c; +} + +static int tagNameList (tokenInfo* token, int c, verilogKind kind) +{ + c = skipClassType (token, c); + if (c == ':' || c == ';') // ## (cycle delay) or unexpected input + return c; + + // skip drive|charge strength or type_reference, dimensions, and delay for net + if (c == '(') + c = skipPastMatch ("()"); + c = skipDimension (c); + if (c == '.') + return c; // foo[...].bar = ..; + c = skipDelay (token, c); + + while (c != EOF) + { + bool with = false; + c = processType (token, c, &kind, &with); // update token and kind + + if (c == '=' || c == ',' || c == ';' || c == ')' || c == '`' || with) + { + // ignore an empty token or procedual assignment: foo = bar; + if (kind != K_UNDEFINED && kind != K_IDENTIFIER && token->kind != K_UNDEFINED) + createTag (token, kind); + if (c == '=') + c = skipExpression (c); + } + else if (c == '(' || c == '[') // should be instance + { + c = skipDimension (c); // name_of_instance {unpacked_dimension} + c = skipPastMatch ("()"); // list_of_port_connections + + // if without the next "if" clause, get a instance named: `add_t from the following example + // var `add_t(foo) = '0; + if (c == ';' || c == ',') + { + verbose ("find instance: %s with kind %s\n", vStringValue (token->name), getNameForKind (K_INSTANCE)); + createTag (token, K_INSTANCE); + } + } + c = skipMacro (c, token); // `ifdef, `else, `endif, etc. (before comma) + if (c != ',' || c == EOF) + break; + c = skipWhite (vGetc ()); // skip ',' + c = skipMacro (c, token); // `ifdef, `else, `endif, etc. (after comma) + } + return c; +} + +static int findTag (tokenInfo *const token, int c) +{ + verbose ("Checking token %s of kind %d\n", vStringValue (token->name), token->kind); + + switch (token->kind) + { + case K_CONSTANT: + case K_EVENT: + case K_LOCALPARAM: + case K_NET: + case K_PARAMETER: + case K_PORT: + case K_REGISTER: + if (token->kind == K_PORT && currentContext->kind == K_CLOCKING) + c = skipToSemiColon (c); // clocking items are not port definitions + else + c = tagNameList (token, c, token->kind); + break; + case K_IDENTIFIER: + { + if (c == '[') // for a case label foo[x]: + c = skipPastMatch ("[]"); + + if (c == ':') + ; /* label */ + else if (c == ',' || c == '{') // "foo, ..." or "coverpoint foo { ... }" + c = skipWhite (vGetc ()); + else if (c == '(') // task, function, or method call + c = skipPastMatch ("()"); + else if (c == '=') // assignment + c = skipExpression (skipWhite (vGetc ())); + else + c = tagNameList (token, c, token->kind); /* user defined type */ + } + break; + case K_CLASS: + c = processClass (token, c, K_CLASS); + break; + case K_TYPEDEF: + case K_NETTYPE: + c = processTypedef (token, c); + break; + case K_ENUM: + c = processEnum (token, c); + break; + case K_STRUCT: + c = processStruct (token, c); + break; + case K_PROTOTYPE: + case K_IMPORT: + case K_WITH: + currentContext->prototype = true; + break; + + case K_INTERFACE: + case K_MODULE: + case K_PROGRAM: + c = processDesignElementL (token, c); + break; + case K_CHECKER: + case K_CLOCKING: + case K_COVERGROUP: + case K_MODPORT: + case K_PACKAGE: + case K_PROPERTY: + case K_SEQUENCE: + c = processDesignElementS (token, c); + break; + case K_END_DE: + c = dropEndContext (token, c); + break; + case K_BLOCK: + c = processBlock (token, c); + break; + case K_END: + c = processEnd (token, c); + break; + case K_FUNCTION: + case K_TASK: + c = processFunction (token, c); + break; + case K_ASSERTION: + c = processAssertion (token, c); + break; + case K_CONSTRAINT: + c = processConstraint (token, c); + break; + + case K_DEFINE: + c = processDefine (token, c); + break; + + case K_IGNORE: + break; + default: + verbose ("Unexpected kind->token %d\n", token->kind); + } + return c; +} + +static void findVerilogTags (void) +{ + tokenInfo *const token = newToken (); + int c = skipWhite (vGetc ()); + currentContext = newToken (); + fieldTable = isInputLanguage (Lang_verilog) ? VerilogFields : SystemVerilogFields; + ptrArrayClear (tagContents); + + while (c != EOF) + { + switch (c) + { + case ':': + /* Store current block name whenever a : is found + * This is used later by any tag type that requires this information */ + vStringCopy (currentContext->blockName, token->name); + c = skipWhite (vGetc ()); + break; + case ';': + /* Drop context on prototypes because they don't have an + * end statement */ + if (currentContext->scope && currentContext->scope->prototype) + dropContext (); + + /* Prototypes end at the end of statement */ + currentContext->prototype = false; + c = skipWhite (vGetc ()); + break; + case '(': // ignore locally declared variables in a for-loop (LRM 12.7.1) + c = skipPastMatch ("()");; + break; + case '{': + c = skipPastMatch ("{}");; + break; + case '#': + c = skipDelay (token, c); + break; + case '@': + c = skipClockEvent (token, c); + break; + case '"': + c = skipString (c); + break; + default : + if (isWordToken (c)) + { + c = readWordTokenNoSkip (token, c); + if (token->kind == K_DIRECTIVE) + { + // Skip compiler directives which are line-based. + c = skipToNewLine (c); + c = skipWhite (c); + } + else if (token->kind != K_UNDEFINED) + c = findTag (token, skipWhite (c)); + } + else + c = skipWhite (vGetc ()); + } + } + deleteToken (token); + pruneTokens (currentContext); + currentContext = NULL; +} + +extern parserDefinition* VerilogParser (void) +{ + static const char *const extensions [] = { "v", NULL }; + parserDefinition* def = parserNew ("Verilog"); + def->kindTable = VerilogKinds; + def->kindCount = ARRAY_SIZE (VerilogKinds); + def->fieldTable = VerilogFields; + def->fieldCount = ARRAY_SIZE (VerilogFields); + def->extensions = extensions; + def->parser = findVerilogTags; + def->initialize = initializeVerilog; + return def; +} + +extern parserDefinition* SystemVerilogParser (void) +{ + static const char *const extensions [] = { "sv", "svh", "svi", NULL }; + parserDefinition* def = parserNew ("SystemVerilog"); + def->kindTable = SystemVerilogKinds; + def->kindCount = ARRAY_SIZE (SystemVerilogKinds); + def->fieldTable = SystemVerilogFields; + def->fieldCount = ARRAY_SIZE (SystemVerilogFields); + def->extensions = extensions; + def->parser = findVerilogTags; + def->initialize = initializeSystemVerilog; + return def; +}
-------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).