some changes

src/VFileLine.cpp

+// -*- C++ -*-
+//*************************************************************************
+//
+// Copyright 2000-2013 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// 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 General Public License for more details.
+//
+//*************************************************************************
+/// \file
+/// \brief Verilog::Preproc: Error handling implementation
+///
+/// Authors: Wilson Snyder
+///
+/// Code available from: http://www.veripool.org/verilog-perl
+///
+//*************************************************************************
+
+#include <cstdio>
+#include <cstdlib>
+
+#include "VFileLine.h"
+
+int VFileLine::s_numErrors = 0;		///< Number of errors detected
+
+//============================================================================
+
+void VFileLine::init(const string& filename, int lineno) {
+    m_filename = filename;
+    m_lineno = lineno;
+}
+
+const string VFileLine::filebasename () const {
+    string name = filename();
+    string::size_type slash;
+    if ((slash = name.rfind("/")) != string::npos) {
+	name.erase(0,slash+1);
+    }
+    return name;
+}
+
+void VFileLine::fatal(const string& msg) {
+    error(msg);
+    error("Fatal Error detected");
+    abort();
+}
+void VFileLine::error(const string& msg) {
+    VFileLine::s_numErrors++;
+    if (msg[msg.length()-1] != '\n') {
+	fprintf (stderr, "%%Error: %s", msg.c_str());
+    } else {
+	fprintf (stderr, "%%Error: %s\n", msg.c_str());	// Append newline, as user omitted it.
+    }
+}
+
+const char* VFileLine::itoa(int i) {
+    static char buf[100];
+    sprintf(buf,"%d",i);
+    return buf;
+}
+
+string VFileLine::lineDirectiveStrg(int enterExit) const {
+    char numbuf[20]; sprintf(numbuf, "%d", lineno());
+    char levelbuf[20]; sprintf(levelbuf, "%d", enterExit);
+    return ((string)"// `line first "+numbuf+" \""+filename()+"\" "+levelbuf+"\n");
+}
+
+VFileLine* VFileLine::lineDirective(const char* textp, int& enterExitRef) {
+    // Handle `line directive
+    // Skip `line
+    while (*textp && isspace(*textp)) textp++;
+    while (*textp && !isspace(*textp)) textp++;
+    while (*textp && (isspace(*textp) || *textp=='"')) textp++;
+
+    // Grab linenumber
+    int lineno = this->lineno();
+    const char *ln = textp;
+    while (*textp && !isspace(*textp)) textp++;
+    if (isdigit(*ln)) {
+	lineno = atoi(ln);
+    }
+    while (*textp && (isspace(*textp) || *textp=='"')) textp++;
+
+    // Grab filename
+    string filename = this->filename();
+    const char* fn = textp;
+    while (*textp && !(isspace(*textp) || *textp=='"')) textp++;
+    if (textp != fn) {
+	string strfn = fn;
+	strfn = strfn.substr(0, textp-fn);
+	filename = strfn;
+    }
+
+    // Grab level
+    while (*textp && (isspace(*textp) || *textp=='"')) textp++;
+    if (isdigit(*textp)) enterExitRef = atoi(textp);
+    else enterExitRef = 0;
+
+    return create(filename,lineno);
+}
+
+//======================================================================
+// Global scope
+
+ostream& operator<<(ostream& os, VFileLine* flp) {
+    if (flp->filename()!="") {
+	os <<flp->filename()<<":"<<dec<<flp->lineno()<<": "<<hex;
+    }
+    return(os);
+}

src/VFileLine.h

