parser.xs

Verilog Parser in Perl

#/* Verilog.xs -- Verilog Booter  -*- C++ -*-
#*********************************************************************
#*
#* DESCRIPTION: Verilog::Parser Perl XS interface
#*
#* Author: Wilson Snyder <[e-mail]>
#*
#* Code available from: http://www.veripool.org/
#*
#*********************************************************************
#*
#* Copyright 2000-2009 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 or the Perl Artistic License.
#*
#* 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.
#*
#* You should have received a copy of the Perl Artistic License
#* along with this module; see the file COPYING.  If not, see
#* www.cpan.org
#*
#***********************************************************************
#* Note with C++ XS libraries, the CLASS parameter is implied...
#***********************************************************************/

/* Mine: */
#include "VParse.h"

/* Perl */
extern "C" {
# include "EXTERN.h"
# include "perl.h"
# include "XSUB.h"
}

#ifdef open
# undef open	/* Perl 64 bit on solaris has a nasty hack that redefines open */
#endif

#//**********************************************************************
#// Parseressor derived classes, so we can override the callbacks to call perl.

class VParserXs : public VParse {
public:
    SV*		m_self;	// Class called from
    VFileLine*	m_cbFilelinep;	///< Last callback's starting point

    VFileLine* cbFilelinep() const { return m_cbFilelinep; }
    void cbFileline(const string& filename, int lineno) { m_cbFilelinep = m_cbFilelinep->create(filename, lineno); }
    void cbFileline(VFileLine* filelinep) { m_cbFilelinep = filelinep; }

    VParserXs(VFileLine* filelinep, bool sigparser, bool useUnreadbackFlag)
	: VParse(filelinep, sigparser, useUnreadbackFlag)
	  , m_cbFilelinep(filelinep)
	{}
    virtual ~VParserXs() {}

    // Verilog::Parser Callback methods
    virtual void attributeCb(VFileLine* fl, const string& text);
    virtual void commentCb(VFileLine* fl, const string& text);
    virtual void endparseCb(VFileLine* fl);
    virtual void keywordCb(VFileLine* fl, const string& text);
    virtual void numberCb(VFileLine* fl, const string& text);
    virtual void operatorCb(VFileLine* fl, const string& text);
    virtual void preprocCb(VFileLine* fl, const string& text);
    virtual void stringCb(VFileLine* fl, const string& text);
    virtual void symbolCb(VFileLine* fl, const string& text);
    virtual void sysfuncCb(VFileLine* fl, const string& text);

    // Verilog::SigParser Callback methods
    virtual void endcellCb(VFileLine* fl, const string& kwd);
    virtual void endinterfaceCb(VFileLine* fl, const string& kwd);
    virtual void endmoduleCb(VFileLine* fl, const string& kwd);
    virtual void endpackageCb(VFileLine* fl, const string& kwd);
    virtual void endtaskfuncCb(VFileLine* fl, const string& kwd);
    virtual void functionCb(VFileLine* fl, const string& kwd, const string& name, const string& type);
    virtual void importCb(VFileLine* fl, const string& name);
    virtual void instantCb(VFileLine* fl, const string& mod, const string& cell, const string& range);
    virtual void interfaceCb(VFileLine* fl, const string& kwd, const string& name);
    virtual void moduleCb(VFileLine* fl, const string& kwd, const string& name, bool celldefine);
    virtual void packageCb(VFileLine* fl, const string& kwd, const string& name);
    virtual void paramPinCb(VFileLine* fl, const string& name, const string& conn, int number);
    virtual void pinCb(VFileLine* fl, const string& name, const string& conn, int number);
    virtual void portCb(VFileLine* fl, const string& name);
    virtual void signalCb(VFileLine* fl, const string& kwd, const string& name,
			  const string& vec, const string& mem, const string& signd,
			  const string& value,
			  bool inFunc);
    virtual void taskCb(VFileLine* fl, const string& kwd, const string& name);

    void call(string* rtnStrp, int params, const char* method, ...);
};

