void map_client(client_t *c)
{
XWindowAttributes attr;
strut_t s = { 0, 0, 0, 0 };
XWMHints *hints;
int btn, want_raise = 1;
XGrabServer(dpy);
XGetWindowAttributes(dpy, c->win, &attr);
collect_struts(c, &s);
if (attr.map_state == IsViewable) {
c->ignore_unmap++;
reparent(c, &s);
if (get_wm_state(c->win) == IconicState) {
c->ignore_unmap++;
XUnmapWindow(dpy, c->win);
} else {
set_wm_state(c, NormalState);
do_map(c, want_raise);
}
} else {
if ((hints = XGetWMHints(dpy, c->win))) {
if (hints->flags & StateHint)
set_wm_state(c, hints->initial_state);
XFree(hints);
} else {
set_wm_state(c, NormalState);
}
if (!init_geom(c, &s) && opt_imap) {
btn = sweep(c, map_curs, recalc_map, SWEEP_DOWN, &s);
if (btn == Button2)
btn = sweep(c, resize_curs, recalc_resize, SWEEP_UP, &s);
if (btn == Button3)
want_raise = 0;
}
#ifdef DEBUG
dump_geom(c, "set to");
dump_info(c);
#endif
reparent(c, &s);
if (get_wm_state(c->win) == NormalState)
do_map(c, want_raise);
}
XSync(dpy, False);
c->name = get_wm_name(c->win); // horrible kludge
XUngrabServer(dpy);
}
void do_done(CHAR_DATA * ch, char * thedir)
{
CHAR_DATA *rch;
if(!ch->infight)
{
printf_to_char(ch,"You're not in a fight.");
return;
}
if(!TURN(ch))
{
printf_to_char(ch,"It's not your turn.");
return;
}
check_winner(ch->in_room);
for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room)
{
printf_to_char(rch,"%s ends %s turn.\n",fcn(ch), ch->sex ? "his" : "her");
do_map(rch,"forced");
rch->AT++;
}
ch->AT = 0;
advance_turn(ch);
}
/**
* vm_map - map another task's memory to current task.
*
* Note: This routine does not support mapping to the specific
* address.
*/
int
vm_map(task_t target, void *addr, size_t size, void **alloc)
{
int err;
sched_lock();
if (!task_valid(target)) {
err = ESRCH;
goto out;
}
if (target == cur_task()) {
err = EINVAL;
goto out;
}
if (!task_capable(CAP_MEMORY)) {
err = EPERM;
goto out;
}
if (!user_area(addr)) {
err = EFAULT;
goto out;
}
err = do_map(target->map, addr, size, alloc);
out:
sched_unlock();
return err;
}
/// Stop using 'keymap'.
static void keymap_unload(void)
{
char_u buf[KMAP_MAXLEN + 10];
char_u *save_cpo = p_cpo;
kmap_T *kp;
if (!(curbuf->b_kmap_state & KEYMAP_LOADED)) {
return;
}
// Set 'cpoptions' to "C" to avoid line continuation.
p_cpo = (char_u *)"C";
// clear the ":lmap"s
kp = (kmap_T *)curbuf->b_kmap_ga.ga_data;
for (int i = 0; i < curbuf->b_kmap_ga.ga_len; ++i) {
vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s", kp[i].from);
(void)do_map(1, buf, LANGMAP, FALSE);
xfree(kp[i].from);
xfree(kp[i].to);
}
p_cpo = save_cpo;
ga_clear(&curbuf->b_kmap_ga);
curbuf->b_kmap_state &= ~KEYMAP_LOADED;
status_redraw_curbuf();
}
mmap_t* CMMap::map_both(const char* filename, size_t size_max)
{
int fd = open(filename, O_RDONLY|O_WRONLY);
if (-1 == fd)
throw CSyscallException(errno, __FILE__, __LINE__);
return do_map(PROT_READ|PROT_WRITE, fd, 0, 0, size_max, false);
}
void advance_turn(CHAR_DATA * ch)
{
CHAR_DATA *rch;
int q=0;
for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room)
{
if(rch->infight)
q++;
}
if(q<1);
return;
check_winner(ch->in_room);
q = 0;
for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room)
{
if(rch == NULL || !rch->infight)
continue;
do_map(rch,"forced");
}
ch->in_room->next = NULL;
while(ch->in_room->next == NULL)
{
for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room)
{
if(rch == NULL || !rch->infight)
continue;
if(rch->ATToCast < rch->AT)
{
say_spell (rch, rch->SnToCast);
tile_spell(rch, rch->SnToCast);
rch->ATToCast = 0;
rch->SnToCast = 0;
rch->casting = FALSE;
rch->CastTargY = 0;
rch->CastTargX = 0;
}
rch->AT += rch->speed;
if(rch->AT >= 100)
{
rch->AT = 100;
ch->in_room->turn = rch;
break;
}
}
}
ch->in_room->turn->MoveLeft = ch->in_room->turn->base_move;
ch->in_room->turn->AttackLeft = 1;
printf_to_char(rch,"%s's turn.\n",fcn(ch->in_room->turn));
}
SYS_NAMESPACE_BEGIN
mmap_t* CMMap::map_read(const char* filename, size_t size_max)
{
int fd = open(filename, O_RDONLY);
if (-1 == fd)
throw CSyscallException(errno, __FILE__, __LINE__);
return do_map(PROT_READ, fd, 0, 0, size_max, false);
}
void
map_and_write (int fd, int map, char c)
{
char b[M_MAXMAP];
int n;
n = do_map(b, map, c);
if ( n )
if ( writen_ni(fd, b, n) < n )
fatal("write to stdout failed: %s", strerror(errno));
}
static errval_t refill_slabs(struct pmap_arm *pmap, size_t request)
{
errval_t err;
/* Keep looping till we have #request slabs */
while (slab_freecount(&pmap->slab) < request) {
// Amount of bytes required for #request
size_t bytes = SLAB_STATIC_SIZE(request - slab_freecount(&pmap->slab),
sizeof(struct vnode));
/* Get a frame of that size */
struct capref cap;
err = frame_alloc(&cap, bytes, &bytes);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_FRAME_ALLOC);
}
/* If we do not have enough slabs to map the frame in, recurse */
size_t required_slabs_for_frame = max_slabs_required(bytes);
if (slab_freecount(&pmap->slab) < required_slabs_for_frame) {
// If we recurse, we require more slabs than to map a single page
assert(required_slabs_for_frame > 4);
err = refill_slabs(pmap, required_slabs_for_frame);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_SLAB_REFILL);
}
}
/* Perform mapping */
genvaddr_t genvaddr = pmap->vregion_offset;
pmap->vregion_offset += (genvaddr_t)bytes;
// if this assert fires, increase META_DATA_RESERVED_SPACE
assert(pmap->vregion_offset < (vregion_get_base_addr(&pmap->vregion) +
vregion_get_size(&pmap->vregion)));
err = do_map(pmap, genvaddr, cap, 0, bytes,
VREGION_FLAGS_READ_WRITE, NULL, NULL);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_PMAP_DO_MAP);
}
/* Grow the slab */
lvaddr_t buf = vspace_genvaddr_to_lvaddr(genvaddr);
slab_grow(&pmap->slab, (void*)buf, bytes);
}
return SYS_ERR_OK;
}
void WidgetWindow::xt_realize(XtValueMask* mask, XSetWindowAttributes* attr) {
WindowRep& wr = *((Window*)this)->rep();
wr.xattrs_ = *attr;
wr.xattrmask_ = *mask;
bind();
set_props();
do_map();
// ### why keep this?
XtAddEventHandler(
(Widget)widget_, StructureNotifyMask, FALSE,
&WidgetWindow::xt_structure_event, this
);
}
/**
* \brief Create page mappings
*
* \param pmap The pmap object
* \param vaddr The virtual address to create the mapping for
* \param frame The frame cap to map in
* \param offset Offset into the frame cap
* \param size Size of the mapping
* \param flags Flags for the mapping
* \param retoff If non-NULL, filled in with adjusted offset of mapped region
* \param retsize If non-NULL, filled in with adjusted size of mapped region
*/
static errval_t
map(struct pmap *pmap,
genvaddr_t vaddr,
struct capref frame,
size_t offset,
size_t size,
vregion_flags_t flags,
size_t *retoff,
size_t *retsize)
{
struct pmap_arm *pmap_arm = (struct pmap_arm *)pmap;
size += BASE_PAGE_OFFSET(offset);
size = ROUND_UP(size, BASE_PAGE_SIZE);
offset -= BASE_PAGE_OFFSET(offset);
const size_t slabs_reserve = 3; // == max_slabs_required(1)
uint64_t slabs_free = slab_freecount(&pmap_arm->slab);
size_t slabs_required = max_slabs_required(size) + slabs_reserve;
if (slabs_required > slabs_free) {
if (get_current_pmap() == pmap) {
errval_t err = refill_slabs(pmap_arm, slabs_required);
if (err_is_fail(err)) {
return err_push(err, LIB_ERR_SLAB_REFILL);
}
}
else {
size_t bytes = SLAB_STATIC_SIZE(slabs_required - slabs_free,
sizeof(struct vnode));
void *buf = malloc(bytes);
if (!buf) {
return LIB_ERR_MALLOC_FAIL;
}
slab_grow(&pmap_arm->slab, buf, bytes);
}
}
return do_map(pmap_arm, vaddr, frame, offset, size, flags,
retoff, retsize);
}
/// ":loadkeymap" command: load the following lines as the keymap.
///
/// @param eap
void ex_loadkeymap(exarg_T *eap)
{
char_u *line;
char_u *p;
char_u *s;
#define KMAP_LLEN 200 // max length of "to" and "from" together
char_u buf[KMAP_LLEN + 11];
char_u *save_cpo = p_cpo;
if (!getline_equal(eap->getline, eap->cookie, getsourceline)) {
EMSG(_("E105: Using :loadkeymap not in a sourced file"));
return;
}
// Stop any active keymap and clear the table.
keymap_unload();
curbuf->b_kmap_state = 0;
ga_init(&curbuf->b_kmap_ga, (int)sizeof(kmap_T), 20);
// Set 'cpoptions' to "C" to avoid line continuation.
p_cpo = (char_u *)"C";
// Get each line of the sourced file, break at the end.
for (;;) {
line = eap->getline(0, eap->cookie, 0);
if (line == NULL) {
break;
}
p = skipwhite(line);
if ((*p != '"') && (*p != NUL)) {
kmap_T *kp = GA_APPEND_VIA_PTR(kmap_T, &curbuf->b_kmap_ga);
s = skiptowhite(p);
kp->from = vim_strnsave(p, (size_t)(s - p));
p = skipwhite(s);
s = skiptowhite(p);
kp->to = vim_strnsave(p, (size_t)(s - p));
if ((STRLEN(kp->from) + STRLEN(kp->to) >= KMAP_LLEN)
|| (*kp->from == NUL)
|| (*kp->to == NUL)) {
if (*kp->to == NUL) {
EMSG(_("E791: Empty keymap entry"));
}
xfree(kp->from);
xfree(kp->to);
--curbuf->b_kmap_ga.ga_len;
}
}
xfree(line);
}
// setup ":lnoremap" to map the keys
for (int i = 0; i < curbuf->b_kmap_ga.ga_len; ++i) {
vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s %s",
((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].from,
((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].to);
(void)do_map(2, buf, LANGMAP, FALSE);
}
p_cpo = save_cpo;
curbuf->b_kmap_state |= KEYMAP_LOADED;
status_redraw_curbuf();
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *derivedData,
ModifierApplyFlag UNUSED(flag))
{
WeightVGProximityModifierData *wmd = (WeightVGProximityModifierData *) md;
DerivedMesh *dm = derivedData;
MDeformVert *dvert = NULL;
MDeformWeight **dw, **tdw;
int numVerts;
float (*v_cos)[3] = NULL; /* The vertices coordinates. */
Object *obr = NULL; /* Our target object. */
int defgrp_idx;
float *tw = NULL;
float *org_w = NULL;
float *new_w = NULL;
int *tidx, *indices = NULL;
int numIdx = 0;
int i;
/* Flags. */
#if 0
int do_prev = (wmd->modifier.mode & eModifierMode_DoWeightPreview);
#endif
#if DO_PROFILE
TIMEIT_START(perf)
#endif
/* Get number of verts. */
numVerts = dm->getNumVerts(dm);
/* Check if we can just return the original mesh.
* Must have verts and therefore verts assigned to vgroups to do anything useful!
*/
if ((numVerts == 0) || (ob->defbase.first == NULL))
return dm;
/* Get our target object. */
obr = wmd->proximity_ob_target;
if (obr == NULL)
return dm;
/* Get vgroup idx from its name. */
defgrp_idx = defgroup_name_index(ob, wmd->defgrp_name);
if (defgrp_idx < 0)
return dm;
dvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MDEFORMVERT, numVerts);
/* If no vertices were ever added to an object's vgroup, dvert might be NULL.
* As this modifier never add vertices to vgroup, just return. */
if (!dvert)
return dm;
/* Find out which vertices to work on (all vertices in vgroup), and get their relevant weight.
*/
tidx = MEM_mallocN(sizeof(int) * numVerts, "WeightVGProximity Modifier, tidx");
tw = MEM_mallocN(sizeof(float) * numVerts, "WeightVGProximity Modifier, tw");
tdw = MEM_mallocN(sizeof(MDeformWeight *) * numVerts, "WeightVGProximity Modifier, tdw");
for (i = 0; i < numVerts; i++) {
MDeformWeight *_dw = defvert_find_index(&dvert[i], defgrp_idx);
if (_dw) {
tidx[numIdx] = i;
tw[numIdx] = _dw->weight;
tdw[numIdx++] = _dw;
}
}
/* If no vertices found, return org data! */
if (numIdx == 0) {
MEM_freeN(tidx);
MEM_freeN(tw);
MEM_freeN(tdw);
return dm;
}
if (numIdx != numVerts) {
indices = MEM_mallocN(sizeof(int) * numIdx, "WeightVGProximity Modifier, indices");
memcpy(indices, tidx, sizeof(int) * numIdx);
org_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGProximity Modifier, org_w");
memcpy(org_w, tw, sizeof(float) * numIdx);
dw = MEM_mallocN(sizeof(MDeformWeight *) * numIdx, "WeightVGProximity Modifier, dw");
memcpy(dw, tdw, sizeof(MDeformWeight *) * numIdx);
MEM_freeN(tw);
MEM_freeN(tdw);
}
else {
org_w = tw;
dw = tdw;
}
new_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGProximity Modifier, new_w");
MEM_freeN(tidx);
/* Get our vertex coordinates. */
v_cos = MEM_mallocN(sizeof(float[3]) * numIdx, "WeightVGProximity Modifier, v_cos");
if (numIdx != numVerts) {
/* XXX In some situations, this code can be up to about 50 times more performant
* than simply using getVertCo for each affected vertex...
*/
float (*tv_cos)[3] = MEM_mallocN(sizeof(float[3]) * numVerts, "WeightVGProximity Modifier, tv_cos");
dm->getVertCos(dm, tv_cos);
for (i = 0; i < numIdx; i++)
copy_v3_v3(v_cos[i], tv_cos[indices[i]]);
MEM_freeN(tv_cos);
}
else
dm->getVertCos(dm, v_cos);
/* Compute wanted distances. */
if (wmd->proximity_mode == MOD_WVG_PROXIMITY_OBJECT) {
const float dist = get_ob2ob_distance(ob, obr);
for (i = 0; i < numIdx; i++)
new_w[i] = dist;
}
else if (wmd->proximity_mode == MOD_WVG_PROXIMITY_GEOMETRY) {
const short use_trgt_verts = (wmd->proximity_flags & MOD_WVG_PROXIMITY_GEOM_VERTS);
const short use_trgt_edges = (wmd->proximity_flags & MOD_WVG_PROXIMITY_GEOM_EDGES);
const short use_trgt_faces = (wmd->proximity_flags & MOD_WVG_PROXIMITY_GEOM_FACES);
if (use_trgt_verts || use_trgt_edges || use_trgt_faces) {
DerivedMesh *target_dm = obr->derivedFinal;
short free_target_dm = FALSE;
if (!target_dm) {
if (ELEM3(obr->type, OB_CURVE, OB_SURF, OB_FONT))
target_dm = CDDM_from_curve(obr);
else if (obr->type == OB_MESH) {
Mesh *me = (Mesh *)obr->data;
if (me->edit_btmesh)
target_dm = CDDM_from_BMEditMesh(me->edit_btmesh, me, FALSE, FALSE);
else
target_dm = CDDM_from_mesh(me, obr);
}
free_target_dm = TRUE;
}
/* We must check that we do have a valid target_dm! */
if (target_dm) {
SpaceTransform loc2trgt;
float *dists_v = use_trgt_verts ? MEM_mallocN(sizeof(float) * numIdx, "dists_v") : NULL;
float *dists_e = use_trgt_edges ? MEM_mallocN(sizeof(float) * numIdx, "dists_e") : NULL;
float *dists_f = use_trgt_faces ? MEM_mallocN(sizeof(float) * numIdx, "dists_f") : NULL;
space_transform_setup(&loc2trgt, ob, obr);
get_vert2geom_distance(numIdx, v_cos, dists_v, dists_e, dists_f,
target_dm, &loc2trgt);
for (i = 0; i < numIdx; i++) {
new_w[i] = dists_v ? dists_v[i] : FLT_MAX;
if (dists_e)
new_w[i] = minf(dists_e[i], new_w[i]);
if (dists_f)
new_w[i] = minf(dists_f[i], new_w[i]);
}
if (free_target_dm) target_dm->release(target_dm);
if (dists_v) MEM_freeN(dists_v);
if (dists_e) MEM_freeN(dists_e);
if (dists_f) MEM_freeN(dists_f);
}
/* Else, fall back to default obj2vert behavior. */
else {
get_vert2ob_distance(numIdx, v_cos, new_w, ob, obr);
}
}
else {
get_vert2ob_distance(numIdx, v_cos, new_w, ob, obr);
}
}
/* Map distances to weights. */
do_map(new_w, numIdx, wmd->min_dist, wmd->max_dist, wmd->falloff_type);
/* Do masking. */
weightvg_do_mask(numIdx, indices, org_w, new_w, ob, dm, wmd->mask_constant,
wmd->mask_defgrp_name, wmd->modifier.scene, wmd->mask_texture,
wmd->mask_tex_use_channel, wmd->mask_tex_mapping,
wmd->mask_tex_map_obj, wmd->mask_tex_uvlayer_name);
/* Update vgroup. Note we never add nor remove vertices from vgroup here. */
weightvg_update_vg(dvert, defgrp_idx, dw, numIdx, indices, org_w, FALSE, 0.0f, FALSE, 0.0f);
/* If weight preview enabled... */
#if 0 /* XXX Currently done in mod stack :/ */
if (do_prev)
DM_update_weight_mcol(ob, dm, 0, org_w, numIdx, indices);
#endif
/* Freeing stuff. */
MEM_freeN(org_w);
MEM_freeN(new_w);
MEM_freeN(dw);
if (indices)
MEM_freeN(indices);
MEM_freeN(v_cos);
#if DO_PROFILE
TIMEIT_END(perf)
#endif
/* Return the vgroup-modified mesh. */
return dm;
}
enum bverror do_blit(struct bvbltparams *bvbltparams,
struct gcbatch *batch,
struct surfaceinfo *srcinfo)
{
enum bverror bverror = BVERR_NONE;
struct gccontext *gccontext = get_context();
struct gcmosrc0 *gcmosrc0;
struct gcmosrc *gcmosrc;
struct gcblit *gcblit;
unsigned int index;
struct bvbuffmap *dstmap = NULL;
struct bvbuffmap *srcmap = NULL;
struct surfaceinfo *dstinfo;
int dstshiftX, dstshiftY;
int dstpixalign, dstbyteshift;
int dstoffsetX, dstoffsetY;
int srcshiftX, srcshiftY, srctopedge;
struct gcrect srcclipped;
int srcsurfwidth, srcsurfheight;
unsigned int physwidth, physheight;
int orthogonal;
int multisrc;
GCENTER(GCZONE_BLIT);
/* 3-plane source not supported. */
if ((srcinfo->format.type == BVFMT_YUV) &&
(srcinfo->format.cs.yuv.planecount == 3)) {
BVSETBLTERROR((srcinfo->index == 0)
? BVERR_SRC1GEOM_FORMAT
: BVERR_SRC2GEOM_FORMAT,
"unsupported source%d format.",
srcinfo->index + 1);
goto exit;
}
/* Get a shortcut to the destination surface. */
dstinfo = &batch->dstinfo;
/* Parse destination parameters. */
bverror = parse_destination(bvbltparams, batch);
if (bverror != BVERR_NONE)
goto exit;
/* Setup rotation. */
process_dest_rotation(bvbltparams, batch);
/***********************************************************************
* Determine source surface alignment offset.
*/
/* Determine whether the source and the destination are orthogonal
* to each other. */
orthogonal = (srcinfo->angle % 2) != (dstinfo->angle % 2);
/* Compute clipped source rectangle. */
srcclipped.left = srcinfo->rect.left + batch->clipdelta.left;
srcclipped.top = srcinfo->rect.top + batch->clipdelta.top;
srcclipped.right = srcinfo->rect.right + batch->clipdelta.right;
srcclipped.bottom = srcinfo->rect.bottom + batch->clipdelta.bottom;
GCPRINT_RECT(GCZONE_SURF, "clipped source", &srcclipped);
/* Validate the source rectangle. */
if (!valid_rect(srcinfo->geom, &srcclipped)) {
BVSETBLTERROR((srcinfo->index == 0)
? BVERR_SRC1RECT
: BVERR_SRC2RECT,
"invalid source rectangle.");
goto exit;
}
/* Compute the source surface shift. */
switch (srcinfo->angle) {
case ROT_ANGLE_0:
srctopedge = srcclipped.top;
srcshiftX = srcclipped.left - batch->dstadjusted.left;
srcshiftY = srctopedge - batch->dstadjusted.top;
break;
case ROT_ANGLE_90:
srctopedge = srcinfo->geom->width - srcclipped.left;
srcshiftX = srcclipped.top - batch->dstadjusted.top;
srcshiftY = srctopedge
- (batch->dstwidth - batch->dstadjusted.left);
srctopedge += 1;
break;
case ROT_ANGLE_180:
srctopedge = srcinfo->geom->height - srcclipped.top;
srcshiftX = (srcinfo->geom->width - srcclipped.left)
- (batch->dstwidth - batch->dstadjusted.left);
srcshiftY = srctopedge
- (batch->dstheight - batch->dstadjusted.top);
srctopedge += 1;
break;
case ROT_ANGLE_270:
srctopedge = srcclipped.left;
srcshiftX = (srcinfo->geom->height - srcclipped.top)
- (batch->dstheight - batch->dstadjusted.top);
srcshiftY = srctopedge - batch->dstadjusted.left;
break;
default:
srctopedge = 0;
srcshiftX = 0;
srcshiftY = 0;
}
/* We cannot be in the middle of a sample, currently only YUV formats
* can have subsamples. Adjust vertical position as necessary.
* Horizontal position will be adjusted based on the byte offset and
* base address alignment requirement. This assumes that if we are
* aligned on the base address, then we are also aligned at the
* beginning of a sample. */
if (srcinfo->format.type == BVFMT_YUV) {
int mody = (srctopedge + srcshiftY)
% srcinfo->format.cs.yuv.ysample;
if (mody < 0)
mody = srcinfo->format.cs.yuv.ysample + mody;
srcshiftY -= mody;
srcinfo->ypixalign = -mody;
} else {
srcinfo->ypixalign = 0;
}
/* Compute the source surface offset in bytes. */
srcinfo->bytealign = srcshiftY * (int) srcinfo->geom->virtstride
+ srcshiftX * (int) srcinfo->format.bitspp / 8;
/* Compute the source offset in pixels needed to compensate
* for the surface base address misalignment if any. */
srcinfo->xpixalign = get_pixel_offset(srcinfo, srcinfo->bytealign);
GCDBG(GCZONE_SURF, "source surface %d:\n", srcinfo->index + 1);
GCDBG(GCZONE_SURF, " surface offset (pixels) = %d,%d\n",
srcshiftX, srcshiftY);
GCDBG(GCZONE_SURF, " surface offset (bytes) = 0x%08X\n",
srcinfo->bytealign);
GCDBG(GCZONE_SURF, " srcpixalign = %d,%d\n",
srcinfo->xpixalign, srcinfo->ypixalign);
/* Apply the source alignment. */
srcinfo->bytealign += srcinfo->xpixalign
* (int) srcinfo->format.bitspp / 8;
srcshiftX += srcinfo->xpixalign;
/* NOTE: at this point the source is ready to be presented,
* srcinfo->xpixalign and srcinfo->ypixalign represent additional
* adjustments for the DESTINATION. */
GCDBG(GCZONE_SURF, " adjusted surface offset (pixels) = %d,%d\n",
srcshiftX, srcshiftY);
GCDBG(GCZONE_SURF, " adjusted surface offset (bytes) = 0x%08X\n",
srcinfo->bytealign);
/* Compute U/V plane offsets. */
if ((srcinfo->format.type == BVFMT_YUV) &&
(srcinfo->format.cs.yuv.planecount > 1))
set_computeyuv(srcinfo, srcshiftX, srcshiftY);
/* Set precomputed destination adjustments based on the destination
* base address misalignment only. */
dstshiftX = dstinfo->xpixalign;
dstshiftY = dstinfo->ypixalign;
/* Apply source adjustemnts. */
if (srcinfo->angle == dstinfo->angle) {
dstshiftX += srcinfo->xpixalign;
dstshiftY += srcinfo->ypixalign;
} else if (((srcinfo->angle + 3) % 4) == dstinfo->angle) {
dstshiftY += srcinfo->xpixalign;
} else if (((srcinfo->angle + 1) % 4) == dstinfo->angle) {
dstshiftX += srcinfo->ypixalign;
}
/* Compute the destination surface offset in bytes. */
dstbyteshift = dstshiftY * (int) dstinfo->geom->virtstride
+ dstshiftX * (int) dstinfo->format.bitspp / 8;
/* Compute the destination offset in pixels needed to compensate
* for the surface base address misalignment if any. If dstpixalign
* comes out anything other than zero, multisource blit cannot be
* performed. */
dstpixalign = get_pixel_offset(dstinfo, dstbyteshift);
GCDBG(GCZONE_SURF, "destination surface:\n");
GCDBG(GCZONE_SURF, " surface offset (pixels) = %d,%d\n",
dstshiftX, dstshiftY);
GCDBG(GCZONE_SURF, " surface offset (bytes) = 0x%08X\n",
dstbyteshift);
GCDBG(GCZONE_SURF, " realignment = %d\n",
dstpixalign);
if ((dstpixalign != 0) ||
((srcinfo->xpixalign != 0) && (srcinfo->angle == dstinfo->angle))) {
/* Adjust the destination to match the source geometry. */
switch (srcinfo->angle) {
case ROT_ANGLE_0:
/* Adjust coordinates. */
srcclipped.left -= srcshiftX;
srcclipped.top -= srcshiftY;
/* Determine source size. */
srcsurfwidth = srcinfo->geom->width
- srcinfo->xpixalign;
srcsurfheight = srcinfo->geom->height;
break;
case ROT_ANGLE_90:
/* Adjust top coordinate. */
srcclipped.top -= srcshiftX;
/* Determine source size. */
srcsurfwidth = srcinfo->geom->height
- srcinfo->xpixalign;
srcsurfheight = srcinfo->geom->width;
break;
case ROT_ANGLE_180:
/* Determine source size. */
srcsurfwidth = srcinfo->geom->width
- srcinfo->xpixalign;
srcsurfheight = srcinfo->geom->height;
break;
case ROT_ANGLE_270:
/* Adjust coordinates. */
srcclipped.left -= srcshiftY;
/* Determine source size. */
srcsurfwidth = srcinfo->geom->height
- srcinfo->xpixalign;
srcsurfheight = srcinfo->geom->width;
break;
default:
srcsurfwidth = 0;
srcsurfheight = 0;
}
GCDBG(GCZONE_SURF, "srcrect origin = %d,%d\n",
srcclipped.left, srcclipped.top);
GCDBG(GCZONE_SURF, "source physical size = %dx%d\n",
srcsurfwidth, srcsurfheight);
/* Overwrite destination byte offset. */
dstbyteshift = dstinfo->bytealign;
/* No adjustment necessary for single-source. */
dstoffsetX = 0;
dstoffsetY = 0;
/* Set the physical destination size. */
physwidth = dstinfo->physwidth;
physheight = dstinfo->physheight;
/* Disable multi source for the cases where the destination
* and the source address alignments do not match. */
multisrc = 0;
GCDBG(GCZONE_SURF, "multi-source disabled.\n");
} else {
/* Source origin is not used in multi-source setup. */
srcclipped.left = 0;
srcclipped.top = 0;
/* Adjust the destination to match the source geometry. */
switch (srcinfo->angle) {
case ROT_ANGLE_0:
/* Adjust the destination horizontally. */
dstoffsetX = srcinfo->xpixalign;
dstoffsetY = srcinfo->ypixalign;
/* Apply the source alignment. */
if ((dstinfo->angle % 2) == 0) {
physwidth = dstinfo->physwidth
- srcinfo->xpixalign;
physheight = dstinfo->physheight
- srcinfo->ypixalign;
} else {
physwidth = dstinfo->physwidth
- srcinfo->ypixalign;
physheight = dstinfo->physheight
- srcinfo->xpixalign;
}
break;
case ROT_ANGLE_90:
/* Adjust the destination vertically. */
dstoffsetX = srcinfo->ypixalign;
dstoffsetY = srcinfo->xpixalign;
/* Apply the source alignment. */
if ((dstinfo->angle % 2) == 0) {
physwidth = dstinfo->physwidth
- srcinfo->ypixalign;
physheight = dstinfo->physheight
- srcinfo->xpixalign;
} else {
physwidth = dstinfo->physwidth
- srcinfo->xpixalign;
physheight = dstinfo->physheight
- srcinfo->ypixalign;
}
break;
case ROT_ANGLE_180:
/* No adjustment necessary. */
dstoffsetX = 0;
dstoffsetY = 0;
/* Apply the source alignment. */
if ((dstinfo->angle % 2) == 0) {
physwidth = dstinfo->physwidth
- srcinfo->xpixalign;
physheight = dstinfo->physheight
- srcinfo->ypixalign;
} else {
physwidth = dstinfo->physwidth
- srcinfo->ypixalign;
physheight = dstinfo->physheight
- srcinfo->xpixalign;
}
break;
case ROT_ANGLE_270:
/* No adjustment necessary. */
dstoffsetX = 0;
dstoffsetY = 0;
/* Apply the source alignment. */
if ((dstinfo->angle % 2) == 0) {
physwidth = dstinfo->physwidth
- srcinfo->ypixalign;
physheight = dstinfo->physheight
- srcinfo->xpixalign;
} else {
physwidth = dstinfo->physwidth
- srcinfo->xpixalign;
physheight = dstinfo->physheight
- srcinfo->ypixalign;
}
break;
default:
physwidth = 0;
physheight = 0;
dstoffsetX = 0;
dstoffsetY = 0;
}
/* Source geometry is now the same as the destination. */
if (orthogonal) {
srcsurfwidth = physheight;
srcsurfheight = physwidth;
} else {
srcsurfwidth = physwidth;
srcsurfheight = physheight;
}
/* Enable multi-source. */
multisrc = 1;
GCDBG(GCZONE_SURF, "multi-source enabled.\n");
}
/* Misaligned source may cause the destination parameters
* to change, verify whether this has happened. */
if ((batch->dstbyteshift != dstbyteshift) ||
(batch->dstphyswidth != physwidth) ||
(batch->dstphysheight != physheight) ||
(batch->dstoffsetX != dstoffsetX) ||
(batch->dstoffsetY != dstoffsetY)) {
/* Set new values. */
batch->dstbyteshift = dstbyteshift;
batch->dstphyswidth = physwidth;
batch->dstphysheight = physheight;
batch->dstoffsetX = dstoffsetX;
batch->dstoffsetY = dstoffsetY;
/* Now we need to end the current batch and program
* the hardware with the new destination. */
batch->batchflags |= BVBATCH_DST;
}
/* Check if we need to finalize existing batch. */
if ((batch->batchend != do_blit_end) ||
(batch->op.blit.srccount == 4) ||
(batch->op.blit.multisrc == 0) ||
(multisrc == 0) ||
((batch->batchflags & (BVBATCH_DST |
BVBATCH_CLIPRECT |
BVBATCH_DESTRECT)) != 0)) {
/* Finalize existing batch if any. */
bverror = batch->batchend(bvbltparams, batch);
if (bverror != BVERR_NONE)
goto exit;
/* Blit batch. */
batch->batchend = do_blit_end;
/* Initialize the new batch. */
gcblit = &batch->op.blit;
gcblit->blockenable = 0;
gcblit->srccount = 0;
gcblit->multisrc = multisrc;
/* Set the destination format. */
gcblit->format = dstinfo->format.format;
gcblit->swizzle = dstinfo->format.swizzle;
/* Set the destination coordinates. */
gcblit->dstrect.left = batch->dstadjusted.left - dstoffsetX;
gcblit->dstrect.top = batch->dstadjusted.top - dstoffsetY;
gcblit->dstrect.right = batch->dstadjusted.right - dstoffsetX;
gcblit->dstrect.bottom = batch->dstadjusted.bottom - dstoffsetY;
/* Map the destination. */
bverror = do_map(dstinfo->buf.desc, batch, &dstmap);
if (bverror != BVERR_NONE) {
bvbltparams->errdesc = gccontext->bverrorstr;
goto exit;
}
/* Set the new destination. */
bverror = set_dst(bvbltparams, batch, dstmap);
if (bverror != BVERR_NONE)
goto exit;
/* Reset the modified flag. */
batch->batchflags &= ~(BVBATCH_DST |
BVBATCH_CLIPRECT |
BVBATCH_DESTRECT);
}
/* Map the source. */
bverror = do_map(srcinfo->buf.desc, batch, &srcmap);
if (bverror != BVERR_NONE) {
bvbltparams->errdesc = gccontext->bverrorstr;
goto exit;
}
/***********************************************************************
** Configure source.
*/
/* We need to walk in blocks if the source and the destination
* surfaces are orthogonal to each other. */
batch->op.blit.blockenable |= orthogonal;
/* Shortcut to the register index. */
index = batch->op.blit.srccount;
/* Set surface parameters. */
if (index == 0) {
/* Allocate command buffer. */
bverror = claim_buffer(bvbltparams, batch,
sizeof(struct gcmosrc0),
(void **) &gcmosrc0);
if (bverror != BVERR_NONE)
goto exit;
add_fixup(bvbltparams, batch, &gcmosrc0->address,
srcinfo->bytealign);
gcmosrc0->config_ldst = gcmosrc0_config_ldst;
gcmosrc0->address = GET_MAP_HANDLE(srcmap);
gcmosrc0->stride = srcinfo->geom->virtstride;
gcmosrc0->rotation.raw = 0;
gcmosrc0->rotation.reg.surf_width = srcsurfwidth;
gcmosrc0->config.raw = 0;
gcmosrc0->config.reg.swizzle = srcinfo->format.swizzle;
gcmosrc0->config.reg.format = srcinfo->format.format;
gcmosrc0->origin.reg.x = srcclipped.left;
gcmosrc0->origin.reg.y = srcclipped.top;
gcmosrc0->size.reg = gcregsrcsize_max;
gcmosrc0->rotation_ldst = gcmosrc0_rotation_ldst;
gcmosrc0->rotationheight.reg.height = srcsurfheight;
gcmosrc0->rotationangle.raw = 0;
gcmosrc0->rotationangle.reg.src = rotencoding[srcinfo->angle];
gcmosrc0->rotationangle.reg.dst = rotencoding[dstinfo->angle];
gcmosrc0->rotationangle.reg.src_mirror = srcinfo->mirror;
gcmosrc0->rotationangle.reg.dst_mirror = GCREG_MIRROR_NONE;
gcmosrc0->rop_ldst = gcmosrc0_rop_ldst;
gcmosrc0->rop.raw = 0;
gcmosrc0->rop.reg.type = GCREG_ROP_TYPE_ROP3;
gcmosrc0->rop.reg.fg = (unsigned char) srcinfo->rop;
gcmosrc0->mult_ldst = gcmosrc0_mult_ldst;
gcmosrc0->mult.raw = 0;
gcmosrc0->mult.reg.srcglobalpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_GLOBAL_PREMULTIPLY_DISABLE;
if (srcinfo->format.premultiplied)
gcmosrc0->mult.reg.srcpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE;
else
gcmosrc0->mult.reg.srcpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE;
if (dstinfo->format.premultiplied) {
gcmosrc0->mult.reg.dstpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE;
gcmosrc0->mult.reg.dstdemul
= GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_DISABLE;
} else {
gcmosrc0->mult.reg.dstpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE;
gcmosrc0->mult.reg.dstdemul
= GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_ENABLE;
}
/* Program blending. */
bverror = set_blending(bvbltparams, batch, srcinfo);
if (bverror != BVERR_NONE)
goto exit;
/* Program YUV source. */
if (srcinfo->format.type == BVFMT_YUV) {
bverror = set_yuvsrc(bvbltparams, batch,
srcinfo, srcmap);
if (bverror != BVERR_NONE)
goto exit;
}
} else {
/* Allocate command buffer. */
bverror = claim_buffer(bvbltparams, batch,
sizeof(struct gcmosrc),
(void **) &gcmosrc);
if (bverror != BVERR_NONE)
goto exit;
add_fixup(bvbltparams, batch, &gcmosrc->address,
srcinfo->bytealign);
gcmosrc->address_ldst = gcmosrc_address_ldst[index];
gcmosrc->address = GET_MAP_HANDLE(srcmap);
gcmosrc->stride_ldst = gcmosrc_stride_ldst[index];
gcmosrc->stride = srcinfo->geom->virtstride;
gcmosrc->rotation_ldst = gcmosrc_rotation_ldst[index];
gcmosrc->rotation.raw = 0;
gcmosrc->rotation.reg.surf_width = srcsurfwidth;
gcmosrc->config_ldst = gcmosrc_config_ldst[index];
gcmosrc->config.raw = 0;
gcmosrc->config.reg.swizzle = srcinfo->format.swizzle;
gcmosrc->config.reg.format = srcinfo->format.format;
gcmosrc->origin_ldst = gcmosrc_origin_ldst[index];
gcmosrc->origin.reg.x = srcclipped.left;
gcmosrc->origin.reg.y = srcclipped.top;
gcmosrc->size_ldst = gcmosrc_size_ldst[index];
gcmosrc->size.reg = gcregsrcsize_max;
gcmosrc->rotationheight_ldst
= gcmosrc_rotationheight_ldst[index];
gcmosrc->rotationheight.reg.height = srcsurfheight;
gcmosrc->rotationangle_ldst
= gcmosrc_rotationangle_ldst[index];
gcmosrc->rotationangle.raw = 0;
gcmosrc->rotationangle.reg.src = rotencoding[srcinfo->angle];
gcmosrc->rotationangle.reg.dst = rotencoding[dstinfo->angle];
gcmosrc->rotationangle.reg.src_mirror = srcinfo->mirror;
gcmosrc->rotationangle.reg.dst_mirror = GCREG_MIRROR_NONE;
gcmosrc->rop_ldst = gcmosrc_rop_ldst[index];
gcmosrc->rop.raw = 0;
gcmosrc->rop.reg.type = GCREG_ROP_TYPE_ROP3;
gcmosrc->rop.reg.fg = (unsigned char) srcinfo->rop;
gcmosrc->mult_ldst = gcmosrc_mult_ldst[index];
gcmosrc->mult.raw = 0;
gcmosrc->mult.reg.srcglobalpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_GLOBAL_PREMULTIPLY_DISABLE;
if (srcinfo->format.premultiplied)
gcmosrc->mult.reg.srcpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE;
else
gcmosrc->mult.reg.srcpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE;
if (dstinfo->format.premultiplied) {
gcmosrc->mult.reg.dstpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE;
gcmosrc->mult.reg.dstdemul
= GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_DISABLE;
} else {
gcmosrc->mult.reg.dstpremul
= GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE;
gcmosrc->mult.reg.dstdemul
= GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_ENABLE;
}
/* Program blending. */
bverror = set_blending_index(bvbltparams, batch,
srcinfo, index);
if (bverror != BVERR_NONE)
goto exit;
/* Program YUV source. */
if (srcinfo->format.type == BVFMT_YUV) {
bverror = set_yuvsrc_index(bvbltparams, batch,
srcinfo, srcmap, index);
if (bverror != BVERR_NONE)
goto exit;
}
}
batch->op.blit.srccount += 1;
exit:
GCEXITARG(GCZONE_BLIT, "bv%s = %d\n",
(bverror == BVERR_NONE) ? "result" : "error", bverror);
return bverror;
}
mmap_t* CMMap::map_read(int fd, size_t size, size_t offset, size_t size_max)
{
return do_map(PROT_READ, fd, size, offset, size_max, true);
}
int main(int argc, char* argv[]){
char* action;
Window window;
int arg[5]={0};
// Connexion à un serveur X
display = XOpenDisplay(NULL);
if(!display){
printf("Can not open display.\n");
exit(EXIT_FAILURE);
}
// Récupère la valeur par default des différentes variables.
screen = DefaultScreen(display);
gc = DefaultGC (display, screen);
root = RootWindow (display, screen);
// Détermine l'action à effectuer :
// On vérifie que le 2er argument (autre que nom fichier) est un id de fenetre :
if(argc>2 && ((!strncmp(argv[2],"0x",2) && strtoll(argv[2],NULL,16)) || strtoll(argv[2],NULL,10)) ){
action = argv[1];
window = get_window(argv);
// Si 5 arguments, c'est soit un move, soit un resize:
if (argc==3){ // 1 seul argument (ex: 0x32422 )
if(!strcmp(action,"mapRaise"))
do_map_and_raise(window);
else if(!strcmp(action,"map"))
do_map(window);
else if(!strcmp(action,"raise"))
do_raise(window);
else if(!strcmp(action,"destroy"))
do_destroy(window);
else if(!strcmp(action,"focus"))
do_focus(window);
else if(!strcmp(action,"minimize"))
do_minimize(window);
else if(!strcmp(action,"set_desktop"))
set_desktop((int)strtoll(argv[2],NULL,10));
else
fail();
}
else if(argc==4){ // 2 arguments (ex : 0x4242535 1 )
if(!strcmp(action,"set_desktop_for_window")){
set_desktop(strtoll(argv[3],NULL,10));
set_desktop_for_window(window,strtoll(argv[3],NULL,10));
}
else if(!strcmp(action,"set_viewport"))
set_viewport((int)strtoll(argv[2],NULL,10),(int)strtoll(argv[3],NULL,10));
else
fail();
}
else if(argc==5){
arg[0]=(int)strtoll(argv[3],NULL,10);
arg[1]=(int)strtoll(argv[4],NULL,10);
if(!strcmp(action,"move"))
do_move(window, arg[0], arg[1]);
else if(!strcmp(action,"resize"))
do_resize(window,arg[0],arg[1]);
else
fail();
}
else if(argc==7){
arg[0]=(int)strtoll(argv[3],NULL,10);
arg[1]=(int)strtoll(argv[4],NULL,10);
arg[2]=(int)strtoll(argv[5],NULL,10);
arg[3]=(int)strtoll(argv[6],NULL,10);
if(!strcmp(action,"moveResize"))
do_move_and_resize(window, arg[0], arg[1], arg[2], arg[3]);
else
fail();
}
else
fail();
}
else
fail();
XCloseDisplay(display);
return EXIT_SUCCESS;
}
mmap_t* CMMap::map_write(int fd, size_t size, size_t offset, size_t size_max)
{
return do_map(PROT_WRITE, fd, size, offset, size_max, true);
}
mmap_t* CMMap::map_both(int fd, size_t size, size_t offset, size_t size_max)
{
return do_map(PROT_READ|PROT_WRITE, fd, size, offset, size_max, true);
}
void
loop(void)
{
enum {
ST_COMMAND,
ST_TRANSPARENT
} state;
fd_set rdset, wrset;
int r, n;
unsigned char c;
tty_q.len = 0;
state = ST_TRANSPARENT;
while ( ! sig_exit ) {
FD_ZERO(&rdset);
FD_ZERO(&wrset);
FD_SET(STI, &rdset);
FD_SET(tty_fd, &rdset);
if ( tty_q.len ) FD_SET(tty_fd, &wrset);
r = select(tty_fd + 1, &rdset, &wrset, NULL, NULL);
if ( r < 0 ) {
if ( errno == EINTR )
continue;
else
fatal("select failed: %d : %s", errno, strerror(errno));
}
if ( FD_ISSET(STI, &rdset) ) {
/* read from terminal */
do {
n = read(STI, &c, 1);
} while (n < 0 && errno == EINTR);
if (n == 0) {
fatal("stdin closed");
} else if (n < 0) {
/* is this really necessary? better safe than sory! */
if ( errno != EAGAIN && errno != EWOULDBLOCK )
fatal("read from stdin failed: %s", strerror(errno));
else
goto skip_proc_STI;
}
switch (state) {
case ST_COMMAND:
if ( c == opts.escape ) {
/* pass the escape character down */
if (tty_q.len + M_MAXMAP <= TTY_Q_SZ) {
n = do_map((char *)tty_q.buff + tty_q.len,
opts.omap, c);
tty_q.len += n;
if ( opts.lecho )
map_and_write(STO, opts.emap, c);
} else {
fd_printf(STO, "\x07");
}
} else {
/* process command key */
if ( do_command(c) )
/* picocom exit */
return;
}
state = ST_TRANSPARENT;
break;
case ST_TRANSPARENT:
if ( c == opts.escape ) {
state = ST_COMMAND;
} else {
if (tty_q.len + M_MAXMAP <= TTY_Q_SZ) {
n = do_map((char *)tty_q.buff + tty_q.len,
opts.omap, c);
tty_q.len += n;
if ( opts.lecho )
map_and_write(STO, opts.emap, c);
} else
fd_printf(STO, "\x07");
}
break;
default:
assert(0);
break;
}
}
skip_proc_STI:
if ( FD_ISSET(tty_fd, &rdset) ) {
char buff_rd[TTY_RD_SZ];
char buff_map[TTY_RD_SZ * M_MAXMAP];
/* read from port */
do {
n = read(tty_fd, &buff_rd, sizeof(buff_rd));
} while (n < 0 && errno == EINTR);
if (n == 0) {
fatal("term closed");
} else if ( n < 0 ) {
if ( errno != EAGAIN && errno != EWOULDBLOCK )
fatal("read from term failed: %s", strerror(errno));
} else {
int i;
char *bmp = &buff_map[0];
for (i = 0; i < n; i++) {
bmp += do_map(bmp, opts.imap, buff_rd[i]);
}
n = bmp - buff_map;
if ( writen_ni(STO, buff_map, n) < n )
fatal("write to stdout failed: %s", strerror(errno));
}
}
if ( FD_ISSET(tty_fd, &wrset) ) {
/* write to port */
int sz;
sz = (tty_q.len < tty_write_sz) ? tty_q.len : tty_write_sz;
do {
n = write(tty_fd, tty_q.buff, sz);
} while ( n < 0 && errno == EINTR );
if ( n <= 0 )
fatal("write to term failed: %s", strerror(errno));
memmove(tty_q.buff, tty_q.buff + n, tty_q.len - n);
tty_q.len -= n;
}
}
}
