/*Faz o bubble up da heap*/ void bubbleUp (Elem h[], int i){ while(i>0){ if(h[UP(i)]->vendas > h[i]->vendas) swap(h,UP(i),i); else break; i = UP(i); } }
/* * term_CS_scroll: should be used if the terminal has the CS capability by * setting term_scroll equal to it */ static int term_CS_scroll(int line1, int line2, int n) { int i; u_char *thing; if (n > 0) thing = UP(SF ? SF : NL); else if (n < 0) { if (SR) thing = UP(SR); else return 1; } else return 0; tputs_x(tgoto(CS, line2, line1)); /* shouldn't do this each time */ if (n < 0) { term_move_cursor(0, line1); n = -n; } else term_move_cursor(0, line2); for (i = 0; i < n; i++) tputs_x(CP(thing)); tputs_x(tgoto(CS, get_li() - 1, 0)); /* shouldn't do this each time */ return (0); }
static int unitgen(Chan *c, ulong type, Dir *dp) { int perm, t; ulong vers; vlong size; char *p; Aoedev *d; Qid q; d = unit2dev(UNIT(c->qid)); perm = 0644; size = 0; vers = d->vers; t = QTFILE; switch(type){ default: return -1; case Qctl: p = "ctl"; break; case Qdata: p = "data"; perm = 0640; if(UP(d)) size = d->bsize; break; case Qconfig: p = "config"; if(UP(d)) size = d->nconfig; break; case Qident: p = "ident"; if(UP(d)) size = sizeof d->ident; break; case Qdevlinkdir: p = "devlink"; t = QTDIR; perm = 0555; break; } mkqid(&q, QID(UNIT(c->qid), type), vers, t); devdir(c, q, p, size, eve, perm, dp); return 1; }
int do_mkdir (struct inode *inode, const char *name, int len, int mode) { #if USE_DENTRY_F struct dentry *tmp_dent; #endif int ret_code; DOWN(&(inode->i_sem)); #if USE_DENTRY_F /* Create a temporary negative dentry for the target. */ ret_code = ovlfs_inode_get_child_dentry(inode, name, len, &tmp_dent, OVLFS_DENT_GET_NEGATIVE); if ( ret_code == 0 ) { /* Use the vfs_mkdir function to do the dirty work. */ ret_code = vfs_mkdir(inode, tmp_dent, mode); dput(tmp_dent); } #else IMARK(inode); ret_code = inode->i_op->mkdir(inode, name, len, mode); #endif UP(&(inode->i_sem)); return ret_code; }
int do_create (struct inode *dir_i, const char *name, int len, int mode, struct dentry **r_dent) { struct dentry *dent; int ret; ret = 0; DOWN(&(dir_i->i_sem)); ret = ovlfs_inode_get_child_dentry(dir_i, name, len, &dent, OVLFS_DENT_GET_NEGATIVE); if ( ret == 0 ) { /* Create the entry using vfs_create to do all the */ /* "dirty work". */ ret = vfs_create(dir_i, dent, mode); if ( ret == 0 ) { if ( dent->d_inode == NULL ) ret = -ENOENT; else r_dent[0] = dent; } } UP(&(dir_i->i_sem)); return ret; }
bool PSPKeyboard::handleMoveState(SceCtrlData &pad) { DEBUG_ENTER_FUNC(); if (UP(PSP_CTRL_SELECT)) { // Toggle between visible and invisible _state = (_lastState == kInvisible) ? kDefault : kInvisible; _dirty = true; if (_moved) { // We moved the keyboard. Keep the keyboard onscreen anyway _state = kDefault; _moved = false; // reset moved flag } if (_state == kInvisible) { return true; // we become invisible } } else if (DOWN(PSP_DPAD)) { // How we move the KB onscreen _moved = true; _dirty = true; if (DOWN(PSP_CTRL_DOWN)) increaseKeyboardLocationY(5); else if (DOWN(PSP_CTRL_UP)) increaseKeyboardLocationY(-5); else if (DOWN(PSP_CTRL_LEFT)) increaseKeyboardLocationX(-5); else /* DOWN(PSP_CTRL_RIGHT) */ increaseKeyboardLocationX(5); } return false; }
void TestScene11::runPURGE() { // initialize framework PURGEBridge::Ogre_1_7::OgreRenderer::createInstance("./resources/Ogre"); // open window PURGE::Window::create(800, 600); // adjust camera auto camera = PURGE::Camera::create() ->move(PURGE::Vector3(100, 100, 100)) ->setDirection(PURGE::Vector3(-1, -1, -1)); PURGE::ObjectGroup* groups[ROWS]; for (int i = 0; i < ROWS; i++) { groups[i] = PURGE::ObjectGroup::create(); } // load & integrate model for (int i = 0; i < ROWS * COLS; i++) { PURGE::ModelNode::create(PURGE::ModelDefinition::load("cube")) ->move(-LEFT(i), UP(i), 0, camera) ->attachTo(groups[i % ROWS]); } // loop runPURGELoop(); }
int main(int argc, char const *argv[]) { init(); creat_POSIX(); DIR1 = DIR; //if the player change the direction of snake,change the DIR and Pirnt the new snake while(1){ if (DIR != DIR1) { DIR = DIR1; } switch(DIR){ case up: UP(); break; case down: DOWN(); break; case left: LEFT(); break; case right: RIGHT(); break; default: break; }; Print(); usleep(speed); } return 0; }
int do_rmdir (struct inode *inode, const char *name, int len) { #if POST_20_KERNEL_F struct dentry *tmp_dent; #endif int ret_code; DOWN(&(inode->i_sem)); #if POST_20_KERNEL_F /* Grab a dentry for the directory being removed. */ ret_code = ovlfs_inode_get_child_dentry(inode, name, len, &tmp_dent, OVLFS_DENT_GET_POSITIVE); if ( ret_code == 0 ) { /* Use the vfs_rmdir function to do the dirty work. */ ret_code = vfs_rmdir(inode, tmp_dent); dput(tmp_dent); } #else IMARK(inode); ret = inode->i_op->rmdir(inode, name, len); #endif UP(&(inode->i_sem)); return ret_code; }
void TestScene12::runPURGE() { // initialize framework PURGEBridge::Ogre_1_7::OgreRenderer::createInstance("./resources/Ogre"); // open window PURGE::Window::create(800, 600); // adjust camera auto camera = PURGE::Camera::create() ->move(PURGE::Vector3(100, 100, 100)) ->setDirection(PURGE::Vector3(-1, -1, -1)); auto task = PURGE::SceneNodeModificationTask::create() ->rotate(PURGE::Degree(360 / 5), PURGE::CoordinateSystem::get().getUpVector()); PURGE::MainTaskGroup::get()->add(task); PURGE::ObjectGroup* groups[ROWS]; for (int i = 0; i < ROWS; i++) { groups[i] = PURGE::ObjectGroup::create(); task->registerNode(groups[i]); } // load & integrate model for (int i = 0; i < ROWS * COLS; i++) { PURGE::ModelNode::create(PURGE::ModelDefinition::load("cube")) ->move(-LEFT(i), UP(i), 0, camera) ->attachTo(groups[i % ROWS]); } // loop runPURGELoop(); }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) { // MACRODOWN only works in this function switch(id) { case 0 ... END_UC: if (record->event.pressed) { send_unicode(unicode_chars[id]); } break; case M_CSA_SFT: // BÉPO over CSA: toggle shift layer layer_invert(LR_CSA_SFT); if (record->event.pressed) { hold_shift(); } else { release_shift(); } break; case M_CSA_SFT_AGR: // BÉPO over CSA: from shift layer, momentary altgr+shift layer layer_invert(LR_CSA_AGR); layer_invert(LR_CSA_AGR_SFT); if (record->event.pressed) { // shift not needed for LR_CSA_AGR_SFT release_shift(); } else { // back to shift layer hold_shift(); } break; case M_CSA_AGR_SFT: // BÉPO over CSA: from altgr layer, momentary altgr+shift layer layer_invert(LR_CSA_SFT); layer_invert(LR_CSA_AGR_SFT); break; case M_1 ... M_0: case M_DEGR: case M_SCLN: case M_GRV: case M_NBSP: // macros of the shift layer that require to release shift if (record->event.pressed) { release_shift(); switch (id) { case M_1 ... M_0: register_code(KC_1 + (id - M_1)); break; case M_DEGR: return MACRO(DOWN(CSA_ALTGR), D(SCLN), END); case M_SCLN: return MACRO(D(SCLN), END); case M_GRV: return MACRO(I(75), DOWN(CSA_ALTGR), TYPE(CSA_DCRC), UP(CSA_ALTGR), T(SPACE), END); case M_NBSP: // use weak mod such that pressing another key will not be affected add_weak_mods(MOD_BIT(CSA_ALTGR)); return MACRO(D(SPACE), END); } } else {
int do_lookup2 (struct inode *inode, const char *name, int len, struct dentry **result, int lock_f) { struct dentry *tmp_dent; struct dentry *r_dent; int ret_code; if ( lock_f ) DOWN(&(inode->i_sem)); /* Grab a dentry for the directory. */ tmp_dent = ovlfs_inode2dentry(inode); if ( tmp_dent == NULL ) { WARN("failed to obtain dentry for dir inode %lu", inode->i_ino); return -ENOENT; } /* Perform the lookup; this will call the filesystem's */ /* lookup entry-point, if needed. */ r_dent = lookup_one_len(name, tmp_dent, len); if ( IS_ERR(r_dent) ) { ret_code = PTR_ERR(r_dent); } else if ( r_dent == NULL ) { ret_code = -ENOENT; } else if ( r_dent->d_inode == NULL ) { dput(r_dent); ret_code = -ENOENT; } else { ret_code = 0; result[0] = r_dent; } dput(tmp_dent); if ( lock_f ) UP(&(inode->i_sem)); return ret_code; }
int do_link (struct inode *inode, struct inode *dir, const char *name, int len) { #if USE_DENTRY_F struct dentry *ref_dent; struct dentry *new_dent; #endif int ret; DOWN(&(dir->i_sem)); #if POST_20_KERNEL_F /* Get a dentry for the link source. */ ref_dent = ovlfs_inode2dentry(inode); if ( ref_dent == NULL ) { ret = -ENOENT; } else { /* Create a temporary negative dentry for the target. */ ret = ovlfs_inode_get_child_dentry(dir, name, len, &new_dent, OVLFS_DENT_GET_NEGATIVE); if ( ret != 0 ) dput(ref_dent); } if ( ret == 0 ) { /* Use the vfs_link function to do the dirty work. */ ret = vfs_link(ref_dent, dir, new_dent); dput(ref_dent); dput(new_dent); } #else IMARK(inode); IMARK(dir); ret = dir->i_op->link(inode, dir, name, len); #endif UP(&(dir->i_sem)); return ret; }
void Move_chessman(void) { int row=35,column=35,count=0,key=0,flag=1; void far *image1=0,*image2=0; setcolor(WHITE); setfillstyle(SOLID_FILL,WHITE); sector(column,row,0,360,15,15); getimage(50,50,80,80,image); image_null=image; while(key!=27) { key=Getkey(); switch(key) { case 72 : row=Limit(72,row); UP(column,row); Trace(72,row); break; case 80 : row=Limit(80,row); DOWN(column,row); Trace(80,row); break; case 75 : column=Limit(75,column); LIFT(column,row); Trace(75,column); break; case 77 : column=Limit(77,column); RIGHT(column,row); Trace(77,column); break; case 13 : Computer(column,row); Move_chessman(); break; case 27 : END(); break; default : break; } } }
static METHOD knh__String_split(Ctx *ctx, knh_sfp_t *sfp) { Array *a = NULL; int istrim = IS_NULL(sfp[2].o) ? 0 : (int)sfp[2].ivalue; if(IS_NULL(sfp[1].o)) { a = knh_String_toCharArray(ctx, sfp[0].s, istrim); } else { knh_bytes_t delim = knh_String_tobytes(sfp[1].s); if(delim.len == 0) { a = knh_String_toCharArray(ctx, sfp[0].s, istrim); } else { knh_bytes_t base = knh_String_tobytes(sfp[0].s); a = new_Array(ctx, CLASS_String, 8); while(1) { knh_index_t loc = knh_bytes_indexOf(base, delim); if(loc == -1) { if(istrim) base = knh_bytes_trim(base); knh_Array_add(ctx, a, UP(new_String(ctx, base, sfp[0].s))); break; } else if(loc == 0) { knh_Array_add(ctx, a, UP(TS_EMPTY)); } else { knh_bytes_t t = knh_bytes_first(base, loc); if(istrim) t = knh_bytes_trim(t); knh_Array_add(ctx, a, UP(new_String(ctx, t, sfp[0].s))); } base.buf = base.buf + loc + delim.len; base.len = base.len - loc - delim.len; } } } KNH_ASSERT(a != NULL); KNH_RETURN(ctx, sfp, a); }
void foreach(u_char *command, u_char *args, u_char *subargs) { u_char *struc = NULL, *ptr, *body = NULL, *var = NULL; u_char **sublist; int total; int i; int slen; if ((ptr = new_next_arg(args, &args)) == NULL) { yell("FOREACH: missing structure expression"); return; } malloc_strcpy(&struc, ptr); malloc_strcat(&struc, UP(".")); upper(struc); if ((var = next_arg(args, &args)) == NULL) { new_free(&struc); yell("FOREACH: missing variable"); return; } while (isspace(*args)) args++; if ((body = next_expr(&args, '{')) == NULL) /* } */ { new_free(&struc); yell("FOREACH: missing statement"); return; } sublist = match_alias(struc, &total, VAR_ALIAS); slen = my_strlen(struc); for (i = 0; i < total; i++) { unsigned display; display = set_display_off(); add_alias(VAR_ALIAS, var, sublist[i]+slen); set_display(display); parse_line(NULL, body, subargs ? subargs : empty_string(), 0, 0, 0); new_free(&sublist[i]); } new_free(&sublist); new_free(&struc); }
// -------------------------------------------------------------------------------- // prüft Benutzereingabe einer Uhrzeit über Input und schreibt bei Validität die // Daten via der Funktion getTimeFromString in ein TTime Konstrukt // -------------------------------------------------------------------------------- int getTime(char *Titel, TTime *Time) { *Input = '\0'; int Erg = 0; // Prüft, ob nach der Dauer des Termins gefragt wurde if(*Titel == 'D') { TTime *Z = calloc (1, sizeof(TTime)); // Speicher für die Eingabe reservieren CLEAR_LINE; printf("%s ", Titel); scanf("%10[^\n qwertzuiopü+*asdfghjklöä#'<>yxcvbnm,._;MNBVCXYÄÖLKJHGFDSAÜPOIUZTREWQ!""§$%&/()=?`'@€~]", Input); clearBuffer(); if(!getTimeFromString(Input, Z)) //rekursiver Aufruf, falls Eingabe nicht valide { UP(1); getTime(Titel, Time); } Time = Z; free(Z); } else { // Für alle Zeitaufrufe ausser der Dauer CLEAR_LINE; printf("%s ", Titel); scanf("%10[^\n qwertzuiopü+*asdfghjklöä#'<>yxcvbnm,._;MNBVCXYÄÖLKJHGFDSAÜPOIUZTREWQ!""§$%&/()=?`'@€~]", Input); clearBuffer(); if(!getTimeFromString(Input, Time)) //rekursiver Aufruf, falls Eingabe nicht valide { UP(1); getTime(Titel, Time); } } return Erg; }
static METHOD knh__String_format(Ctx *ctx, knh_sfp_t *sfp) { knh_bytes_t fmt = knh_String_tobytes(sfp[0].s); knh_sfp_t *param = sfp + 1; int ac = knh_stack_argc(ctx, param); knh_bytes_t mt, expr, next; if(!knh_bytes_findMT(ctx, fmt, &mt, &expr, &next)) { KNH_RETURN(ctx, sfp, sfp[0].s); } knh_cwb_t cwbbuf, *cwb = knh_cwb_open(ctx, &cwbbuf); int count; for(count = 0; ; count++) { if(mt.buf > fmt.buf + 1) { fmt.len = (mt.buf - fmt.buf) - 1; knh_Bytes_write(ctx, cwb->ba, fmt); } int index = count; if(expr.len > 0) { knh_int_t num; if(knh_bytes_parseint(expr, &num)) { index = (int)num; } } if(0 <= index && index < ac) { knh_sfp_t *esp = KNH_LOCAL(ctx); KNH_SETv(ctx, esp[1].o, param[index].o); esp[1].data = param[index].data; Object *m = KNH_NULL; if(knh_bytes_isOptionalMT(mt)) m = UP(new_String(ctx, mt, NULL)); mt.buf = mt.buf - 1; mt.len++; /* 's' == > '%s' */ knh_methodn_t mn = knh_getmn(ctx, mt, METHODN__empty); knh_esp1_format(ctx, mn, cwb->w, m); } else { if(knh_Context_isDebug(ctx)) { KNH_THROW_OUTOFINDEX(ctx, index, ac); } } fmt.buf = next.buf; fmt.len = next.len; if(!knh_bytes_findMT(ctx, fmt, &mt, &expr, &next)) { break; } } if(fmt.len > 0) { knh_Bytes_write(ctx, cwb->ba, fmt); } KNH_RETURN(ctx, sfp, new_StringX__cwb(ctx, knh_Object_cid(sfp[0].o), cwb)); }
static Array *knh_String_toCharArray(Ctx *ctx, String *bs, int istrim) { knh_bytes_t base = knh_String_tobytes(bs); if(knh_String_isASCII(bs)) { size_t i, n = base.len; Array *a = new_Array(ctx, CLASS_String, n); for(i = 0; i < n; i++) { if(istrim && isspace(base.buf[i])) continue; knh_bytes_t sub = { base.buf + i, 1}; knh_Array_add(ctx, a, UP(new_String(ctx, sub, bs))); } return a; } else { size_t i, n = knh_bytes_mlen(base); Array *a = new_Array(ctx, CLASS_String, n); for(i = 0; i < n; i++) { if(istrim && isspace(base.buf[i])) continue; knh_bytes_t sub = knh_bytes_mofflen(base, n, 1); knh_Array_add(ctx, a, UP(new_String(ctx, sub, bs))); } return a; } }
/* * get_password: when a host responds that the user needs to supply a * password, it gets handled here! the user is prompted for a password and * then reconnection is attempted with that password. but, the reality of * the situation is that no one really uses user passwords. ah well */ static void get_password(void) { u_char server_num[8]; say("password required for connection to server %s", server_get_name(parsing_server())); close_server(parsing_server(), empty_string()); if (!term_basic()) { snprintf(CP(server_num), sizeof server_num, "%d", parsing_server()); add_wait_prompt(UP("Server Password:"), password_sendline, server_num, WAIT_PROMPT_LINE); } }
int do_readlink (struct inode *inode, char *buf, int size) { int ret; ret = 0; DOWN(&(inode->i_sem)); IMARK(inode); ret = inode->i_op->readlink(inode, buf, size); UP(&(inode->i_sem)); return ret; }
int do_create (struct inode *dir_i, const char *name, int len, int mode, struct inode **r_inode) { int ret; ret = 0; DOWN(&(dir_i->i_sem)); IMARK(dir_i); ret = dir_i->i_op->create(dir_i, name, len, ref->i_mode, r_inode); UP(&(dir_i->i_sem)); return ret; }
int do_readlink (struct dentry *dent, char *buf, int size) { int ret; ret = 0; DOWN(&(dent->d_inode->i_sem)); if ( dent == NULL ) ret = -ENOENT; else ret = dent->d_inode->i_op->readlink(dent, buf, size); UP(&(dent->d_inode->i_sem)); return ret; }
int do_rename (struct inode *olddir, const char *oname, int olen, struct inode *newdir, const char *nname, int nlen, int must_be_dir) { #if POST_20_KERNEL_F struct dentry *old_dent; struct dentry *new_dent; #endif int ret; #if POST_20_KERNEL_F ret = ovlfs_inode_get_child_dentry(olddir, oname, olen, &old_dent, OVLFS_DENT_GET_POSITIVE); if ( ret == 0 ) { /* Get a dentry for the target; note that this may */ /* be a positive or negative dentry. */ ret = ovlfs_inode_get_child_dentry(newdir, nname, nlen, &new_dent, OVLFS_DENT_GET_ANY); if ( ret != 0 ) dput(old_dent); } if ( ret == 0 ) { ret = vfs_rename(olddir, old_dent, newdir, new_dent); dput(old_dent); dput(new_dent); } #else DOWN(&(newdir->i_sem)); IMARK(olddir); IMARK(newdir); ret = o_olddir->i_op->rename(o_olddir, oname, olen, o_newdir, nname, nlen, must_be_dir); UP(&(newdir->i_sem)); #endif return ret; }
/* * Attempts to read a character from the controller * Uses the state machine. * returns whether we have an event */ bool PSPKeyboard::processInput(Common::Event &event, PspEvent &pspEvent, SceCtrlData &pad) { DEBUG_ENTER_FUNC(); bool haveEvent = false; // Whether we have an event for the event manager to process bool havePspEvent = false; event.kbd.flags = 0; _buttonsChanged = _prevButtons ^ pad.Buttons; if (!_init) // In case we never had init return false; if (_state == kInvisible) // Return if we're invisible return false; if (_state != kMove && PRESSED(PSP_CTRL_SELECT)) { _lastState = _state; _state = kMove; // Check for move or visible state } else if (CHANGED(PSP_CTRL_START)) { // Handle start button: enter, make KB invisible event.kbd.ascii = '\r'; event.kbd.keycode = Common::KEYCODE_RETURN; event.type = DOWN(PSP_CTRL_START) ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP; haveEvent = true; _dirty = true; if (UP(PSP_CTRL_START)) havePspEvent = true; } // Check for being in state of moving the keyboard onscreen or pressing select else if (_state == kMove) havePspEvent = handleMoveState(pad); else if (_state == kDefault) haveEvent = handleDefaultState(event, pad); else if (_state == kCornersSelected) haveEvent = handleCornersSelectedState(event, pad); else if (_state == kRTriggerDown) handleRTriggerDownState(pad); // Deal with trigger states else if (_state == kLTriggerDown) handleLTriggerDownState(pad); // Deal with trigger states if (havePspEvent) { pspEvent.type = PSP_EVENT_SHOW_VIRTUAL_KB; // tell the input handler we're off pspEvent.data = false; } _prevButtons = pad.Buttons; return haveEvent; }
static int input_is_password_prompt(void) { ScreenInputData *inputdata = screen_get_inputdata(get_current_screen()); u_char* buf = inputdata->buffer.buf; unsigned limit = inputdata->buffer.minpos; if (limit < 9) return 0; /* If the prompt ends with "Password:"******"Password:"******"Operator Password:"******"Server Password:"******"Password:"), 9) == 0; }
// -------------------------------------------------------------------------------- // prüft Benutzereingabe eines Datum über Input und schreibt bei Validität die // Daten via der Funktion getDateFromString in ein TDate Konstrukt // -------------------------------------------------------------------------------- int getDate(char *Titel, TDate *Date) // Einbage = Eingabebaufforderung { *Input = '\0'; CLEAR_LINE; printf("%s ", Titel); scanf("%10[^\n qwertzuiopü+*asdfghjklöä#'<>yxcvbnm,_:;MNBVCXYÄÖLKJHGFDSAÜPOIUZTREWQ!""§$%&/()=?`'@€~]", Input); clearBuffer(); if(!getDateFromString(Input, Date)) //rekursiver Aufruf, falls Eingabe nicht valide { UP(1); getDate(Titel, Date); } else return 1; return 0; }
void TestScene12::runOgre() { // initialize framework & open window Ogre::Root* root = new Ogre::Root(); root->restoreConfig(); root->initialise(false); auto window = root->createRenderWindow("Ogre RenderWindow", 800, 600, false); auto sceneMgr = root->createSceneManager(Ogre::ST_GENERIC); // adjust camera auto cam1 = sceneMgr->createCamera("cam1"); auto camNode1 = sceneMgr->getRootSceneNode()->createChildSceneNode("camnode1"); cam1->setNearClipDistance(5); camNode1->attachObject(cam1); camNode1->setPosition(Ogre::Vector3(100, 100, 100)); camNode1->lookAt(Ogre::Vector3(-1, -1, -1), Ogre::Node::TS_LOCAL); window->addViewport(cam1); // load & integrate model root->addResourceLocation("./resources/Ogre", "FileSystem"); Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); Mesh_Cube M(1); M.createMesh("cube"); Ogre::SceneNode* groups[ROWS]; std::list<Ogre::SceneNode*> nodes; for (int i = 0; i < ROWS; i++) { groups[i] = sceneMgr->getRootSceneNode()->createChildSceneNode(); nodes.push_back(groups[i]); } for (int i = 0; i < ROWS * COLS; i++) { auto node = groups[i % ROWS]->createChildSceneNode(); node->attachObject(sceneMgr->createEntity(std::string("model") + boost::lexical_cast<std::string>(i), "cube")); node->setPosition( camNode1->getOrientation() * -Ogre::Vector3::UNIT_X * LEFT(i) + camNode1->getOrientation() * Ogre::Vector3::UNIT_Y * UP(i) ); } root->addFrameListener(new MoveObjectTask_Ogre12(nodes)); // loop runOgreLoop(root); }
int do_lookup3 (struct dentry *dent, const char *name, int len, struct dentry **result, int lock_f) { struct dentry *r_dent; int ret_code; if ( lock_f ) DOWN(&(dent->d_inode->i_sem)); /* Perform the lookup; this will call the filesystem's */ /* lookup entry-point, if needed. */ r_dent = lookup_one_len(name, dent, len); if ( IS_ERR(r_dent) ) { ret_code = PTR_ERR(r_dent); } else if ( r_dent == NULL ) { ret_code = -ENOENT; } else if ( r_dent->d_inode == NULL ) { dput(r_dent); ret_code = -ENOENT; } else { ret_code = 0; result[0] = r_dent; } if ( lock_f ) UP(&(dent->d_inode->i_sem)); return ret_code; }
static Chan* aoeopen(Chan *c, int omode) { Aoedev *d; if(TYPE(c->qid) != Qdata) return devopen(c, omode, 0, 0, aoegen); d = unit2dev(UNIT(c->qid)); qlock(d); if(waserror()){ qunlock(d); nexterror(); } if(!UP(d)) error(Eaoedown); c = devopen(c, omode, 0, 0, aoegen); d->nopen++; poperror(); qunlock(d); return c; }