class VFileLineParseXs : public VFileLine {
    VParserXs*	m_vParserp;		// Parser handling the errors
public:
    VFileLineParseXs(int called_only_for_default) : VFileLine(called_only_for_default) {}
    virtual ~VFileLineParseXs() { }
    virtual VFileLine* create(const string filename, int lineno);
    virtual void error(const string msg);	// Report a error at given location
    void setParser(VParserXs* pp) { m_vParserp=pp; }
};

#//**********************************************************************
#// Overrides error handling virtual functions to invoke callbacks

VFileLine* VFileLineParseXs::create(const string filename, int lineno) {
    VFileLineParseXs* filelp = new VFileLineParseXs(true);
    filelp->init(filename, lineno);
    filelp->m_vParserp = m_vParserp;
    return filelp;
}

void VFileLineParseXs::error(string msg) {
    static string holdmsg; holdmsg = msg;
    m_vParserp->cbFileline(this);
    m_vParserp->call(NULL, 1,"error",holdmsg.c_str());
}

#//**********************************************************************
#// Overrides of virtual functions to invoke callbacks

// Verilog::Parser Callback methods
void VParserXs::attributeCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"attribute",hold1.c_str());
}
void VParserXs::commentCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"comment",hold1.c_str());
}
void VParserXs::endparseCb(VFileLine* fl) {
    cbFileline(fl);
    call(NULL, 1,"endparse","");
}
void VParserXs::keywordCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"keyword",hold1.c_str());
}
void VParserXs::numberCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"number",hold1.c_str());
}
void VParserXs::operatorCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"operator",hold1.c_str());
}
void VParserXs::preprocCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"preproc",hold1.c_str());
}
void VParserXs::stringCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"string",hold1.c_str());
}
void VParserXs::symbolCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"symbol",hold1.c_str());
}
void VParserXs::sysfuncCb(VFileLine* fl, const string& text) {
    cbFileline(fl);
    static string hold1; hold1 = text;
    call(NULL, 1,"sysfunc",hold1.c_str());
}

// Verilog::SigParser Callback methods
void VParserXs::endcellCb(VFileLine* fl, const string& kwd) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    call(NULL, 1,"endcell",hold1.c_str());
}
void VParserXs::endinterfaceCb(VFileLine* fl, const string& kwd) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    call(NULL, 1,"endinterface",hold1.c_str());
}
void VParserXs::endmoduleCb(VFileLine* fl, const string& kwd) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    call(NULL, 1,"endmodule",hold1.c_str());
}
void VParserXs::endpackageCb(VFileLine* fl, const string& kwd) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    call(NULL, 1,"endpackage",hold1.c_str());
}
void VParserXs::endtaskfuncCb(VFileLine* fl, const string& kwd) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    call(NULL, 1,"endtaskfunc",hold1.c_str());
}
void VParserXs::functionCb(VFileLine* fl, const string& kwd, const string& name, const string& type) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    static string hold2; hold2 = name;
    static string hold3; hold3 = type;
    call(NULL, 3,"function",hold1.c_str(), hold2.c_str(), hold3.c_str());
}
void VParserXs::importCb(VFileLine* fl, const string& name) {
    cbFileline(fl);
    static string hold1; hold1 = name;
    call(NULL, 1,"import",hold1.c_str());
}
void VParserXs::instantCb(VFileLine* fl, const string& mod, const string& cell, const string& range) {
    cbFileline(fl);
    static string hold1; hold1 = mod;
    static string hold2; hold2 = cell;
    static string hold3; hold3 = range;
    call(NULL, 3,"instant",hold1.c_str(), hold2.c_str(), hold3.c_str());
}
void VParserXs::interfaceCb(VFileLine* fl, const string& kwd, const string& name) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    static string hold2; hold2 = name;
    call(NULL, 2,"interface",hold1.c_str(), hold2.c_str());
}
void VParserXs::moduleCb(VFileLine* fl, const string& kwd, const string& name, bool celldefine) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    static string hold2; hold2 = name;
    //Unused
    static string hold4; hold4 = celldefine?"1":"0";
    call(NULL, 4,"module",hold1.c_str(), hold2.c_str(), NULL, hold4.c_str());
}
void VParserXs::packageCb(VFileLine* fl, const string& kwd, const string& name) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    static string hold2; hold2 = name;
    //Unused
    call(NULL, 2,"package",hold1.c_str(), hold2.c_str());
}