static void modperl_package_unload_dynamic(pTHX_ const char *package,
I32 dl_index)
{
AV *librefs = get_av(dl_librefs, 0);
SV *libref = *av_fetch(librefs, dl_index, 0);
modperl_sys_dlclose(INT2PTR(void *, SvIV(libref)));
/* remove package from @dl_librefs and @dl_modules */
modperl_av_remove_entry(aTHX_ get_av(dl_librefs, 0), dl_index);
modperl_av_remove_entry(aTHX_ get_av(dl_modules, 0), dl_index);
return;
}
JSObject *
PJS_InitPerlArrayClass(
pTHX_
JSContext *cx,
JSObject *global
) {
JSObject *proto;
JSObject *stash = PJS_GetPackageObject(aTHX_ cx, PerlArrayPkg);
proto = JS_InitClass(
cx,
global,
stash,
&perlarray_class,
PerlArray, 0,
perlarray_props, perlarray_methods,
NULL, NULL
);
if(!proto ||
!JS_DefineProperty(cx, stash, PJS_PROXY_PROP,
OBJECT_TO_JSVAL(proto), NULL, NULL, 0))
return NULL;
return PJS_CreateJSVis(aTHX_ cx, proto,
newRV_inc((SV *)get_av(NAMESPACE"PerlArray::prototype",1)));
}
/** In debug mode, this method is used to draw the frame of the fighters.
\param a_pcName The name of the polygon (in the perl namespace)
\param a_iColor The game color to draw the polygon with.
*/
void CGame::DrawPoly( const char* a_pcName, int a_iColor )
{
AV *poList;
int n;
poList = get_av( a_pcName, FALSE );
if ( poList == NULL )
{
return;
}
n = av_len( poList ) + 1;
if ( n< 2 )
{
return;
}
for ( int i=0; i<n; i += 2 )
{
int j = (i+2) % n;
int x1 = SvIV( *av_fetch( poList, i, false) );
int y1 = SvIV( *av_fetch( poList, i+1, false) );
int x2 = SvIV( *av_fetch( poList, j, false) );
int y2 = SvIV( *av_fetch( poList, j+1, false) );
sge_Line( gamescreen, x1, y1 + m_iYOffset, x2, y2 + m_iYOffset, a_iColor ) ;
}
}
void modperl_xs_dl_handles_clear(pTHX)
{
AV *librefs = get_av(dl_librefs, FALSE);
if (librefs) {
av_clear(librefs);
}
}
static void rlm_perl_clear_handles(pTHX)
{
AV *librefs = get_av(dl_librefs, false);
if (librefs) {
av_clear(librefs);
}
}
static int modperl_package_is_dynamic(pTHX_ const char *package,
I32 *dl_index)
{
I32 i;
AV *modules = get_av(dl_modules, FALSE);
for (i=0; i<av_len(modules); i++) {
SV *module = *av_fetch(modules, i, 0);
if (strEQ(package, SvPVX(module))) {
*dl_index = i;
return TRUE;
}
}
return FALSE;
}
START_MY_CXT
#define dl_last_error (SvPVX(MY_CXT.x_dl_last_error))
#define dl_nonlazy (MY_CXT.x_dl_nonlazy)
#ifdef DL_LOADONCEONLY
#define dl_loaded_files (MY_CXT.x_dl_loaded_files)
#endif
#ifdef DL_CXT_EXTRA
#define dl_cxtx (MY_CXT.x_dl_cxtx)
#endif
#ifdef DEBUGGING
#define dl_debug (MY_CXT.x_dl_debug)
#endif
#ifdef DEBUGGING
#define DLDEBUG(level,code) \
STMT_START { \
dMY_CXT; \
if (dl_debug>=level) { code; } \
} STMT_END
#else
#define DLDEBUG(level,code) NOOP
#endif
#ifdef DL_UNLOAD_ALL_AT_EXIT
/* Close all dlopen'd files */
static void
dl_unload_all_files(pTHX_ void *unused)
{
CV *sub;
AV *dl_librefs;
SV *dl_libref;
if ((sub = get_cv("DynaLoader::dl_unload_file", FALSE)) != NULL) {
dl_librefs = get_av("DynaLoader::dl_librefs", FALSE);
while ((dl_libref = av_pop(dl_librefs)) != &PL_sv_undef) {
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(dl_libref));
PUTBACK;
call_sv((SV*)sub, G_DISCARD | G_NODEBUG);
FREETMPS;
LEAVE;
}
}
}
SV *p5_get_global(PerlInterpreter *my_perl, const char* name) {
PERL_SET_CONTEXT(my_perl);
if (strlen(name) < 2)
return NULL;
if (name[0] == '$')
return get_sv(&name[1], 0);
if (name[0] == '@')
return sv_2mortal(newRV_inc((SV *)get_av(&name[1], 0)));
if (name[0] == '%')
return sv_2mortal(newRV_inc((SV *)get_hv(&name[1], 0)));
return NULL;
}
USER_OBJECT_
RS_getAV(USER_OBJECT_ name, USER_OBJECT_ convert, USER_OBJECT_ elFilter, USER_OBJECT_ interpreter)
{
USER_OBJECT_ ans = NULL_USER_OBJECT;
AV *arr;
dTHX;
if(!IS_CHARACTER(name)) {
SV *tmp = getForeignPerlReference(name);
if(tmp != NULL && SvTYPE(tmp) == SVt_RV) {
tmp = SvRV(tmp);
}
if(tmp == NULL || SvTYPE(tmp) != SVt_PVAV) {
PROBLEM "non-array reference passed to RS_getAV"
ERROR;
}
arr = (AV*) tmp;
} else {
arr = get_av(CHAR_DEREF(STRING_ELT(name,0)), FALSE);
}
if(arr != NULL) {
if(TYPEOF(convert) == LGLSXP || TYPEOF(convert) == INTSXP) {
unsigned int depth;
depth = (TYPEOF(convert) == LGLSXP ? LOGICAL(convert)[0] : INTEGER(convert)[0]);
if(depth) {
SV *filter = NULL;
if(GET_LENGTH(elFilter))
filter = getPerlCodeObject(elFilter);
ans = fromPerlAV(arr, filter, depth);
} else {
/* ans = fromPerl((SV*) arr); */
ans = makeForeignPerlReference((SV*) arr, makeRSPerlClassVector("PerlArrayReference"), &exportReferenceTable);
}
} else
ans = directConvertFromPerl((SV *) arr, convert);
}
return(ans);
}
/* Close all dlopen'd files */
static void
dl_unload_all_files(pTHXo_ void *unused)
{
CV *sub;
AV *dl_librefs;
SV *dl_libref;
if ((sub = get_cv("DynaLoader::dl_unload_file", FALSE)) != NULL) {
dl_librefs = get_av("DynaLoader::dl_librefs", FALSE);
while ((dl_libref = av_pop(dl_librefs)) != &PL_sv_undef) {
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(dl_libref));
PUTBACK;
call_sv((SV*)sub, G_DISCARD | G_NODEBUG);
FREETMPS;
LEAVE;
}
}
}
static void
sdi_mux (guint8 * data, GstBuffer * buffer)
{
int j;
int i;
guint8 *dest;
int f, v;
int line;
for (j = 0; j < 525; j++) {
dest = data + 858 * 2 * j;
line = (j + 4) % 525;
if (line < 10 || (line >= 264 && line < 273)) {
v = 1;
} else {
v = 0;
}
if (line >= 266 || line < 4) {
f = 1;
} else {
f = 0;
}
dest[0] = 0xff;
dest[1] = 0;
dest[2] = 0;
dest[3] = get_av (f, v, 1);
for (i = 1; i < (858 - 720) / 2 - 1; i++) {
dest[i * 4 + 0] = 0x200 >> 2;
dest[i * 4 + 1] = 0x040 >> 2;
dest[i * 4 + 2] = 0x200 >> 2;
dest[i * 4 + 3] = 0x040 >> 2;
}
i = (858 - 720) / 2 - 1;
dest[i * 4 + 0] = 0xff;
dest[i * 4 + 1] = 0x00;
dest[i * 4 + 2] = 0x00;
dest[3] = get_av (f, v, 0);
i = (858 - 720) / 2;
if (line >= 23 && line <= 262) {
int src_line = (line - 23) * 2 + 1;
memcpy (dest + i * 4, GST_BUFFER_DATA (buffer) + 720 * 2 * src_line,
720 * 2);
} else if (line >= 285 && line <= 525) {
int src_line = (line - 285) * 2 + 0;
memcpy (dest + i * 4, GST_BUFFER_DATA (buffer) + 720 * 2 * src_line,
720 * 2);
} else {
for (i = (858 - 720) / 2; i < 858 / 2; i++) {
dest[i * 4 + 0] = 0x200 >> 2;
dest[i * 4 + 1] = 0x040 >> 2;
dest[i * 4 + 2] = 0x200 >> 2;
dest[i * 4 + 3] = 0x040 >> 2;
}
}
}
}
bool KviPerlInterpreter::execute(
const QString &szCode,
QStringList &args,
QString &szRetVal,
QString &szError,
QStringList &lWarnings)
{
if(!m_pInterpreter)
{
szError = __tr2qs_ctx("Internal error: perl interpreter not initialized","perl");
return false;
}
g_lWarningList.clear();
QByteArray szUtf8 = szCode.toUtf8();
PERL_SET_CONTEXT(m_pInterpreter);
// clear the _ array
AV * pArgs = get_av("_",1);
SV * pArg = av_shift(pArgs);
while(SvOK(pArg))
{
SvREFCNT_dec(pArg);
pArg = av_shift(pArgs);
}
if(args.count() > 0)
{
// set the args in the _ arry
av_unshift(pArgs,(I32)args.count());
int idx = 0;
for(QStringList::Iterator it = args.begin();it != args.end();++it)
{
QString tmp = *it;
const char * val = tmp.toUtf8().data();
if(val)
{
pArg = newSVpv(val,tmp.length());
if(!av_store(pArgs,idx,pArg))
SvREFCNT_dec(pArg);
}
idx++;
}
}
// call the code
SV * pRet = eval_pv(szUtf8.data(),false);
// clear the _ array again
pArgs = get_av("_",1);
pArg = av_shift(pArgs);
while(SvOK(pArg))
{
SvREFCNT_dec(pArg);
pArg = av_shift(pArgs);
}
av_undef(pArgs);
// get the ret value
if(pRet)
{
if(SvOK(pRet))
szRetVal = svToQString(pRet);
}
if(!g_lWarningList.isEmpty())
lWarnings = g_lWarningList;
// and the eventual error string
pRet = get_sv("@",false);
if(pRet)
{
if(SvOK(pRet))
{
szError = svToQString(pRet);
if(!szError.isEmpty())return false;
}
}
return true;
}
Array::Temp Interpreter::array(const char* name) const {
AV* const ret = get_av(name, true);
SvGETMAGIC(reinterpret_cast<SV*>(ret));
return Array::Temp(raw_interp.get(), ret, false);
}
Array::Temp Package::array(const char* name) const {
AV* const ret = get_av((package_name + "::" + name).c_str(), true);
return Array::Temp(interp, ret, false);
}
// av getters
void *swiftperl_get_av(const char *name, int add) {
return (void *)get_av(name, add ? GV_ADD : 0);
}
CFighterStatsDemo::CFighterStatsDemo( FighterEnum a_iFighter )
{
m_iTimeLeft = 500;
m_poStaff = NULL;
m_poBackground = LoadBackground( "FighterStats.jpg", 64 );
DrawGradientText( "Fighter Stats", titleFont, 10, m_poBackground );
SDL_BlitSurface( m_poBackground, NULL, gamescreen, NULL );
SDL_Flip( gamescreen );
if ( mg_iLastFighter < 0 )
{
// First run; create shuffled array of fighters.
mg_iLastFighter = 0;
int i, j;
FighterEnum k;
for ( i=0; i<LASTFIGHTER-1; ++i )
{
mg_aenFighterOrder[i] = (FighterEnum)(i+1);
}
for ( i=0; i<LASTFIGHTER-1; ++i )
{
j = rand() % (LASTFIGHTER-1);
k = mg_aenFighterOrder[i];
mg_aenFighterOrder[i] = mg_aenFighterOrder[j];
mg_aenFighterOrder[j] = k;
}
}
if ( a_iFighter <= UNKNOWN )
{
mg_iLastFighter = (mg_iLastFighter+1) % (LASTFIGHTER-1);
m_enFighter = mg_aenFighterOrder[mg_iLastFighter];
}
else
{
m_enFighter = a_iFighter;
}
if ( g_oPlayerSelect.IsFighterAvailable( m_enFighter ) )
{
g_oPlayerSelect.SetPlayer( 0, m_enFighter );
g_oBackend.PerlEvalF( "SelectStart(%d);", 2 );
}
else
{
std::string sStaffFilename = DATADIR;
sStaffFilename += "/characters/STAFF.DAT";
m_poStaff = new CRlePack( sStaffFilename.c_str(), 255 );
}
g_oBackend.PerlEvalF("GetFighterStats(%d);", m_enFighter );
_sge_TTFont* font = impactFont;
int y = TOPMARGIN;
AV *StatTags = get_av( "StatTags", FALSE );
char *s, *sTag;
s = SvPV_nolen(get_sv("Name", FALSE));
DrawTextMSZ( s, inkFont, (LEFTMARGIN + RIGHTMARGIN)/2, y, AlignHCenter, C_WHITE, m_poBackground );
y+= 10;
s = SvPV_nolen(get_sv("Team", FALSE ));
sTag = SvPV_nolen( *av_fetch( StatTags, 1, false ) );
int i = DrawTextMSZ( sTag, font, LEFTMARGIN, y+=LINEHEIGHT, 0, C_YELLOW, m_poBackground );
DrawTextMSZ( s, font, LEFTMARGIN+i, y, 0, C_ORANGE, m_poBackground, false );
s = SvPV_nolen(get_sv("Style", FALSE ));
sTag = SvPV_nolen( *av_fetch( StatTags, 2, false ) );
i = DrawTextMSZ( sTag, font, LEFTMARGIN2, y, 0, C_YELLOW, m_poBackground );
DrawTextMSZ( s, font, LEFTMARGIN2+i, y, 0, C_ORANGE, m_poBackground, false );
s = SvPV_nolen(get_sv("Age", FALSE ));
sTag = SvPV_nolen( *av_fetch( StatTags, 3, false ) );
i = DrawTextMSZ( sTag, font, LEFTMARGIN, y+=LINEHEIGHT, 0, C_YELLOW, m_poBackground );
DrawTextMSZ( s, font, LEFTMARGIN+i, y, 0, C_ORANGE, m_poBackground, false );
s = SvPV_nolen(get_sv("Weight", FALSE ));
sTag = SvPV_nolen( *av_fetch( StatTags, 4, false ) );
i = DrawTextMSZ( sTag, font, LEFTMARGIN2, y, 0, C_YELLOW, m_poBackground );
DrawTextMSZ( s, font, LEFTMARGIN2+i, y, 0, C_ORANGE, m_poBackground, false );
s = SvPV_nolen(get_sv("Height", FALSE ));
sTag = SvPV_nolen( *av_fetch( StatTags, 5, false ) );
i = DrawTextMSZ( sTag, font, LEFTMARGIN, y+=LINEHEIGHT, 0, C_YELLOW, m_poBackground );
DrawTextMSZ( s, font, LEFTMARGIN+i, y, 0, C_ORANGE, m_poBackground, false );
s = SvPV_nolen(get_sv("Shoe", FALSE ));
sTag = SvPV_nolen( *av_fetch( StatTags, 6, false ) );
i = DrawTextMSZ( sTag, font, LEFTMARGIN2, y, 0, C_YELLOW, m_poBackground );
DrawTextMSZ( s, font, LEFTMARGIN2+i, y, 0, C_ORANGE, m_poBackground, false );
m_sStory = SvPV_nolen(get_sv("Story", FALSE ));
SDL_Rect oFlyingRect;
oFlyingRect.x = LEFTMARGIN;
oFlyingRect.y = y+DESCMARGIN;
oFlyingRect.w = gamescreen->w - oFlyingRect.x - 20;
oFlyingRect.h = gamescreen->h - oFlyingRect.y - 10;
m_poFlyingChars = new CFlyingChars( creditsFont, oFlyingRect );
m_poFlyingChars->AddText( m_sStory.c_str(), CFlyingChars::FC_AlignJustify, false );
if ( g_oPlayerSelect.IsFighterAvailable( m_enFighter ) )
{
m_sKeys = SvPV_nolen(get_sv("Keys", TRUE ));
m_poFlyingChars->AddText( "\n\nKEYS\n", CFlyingChars::FC_AlignCenter, true );
m_poFlyingChars->AddText( m_sKeys.c_str(), CFlyingChars::FC_AlignCenter, true );
}
else
{
m_sKeys = Translate("Unfortunately this fighter is not yet playable.");
m_poFlyingChars->AddText( m_sKeys.c_str(), CFlyingChars::FC_AlignLeft, true );
}
}
/* caller must free result, if not NULL */
CALLER_OWN char *owl_perlconfig_initperl(const char *file, int *Pargc, char ***Pargv, char ***Penv)
{
int ret;
PerlInterpreter *p;
char *err;
const char *args[4] = {"", "-e", "0;", NULL};
AV *inc;
char *path;
/* create and initialize interpreter */
PERL_SYS_INIT3(Pargc, Pargv, Penv);
p=perl_alloc();
owl_global_set_perlinterp(&g, p);
perl_construct(p);
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
owl_global_set_no_have_config(&g);
ret=perl_parse(p, owl_perl_xs_init, 2, (char **)args, NULL);
if (ret || SvTRUE(ERRSV)) {
err=g_strdup(SvPV_nolen(ERRSV));
sv_setsv(ERRSV, &PL_sv_undef); /* and clear the error */
return(err);
}
ret=perl_run(p);
if (ret || SvTRUE(ERRSV)) {
err=g_strdup(SvPV_nolen(ERRSV));
sv_setsv(ERRSV, &PL_sv_undef); /* and clear the error */
return(err);
}
owl_global_set_have_config(&g);
/* create legacy variables */
get_sv("BarnOwl::id", TRUE);
get_sv("BarnOwl::class", TRUE);
get_sv("BarnOwl::instance", TRUE);
get_sv("BarnOwl::recipient", TRUE);
get_sv("BarnOwl::sender", TRUE);
get_sv("BarnOwl::realm", TRUE);
get_sv("BarnOwl::opcode", TRUE);
get_sv("BarnOwl::zsig", TRUE);
get_sv("BarnOwl::msg", TRUE);
get_sv("BarnOwl::time", TRUE);
get_sv("BarnOwl::host", TRUE);
get_av("BarnOwl::fields", TRUE);
if(file) {
SV * cfg = get_sv("BarnOwl::configfile", TRUE);
sv_setpv(cfg, file);
}
sv_setpv(get_sv("BarnOwl::VERSION", TRUE), OWL_VERSION_STRING);
/* Add the system lib path to @INC */
inc = get_av("INC", 0);
path = g_build_filename(owl_get_datadir(), "lib", NULL);
av_unshift(inc, 1);
av_store(inc, 0, owl_new_sv(path));
g_free(path);
eval_pv("use BarnOwl;", FALSE);
if (SvTRUE(ERRSV)) {
err=g_strdup(SvPV_nolen(ERRSV));
sv_setsv (ERRSV, &PL_sv_undef); /* and clear the error */
return(err);
}
/* check if we have the formatting function */
if (owl_perlconfig_is_function("BarnOwl::format_msg")) {
owl_global_set_config_format(&g, 1);
}
return(NULL);
}
SV * parse_in_chunks(char * filepath, size_t filesize) {
char *buf;
size_t bytes_read = 0;
int max_buf = 1000;
char *err_msg;
int block = BLOCK_HEADER;
int cur_event_type = 0;
int event_type = 0;
char event_block = 0;
char *brnl, *breq;
AV * data;
AV * datawrapper;
AV * events;
char *line;
char * nl = "\n";
char * eq = "=";
int rewind_pos = 0;
size_t cur_fpos = 0;
SV * pbuf;
SV * pmax_buf;
AV * HANDLERS = get_av("Opsview::Utils::NDOLogsImporter::HANDLERS", 0);
AV * INPUT_DATA_TYPE = get_av("Opsview::Utils::NDOLogsImporter::INPUT_DATA_TYPE", 0);
int init_last_pos;
int init_block;
if ( first_read ) {
if ( ! ( fh = PerlIO_open( filepath, "rb" ) ) ) {
croak("Could not open file: %s\n", strerror(errno));
}
bytes_left = filesize;
init_last_pos = prev_pos = first_read = 0;
init_block = block = BLOCK_HEADER;
} else {
init_block = block = BLOCK_EVENTS;
init_last_pos = prev_pos;
}
read_begin:
brnl = NULL;
breq = NULL;
pbuf = get_sv("Opsview::Utils::NDOLogsImporter::PARSE_BUF", 0);
pmax_buf = get_sv("Opsview::Utils::NDOLogsImporter::MAX_BUF_SIZE", 0);
buf = SvPVX(pbuf);
max_buf = SvIVX(pmax_buf);
if ( max_buf < 1024 * 1024 && ! automated_tests ) {
max_buf = 1024*1024;
SvIV_set( pmax_buf, max_buf );
SvGROW( pbuf, max_buf + 1);
SvCUR_set( pbuf, max_buf);
}
if ( bytes_left > 0 ) {
bytes_read = PerlIO_read(fh, buf + prev_pos, max_buf-prev_pos);
cur_fpos = PerlIO_tell(fh);
if ( bytes_read < 0 ) {
err_msg = strerror(errno);
PerlIO_close( fh );
croak("Could not read file: %s\n", err_msg);
}
bytes_left -= bytes_read;
events = (AV *)sv_2mortal((SV *)newAV());
rewind_pos = last_999(buf+prev_pos, bytes_read);
prev_pos = bytes_read + prev_pos - rewind_pos;
buf[prev_pos] = '\0';
// avg ratio events:file_size = 0.21%
if ( prev_pos > 1000 ) {
av_extend( events, (int)(prev_pos * 0.0021) );
}
for ( line = strtok_r(buf, nl, &brnl); line != NULL; line = strtok_r(NULL, nl, &brnl) )
{
switch(block) {
case BLOCK_HEADER:
{
if ( strEQ(line, "STARTDATADUMP") ) {
block = BLOCK_EVENTS;
}
}
break;
case BLOCK_EVENTS:
{
if ( strEQ(line, "1000") ) { /* NDO_API_ENDDATADUMP */
block = BLOCK_FOOTER;
continue;
}
cur_event_type = atoi(line);
/* ignore events we are not handling */
if ( ! av_exists(HANDLERS, cur_event_type) ) {
block = BLOCK_IGNORE_EVENT;
continue;
}
event_block = BLOCK_EVENT_STARTED;
if ( cur_event_type != event_type ) {
datawrapper = (AV *)sv_2mortal((SV *)newAV());
data = (AV *)sv_2mortal((SV *)newAV());
av_push( events, newSViv( cur_event_type ) );
av_push( datawrapper, newRV( (SV *)data ) );
av_push( events, newRV( (SV *)datawrapper ) );
event_type = cur_event_type;
} else {
data = (AV *)sv_2mortal((SV *)newAV());
av_push( datawrapper, newRV( (SV *)data ) );
}
block = BLOCK_EVENT;
}
break;
case BLOCK_EVENT:
{
if ( strEQ(line, "999") ) { /* NDO_API_ENDDATA */
block = BLOCK_EVENTS;
event_block = BLOCK_EVENT_ENDED;
} else {
char *k;
char *v;
int key;
int key_type = 0;
int v_len = 0;
k = strtok_r(line, eq, &breq);
v = strtok_r(NULL, "\0", &breq);
key = atoi(k);
/* invalid key, skip parsing */
if ( key == 0 ) {
goto remove_invalid;
}
SV ** const k_type = av_fetch(INPUT_DATA_TYPE, key, 0 );
if ( k_type ) {
key_type = SvIVx( *k_type );
}
if ( v ) {
if ( key_type & 1 ) {
v_len = ndo_unescape_buffer( v );
} else {
v_len = strlen(v);
}
}
if ( key_type & 2 ) {
AV * datanstptr;
SV ** const datanst = av_fetch(data, key, 0 );
if ( datanst ) {
datanstptr = (AV *)SvRV( *datanst );
} else {
datanstptr = (AV *)sv_2mortal((SV *)newAV());
av_store( data, key, newRV( (SV *)datanstptr ) );
}
if ( v ) {
av_push( datanstptr, newSVpvn(v, v_len) );
} else {
av_push( datanstptr, newSVpvn("", 0) );
}
} else {
if ( v ) {
av_store( data, key, newSVpvn(v, v_len) );
} else {
av_store( data, key, newSVpvn("", 0) );
}
}
}
}
break;
case BLOCK_FOOTER:
{
if ( strEQ(line, "GOODBYE") ) {
block = BLOCK_HEADER;
}
}
break;
case BLOCK_IGNORE_EVENT:
{
if ( strEQ(line, "999") ) { /* NDO_API_ENDDATA */
block = BLOCK_EVENTS; // go back to EVENTS
continue;
}
}
break;
}
};
/* there were some events */
if ( event_block != BLOCK_HEADER ) {
if ( event_block != BLOCK_EVENT_ENDED ) {
remove_invalid:
av_pop( datawrapper );
}
/* remove whole block if the last block has no events */
if ( av_len( datawrapper ) == -1 ) {
av_pop( events );
av_pop( events );
}
}
if ( av_len(events) > 0 ) {
if ( rewind_pos > 0 && cur_fpos < filesize ) {
memmove(buf, buf+prev_pos+1, rewind_pos-1);
}
prev_pos = rewind_pos - 1;
return newRV_inc((SV *) events);
} else {
if ( cur_fpos < filesize && event_block != BLOCK_HEADER && event_block != BLOCK_EVENT_ENDED ) {
int new_max_buf = max_buf * 2;
SvIV_set( pmax_buf, new_max_buf );
SvGROW( pbuf, new_max_buf + 1);
SvCUR_set( pbuf, new_max_buf);
//start again as previous buffer would be tokenized already
prev_pos = 0;
block = init_block;
event_type = 0;
PerlIO_close( fh );
if ( ! ( fh = PerlIO_open( filepath, "rb" ) ) ) {
croak("Could not re-open file: %s\n", strerror(errno));
}
PerlIO_seek(fh, cur_fpos-bytes_read-init_last_pos, SEEK_SET);
bytes_left += bytes_read + init_last_pos;
goto read_begin;
}
}
}
parser_reset_iterator();
return &PL_sv_undef;
}
void
plcb_define_constants(void)
{
HV *priv_stash = gv_stashpv(PLCB_PRIV_CONSTANTS_PKG, GV_ADD);
HV *pub_stash = gv_stashpv(PLCB_PUB_CONSTANTS_PKG, GV_ADD);
AV *our_public = get_av(PLCB_PUB_CONSTANTS_PKG "::EXPORT", GV_ADD);
AV *our_private = get_av(PLCB_PRIV_CONSTANTS_PKG "::EXPORT", GV_ADD);
HV *async_stash = gv_stashpv(PLCB_IOPROCS_CONSTANTS_CLASS, GV_ADD);
AV *our_async = get_av(PLCB_IOPROCS_CONSTANTS_CLASS "::EXPORT", GV_ADD);
#define ADD_PUBLIC(n, v) \
newCONSTSUB(pub_stash, n, newSViv(v)); \
av_push(our_public, newSVpvs(n));
#define ADD_PRIVATE(n, v) \
newCONSTSUB(priv_stash, n, newSViv(v)); \
av_push(our_private, newSVpvs(n));
#define DEF_ASYNC(n) \
newCONSTSUB(async_stash, "COUCHBASE_"#n, newSViv(PLCB_##n)); \
av_push(our_async, newSVpvs("COUCHBASE_"#n));
#define DEF_PRIV(nbase) ADD_PRIVATE(#nbase, PLCB_##nbase)
#define ADD_PUB_LCB(n) ADD_PUBLIC("COUCHBASE_" #n, LCB_##n)
#define ADD_PRIV_LCB(n) ADD_PRIVATE(#n, n)
DEF_PRIV(RETIDX_VALUE);
DEF_PRIV(RETIDX_ERRNUM);
DEF_PRIV(RETIDX_KEY);
DEF_PRIV(RETIDX_FMTSPEC);
DEF_PRIV(RETIDX_CAS);
DEF_PRIV(RETIDX_EXP);
DEF_PRIV(VHIDX_PATH);
DEF_PRIV(VHIDX_PARENT);
DEF_PRIV(VHIDX_PLPRIV);
DEF_PRIV(VHIDX_ROWBUF);
DEF_PRIV(VHIDX_PRIVCB);
DEF_PRIV(VHIDX_META);
DEF_PRIV(VHIDX_RC);
DEF_PRIV(VHIDX_HTCODE);
DEF_PRIV(VHIDX_ISDONE);
DEF_PRIV(HTIDX_HEADERS);
DEF_PRIV(HTIDX_STATUS);
/* View query options */
ADD_PRIV_LCB(LCB_CMDVIEWQUERY_F_NOROWPARSE);
ADD_PRIV_LCB(LCB_CMDVIEWQUERY_F_INCLUDE_DOCS);
ADD_PRIV_LCB(LCB_CMDVIEWQUERY_F_SPATIAL);
ADD_PRIV_LCB(LCB_N1P_QUERY_STATEMENT);
ADD_PRIV_LCB(LCB_N1P_QUERY_PREPARED);
ADD_PRIV_LCB(LCB_HTTP_METHOD_GET);
ADD_PRIV_LCB(LCB_HTTP_METHOD_POST);
ADD_PRIV_LCB(LCB_HTTP_METHOD_PUT);
ADD_PRIV_LCB(LCB_HTTP_METHOD_DELETE);
ADD_PRIV_LCB(LCB_HTTP_TYPE_VIEW);
ADD_PRIV_LCB(LCB_HTTP_TYPE_MANAGEMENT);
ADD_PRIV_LCB(LCB_HTTP_TYPE_RAW);
DEF_PRIV(CONVERTERS_JSON);
DEF_PRIV(CONVERTERS_CUSTOM);
DEF_PRIV(CONVERTERS_STORABLE);
DEF_PRIV(SETTING_INT);
DEF_PRIV(SETTING_UINT);
DEF_PRIV(SETTING_U32);
DEF_PRIV(SETTING_SIZE);
DEF_PRIV(SETTING_TIMEOUT);
DEF_PRIV(SETTING_STRING);
DEF_PRIV(OPCTXIDX_REMAINING);
DEF_PRIV(OPCTXIDX_FLAGS);
DEF_PRIV(OPCTXIDX_QUEUE);
DEF_PRIV(OPCTXIDX_CBO);
DEF_PRIV(OPCTXf_IMPLICIT);
DEF_PRIV(OPCTXf_WAITONE);
ADD_PRIVATE("SVCTYPE_MGMT", LCBVB_SVCTYPE_MGMT);
ADD_PRIVATE("SVCTYPE_DATA", LCBVB_SVCTYPE_DATA);
ADD_PRIVATE("SVCTYPE_VIEWS", LCBVB_SVCTYPE_VIEWS);
ADD_PRIVATE("SVCMODE_SSL", LCBVB_SVCMODE_SSL);
ADD_PRIVATE("SVCMODE_PLAIN", LCBVB_SVCMODE_PLAIN);
/* Public constants */
ADD_PUBLIC("COUCHBASE_FMT_JSON", PLCB_CF_JSON);
ADD_PUBLIC("COUCHBASE_FMT_BYTES", PLCB_CF_RAW);
ADD_PUBLIC("COUCHBASE_FMT_RAW", PLCB_CF_RAW);
ADD_PUBLIC("COUCHBASE_FMT_UTF8", PLCB_CF_UTF8);
ADD_PUBLIC("COUCHBASE_FMT_STORABLE", PLCB_CF_STORABLE);
/* Error Codes */
ADD_PUB_LCB(SUCCESS);
ADD_PUB_LCB(AUTH_ERROR);
ADD_PUB_LCB(DELTA_BADVAL);
ADD_PUB_LCB(E2BIG);
ADD_PUB_LCB(EINVAL);
ADD_PUB_LCB(ENOMEM);
ADD_PUB_LCB(CLIENT_ENOMEM);
ADD_PUB_LCB(ETMPFAIL);
ADD_PUB_LCB(CLIENT_ETMPFAIL);
ADD_PUB_LCB(KEY_EEXISTS);
ADD_PUB_LCB(KEY_ENOENT);
ADD_PUB_LCB(BUCKET_ENOENT);
ADD_PUB_LCB(NOT_STORED);
ADD_PUB_LCB(NETWORK_ERROR);
ADD_PUB_LCB(ETIMEDOUT);
ADD_PUB_LCB(CONNECT_ERROR);
DEF_ASYNC(EVIDX_FD);
DEF_ASYNC(EVIDX_DUPFH);
DEF_ASYNC(EVIDX_WATCHFLAGS);
DEF_ASYNC(EVIDX_PLDATA);
DEF_ASYNC(EVIDX_TYPE);
DEF_ASYNC(EVIDX_OPAQUE);
DEF_ASYNC(EVIDX_MAX);
DEF_ASYNC(EVACTION_WATCH);
DEF_ASYNC(EVACTION_UNWATCH);
DEF_ASYNC(EVACTION_INIT);
DEF_ASYNC(EVACTION_CLEANUP);
DEF_ASYNC(EVTYPE_IO);
DEF_ASYNC(EVTYPE_TIMER);
DEF_ASYNC(READ_EVENT);
DEF_ASYNC(WRITE_EVENT);
}
