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