static void __ast_free_region(void *ptr, const char *file, int lineno, const char *func)
{
struct ast_region *reg;
if (!ptr) {
return;
}
reg = region_remove(ptr);
if (reg) {
region_check_fences(reg);
if (reg->len <= MINNOWS_MAX_SIZE) {
region_free(&minnows, reg);
} else {
region_free(&whales, reg);
}
} else {
/*
* This memory region is not registered. It could be because of
* a double free or the memory block was not allocated by the
* malloc debug code.
*/
astmm_log("WARNING: Freeing unregistered memory %p by %s %s() line %d\n",
ptr, file, func, lineno);
my_do_crash();
}
}
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 );
}
LOCAL TBOOL fbp_copyarea(struct rfb_Display *mod, struct rfb_Window *v,
TINT dx, TINT dy, TINT dr[4], struct THook *exposehook)
{
if (v->rfbw_ClipRect.r[0] < 0 || !region_intersect(dr, v->rfbw_ClipRect.r))
return TFALSE;
TBOOL check_expose = fbp_copyarea_int(mod, v, dx, dy, dr);
if (check_expose && exposehook)
{
struct RectPool *pool = &mod->rfb_RectPool;
struct Region R, L;
if (rfb_getlayers(mod, &R, v, 0, 0))
{
if (rfb_getlayers(mod, &L, v, dx, dy))
{
if (region_subregion(pool, &L, &R) &&
region_andrect(pool, &L, dr, 0, 0))
fbp_doexpose(mod, v, &L, exposehook);
region_free(pool, &L);
}
region_free(pool, &R);
}
}
return check_expose;
}
LOCAL void fbp_drawbuffer(struct rfb_Display *mod, struct rfb_Window *v,
struct TVPixBuf *src, TINT rect[4], TBOOL alpha)
{
struct Region R;
if (!rfb_getlayermask(mod, &R, v->rfbw_ClipRect.r, v, 0, 0))
return;
region_andrect(&mod->rfb_RectPool, &R, rect, 0, 0);
struct TNode *next, *node = R.rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *r = (struct RectNode *) node;
rfb_markdirty(mod, v, r->rn_Rect);
TINT x0 = r->rn_Rect[0];
TINT y0 = r->rn_Rect[1];
TINT x1 = r->rn_Rect[2];
TINT y1 = r->rn_Rect[3];
TINT sx = x0 - rect[0];
TINT sy = y0 - rect[1];
pixconv_convert(src, &v->rfbw_PixBuf, x0, y0, x1, y1, sx, sy, alpha,
0);
}
region_free(&mod->rfb_RectPool, &R);
}
void clearDelayed() {
ListNode *n = envToClear.head;
while ( n != NULL ) {
/* deleteEnv((Env *) n->value, 1); */
listRemoveNoRegion( &envToClear, n );
n = envToClear.head;
}
n = hashtablesToClear.head;
while ( n != NULL ) {
deleteHashTable( ( Hashtable * ) n->value, nop );
listRemoveNoRegion( &hashtablesToClear, n );
n = hashtablesToClear.head;
}
n = regionsToClear.head;
while ( n != NULL ) {
region_free( ( Region * ) n->value );
listRemoveNoRegion( ®ionsToClear, n );
n = regionsToClear.head;
}
n = memoryToFree.head;
while ( n != NULL ) {
free( n->value );
listRemoveNoRegion( &memoryToFree, n );
n = memoryToFree.head;
}
}
static int
do_free(vm_map_t map, void *addr)
{
struct region *reg;
addr = (void *)PAGE_TRUNC(addr);
/*
* Find the target region.
*/
reg = region_find(&map->head, addr, 1);
if (reg == NULL || reg->addr != addr || (reg->flags & REG_FREE))
return EINVAL;
/*
* Unmap pages of the region.
*/
mmu_map(map->pgd, reg->phys, reg->addr, reg->size, PG_UNMAP);
/*
* Relinquish use of the page if it is not shared and mapped.
*/
if (!(reg->flags & REG_SHARED) && !(reg->flags & REG_MAPPED))
page_free(reg->phys, reg->size);
region_free(&map->head, reg);
return 0;
}
LOCAL void fbp_drawfrect(struct rfb_Display *mod, struct rfb_Window *v,
TINT rect[4], struct rfb_Pen *pen)
{
struct Region R;
if (!rfb_getlayermask(mod, &R, v->rfbw_ClipRect.r, v, 0, 0))
return;
region_andrect(&mod->rfb_RectPool, &R, rect, 0, 0);
TINT y;
TUINT dfmt = v->rfbw_PixBuf.tpb_Format;
TUINT p = pixconv_rgbfmt(dfmt, pen->rgb);
struct TNode *next, *node = R.rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *r = (struct RectNode *) node;
rfb_markdirty(mod, v, r->rn_Rect);
TINT x0 = r->rn_Rect[0];
TINT y0 = r->rn_Rect[1];
TINT x1 = r->rn_Rect[2];
TINT y1 = r->rn_Rect[3];
TUINT8 *buf = TVPB_GETADDRESS(&v->rfbw_PixBuf, x0, y0);
for (y = y0; y <= y1; y++, buf += v->rfbw_PixBuf.tpb_BytesPerLine)
pixconv_line_set(buf, dfmt, x1 - x0 + 1, p);
}
region_free(&mod->rfb_RectPool, &R);
}
/* 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;
}
void print_args(struct cap_args args)
{
region_t r = region_make();
fprintf(stderr, "%i caps, %i FDs, data:\n", args.caps.size, args.fds.count);
fprint_data(stderr, flatten_reuse(r, args.data));
region_free(r);
}
static void rfb_exittask(struct rfb_Display *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
struct TNode *imsg, *node, *next;
#if defined(ENABLE_LINUXFB)
rfb_linux_exit(mod);
#endif
TFree(mod->rfb_PtrBackBuffer.data);
if (mod->rfb_Flags & RFBFL_PTR_ALLOCATED)
TFree(mod->rfb_PtrImage.tpb_Data);
/* free pooled input messages: */
while ((imsg = TRemHead(&mod->rfb_IMsgPool)))
TFree(imsg);
/* close all fonts */
node = mod->rfb_FontManager.openfonts.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
rfb_hostclosefont(mod, (TAPTR) node);
if (mod->rfb_Flags & RFBFL_BUFFER_OWNER)
TFree(mod->rfb_PixBuf.tpb_Data);
TDestroy(mod->rfb_RndIMsgPort);
TFree(mod->rfb_RndRequest);
TCloseModule(mod->rfb_RndDevice);
TDestroy((struct THandle *) mod->rfb_RndRPort);
TDestroy((struct THandle *) mod->rfb_InstanceLock);
region_free(&mod->rfb_RectPool, &mod->rfb_DirtyRegion);
region_destroypool(&mod->rfb_RectPool);
}
void
region_test_truncate()
{
header();
struct region region;
region_create(®ion, &cache);
void *ptr = region_alloc(®ion, 10);
fail_unless(ptr);
size_t used = region_used(®ion);
region_alloc(®ion, 10000);
region_alloc(®ion, 10000000);
region_truncate(®ion, used);
fail_unless(region_used(®ion) == used);
region_free(®ion);
footer();
}
int my_fstat(int type, int fd, void *buf)
{
log_msg(MOD_MSG "fstat\n");
plash_libc_lock();
if(0 <= fd && fd < g_fds_size && g_fds[fd].fd_dir_obj) {
/* Handle directory FDs specially: send a message. */
cap_t dir_obj = g_fds[fd].fd_dir_obj;
region_t r = region_make();
cap_t fs_op_server;
struct cap_args result;
int rc = -1;
log_fd(fd, "fstat on directory");
if(!buf) {
__set_errno(EINVAL);
goto exit;
}
if(libc_get_fs_op(&fs_op_server) < 0)
goto exit;
cap_call(fs_op_server, r,
cap_args_dc(mk_int(r, METHOD_FSOP_DIR_FSTAT),
mk_caps1(r, inc_ref(dir_obj))),
&result);
{
seqf_t msg = flatten_reuse(r, result.data);
int ok = 1;
m_int_const(&ok, &msg, METHOD_R_FSOP_STAT);
m_stat_info(&ok, &msg, type, buf);
m_end(&ok, &msg);
if(ok && result.fds.count == 0 && result.caps.size == 0) {
rc = 0;
goto exit;
}
}
pl_args_free(&result);
set_errno_from_reply(flatten_reuse(r, result.data));
exit:
plash_libc_unlock();
region_free(r);
return rc;
}
else {
plash_libc_unlock();
/* Use the normal fstat system call. */
log_fd(fd, "normal fstat");
if(type == TYPE_STAT) {
return kernel_fxstat(_STAT_VER, fd, (struct stat *) buf);
}
else if(type == TYPE_STAT64) {
return kernel_fxstat64(_STAT_VER, fd, (struct stat64 *) buf);
}
else {
/* Don't recognise ABI version requested. */
__set_errno(ENOSYS);
return -1;
}
}
}
static void
ts_free(void)
{
ts_options_free(&tss.opts);
ts_space_free(&tss.s);
ts_reftable_free(&tss.rt);
region_free(&tss.ra);
slab_cache_destroy(&tss.sc);
}
static int
do_allocate(vm_map_t map, void **addr, size_t size, int anywhere)
{
struct region *reg;
char *start, *end, *phys;
if (size == 0)
return EINVAL;
/*
* Allocate region
*/
if (anywhere) {
size = (size_t)PAGE_ALIGN(size);
if ((reg = region_alloc(&map->head, size)) == NULL)
return ENOMEM;
} else {
start = (char *)PAGE_TRUNC(*addr);
end = (char *)PAGE_ALIGN(start + size);
size = (size_t)(end - start);
reg = region_find(&map->head, start, size);
if (reg == NULL || !(reg->flags & REG_FREE))
return EINVAL;
reg = region_split(&map->head, reg, start, size);
if (reg == NULL)
return ENOMEM;
}
reg->flags = REG_READ | REG_WRITE;
/*
* Allocate physical pages, and map them into virtual address
*/
if ((phys = page_alloc(size)) == 0)
goto err1;
if (mmu_map(map->pgd, phys, reg->addr, size, PG_WRITE))
goto err2;
reg->phys = phys;
/* Zero fill */
memset(phys_to_virt(phys), 0, reg->size);
*addr = reg->addr;
return 0;
err2:
page_free(phys, size);
err1:
region_free(&map->head, reg);
return ENOMEM;
}
LOCAL TBOOL rfb_getlayermask(struct rfb_Display *mod, struct Region *A,
TINT *crect, struct rfb_Window *v, TINT dx, TINT dy)
{
if (crect[0] < 0)
return TFALSE;
struct RectPool *pool = &mod->rfb_RectPool;
if (!region_init(pool, A, crect))
return TFALSE;
if (v->rfbw_Flags & RFBWFL_BACKBUFFER)
return TTRUE;
TBOOL success = TFALSE;
struct Region L;
if (rfb_getlayers(mod, &L, v, dx, dy))
{
success = region_subregion(pool, A, &L);
region_free(pool, &L);
}
if (!success)
region_free(pool, A);
return success;
}
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;
}
/* nofollow=0 for stat, nofollow=1 for lstat. */
int my_statat(int dir_fd, int nofollow, int type, const char *pathname,
void *buf)
{
region_t r = region_make();
cap_t fs_op_server;
cap_t dir_obj;
struct cap_args result;
int rc = -1;
plash_libc_lock();
log_msg(MOD_MSG "stat\n");
if(!pathname || !buf) {
__set_errno(EINVAL);
goto error;
}
if(libc_get_fs_op(&fs_op_server) < 0)
goto error;
if(fds_get_dir_obj(dir_fd, &dir_obj) < 0)
goto error;
cap_call(fs_op_server, r,
pl_pack(r, METHOD_FSOP_STAT, "diS", dir_obj, nofollow,
seqf_string(pathname)),
&result);
seqf_t reply = flatten_reuse(r, result.data);
pl_args_free(&result);
{
seqf_t msg = reply;
int ok = 1;
m_int_const(&ok, &msg, METHOD_R_FSOP_STAT);
m_stat_info(&ok, &msg, type, buf);
m_end(&ok, &msg);
if(ok) {
rc = 0;
goto error;
}
}
set_errno_from_reply(reply);
error:
plash_libc_unlock();
region_free(r);
return rc;
}
void
region_basic()
{
header();
struct region region;
region_create(®ion, &cache);
fail_unless(region_used(®ion) == 0);
void *ptr = region_alloc(®ion, 10);
fail_unless(ptr);
fail_unless(region_used(®ion) == 10);
ptr = region_alloc(®ion, 10000000);
fail_unless(ptr);
fail_unless(region_used(®ion) == 10000010);
region_free(®ion);
fail_unless(region_used(®ion) == 0);
printf("name of a new region: %s.\n", region_name(®ion));
region_set_name(®ion, "region");
printf("set new region name: %s.\n", region_name(®ion));
region_set_name(®ion, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
printf("region name is truncated: %s.\n", region_name(®ion));
footer();
}
/*
* Sprit region for the specified address/size.
*/
static struct region *
region_split(struct region *head, struct region *reg, void *addr,
size_t size)
{
struct region *prev, *next;
size_t diff;
/*
* Check previous region to split region.
*/
prev = NULL;
if (reg->addr != addr) {
prev = reg;
diff = (size_t)((char *)addr - (char *)reg->addr);
reg = region_create(prev, addr, prev->size - diff);
if (reg == NULL)
return NULL;
prev->size = diff;
}
/*
* Check next region to split region.
*/
if (reg->size != size) {
next = region_create(reg, (char *)reg->addr + size,
reg->size - size);
if (next == NULL) {
if (prev) {
/* Undo previous region_create() */
region_free(head, reg);
}
return NULL;
}
reg->size = size;
}
reg->flags = 0;
return reg;
}
static int
do_free(vm_map_t map, void *addr)
{
struct region *reg;
addr = (void *)PAGE_TRUNC(addr);
/*
* Find the target region.
*/
reg = region_find(&map->head, addr, 1);
if (reg == NULL || reg->addr != addr || (reg->flags & REG_FREE))
return EINVAL; /* not allocated */
/*
* Free pages if it is not shared and mapped.
*/
if (!(reg->flags & REG_SHARED) && !(reg->flags & REG_MAPPED))
page_free(reg->addr, reg->size);
region_free(&map->head, reg);
return 0;
}
LOCAL TBOOL rfb_getlayers(struct rfb_Display *mod, struct Region *A,
struct rfb_Window *v, TINT dx, TINT dy)
{
struct RectPool *pool = &mod->rfb_RectPool;
region_init(pool, A, TNULL);
struct TNode *next, *node = mod->rfb_VisualList.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct rfb_Window *bv = (struct rfb_Window *) node;
if (bv == v)
break;
if (!region_orrect(pool, A, bv->rfbw_ScreenRect.r, TFALSE))
{
region_free(pool, A);
return TFALSE;
}
}
if (dx || dy)
region_shift(A, dx, dy);
return TTRUE;
}
static int
do_map(vm_map_t map, void *addr, size_t size, void **alloc)
{
vm_map_t curmap;
char *start, *end, *phys;
size_t offset;
struct region *reg, *cur, *tgt;
task_t self;
int map_type;
void *tmp;
if (size == 0)
return EINVAL;
/* check fault */
tmp = NULL;
if (umem_copyout(&tmp, alloc, sizeof(tmp)))
return EFAULT;
start = (char *)PAGE_TRUNC(addr);
end = (char *)PAGE_ALIGN((char *)addr + size);
size = (size_t)(end - start);
offset = (size_t)((char *)addr - start);
/*
* Find the region that includes target address
*/
reg = region_find(&map->head, start, size);
if (reg == NULL || (reg->flags & REG_FREE))
return EINVAL; /* not allocated */
tgt = reg;
/*
* Find the free region in current task
*/
self = cur_task();
curmap = self->map;
if ((reg = region_alloc(&curmap->head, size)) == NULL)
return ENOMEM;
cur = reg;
/*
* Try to map into current memory
*/
if (tgt->flags & REG_WRITE)
map_type = PG_WRITE;
else
map_type = PG_READ;
phys = (char *)tgt->phys + (start - (char *)tgt->addr);
if (mmu_map(curmap->pgd, phys, cur->addr, size, map_type)) {
region_free(&curmap->head, reg);
return ENOMEM;
}
cur->flags = tgt->flags | REG_MAPPED;
cur->phys = phys;
tmp = (char *)cur->addr + offset;
umem_copyout(&tmp, alloc, sizeof(tmp));
return 0;
}
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;
}
LOCAL TBOOL rfb_damage(struct rfb_Display *mod, TINT drect[],
struct rfb_Window *v)
{
TAPTR TExecBase = TGetExecBase(mod);
struct RectPool *pool = &mod->rfb_RectPool;
struct Region A, B;
if (!region_init(pool, &A, drect))
return TFALSE;
TDBPRINTF(TDB_TRACE, ("incoming damage: %d %d %d %d\n",
drect[0], drect[1], drect[2], drect[3]));
/* traverse window stack; refresh B where A and B overlap ; A = A - B */
struct TNode *next, *node = mod->rfb_VisualList.tlh_Head.tln_Succ;
TBOOL success = TTRUE;
TBOOL below = TFALSE;
TLock(mod->rfb_InstanceLock);
for (; success && !region_isempty(pool, &A) &&
(next = node->tln_Succ); node = next)
{
struct rfb_Window *bv = (struct rfb_Window *) node;
if (v && !below)
{
if (bv == v)
below = TTRUE;
else
/* above: subtract current from rect to be damaged: */
success = region_subrect(pool, &A, bv->rfbw_ScreenRect.r);
continue;
}
success = TFALSE;
if (region_init(pool, &B, bv->rfbw_ScreenRect.r))
{
if (region_andregion(pool, &B, &A))
{
region_shift(&B,
bv->rfbw_WinRect.r[0] - bv->rfbw_ScreenRect.r[0],
bv->rfbw_WinRect.r[1] - bv->rfbw_ScreenRect.r[1]);
struct TNode *next,
*node = B.rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *r = (struct RectNode *) node;
if (bv->rfbw_Flags & RFBWFL_BACKBUFFER)
{
rfb_markdirty(mod, bv, r->rn_Rect);
}
else if (bv->rfbw_InputMask & TITYPE_REFRESH)
{
TIMSG *imsg;
if (rfb_getimsg(mod, bv, &imsg, TITYPE_REFRESH))
{
TDBPRINTF(TDB_TRACE, ("send refresh %d %d %d %d\n",
r->rn_Rect[0], r->rn_Rect[1],
r->rn_Rect[2], r->rn_Rect[3]));
imsg->timsg_X = r->rn_Rect[0];
imsg->timsg_Y = r->rn_Rect[1];
imsg->timsg_Width =
r->rn_Rect[2] - r->rn_Rect[0] + 1;
imsg->timsg_Height =
r->rn_Rect[3] - r->rn_Rect[1] + 1;
imsg->timsg_X -= bv->rfbw_ScreenRect.r[0];
imsg->timsg_Y -= bv->rfbw_ScreenRect.r[1];
TPutMsg(bv->rfbw_IMsgPort, TNULL, imsg);
}
}
}
success = TTRUE;
}
region_free(pool, &B);
}
if (success)
success = region_subrect(pool, &A, bv->rfbw_ScreenRect.r);
}
TUnlock(mod->rfb_InstanceLock);
region_free(pool, &A);
return success;
}
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;
}
LOCAL void rfb_flush_clients(struct rfb_Display *mod, TBOOL also_external)
{
TAPTR TExecBase = mod->rfb_ExecBase;
struct RectPool *pool = &mod->rfb_RectPool;
/* flush windows to buffer */
/* screen mask: */
struct Rect s;
REGION_RECT_SET(&s, 0, 0, mod->rfb_Width - 1, mod->rfb_Height - 1);
struct Region S;
if (region_init(pool, &S, s.r))
{
struct TNode *next, *node = mod->rfb_VisualList.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct rfb_Window *v = (struct rfb_Window *) node;
if (v->rfbw_Flags & RFBWFL_DIRTY)
{
struct Region *R = &v->rfbw_DirtyRegion;
TINT sx = v->rfbw_ScreenRect.r[0];
TINT sy = v->rfbw_ScreenRect.r[1];
region_shift(R, sx, sy);
region_andregion(pool, R, &S);
struct TNode *rnext, *rnode =
R->rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (rnext = rnode->tln_Succ); rnode = rnext)
{
struct RectNode *r = (struct RectNode *) rnode;
TINT x0 = r->rn_Rect[0];
TINT y0 = r->rn_Rect[1];
TINT x1 = r->rn_Rect[2];
TINT y1 = r->rn_Rect[3];
pixconv_convert(&v->rfbw_PixBuf, &mod->rfb_PixBuf,
x0, y0, x1, y1, x0 - sx, y0 - sy, TFALSE, TFALSE);
region_orrect(pool, &mod->rfb_DirtyRegion, r->rn_Rect,
TTRUE);
mod->rfb_Flags |= RFBFL_DIRTY;
}
region_free(pool, R);
v->rfbw_Flags &= ~RFBWFL_DIRTY;
}
/* subtract this window from screenmask: */
region_subrect(pool, &S, v->rfbw_ScreenRect.r);
}
region_free(pool, &S);
}
/* flush buffer to device(s) */
if (mod->rfb_Flags & RFBFL_DIRTY)
{
struct Region *D = &mod->rfb_DirtyRegion;
struct TNode *next, *node;
#if defined(ENABLE_VNCSERVER)
if (also_external && mod->rfb_VNCTask)
rfb_vnc_flush(mod, D);
#endif
/* flush to sub pixbuf: */
if (mod->rfb_Flags & RFBFL_BUFFER_DEVICE)
{
node = D->rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *r = (struct RectNode *) node;
TINT x0 = r->rn_Rect[0];
TINT y0 = r->rn_Rect[1];
TINT x1 = r->rn_Rect[2];
TINT y1 = r->rn_Rect[3];
pixconv_convert(&mod->rfb_PixBuf, &mod->rfb_DevBuf,
x0, y0, x1, y1, x0, y0, TFALSE, TFALSE);
}
}
/* flush to sub device: */
if (mod->rfb_RndDevice)
{
TTAGITEM tags[2];
tags[0].tti_Tag = TVisual_PixelFormat;
tags[0].tti_Value = mod->rfb_PixBuf.tpb_Format;
tags[1].tti_Tag = TTAG_DONE;
/* NOTE: do multiple flushes asynchronously? */
struct TVRequest *req = mod->rfb_RndRequest;
req->tvr_Req.io_Command = TVCMD_DRAWBUFFER;
req->tvr_Op.DrawBuffer.Window = mod->rfb_RndInstance;
req->tvr_Op.DrawBuffer.Tags = tags;
req->tvr_Op.DrawBuffer.TotWidth = mod->rfb_Width;
node = D->rg_Rects.rl_List.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct RectNode *r = (struct RectNode *) node;
TINT x0 = r->rn_Rect[0];
TINT y0 = r->rn_Rect[1];
TINT x1 = r->rn_Rect[2];
TINT y1 = r->rn_Rect[3];
req->tvr_Op.DrawBuffer.RRect[0] = x0;
req->tvr_Op.DrawBuffer.RRect[1] = y0;
req->tvr_Op.DrawBuffer.RRect[2] = x1 - x0 + 1;
req->tvr_Op.DrawBuffer.RRect[3] = y1 - y0 + 1;
req->tvr_Op.DrawBuffer.Buf =
TVPB_GETADDRESS(&mod->rfb_PixBuf, x0, y0);
TDoIO(&req->tvr_Req);
}
req->tvr_Req.io_Command = TVCMD_FLUSH;
req->tvr_Op.Flush.Window = mod->rfb_RndInstance;
req->tvr_Op.Flush.Rect[0] = 0;
req->tvr_Op.Flush.Rect[1] = 0;
req->tvr_Op.Flush.Rect[2] = -1;
req->tvr_Op.Flush.Rect[3] = -1;
TDoIO(&req->tvr_Req);
}
region_free(&mod->rfb_RectPool, D);
mod->rfb_Flags &= ~RFBFL_DIRTY;
}
}
LOCAL TBOOL fbp_copyarea_int(struct rfb_Display *mod, struct rfb_Window *v,
TINT dx, TINT dy, TINT *dr)
{
struct RectPool *pool = &mod->rfb_RectPool;
struct Region R;
if (!rfb_getlayermask(mod, &R, dr, v, 0, 0))
return TFALSE;
if (R.rg_Rects.rl_NumNodes == 0)
{
region_free(pool, &R);
return TFALSE;
}
TINT yinc = dy < 0 ? -1 : 1;
TINT y, i, h;
TINT dy0 = dr[1];
TINT dy1 = dr[3];
h = dy1 - dy0 + 1;
if (yinc > 0)
{
TINT t = dy0;
dy0 = dy1;
dy1 = t;
}
TINT bpp = TVPIXFMT_BYTES_PER_PIXEL(v->rfbw_PixBuf.tpb_Format);
if (R.rg_Rects.rl_NumNodes == 1)
{
/* optimization for a single rectangle */
struct RectNode *rn =
(struct RectNode *) TFIRSTNODE(&R.rg_Rects.rl_List);
TINT x0 = rn->rn_Rect[0];
TINT y0 = rn->rn_Rect[1];
TINT x1 = rn->rn_Rect[2];
TINT y1 = rn->rn_Rect[3];
h = y1 - y0 + 1;
dy0 = y0;
dy1 = y1;
if (yinc > 0)
{
TINT t = dy0;
dy0 = dy1;
dy1 = t;
}
#if defined(ENABLE_VNCSERVER)
if (mod->rfb_VNCTask && !(v->rfbw_Flags & RFBWFL_BACKBUFFER))
rfb_vnc_copyrect(mod, v, dx, dy, x0, y0, x1, y1, yinc);
else
#endif
{
/* update own buffer */
for (i = 0, y = dy0; i < h; ++i, y -= yinc)
CopyLineOver(v, x0 - dx, y - dy, x0, y, (x1 - x0 + 1) * bpp);
}
/* update sub device */
TINT d[4];
d[0] = rn->rn_Rect[0];
d[1] = rn->rn_Rect[1];
d[2] = rn->rn_Rect[2];
d[3] = rn->rn_Rect[3];
if (v->rfbw_Flags & RFBWFL_BACKBUFFER)
rfb_markdirty(mod, v, d);
else
rfb_copyrect_sub(mod, d, dx, dy);
}
else
{
struct TNode *n;
struct TList r, t;
TInitList(&r);
TInitList(&t);
while ((n = TRemHead(&R.rg_Rects.rl_List)))
TAddTail(&r, n);
for (i = 0, y = dy0; i < h; ++i, y -= yinc)
{
struct TNode *rnext, *rnode = r.tlh_Head.tln_Succ;
for (; (rnext = rnode->tln_Succ); rnode = rnext)
{
struct RectNode *rn = (struct RectNode *) rnode;
if (y >= rn->rn_Rect[1] && y <= rn->rn_Rect[3])
{
struct TNode *prednode = TNULL;
struct TNode *tnext, *tnode = t.tlh_Head.tln_Succ;
for (; (tnext = tnode->tln_Succ); tnode = tnext)
{
struct RectNode *tn = (struct RectNode *) tnode;
if (rn->rn_Rect[2] < tn->rn_Rect[0])
break;
prednode = tnode;
}
TRemove(rnode);
TInsert(&t, rnode, prednode); /* insert after prednode */
}
}
while (!TISLISTEMPTY(&t))
{
TINT x0, x1;
if (dx < 0)
{
struct RectNode *E = (struct RectNode *) TRemHead(&t);
x0 = E->rn_Rect[0];
x1 = E->rn_Rect[2];
TAddTail(&r, &E->rn_Node);
while (!TISLISTEMPTY(&t))
{
struct RectNode *N =
(struct RectNode *) TFIRSTNODE(&t);
if (N->rn_Rect[0] == x1 + 1)
{
x1 = N->rn_Rect[2];
TAddTail(&r, TRemHead(&t));
continue;
}
break;
}
}
else
{
struct RectNode *E = (struct RectNode *) TRemTail(&t);
x0 = E->rn_Rect[0];
x1 = E->rn_Rect[2];
TAddTail(&r, &E->rn_Node);
while (!TISLISTEMPTY(&t))
{
struct RectNode *N = (struct RectNode *) TLASTNODE(&t);
if (N->rn_Rect[2] == x0 - 1)
{
x0 = N->rn_Rect[0];
TAddTail(&r, TRemTail(&t));
continue;
}
break;
}
}
CopyLineOver(v, x0 - dx, y - dy, x0, y, (x1 - x0 + 1) * bpp);
}
}
while ((n = TRemHead(&r)))
{
struct RectNode *rn = (struct RectNode *) n;
/* this would be incorrect, unfortunately: */
/* rfb_copyrect_sub(mod, rn->rn_Rect, dx, dy); */
rfb_markdirty(mod, v, rn->rn_Rect);
TAddTail(&R.rg_Rects.rl_List, n);
}
}
region_free(pool, &R);
return TTRUE; /* do expose */
}
~all_resources() {
for(auto itr= begin(myArgv);itr != end(myArgv); ++itr) {
clearMsParam(*itr, 1);
}
region_free(rNew);
}
static void rfb_processevent(struct rfb_Display *mod)
{
TAPTR TExecBase = TGetExecBase(mod);
TIMSG *msg;
if (mod->rfb_RndIMsgPort == TNULL)
return;
while ((msg = TGetMsg(mod->rfb_RndIMsgPort)))
{
/*struct rfb_Window *v = (struct rfb_Window *) msg->timsg_Instance; */
TIMSG *imsg;
switch (msg->timsg_Type)
{
case TITYPE_INTERVAL:
TDBPRINTF(TDB_WARN, ("unhandled event: INTERVAL\n"));
break;
case TITYPE_REFRESH:
{
TINT drect[4];
drect[0] = msg->timsg_X;
drect[1] = msg->timsg_Y;
drect[2] = msg->timsg_X + msg->timsg_Width - 1;
drect[3] = msg->timsg_Y + msg->timsg_Height - 1;
rfb_damage(mod, drect, TNULL);
rfb_flush_clients(mod, TTRUE);
break;
}
case TITYPE_NEWSIZE:
if ((mod->rfb_Flags & RFBFL_BUFFER_OWNER) &&
(mod->rfb_Flags & RFBFL_BUFFER_CAN_RESIZE))
{
region_free(&mod->rfb_RectPool, &mod->rfb_DirtyRegion);
mod->rfb_Flags &= ~RFBFL_DIRTY;
TINT neww = mod->rfb_Width = msg->timsg_Width;
TINT newh = mod->rfb_Height = msg->timsg_Height;
TUINT pixfmt = mod->rfb_PixBuf.tpb_Format;
TUINT bpp = TVPIXFMT_BYTES_PER_PIXEL(pixfmt);
TUINT bpl = bpp * neww;
struct TVPixBuf newbuf;
newbuf.tpb_BytesPerLine = bpl;
newbuf.tpb_Format = mod->rfb_PixBuf.tpb_Format;
newbuf.tpb_Data = TAlloc(mod->rfb_MemMgr, bpl * newh);
if (newbuf.tpb_Data == TNULL)
break;
struct TNode *next,
*node = mod->rfb_VisualList.tlh_Head.tln_Succ;
for (; (next = node->tln_Succ); node = next)
{
struct rfb_Window *v = (struct rfb_Window *) node;
rfb_setrealcliprect(mod, v);
TINT w0 = REGION_RECT_WIDTH(&v->rfbw_ScreenRect);
TINT h0 = REGION_RECT_HEIGHT(&v->rfbw_ScreenRect);
if ((v->rfbw_Flags & RFBWFL_FULLSCREEN))
{
v->rfbw_ScreenRect.r[0] = 0;
v->rfbw_ScreenRect.r[1] = 0;
v->rfbw_ScreenRect.r[2] = neww - 1;
v->rfbw_ScreenRect.r[3] = newh - 1;
}
TINT ww = REGION_RECT_WIDTH(&v->rfbw_ScreenRect);
TINT wh = REGION_RECT_HEIGHT(&v->rfbw_ScreenRect);
if (v->rfbw_MinWidth > 0 && ww < v->rfbw_MinWidth)
v->rfbw_ScreenRect.r[0] =
v->rfbw_ScreenRect.r[2] - v->rfbw_MinWidth;
if (v->rfbw_MinHeight > 0 && wh < v->rfbw_MinHeight)
v->rfbw_ScreenRect.r[1] =
v->rfbw_ScreenRect.r[3] - v->rfbw_MinHeight;
ww = REGION_RECT_WIDTH(&v->rfbw_ScreenRect);
wh = REGION_RECT_HEIGHT(&v->rfbw_ScreenRect);
if (v->rfbw_Flags & RFBWFL_BACKBUFFER)
rfb_resizewinbuffer(mod, v, w0, h0, ww, wh);
else
v->rfbw_PixBuf = newbuf;
rfb_setwinrect(mod, v);
if (ww != w0 || wh != h0)
{
if (rfb_getimsg(mod, v, &imsg, TITYPE_NEWSIZE))
{
imsg->timsg_Width = ww;
imsg->timsg_Height = wh;
TPutMsg(v->rfbw_IMsgPort, TNULL, imsg);
}
}
}
TFree(mod->rfb_PixBuf.tpb_Data);
mod->rfb_PixBuf = newbuf;
struct Rect drect;
REGION_RECT_SET(&drect, 0, 0, neww - 1, newh - 1);
rfb_damage(mod, drect.r, TNULL);
}
else
TDBPRINTF(TDB_WARN, ("Cannot resize this framebuffer\n"));
break;
case TITYPE_CLOSE:
{
/* send to root window */
TLock(mod->rfb_InstanceLock);
struct rfb_Window *v =
(struct rfb_Window *) TLASTNODE(&mod->rfb_VisualList);
if (rfb_getimsg(mod, v, &imsg, TITYPE_CLOSE))
TPutMsg(v->rfbw_IMsgPort, TNULL, imsg);
TUnlock(mod->rfb_InstanceLock);
break;
}
case TITYPE_FOCUS:
TDBPRINTF(TDB_INFO, ("unhandled event: FOCUS\n"));
break;
case TITYPE_MOUSEOVER:
TDBPRINTF(TDB_INFO, ("unhandled event: MOUSEOVER\n"));
break;
case TITYPE_KEYUP:
case TITYPE_KEYDOWN:
rfb_passevent_keyboard(mod, msg);
break;
case TITYPE_MOUSEMOVE:
rfb_passevent_mousemove(mod, msg);
break;
case TITYPE_MOUSEBUTTON:
rfb_passevent_mousebutton(mod, msg);
break;
}
TReplyMsg(msg);
}
}
/* This is used by cow_dir too. */
int merge_dir_lists(region_t r,
struct filesys_obj *dir1,
struct filesys_obj *dir2,
seqt_t *result,
int *err)
{
int count1, count2;
seqt_t got;
seqf_t buf;
seqf_t *array1, *array2;
int i;
region_t r2 = region_make();
count1 = dir1->vtable->list(dir1, r2, &got, err);
if(count1 < 0) { region_free(r2); return -1; }
array1 = region_alloc(r2, count1 * sizeof(seqf_t));
buf = flatten(r, got);
for(i = 0; i < count1; i++) {
int inode, type;
seqf_t name;
int ok = 1;
m_int(&ok, &buf, &inode);
m_int(&ok, &buf, &type);
m_lenblock(&ok, &buf, &name);
if(ok) {
array1[i] = name;
}
else { region_free(r2); *err = EIO; return -1; }
}
count2 = dir2->vtable->list(dir2, r2, &got, err);
if(count2 < 0) { region_free(r2); return -1; }
array2 = region_alloc(r2, count2 * sizeof(seqf_t));
buf = flatten(r, got);
for(i = 0; i < count2; i++) {
int inode, type;
seqf_t name;
int ok = 1;
m_int(&ok, &buf, &inode);
m_int(&ok, &buf, &type);
m_lenblock(&ok, &buf, &name);
if(ok) {
array2[i] = name;
}
else { region_free(r2); *err = EIO; return -1; }
}
/* Sort the sequences to make it easy to merge them. */
qsort(array1, count1, sizeof(seqf_t), sort_seqf_compare);
qsort(array2, count2, sizeof(seqf_t), sort_seqf_compare);
/* Merge the two sequences. */
{
cbuf_t buf = cbuf_make(r, 100);
int count = 0;
int i1 = 0, i2 = 0;
while(1) {
int comp;
if(i1 < count1 && i2 < count2) {
comp = seqf_compare(array1[i1], array2[i2]);
}
else if(i1 < count1) comp = -1;
else if(i2 < count2) comp = 1;
else break;
cbuf_put_int(buf, 0); /* d_ino */
cbuf_put_int(buf, 0); /* d_type */
if(comp < 0) {
cbuf_put_int(buf, array1[i1].size);
cbuf_put_seqf(buf, array1[i1]);
i1++;
}
else if(comp > 0) {
cbuf_put_int(buf, array2[i2].size);
cbuf_put_seqf(buf, array2[i2]);
i2++;
}
else {
cbuf_put_int(buf, array1[i1].size);
cbuf_put_seqf(buf, array1[i1]);
i1++;
i2++;
}
count++;
}
*result = seqt_of_cbuf(buf);
region_free(r2);
return count;
}
}
