bool Key(const char* str, SizeType length, bool copy)
{
if (!check_depth("object"))
return false;
if (depth == 1) {
if (0) {
}
else if (utility::string_equal(str, length, "\x53\x70\x61\x63\x65\x49\x44", 7))
{ state=0; has_SpaceID = true; }
else {
state = -1;
return true;
}
} else {
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Key(str, length, copy));
default:
break;
}
}
return true;
}
bool EndArray(SizeType length)
{
if (!check_depth("array"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.EndArray(length));
default:
break;
}
return true;
}
bool StartArray()
{
if (!check_depth("array"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.StartArray());
default:
break;
}
return true;
}
bool Double(double d)
{
if (!check_depth("double"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Double(d));
default:
break;
}
return true;
}
bool String(const char* str, SizeType length, bool copy)
{
if (!check_depth("string"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.String(str, length, copy));
default:
break;
}
return true;
}
bool Uint64(utility::uint64_t i)
{
if (!check_depth("uint64_t"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Uint64(i));
default:
break;
}
return true;
}
bool Uint(unsigned i)
{
if (!check_depth("unsigned"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Uint(i));
default:
break;
}
return true;
}
bool Int(int i)
{
if (!check_depth("int"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Int(i));
default:
break;
}
return true;
}
bool Bool(bool b)
{
if (!check_depth("bool"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Bool(b));
default:
break;
}
return true;
}
bool Null()
{
if (!check_depth("null"))
return false;
switch (state) {
case 0:
return checked_event_forwarding(handler_0.Null());
default:
break;
}
return true;
}
void C_TreeGrow(SEXP node, SEXP learnsample, SEXP fitmem,
SEXP controls, int *where, int *nodenum, int depth) {
SEXP weights;
int nobs, i, stop;
double *dweights;
weights = S3get_nodeweights(node);
/* stop if either stumps have been requested or
the maximum depth is exceeded */
stop = (nodenum[0] == 2 || nodenum[0] == 3) &&
get_stump(get_tgctrl(controls));
stop = stop || !check_depth(get_tgctrl(controls), depth);
if (stop)
C_Node(node, learnsample, weights, fitmem, controls, 1, depth);
else
C_Node(node, learnsample, weights, fitmem, controls, 0, depth);
S3set_nodeID(node, nodenum[0]);
if (!S3get_nodeterminal(node)) {
C_splitnode(node, learnsample, controls);
/* determine surrogate splits and split missing values */
if (get_maxsurrogate(get_splitctrl(controls)) > 0) {
C_surrogates(node, learnsample, weights, controls, fitmem);
C_splitsurrogate(node, learnsample);
}
nodenum[0] += 1;
C_TreeGrow(S3get_leftnode(node), learnsample, fitmem,
controls, where, nodenum, depth + 1);
nodenum[0] += 1;
C_TreeGrow(S3get_rightnode(node), learnsample, fitmem,
controls, where, nodenum, depth + 1);
} else {
dweights = REAL(weights);
nobs = get_nobs(learnsample);
for (i = 0; i < nobs; i++)
if (dweights[i] > 0) where[i] = nodenum[0];
}
}
void
stret_iteration_init( StretIteration *iteration, StretRegion *region, StretRegion *abort_at )
{
D_ASSERT( iteration != NULL );
D_MAGIC_ASSERT( region, StretRegion );
D_MAGIC_ASSERT_IF( abort_at, StretRegion );
D_DEBUG_AT( UniQuE_StReT, "stret_iteration_init()\n" );
iteration->frame = -1;
iteration->x0 = 0;
iteration->y0 = 0;
iteration->abort = abort_at;
do {
int last_level = region->levels - 1;
int last_child = fusion_vector_size( ®ion->children[last_level] ) - 1;
iteration->frame++;
iteration->x0 += region->bounds.x1;
iteration->y0 += region->bounds.y1;
iteration->stack[iteration->frame].region = region;
iteration->stack[iteration->frame].level = last_level;
iteration->stack[iteration->frame].index = last_child - 1;
D_DEBUG_AT( UniQuE_StReT, " -> (%d) %p, last level %d, last index %d\n",
iteration->frame, region, last_level, last_child );
if (last_child >= 0) {
region = fusion_vector_at( ®ion->children[last_level], last_child );
D_MAGIC_ASSERT( region, StretRegion );
}
} while (fusion_vector_size( ®ion->children[region->levels - 1] ) && check_depth( iteration->frame + 1 ));
iteration->stack[iteration->frame].index++;
D_MAGIC_SET( iteration, StretIteration );
}
StretRegion *
stret_iteration_next( StretIteration *iteration,
const DFBRegion *clip )
{
int index;
int level;
StretRegion *region;
D_MAGIC_ASSERT( iteration, StretIteration );
DFB_REGION_ASSERT_IF( clip );
if (clip)
D_DEBUG_AT( UniQuE_StReT, "stret_iteration_next( %d, %d - %dx%d )\n",
DFB_RECTANGLE_VALS_FROM_REGION( clip ) );
else
D_DEBUG_AT( UniQuE_StReT, "stret_iteration_next()\n" );
while (iteration->frame >= 0) {
StretIterationStackFrame *frame = &iteration->stack[iteration->frame];
region = frame->region;
level = frame->level;
index = frame->index--;
D_MAGIC_ASSERT( region, StretRegion );
D_DEBUG_AT( UniQuE_StReT, " -> (%d) %p, level [%d/%d], index %d\n",
iteration->frame, region, level, region->levels - 1, index );
if (iteration->abort && region == iteration->abort) {
D_MAGIC_CLEAR( iteration );
return NULL;
}
if (index < 0) {
level = --frame->level;
if (level < 0) {
iteration->frame--;
iteration->x0 -= region->bounds.x1;
iteration->y0 -= region->bounds.y1;
if (accept_region( region, iteration->x0, iteration->y0, clip ))
return region;
}
else {
frame->index = fusion_vector_size( ®ion->children[level] ) - 1;
}
}
else {
region = fusion_vector_at( ®ion->children[level], index );
D_MAGIC_ASSERT( region, StretRegion );
if (iteration->abort && region == iteration->abort) {
D_MAGIC_CLEAR( iteration );
return NULL;
}
if (accept_region( region, iteration->x0, iteration->y0, clip )) {
level = region->levels - 1;
while (fusion_vector_is_empty( ®ion->children[level] )) {
if (level)
level--;
else
return region;
}
if (check_depth( iteration->frame + 1 )) {
frame = &iteration->stack[++iteration->frame];
iteration->x0 += region->bounds.x1;
iteration->y0 += region->bounds.y1;
frame->region = region;
frame->level = level;
frame->index = fusion_vector_size( ®ion->children[level] ) - 1;
continue;
}
return region;
}
}
}
D_ASSUME( iteration->x0 == 0 );
D_ASSUME( iteration->y0 == 0 );
D_MAGIC_CLEAR( iteration );
return NULL;
}
void test_two_level_stack(void)
{
names_stack *stack;
unsigned int check_num;
check_num = 0;
stack = stack_new();
stack_enter(stack);
check_depth(check_num++, stack, "foo", 0);
check_depth(check_num++, stack, "bar", 0);
check_depth(check_num++, stack, "baz", 0);
check_unsigned_int(stack_frame_size(stack), 0);
stack_name_add(stack, "foo");
stack_name_add(stack, "bar");
check_depth(check_num++, stack, "foo", 1);
check_depth(check_num++, stack, "bar", 2);
check_depth(check_num++, stack, "baz", 0);
check_unsigned_ints(stack_frame_size(stack), 2, "1");
stack_enter(stack);
check_unsigned_ints(stack_frame_size(stack), 0, "2");
stack_name_add(stack, "baz");
check_unsigned_ints(stack_frame_size(stack), 1, "3");
stack_name_add(stack, "foo");
check_unsigned_ints(stack_frame_size(stack), 2, "4");
check_depth(check_num++, stack, "foo", 2);
check_depth(check_num++, stack, "bar", 0);
check_depth(check_num++, stack, "baz", 1);
stack_leave(stack);
check_unsigned_ints(stack_frame_size(stack), 2, "5");
check_depth(check_num++, stack, "foo", 1);
check_depth(check_num++, stack, "bar", 2);
check_depth(check_num++, stack, "baz", 0);
stack_leave(stack);
check_unsigned_ints(stack_frame_size(stack), 0, "6");
check_depth(check_num++, stack, "foo", 0);
check_depth(check_num++, stack, "bar", 0);
check_depth(check_num++, stack, "baz", 0);
stack_destroy(stack);
}
static GLboolean
mgaTryDrawPixels( GLcontext *ctx,
GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type,
const struct gl_pixelstore_attrib *unpack,
const GLvoid *pixels )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLint size, skipPixels, skipRows;
GLint pitch = unpack->RowLength ? unpack->RowLength : width;
GLuint dest, planemask;
GLuint cpp = mmesa->mgaScreen->cpp;
if (!clip_pixelrect(ctx, ctx->DrawBuffer,
&x, &y, &width, &height,
&skipPixels, &skipRows, &size)) {
return GL_TRUE;
}
switch (format) {
#if defined(MESA_packed_depth_stencil)
case GL_DEPTH_STENCIL_MESA:
dest = mmesa->mgaScreen->depthOffset;
planemask = ~0;
if (!check_depth_stencil_24_8(ctx, type, unpack, pixels, size, pitch) ||
!check_depth_per_fragment_ops(ctx) ||
!check_stencil_per_fragment_ops(ctx))
return GL_FALSE;
break;
#endif
case GL_DEPTH_COMPONENT:
dest = mmesa->mgaScreen->depthOffset;
if (ctx->Visual.depthBits == 24)
planemask = ~0xff;
else
planemask = ~0;
if (!check_depth(ctx, type, unpack, pixels, size, pitch) ||
!check_depth_per_fragment_ops(ctx))
return GL_FALSE;
break;
case GL_RGB:
case GL_BGRA:
dest = (mmesa->draw_buffer == MGA_FRONT ?
mmesa->mgaScreen->frontOffset :
mmesa->mgaScreen->backOffset);
planemask = mgaPackColor(cpp,
ctx->Color.ColorMask[RCOMP],
ctx->Color.ColorMask[GCOMP],
ctx->Color.ColorMask[BCOMP],
ctx->Color.ColorMask[ACOMP]);
if (cpp == 2)
planemask |= planemask << 16;
if (!check_color(ctx, type, format, unpack, pixels, size, pitch)) {
return GL_FALSE;
}
if (!check_color_per_fragment_ops(ctx)) {
return GL_FALSE;
}
break;
default:
return GL_FALSE;
}
LOCK_HARDWARE_QUIESCENT( mmesa );
if (mmesa->dirty_cliprects & MGA_FRONT)
mgaUpdateRects( mmesa, MGA_FRONT );
if ( IS_AGP_MEM(mmesa, (char *)pixels) &&
IS_AGP_MEM(mmesa, (char *)pixels + size) )
{
do_draw_pix( ctx, x, y, width, height, pitch, pixels,
dest, planemask );
UPDATE_LOCK( mmesa, DRM_LOCK_FLUSH | DRM_LOCK_QUIESCENT );
}
else
{
/* Pixels is in regular memory -- get dma buffers and perform
* upload through them.
*/
/* drmBufPtr buf = mgaGetBufferLocked(mmesa); */
GLuint bufferpitch = (width*cpp+31)&~31;
char *address = 0; /* mmesa->mgaScreen->agp.map; */
do {
/* GLuint rows = MIN2( height, MGA_DMA_BUF_SZ / bufferpitch ); */
GLuint rows = height;
if (0) fprintf(stderr, "trying to upload %d rows (pitch %d)\n",
rows, bufferpitch);
/* The texture conversion code is so slow that there is only
* negligble speedup when the buffers/images don't exactly
* match:
*/
#if 0
if (cpp == 2) {
if (!_mesa_convert_texsubimage2d( MESA_FORMAT_RGB565,
0, 0, width, rows,
bufferpitch, format, type,
unpack, pixels, address )) {
/* mgaReleaseBufLocked( mmesa, buf ); */
UNLOCK_HARDWARE(mmesa);
return GL_FALSE;
}
} else {
if (!_mesa_convert_texsubimage2d( MESA_FORMAT_ARGB8888,
0, 0, width, rows,
bufferpitch, format, type,
unpack, pixels, address )) {
/* mgaReleaseBufLocked( mmesa, buf ); */
UNLOCK_HARDWARE(mmesa);
return GL_FALSE;
}
}
#else
MEMCPY( address, pixels, rows*bufferpitch );
#endif
do_draw_pix( ctx, x, y, width, rows,
bufferpitch/cpp, address, dest, planemask );
/* Fix me -- use multiple buffers to avoid flush.
*/
UPDATE_LOCK( mmesa, DRM_LOCK_FLUSH | DRM_LOCK_QUIESCENT );
pixels = (void *)((char *) pixels + rows * pitch);
height -= rows;
y += rows;
} while (height);
/* mgaReleaseBufLocked( mmesa, buf ); */
}
UNLOCK_HARDWARE( mmesa );
mmesa->dirty |= MGA_UPLOAD_CLIPRECTS;
return GL_TRUE;
}
static GLboolean
mgaTryReadPixels( GLcontext *ctx,
GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type,
const struct gl_pixelstore_attrib *pack,
GLvoid *pixels )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLint size, skipPixels, skipRows;
GLint pitch = pack->RowLength ? pack->RowLength : width;
GLboolean ok;
GLuint planemask;
GLuint source;
#if 0
drmMGABlit blit;
GLuint dest;
GLint source_pitch, dest_pitch;
GLint delta_sx, delta_sy;
GLint delta_dx, delta_dy;
GLint blit_height, ydir;
#endif
if (!clip_pixelrect(ctx, ctx->ReadBuffer,
&x, &y, &width, &height,
&skipPixels, &skipRows, &size)) {
return GL_TRUE;
}
/* Only accelerate reading to agp buffers.
*/
if ( !IS_AGP_MEM(mmesa, (char *)pixels) ||
!IS_AGP_MEM(mmesa, (char *)pixels + size) )
return GL_FALSE;
switch (format) {
#if defined(MESA_packed_depth_stencil)
case GL_DEPTH_STENCIL_MESA:
ok = check_depth_stencil_24_8(ctx, type, pack, pixels, size, pitch);
planemask = ~0;
source = mmesa->mgaScreen->depthOffset;
break;
#endif
case GL_DEPTH_COMPONENT:
ok = check_depth(ctx, type, pack, pixels, size, pitch);
/* Can't accelerate at this depth -- planemask does the wrong
* thing; it doesn't clear the low order bits in the
* destination, instead it leaves them untouched.
*
* Could get the acclerator to solid fill the destination with
* zeros first... Or get the cpu to do it...
*/
if (ctx->Visual.depthBits == 24)
return GL_FALSE;
planemask = ~0;
source = mmesa->mgaScreen->depthOffset;
break;
case GL_RGB:
case GL_BGRA:
ok = check_color(ctx, type, format, pack, pixels, size, pitch);
planemask = ~0;
source = (mmesa->draw_buffer == MGA_FRONT ?
mmesa->mgaScreen->frontOffset :
mmesa->mgaScreen->backOffset);
break;
default:
return GL_FALSE;
}
if (!ok) {
return GL_FALSE;
}
LOCK_HARDWARE( mmesa );
#if 0
{
__DRIdrawablePrivate *dPriv = mmesa->driDrawable;
int nbox, retcode, i;
UPDATE_LOCK( mmesa, DRM_LOCK_FLUSH | DRM_LOCK_QUIESCENT );
if (mmesa->dirty_cliprects & MGA_FRONT)
mgaUpdateRects( mmesa, MGA_FRONT );
nbox = dPriv->numClipRects;
y = dPriv->h - y - height;
x += mmesa->drawX;
y += mmesa->drawY;
dest = ((mmesa->mgaScreen->agp.handle + AGP_OFFSET(mmesa, pixels)) |
DO_dstmap_sys | DO_dstacc_agp);
source_pitch = mmesa->mgaScreen->frontPitch / mmesa->mgaScreen->cpp;
dest_pitch = pitch;
delta_sx = 0;
delta_sy = 0;
delta_dx = -x;
delta_dy = -y;
blit_height = 2*y + height;
ydir = -1;
if (0) fprintf(stderr, "XX doing readpixel blit src_pitch %d dst_pitch %d\n",
source_pitch, dest_pitch);
for (i = 0 ; i < nbox ; )
{
int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, dPriv->numClipRects);
XF86DRIClipRectRec *box = dPriv->pClipRects;
drm_clip_rect_t *b = mmesa->sarea->boxes;
int n = 0;
for ( ; i < nr ; i++) {
GLint bx = box[i].x1;
GLint by = box[i].y1;
GLint bw = box[i].x2 - bx;
GLint bh = box[i].y2 - by;
if (bx < x) bw -= x - bx, bx = x;
if (by < y) bh -= y - by, by = y;
if (bx + bw > x + width) bw = x + width - bx;
if (by + bh > y + height) bh = y + height - by;
if (bw <= 0) continue;
if (bh <= 0) continue;
b->x1 = bx;
b->y1 = by;
b->x2 = bx + bw;
b->y2 = by + bh;
b++;
n++;
}
mmesa->sarea->nbox = n;
if (n && (retcode = drmCommandWrite( mmesa->driFd, DRM_MGA_BLIT,
&blit, sizeof(drmMGABlit)))) {
fprintf(stderr, "blit ioctl failed, retcode = %d\n", retcode);
UNLOCK_HARDWARE( mmesa );
exit(1);
}
}
UPDATE_LOCK( mmesa, DRM_LOCK_FLUSH | DRM_LOCK_QUIESCENT );
}
#endif
UNLOCK_HARDWARE( mmesa );
return GL_TRUE;
}