+// -*- C++ -*-
+//*************************************************************************
+//
+// Copyright 2000-2013 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// 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 General Public License for more details.
+//
+//*************************************************************************
+/// \file
+/// \brief Verilog::Preproc: Error handling
+///
+/// Authors: Wilson Snyder
+///
+/// Code available from: http://www.veripool.org/verilog-perl
+///
+//*************************************************************************
+
+#ifndef _VFILELINE_H_
+#define _VFILELINE_H_ 1
+#include <string>
+#include <iostream>
+#include <sstream>
+using namespace std;
+
+//============================================================================
+// VFileLine
+/// User information and error reporting functions
+////
+/// Users can override this class to implement their own error handling
+
+class VFileLine {
+private:
+    int		m_lineno;		///< Line number in file
+    string	m_filename;		///< File name
+    static int	s_numErrors;		///< Number of errors detected
+
+protected:
+    VFileLine(int called_only_for_default) {init("",0);}
+
+public:
+    // CONSTRUCTORS
+    /// Create a new fileline, for a new file and/or line number.
+    /// Member functions, so that if a user provides another class, a change in the
+    /// filename/linenumber will create a new element using the derived class.
+    virtual VFileLine* create(const string& filename, int lineno) = 0;
+    /// Create with same filename, new line number; just calls create(fn,ln)
+    virtual VFileLine* create(int lineno)
+     { 
+      return create(filename(), lineno); 
+      }
+    virtual void init(const string& filename, int lineno);
+    virtual ~VFileLine() {}
+    // ACCESSORS
+    int lineno () const { return m_lineno; }	///< Return line number
+    void linenoIncInPlace() { m_lineno++; }	///< Increment line IN PLACE; normally use create() instead
+    const string filename () const { return m_filename; }	///< Return filename
+    const string filebasename () const;	///< Filename with any directory stripped
+    string lineDirectiveStrg(int enter_exit_level) const;
+    // METHODS
+    virtual void fatal(const string& msg);	///< Report a fatal error at given location
+    virtual void error(const string& msg);	///< Report a error at given location
+    VFileLine* lineDirective(const char* textp, int& enterExitRef);
+    // STATIC METHODS
+    static int numErrors() {return s_numErrors;}	///< Return total errors detected
+
+    // Internal methods -- special use
+    static const char* itoa(int i);	///< Internal: Not reentrant! - for fatalSrc() only
+};
+
+ostream& operator<<(ostream& os, VFileLine* fileline);
+
+/// Use this instead of fatal() to mention the source code line.
+#define fatalSrc(msg) fatal((string)"Internal Error: "+__FILE__+":"+VFileLine::itoa(__LINE__)+": "+(msg))
+
+template< class T> std::string cvtToStr (const T& t) {
+    ostringstream os; os<<t; return os.str();
+}
+
+
+class VerilogFileLine : public VFileLine
+{
+ 
+ public:
+    VerilogFileLine(const string& file,int line):VFileLine(0)
+    {
+      init(file,line);
+    }
+ 
+ virtual VFileLine* create(const string& filename, int lineno)
+ {
+ VerilogFileLine* fnew=new VerilogFileLine(filename,lineno);
+ return fnew;
+ }
+ 
+    /// Create with same filename, new line number; just calls create(fn,ln)
+ virtual VFileLine* create(int lineno) { return create(filename(), lineno); }
+
+};
+
+#endif // Guard

src/VPreLex.h

