static int
cmd_or_math(int cs_type)
{
int oldlen = len;
int c;
cmdpush(cs_type);
c = dquote_parse(')', 0);
cmdpop();
*bptr = '\0';
if (!c) {
c = hgetc();
if (c == ')')
return 1;
hungetc(c);
lexstop = 0;
c = ')';
}
hungetc(c);
lexstop = 0;
while (len > oldlen) {
len--;
hungetc(itok(*--bptr) ? ztokens[*bptr - Pound] : *bptr);
}
hungetc('(');
return 0;
}
static int
cmd_or_math(int cs_type)
{
int oldlen = len;
int c;
cmdpush(cs_type);
c = dquote_parse(')', 0);
cmdpop();
*bptr = '\0';
if (!c) {
/* Successfully parsed, see if it was math */
c = hgetc();
if (c == ')')
return 1; /* yes */
hungetc(c);
lexstop = 0;
c = ')';
} else if (lexstop) {
/* we haven't got anything to unget */
return 2;
}
/* else unsuccessful: unget the whole thing */
hungetc(c);
lexstop = 0;
while (len > oldlen) {
len--;
hungetc(itok(*--bptr) ? ztokens[*bptr - Pound] : *bptr);
}
hungetc('(');
return 0;
}
int
ingetc(void)
{
int lastc = ' ';
if (lexstop)
return ' ';
for (;;) {
if (inbufleft) {
inbufleft--;
inbufct--;
if (itok(lastc = STOUC(*inbufptr++)))
continue;
if (((inbufflags & INP_LINENO) || !strin) && lastc == '\n')
lineno++;
break;
}
/*
* See if we have reached the end of input
* (due to an error, or to reading from a single string).
* Check the remaining characters left, since if there aren't
* any we don't want to pop the stack---it'll mark any aliases
* as not in use before we've finished processing.
*/
if (!inbufct && (strin || errflag)) {
lexstop = 1;
break;
}
/* If the next element down the input stack is a continuation of
* this, use it.
*/
if (inbufflags & INP_CONT) {
inpoptop();
continue;
}
/* As a last resort, get some more input */
if (inputline())
break;
}
if (!lexstop)
zshlex_raw_add(lastc);
return lastc;
}
static int
cmd_or_math(int cs_type)
{
int oldlen = lexbuf.len;
int c;
int oinflags = inbufflags;
cmdpush(cs_type);
inbufflags |= INP_APPEND;
c = dquote_parse(')', 0);
if (!(oinflags & INP_APPEND))
inbufflags &= ~INP_APPEND;
cmdpop();
*lexbuf.ptr = '\0';
if (!c) {
/* Successfully parsed, see if it was math */
c = hgetc();
if (c == ')')
return CMD_OR_MATH_MATH; /* yes */
hungetc(c);
lexstop = 0;
c = ')';
} else if (lexstop) {
/* we haven't got anything to unget */
return CMD_OR_MATH_ERR;
}
/* else unsuccessful: unget the whole thing */
hungetc(c);
lexstop = 0;
while (lexbuf.len > oldlen && !(errflag & ERRFLAG_ERROR)) {
lexbuf.len--;
hungetc(itok(*--lexbuf.ptr) ?
ztokens[*lexbuf.ptr - Pound] : *lexbuf.ptr);
}
if (errflag)
return CMD_OR_MATH_ERR;
hungetc('(');
return errflag ? CMD_OR_MATH_ERR : CMD_OR_MATH_CMD;
}
static int
skipcomm(void)
{
#ifdef ZSH_OLD_SKIPCOMM
int pct = 1, c, start = 1;
cmdpush(CS_CMDSUBST);
SETPARBEGIN
c = Inpar;
do {
int iswhite;
add(c);
c = hgetc();
if (itok(c) || lexstop)
break;
iswhite = inblank(c);
switch (c) {
case '(':
pct++;
break;
case ')':
pct--;
break;
case '\\':
add(c);
c = hgetc();
break;
case '\'': {
int strquote = lexbuf.ptr[-1] == '$';
add(c);
STOPHIST
while ((c = hgetc()) != '\'' && !lexstop) {
if (c == '\\' && strquote) {
add(c);
c = hgetc();
}
add(c);
}
ALLOWHIST
break;
}
case '\"':
add(c);
while ((c = hgetc()) != '\"' && !lexstop)
if (c == '\\') {
add(c);
add(hgetc());
} else
add(c);
break;
case '`':
add(c);
while ((c = hgetc()) != '`' && !lexstop)
if (c == '\\')
add(c), add(hgetc());
else
add(c);
break;
case '#':
if (start) {
add(c);
while ((c = hgetc()) != '\n' && !lexstop)
add(c);
iswhite = 1;
}
break;
}
start = iswhite;
}
while (pct);
if (!lexstop)
SETPAREND
cmdpop();
return lexstop;
#else
char *new_tokstr;
int new_lexstop, new_lex_add_raw;
int save_infor = infor;
struct lexbufstate new_lexbuf;
int noalias = noaliases;
noaliases = 1;
infor = 0;
cmdpush(CS_CMDSUBST);
SETPARBEGIN
add(Inpar);
new_lex_add_raw = lex_add_raw + 1;
if (!lex_add_raw) {
/*
* We'll combine the string so far with the input
* read in for the command substitution. To do this
* we'll just propagate the current tokstr etc. as the
* variables used for adding raw input, and
* ensure we swap those for the real tokstr etc. at the end.
*
* However, we need to save and restore the rest of the
* lexical and parse state as we're effectively parsing
* an internal string. Because we're still parsing it from
* the original input source (we have to --- we don't know
* when to stop inputting it otherwise and can't rely on
* the input being recoverable until we've read it) we need
* to keep the same history context.
*/
new_tokstr = tokstr;
new_lexbuf = lexbuf;
/*
* If we're expanding an alias at this point, we need the whole
* remaining text as part of the string for the command in
* parentheses, so don't backtrack. This is different from the
* usual case where the alias is fully within the command, where
* we want the unexpanded text so that it will be expanded
* again when the command in the parentheses is executed.
*
* I never wanted to be a software engineer, you know.
*/
if (inbufflags & INP_ALIAS)
inbufflags |= INP_RAW_KEEP;
zcontext_save_partial(ZCONTEXT_LEX|ZCONTEXT_PARSE);
hist_in_word(1);
} else {
/*
* Set up for nested command subsitution, however
* we don't actually need the string until we get
* back to the top level and recover the lot.
* The $() body just appears empty.
*
* We do need to propagate the raw variables which would
* otherwise by cleared, though.
*/
new_tokstr = tokstr_raw;
new_lexbuf = lexbuf_raw;
zcontext_save_partial(ZCONTEXT_LEX|ZCONTEXT_PARSE);
}
tokstr_raw = new_tokstr;
lexbuf_raw = new_lexbuf;
lex_add_raw = new_lex_add_raw;
/*
* Don't do any ZLE specials down here: they're only needed
* when we return the string from the recursive parse.
* (TBD: this probably means we should be initialising lexflags
* more consistently.)
*
* Note that in that case we're still using the ZLE line reading
* function at the history layer --- this is consistent with the
* intention of maintaining the history and input layers across
* the recursive parsing.
*/
lexflags &= ~LEXFLAGS_ZLE;
dbparens = 0; /* restored by zcontext_restore_partial() */
if (!parse_event(OUTPAR) || tok != OUTPAR)
lexstop = 1;
/* Outpar lexical token gets added in caller if present */
/*
* We're going to keep the full raw input string
* as the current token string after popping the stack.
*/
new_tokstr = tokstr_raw;
new_lexbuf = lexbuf_raw;
/*
* We're also going to propagate the lexical state:
* if we couldn't parse the command substitution we
* can't continue.
*/
new_lexstop = lexstop;
zcontext_restore_partial(ZCONTEXT_LEX|ZCONTEXT_PARSE);
if (lex_add_raw) {
/*
* Keep going, so retain the raw variables.
*/
tokstr_raw = new_tokstr;
lexbuf_raw = new_lexbuf;
} else {
if (!new_lexstop) {
/* Ignore the ')' added on input */
new_lexbuf.len--;
*--new_lexbuf.ptr = '\0';
}
/*
* Convince the rest of lex.c we were examining a string
* all along.
*/
tokstr = new_tokstr;
lexbuf = new_lexbuf;
lexstop = new_lexstop;
hist_in_word(0);
}
if (!lexstop)
SETPAREND
cmdpop();
infor = save_infor;
noaliases = noalias;
return lexstop;
#endif
}
int
exalias(void)
{
Reswd rw;
hwend();
if (interact && isset(SHINSTDIN) && !strin && !incasepat &&
tok == STRING && !nocorrect && !(inbufflags & INP_ALIAS) &&
(isset(CORRECTALL) || (isset(CORRECT) && incmdpos)))
spckword(&tokstr, 1, incmdpos, 1);
if (!tokstr) {
zshlextext = tokstrings[tok];
if (tok == NEWLIN)
return 0;
return checkalias();
} else {
VARARR(char, copy, (strlen(tokstr) + 1));
if (has_token(tokstr)) {
char *p, *t;
zshlextext = p = copy;
for (t = tokstr;
(*p++ = itok(*t) ? ztokens[*t++ - Pound] : *t++););
} else
zshlextext = tokstr;
if ((lexflags & LEXFLAGS_ZLE) && !(inbufflags & INP_ALIAS)) {
int zp = lexflags;
gotword();
if ((zp & LEXFLAGS_ZLE) && !lexflags) {
if (zshlextext == copy)
zshlextext = tokstr;
return 0;
}
}
if (tok == STRING) {
/* Check for an alias */
if ((zshlextext != copy || !isset(POSIXALIASES)) && checkalias()) {
if (zshlextext == copy)
zshlextext = tokstr;
return 1;
}
/* Then check for a reserved word */
if ((incmdpos ||
(unset(IGNOREBRACES) && unset(IGNORECLOSEBRACES) &&
zshlextext[0] == '}' && !zshlextext[1])) &&
(rw = (Reswd) reswdtab->getnode(reswdtab, zshlextext))) {
tok = rw->token;
inrepeat_ = (tok == REPEAT);
if (tok == DINBRACK)
incond = 1;
} else if (incond && !strcmp(zshlextext, "]]")) {
tok = DOUTBRACK;
incond = 0;
} else if (incond == 1 && zshlextext[0] == '!' && !zshlextext[1])
tok = BANG;
}
inalmore = 0;
if (zshlextext == copy)
zshlextext = tokstr;
}
return 0;
}
_Accum sincosk(_Accum angle, _Accum* cosp)
{
_Accum x;
_Accum y = 0;
uint8_t correctionCount = 0;
uint8_t quadrant = 1;
if(cosp == NULL)
cosp = &x;
/* move large values into [0,2 PI] */
#define MAX_CORRECTION_COUNT 1
while(angle >= PIlk) { /* PIlk = PIk * 2^8 */
angle -= PIlk;
if(correctionCount == MAX_CORRECTION_COUNT) {
correctionCount = 0;
angle++;
} else {
correctionCount++;
}
}
correctionCount = 0;
while(angle < 0) {
angle += PIlk;
if(correctionCount == MAX_CORRECTION_COUNT) {
correctionCount = 0;
angle--;
} else {
correctionCount++;
}
}
#undef MAX_CORRECTION_COUNT
/* move small values into [0,2 PI] */
#define MAX_CORRECTION_COUNT 5
while(angle >= 2*PIk + 1) {
angle -= 2*PIk + 1;
if(correctionCount == MAX_CORRECTION_COUNT) {
correctionCount = 0;
angle++;
} else {
correctionCount++;
}
}
if(correctionCount > 0) {
angle++;
}
correctionCount = 0;
while(angle < 0) {
angle += 2*PIk + 1;
if(correctionCount == MAX_CORRECTION_COUNT) {
correctionCount = 0;
angle--;
} else {
correctionCount++;
}
}
if(correctionCount > 0) {
angle--;
}
#undef MAX_CORRECTION_COUNT
if(angle > PIk) {
angle = angle - PIk;
quadrant += 2;
}
if(angle > (PIk/2 + 1)) {
angle = PIk - angle + 1;
quadrant += 1;
}
if(angle == 0) {
*cosp = (quadrant == 2 || quadrant == 3 ? -itok(1) : itok(1));
return 0;
}
*cosp = CORDICC_GAIN;
angle = LSHIFT_static(angle, 8);
cordicck(cosp, &y, &angle, 17, 0);
(*cosp) = RSHIFT_static(*cosp, 8);
y = RSHIFT_static(y, 8);
switch(quadrant) {
case 2: {
(*cosp) = -(*cosp);
} break;
case 3: {
y = -y;
(*cosp) = -(*cosp);
} break;
case 4: {
y = -y;
} break;
default:;
}
return y;
}
static int
skipcomm(void)
{
int pct = 1, c;
cmdpush(CS_CMDSUBST);
SETPARBEGIN
c = Inpar;
do {
add(c);
c = hgetc();
if (itok(c) || lexstop)
break;
switch (c) {
case '(':
pct++;
break;
case ')':
pct--;
break;
case '\\':
add(c);
c = hgetc();
break;
case '\'': {
int strquote = bptr[-1] == '$';
add(c);
STOPHIST
while ((c = hgetc()) != '\'' && !lexstop) {
if (c == '\\' && strquote) {
add(c);
c = hgetc();
}
add(c);
}
ALLOWHIST
break;
}
case '\"':
add(c);
while ((c = hgetc()) != '\"' && !lexstop)
if (c == '\\') {
add(c);
add(hgetc());
} else
add(c);
break;
case '`':
add(c);
while ((c = hgetc()) != '`' && !lexstop)
if (c == '\\')
add(c), add(hgetc());
else
add(c);
break;
}
}
while (pct);
if (!lexstop)
SETPAREND
cmdpop();
return lexstop;
}
int
exalias(void)
{
Alias an;
Reswd rw;
hwend();
if (interact && isset(SHINSTDIN) && !strin && !incasepat &&
tok == STRING && !nocorrect && !(inbufflags & INP_ALIAS) &&
(isset(CORRECTALL) || (isset(CORRECT) && incmdpos)))
spckword(&tokstr, 1, incmdpos, 1);
if (!tokstr) {
yytext = tokstrings[tok];
return 0;
} else {
VARARR(char, copy, (strlen(tokstr) + 1));
if (has_token(tokstr)) {
char *p, *t;
yytext = p = copy;
for (t = tokstr;
(*p++ = itok(*t) ? ztokens[*t++ - Pound] : *t++););
} else
yytext = tokstr;
if (zleparse && !(inbufflags & INP_ALIAS)) {
int zp = zleparse;
gotword();
if (zp == 1 && !zleparse) {
if (yytext == copy)
yytext = tokstr;
return 0;
}
}
if (tok == STRING) {
/* Check for an alias */
if (!noaliases && isset(ALIASESOPT)) {
char *suf;
an = (Alias) aliastab->getnode(aliastab, yytext);
if (an && !an->inuse &&
((an->flags & ALIAS_GLOBAL) || incmdpos || inalmore)) {
inpush(an->text, INP_ALIAS, an);
if (an->text[0] == ' ')
aliasspaceflag = 1;
lexstop = 0;
if (yytext == copy)
yytext = tokstr;
return 1;
}
if ((suf = strrchr(yytext, '.')) && suf[1] &&
suf > yytext && suf[-1] != Meta &&
(an = (Alias)sufaliastab->getnode(sufaliastab, suf+1)) &&
!an->inuse && incmdpos) {
inpush(dupstring(yytext), INP_ALIAS, NULL);
inpush(" ", INP_ALIAS, NULL);
inpush(an->text, INP_ALIAS, an);
lexstop = 0;
if (yytext == copy)
yytext = tokstr;
return 1;
}
}
/* Then check for a reserved word */
if ((incmdpos ||
(unset(IGNOREBRACES) && yytext[0] == '}' && !yytext[1])) &&
(rw = (Reswd) reswdtab->getnode(reswdtab, yytext))) {
tok = rw->token;
if (tok == DINBRACK)
incond = 1;
} else if (incond && !strcmp(yytext, "]]")) {
tok = DOUTBRACK;
incond = 0;
} else if (incond == 1 && yytext[0] == '!' && !yytext[1])
tok = BANG;
}
inalmore = 0;
if (yytext == copy)
yytext = tokstr;
}
return 0;
}
LinkNode
stringsubst(LinkList list, LinkNode node, int ssub)
{
int qt;
char *str3 = (char *)getdata(node);
char *str = str3;
while (!errflag && *str) {
if ((qt = *str == Qstring) || *str == String)
if (str[1] == Inpar) {
str++;
goto comsub;
} else if (str[1] == Inbrack) {
/* $[...] */
char *str2 = str;
str2++;
if (skipparens(Inbrack, Outbrack, &str2)) {
zerr("closing bracket missing", NULL, 0);
return NULL;
}
str2[-1] = *str = '\0';
str = arithsubst(str + 2, &str3, str2);
setdata(node, (void *) str3);
continue;
} else {
node = paramsubst(list, node, &str, qt, ssub);
if (errflag || !node)
return NULL;
str3 = (char *)getdata(node);
continue;
}
else if ((qt = *str == Qtick) || *str == Tick)
comsub: {
LinkList pl;
char *s, *str2 = str;
char endchar;
int l1, l2;
if (*str == Inpar) {
endchar = Outpar;
str[-1] = '\0';
if (skipparens(Inpar, Outpar, &str))
DPUTS(1, "Oops. parse error in command substitution");
str--;
} else {
endchar = *str;
*str = '\0';
while (*++str != endchar)
DPUTS(!*str, "Oops. parse error in command substitution");
}
*str++ = '\0';
if (endchar == Outpar && str2[1] == '(' && str[-2] == ')') {
/* Math substitution of the form $((...)) */
str = arithsubst(str2 + 1, &str3, str);
setdata(node, (void *) str3);
continue;
}
/* It is a command substitution, which will be parsed again *
* by the lexer, so we untokenize it first, but we cannot use *
* untokenize() since in the case of `...` some Bnulls should *
* be left unchanged. Note that the lexer doesn't tokenize *
* the body of a command substitution so if there are some *
* tokens here they are from a ${(e)~...} substitution. */
for (str = str2; *++str; )
if (itok(*str) && *str != Nularg &&
!(endchar != Outpar && *str == Bnull &&
(str[1] == '$' || str[1] == '\\' || str[1] == '`' ||
(qt && str[1] == '"'))))
*str = ztokens[*str - Pound];
str++;
if (!(pl = getoutput(str2 + 1, qt || ssub))) {
zerr("parse error in command substitution", NULL, 0);
return NULL;
}
if (endchar == Outpar)
str2--;
if (!(s = (char *) ugetnode(pl))) {
str = strcpy(str2, str);
continue;
}
if (!qt && ssub && isset(GLOBSUBST))
tokenize(s);
l1 = str2 - str3;
l2 = strlen(s);
if (nonempty(pl)) {
LinkNode n = lastnode(pl);
str2 = (char *) ncalloc(l1 + l2 + 1);
strcpy(str2, str3);
strcpy(str2 + l1, s);
setdata(node, str2);
insertlinklist(pl, node, list);
s = (char *) getdata(node = n);
l1 = 0;
l2 = strlen(s);
}
str2 = (char *) ncalloc(l1 + l2 + strlen(str) + 1);
if (l1)
strcpy(str2, str3);
strcpy(str2 + l1, s);
str = strcpy(str2 + l1 + l2, str);
str3 = str2;
setdata(node, str3);
continue;
}
str++;
}
return errflag ? NULL : node;
}
