int main()
{
ASTREE* root,*ast1,*ast2,*ast3,*ast4,*ast5,*ast6;
//DICT_NODE *symbol = malloc(sizeof(DICT_NODE*));
ast1=astCreate(5,0,0, 0, 0, 0);
ast2=astCreate(6,0,0, 0, 0, 0);
ast3=astCreate(7,0,0, 0, 0, 0);
ast4=astCreate(7,0,0, 0, 0, 0);
ast5=astCreate(7,0,0, 0, 0, 0);
ast6=astCreate(7,0,0, 0, 0, 0);
ast4=astCreate(7,0,0, ast5, ast6, 0);
root=astCreate(5,0,ast1, ast2, ast3, ast4);
//------------------------------------------------
gv_init("testando.dot");
astReadTree(root);
gv_close();
return 0;
}
GV *
Perl_gv_fetchfile(pTHX_ const char *name)
{
char smallbuf[256];
char *tmpbuf;
STRLEN tmplen;
GV *gv;
if (!PL_defstash)
return Nullgv;
tmplen = strlen(name) + 2;
if (tmplen < sizeof smallbuf)
tmpbuf = smallbuf;
else
New(603, tmpbuf, tmplen + 1, char);
tmpbuf[0] = '_';
tmpbuf[1] = '<';
strcpy(tmpbuf + 2, name);
gv = *(GV**)hv_fetch(PL_defstash, tmpbuf, tmplen, TRUE);
if (!isGV(gv)) {
gv_init(gv, PL_defstash, tmpbuf, tmplen, FALSE);
sv_setpv(GvSV(gv), name);
if (PERLDB_LINE)
hv_magic(GvHVn(gv_AVadd(gv)), Nullgv, 'L');
}
if (tmpbuf != smallbuf)
Safefree(tmpbuf);
return gv;
}
int main (int argc, char **argv)
{
int result;
long window=1;
long count=1;
if (argc>1) {
const char *filename = argv[1];
if (argc==4) {
window = strtol(argv[2],NULL,10);
count = strtol(argv[3],NULL,10);
}
result = iloc_parser(filename);
}
else {
iks_init();
gv_init("ast_graph.dot");
result = yyparse();
gv_close();
code_generator(&ast);
iks_ast_node_value_t *program = ast->item;
program_iloc = program->code;
}
optim_main(program_iloc,window,count);
iloc_print(program_iloc);
return result;
}
int main (int argc, char **argv)
{
gv_init("saida.dot");
int resultado = yyparse();
gv_close();
//dict_print();
return resultado;
}
GV*
Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
{
char autoload[] = "AUTOLOAD";
STRLEN autolen = sizeof(autoload)-1;
GV* gv;
CV* cv;
HV* varstash;
GV* vargv;
SV* varsv;
if (len == autolen && strnEQ(name, autoload, autolen))
return Nullgv;
if (!(gv = gv_fetchmeth(stash, autoload, autolen, FALSE)))
return Nullgv;
cv = GvCV(gv);
if (!CvROOT(cv))
return Nullgv;
/*
* Inheriting AUTOLOAD for non-methods works ... for now.
*/
if (ckWARN(WARN_DEPRECATED) && !method &&
(GvCVGEN(gv) || GvSTASH(gv) != stash))
Perl_warner(aTHX_ WARN_DEPRECATED,
"Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
HvNAME(stash), (int)len, name);
/*
* Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
* The subroutine's original name may not be "AUTOLOAD", so we don't
* use that, but for lack of anything better we will use the sub's
* original package to look up $AUTOLOAD.
*/
varstash = GvSTASH(CvGV(cv));
vargv = *(GV**)hv_fetch(varstash, autoload, autolen, TRUE);
ENTER;
#ifdef USE_THREADS
sv_lock((SV *)varstash);
#endif
if (!isGV(vargv))
gv_init(vargv, varstash, autoload, autolen, FALSE);
LEAVE;
varsv = GvSV(vargv);
#ifdef USE_THREADS
sv_lock(varsv);
#endif
sv_setpv(varsv, HvNAME(stash));
sv_catpvn(varsv, "::", 2);
sv_catpvn(varsv, name, len);
SvTAINTED_off(varsv);
return gv;
}
Agraph_t *read(const char *filename)
{
FILE *f;
Agraph_t *g;
f = fopen(filename, "r");
if (!f)
return NULL;
if (!gvc)
gv_init();
g = agread(f, NULL);
fclose(f);
return g;
}
void
mop_get_package_symbols (HV *stash, type_filter_t filter, get_package_symbols_cb_t cb, void *ud)
{
HE *he;
(void)hv_iterinit(stash);
if (filter == TYPE_FILTER_NONE) {
while ( (he = hv_iternext(stash)) ) {
STRLEN keylen;
const char *key = HePV(he, keylen);
if (!cb(key, keylen, HeVAL(he), ud)) {
return;
}
}
return;
}
while ( (he = hv_iternext(stash)) ) {
GV * const gv = (GV*)HeVAL(he);
STRLEN keylen;
const char * const key = HePV(he, keylen);
SV *sv = NULL;
if(isGV(gv)){
switch (filter) {
case TYPE_FILTER_CODE: sv = (SV *)GvCVu(gv); break;
case TYPE_FILTER_ARRAY: sv = (SV *)GvAV(gv); break;
case TYPE_FILTER_IO: sv = (SV *)GvIO(gv); break;
case TYPE_FILTER_HASH: sv = (SV *)GvHV(gv); break;
case TYPE_FILTER_SCALAR: sv = (SV *)GvSV(gv); break;
default:
croak("Unknown type");
}
}
/* expand the gv into a real typeglob if it
* contains stub functions or constants and we
* were asked to return CODE references */
else if (filter == TYPE_FILTER_CODE) {
gv_init(gv, stash, key, keylen, GV_ADDMULTI);
sv = (SV *)GvCV(gv);
}
if (sv) {
if (!cb(key, keylen, sv, ud)) {
return;
}
}
}
}
int main (int argc, char **argv)
{
local_scope = treeCreateNode(0, NULL);
gv_init("teste.dot");
int resultado = yyparse();
//printf("Result: %d\n", resultado);
gv_close();
if(resultado)
exit(IKS_SYNTAX_ERRO);
else
exit(IKS_SYNTAX_SUCESSO);
dictEmpty(dictionary);
return resultado;
}
int draw_list(const char *name[], const char *data[], int n, size_t data_size)
{
FILE *fp = gv_init();
if (!fp)
{
return 1;
}
write_nodes_by_array(fp, name, data, n, data_size);
write_egdes_by_array(fp, name, name + 1, n);
if (!gv_close(fp))
{
return 2;
}
return 0;
}
int draw_node(Iter *iter)
{
FILE *fp = gv_init();
if (!fp)
return 1;
for (; iter->next; iter->iterate(iter,iter->next)) {
draw_node_info(fp, iter, DATA_LIMITS);
}
//链表最后一个节点
draw_node_info(fp, iter, DATA_LIMITS);
if (!gv_close(fp))
return 2;
return 0;
}
int main (int argc, char **argv)
{
if (argc > 1)
{
yyin = fopen(argv[1], "r");
}
gv_init("saida.dot");
int resultado = yyparse();
gv_close();
if (argc > 1)
{
fclose(yyin);
}
return resultado;
}
GV *
Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, I32 sv_type)
{
register const char *name = nambeg;
register GV *gv = 0;
GV**gvp;
I32 len;
register const char *namend;
HV *stash = 0;
if (*name == '*' && isALPHA(name[1])) /* accidental stringify on a GV? */
name++;
for (namend = name; *namend; namend++) {
if ((*namend == ':' && namend[1] == ':')
|| (*namend == '\'' && namend[1]))
{
if (!stash)
stash = PL_defstash;
if (!stash || !SvREFCNT(stash)) /* symbol table under destruction */
return Nullgv;
len = namend - name;
if (len > 0) {
char smallbuf[256];
char *tmpbuf;
if (len + 3 < sizeof smallbuf)
tmpbuf = smallbuf;
else
New(601, tmpbuf, len+3, char);
Copy(name, tmpbuf, len, char);
tmpbuf[len++] = ':';
tmpbuf[len++] = ':';
tmpbuf[len] = '\0';
gvp = (GV**)hv_fetch(stash,tmpbuf,len,add);
gv = gvp ? *gvp : Nullgv;
if (gv && gv != (GV*)&PL_sv_undef) {
if (SvTYPE(gv) != SVt_PVGV)
gv_init(gv, stash, tmpbuf, len, (add & GV_ADDMULTI));
else
GvMULTI_on(gv);
}
if (tmpbuf != smallbuf)
Safefree(tmpbuf);
if (!gv || gv == (GV*)&PL_sv_undef)
return Nullgv;
if (!(stash = GvHV(gv)))
stash = GvHV(gv) = newHV();
if (!HvNAME(stash))
HvNAME(stash) = savepvn(nambeg, namend - nambeg);
}
if (*namend == ':')
namend++;
namend++;
name = namend;
if (!*name)
return gv ? gv : (GV*)*hv_fetch(PL_defstash, "main::", 6, TRUE);
}
}
GV *
Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
{
AV* av;
GV* topgv;
GV* gv;
GV** gvp;
CV* cv;
if (!stash)
return 0;
if ((level > 100) || (level < -100))
Perl_croak(aTHX_ "Recursive inheritance detected while looking for method '%s' in package '%s'",
name, HvNAME(stash));
DEBUG_o( Perl_deb(aTHX_ "Looking for method %s in package %s\n",name,HvNAME(stash)) );
gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
if (!gvp)
topgv = Nullgv;
else {
topgv = *gvp;
if (SvTYPE(topgv) != SVt_PVGV)
gv_init(topgv, stash, name, len, TRUE);
if ((cv = GvCV(topgv))) {
/* If genuine method or valid cache entry, use it */
if (!GvCVGEN(topgv) || GvCVGEN(topgv) == PL_sub_generation)
return topgv;
/* Stale cached entry: junk it */
SvREFCNT_dec(cv);
GvCV(topgv) = cv = Nullcv;
GvCVGEN(topgv) = 0;
}
else if (GvCVGEN(topgv) == PL_sub_generation)
return 0; /* cache indicates sub doesn't exist */
}
gvp = (GV**)hv_fetch(stash, "ISA", 3, FALSE);
av = (gvp && (gv = *gvp) && gv != (GV*)&PL_sv_undef) ? GvAV(gv) : Nullav;
/* create and re-create @.*::SUPER::ISA on demand */
if (!av || !SvMAGIC(av)) {
char* packname = HvNAME(stash);
STRLEN packlen = strlen(packname);
if (packlen >= 7 && strEQ(packname + packlen - 7, "::SUPER")) {
HV* basestash;
packlen -= 7;
basestash = gv_stashpvn(packname, packlen, TRUE);
gvp = (GV**)hv_fetch(basestash, "ISA", 3, FALSE);
if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (av = GvAV(gv))) {
gvp = (GV**)hv_fetch(stash, "ISA", 3, TRUE);
if (!gvp || !(gv = *gvp))
Perl_croak(aTHX_ "Cannot create %s::ISA", HvNAME(stash));
if (SvTYPE(gv) != SVt_PVGV)
gv_init(gv, stash, "ISA", 3, TRUE);
SvREFCNT_dec(GvAV(gv));
GvAV(gv) = (AV*)SvREFCNT_inc(av);
}
}
}
if (av) {
SV** svp = AvARRAY(av);
/* NOTE: No support for tied ISA */
I32 items = AvFILLp(av) + 1;
while (items--) {
SV* sv = *svp++;
HV* basestash = gv_stashsv(sv, FALSE);
if (!basestash) {
if (ckWARN(WARN_MISC))
Perl_warner(aTHX_ WARN_MISC, "Can't locate package %s for @%s::ISA",
SvPVX(sv), HvNAME(stash));
continue;
}
gv = gv_fetchmeth(basestash, name, len,
(level >= 0) ? level + 1 : level - 1);
if (gv)
goto gotcha;
}
}
/* if at top level, try UNIVERSAL */
if (level == 0 || level == -1) {
HV* lastchance;
if ((lastchance = gv_stashpvn("UNIVERSAL", 9, FALSE))) {
if ((gv = gv_fetchmeth(lastchance, name, len,
(level >= 0) ? level + 1 : level - 1)))
{
gotcha:
/*
* Cache method in topgv if:
* 1. topgv has no synonyms (else inheritance crosses wires)
* 2. method isn't a stub (else AUTOLOAD fails spectacularly)
*/
if (topgv &&
GvREFCNT(topgv) == 1 &&
(cv = GvCV(gv)) &&
(CvROOT(cv) || CvXSUB(cv)))
{
if ((cv = GvCV(topgv)))
SvREFCNT_dec(cv);
GvCV(topgv) = (CV*)SvREFCNT_inc(GvCV(gv));
GvCVGEN(topgv) = PL_sub_generation;
}
return gv;
}
else if (topgv && GvREFCNT(topgv) == 1) {
/* cache the fact that the method is not defined */
GvCVGEN(topgv) = PL_sub_generation;
}
}
}
return 0;
}
GV*
Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
{
char autoload[] = "AUTOLOAD";
STRLEN autolen = sizeof(autoload)-1;
GV* gv;
CV* cv;
HV* varstash;
GV* vargv;
SV* varsv;
char *packname = "";
if (len == autolen && strnEQ(name, autoload, autolen))
return Nullgv;
if (stash) {
if (SvTYPE(stash) < SVt_PVHV) {
packname = SvPV_nolen((SV*)stash);
stash = Nullhv;
}
else {
packname = HvNAME(stash);
}
}
if (!(gv = gv_fetchmeth(stash, autoload, autolen, FALSE)))
return Nullgv;
cv = GvCV(gv);
if (!(CvROOT(cv) || CvXSUB(cv)))
return Nullgv;
/*
* Inheriting AUTOLOAD for non-methods works ... for now.
*/
if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX) && !method &&
(GvCVGEN(gv) || GvSTASH(gv) != stash))
Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
"Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
packname, (int)len, name);
if (CvXSUB(cv)) {
/* rather than lookup/init $AUTOLOAD here
* only to have the XSUB do another lookup for $AUTOLOAD
* and split that value on the last '::',
* pass along the same data via some unused fields in the CV
*/
CvSTASH(cv) = stash;
SvPVX(cv) = (char *)name; /* cast to lose constness warning */
SvCUR(cv) = len;
return gv;
}
/*
* Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
* The subroutine's original name may not be "AUTOLOAD", so we don't
* use that, but for lack of anything better we will use the sub's
* original package to look up $AUTOLOAD.
*/
varstash = GvSTASH(CvGV(cv));
vargv = *(GV**)hv_fetch(varstash, autoload, autolen, TRUE);
ENTER;
if (!isGV(vargv))
gv_init(vargv, varstash, autoload, autolen, FALSE);
LEAVE;
varsv = GvSV(vargv);
sv_setpv(varsv, packname);
sv_catpvn(varsv, "::", 2);
sv_catpvn(varsv, name, len);
SvTAINTED_off(varsv);
return gv;
}
/**
* Switch the current map
*/
static GFraMe_ret ps_switchMap() {
GFraMe_ret rv;
#if !defined(DEBUG) || !defined(FAST_TRANSITION)
GFraMe_event_update_begin();
int tmp;
// Store whether the game was running
tmp = gl_running;
// Make it stop on any error
gl_running = 0;
switch (switchState) {
/** Simply start the transition */
case 0: transition_initFadeOut(); switchState++; break;
/** Fade out */
case 1: {
if (transition_fadeOut(GFraMe_event_elapsed) == TR_COMPLETE)
switchState++;
} break;
/** Load the map */
case 2: {
int map;
map = gv_getValue(MAP);
rv = map_loadi(m, map);
ASSERT(rv == GFraMe_ret_ok, rv);
if (map >= 20) {
audio_playBoss();
}
else if (map >= 15) {
audio_playTensionGoesUp();
}
else if (map >= 4) {
audio_playMovingOn();
}
else {
audio_playIntro();
}
switchState++;
} break;
/** Tween players to their new position */
case 3: {
int x, y;
// Get their destiny position
x = gv_getValue(DOOR_X) * 8;
y = gv_getValue(DOOR_Y) * 8;
// Tween the players
rv = player_tweenTo(p1, x, y, GFraMe_event_elapsed, PL_TWEEN_DELAY);
rv = player_tweenTo(p2, x, y, GFraMe_event_elapsed, PL_TWEEN_DELAY);
// Update camera
cam_setPositionSt(p1, p2);
if (rv == GFraMe_ret_ok)
switchState++;
} break;
/** Init fade in animation */
case 4: transition_initFadeIn(); switchState++; break;
/** Fade in */
case 5: {
if (transition_fadeIn(GFraMe_event_elapsed) == TR_COMPLETE)
switchState++;
} break;
/** Finish the transition */
default: {
int map;
map = gv_getValue(MAP);
if (map == 1) {
if (gl_lang == EN_US) {
ps_showText(_ps_map001_textEN, sizeof(_ps_map001_textEN), 0, 0, 40, 6);
}
else if (gl_lang == PT_BR) {
ps_showText(_ps_map001_textPT, sizeof(_ps_map001_textPT), 0, 0, 40, 6);
}
}
else if (map == 8 || map == 13) {
if (gl_lang == EN_US) {
ps_showText(_ps_map_afterItemEN, sizeof(_ps_map_afterItemEN), 0, 0, 40, 6);
}
else if (gl_lang == PT_BR) {
ps_showText(_ps_map_afterItemPT, sizeof(_ps_map_afterItemPT), 0, 0, 40, 6);
}
}
gv_setValue(SWITCH_MAP, 0);
switchState = 0;
signal_release();
// Set the update time (for using on events)
gv_setValue(GAME_UPS, GFraMe_event_elapsed);
// Save the current state
if (player_isAlive(p1) && player_isAlive(p2)) {
gv_setValue(GAME_TIME, timer_getTime());
rv = gv_save(SAVEFILE);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Error saving file!", __ret);
}
# if defined(DEBUG) && defined(RESET_GV)
gv_init();
# endif /* RESET_GV */
}
}
gl_running = tmp;
GFraMe_event_update_end();
#else /* FAST_TRANSITION */
int tmp, x, y;
int map;
// Store whether the game was running
tmp = gl_running;
// Make it stop on any error
gl_running = 0;
map = gv_getValue(MAP);
rv = map_loadi(m, map);
ASSERT(rv == GFraMe_ret_ok, rv);
// Get their destiny position
x = gv_getValue(DOOR_X) * 8;
y = gv_getValue(DOOR_Y) * 8;
// Tween the players
rv = player_tweenTo(p1, x, y, GFraMe_event_elapsed, 0);
rv = player_tweenTo(p2, x, y, GFraMe_event_elapsed, 0);
// Update camera
cam_setPositionSt(p1, p2);
gv_setValue(SWITCH_MAP, 0);
# ifdef RESET_GV
gv_init();
# endif /* RESET_GV */
gl_running = tmp;
// Set the update time (for using on events)
gv_setValue(GAME_UPS, GFraMe_event_elapsed);
// Save the current state
if (player_isAlive(p1) && player_isAlive(p2)) {
gv_setValue(GAME_TIME, timer_getTime());
rv = gv_save(SAVEFILE);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Error saving file!", __ret);
}
#endif /* FAST_TRANSITION */
// Set return variable
rv = GFraMe_ret_ok;
__ret:
return rv;
}
/**
* Initialize the playstate
*
* @return GFraMe error code
*/
static GFraMe_ret ps_init(int isLoading) {
GFraMe_ret rv;
GFraMe_save sv, *pSv;
int map, plX, plY, time;
// Open the configurations
rv = GFraMe_save_bind(&sv, CONFFILE);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Error reading config file", __ret);
pSv = &sv;
// Read the desired fps (for update and drawing)
rv = GFraMe_save_read_int(&sv, "ufps", &_maxUfps);
if (rv != GFraMe_ret_ok)
_maxUfps = GAME_UFPS;
rv = GFraMe_save_read_int(&sv, "dfps", &_maxDfps);
if (rv != GFraMe_ret_ok)
_maxDfps = GAME_DFPS;
rv = GFraMe_save_read_int(&sv, "speedrun", &_ps_isSpeedrun);
if (rv != GFraMe_ret_ok)
_ps_isSpeedrun = 0;
GFraMe_save_close(&sv);
pSv = 0;
if (!isLoading) {
gv_init();
plX = 16;
plY = 184;
map = 0;
}
else {
rv = gv_load(SAVEFILE);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to load state", __ret);
plX = gv_getValue(DOOR_X) * 8;
plY = gv_getValue(DOOR_Y) * 8;
map = gv_getValue(MAP);
}
time = gv_getValue(GAME_TIME);
timer_init(time);
if (map >= 20) {
audio_playBoss();
}
else if (map >= 15) {
audio_playTensionGoesUp();
}
else if (map >= 4) {
audio_playMovingOn();
}
else {
audio_playIntro();
}
rv = ui_init();
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to init ui", __ret);
rv = rg_init();
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to registry ui", __ret);
rv = map_init(&m);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to init map", __ret);
rv = player_init(&p1, ID_PL1, 224, plX, plY);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to init player", __ret);
rv = player_init(&p2, ID_PL2, 240, plX, plY);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to init player", __ret);
rv = map_loadi(m, map);
GFraMe_assertRet(rv == GFraMe_ret_ok, "Failed to init map", __ret);
signal_init();
_timerTilCredits = 0;
_ps_onOptions = 0;
_ps_text = 0;
switchState = 0;
transition_initFadeOut();
#ifdef DEBUG
_updCalls = 0;
_drwCalls = 0;
_time = 0;
_ltime = 0;
#endif
rv = GFraMe_ret_ok;
__ret:
if (pSv)
GFraMe_save_close(pSv);
return rv;
}
Agraph_t *read(FILE *f)
{
if (!gvc)
gv_init();
return agread(f, NULL);
}
Agraph_t *strictdigraph(char *name)
{
if (!gvc)
gv_init();
return agopen(name, Agstrictdirected, 0);
}
//-------------------------------------------------
Agraph_t *graph(Agraph_t *g, char *name)
{
if (!gvc)
gv_init();
return agsubg(g, name, 1);
}
Agraph_t *graph(char *name)
{
if (!gvc)
gv_init();
return agopen(name, Agundirected, 0);
}
STATIC SV *
S_isa_lookup(pTHX_ HV *stash, const char *name, int len, int level)
{
AV* av;
GV* gv;
GV** gvp;
HV* hv = Nullhv;
SV* subgen = Nullsv;
if (!stash)
return &PL_sv_undef;
if (strEQ(HvNAME(stash), name))
return &PL_sv_yes;
if (level > 100)
Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
HvNAME(stash));
gvp = (GV**)hv_fetch(stash, "::ISA::CACHE::", 14, FALSE);
if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (subgen = GvSV(gv))
&& (hv = GvHV(gv)))
{
if (SvIV(subgen) == PL_sub_generation) {
SV* sv;
SV** svp = (SV**)hv_fetch(hv, name, len, FALSE);
if (svp && (sv = *svp) != (SV*)&PL_sv_undef) {
DEBUG_o( Perl_deb(aTHX_ "Using cached ISA %s for package %s\n",
name, HvNAME(stash)) );
return sv;
}
}
else {
DEBUG_o( Perl_deb(aTHX_ "ISA Cache in package %s is stale\n",
HvNAME(stash)) );
hv_clear(hv);
sv_setiv(subgen, PL_sub_generation);
}
}
gvp = (GV**)hv_fetch(stash,"ISA",3,FALSE);
if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (av = GvAV(gv))) {
if (!hv || !subgen) {
gvp = (GV**)hv_fetch(stash, "::ISA::CACHE::", 14, TRUE);
gv = *gvp;
if (SvTYPE(gv) != SVt_PVGV)
gv_init(gv, stash, "::ISA::CACHE::", 14, TRUE);
if (!hv)
hv = GvHVn(gv);
if (!subgen) {
subgen = newSViv(PL_sub_generation);
GvSV(gv) = subgen;
}
}
if (hv) {
SV** svp = AvARRAY(av);
/* NOTE: No support for tied ISA */
I32 items = AvFILLp(av) + 1;
while (items--) {
SV* sv = *svp++;
HV* basestash = gv_stashsv(sv, FALSE);
if (!basestash) {
if (ckWARN(WARN_MISC))
Perl_warner(aTHX_ WARN_SYNTAX,
"Can't locate package %s for @%s::ISA",
SvPVX(sv), HvNAME(stash));
continue;
}
if (&PL_sv_yes == isa_lookup(basestash, name, len, level + 1)) {
(void)hv_store(hv,name,len,&PL_sv_yes,0);
return &PL_sv_yes;
}
}
(void)hv_store(hv,name,len,&PL_sv_no,0);
}
}
return boolSV(strEQ(name, "UNIVERSAL"));
}
Agraph_t *readstring(char *string)
{
if (!gvc)
gv_init();
return agmemread(string);
}