+// -*- C++ -*-
+//*************************************************************************
+//
+// Copyright 2000-2013 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// 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 General Public License for more details.
+//
+//*************************************************************************
+/// \file
+/// \brief Verilog::Preproc: Internal header for lex interfacing
+///
+/// Authors: Wilson Snyder
+///
+/// Code available from: http://www.veripool.org/verilog-perl
+///
+/// This header provides the interface between the lex proper VPreLex.l/.cpp
+/// and the class implementation file VPreProc.cpp
+/// It is not intended for user applications.
+///
+//*************************************************************************
+
+#ifndef _VPREPROCLEX_H_		// Guard
+#define _VPREPROCLEX_H_ 1
+
+#include <deque>
+#include <stack>
+
+#include "VFileLine.h"
+#include "VPreProc.h"
+
+class VPreLex;
+struct VPreProcImp;
+
+//======================================================================
+// Token codes
+// If changing, see VPreProc.cpp's VPreProcImp::tokenName()
+#define VP_EOF		0
+
+#define VP_INCLUDE	256
+#define VP_IFDEF	257
+#define VP_IFNDEF	258
+#define VP_ENDIF	259
+#define VP_UNDEF	260
+#define VP_DEFINE	261
+#define VP_ELSE		262
+#define VP_ELSIF	263
+#define VP_LINE		264
+#define VP_UNDEFINEALL	265
+
+#define VP_SYMBOL	300
+#define VP_STRING	301
+#define VP_DEFVALUE	302
+#define VP_COMMENT	303
+#define VP_TEXT		304
+#define VP_WHITE	305
+#define VP_DEFREF	306
+#define VP_DEFARG	307
+#define VP_ERROR	308
+#define VP_DEFFORM	309
+#define VP_STRIFY	310
+#define VP_BACKQUOTE	311
+#define VP_SYMBOL_JOIN	312
+#define VP_DEFREF_JOIN	313
+
+#define VP_PSL		350
+
+//======================================================================
+// Externs created by flex
+// We add a prefix so that other lexers/flexers in the same program won't collide.
+#ifndef yy_create_buffer
+# define yy_create_buffer VPreLex_create_buffer
+# define yy_delete_buffer VPreLex_delete_buffer
+# define yy_scan_buffer VPreLex_scan_buffer
+# define yy_scan_string VPreLex_scan_string
+# define yy_scan_bytes VPreLex_scan_bytes
+# define yy_flex_debug VPreLex_flex_debug
+# define yy_init_buffer VPreLex_init_buffer
+# define yy_flush_buffer VPreLex_flush_buffer
+# define yy_load_buffer_state VPreLex_load_buffer_state
+# define yy_switch_to_buffer VPreLex_switch_to_buffer
+# define yyin VPreLexin
+# define yyleng VPreLexleng
+# define yylex VPreLexlex
+# define yyout VPreLexout
+# define yyrestart VPreLexrestart
+# define yytext VPreLextext
+#endif
+
+#ifndef yyourleng
+# define yyourleng VPreLexourleng
+# define yyourtext VPreLexourtext
+#endif
+
+#ifndef YY_BUFFER_STATE
+struct yy_buffer_state;
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+# define YY_BUF_SIZE 16384
+#endif
+
+extern int yylex();
+extern void yyrestart(FILE*);
+
+// Accessors, because flex keeps changing the type of yyleng
+extern char* yyourtext();
+extern size_t yyourleng();
+extern void yyourtext(const char* textp, size_t size);  // Must call with static
+
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer );
+void yy_delete_buffer( YY_BUFFER_STATE b );
+
+//======================================================================
+
+#define KEEPCMT_SUB 2
+#define KEEPCMT_EXP 3
+
+//======================================================================
+// Entry for each file processed; a stack of entries included
+
+class VPreStream {
+public:
+    VFileLine*		m_curFilelinep;	// Current processing point (see also m_tokFilelinep)
+    VPreLex*		m_lexp;		// Lexer, for resource tracking
+    deque<string>	m_buffers;	// Buffer of characters to process
+    int			m_ignNewlines;	// Ignore multiline newlines
+    bool		m_eof;		// "EOF" buffer
+    bool		m_file;		// Buffer is start of new file
+    int			m_termState;	// Termination fsm
+    VPreStream(VFileLine* fl, VPreLex* lexp)
+	: m_curFilelinep(fl), m_lexp(lexp),
+	  m_ignNewlines(0),
+	  m_eof(false), m_file(false), m_termState(0) {
+	lexStreamDepthAdd(1);
+    }
+    ~VPreStream() {
+	lexStreamDepthAdd(-1);
+    }
+private:
+    void lexStreamDepthAdd(int delta);
+};
+
+//======================================================================
+// Class entry for each per-lexer state
+
+class VPreLex {
+  public:	// Used only by VPreLex.cpp and VPreProc.cpp
+    VPreProcImp*	m_preimpp;	// Preprocessor lexor belongs to
+    stack<VPreStream*>	m_streampStack;	// Stack of processing files
+    int			m_streamDepth;	// Depth of stream processing
+   
+    void debugErr()
+    {
+    //  cout<<m_preimpp->m_lineChars()<<endl;
+    }
+   
+    int getBufSize(); // return the current size of unread string 
+    char* getInputBuffer();
+    char* getInputBuffer1();
+    void initBuffer(const string & buf);
+  
+  
+    YY_BUFFER_STATE 	m_bufferState;	// Flex state
+    VFileLine*		m_tokFilelinep;	// Starting position of current token
+
+    // State to lexer
+    static VPreLex* s_currentLexp;	///< Current lexing point
+    int		m_keepComments;		///< Emit comments in output text
+    int		m_keepWhitespace;	///< Emit all whitespace in output text
+    bool	m_pedantic;	///< Obey standard; don't Substitute `error
+    bool	m_synthesis;	///< Remove translate_offs
+
+    // State from lexer
+    int		m_formalLevel;	///< Parenthesis counting inside def formals
+    int		m_parenLevel;	///< Parenthesis counting inside def args
+    bool	m_defCmtSlash;	///< /*...*/ comment in define had \ ending
+    string	m_defValue;	///< Definition value being built.
+    int		m_enterExit;	///< For VL_LINE, the enter/exit level
+
+    // CONSTRUCTORS
+    VPreLex(VPreProcImp* preimpp, VFileLine* filelinep) {
+	m_preimpp = preimpp;
+	m_streamDepth = 0;
+	m_keepComments = 0;
+	m_keepWhitespace = 1;
+	m_pedantic = false;
+	m_synthesis = false;
+	m_formalLevel = 0;
+	m_parenLevel = 0;
+	m_defCmtSlash = false;
+	m_tokFilelinep = filelinep;
+	m_enterExit = 0;
+	initFirstBuffer(filelinep);
+    }
+    ~VPreLex() {
+	while (!m_streampStack.empty()) { delete m_streampStack.top(); m_streampStack.pop(); }
+	yy_delete_buffer(m_bufferState); m_bufferState=NULL;
+    }
+
+    /// Called by VPreLex.l from lexer
+    VPreStream* curStreamp() { return m_streampStack.top(); }  // Can't be empty, "EOF" is on top
+    VFileLine* curFilelinep() { return curStreamp()->m_curFilelinep; }
+    void curFilelinep(VFileLine* fl) { curStreamp()->m_curFilelinep = fl; }
+    void appendDefValue(const char* textp, size_t len) 
+    { 
+      m_defValue.append(textp,len); 
+    }
+    void lineDirective(const char* textp) { curFilelinep(curFilelinep()->lineDirective(textp, m_enterExit/*ref*/)); }
+    void linenoInc() { if (curStreamp()->m_ignNewlines) curStreamp()->m_ignNewlines--;
+	else curFilelinep(curFilelinep()->create(curFilelinep()->lineno()+1)); }
+    /// Called by VPreProc.cpp to inform lexer
+    void pushStateDefArg(int level);
+    void pushStateDefForm();
+    void pushStateDefValue();
+    void pushStateIncFilename();
+    void scanNewFile(VFileLine* filelinep);
+    void scanBytes(const string& str);
+    void scanBytesBack(const string& str);
+    size_t inputToLex(char* buf, size_t max_size);
+    /// Called by VPreProc.cpp to get data from lexer
+    YY_BUFFER_STATE currentBuffer();
+    int  lex();
+    int	 currentStartState();
+    void dumpSummary();
+    void dumpStack();
+    void unused();
+    // Called by VPreStream
+    void streamDepthAdd(int delta) { m_streamDepth += delta; }
+    int streamDepth() const { return m_streamDepth; }
+    /// Utility
+    static int debug();
+    static void debug(int level);
+    static string cleanDbgStrg(const string& in);
+     string currentUnreadChars();
+  
+    
+private:
+    string endOfStream(bool& againr);
+    void initFirstBuffer(VFileLine* filelinep);
+    void scanSwitchStream(VPreStream* streamp);
+};
+
+inline void VPreStream::lexStreamDepthAdd(int delta) { m_lexp->streamDepthAdd(delta); }
+
+#endif // Guard

