int getSessionVarValue( char *action, char *varName, ruleExecInfo_t *rei, char **varValue ) { char *varMap; int i, vinx; Res *res; Region *r = make_region( 0, NULL ); vinx = getVarMap( action, varName, &varMap, 0 ); while ( vinx >= 0 ) { i = getVarValue( varMap, rei, &res, r ); if ( i >= 0 ) { free( varMap ); *varValue = convertResToString( res ); region_free( r ); return( i ); } else if ( i == NULL_VALUE_ERR ) { free( varMap ); vinx = getVarMap( action, varName, &varMap, vinx + 1 ); } else { free( varMap ); region_free( r ); return( i ); } } region_free( r ); if ( vinx < 0 ) { return( vinx ); } return( i ); }
/* compute an expression or action given by an AST node */ Res* computeNode( Node *node, Node *reco, Env *env, ruleExecInfo_t *rei, int reiSaveFlag, rError_t* errmsg, Region *r ) { Hashtable *varTypes = newHashTable2( 10, r ); Region *rNew = make_region( 0, NULL ); Node *en; Node **errnode = &en; Res* res; int errorcode; if ( ( errorcode = typeNode( node, varTypes, errmsg, errnode, r ) ) != 0 ) { res = newErrorRes( r, errorcode ); RETURN; } if ( reco != NULL && ( errorcode = typeNode( reco, varTypes, errmsg, errnode, r ) ) != 0 ) { res = newErrorRes( r, errorcode ); RETURN; } if ( getNodeType( node ) == N_ACTIONS ) { res = evaluateActions( node, NULL, GlobalAllRuleExecFlag, rei, reiSaveFlag, env, errmsg, rNew ); } else { res = evaluateExpression3( node, GlobalAllRuleExecFlag, 0, rei, reiSaveFlag, env, errmsg, rNew ); } /* switch (TYPE(res)) { case T_ERROR: addRErrorMsg(errmsg, -1, "error: in rule"); break; default: break; }*/ ret: res = cpRes( res, r ); cpEnv( env, r ); region_free( rNew ); return res; }
allocator_t *allocator_init(size_t default_size) { allocator_t *out = malloc(sizeof(allocator_t)); out->default_size = default_size; out->current = make_region(default_size, NULL); out->marks = NULL; out->num_marks = 0; allocator_push(out); return out; }
static void plug_mask(struct FRPlugin *plug, struct Rgn *rgn){ cairo_region_t *crgn = NULL; if(plug->rgn != rgn && rgn){ if(plug->rgn) free(plug->rgn); plug->rgn = malloc(sizeof(struct Rgn) + rgn->num * sizeof(cairo_rectangle_int_t)); memcpy(plug->rgn, rgn, sizeof(struct Rgn) + rgn->num * sizeof(cairo_rectangle_int_t)); } crgn = make_region(rgn); gtk_widget_shape_combine_region(plug->view, crgn); gtk_widget_show(plug->view); }
void *allocator_new(allocator_t *al, size_t num) { region_t *r = al->current; // If we have space in the current region use it. if(r->size - r->used > num) { void * out = r->data + r->used; r->used += num; return out; } // Create a new region at least as big as the allocation request. size_t s = al->default_size; if(s < num) { s = num; } al->current = make_region(s, r); al->current->used = num; return al->current->data; }
int getSessionVarValue( char *action, char *varName, ruleExecInfo_t *rei, char **varValue ) { Region *r = make_region( 0, NULL ); char *varMap; int vinx = getVarMap( action, varName, &varMap, 0 ); while ( vinx >= 0 ) { Res *res; int i = getVarValue( varMap, rei, &res, r ); free( varMap ); if ( i != NULL_VALUE_ERR ) { if ( i >= 0 ) { *varValue = convertResToString( res ); } region_free( r ); return i; } vinx = getVarMap( action, varName, &varMap, vinx + 1 ); } free( varMap ); region_free( r ); return vinx; }
static SkImageFilter* make_image_filter(bool canBeNull) { SkImageFilter* filter = 0; // Add a 1 in 3 chance to get a nullptr input if (canBeNull && (R(3) == 1)) { return filter; } enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER, DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE, DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW, MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS }; switch (R(NUM_FILTERS)) { case ALPHA_THRESHOLD: filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar()); break; case MERGE: filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode()); break; case COLOR: { SkAutoTUnref<SkColorFilter> cf(make_color_filter()); filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0; } break; case LUT3D: { int cubeDimension; SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1))); SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension)); filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0; } break; case BLUR: filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter()); break; case MAGNIFIER: filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true)); break; case DOWN_SAMPLE: filter = SkDownSampleImageFilter::Create(make_scalar()); break; case XFERMODE: { SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode())); filter = SkXfermodeImageFilter::Create(mode, make_image_filter(), make_image_filter()); } break; case OFFSET: filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter()); break; case MATRIX: filter = SkImageFilter::CreateMatrixFilter(make_matrix(), (SkFilterQuality)R(4), make_image_filter()); break; case MATRIX_CONVOLUTION: { SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); SkISize size = SkISize::Make(R(10)+1, R(10)+1); int arraySize = size.width() * size.height(); SkTArray<SkScalar> kernel(arraySize); for (int i = 0; i < arraySize; ++i) { kernel.push_back() = make_scalar(); } SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())), R(SkIntToScalar(size.height()))); filter = SkMatrixConvolutionImageFilter::Create(size, kernel.begin(), make_scalar(), make_scalar(), kernelOffset, (SkMatrixConvolutionImageFilter::TileMode)R(3), R(2) == 1, make_image_filter(), &cropR); } break; case COMPOSE: filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter()); break; case DISTANT_LIGHT: filter = (R(2) == 1) ? SkLightingImageFilter::CreateDistantLitDiffuse(make_point(), make_color(), make_scalar(), make_scalar(), make_image_filter()) : SkLightingImageFilter::CreateDistantLitSpecular(make_point(), make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter()); break; case POINT_LIGHT: filter = (R(2) == 1) ? SkLightingImageFilter::CreatePointLitDiffuse(make_point(), make_color(), make_scalar(), make_scalar(), make_image_filter()) : SkLightingImageFilter::CreatePointLitSpecular(make_point(), make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter()); break; case SPOT_LIGHT: filter = (R(2) == 1) ? SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0), make_point(), make_scalar(), make_scalar(), make_color(), make_scalar(), make_scalar(), make_image_filter()) : SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0), make_point(), make_scalar(), make_scalar(), make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter()); break; case NOISE: { SkAutoTUnref<SkShader> shader((R(2) == 1) ? SkPerlinNoiseShader::CreateFractalNoise( make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) : SkPerlinNoiseShader::CreateTurbulence( make_scalar(true), make_scalar(true), R(10.0f), make_scalar())); SkPaint paint; paint.setShader(shader); SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); filter = SkPaintImageFilter::Create(paint, &cropR); } break; case DROP_SHADOW: filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true), make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(), nullptr); break; case MORPHOLOGY: if (R(2) == 1) { filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)), R(static_cast<float>(kBitmapSize)), make_image_filter()); } else { filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)), R(static_cast<float>(kBitmapSize)), make_image_filter()); } break; case BITMAP: { SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(make_bitmap())); if (R(2) == 1) { filter = SkImageSource::Create(image, make_rect(), make_rect(), kHigh_SkFilterQuality); } else { filter = SkImageSource::Create(image); } } break; case DISPLACE: filter = SkDisplacementMapEffect::Create(make_channel_selector_type(), make_channel_selector_type(), make_scalar(), make_image_filter(false), make_image_filter()); break; case TILE: filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false)); break; case PICTURE: { SkRTreeFactory factory; SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize), &factory, 0); drawSomething(recordingCanvas); SkAutoTUnref<SkPicture> pict(recorder.endRecording()); filter = SkPictureImageFilter::Create(pict.get(), make_rect()); } break; case PAINT: { SkImageFilter::CropRect cropR(make_rect()); filter = SkPaintImageFilter::Create(make_paint(), &cropR); } default: break; } return (filter || canBeNull) ? filter : make_image_filter(canBeNull); }
static int rulecubature(rule *r, unsigned fdim, integrand_v f, void *fdata, const hypercube *h, size_t maxEval, double reqAbsError, double reqRelError, error_norm norm, double *val, double *err, int parallel) { size_t numEval = 0; heap regions; unsigned i, j; region *R = NULL; /* array of regions to evaluate */ size_t nR_alloc = 0; esterr *ee = NULL; if (fdim <= 1) norm = ERROR_INDIVIDUAL; /* norm is irrelevant */ if (norm < 0 || norm > ERROR_LINF) return FAILURE; /* invalid norm */ regions = heap_alloc(1, fdim); if (!regions.ee || !regions.items) goto bad; ee = (esterr *) malloc(sizeof(esterr) * fdim); if (!ee) goto bad; nR_alloc = 2; R = (region *) malloc(sizeof(region) * nR_alloc); if (!R) goto bad; R[0] = make_region(h, fdim); if (!R[0].ee || eval_regions(1, R, f, fdata, r) || heap_push(®ions, R[0])) goto bad; numEval += r->num_points; while (numEval < maxEval || !maxEval) { if (converged(fdim, regions.ee, reqAbsError, reqRelError, norm)) break; if (parallel) { /* maximize potential parallelism */ /* adapted from I. Gladwell, "Vectorization of one dimensional quadrature codes," pp. 230--238 in _Numerical Integration. Recent Developments, Software and Applications_, G. Fairweather and P. M. Keast, eds., NATO ASI Series C203, Dordrecht (1987), as described in J. M. Bull and T. L. Freeman, "Parallel Globally Adaptive Algorithms for Multi-dimensional Integration," http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.6638 (1994). Basically, this evaluates in one shot all regions that *must* be evaluated in order to reduce the error to the requested bound: the minimum set of largest-error regions whose errors push the total error over the bound. [Note: Bull and Freeman claim that the Gladwell approach is intrinsically inefficent because it "requires sorting", and propose an alternative algorithm that "only" requires three passes over the entire set of regions. Apparently, they didn't realize that one could use a heap data structure, in which case the time to pop K biggest-error regions out of N is only O(K log N), much better than the O(N) cost of the Bull and Freeman algorithm if K << N, and it is also much simpler.] */ size_t nR = 0; for (j = 0; j < fdim; ++j) ee[j] = regions.ee[j]; do { if (nR + 2 > nR_alloc) { nR_alloc = (nR + 2) * 2; R = (region *) realloc(R, nR_alloc * sizeof(region)); if (!R) goto bad; } R[nR] = heap_pop(®ions); for (j = 0; j < fdim; ++j) ee[j].err -= R[nR].ee[j].err; if (cut_region(R+nR, R+nR+1)) goto bad; numEval += r->num_points * 2; nR += 2; if (converged(fdim, ee, reqAbsError, reqRelError, norm)) break; /* other regions have small errs */ } while (regions.n > 0 && (numEval < maxEval || !maxEval)); if (eval_regions(nR, R, f, fdata, r) || heap_push_many(®ions, nR, R)) goto bad; } else { /* minimize number of function evaluations */ R[0] = heap_pop(®ions); /* get worst region */ if (cut_region(R, R+1) || eval_regions(2, R, f, fdata, r) || heap_push_many(®ions, 2, R)) goto bad; numEval += r->num_points * 2; } } /* re-sum integral and errors */ for (j = 0; j < fdim; ++j) val[j] = err[j] = 0; for (i = 0; i < regions.n; ++i) { for (j = 0; j < fdim; ++j) { val[j] += regions.items[i].ee[j].val; err[j] += regions.items[i].ee[j].err; } destroy_region(®ions.items[i]); } /* printf("regions.nalloc = %d\n", regions.nalloc); */ free(ee); heap_free(®ions); free(R); return SUCCESS; bad: free(ee); heap_free(®ions); free(R); return FAILURE; }
char* typeToString(ExprType *type, Hashtable *var_types, char *buf, int bufsize) { buf[0] = '\0'; Region *r = make_region(0, NULL); if(getVararg(type) != OPTION_VARARG_ONCE) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "vararg "); } ExprType *etype = type; if(getNodeType(etype) == T_VAR && var_types != NULL) { /* dereference */ etype = dereference(etype, var_types, r); } if(getNodeType(etype) == T_VAR) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", etype == NULL?"?":typeName_ExprType(etype)); snprintf(buf+strlen(buf), bufsize-strlen(buf), "%d", T_VAR_ID(etype)); if(T_VAR_NUM_DISJUNCTS(type)!=0) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "{"); int i; for(i=0;i<T_VAR_NUM_DISJUNCTS(type);i++) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", typeName_ExprType(T_VAR_DISJUNCT(type, i))); } snprintf(buf+strlen(buf), bufsize-strlen(buf), "}"); } } else if(getNodeType(etype) == T_CONS) { if(strcmp(etype->text, FUNC) == 0) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "("); typeToString(T_CONS_TYPE_ARG(etype, 0), var_types, buf+strlen(buf), bufsize-strlen(buf)); snprintf(buf+strlen(buf), bufsize-strlen(buf), ")"); snprintf(buf+strlen(buf), bufsize-strlen(buf), "->"); typeToString(T_CONS_TYPE_ARG(etype, 1), var_types, buf+strlen(buf), bufsize-strlen(buf)); } else { snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", T_CONS_TYPE_NAME(etype)); int i; if(T_CONS_ARITY(etype) != 0) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "("); for(i=0;i<T_CONS_ARITY(etype);i++) { if(i!=0) { snprintf(buf+strlen(buf), bufsize-strlen(buf), ", "); } typeToString(T_CONS_TYPE_ARG(etype, i), var_types, buf+strlen(buf), bufsize-strlen(buf)); } snprintf(buf+strlen(buf), bufsize-strlen(buf), ")"); } } } else if(getNodeType(etype) == T_FLEX) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", typeName_ExprType(etype)); typeToString(etype->subtrees[0], var_types, buf+strlen(buf), bufsize-strlen(buf)); } else if(getNodeType(etype) == T_FIXD) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", typeName_ExprType(etype)); typeToString(etype->subtrees[0], var_types, buf+strlen(buf), bufsize-strlen(buf)); snprintf(buf+strlen(buf), bufsize-strlen(buf), "=> "); typeToString(etype->subtrees[1], var_types, buf+strlen(buf), bufsize-strlen(buf)); } else if(getNodeType(etype) == T_TUPLE) { if(T_CONS_ARITY(etype) == 0) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "unit"); } else { if(T_CONS_ARITY(etype) == 1) { snprintf(buf+strlen(buf), bufsize-strlen(buf), "("); } int i; for(i=0;i<T_CONS_ARITY(etype);i++) { if(i!=0) { snprintf(buf+strlen(buf), bufsize-strlen(buf), " * "); } typeToString(T_CONS_TYPE_ARG(etype, i), var_types, buf+strlen(buf), bufsize-strlen(buf)); } if(T_CONS_ARITY(etype) == 1) { snprintf(buf+strlen(buf), bufsize-strlen(buf), ")"); } } } else { snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", etype == NULL?"?":typeName_ExprType(etype)); } int i = strlen(buf) - 1; while(buf[i]==' ') i--; buf[i+1]='\0'; region_free(r); return buf; }
int processXMsg( int streamId, char *readmsg, RuleEngineEventParam *param, Node *node, Env *env, ruleExecInfo_t *rei ) { char myhdr[HEADER_TYPE_LEN]; char mymsg[MAX_NAME_LEN]; char *outStr = NULL; int i, n; int iLevel, wCnt; int ruleInx = 0; Region *r; Res *res; rError_t errmsg; errmsg.len = 0; errmsg.errMsg = NULL; r = make_region( 0, NULL ); ParserContext *context = newParserContext( &errmsg, r ); Pointer *e = newPointer2( readmsg ); int rulegen = 1; int found; int grdf[2]; int cmd = 0; int smallW; snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug:%s", param->actionName ); memset( mymsg, 0, sizeof( mymsg ) ); PARSER_BEGIN( DbgCmd ) TRY( DbgCmd ) TTEXT2( "n", "next" ); cmd = REDEBUG_STEP_OVER; OR( DbgCmd ) TTEXT2( "s", "step" ); cmd = REDEBUG_NEXT; OR( DbgCmd ) TTEXT2( "f", "finish" ); cmd = REDEBUG_STEP_OUT; OR( DbgCmd ) TTEXT2( "b", "break" ); TRY( Param ) TTYPE( TK_TEXT ); int breakPointsInx2; for ( breakPointsInx2 = 0; breakPointsInx2 < 100; breakPointsInx2++ ) { if ( breakPoints[breakPointsInx2].actionName == NULL ) { break; } } if ( breakPointsInx2 == 100 ) { _writeXMsg( streamId, myhdr, "Maximum breakpoint count reached. Breakpoint not set.\n" ); cmd = REDEBUG_WAIT; } else { breakPoints[breakPointsInx2].actionName = strdup( token->text ); char * base_ptr = NULL; TRY( loc ) TTYPE( TK_TEXT ); base_ptr = ( char * ) malloc( sizeof( token->text ) + 2 ); base_ptr[0] = 'f'; strcpy( base_ptr + 1, token->text ); TTEXT( ":" ); TTYPE( TK_INT ); breakPoints[breakPointsInx2].base = strdup( base_ptr ); breakPoints[breakPointsInx2].line = atoi( token->text ); rodsLong_t range[2]; char rulesFileName[MAX_NAME_LEN]; getRuleBasePath( base_ptr, rulesFileName ); FILE *file; /* char errbuf[ERR_MSG_LEN]; */ file = fopen( rulesFileName, "r" ); if ( file == NULL ) { free( context ); deletePointer( e ); free( base_ptr ); return RULES_FILE_READ_ERROR; } Pointer *p = newPointer( file, base_ptr ); if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) { breakPoints[breakPointsInx2].start = range[0]; breakPoints[breakPointsInx2].finish = range[1]; } else { breakPoints[breakPointsInx2].actionName = NULL; } deletePointer( p ); OR( loc ) TTYPE( TK_INT ); if ( node != NULL ) { breakPoints[breakPointsInx2].base = strdup( node->base ); breakPoints[breakPointsInx2].line = atoi( token->text ); rodsLong_t range[2]; Pointer *p = newPointer2( breakPoints[breakPointsInx2].base ); if ( getLineRange( p, breakPoints[breakPointsInx2].line, range ) == 0 ) { breakPoints[breakPointsInx2].start = range[0]; breakPoints[breakPointsInx2].finish = range[1]; } else { breakPoints[breakPointsInx2].actionName = NULL; } deletePointer( p ); } else { breakPoints[breakPointsInx2].actionName = NULL; } OR( loc ) /* breakPoints[breakPointsInx].base = NULL; */ END_TRY( loc ) free( base_ptr ); if ( breakPoints[breakPointsInx2].actionName != NULL ) snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i set at %s\n", breakPointsInx2, breakPoints[breakPointsInx2].actionName ); else { snprintf( mymsg, MAX_NAME_LEN, "Cannot set breakpoint, source not available\n" ); } _writeXMsg( streamId, myhdr, mymsg ); if ( breakPointsInx <= breakPointsInx2 ) { breakPointsInx = breakPointsInx2 + 1; } cmd = REDEBUG_WAIT; } OR( Param ) NEXT_TOKEN_BASIC; _writeXMsg( streamId, myhdr, "Unknown parameter type.\n" ); cmd = REDEBUG_WAIT; OR( Param ) _writeXMsg( streamId, myhdr, "Debugger command \'break\' requires at least one argument.\n" ); cmd = REDEBUG_WAIT; END_TRY( Param ) OR( DbgCmd ) TRY( Where ) TTEXT2( "w", "where" ); smallW = 1; OR( Where ) TTEXT2( "W", "Where" ); smallW = 0; END_TRY( Where ) wCnt = 20; OPTIONAL_BEGIN( Param ) TTYPE( TK_INT ); wCnt = atoi( token->text ); OPTIONAL_END( Param ) iLevel = 0; i = reDebugStackCurrPtr - 1; while ( i >= 0 && wCnt > 0 ) { if ( !smallW || ( reDebugPCType( ( RuleEngineEvent ) reDebugStackCurr[i].label ) & 1 ) != 0 ) { snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Level %3i", iLevel ); char msg[HEADER_TYPE_LEN - 1]; RuleEngineEventParam param; param.ruleIndex = 0; param.actionName = reDebugStackCurr[i].step; printRuleEngineEventLabel( msg, HEADER_TYPE_LEN - 1, ( RuleEngineEvent ) reDebugStackCurr[i].label, ¶m ); _writeXMsg( streamId, myhdr, msg ); if ( reDebugStackCurr[i].label != EXEC_ACTION_BEGIN ) { iLevel++; } wCnt--; } i--; } OR( DbgCmd ) TTEXT2( "l", "list" ); TRY( Param ) TTEXT2( "r", "rule" ); TRY( ParamParam ) TTYPE( TK_TEXT ); mymsg[0] = '\n'; mymsg[1] = '\0'; snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text ); RuleIndexListNode *node; found = 0; while ( findNextRule2( token->text, ruleInx, &node ) != NO_MORE_RULES_ERR ) { found = 1; if ( node->secondaryIndex ) { n = node->condIndex->valIndex->len; int i; for ( i = 0; i < n; i++ ) { Bucket *b = node->condIndex->valIndex->buckets[i]; while ( b != NULL ) { RuleDesc *rd = getRuleDesc( *( int * )b->value ); char buf[MAX_RULE_LEN]; ruleToString( buf, MAX_RULE_LEN, rd ); snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf ); b = b->next; } } } else { RuleDesc *rd = getRuleDesc( node->ruleIndex ); char buf[MAX_RULE_LEN]; ruleToString( buf, MAX_RULE_LEN, rd ); snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "\n %i: %s\n%s\n", node->ruleIndex, rd->node->base[0] == 's' ? "<source>" : rd->node->base + 1, buf ); } ruleInx ++; } if ( !found ) { snprintf( mymsg, MAX_NAME_LEN, "Rule %s not found\n", token->text ); } _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; OR( ParamParam ) _writeXMsg( streamId, myhdr, "Debugger command \'list rule\' requires one argument.\n" ); cmd = REDEBUG_WAIT; END_TRY( ParamParam ) OR( Param ) TTEXT2( "b", "breakpoints" ); snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text ); mymsg[0] = '\n'; mymsg[1] = '\0'; for ( i = 0; i < breakPointsInx; i++ ) { if ( breakPoints[i].actionName != NULL ) { if ( breakPoints[i].base != NULL ) { snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s %s:%d\n", i , breakPoints[i].actionName, breakPoints[i].base[0] == 's' ? "<source>" : breakPoints[i].base + 1, breakPoints[i].line ); } else { snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "Breaking at BreakPoint %i:%s\n", i , breakPoints[i].actionName ); } } } _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; OR( Param ) TTEXT( "*" ); snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text ); Env *cenv = env; mymsg[0] = '\n'; mymsg[1] = '\0'; found = 0; while ( cenv != NULL ) { n = cenv->current->size; for ( i = 0; i < n; i++ ) { Bucket *b = cenv->current->buckets[i]; while ( b != NULL ) { if ( b->key[0] == '*' ) { /* skip none * variables */ found = 1; char typeString[128]; typeToString( ( ( Res * )b->value )->exprType, NULL, typeString, 128 ); snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "%s of type %s\n", b->key, typeString ); } b = b->next; } } cenv = cenv->previous; } if ( !found ) { snprintf( mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ), "<empty>\n" ); } _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; OR( Param ) syncTokenQueue( e, context ); skipWhitespace( e ); ABORT( lookAhead( e, 0 ) != '$' ); snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Listing %s", token->text ); mymsg[0] = '\n'; mymsg[1] = '\0'; Hashtable *vars = newHashTable( 100 ); for ( i = 0; i < coreRuleVarDef .MaxNumOfDVars; i++ ) { if ( lookupFromHashTable( vars, coreRuleVarDef.varName[i] ) == NULL ) { snprintf( &mymsg[strlen( mymsg )], MAX_NAME_LEN - strlen( mymsg ), "$%s\n", coreRuleVarDef.varName[i] ); insertIntoHashTable( vars, coreRuleVarDef.varName[i], coreRuleVarDef.varName[i] ); } } deleteHashTable( vars, NULL ); _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; OR( Param ) NEXT_TOKEN_BASIC; _writeXMsg( streamId, myhdr, "Unknown parameter type.\n" ); cmd = REDEBUG_WAIT; OR( Param ) _writeXMsg( streamId, myhdr, "Debugger command \'list\' requires at least one argument.\n" ); cmd = REDEBUG_WAIT; END_TRY( Param ) OR( DbgCmd ) TTEXT2( "c", "continue" ); cmd = REDEBUG_STEP_CONTINUE; OR( DbgCmd ) TTEXT2( "C", "Continue" ); cmd = REDEBUG_CONTINUE_VERBOSE; OR( DbgCmd ) TTEXT2( "del", "delete" ); TRY( Param ) TTYPE( TK_INT ); n = atoi( token->text ); if ( breakPoints[n].actionName != NULL ) { free( breakPoints[n].actionName ); if ( breakPoints[n].base != NULL ) { free( breakPoints[n].base ); } breakPoints[n].actionName = NULL; breakPoints[n].base = NULL; snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i deleted\n", n ); } else { snprintf( mymsg, MAX_NAME_LEN, "Breakpoint %i has not been defined\n", n ); } _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; OR( Param ) _writeXMsg( streamId, myhdr, "Debugger command \'delete\' requires one argument.\n" ); cmd = REDEBUG_WAIT; END_TRY( Param ) OR( DbgCmd ) TTEXT2( "p", "print" ); Node *n = parseTermRuleGen( e, 1, context ); if ( getNodeType( n ) == N_ERROR ) { errMsgToString( context->errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) ); } else { snprintf( myhdr, HEADER_TYPE_LEN - 1, "idbug: Printing " ); char * ptr = myhdr + strlen( myhdr ); i = HEADER_TYPE_LEN - 1 - strlen( myhdr ); termToString( &ptr, &i, 0, MIN_PREC, n, 0 ); snprintf( ptr, i, "\n" ); if ( env != NULL ) { disableReDebugger( grdf ); res = computeNode( n, NULL, regionRegionCpEnv( env, r, ( RegionRegionCopyFuncType * ) regionRegionCpNode ), rei, 0, &errmsg, r ); enableReDebugger( grdf ); outStr = convertResToString( res ); snprintf( mymsg, MAX_NAME_LEN, "%s\n", outStr ); free( outStr ); if ( getNodeType( res ) == N_ERROR ) { errMsgToString( &errmsg, mymsg + strlen( mymsg ), MAX_NAME_LEN - strlen( mymsg ) ); } } else { snprintf( mymsg, MAX_NAME_LEN, "Runtime environment: <empty>\n" ); } } _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; OR( DbgCmd ) TTEXT2( "d", "discontinue" ); cmd = REDEBUG_WAIT; OR( DbgCmd ) snprintf( mymsg, MAX_NAME_LEN, "Unknown Action: %s", readmsg ); _writeXMsg( streamId, myhdr, mymsg ); cmd = REDEBUG_WAIT; END_TRY( DbgCmd ) PARSER_END( DbgCmd ) freeRErrorContent( &errmsg ); region_free( r ); deletePointer( e ); free( context ); return cmd; }
all_resources() { rNew = make_region(0, NULL); memset(msParams,0 ,sizeof(msParam_t[10])); }
static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) { sk_sp<SkImageFilter> filter; // Add a 1 in 3 chance to get a nullptr input uint8_t i; fuzz->nextRange(&i, 0, 2); if (fuzz->exhausted() || (canBeNull && i == 1)) { return filter; } enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER, BLENDMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE, DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW, MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS }; uint8_t s; fuzz->nextRange(&s, 0, NUM_FILTERS - 1); switch (s) { case ALPHA_THRESHOLD: { SkRegion reg = make_region(); SkScalar innerMin, outerMax; fuzz->next(&innerMin, &outerMax); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkAlphaThresholdFilter::Make(reg, innerMin, outerMax, fil); break; } case MERGE: { sk_sp<SkImageFilter> filA = make_image_filter(); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkMergeImageFilter::Make(filA, filB); break; } case COLOR: { sk_sp<SkColorFilter> cf(make_color_filter()); filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter()) : nullptr; break; } case BLUR: { SkScalar sX = make_number(true); SkScalar sY = make_number(true); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkBlurImageFilter::Make(sX, sY, fil); break; } case MAGNIFIER: { SkRect rect = make_rect(); SkScalar inset = make_number(true); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkMagnifierImageFilter::Make(rect, inset, fil); break; } case BLENDMODE: { SkBlendMode mode = make_blendmode(); sk_sp<SkImageFilter> filA = make_image_filter(); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkXfermodeImageFilter::Make(mode, filA, filB, nullptr); break; } case OFFSET: { SkScalar dx, dy; fuzz->next(&dx, &dy); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkOffsetImageFilter::Make(dx, dy, fil); break; } case MATRIX: { SkMatrix m; init_matrix(&m); int qual; fuzz->nextRange(&qual, 0, SkFilterQuality::kLast_SkFilterQuality - 1); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkImageFilter::MakeMatrixFilter(m, (SkFilterQuality)qual, fil); break; } case MATRIX_CONVOLUTION: { SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); int w, h; fuzz->nextRange(&w, 1, 10); fuzz->nextRange(&h, 1, 10); SkISize size = SkISize::Make(w, h); int arraySize = size.width() * size.height(); SkTArray<SkScalar> kernel(arraySize); for (int i = 0; i < arraySize; ++i) { kernel.push_back() = make_number(false); } fuzz->nextRange(&w, 0, size.width() - 1); fuzz->nextRange(&h, 0, size.height() - 1); SkIPoint kernelOffset = SkIPoint::Make(w, h); int mode; fuzz->nextRange(&mode, 0, SkMatrixConvolutionImageFilter::kMax_TileMode - 1); bool convolveAlpha = make_bool(); SkScalar gain, bias; fuzz->next(&gain, &bias); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkMatrixConvolutionImageFilter::Make(size, kernel.begin(), gain, bias, kernelOffset, (SkMatrixConvolutionImageFilter::TileMode)mode, convolveAlpha, fil, &cropR); break; } case COMPOSE: { sk_sp<SkImageFilter> filA = make_image_filter(); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkComposeImageFilter::Make(filA, filB); break; } case DISTANT_LIGHT: { SkPoint3 p = make_point(); SkColor c = make_color(); SkScalar ss, kd; fuzz->next(&ss, &kd); int shininess; fuzz->nextRange(&shininess, 0, 9); sk_sp<SkImageFilter> fil = make_image_filter(); filter = make_bool() ? SkLightingImageFilter::MakeDistantLitDiffuse(p, c, ss, kd, fil) : SkLightingImageFilter::MakeDistantLitSpecular(p, c, ss, kd, shininess, fil); break; } case POINT_LIGHT: { SkPoint3 p = make_point(); SkColor c = make_color(); SkScalar ss, kd; fuzz->next(&ss, &kd); int shininess; fuzz->nextRange(&shininess, 0, 9); sk_sp<SkImageFilter> fil = make_image_filter(); filter = make_bool() ? SkLightingImageFilter::MakePointLitDiffuse(p, c, ss, kd, fil) : SkLightingImageFilter::MakePointLitSpecular(p, c, ss, kd, shininess, fil); break; } case SPOT_LIGHT: { SkPoint3 p = make_point(); SkColor c = make_color(); SkScalar se, ca, ss, kd; fuzz->next(&se, &ca, &ss, &kd); int shininess; fuzz->nextRange(&shininess, 0, 9); sk_sp<SkImageFilter> fil = make_image_filter(); filter = make_bool() ? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0), p, se, ca, c, ss, kd, fil) : SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0), p, se, ca, c, ss, kd, shininess, fil); break; } case NOISE: { SkScalar bfx = make_number(true); SkScalar bfy = make_number(true); SkScalar seed = make_number(false); int octaves; fuzz->nextRange(&octaves, 0, 9); sk_sp<SkShader> shader(make_bool() ? SkPerlinNoiseShader::MakeFractalNoise(bfx, bfy, octaves, seed) : SkPerlinNoiseShader::MakeTurbulence(bfx, bfy, octaves, seed)); SkPaint paint; paint.setShader(shader); SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); filter = SkPaintImageFilter::Make(paint, &cropR); break; } case DROP_SHADOW: { SkScalar dx, dy, sx, sy; fuzz->next(&dx, &dy); sx = make_number(true); sy = make_number(true); SkColor c = make_color(); SkDropShadowImageFilter::ShadowMode mode = make_shadow_mode(); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkDropShadowImageFilter::Make(dx, dy, sx, sy, c, mode, fil, nullptr); break; } case MORPHOLOGY: { int rx, ry; fuzz->nextRange(&rx, 0, kBitmapSize); fuzz->nextRange(&ry, 0, kBitmapSize); sk_sp<SkImageFilter> fil = make_image_filter(); if (make_bool()) { filter = SkDilateImageFilter::Make(rx, ry, fil); } else { filter = SkErodeImageFilter::Make(rx, ry, fil); } break; } case BITMAP: { sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap())); if (make_bool()) { filter = SkImageSource::Make(std::move(image), make_rect(), make_rect(), kHigh_SkFilterQuality); } else { filter = SkImageSource::Make(std::move(image)); } break; } case DISPLACE: { SkDisplacementMapEffect::ChannelSelectorType x = make_channel_selector_type(); SkDisplacementMapEffect::ChannelSelectorType y = make_channel_selector_type(); SkScalar scale = make_number(false); sk_sp<SkImageFilter> filA = make_image_filter(false); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkDisplacementMapEffect::Make(x, y, scale, filA, filB); break; } case TILE: { SkRect src = make_rect(); SkRect dest = make_rect(); sk_sp<SkImageFilter> fil = make_image_filter(false); filter = SkTileImageFilter::Make(src, dest, fil); break; } case PICTURE: { SkRTreeFactory factory; SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize), &factory, 0); drawSomething(recordingCanvas); sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture()); filter = SkPictureImageFilter::Make(pict, make_rect()); break; } case PAINT: { SkImageFilter::CropRect cropR(make_rect()); filter = SkPaintImageFilter::Make(make_paint(), &cropR); break; } default: break; } return filter; }