PJS_EXTERN JSBool
PJS_Call_js_function(
pTHX_
JSContext *cx,
JSObject *gobj,
jsval func,
AV *av,
jsval *rval
) {
jsval *arg_list;
SV *val;
int arg_count, i;
JSBool res;
arg_count = av_len(av);
Newz(1, arg_list, arg_count + 1, jsval);
if(!arg_list) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
for(i = 0; i <= arg_count; i++) {
val = *av_fetch(av, i, 0);
if (!PJS_ReflectPerl2JS(aTHX_ cx, gobj, val, &(arg_list[i]))) {
Safefree(arg_list);
croak("Can't convert argument number %d to jsval", i);
}
}
res = JS_CallFunctionValue(cx, gobj, func, i, arg_list, rval);
Safefree(arg_list);
return res;
}
FILE *
my_fdopen(int fd, char *mode)
{
FILE *fp;
char sockbuf[256];
int optlen = sizeof(sockbuf);
int retval;
if (!wsock_started)
return(fdopen(fd, mode));
retval = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
if(retval == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK) {
return(fdopen(fd, mode));
}
/*
* If we get here, then fd is actually a socket.
*/
Newz(1310, fp, 1, FILE); /* XXX leak, good thing this code isn't used */
if(fp == NULL) {
errno = ENOMEM;
return NULL;
}
fp->_file = fd;
if(*mode == 'r')
fp->_flag = _IOREAD;
else
fp->_flag = _IOWRT;
return fp;
}
/*
Create PJS_Context structure
*/
PJS_Context * PJS_CreateContext(PJS_Runtime *rt) {
PJS_Context *pcx;
JSObject *obj;
Newz(1, pcx, 1, PJS_Context);
if (pcx == NULL) {
croak("Failed to allocate memory for PJS_Context");
}
/*
The 'stack size' param here isn't actually the stack size, it's
the "chunk size of the stack pool--an obscure memory management
tuning knob"
http://groups.google.com/group/mozilla.dev.tech.js-engine/browse_thread/thread/be9f404b623acf39
*/
pcx->cx = JS_NewContext(rt->rt, 8192);
if(pcx->cx == NULL) {
Safefree(pcx);
croak("Failed to create JSContext");
}
JS_SetOptions(pcx->cx, JSOPTION_DONT_REPORT_UNCAUGHT);
obj = JS_NewObject(pcx->cx, &global_class, NULL, NULL);
if (JS_InitStandardClasses(pcx->cx, obj) == JS_FALSE) {
PJS_DestroyContext(pcx);
croak("Standard classes not loaded properly.");
}
pcx->function_by_name = newHV();
pcx->class_by_name = newHV();
pcx->class_by_package = newHV();
if (PJS_InitPerlArrayClass(pcx, obj) == JS_FALSE) {
PJS_DestroyContext(pcx);
croak("Perl classes not loaded properly.");
}
if (PJS_InitPerlHashClass(pcx, obj) == JS_FALSE) {
PJS_DestroyContext(pcx);
croak("Perl classes not loaded properly.");
}
if (PJS_InitPerlSubClass(pcx, obj) == JS_FALSE) {
PJS_DestroyContext(pcx);
croak("Perl class 'PerlSub' not loaded properly.");
}
pcx->rt = rt;
/* Add context to context list */
pcx->next = rt->list;
rt->list = pcx;
JS_SetContextPrivate(pcx->cx, (void *) pcx);
return pcx;
}
STATIC void
S_debprof(pTHX_ OP *o)
{
#ifdef DEBUGGING
if (!PL_profiledata)
Newz(000, PL_profiledata, MAXO, U32);
++PL_profiledata[o->op_type];
#endif /* DEBUGGING */
}
void
Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi)
{
register GP *gp;
bool doproto = SvTYPE(gv) > SVt_NULL;
char *proto = (doproto && SvPOK(gv)) ? SvPVX(gv) : NULL;
sv_upgrade((SV*)gv, SVt_PVGV);
if (SvLEN(gv)) {
if (proto) {
SvPVX(gv) = NULL;
SvLEN(gv) = 0;
SvPOK_off(gv);
} else
Safefree(SvPVX(gv));
}
Newz(602, gp, 1, GP);
GvGP(gv) = gp_ref(gp);
GvSV(gv) = NEWSV(72,0);
GvLINE(gv) = CopLINE(PL_curcop);
GvFILE(gv) = CopFILE(PL_curcop) ? CopFILE(PL_curcop) : "";
GvCVGEN(gv) = 0;
GvEGV(gv) = gv;
sv_magic((SV*)gv, (SV*)gv, '*', Nullch, 0);
GvSTASH(gv) = (HV*)SvREFCNT_inc(stash);
GvNAME(gv) = savepvn(name, len);
GvNAMELEN(gv) = len;
if (multi || doproto) /* doproto means it _was_ mentioned */
GvMULTI_on(gv);
if (doproto) { /* Replicate part of newSUB here. */
SvIOK_off(gv);
ENTER;
/* XXX unsafe for threads if eval_owner isn't held */
start_subparse(0,0); /* Create CV in compcv. */
GvCV(gv) = PL_compcv;
LEAVE;
PL_sub_generation++;
CvGV(GvCV(gv)) = gv;
CvFILE(GvCV(gv)) = CopFILE(PL_curcop);
CvSTASH(GvCV(gv)) = PL_curstash;
#ifdef USE_THREADS
CvOWNER(GvCV(gv)) = 0;
if (!CvMUTEXP(GvCV(gv))) {
New(666, CvMUTEXP(GvCV(gv)), 1, perl_mutex);
MUTEX_INIT(CvMUTEXP(GvCV(gv)));
}
#endif /* USE_THREADS */
if (proto) {
sv_setpv((SV*)GvCV(gv), proto);
Safefree(proto);
}
}
}
/*============================================================================
mainRoutine:
Function: Generates the polynomials, initialises and calls the sieve,
implementing cache blocking (breaking the sieve interval into
small blocks for the small primes.
============================================================================*/
static int mainRoutine(
unsigned long numPrimes,
unsigned long Mdiv2,
unsigned long relSought,
mpz_t n,
mpz_t* farray,
unsigned long multiplier)
{
mpz_t A, B, C, D, Bdivp2, q, r, nsqrtdiv, temp, temp2, temp3, temp4;
int i, j, l, s, fact, span, min, nfactors, verbose;
unsigned long u1, p, reps, numRelations, M;
unsigned long curves = 0;
unsigned long npartials = 0;
unsigned long relsFound = 0;
unsigned long * relations;
unsigned short * primecount;
unsigned char * sieve;
int * exponents;
unsigned long * aind;
unsigned long * amodp;
unsigned long * Ainv;
unsigned long * soln1;
unsigned long * soln2;
unsigned char * flags;
unsigned long ** Ainv2B;
unsigned char ** offsets;
unsigned char ** offsets2;
mpz_t * XArr;
mpz_t * Bterms;
mpz_t * sqrts;
matrix_t m;
verbose = get_verbose_level();
s = mpz_sizeinbase(n,2)/28+1;
New( 0, exponents, firstprime, int );
Newz( 0, aind, s, unsigned long );
Newz( 0, amodp, s, unsigned long );
Newz( 0, Ainv, numPrimes, unsigned long );
Newz( 0, soln1, numPrimes, unsigned long );
Newz( 0, soln2, numPrimes, unsigned long );
Newz( 0, Ainv2B, s, unsigned long*);
Newz( 0, XArr, relSought, mpz_t );
New( 0, Bterms, s, mpz_t );
if (exponents == 0 || aind == 0 || amodp == 0 || Ainv == 0 ||
soln1 == 0 || soln2 == 0 || Ainv2B == 0 || Bterms == 0 ||
XArr == 0)
croak("SIMPQS: Unable to allocate memory!\n");
flags = 0;
if (secondprime < numPrimes) {
New(0, flags, numPrimes, unsigned char);
if (flags == 0) croak("SIMPQS: Unable to allocate memory!\n");
}
PerlFMM*
PerlFMM_create(SV *class_sv) {
PerlFMM *state;
PERL_UNUSED_VAR(class_sv);
Newz(1234, state, 1, PerlFMM);
state->magic = NULL;
state->error = NULL;
state->ext = st_init_strtable();
return state;
}
static int test_anr(UV a, UV n, UV r)
{
UV* pn;
UV* res;
UV i;
int retval = 1;
Newz(0, pn, r, UV);
if (pn == 0)
croak("Couldn't allocate space for polynomial of degree %lu\n", (unsigned long) r);
a %= r;
pn[0] = a;
pn[1] = 1;
res = poly_mod_pow(pn, n, r, n);
res[n % r] = addmod(res[n % r], n - 1, n);
res[0] = addmod(res[0], n - a, n);
for (i = 0; i < r; i++)
if (res[i] != 0)
retval = 0;
Safefree(res);
Safefree(pn);
return retval;
}
static UV* poly_mod_pow(UV* pn, UV power, UV r, UV mod)
{
UV* res;
UV* temp;
int use_sqr = (mod > sqrt(UV_MAX/r)) ? 0 : 1;
Newz(0, res, r, UV);
New(0, temp, r, UV);
if ( (res == 0) || (temp == 0) )
croak("Couldn't allocate space for polynomial of degree %lu\n", (unsigned long) r);
res[0] = 1;
while (power) {
if (power & 1) poly_mod_mul(res, pn, temp, r, mod);
power >>= 1;
if (power) {
if (use_sqr) poly_mod_sqr(pn, temp, r, mod);
else poly_mod_mul(pn, pn, temp, r, mod);
}
}
Safefree(temp);
return res;
}
void PJS_bind_class(PJS_Context *pcx, char *name, char *pkg, SV *cons, HV *fs, HV *static_fs, HV *ps, HV *static_ps, U32 flags) {
PJS_Class *pcls;
if (pcx == NULL) {
croak("Can't bind_class in an undefined context");
}
Newz(1, pcls, 1, PJS_Class);
if (pcls == NULL) {
croak("Failed to allocate memory for PJS_Class");
}
/* Add "package" */
Newz(1, pcls->pkg, strlen(pkg) + 1, char);
if (pcls->pkg == NULL) {
PJS_free_class(pcls);
croak("Failed to allocate memory for pkg");
}
Copy(pkg, pcls->pkg, strlen(pkg), char);
/* Create JSClass "clasp" */
Newz(1, pcls->clasp, 1, JSClass);
Zero(pcls->clasp, 1, JSClass);
if (pcls->clasp == NULL) {
PJS_free_class(pcls);
croak("Failed to allocate memory for JSClass");
}
Newz(1, pcls->clasp->name, strlen(name) + 1, char);
if (pcls->clasp->name == NULL) {
PJS_free_class(pcls);
croak("Failed to allocate memory for name in JSClass");
}
Copy(name, pcls->clasp->name, strlen(name), char);
pcls->methods = NULL;
pcls->properties = NULL;
pcls->clasp->flags = JSCLASS_HAS_PRIVATE;
pcls->clasp->addProperty = JS_PropertyStub;
pcls->clasp->delProperty = JS_PropertyStub;
pcls->clasp->getProperty = PJS_invoke_perl_property_getter;
pcls->clasp->setProperty = PJS_invoke_perl_property_setter;
pcls->clasp->enumerate = JS_EnumerateStub;
pcls->clasp->resolve = JS_ResolveStub;
pcls->clasp->convert = JS_ConvertStub;
pcls->clasp->finalize = PJS_finalize;
pcls->clasp->getObjectOps = NULL;
pcls->clasp->checkAccess = NULL;
pcls->clasp->call = NULL;
pcls->clasp->construct = NULL;
pcls->clasp->hasInstance = NULL;
pcls->next_property_id = 0;
/* Per-object functions and properties */
pcls->fs = PJS_add_class_functions(pcls, fs, PJS_INSTANCE_METHOD);
pcls->ps = PJS_add_class_properties(pcls, ps, PJS_INSTANCE_METHOD);
/* Class functions and properties */
pcls->static_fs = PJS_add_class_functions(pcls, static_fs, PJS_CLASS_METHOD);
pcls->static_ps = PJS_add_class_properties(pcls, static_ps, PJS_CLASS_METHOD);
/* Initialize class */
pcls->proto = JS_InitClass(PJS_GetJSContext(pcx), JS_GetGlobalObject(PJS_GetJSContext(pcx)),
NULL, pcls->clasp,
PJS_construct_perl_object, 0,
pcls->ps /* ps */, pcls->fs,
pcls->static_ps /* static_ps */, pcls->static_fs /* static_fs */);
if (pcls->proto == NULL) {
PJS_free_class(pcls);
croak("Failed to initialize class in context");
}
/* refcount constructor */
pcls->cons = SvREFCNT_inc(cons);
pcls->flags |= PJS_FREE_JSCLASS;
PJS_store_class(pcx, pcls);
}
JSFunctionSpec *PJS_add_class_functions(PJS_Class *pcls, HV *fs, U8 flags) {
JSFunctionSpec *fs_list, *current_fs;
PJS_Function *pfunc;
HE *entry;
char *name;
I32 len;
SV *callback;
I32 number_of_keys = hv_iterinit(fs);
Newz(1, fs_list, number_of_keys + 1, JSFunctionSpec);
current_fs = fs_list;
while((entry = hv_iternext(fs)) != NULL) {
name = hv_iterkey(entry, &len);
callback = hv_iterval(fs, entry);
len = strlen(name);
Newz(1, pfunc, 1, PJS_Function);
if (pfunc == NULL) {
/* We might need to free more memory stuff here */
croak("Failed to allocate memory for PJS_Function");
}
/* Name of function */
Newz(1, pfunc->name, len + 1, char);
if (pfunc->name == NULL) {
Safefree(pfunc);
croak("Failed to allocate memory for PJS_Function name");
}
Copy(name, pfunc->name, len, char);
/* Setup JSFunctionSpec */
Newz(1, current_fs->name, len + 1, char);
if (current_fs->name == NULL) {
Safefree(pfunc->name);
Safefree(pfunc);
croak("Failed to allocate memory for JSFunctionSpec name");
}
Copy(name, current_fs->name, len, char);
current_fs->call = PJS_invoke_perl_object_method;
current_fs->nargs = 0;
current_fs->flags = 0;
current_fs->extra = 0;
pfunc->callback = SvREFCNT_inc(callback);
/* Add entry to linked list */
pfunc->_next = pcls->methods;
pcls->methods = pfunc;
/* Get next function */
current_fs++;
}
current_fs->name = 0;
current_fs->call = 0;
current_fs->nargs = 0;
current_fs->flags = 0;
current_fs->extra = 0;
return fs_list;
}
JSPropertySpec *PJS_add_class_properties(PJS_Class *pcls, HV *ps, U8 flags) {
JSPropertySpec *ps_list, *current_ps;
PJS_Property *pprop;
HE *entry;
char *name;
I32 len;
AV *callbacks;
SV **getter, **setter;
I32 number_of_keys = hv_iterinit(ps);
Newz(1, ps_list, number_of_keys + 1, JSPropertySpec);
current_ps = ps_list;
while((entry = hv_iternext(ps)) != NULL) {
name = hv_iterkey(entry, &len);
callbacks = (AV *) SvRV(hv_iterval(ps, entry));
len = strlen(name);
Newz(1, pprop, 1, PJS_Property);
if (pprop == NULL) {
/* We might need to free more memory stuff here */
croak("Failed to allocate memory for PJS_Property");
}
/* Setup JSFunctionSpec */
Newz(1, current_ps->name, len + 1, char);
if (current_ps->name == NULL) {
Safefree(pprop);
croak("Failed to allocate memory for JSPropertySpec name");
}
Copy(name, current_ps->name, len, char);
getter = av_fetch(callbacks, 0, 0);
setter = av_fetch(callbacks, 1, 0);
pprop->getter = getter != NULL && SvTRUE(*getter) ? SvREFCNT_inc(*getter) : NULL;
pprop->setter = setter != NULL && SvTRUE(*setter) ? SvREFCNT_inc(*setter) : NULL;
current_ps->getter = PJS_invoke_perl_property_getter;
current_ps->setter = PJS_invoke_perl_property_setter;
current_ps->tinyid = pcls->next_property_id++;
current_ps->flags = JSPROP_ENUMERATE;
if (setter == NULL) {
current_ps->flags |= JSPROP_READONLY;
}
pprop->tinyid = current_ps->tinyid;
pprop->_next = pcls->properties;
pcls->properties = pprop;
current_ps++;
}
current_ps->name = 0;
current_ps->tinyid = 0;
current_ps->flags = 0;
current_ps->getter = 0;
current_ps->setter = 0;
return ps_list;
}
int
image_init(HV *self, image *im)
{
unsigned char *bptr;
char *file = NULL;
int ret = 1;
if (my_hv_exists(self, "file")) {
// Input from file
SV *path = *(my_hv_fetch(self, "file"));
file = SvPVX(path);
im->fh = IoIFP(sv_2io(*(my_hv_fetch(self, "_fh"))));
im->path = newSVsv(path);
}
else {
// Input from scalar ref
im->fh = NULL;
im->path = newSVpv("(data)", 0);
im->sv_data = *(my_hv_fetch(self, "data"));
if (SvROK(im->sv_data))
im->sv_data = SvRV(im->sv_data);
else
croak("data is not a scalar ref\n");
}
im->pixbuf = NULL;
im->outbuf = NULL;
im->outbuf_size = 0;
im->type = UNKNOWN;
im->sv_offset = 0;
im->image_offset = 0;
im->image_length = 0;
im->width = 0;
im->height = 0;
im->width_padding = 0;
im->width_inner = 0;
im->height_padding = 0;
im->height_inner = 0;
im->flipped = 0;
im->bpp = 0;
im->channels = 0;
im->has_alpha = 0;
im->orientation = ORIENTATION_NORMAL;
im->orientation_orig = ORIENTATION_NORMAL;
im->memory_limit = 0;
im->target_width = 0;
im->target_height = 0;
im->keep_aspect = 0;
im->resize_type = IMAGE_SCALE_TYPE_GD_FIXED;
im->filter = 0;
im->bgcolor = 0;
im->used = 0;
im->palette = NULL;
#ifdef HAVE_JPEG
im->cinfo = NULL;
#endif
#ifdef HAVE_PNG
im->png_ptr = NULL;
im->info_ptr = NULL;
#endif
#ifdef HAVE_GIF
im->gif = NULL;
#endif
// Read new() options
if (my_hv_exists(self, "offset")) {
im->image_offset = SvIV(*(my_hv_fetch(self, "offset")));
if (im->fh != NULL)
PerlIO_seek(im->fh, im->image_offset, SEEK_SET);
}
if (my_hv_exists(self, "length"))
im->image_length = SvIV(*(my_hv_fetch(self, "length")));
Newz(0, im->buf, sizeof(Buffer), Buffer);
buffer_init(im->buf, BUFFER_SIZE);
im->memory_used = BUFFER_SIZE;
// Determine type of file from magic bytes
if (im->fh != NULL) {
if ( !_check_buf(im->fh, im->buf, 8, BUFFER_SIZE) ) {
image_finish(im);
croak("Unable to read image header for %s\n", file);
}
}
else {
im->sv_offset = MIN(sv_len(im->sv_data) - im->image_offset, BUFFER_SIZE);
buffer_append(im->buf, SvPVX(im->sv_data) + im->image_offset, im->sv_offset);
}
bptr = buffer_ptr(im->buf);
switch (bptr[0]) {
case 0xff:
if (bptr[1] == 0xd8 && bptr[2] == 0xff) {
#ifdef HAVE_JPEG
im->type = JPEG;
#else
image_finish(im);
croak("Image::Scale was not built with JPEG support\n");
#endif
}
break;
case 0x89:
if (bptr[1] == 'P' && bptr[2] == 'N' && bptr[3] == 'G'
&& bptr[4] == 0x0d && bptr[5] == 0x0a && bptr[6] == 0x1a && bptr[7] == 0x0a) {
#ifdef HAVE_PNG
im->type = PNG;
#else
image_finish(im);
croak("Image::Scale was not built with PNG support\n");
#endif
}
break;
case 'G':
if (bptr[1] == 'I' && bptr[2] == 'F' && bptr[3] == '8'
&& (bptr[4] == '7' || bptr[4] == '9') && bptr[5] == 'a') {
#ifdef HAVE_GIF
im->type = GIF;
#else
image_finish(im);
croak("Image::Scale was not built with GIF support\n");
#endif
}
break;
case 'B':
if (bptr[1] == 'M') {
im->type = BMP;
}
break;
}
DEBUG_TRACE("Image type: %d\n", im->type);
// Read image header via type-specific function to determine dimensions
switch (im->type) {
#ifdef HAVE_JPEG
case JPEG:
if ( !image_jpeg_read_header(im) ) {
ret = 0;
goto out;
}
break;
#endif
#ifdef HAVE_PNG
case PNG:
if ( !image_png_read_header(im) ) {
ret = 0;
goto out;
}
break;
#endif
#ifdef HAVE_GIF
case GIF:
if ( !image_gif_read_header(im) ) {
ret = 0;
goto out;
}
break;
#endif
case BMP:
image_bmp_read_header(im);
break;
case UNKNOWN:
warn("Image::Scale unknown file type (%s), first 8 bytes were: %02x %02x %02x %02x %02x %02x %02x %02x\n",
SvPVX(im->path), bptr[0], bptr[1], bptr[2], bptr[3], bptr[4], bptr[5], bptr[6], bptr[7]);
ret = 0;
break;
}
DEBUG_TRACE("Image dimenensions: %d x %d, channels %d\n", im->width, im->height, im->channels);
out:
if (ret == 0)
image_finish(im);
return ret;
}
wvpinfo *
_wavpack_parse(PerlIO *infile, char *file, HV *info, uint8_t seeking)
{
int err = 0;
int done = 0;
u_char *bptr;
wvpinfo *wvp;
Newz(0, wvp, sizeof(wvpinfo), wvpinfo);
Newz(0, wvp->buf, sizeof(Buffer), Buffer);
Newz(0, wvp->header, sizeof(WavpackHeader), WavpackHeader);
wvp->infile = infile;
wvp->file = file;
wvp->info = info;
wvp->file_offset = 0;
wvp->audio_offset = 0;
wvp->seeking = seeking ? 1 : 0;
buffer_init(wvp->buf, WAVPACK_BLOCK_SIZE);
wvp->file_size = _file_size(infile);
my_hv_store( info, "file_size", newSVuv(wvp->file_size) );
// Loop through each wvpk block until we find a good one
while (!done) {
if ( !_check_buf(infile, wvp->buf, 32, WAVPACK_BLOCK_SIZE) ) {
err = -1;
goto out;
}
bptr = buffer_ptr(wvp->buf);
// If first byte is 'R', assume old version
if ( bptr[0] == 'R' ) {
if ( !_wavpack_parse_old(wvp) ) {
err = -1;
goto out;
}
break;
}
// May need to read past some junk before wvpk header
while ( bptr[0] != 'w' || bptr[1] != 'v' || bptr[2] != 'p' || bptr[3] != 'k' ) {
buffer_consume(wvp->buf, 1);
wvp->audio_offset++;
if ( !buffer_len(wvp->buf) ) {
if ( !_check_buf(infile, wvp->buf, 32, WAVPACK_BLOCK_SIZE) ) {
PerlIO_printf(PerlIO_stderr(), "Unable to find a valid WavPack block in file: %s\n", file);
err = -1;
goto out;
}
}
bptr = buffer_ptr(wvp->buf);
}
if ( _wavpack_parse_block(wvp) ) {
done = 1;
}
}
my_hv_store( info, "audio_offset", newSVuv(wvp->audio_offset) );
my_hv_store( info, "audio_size", newSVuv(wvp->file_size - wvp->audio_offset) );
out:
buffer_free(wvp->buf);
Safefree(wvp->buf);
Safefree(wvp->header);
return wvp;
}
/* maps to mod_mime_magic::parse */
static int
fmm_parse_magic_line(PerlFMM *state, char *l, int lineno)
{
char *t;
char *s;
fmmagic *m;
SV *err;
Newz(1234, m, 1, fmmagic);
m->next = NULL;
m->flag = 0;
m->cont_level = 0;
m->lineno = lineno;
if (! state->magic || !state->last) {
state->magic = state->last = m;
} else {
state->last->next = m;
state->last = m;
}
while (*l == '>') {
l++; /* step over */
m->cont_level++;
}
if (m->cont_level != 0 && *l == '(') {
l++; /* step over */
m->flag |= INDIR;
}
/* get offset, then skip over it */
m->offset = (int) strtol(l, &t, 0);
if (l == t) {
err = newSVpvf("Invalid offset in mime magic file, line %d: %s", lineno, l);
goto error;
}
l = t;
if (m->flag & INDIR) {
m->in.type = LONG;
m->in.offset = 0;
/* read [.lbs][+=]nnnnn) */
if (*l == '.') {
switch (*++l) {
case 'l':
m->in.type = LONG;
break;
case 's':
m->in.type = SHORT;
break;
case 'b':
m->in.type = BYTE;
break;
default:
err = newSVpvf(
"Invalid indirect offset type in mime magic file, line %d: %c", lineno, *l);
goto error;
}
l++;
}
s = l;
if (*l == '+' || *l == '-') {
l++;
}
if (isdigit((unsigned char) *l)) {
m->in.offset = strtol(l, &t, 0);
if (*s == '-') {
m->in.offset = -(m->in.offset);
}
} else {
t = l;
}
if (*t++ != ')') {
err = newSVpvf(
"Missing ')' in indirect offset in mime magic file, line %d", lineno);
goto error;
}
l = t;
}
while (isdigit((unsigned char) *l)) {
++l;
}
EATAB(l);
#define NBYTE 4
#define NSHORT 5
#define NLONG 4
#define NSTRING 6
#define NDATE 4
#define NBESHORT 7
#define NBELONG 6
#define NBEDATE 6
#define NLESHORT 7
#define NLELONG 6
#define NLEDATE 6
if (*l == 'u') {
++l;
m->flag |= UNSIGNED;
}
/* get type, skip it */
if (strncmp(l, "byte", NBYTE) == 0) {
m->type = BYTE;
l += NBYTE;
}
else if (strncmp(l, "short", NSHORT) == 0) {
m->type = SHORT;
l += NSHORT;
}
else if (strncmp(l, "long", NLONG) == 0) {
m->type = LONG;
l += NLONG;
}
else if (strncmp(l, "string", NSTRING) == 0) {
m->type = STRING;
l += NSTRING;
}
else if (strncmp(l, "date", NDATE) == 0) {
m->type = DATE;
l += NDATE;
}
else if (strncmp(l, "beshort", NBESHORT) == 0) {
m->type = BESHORT;
l += NBESHORT;
}
else if (strncmp(l, "belong", NBELONG) == 0) {
m->type = BELONG;
l += NBELONG;
}
else if (strncmp(l, "bedate", NBEDATE) == 0) {
m->type = BEDATE;
l += NBEDATE;
}
else if (strncmp(l, "leshort", NLESHORT) == 0) {
m->type = LESHORT;
l += NLESHORT;
}
else if (strncmp(l, "lelong", NLELONG) == 0) {
m->type = LELONG;
l += NLELONG;
}
else if (strncmp(l, "ledate", NLEDATE) == 0) {
m->type = LEDATE;
l += NLEDATE;
}
else {
err = newSVpvf("Invalid type in mime magic file, line %d: %s", lineno, l);
goto error;
}
/* New-style anding: "0 byte&0x80 =0x80 dynamically linked" */
if (*l == '&') {
++l;
m->mask = fmm_signextend(state, m, strtol(l, &l, 0));
}
else {
m->mask = ~0L;
}
EATAB(l);
switch (*l) {
case '>':
case '<':
/* Old-style anding: "0 byte &0x80 dynamically linked" */
case '&':
case '^':
case '=':
m->reln = *l;
++l;
break;
case '!':
if (m->type != STRING) {
m->reln = *l;
++l;
break;
}
/* FALL THROUGH */
default:
if (*l == 'x' && isSPACE(l[1])) {
m->reln = *l;
++l;
goto GetDesc; /* Bill The Cat */
}
m->reln = '=';
break;
}
EATAB(l);
if (fmm_getvalue(state, m, &l))
return -1;
/*
* now get last part - the description
*/
GetDesc:
EATAB(l);
if (l[0] == '\b') {
++l;
m->nospflag = 1;
}
else if ((l[0] == '\\') && (l[1] == 'b')) {
++l;
++l;
m->nospflag = 1;
}
else {
m->nospflag = 0;
}
strncpy(m->desc, l, sizeof(m->desc) - 1);
m->desc[sizeof(m->desc) - 1] = '\0';
return 0;
error:
FMM_SET_ERROR(state, err);
croak(SvPV_nolen(err));
}