src/VPreProc.h

+// -*- C++ -*-
+//*************************************************************************
+//
+// Copyright 2000-2013 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// 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 General Public License for more details.
+//
+//*************************************************************************
+/// \file
+/// \brief Verilog::Preproc: Preprocess verilog code
+///
+/// Authors: Wilson Snyder
+///
+/// Code available from: http://www.veripool.org/verilog-perl
+///
+//*************************************************************************
+
+#ifndef _VPREPROC_H_
+#define _VPREPROC_H_ 1
+
+#include <string>
+#include <map>
+#include <iostream>
+#include "qmap.h"
+#include "qcstring.h"
+#include "assert.h"
+using namespace std;
+#include "VFileLine.h"
+#include "define.h"
+#include <deque>
+#include <stack>
+/// Generic opaque pointer to VPreProcImp implementation class.
+struct VPreProcOpaque {
+    virtual ~VPreProcOpaque() {}
+};
+class VDefine;
+
+//**********************************************************************
+// VPreProc
+/// Verilog Preprocessor.
+////
+/// This defines a preprocessor.  Functions are virtual so users can override them.
+/// After creating, call openFile(), then getline() in a loop.  The class will to the rest...
+
+class VPreProc {
+public:
+    VPreProc();
+    void configure(VFileLine* filelinep);
+    virtual ~VPreProc();
+    
+    // STATE
+private:
+    int		m_keepComments;
+    int		m_keepWhitespace;
+    bool	m_lineDirectives;
+    bool	m_pedantic;
+    bool	m_synthesis;
+
+public:
+    // CONSTANTS
+    enum MiscConsts {
+ 	DEFINE_RECURSION_LEVEL_MAX = 1000,	// How many `def substitutions before an error
+ 	INCLUDE_DEPTH_MAX = 500,		// How many `includes deep before an error
+	STREAM_DEPTH_LEVEL_MAX = 2000,		// How many streams deep (sometimes `def deep) before an error
+	//					// Set more than DEFINE_RECURSION_LEVEL_MAX or INCLUDE_DEPTH_MAX
+ 	NEWLINES_VS_TICKLINE = 20		// Use `line in place of this many newlines
+    };
+
+    // ACCESSORS
+    /// Insert given file into this point in input stream
+    void openFile(string filename, VFileLine* filelinep=NULL);
+    void debug(int level);	///< Set debugging level
+    string getall(size_t approx_chunk);	///< Return all lines, or at least approx_chunk bytes. (Null if done.)
+    string getline();		///< Return next line/lines. (Null if done.)
+    bool isEof();		///< Return true on EOF.
+    void insertUnreadback(string text);
+    int getNextStateToken(string & buf);
+    VFileLine* fileline();	///< File/Line number for last getline call
+
+    // The default behavior is to pass all unknown `defines right through.
+    // This lets the user determine how to report the errors.  It also nicely
+    // allows `celldefine and such to remain in the output stream.
+
+    // CONTROL METHODS
+    // These options control how the parsing proceeds
+    int  keepComments() { return m_keepComments; }
+    void keepComments(int flag) { m_keepComments=flag; }	// Return comments, 0=no, 1=yes, 2=callback
+    int  keepWhitespace() { return m_keepWhitespace; }
+    void keepWhitespace(int flag) { m_keepWhitespace=flag; }	// Return extra whitespace
+    bool lineDirectives() { return m_lineDirectives; }
+    void lineDirectives(bool flag) { m_lineDirectives=flag; }	// Insert `line directives
+    bool pedantic() { return m_pedantic; }
+    void pedantic(bool flag) { m_pedantic=flag; }	// Obey standard; Don't substitute `error
+    bool synthesis() { return m_synthesis; }
+    void synthesis(bool flag) { m_synthesis=flag; }	// Ignore translate off
+
+    // CALLBACK METHODS
+    // This probably will want to be overridden for given child users of this class.
+    virtual void comment(string cmt) = 0;		///< Comment detected (if keepComments==2)
+    virtual void include(string filename) = 0;	///< Request a include file be processed
+    virtual void define(string name, string value, string params) = 0; ///< `define without any parameters
+    virtual void undef(string name) = 0;		///< Remove a definition
+    virtual void undefineall() = 0;			///< Remove all non-command-line definitions
+    virtual bool defExists(string name) = 0;	///< Return true if define exists
+    virtual string defParams(string name) = 0;	///< Return parameter list if define exists
+    virtual string defValue(string name) = 0;	///< Return value of given define (should exist)
+    virtual string defSubstitute(string substitute) = 0;	///< Return value to substitute for given post-parameter value
+
+    // UTILITIES
+    void error(string msg) { fileline()->error(msg); }	///< Report a error
+    void fatal(string msg) { fileline()->fatal(msg); }	///< Report a fatal error
+    VPreProcOpaque* getImp() const { return m_opaquep;}
+private:
+    VPreProcOpaque*	m_opaquep;	///< Pointer to parser's implementation data.
+};
+
+#include "qfileinfo.h"
+
+class VerilogPreProc: public VPreProc
+ {
+ 
+ private:
+    string getIndexString(const string& x,bool upper);
+    
+    static DefineDict  *g_fileDefineDict;
+    static DefineDict  *g_preDefineDict;
+
+
+ public:
+     VerilogPreProc():VPreProc(){}
+     ~VerilogPreProc(){} 
+
+  
+   static DefineDict  *getFileDefineDict() 
+   { 
+      if(g_fileDefineDict==0)
+       {
+       g_fileDefineDict=new DefineDict();
+       g_fileDefineDict->setAutoDelete(true);
+       }
+       
+       return g_fileDefineDict;
+   } 
+    
+    static DefineDict  *getPreDefineDict() 
+   { 
+      if(g_preDefineDict==0)
+       {
+       g_preDefineDict=new DefineDict();
+       g_preDefineDict->setAutoDelete(true);
+       }
+       
+       return g_preDefineDict;
+   } 
+    
+    void  getPredefs();
+  
+    string performPreprocessing(const QFileInfo & qf,bool include=false);
+    
+     void comment(string cmt) {}		///< Comment detected (if keepComments==2)
+  
+     void include(string filename) ;
+         
+     void define(string name, string value, string params) ;
+
+     void undef(string name); 
+    
+    ///< Remove all non-command-line definitions
+     void undefineall() ;
+    
+     bool defExists(string name); 
+    
+     string defParams(string name) ;
+    
+     string defValue(string name) ;
+   
+     string defSubstitute(string substitute); 
+     
+     void printDict();
+    };
+
+#endif // Guard

