int sh21(void) { t_sh sh; ft_bzero(&sh.l, sizeof(t_line)); srand(time(NULL)); sh.nbr = rand(); get_history(&g_hist); sh.av = NULL; handle_var(KV_SET, "?", "0"); while (1) { g_toto = g_titi = 1; g_tata = 0; g_prompt.onshell = 1; catch_signal(); g_prompt.son == 0 ? print_prompt(sh.nbr, g_env, g_lenv, &sh.l) : 0; g_prompt = (t_prompt){sh.nbr, g_env, g_lenv, 0, &sh.l, 1}; g_line = NULL; if ((sh.av = read_init(&sh.l, &g_hist)) != NULL) { g_line = NULL; g_prompt.onshell = 0; sh.o = shell(sh.av, 0); g_prompt.onshell = 1; } xmasterfree(); } return (1); }
void set_retcode(unsigned char ret_code) { char *s; handle_var(KV_SET, "?", (s = ft_litoa(ret_code))); ft_strdel(&s); }
void doparse( tsd_t *TSD, const streng *source, cnodeptr thisptr, int caseless ) { int start=0,point=0,length=0, end=0, nextstart=0, solid=0 ; const streng *pattern=NULL ; const streng *xtmp=NULL ; char tch=' ' ; nextstart = 0 ; /* too keep gcc from complaining about uninitialized */ tch = TSD->currlevel->tracestat ; TSD->traceparse = ((tch=='I') || (tch=='R')) ; recurse: /* * Cache the length of source, to avoid chasing ponters later. * Then make pattern default to the nullstring. The nullstring is * so muched used, that we don't want to allocate and deallocate * that all the time. */ length = source->len ; pattern = &nullstring ; /* * There are two main cases, either this is the last pattern, in * which case we use the rest of the string. Or either there is * another pattern further out, in which case we have to find it. * */ if (thisptr->p[1]) { /* * We are not the last pattern, so first find the next pattern. * First cache the type, so we don't chase pointers. There are * two main choises: either seek for a string of some sort, or * use an offset of some sort. */ solid = thisptr->p[1]->type ; if ((solid==X_TPL_MVE)||(solid==X_TPL_VAR)) { /* * The pattern to search for is either a literal string, or it * is the value hold in a variable, set pattern to whatever * it might be. Pattern previous points to a statically * allocated variable, so don't bother to deallocate. */ if (solid==X_TPL_MVE) pattern = thisptr->p[1]->name ; else pattern = handle_var( TSD, thisptr->p[1]->p[0] ) ; /* * Then we must find where in the source string pattern occurs. * If it don't occur there, we use the rest of the string, else * we use the string up to, but not including, the first char * that matched pattern. The 'bmstrstr' returns -1 for not * found, so correct that to rest-of-string. Also note that if * the pattern is the nullstring, it should match the end of * the string. */ if (Str_len(pattern)) { end = bmstrstr( source, start, pattern, caseless ) ; if (end<0) { point = end = length ; nextstart = end ; } else { nextstart = end + Str_len(pattern) ; point = end ; } } else { nextstart = point = end = length ; } /* * While 'end' marks how much to stuff into variables, nextstart * marks where to start the search for the next pattern (if * any). Remember that patterns "eat" up the part of the * parse string that they match. */ /* nextstart = end + Str_len(pattern) ; */ } else { /* * The next pattern to match is not a string to match, but a * positional movement, which will always be numeric, and if * it contains a sign, that should have been stripped off during * parsing. But a variable may be negative, too. */ if (thisptr->p[1]->name) xtmp = thisptr->p[1]->name ; else xtmp = handle_var( TSD, thisptr->p[1]->p[0] ) ; end = streng_to_int( TSD, xtmp, &nextstart ) ; if (nextstart) exiterror( ERR_INVALID_INTEGER, 4, tmpstr_of( TSD, xtmp ) ); /* * Depending on what sort of positional movement, do the right * thing. */ if (solid==X_NEG_OFFS) { /* * If it is a movement backwards, the concept goes something * like move-it-foreward-to-a-backwards-position. That is, * the string to be parsed continues forwards to the end of * the sting and stops there, while the nextposition wraps * round to the start again. * * Anyway, parse all the rest of the sting in this parse, and * start on the specified position for the next parse. */ start = point ; nextstart = point - end ; end = length ; if (nextstart > length) nextstart = length; if (nextstart < 0) nextstart = 0; point = nextstart ; } else if (solid==X_POS_OFFS) { /* * If the movement is forward, it is simpler, just move the * position of both the end of thisptr, and the start of next * to the right point. */ start = point ; nextstart = point + end ; if (nextstart > length) nextstart = length; if (nextstart < 0) nextstart = 0; end = nextstart ; if (end<=start) end = length ; point = nextstart ; } else if (solid==X_ABS_OFFS) { /* * Same applies if the position is absolute, just move it. */ end--; if (end > length) end = length; if (end < 0) /* fixes bug 1107757 */ end = 0; point = nextstart = end; if (end <= start) end = length; } } } else /* * We are last pattern to match, set the end of the string to * be parsed to the rest of the string available. */ end = nextstart = length ; /* * Make sure that we didn't do anything illegal when we pushed * around on the value of end and nextstart. These should have been * set correctly in the statements above. */ assert((0<=nextstart) && (nextstart<=length)) ; /* * Then handle end. It must be _after_ the last character in * the pattern, while it must not be larger than length. */ assert((start <= end) && (end <= length)) ; /* * Now we have marked off an area to be parsed, so call 'doparse3' to * put values into the variables. Note that end is decremented, * since doparse3 expects ptr to last char to use, not ptr to char * after last char to use. */ if (thisptr->p[0]) { doparse3( TSD, thisptr->p[0], source->value+start, end-start); --end; } /* * Then make a tailrecursive call, or rather, simulate one. This * operation will take care of the next set of variables to be * parsed values into. */ if ((thisptr=thisptr->p[2]) != NULL) { start = nextstart ; goto recurse ; } }