static void
scan_ag(
xfs_agnumber_t agno)
{
xfs_agf_t *agf;
xfs_agi_t *agi;
push_cur();
set_cur(&typtab[TYP_AGF],
XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
if ((agf = iocur_top->data) == NULL) {
dbprintf(_("can't read agf block for ag %u\n"), agno);
pop_cur();
return;
}
push_cur();
set_cur(&typtab[TYP_AGI],
XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
if ((agi = iocur_top->data) == NULL) {
dbprintf(_("can't read agi block for ag %u\n"), agno);
pop_cur();
pop_cur();
return;
}
scan_sbtree(agf, be32_to_cpu(agi->agi_root),
be32_to_cpu(agi->agi_level), scanfunc_ino, TYP_INOBT);
pop_cur();
pop_cur();
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolPrintArea::clic(i2dvertex loc, int count){
bStdToolPres::clic(loc,count);
ivx_rect vr=*(_gapp->printMgr()->get_print_area());
bGenericUnit* u=_gapp->scaleMgr()->get();
i2dvertex vxa={vr.left,vr.top};
if( (_d_(vr.bottom,loc.v,u->conv())<3) &&
(_d_(vr.right,loc.h,u->conv())<3) ){
_dragmode=kPrintAreaDragModeFullResize;
set_clic(&vxa);
set_cur(&vxa);
}
else if(_d_(vr.bottom,loc.v,u->conv())<3){
_dragmode=kPrintAreaDragModeBottomResize;
set_clic(&vxa);
set_cur(&vxa);
}
else if(_d_(vr.right,loc.h,u->conv())<3){
_dragmode=kPrintAreaDragModeRightResize;
set_clic(&vxa);
set_cur(&vxa);
}
else if((_d_(vr.top,loc.v,u->conv())<3) ||
(_d_(vr.left,loc.h,u->conv())<3)){
_dragmode=kPrintAreaDragModeMove;
_startmove=true;
}
else{
_dragmode=kPrintAreaDragModeSet;
}
set_use_drag(true);
}
void clrB(BLOCK* b, int x, int y)
{
set_put_c_color(_COLOR_BLACK,_COLOR_BLACK);
set_cur(2*(b->p.x+x)+0,b->p.y+y+0); put_c(b->b[0]);
set_cur(2*(b->p.x+x)+1,b->p.y+y+0); put_c(b->b[1]);
set_put_c_color(0,0);
}
void prtB(BLOCK* b, int x, int y)
{
set_put_c_color(b->str_col,b->bg_col);
set_cur(2*(b->p.x+x)+0,b->p.y+y+0); put_c(b->b[0]);
set_cur(2*(b->p.x+x)+1,b->p.y+y+0); put_c(b->b[1]);
set_put_c_color(0,0);
}
void crtc_ega_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_LINE:
handle_line_timer();
break;
case TIMER_DE_OFF:
set_de( FALSE );
break;
case TIMER_CUR_ON:
set_cur( TRUE );
/* Schedule CURSOR off signal */
m_cur_off_timer->adjust( attotime::from_ticks( 1, m_clock ) );
break;
case TIMER_CUR_OFF:
set_cur( FALSE );
break;
case TIMER_HSYNC_ON:
{
INT8 hsync_width = ( 0x20 | m_horiz_blank_end ) - ( m_horiz_blank_start & 0x1f );
if ( hsync_width <= 0 )
{
hsync_width += 0x20;
}
m_hsync_width_counter = 0;
set_hsync( TRUE );
/* Schedule HSYNC off signal */
m_hsync_off_timer->adjust( attotime::from_ticks( hsync_width, m_clock ) );
}
break;
case TIMER_HSYNC_OFF:
set_hsync( FALSE );
break;
case TIMER_LIGHT_PEN_LATCH:
m_light_pen_addr = get_ma();
m_light_pen_latched = true;
break;
}
}
static int
get_sb(xfs_agnumber_t agno, xfs_sb_t *sb)
{
push_cur();
set_cur(&typtab[TYP_SB],
XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
if (!iocur_top->data) {
dbprintf(_("can't read superblock for AG %u\n"), agno);
pop_cur();
return 0;
}
libxfs_sb_from_disk(sb, iocur_top->data);
if (sb->sb_magicnum != XFS_SB_MAGIC) {
dbprintf(_("bad sb magic # %#x in AG %u\n"),
sb->sb_magicnum, agno);
return 0;
}
if (!xfs_sb_good_version(sb)) {
dbprintf(_("bad sb version # %#x in AG %u\n"),
sb->sb_versionnum, agno);
return 0;
}
if (agno == 0 && sb->sb_inprogress != 0) {
dbprintf(_("mkfs not completed successfully\n"));
return 0;
}
return 1;
}
static int
get_sb(xfs_agnumber_t agno, xfs_sb_t *sb)
{
push_cur();
set_cur(&typtab[TYP_SB], XFS_AG_DADDR(mp, agno, XFS_SB_DADDR), 1,
DB_RING_IGN, NULL);
if (!iocur_top->data) {
dbprintf("can't read superblock for AG %u\n", agno);
pop_cur();
return 0;
}
libxfs_xlate_sb(iocur_top->data, sb, 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
if (sb->sb_magicnum != XFS_SB_MAGIC) {
dbprintf("bad sb magic # %#x in AG %u\n",
sb->sb_magicnum, agno);
return 0;
}
if (!XFS_SB_GOOD_VERSION(sb)) {
dbprintf("bad sb version # %#x in AG %u\n",
sb->sb_versionnum, agno);
return 0;
}
if (agno == 0 && sb->sb_inprogress != 0) {
dbprintf("mkfs not completed successfully\n");
return 0;
}
return 1;
}
//------------- Begin of function UnitB::set_wait --------------//
//
// set parameters for unit idle
//
void UnitB::set_wait()
{
set_cur(next_x, next_y); // align the sprite to 32x32 location when it stops
cur_action = SPRITE_WAIT;
cur_frame = 1;
wait_count++; // this will be reset when the unit moves
}
void select_con(int con)
{
if(fg_console==con)
return ;
fg_console=con;
cur_console=con;
set_orign();
set_cur();
}
int con_write(struct tty_struct *tty)
{
char ch;
int res = 0;
cur_console = tty-tty_table-1;
irq_lock();
while (!isempty(tty->out)) {
GETCH(tty->out, ch);
if (ch == '\033') {
char tmp_x = 0, tmp_y = 0;
while (1) {
GETCH(tty->out, ch);
if (ch >= '0' && ch <= '9')
tmp_x = tmp_x * 10 + ch - '0';
else
break;
}
if (ch == ';') {
while (1) {
GETCH(tty->out, ch);
if (ch >= '0' && ch <= '9')
tmp_y = tmp_y * 10 + ch - '0';
else
break;
}
}
if (ch == 'P') {
if (tmp_x >= 80)
x = 79;
else
x = tmp_x;
if (tmp_y >= 25)
x = 24;
else
y = tmp_y;
} else if (ch == 'C')
color = ((tmp_x << 4) & 0xf0) | (tmp_y & 0xf);
else if (ch=='E')
__echo__=0;
else if (ch=='e')
__echo__=1;
} else
write_char(ch);
res++;
}
if (fg_console == cur_console)
set_cur();
irq_unlock();
return res;
}
static void
scanfunc_ino(
struct xfs_btree_block *block,
int level,
xfs_agf_t *agf)
{
xfs_agino_t agino;
xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
int i;
int j;
int off;
xfs_inobt_ptr_t *pp;
xfs_inobt_rec_t *rp;
if (level == 0) {
rp = XFS_INOBT_REC_ADDR(mp, block, 1);
for (i = 0; i < be16_to_cpu(block->bb_numrecs); i++) {
agino = be32_to_cpu(rp[i].ir_startino);
off = XFS_INO_TO_OFFSET(mp, agino);
push_cur();
set_cur(&typtab[TYP_INODE],
XFS_AGB_TO_DADDR(mp, seqno,
XFS_AGINO_TO_AGBNO(mp, agino)),
XFS_FSB_TO_BB(mp, XFS_IALLOC_BLOCKS(mp)),
DB_RING_IGN, NULL);
if (iocur_top->data == NULL) {
dbprintf(_("can't read inode block %u/%u\n"),
seqno, XFS_AGINO_TO_AGBNO(mp, agino));
continue;
}
for (j = 0; j < XFS_INODES_PER_CHUNK; j++) {
if (XFS_INOBT_IS_FREE_DISK(&rp[i], j))
continue;
process_inode(agf, agino + j, (xfs_dinode_t *)
((char *)iocur_top->data +
((off + j) << mp->m_sb.sb_inodelog)));
}
pop_cur();
}
return;
}
pp = XFS_INOBT_PTR_ADDR(mp, block, 1, mp->m_inobt_mxr[1]);
for (i = 0; i < be16_to_cpu(block->bb_numrecs); i++)
scan_sbtree(agf, be32_to_cpu(pp[i]), level, scanfunc_ino,
TYP_INOBT);
}
bool customers::check_stay(const customer_info *c_info) {
string chin = c_info->in_date,
chout = c_info->out_date;
set_cur();
if ((get_days_left(chin, cur_day) < 0 || get_days_left(cur_day, chout) < 0)) {
cout << "\n\n\t=== [No Within Stay Customer] ===\n";
return false;
}
else if (chin == chout) { // If check-in data is same as check-out data (not overnight)
cout << "\n\n\t=== [No Overnight Customer] ===\n";
return false;
}
// The customer is a within-stay and overnight customer
cout << "\n\n\t=== Valid to Reserve the Spa Service(s) ===\n";
return true;
}
static void
scan_sbtree(
xfs_agf_t *agf,
xfs_agblock_t root,
int nlevels,
scan_sbtree_f_t func,
typnm_t btype)
{
xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
push_cur();
set_cur(&typtab[btype], XFS_AGB_TO_DADDR(mp, seqno, root),
blkbb, DB_RING_IGN, NULL);
if (iocur_top->data == NULL) {
dbprintf(_("can't read btree block %u/%u\n"), seqno, root);
return;
}
(*func)(iocur_top->data, nlevels - 1, agf);
pop_cur();
}
static void
scan_lbtree(
xfs_fsblock_t root,
int nlevels,
scan_lbtree_f_t func,
extmap_t **extmapp,
typnm_t btype)
{
push_cur();
set_cur(&typtab[btype], XFS_FSB_TO_DADDR(mp, root), blkbb, DB_RING_IGN,
NULL);
if (iocur_top->data == NULL) {
dbprintf(_("can't read btree block %u/%u\n"),
XFS_FSB_TO_AGNO(mp, root),
XFS_FSB_TO_AGBNO(mp, root));
return;
}
(*func)(iocur_top->data, nlevels - 1, extmapp, btype);
pop_cur();
}
static int
sb_f(
int argc,
char **argv)
{
xfs_agnumber_t agno;
char *p;
if (argc > 1) {
agno = (xfs_agnumber_t)strtoul(argv[1], &p, 0);
if (*p != '\0' || agno >= mp->m_sb.sb_agcount) {
dbprintf("bad allocation group number %s\n", argv[1]);
return 0;
}
cur_agno = agno;
} else if (cur_agno == NULLAGNUMBER)
cur_agno = 0;
ASSERT(typtab[TYP_SB].typnm == TYP_SB);
set_cur(&typtab[TYP_SB], XFS_AG_DADDR(mp, cur_agno, XFS_SB_DADDR), 1,
DB_RING_ADD, NULL);
return 0;
}
NcValues* NcVar::get_rec(NcDim* rdim, long slice)
{
int idx = dim_to_index(rdim);
long size = num_dims();
size_t* start = new size_t[size];
long* startl = new long[size];
for (int i=1; i < size ; i++) {
start[i] = 0;
startl[i] = 0;
}
start[idx] = slice;
startl[idx] = slice;
NcBool result = set_cur(startl);
if (! result ) {
delete [] start;
delete [] startl;
return 0;
}
long* edgel = edges();
size_t* edge = new size_t[size];
for (int i=1; i < size ; i++) {
edge[i] = edgel[i];
}
edge[idx] = 1;
edgel[idx] = 1;
NcValues* valp = get_space(rec_size(rdim));
int status;
switch (type()) {
case ncFloat:
status = NcError::set_err(
nc_get_vara_float(the_file->id(), the_id, start, edge,
(float *)valp->base())
);
break;
case ncDouble:
status = NcError::set_err(
nc_get_vara_double(the_file->id(), the_id, start, edge,
(double *)valp->base())
);
break;
case ncInt:
status = NcError::set_err(
nc_get_vara_int(the_file->id(), the_id, start, edge,
(int *)valp->base())
);
break;
case ncShort:
status = NcError::set_err(
nc_get_vara_short(the_file->id(), the_id, start, edge,
(short *)valp->base())
);
break;
case ncByte:
status = NcError::set_err(
nc_get_vara_schar(the_file->id(), the_id, start, edge,
(signed char *)valp->base())
);
break;
case ncChar:
status = NcError::set_err(
nc_get_vara_text(the_file->id(), the_id, start, edge,
(char *)valp->base())
);
break;
case ncNoType:
default:
return 0;
}
delete [] start;
delete [] startl;
delete [] edge;
delete [] edgel;
if (status != NC_NOERR) {
delete valp;
return 0;
}
return valp;
}
void mc6845_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
switch (id)
{
case TIMER_LINE:
handle_line_timer();
break;
case TIMER_DE_OFF:
set_de( FALSE );
break;
case TIMER_CUR_ON:
set_cur( TRUE );
/* Schedule CURSOR off signal */
m_cur_off_timer->adjust( attotime::from_ticks( 1, m_clock ) );
break;
case TIMER_CUR_OFF:
set_cur( FALSE );
break;
case TIMER_HSYNC_ON:
{
UINT8 hsync_width = ( m_sync_width & 0x0f ) ? ( m_sync_width & 0x0f ) : 0x10;
m_hsync_width_counter = 0;
set_hsync( TRUE );
/* Schedule HSYNC off signal */
m_hsync_off_timer->adjust( attotime::from_ticks( hsync_width, m_clock ) );
}
break;
case TIMER_HSYNC_OFF:
set_hsync( FALSE );
break;
case TIMER_LIGHT_PEN_LATCH:
m_light_pen_addr = get_ma();
m_light_pen_latched = true;
break;
case TIMER_UPD_ADR:
/* fire a update address strobe */
call_on_update_address(0);
break;
case TIMER_UPD_TRANS:
{
int addr = (param >> 8);
int strobe = (param & 0xff);
/* call the callback function -- we know it exists */
m_on_update_addr_changed_cb(addr, strobe);
if(!m_update_ready_bit && MODE_TRANSPARENT_BLANK)
{
m_update_addr++;
m_update_addr &= 0x3fff;
m_update_ready_bit = true;
}
}
break;
}
}
static int
dquot_f(
int argc,
char **argv)
{
bmap_ext_t bm;
int c;
int dogrp;
int doprj;
xfs_dqid_t id;
xfs_ino_t ino;
int nex;
char *p;
int perblock;
xfs_fileoff_t qbno;
int qoff;
char *s;
dogrp = doprj = optind = 0;
while ((c = getopt(argc, argv, "gpu")) != EOF) {
switch (c) {
case 'g':
dogrp = 1;
doprj = 0;
break;
case 'p':
doprj = 1;
dogrp = 0;
break;
case 'u':
dogrp = doprj = 0;
break;
default:
dbprintf(_("bad option for dquot command\n"));
return 0;
}
}
s = doprj ? _("project") : dogrp ? _("group") : _("user");
if (optind != argc - 1) {
dbprintf(_("dquot command requires one %s id argument\n"), s);
return 0;
}
ino = mp->m_sb.sb_uquotino;
if (doprj)
ino = mp->m_sb.sb_pquotino;
else if (dogrp)
ino = mp->m_sb.sb_gquotino;
if (ino == 0 || ino == NULLFSINO) {
dbprintf(_("no %s quota inode present\n"), s);
return 0;
}
id = (xfs_dqid_t)strtol(argv[optind], &p, 0);
if (*p != '\0') {
dbprintf(_("bad %s id for dquot %s\n"), s, argv[optind]);
return 0;
}
perblock = (int)(mp->m_sb.sb_blocksize / sizeof(xfs_dqblk_t));
qbno = (xfs_fileoff_t)id / perblock;
qoff = (int)(id % perblock);
push_cur();
set_cur_inode(ino);
nex = 1;
bmap(qbno, 1, XFS_DATA_FORK, &nex, &bm);
pop_cur();
if (nex == 0) {
dbprintf(_("no %s quota data for id %d\n"), s, id);
return 0;
}
set_cur(&typtab[TYP_DQBLK], XFS_FSB_TO_DADDR(mp, bm.startblock), blkbb,
DB_RING_IGN, NULL);
off_cur(qoff * (int)sizeof(xfs_dqblk_t), sizeof(xfs_dqblk_t));
ring_add();
return 0;
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolGeomWithJoin::track_join(){
i2dvertex br;
if(get_join(&br)){
set_cur(&br);
}
}
void
bmap(
xfs_dfiloff_t offset,
xfs_dfilblks_t len,
int whichfork,
int *nexp,
bmap_ext_t *bep)
{
struct xfs_btree_block *block;
xfs_fsblock_t bno;
xfs_dfiloff_t curoffset;
xfs_dinode_t *dip;
xfs_dfiloff_t eoffset;
xfs_bmbt_rec_64_t *ep;
xfs_dinode_fmt_t fmt;
int fsize;
xfs_bmbt_key_t *kp;
int n;
int nex;
xfs_fsblock_t nextbno;
int nextents;
xfs_bmbt_ptr_t *pp;
xfs_bmdr_block_t *rblock;
typnm_t typ;
xfs_bmbt_rec_64_t *xp;
push_cur();
set_cur_inode(iocur_top->ino);
nex = *nexp;
*nexp = 0;
ASSERT(nex > 0);
dip = iocur_top->data;
n = 0;
eoffset = offset + len - 1;
curoffset = offset;
fmt = (xfs_dinode_fmt_t)XFS_DFORK_FORMAT(dip, whichfork);
typ = whichfork == XFS_DATA_FORK ? TYP_BMAPBTD : TYP_BMAPBTA;
ASSERT(typtab[typ].typnm == typ);
ASSERT(fmt == XFS_DINODE_FMT_LOCAL || fmt == XFS_DINODE_FMT_EXTENTS ||
fmt == XFS_DINODE_FMT_BTREE);
if (fmt == XFS_DINODE_FMT_EXTENTS) {
nextents = XFS_DFORK_NEXTENTS(dip, whichfork);
xp = (xfs_bmbt_rec_64_t *)XFS_DFORK_PTR(dip, whichfork);
for (ep = xp; ep < &xp[nextents] && n < nex; ep++) {
if (!bmap_one_extent(ep, &curoffset, eoffset, &n, bep))
break;
}
} else if (fmt == XFS_DINODE_FMT_BTREE) {
push_cur();
bno = NULLFSBLOCK;
rblock = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
fsize = XFS_DFORK_SIZE(dip, mp, whichfork);
pp = XFS_BMDR_PTR_ADDR(rblock, 1, xfs_bmdr_maxrecs(mp, fsize, 0));
kp = XFS_BMDR_KEY_ADDR(rblock, 1);
bno = select_child(curoffset, kp, pp,
be16_to_cpu(rblock->bb_numrecs));
for (;;) {
set_cur(&typtab[typ], XFS_FSB_TO_DADDR(mp, bno),
blkbb, DB_RING_IGN, NULL);
block = (struct xfs_btree_block *)iocur_top->data;
if (be16_to_cpu(block->bb_level) == 0)
break;
pp = XFS_BMDR_PTR_ADDR(block, 1,
xfs_bmbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0));
kp = XFS_BMDR_KEY_ADDR(block, 1);
bno = select_child(curoffset, kp, pp,
be16_to_cpu(block->bb_numrecs));
}
for (;;) {
nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
nextents = be16_to_cpu(block->bb_numrecs);
xp = (xfs_bmbt_rec_64_t *)
XFS_BMBT_REC_ADDR(mp, block, 1);
for (ep = xp; ep < &xp[nextents] && n < nex; ep++) {
if (!bmap_one_extent(ep, &curoffset, eoffset,
&n, bep)) {
nextbno = NULLFSBLOCK;
break;
}
}
bno = nextbno;
if (bno == NULLFSBLOCK)
break;
set_cur(&typtab[typ], XFS_FSB_TO_DADDR(mp, bno),
blkbb, DB_RING_IGN, NULL);
block = (struct xfs_btree_block *)iocur_top->data;
}
pop_cur();
}
pop_cur();
*nexp = n;
}