/*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;
}
