void Character::jump() { if ((_state&BAN_JUMP))return; //if (_state & IS_DROPPING)return; /*if (_jumpCnt == 0 && _playerState != PS_WALK) { return false; } if (_jumpCnt >= 2) { return false; } if (!touchBegin) { if (_playerState == PS_JUMP) { _jumpAction->change(); } return false; }*/ if (_jumpCnt >=1)return; //if (_state == PS_JUMP || _playerState == PS_JUMPBACK) if(_state & IS_JUMPING) { //this->stopActionByTag(11);//rotate this->stopActionByTag(JUMPSEQ_TAG);//jumpseq //this->stopActionByTag(DROP_TAG);//jumpdone } BIT_ON(_state , IS_JUMPING); //runRotateAction(); // _jumpAction = MyJump::create((float)240 / (float)80 / (float)10, ccp(0, 240), 60, 1); auto _jumpAction = JumpBy::create(JUMP_DURATION, Vec2(0, JUMP_HEIGHT), JUMP_HEIGHT, 1); //auto _jumpAction = MoveBy::create(JUMP_DURATION, Vec2(0, JUMP_HEIGHT*2)); _jumpAction->setTag(JUMP_TAG); auto jumpSeq = Sequence::create( _jumpAction, CallFunc::create(CC_CALLBACK_0(Character::drop,this)), NULL); jumpSeq->setTag(JUMPSEQ_TAG); _jumpCnt++; //BIT_OFF(_state, IS_DROPPING); BIT_ON(_state, IS_JUMPING); this->runAction(jumpSeq); /*GameLayer * gl = (GameLayer *)this->getParent(); if (gl->soundIsOn()){ if (_jumpCnt == 1) { cd::SimpleAudioEngine::sharedEngine()->playEffect("sounds/jumpA.wav"); } else if (_jumpCnt == 2) { cd::SimpleAudioEngine::sharedEngine()->playEffect("sounds/jumpB.wav"); } }*/ //return true; }
void Character::move(Vec2 dir) { if ((_state & BAN_MOVE))return; if (_state & IS_MOVING)return; //if (LOCK)return; //dir.y-=0.1f; if (dir.x < 0)dir = Vec2(-MOVE_SPEED_PER_F,0); else dir=Vec2(MOVE_SPEED_PER_F, 0); //if(dir.x>0?CH_RIGHT:CH_LEFT; auto call = [&]() { BIT_OFF(_state,IS_MOVING); }; // auto callEnd = [&]() { //this->stateFlag&=~flag;}; auto action = MoveBy::create(MOVE_DURATION, dir); auto actionSeq = Sequence::create( action, CallFunc::create(call), NULL ); BIT_ON(_state, IS_MOVING); actionSeq->setTag(MOVE_TAG); this->runAction(actionSeq); //this->runActionWithFlag(actionMove,flag); log("WH:ch moved to (%f,%f)" , this->getPositionX() , this->getPositionY()); }
//========================================================================= // blinkLED: routine that will blink an led when vxWorks is running //========================================================================= // from winSH: -> show_active starts the thread // -> td "show_active" kills the thread //========================================================================= static void blinkLED() { static int count=0; int leds=GET_LEDS; while (1) { if(count) BIT_ON(leds,HOST_ACTIVE_LED); else BIT_OFF(leds,HOST_ACTIVE_LED); SET_LEDS(leds); count=count?0:1; taskDelay(calcSysClkTicks(83)); /* taskDelay(5); */ } }
static void* unixfs_internal_init(const char* dmg, uint32_t flags, fs_endian_t fse, char** fsname, char** volname) { int fd = -1; if ((fd = open(dmg, O_RDONLY)) < 0) { perror("open"); return NULL; } int err, i; struct stat stbuf; struct super_block* sb = (struct super_block*)0; struct filsys* fs = (struct filsys*)0; assert(sizeof(struct spcl) == BSIZE); if ((err = fstat(fd, &stbuf)) != 0) { perror("fstat"); goto out; } if (!S_ISREG(stbuf.st_mode) && !(flags & UNIXFS_FORCE)) { err = EINVAL; fprintf(stderr, "%s is not a tape dump image file\n", dmg); goto out; } if ((stbuf.st_size % TAPE_BSIZE) && !(flags & UNIXFS_FORCE)) { err = EINVAL; fprintf(stderr, "%s is not a multiple of tape block size\n", dmg); goto out; } if (S_ISREG(stbuf.st_mode) && (stbuf.st_size < TAPE_BSIZE)) { err = EINVAL; fprintf(stderr, "*** fatal error: %s is smaller in size than a " "physical tape block\n", dmg); goto out; } sb = malloc(sizeof(struct super_block)); if (!sb) { err = ENOMEM; goto out; } fs = calloc(1, sizeof(struct filsys)); if (!fs) { free(sb); err = ENOMEM; goto out; } unixfs = sb; unixfs->s_flags = flags; unixfs->s_endian = (fse == UNIXFS_FS_INVALID) ? UNIXFS_FS_PDP : fse; unixfs->s_fs_info = (void*)fs; unixfs->s_bdev = fd; unixfs->s_statvfs.f_bsize = BSIZE; unixfs->s_statvfs.f_frsize = BSIZE; fs->s_fsize += stbuf.st_size / BSIZE; /* must initialize the inode layer before sanity checking */ if ((err = unixfs_inodelayer_init(sizeof(struct tap_node_info))) != 0) goto out; struct spcl spcl; if (ancientfs_dump_readheader(fd, &spcl) != 0) { fprintf(stderr, "failed to read dump header\n"); err = EINVAL; goto out; } if (spcl.c_type != TS_TAPE) { fprintf(stderr, "failed to recognize image as a tape dump\n"); err = EINVAL; goto out; } fs->s_date = fs32_to_host(unixfs->s_endian, spcl.c_date); fs->s_ddate = fs32_to_host(unixfs->s_endian, spcl.c_ddate); int done = 0; while (!done) { err = ancientfs_dump_readheader(fd, &spcl); if (err) { if (err != 1) { fprintf(stderr, "*** warning: no tape header: retrying\n"); continue; } else { fprintf(stderr, "failed to read next header (%d)\n", err); err = EINVAL; goto out; } } next: switch (spcl.c_type) { case TS_TAPE: break; case TS_END: done = 1; break; case TS_BITS: if (!fs->s_initialized) { fs->s_initialized = 1; int count = spcl.c_count; char* bmp = (char*)fs->s_dumpmap; while (count--) { if (read(fd, bmp, BSIZE) != BSIZE) { fprintf(stderr, "*** fatal error: failed to read bitmap\n"); err = EIO; goto out; } /* fix up endian-ness */ int idx; for (idx = 0; idx < BSIZE/sizeof(uint16_t); idx++) bmp[idx] = fs16_to_host(unixfs->s_endian, bmp[idx]); bmp += BSIZE / sizeof(uint16_t); } } else { fprintf(stderr, "*** warning: duplicate inode map\n"); /* ignore the data */ (void)lseek(fd, (off_t)(spcl.c_count * BSIZE), SEEK_CUR); } break; case TS_INODE: { struct dinode* dip = &spcl.c_dinode; a_ino_t candidate = spcl.c_inumber; if ((!BIT_ON(candidate, fs->s_dumpmap)) || (candidate == BADINO)) continue; struct inode* ip = unixfs_inodelayer_iget((ino_t)candidate); if (!ip) { fprintf(stderr, "*** fatal error: no inode for %llu\n", (ino64_t)candidate); abort(); } struct tap_node_info* ti = (struct tap_node_info*)ip->I_private; ti->ti_daddr = NULL; assert(!ip->I_initialized); ip->I_number = (ino_t)candidate; ip->I_mode = dip->di_mode; ip->I_nlink = dip->di_nlink; ip->I_uid = dip->di_uid; ip->I_gid = dip->di_gid; ip->I_size = dip->di_size; ip->I_atime_sec = dip->di_atime; ip->I_mtime_sec = dip->di_mtime; ip->I_ctime_sec = dip->di_ctime; if (S_ISDIR(ip->I_mode)) fs->s_directories++; else fs->s_files++; /* populate i_daddr */ off_t nblocks = (off_t)((ip->I_size + (BSIZE - 1)) / BSIZE); ti->ti_daddr = (uint32_t*)calloc(nblocks, sizeof(uint32_t)); if (!ti->ti_daddr) { fprintf(stderr, "*** fatal error: cannot allocate memory\n"); abort(); } int block_index = 0; for (i = 0; i < nblocks; i++) { if (block_index >= spcl.c_count) { if (ancientfs_dump_readheader(fd, &spcl) == -1) { fprintf(stderr, "*** fatal error: cannot read header\n"); abort(); } if (spcl.c_type != TS_ADDR) { fprintf(stderr, "*** warning: expected TS_ADDR but " "got %hd\n", spcl.c_type); int k = i; for (; k < nblocks; k++) ti->ti_daddr[k] = 0; goto next; } block_index = 0; } if (spcl.c_addr[block_index]) { off_t nextb = lseek(fd, (off_t)BSIZE, SEEK_CUR); if (nextb == -1) { fprintf(stderr, "*** fatal error: cannot read tape\n"); abort(); } ti->ti_daddr[i] = spcl.c_tapea + block_index + 1; } else { ti->ti_daddr[i] = 0; /* zero fill */ } block_index++; } if (S_ISCHR(ip->I_mode) || S_ISBLK(ip->I_mode)) { char* p1 = (char*)(ip->I_daddr); char* p2 = (char*)(dip->di_addr); for (i = 0; i < 4; i++) { *p1++ = *p2++; *p1++ = 0; *p1++ = *p2++; *p1++ = *p2++; } ip->I_daddr[0] = fs32_to_host(unixfs->s_endian, ip->I_daddr[0]); uint32_t rdev = ip->I_daddr[0]; ip->I_rdev = makedev((rdev >> 8) & 255, rdev & 255); } if (ip->I_ino > fs->s_lastino) fs->s_lastino = ip->I_ino; unixfs_inodelayer_isucceeded(ip); } break; } }
int main ( int argc , const char* argv[] ) { mcxIO* xf_tab = NULL ; mcxIO* xf_tabr = NULL ; mcxIO* xf_tabc = NULL ; mcxIO* xf_restrict_tab = NULL ; mcxIO* xf_restrict_tabr = NULL ; mcxIO* xf_restrict_tabc = NULL ; mcxIO* xf_mx = mcxIOnew("-", "r") ; mcxIO* xfout = NULL ; const char* fndump = "-" ; mclTab* tabr = NULL ; mclTab* tabc = NULL ; mclTab* restrict_tabr = NULL ; mclTab* restrict_tabc = NULL ; mcxbool transpose = FALSE ; mcxbool lazy_tab = FALSE ; mcxbool write_tabc = FALSE ; mcxbool write_tabr = FALSE ; mcxbool cat = FALSE ; mcxbool tree = FALSE ; mcxbool skel = FALSE ; mcxbool newick = FALSE ; mcxbits newick_bits = 0 ; mcxbits cat_bits = 0 ; dim catmax = 1 ; dim n_max = 0 ; dim table_nlines = 0 ; dim table_nfields = 0 ; int split_idx = 1 ; int split_inc = 1 ; const char* split_stem = NULL ; const char* sort_mode = NULL ; mcxTing* line = mcxTingEmpty(NULL, 10) ; mcxbits modes = MCLX_DUMP_VALUES ; mcxbits mode_dump = MCLX_DUMP_PAIRS ; mcxbits mode_part = 0 ; mcxbits mode_loop = MCLX_DUMP_LOOP_ASIS ; mcxbits mode_matrix = 0 ; int digits = MCLXIO_VALUE_GETENV ; mcxOption* opts, *opt ; mcxstatus parseStatus = STATUS_OK ; mcxLogLevel = MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN ; mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_YES) ; mclx_app_init(stderr) ; mcxOptAnchorSortById(options, sizeof(options)/sizeof(mcxOptAnchor) -1) ; opts = mcxOptParse(options, (char**) argv, argc, 1, 0, &parseStatus) ; if (!opts) exit(0) ; for (opt=opts;opt->anch;opt++) { mcxOptAnchor* anch = opt->anch ; switch(anch->id) { case MY_OPT_HELP : case MY_OPT_APROPOS : mcxOptApropos(stdout, me, syntax, 0, 0, options) ; return 0 ; case MY_OPT_VERSION : app_report_version(me) ; return 0 ; case MY_OPT_TAB : xf_tab = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_TABC : xf_tabc = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_TABR : xf_tabr = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_OUTPUT : fndump = opt->val ; break ; case MY_OPT_SEP_LEAD : sep_lead_g = opt->val ; break ; case MY_OPT_SEP_FIELD : sep_row_g = opt->val ; break ; case MY_OPT_SEP_CAT : sep_cat_g = opt->val ; break ; case MY_OPT_SEP_VAL : sep_val_g = opt->val ; break ; case MY_OPT_PREFIXC : prefixc_g = opt->val ; break ; case MY_OPT_RESTRICT_TAB : xf_restrict_tab = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_RESTRICT_TABC : xf_restrict_tabc = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_RESTRICT_TABR : xf_restrict_tabr = mcxIOnew(opt->val, "r") ; break ; case MY_OPT_LAZY_TAB : lazy_tab = TRUE ; break ; case MY_OPT_NO_VALUES : BIT_OFF(modes, MCLX_DUMP_VALUES) ; break ; case MY_OPT_DUMP_RLINES : mode_dump = MCLX_DUMP_LINES ; BIT_ON(modes, MCLX_DUMP_NOLEAD) ; break ; case MY_OPT_DUMP_VLINES : mode_dump = MCLX_DUMP_LINES ; BIT_ON(modes, MCLX_DUMP_LEAD_VALUE) ; break ; case MY_OPT_DUMP_LINES : mode_dump = MCLX_DUMP_LINES ; break ; case MY_OPT_OMIT_EMPTY : BIT_ON(modes, MCLX_DUMP_OMIT_EMPTY) ; break ; case MY_OPT_SORT : sort_mode = opt->val ; break ; case MY_OPT_NO_LOOPS : mode_loop = MCLX_DUMP_LOOP_NONE ; break ; case MY_OPT_CAT_LIMIT : n_max = atoi(opt->val) ; break ; case MY_OPT_SPLIT_STEM : split_stem = opt->val ; sep_cat_g = NULL ; break ; case MY_OPT_FORCE_LOOPS : mode_loop = MCLX_DUMP_LOOP_FORCE ; break ; case MY_OPT_SKEL : skel = TRUE ; break ; case MY_OPT_WRITE_TABC : write_tabc = TRUE ; break ; case MY_OPT_DIGITS : digits = strtol(opt->val, NULL, 10) ; break ; case MY_OPT_WRITE_TABR : write_tabr = TRUE ; break ; case MY_OPT_DUMP_RDOM : transpose = TRUE ; skel = TRUE ; mode_dump = MCLX_DUMP_LINES ; break ; case MY_OPT_DUMP_CDOM : skel = TRUE ; mode_dump = MCLX_DUMP_LINES ; break ; case MY_OPT_IMX : mcxIOnewName(xf_mx, opt->val) ; break ; case MY_OPT_ICL : mcxIOnewName(xf_mx, opt->val) ; mode_dump = MCLX_DUMP_LINES ; BIT_ON(modes, MCLX_DUMP_NOLEAD) ; BIT_OFF(modes, MCLX_DUMP_VALUES) ; break ; case MY_OPT_TREECAT : mcxIOnewName(xf_mx, opt->val) ; tree = TRUE ; cat_bits |= MCLX_PRODUCE_DOMSTACK ; break ; case MY_OPT_CAT : mcxIOnewName(xf_mx, opt->val) ; cat = TRUE ; break ; case MY_OPT_DUMP_MATRIX : mode_matrix |= MCLX_DUMP_MATRIX ; break ; case MY_OPT_TRANSPOSE : transpose = TRUE ; break ; case MY_OPT_DUMP_UPPER : mode_part = MCLX_DUMP_PART_UPPER ; break ; case MY_OPT_DUMP_UPPERI : mode_part = MCLX_DUMP_PART_UPPERI ; break ; case MY_OPT_DUMP_LOWER : mode_part = MCLX_DUMP_PART_LOWER ; break ; case MY_OPT_DUMP_LOWERI : mode_part = MCLX_DUMP_PART_LOWERI ; break ; case MY_OPT_DUMP_NOLEAD : BIT_ON(modes, MCLX_DUMP_NOLEAD) ; break ; case MY_OPT_NEWICK_MODE : if (strchr(opt->val, 'N')) newick_bits |= (MCLX_NEWICK_NONL | MCLX_NEWICK_NOINDENT) ; if (strchr(opt->val, 'I')) newick_bits |= MCLX_NEWICK_NOINDENT ; if (strchr(opt->val, 'B')) newick_bits |= MCLX_NEWICK_NONUM ; if (strchr(opt->val, 'S')) newick_bits |= MCLX_NEWICK_NOPTHS ; newick = TRUE ; break ; case MY_OPT_DUMP_NEWICK : newick = TRUE ; break ; case MY_OPT_DUMP_TABLE : mode_dump = MCLX_DUMP_TABLE ; break ; case MY_OPT_TABLE_NFIELDS : table_nfields = atoi(opt->val) ; break ; case MY_OPT_TABLE_NLINES : table_nlines = atoi(opt->val) ; break ; case MY_OPT_DUMP_PAIRS : mode_dump = MCLX_DUMP_PAIRS ; break ; } } ; if (skel) cat_bits |= MCLX_READ_SKELETON ; modes |= mode_loop | mode_dump | mode_part | mode_matrix ; xfout = mcxIOnew(fndump, "w") ; mcxIOopen(xfout, EXIT_ON_FAIL) ; mcxIOopen(xf_mx, EXIT_ON_FAIL) ; if (cat || tree) catmax = n_max ? n_max : 0 ; if ((write_tabc || write_tabr) && !xf_tab) mcxDie(1, me, "need a single tab file (-tab option) with --write-tabc or --write-tabr") ; if (xf_tab && mcxIOopen(xf_tab, RETURN_ON_FAIL)) mcxDie(1, me, "no tab") ; else { if (xf_tabr && mcxIOopen(xf_tabr, RETURN_ON_FAIL)) mcxDie(1, me, "no tabr") ; if (xf_tabc && mcxIOopen(xf_tabc, RETURN_ON_FAIL)) mcxDie(1, me, "no tabc") ; } { if (xf_restrict_tab && mcxIOopen(xf_restrict_tab, RETURN_ON_FAIL)) mcxDie(1, me, "no restriction tab") ; else { if (xf_restrict_tabr && mcxIOopen(xf_restrict_tabr, RETURN_ON_FAIL)) mcxDie(1, me, "no restriction tabr") ; if (xf_restrict_tabc && mcxIOopen(xf_restrict_tabc, RETURN_ON_FAIL)) mcxDie(1, me, "no restriction tabc") ; } /* fixme: below is pretty boilerplate, happens in other places as well */ if (xf_restrict_tab) { if (!(restrict_tabr = mclTabRead (xf_restrict_tab, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading restriction tab") ; restrict_tabc = restrict_tabr ; mcxIOclose(xf_restrict_tab) ; } else { if (xf_restrict_tabr) { if (!(restrict_tabr = mclTabRead(xf_restrict_tabr, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading restriction tabr") ; mcxIOclose(xf_restrict_tabr) ; } if (xf_restrict_tabc) { if (!(restrict_tabc = mclTabRead(xf_restrict_tabc, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading restriction tabc") ; mcxIOclose(xf_restrict_tabc) ; } } } /* fixme: restructure code to include bit below */ if (write_tabc || write_tabr) { mclv* dom_cols = mclvInit(NULL) ; mclv* dom_rows = mclvInit(NULL) ; mclv* dom = write_tabc ? dom_cols : dom_rows ; if (!(tabc = mclTabRead(xf_tab, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading tab file") ; if (mclxReadDomains(xf_mx, dom_cols, dom_rows)) mcxDie(1, me, "error reading matrix file") ; mcxIOclose(xf_mx) /* fixme check status */ ; mclTabWrite(tabc, xfout, dom, RETURN_ON_FAIL) ; mcxIOclose(xfout) ; return 0 ; } if (newick) { mcxTing* thetree ; mclxCat cat ; if (xf_tab && !(tabr = mclTabRead(xf_tab, NULL, RETURN_ON_FAIL))) mcxDie(1, me, "error reading tab file") ; mclxCatInit(&cat) ; if ( mclxCatRead ( xf_mx , &cat , 0 , NULL , tabr ? tabr->domain : NULL , MCLX_CATREAD_CLUSTERTREE | MCLX_ENSURE_ROOT ) ) mcxDie(1, me, "failure reading file") ; thetree = mclxCatNewick(&cat, tabr, newick_bits) ; fwrite(thetree->str, 1, thetree->len, xfout->fp) ; fputc('\n', xfout->fp) ; mcxIOclose(xfout) ; return 0 ; } while (1) { mclxIOdumper dumper ; mclxCat cat ; dim i ; if (xf_tab && !lazy_tab) cat_bits |= MCLX_REQUIRE_GRAPH ; mclxCatInit(&cat) ; if (mclxCatRead(xf_mx, &cat, catmax, NULL, NULL, cat_bits)) break ; for (i=0;i<cat.n_level;i++) { mclx* mx = cat.level[i].mx ; if (restrict_tabr || restrict_tabc) { mclx* sub ; sub = mclxSub ( mx , restrict_tabc ? restrict_tabc->domain : mx->dom_cols , restrict_tabr ? restrict_tabr->domain : mx->dom_rows ) ; mx = sub ; } /* noteme fixme dangersign mx now may violate some 'cat' invariant */ if (sort_mode) { if (!strcmp(sort_mode, "size-ascending")) mclxColumnsRealign(mx, mclvSizeCmp) ; else if (!strcmp(sort_mode, "size-descending")) mclxColumnsRealign(mx, mclvSizeRevCmp) ; else mcxErr(me, "unknown sort mode <%s>", sort_mode) ; if (catmax != 1) mcxErr(me, "-sort option and cat mode may fail or corrupt") ; } if (xf_tab && !tabr) { if (!( tabr = mclTabRead (xf_tab, lazy_tab ? NULL : mx->dom_rows, RETURN_ON_FAIL) ) ) mcxDie(1, me, "consider using --lazy-tab option") ; tabc = tabr ; mcxIOclose(xf_tab) ; } else { if (!tabr && xf_tabr) { if (!(tabr = mclTabRead (xf_tabr, lazy_tab ? NULL : mx->dom_rows, RETURN_ON_FAIL) ) ) mcxDie(1, me, "consider using --lazy-tab option") ; mcxIOclose(xf_tabr) ; } if (!tabc && xf_tabc) { if (!( tabc = mclTabRead (xf_tabc, lazy_tab ? NULL : mx->dom_cols, RETURN_ON_FAIL) ) ) mcxDie(1, me, "consider using --lazy-tab option") ; mcxIOclose(xf_tabc) ; } } ; if (transpose) { mclx* tp = mclxTranspose(mx) ; mclxFree(&mx) ; mx = tp ; if (tabc || tabr) { mclTab* tabt = tabc ; tabc = tabr ; tabr = tabt ; } } if (mode_dump == MCLX_DUMP_TABLE) BIT_ON(modes, MCLX_DUMP_TABLE_HEADER) ; mclxIOdumpSet(&dumper, modes, sep_lead_g, sep_row_g, sep_val_g) ; dumper.table_nlines = table_nlines ; dumper.table_nfields = table_nfields ; dumper.prefixc = prefixc_g ; if (split_stem) { mcxTing* ting = mcxTingPrint(NULL, "%s.%03d", split_stem, split_idx) ; mcxIOclose(xfout) ; mcxIOrenew(xfout, ting->str, "w") ; split_idx += split_inc ; } if ( mclxIOdump ( mx , xfout , &dumper , tabc , tabr , digits , RETURN_ON_FAIL ) ) mcxDie(1, me, "something suboptimal") ; mclxFree(&mx) ; if (sep_cat_g && i+1 < cat.n_level) fprintf(xfout->fp, "%s\n", sep_cat_g) ; } break ; } mcxIOfree(&xf_mx) ; mcxIOfree(&xfout) ; mcxIOfree(&xf_tab) ; mcxIOfree(&xf_tabr) ; mcxIOfree(&xf_tabc) ; mcxTingFree(&line) ; return 0 ; }