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