src/settings.h

+#ifndef SETTINGS_H
+#define SETTINGS_H
+
+#define USE_SQLITE3  0
+#define USE_LIBCLANG 0
+
+#define IS_SUPPORTED(x) \
+  ((USE_SQLITE3  && strcmp("USE_SQLITE3",(x))==0)  || \
+   (USE_LIBCLANG && strcmp("USE_LIBCLANG",(x))==0) || \
+  0)
+
+#endif

src/verilogdocgen.h

+
+/******************************************************************************
+* Copyright (c) M.Kreis,2009 
+* 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
+* 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+*
+* You may use and distribute this software under the terms of the
+* GNU General Public License, version 2 or later
+*****************************************************************************/
+
+
+#ifndef VerilogDocGen_h
+#define VerilogDocGen_h
+
+#include "entry.h"
+#include "verilogscanner.h"
+//#include "vhdlscanner.h"
+#include "qfileinfo.h"
+#include "vhdldocgen.h"
+#include "config.h"
+// wrapper class for the parser
+class MyParserConv  
+{
+  
+ public:
+  uint iFileSize; 
+
+  ~MyParserConv(){}
+  MyParserConv(){}
+  
+ int parse(MyParserConv*);
+ int doLex();
+ 
+ 
+};
+
+
+class VerilogDocGen  
+{
+public:
+
+ // enum VerilogClasses {ENTITYCLASS,PACKBODYCLASS,ARCHITECTURECLASS,PACKAGECLASS};
+ 	
+  enum States {STATE_FUNCTION=0x100,STATE_MODULE,STATE_UDP,STATE_TASK,STATE_GENERATE};
+ 
+  
+	enum VerilogKeyWords
+	{
+	  MODULE=0x1000,
+	  FUNCTION,  //4097
+	  FEATURE,
+	  PRIMITIVE,
+	  COMPONENT, //4100
+	  PORT,
+       PARAMETER, //4102
+	  ALWAYS,          //4103
+	  TASK,                //4104
+	  OUTPUT,          //4105
+	  INPUT,              //4106
+	   INOUT,             //4107
+	  DEFPARAM,
+	  SPECPARAM,
+	  GENERATE,
+	  INCLUDE,
+	  TIME,
+	  SIGNAL,
+	  LIBRARY,
+	  CONFIGURATION
+	  };
+
+// functions for  verilog parser ---------------------
+
+static void writeSource(MemberDef *mdef,OutputList& ol,QCString & cname);
+static QCString convertTypeToString(int type,bool sing=true);
+
+static void writeVerilogDeclarations(MemberList* ml,OutputList &ol,
+               ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
+               const char *title,const char *subtitle,bool showEnumValues,int type);
+
+static void writeVerilogDeclarations(MemberList* ml,OutputList& ol,GroupDef* gd,ClassDef* cd,FileDef* fd=NULL);
+
+static void writePlainVerilogDeclarations(MemberDef* mdef,MemberList* mlist,OutputList &ol,
+               ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,int specifier);
+
+static void writeVerilogDeclarations(MemberDef* mdef,OutputList &ol,
+                   ClassDef *cd,NamespaceDef *nd,FileDef *fd,GroupDef *gd,
+                   bool inGroup);
+
+
+// insert a new entry
+static Entry* makeNewEntry(char* name=NULL,int sec=0,int spec=0,int line=0,bool add=true);
+
+static MemberDef* findMember(QCString& className, QCString& memName,int type);
+
+static MemberDef* findMemberDef(ClassDef* cd,QCString& key,MemberListType type,
+                                int t,bool def=false);
+
+
+static void setCurrVerilogClass(QCString&);
+
+// returns the definition which is found in class
+static MemberDef* findDefinition(ClassDef* cd,  QCString& memName);
+
+// return the module/primitve name
+static QCString getClassTitle(const ClassDef*);
+
+// returns the color of a keyword if one is found
+static const QCString* findKeyWord(const char*);
+
+static void initEntry(Entry *e);
+
+static char* removeLastWord(const char* word);
+
+static QCString getFileNameFromString(const char* fileName);
+
+static void writeLink(const MemberDef* mdef,OutputList &ol);
+static void adjustMemberName(MemberDef* md) ;
+static void adjustOpName(QCString & nn) ;
+// returns the entry found at line
+static Entry* getEntryAtLine(const Entry* ce,int line);
+static QList<Entry>* getEntryAtLine1(const Entry* ce,int line);
+static void buildGlobalVerilogVariableDict(const FileDef* fileDef,bool clear=FALSE,int level=0);
+static MemberDef* findInstMember(QCString& cl,QCString& inst,QCString& key,bool b);
+static QCString findFile(const char *fileName);
+static void writeTagFile(MemberDef *mdef,FTextStream &tagFile);
+
+};
+
+// start prefix for each comment 
+
+//% a one line comment
+
+//% a 
+//% multi line
+//% comment 
+static const char* vlogComment="//%";
+
+#endif