parser.xs

Verilog Parser in Perl

void VParserXs::paramPinCb(VFileLine* fl, const string& name, const string& conn, int number) {
    cbFileline(fl);
    static string hold1; hold1 = name;
    static string hold2; hold2 = conn;
    static char num3[100]; sprintf(num3,"%d",number);
    static string hold3; hold3 = num3;
    call(NULL, 3,"parampin",hold1.c_str(), hold2.c_str(), hold3.c_str());
}
void VParserXs::pinCb(VFileLine* fl, const string& name, const string& conn, int number) {
    cbFileline(fl);
    static string hold1; hold1 = name;
    static string hold2; hold2 = conn;
    static char num3[100]; sprintf(num3,"%d",number);
    static string hold3; hold3 = num3;
    call(NULL, 3,"pin",hold1.c_str(), hold2.c_str(), hold3.c_str());
}
void VParserXs::portCb(VFileLine* fl, const string& name) {
    cbFileline(fl);
    static string hold1; hold1 = name;
    call(NULL, 1,"port",hold1.c_str());
}
void VParserXs::signalCb(VFileLine* fl, const string& kwd, const string& name,
			 const string& vec, const string& mem, const string& signd,
			 const string& value,
			 bool inFunc) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    static string hold2; hold2 = name;
    static string hold3; hold3 = vec;
    static string hold4; hold4 = mem;
    static string hold5; hold5 = signd;
    static string hold6; hold6 = value;
    call(NULL, 6, (inFunc?"funcsignal":"signal_decl"),
	 hold1.c_str(), hold2.c_str(),
	 hold3.c_str(), hold4.c_str(), hold5.c_str(), hold6.c_str());
}
void VParserXs::taskCb(VFileLine* fl, const string& kwd, const string& name) {
    cbFileline(fl);
    static string hold1; hold1 = kwd;
    static string hold2; hold2 = name;
    call(NULL, 2,"task",hold1.c_str(), hold2.c_str());
}


void VParserXs::call (
    string* rtnStrp,	/* If non-null, load return value here */
    int params,		/* Number of parameters */
    const char* method,	/* Name of method to call */
    ...)		/* Arguments to pass to method's @_ */
{
    // Call $perlself->method (passedparam1, parsedparam2)
    if (debug()) cout << "CALLBACK "<<method<<endl;
    va_list ap;
    va_start(ap, method);
    {
	dSP;				/* Initialize stack pointer */
	ENTER;				/* everything created after here */
	SAVETMPS;			/* ...is a temporary variable. */
	PUSHMARK(SP);			/* remember the stack pointer */
	XPUSHs(m_self);			/* $self-> */

	while (params--) {
	    char *text;
	    SV *sv;
	    text = va_arg(ap, char *);
	    if (text) {
		sv = newSVpv (text, 0);
	    } else {
		sv = &PL_sv_undef;
	    }
	    XPUSHs(sv);			/* token */
	}

	PUTBACK;			/* make local stack pointer global */

	if (rtnStrp) {
	    int rtnCount = perl_call_method ((char*)method, G_SCALAR);
	    SPAGAIN;			/* refresh stack pointer */
	    if (rtnCount > 0) {
		SV* sv = POPs;
		//printf("RTN %ld %d %s\n", SvTYPE(sv),SvTRUE(sv),SvPV_nolen(sv));
#ifdef SvPV_nolen	// Perl 5.6 and later
		*rtnStrp = SvPV_nolen(sv);
#else
		*rtnStrp = SvPV(sv,PL_na);
#endif
	    }
	    PUTBACK;
	} else {
	    perl_call_method ((char*)method, G_DISCARD | G_VOID);
	}

	FREETMPS;			/* free that return value */
	LEAVE;				/* ...and the XPUSHed "mortal" args.*/
    }
    va_end(ap);
}

#//**********************************************************************

MODULE = Verilog::Parser  PACKAGE = Verilog::Parser

#//**********************************************************************
#// self->_new (class, sigparser)

static VParserXs *
VParserXs::_new (SV* SELF, bool sigparser, bool useUnreadback)
PROTOTYPE: $$
CODE:
{
    if (CLASS) {}  /* Prevent unused warning */
    VFileLineParseXs* filelinep = new VFileLineParseXs(1/*ok,for initial*/);
    VParserXs* parserp = new VParserXs(filelinep, sigparser, useUnreadback);
    filelinep->setParser(parserp);
    parserp->m_self = newSVsv(SELF);
    RETVAL = parserp;
}
OUTPUT: RETVAL

#//**********************************************************************
#// self->_DESTROY()

void
VParserXs::_DESTROY()
PROTOTYPE: $
CODE:
{
    delete THIS;
}
#//**********************************************************************
#// self->debug()

void
VParserXs::_debug (level)
int level
PROTOTYPE: $$
CODE:
{
    THIS->debug(level);
}

#//**********************************************************************
#// self->eof()

void
VParserXs::eof ()
PROTOTYPE: $
CODE:
{
    THIS->setEof();
}
#//**********************************************************************
#// self->filename([setit])

const char *
VParserXs::filename (const char* flagp="")
PROTOTYPE: $;$
CODE:
{
    if (!THIS) XSRETURN_UNDEF;
    if (items > 1) {
	THIS->inFileline(flagp, THIS->inFilelinep()->lineno());
	THIS->cbFileline(flagp, THIS->inFilelinep()->lineno());
    }
    RETVAL = THIS->cbFilelinep()->filename().c_str();
}
OUTPUT: RETVAL

#//**********************************************************************
#// self->language()

void
VParserXs::language (valuep)
const char* valuep
PROTOTYPE: $$
CODE:
{
    if (items > 1) {
        THIS->language(valuep);
    }
}

#//**********************************************************************
#// self->lineno([setit])

int
VParserXs::lineno (int flag=0)
PROTOTYPE: $;$
CODE:
{
    if (!THIS) XSRETURN_UNDEF;
    if (items > 1) {
	THIS->inFileline(THIS->inFilelinep()->filename(), flag);
	THIS->cbFileline(THIS->inFilelinep()->filename(), flag);
    }
    RETVAL = (THIS->cbFilelinep()->lineno());
}
OUTPUT: RETVAL

#//**********************************************************************
#// self->parse()

void
VParserXs::parse (const char* textp)
PROTOTYPE: $$
CODE:
{
    THIS->parse(textp);
}

#//**********************************************************************
#// self->unreadback()

SV*
VParserXs::unreadback (const char* flagp="")
PROTOTYPE: $;$
CODE:
{
    if (!THIS) XSRETURN_UNDEF;
    // Set RETVAL to a SV before we replace with the new value, and c_str may change
    RETVAL = newSVpv(THIS->unreadback().c_str(), THIS->unreadback().length());
    if (items > 1) {
	THIS->unreadback(flagp);
    }
}
OUTPUT: RETVAL

#//**********************************************************************
#// self->unreadbackCat()

void
VParserXs::unreadbackCat (SV* textsvp)
PROTOTYPE: $$
CODE:
{
    if (!THIS) XSRETURN_UNDEF;
    STRLEN textlen;
    const char* textp = SvPV(textsvp, textlen);
    THIS->unreadbackCat(textp, textlen);
}