Index: head/bin/sh/arith_yacc.c =================================================================== --- head/bin/sh/arith_yacc.c (revision 343980) +++ head/bin/sh/arith_yacc.c (revision 343981) @@ -1,381 +1,381 @@ /*- * Copyright (c) 1993 * The Regents of the University of California. All rights reserved. * Copyright (c) 2007 * Herbert Xu . All rights reserved. * * This code is derived from software contributed to Berkeley by * Kenneth Almquist. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include "arith.h" #include "arith_yacc.h" #include "expand.h" #include "shell.h" #include "error.h" #include "memalloc.h" #include "output.h" #include "options.h" #include "var.h" #if ARITH_BOR + 11 != ARITH_BORASS || ARITH_ASS + 11 != ARITH_EQ #error Arithmetic tokens are out of order. #endif static const char *arith_startbuf; const char *arith_buf; union yystype yylval; static int last_token; #define ARITH_PRECEDENCE(op, prec) [op - ARITH_BINOP_MIN] = prec static const char prec[ARITH_BINOP_MAX - ARITH_BINOP_MIN] = { ARITH_PRECEDENCE(ARITH_MUL, 0), ARITH_PRECEDENCE(ARITH_DIV, 0), ARITH_PRECEDENCE(ARITH_REM, 0), ARITH_PRECEDENCE(ARITH_ADD, 1), ARITH_PRECEDENCE(ARITH_SUB, 1), ARITH_PRECEDENCE(ARITH_LSHIFT, 2), ARITH_PRECEDENCE(ARITH_RSHIFT, 2), ARITH_PRECEDENCE(ARITH_LT, 3), ARITH_PRECEDENCE(ARITH_LE, 3), ARITH_PRECEDENCE(ARITH_GT, 3), ARITH_PRECEDENCE(ARITH_GE, 3), ARITH_PRECEDENCE(ARITH_EQ, 4), ARITH_PRECEDENCE(ARITH_NE, 4), ARITH_PRECEDENCE(ARITH_BAND, 5), ARITH_PRECEDENCE(ARITH_BXOR, 6), ARITH_PRECEDENCE(ARITH_BOR, 7), }; #define ARITH_MAX_PREC 8 int letcmd(int, char **); static __dead2 void yyerror(const char *s) { error("arithmetic expression: %s: \"%s\"", s, arith_startbuf); /* NOTREACHED */ } static arith_t arith_lookupvarint(char *varname) { const char *str; char *p; arith_t result; str = lookupvar(varname); if (uflag && str == NULL) yyerror("variable not set"); if (str == NULL || *str == '\0') str = "0"; errno = 0; - result = strtoarith_t(str, &p, 0); + result = strtoarith_t(str, &p); if (errno != 0 || *p != '\0') yyerror("variable conversion error"); return result; } static inline int arith_prec(int op) { return prec[op - ARITH_BINOP_MIN]; } static inline int higher_prec(int op1, int op2) { return arith_prec(op1) < arith_prec(op2); } static arith_t do_binop(int op, arith_t a, arith_t b) { switch (op) { default: case ARITH_REM: case ARITH_DIV: if (!b) yyerror("division by zero"); if (a == ARITH_MIN && b == -1) yyerror("divide error"); return op == ARITH_REM ? a % b : a / b; case ARITH_MUL: return (uintmax_t)a * (uintmax_t)b; case ARITH_ADD: return (uintmax_t)a + (uintmax_t)b; case ARITH_SUB: return (uintmax_t)a - (uintmax_t)b; case ARITH_LSHIFT: return (uintmax_t)a << (b & (sizeof(uintmax_t) * CHAR_BIT - 1)); case ARITH_RSHIFT: return a >> (b & (sizeof(uintmax_t) * CHAR_BIT - 1)); case ARITH_LT: return a < b; case ARITH_LE: return a <= b; case ARITH_GT: return a > b; case ARITH_GE: return a >= b; case ARITH_EQ: return a == b; case ARITH_NE: return a != b; case ARITH_BAND: return a & b; case ARITH_BXOR: return a ^ b; case ARITH_BOR: return a | b; } } static arith_t assignment(int var, int noeval); static arith_t primary(int token, union yystype *val, int op, int noeval) { arith_t result; again: switch (token) { case ARITH_LPAREN: result = assignment(op, noeval); if (last_token != ARITH_RPAREN) yyerror("expecting ')'"); last_token = yylex(); return result; case ARITH_NUM: last_token = op; return val->val; case ARITH_VAR: last_token = op; return noeval ? val->val : arith_lookupvarint(val->name); case ARITH_ADD: token = op; *val = yylval; op = yylex(); goto again; case ARITH_SUB: *val = yylval; return -primary(op, val, yylex(), noeval); case ARITH_NOT: *val = yylval; return !primary(op, val, yylex(), noeval); case ARITH_BNOT: *val = yylval; return ~primary(op, val, yylex(), noeval); default: yyerror("expecting primary"); } } static arith_t binop2(arith_t a, int op, int precedence, int noeval) { for (;;) { union yystype val; arith_t b; int op2; int token; token = yylex(); val = yylval; b = primary(token, &val, yylex(), noeval); op2 = last_token; if (op2 >= ARITH_BINOP_MIN && op2 < ARITH_BINOP_MAX && higher_prec(op2, op)) { b = binop2(b, op2, arith_prec(op), noeval); op2 = last_token; } a = noeval ? b : do_binop(op, a, b); if (op2 < ARITH_BINOP_MIN || op2 >= ARITH_BINOP_MAX || arith_prec(op2) >= precedence) return a; op = op2; } } static arith_t binop(int token, union yystype *val, int op, int noeval) { arith_t a = primary(token, val, op, noeval); op = last_token; if (op < ARITH_BINOP_MIN || op >= ARITH_BINOP_MAX) return a; return binop2(a, op, ARITH_MAX_PREC, noeval); } static arith_t and(int token, union yystype *val, int op, int noeval) { arith_t a = binop(token, val, op, noeval); arith_t b; op = last_token; if (op != ARITH_AND) return a; token = yylex(); *val = yylval; b = and(token, val, yylex(), noeval | !a); return a && b; } static arith_t or(int token, union yystype *val, int op, int noeval) { arith_t a = and(token, val, op, noeval); arith_t b; op = last_token; if (op != ARITH_OR) return a; token = yylex(); *val = yylval; b = or(token, val, yylex(), noeval | !!a); return a || b; } static arith_t cond(int token, union yystype *val, int op, int noeval) { arith_t a = or(token, val, op, noeval); arith_t b; arith_t c; if (last_token != ARITH_QMARK) return a; b = assignment(yylex(), noeval | !a); if (last_token != ARITH_COLON) yyerror("expecting ':'"); token = yylex(); *val = yylval; c = cond(token, val, yylex(), noeval | !!a); return a ? b : c; } static arith_t assignment(int var, int noeval) { union yystype val = yylval; int op = yylex(); arith_t result; char sresult[DIGITS(result) + 1]; if (var != ARITH_VAR) return cond(var, &val, op, noeval); if (op != ARITH_ASS && (op < ARITH_ASS_MIN || op >= ARITH_ASS_MAX)) return cond(var, &val, op, noeval); result = assignment(yylex(), noeval); if (noeval) return result; if (op != ARITH_ASS) result = do_binop(op - 11, arith_lookupvarint(val.name), result); snprintf(sresult, sizeof(sresult), ARITH_FORMAT_STR, result); setvar(val.name, sresult, 0); return result; } arith_t arith(const char *s) { struct stackmark smark; arith_t result; setstackmark(&smark); arith_buf = arith_startbuf = s; result = assignment(yylex(), 0); if (last_token) yyerror("expecting EOF"); popstackmark(&smark); return result; } /* * The exp(1) builtin. */ int letcmd(int argc, char **argv) { const char *p; char *concat; char **ap; arith_t i; if (argc > 1) { p = argv[1]; if (argc > 2) { /* * Concatenate arguments. */ STARTSTACKSTR(concat); ap = argv + 2; for (;;) { while (*p) STPUTC(*p++, concat); if ((p = *ap++) == NULL) break; STPUTC(' ', concat); } STPUTC('\0', concat); p = grabstackstr(concat); } } else p = ""; i = arith(p); out1fmt(ARITH_FORMAT_STR "\n", i); return !i; } Index: head/bin/sh/arith_yacc.h =================================================================== --- head/bin/sh/arith_yacc.h (revision 343980) +++ head/bin/sh/arith_yacc.h (revision 343981) @@ -1,93 +1,94 @@ /*- * Copyright (c) 1993 * The Regents of the University of California. All rights reserved. * Copyright (c) 2007 * Herbert Xu . All rights reserved. * * This code is derived from software contributed to Berkeley by * Kenneth Almquist. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #define ARITH_ASS 1 #define ARITH_OR 2 #define ARITH_AND 3 #define ARITH_BAD 4 #define ARITH_NUM 5 #define ARITH_VAR 6 #define ARITH_NOT 7 #define ARITH_BINOP_MIN 8 #define ARITH_LE 8 #define ARITH_GE 9 #define ARITH_LT 10 #define ARITH_GT 11 #define ARITH_EQ 12 #define ARITH_REM 13 #define ARITH_BAND 14 #define ARITH_LSHIFT 15 #define ARITH_RSHIFT 16 #define ARITH_MUL 17 #define ARITH_ADD 18 #define ARITH_BOR 19 #define ARITH_SUB 20 #define ARITH_BXOR 21 #define ARITH_DIV 22 #define ARITH_NE 23 #define ARITH_BINOP_MAX 24 #define ARITH_ASS_MIN 24 #define ARITH_REMASS 24 #define ARITH_BANDASS 25 #define ARITH_LSHIFTASS 26 #define ARITH_RSHIFTASS 27 #define ARITH_MULASS 28 #define ARITH_ADDASS 29 #define ARITH_BORASS 30 #define ARITH_SUBASS 31 #define ARITH_BXORASS 32 #define ARITH_DIVASS 33 #define ARITH_ASS_MAX 34 #define ARITH_LPAREN 34 #define ARITH_RPAREN 35 #define ARITH_BNOT 36 #define ARITH_QMARK 37 #define ARITH_COLON 38 extern const char *arith_buf; union yystype { arith_t val; char *name; }; extern union yystype yylval; +arith_t strtoarith_t(const char *restrict nptr, char **restrict endptr); int yylex(void); Index: head/bin/sh/arith_yylex.c =================================================================== --- head/bin/sh/arith_yylex.c (revision 343980) +++ head/bin/sh/arith_yylex.c (revision 343981) @@ -1,248 +1,276 @@ /*- * Copyright (c) 2002 * Herbert Xu. * Copyright (c) 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Kenneth Almquist. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); +#include +#include #include #include #include #include "shell.h" #include "arith_yacc.h" #include "expand.h" #include "error.h" #include "memalloc.h" #include "parser.h" #include "syntax.h" #if ARITH_BOR + 11 != ARITH_BORASS || ARITH_ASS + 11 != ARITH_EQ #error Arithmetic tokens are out of order. #endif +arith_t +strtoarith_t(const char *restrict nptr, char **restrict endptr) +{ + arith_t val; + + while (isspace((unsigned char)*nptr)) + nptr++; + switch (*nptr) { + case '-': + return strtoimax(nptr, endptr, 0); + case '0': + return (arith_t)strtoumax(nptr, endptr, 0); + default: + val = (arith_t)strtoumax(nptr, endptr, 0); + if (val >= 0) + return val; + else if (val == ARITH_MIN) { + errno = ERANGE; + return ARITH_MIN; + } else { + errno = ERANGE; + return ARITH_MAX; + } + } +} + int yylex(void) { int value; const char *buf = arith_buf; char *end; const char *p; for (;;) { value = *buf; switch (value) { case ' ': case '\t': case '\n': buf++; continue; default: return ARITH_BAD; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': - yylval.val = strtoarith_t(buf, &end, 0); + yylval.val = strtoarith_t(buf, &end); arith_buf = end; return ARITH_NUM; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': p = buf; while (buf++, is_in_name(*buf)) ; yylval.name = stalloc(buf - p + 1); memcpy(yylval.name, p, buf - p); yylval.name[buf - p] = '\0'; value = ARITH_VAR; goto out; case '=': value += ARITH_ASS - '='; checkeq: buf++; checkeqcur: if (*buf != '=') goto out; value += 11; break; case '>': switch (*++buf) { case '=': value += ARITH_GE - '>'; break; case '>': value += ARITH_RSHIFT - '>'; goto checkeq; default: value += ARITH_GT - '>'; goto out; } break; case '<': switch (*++buf) { case '=': value += ARITH_LE - '<'; break; case '<': value += ARITH_LSHIFT - '<'; goto checkeq; default: value += ARITH_LT - '<'; goto out; } break; case '|': if (*++buf != '|') { value += ARITH_BOR - '|'; goto checkeqcur; } value += ARITH_OR - '|'; break; case '&': if (*++buf != '&') { value += ARITH_BAND - '&'; goto checkeqcur; } value += ARITH_AND - '&'; break; case '!': if (*++buf != '=') { value += ARITH_NOT - '!'; goto out; } value += ARITH_NE - '!'; break; case 0: goto out; case '(': value += ARITH_LPAREN - '('; break; case ')': value += ARITH_RPAREN - ')'; break; case '*': value += ARITH_MUL - '*'; goto checkeq; case '/': value += ARITH_DIV - '/'; goto checkeq; case '%': value += ARITH_REM - '%'; goto checkeq; case '+': if (buf[1] == '+') return ARITH_BAD; value += ARITH_ADD - '+'; goto checkeq; case '-': if (buf[1] == '-') return ARITH_BAD; value += ARITH_SUB - '-'; goto checkeq; case '~': value += ARITH_BNOT - '~'; break; case '^': value += ARITH_BXOR - '^'; goto checkeq; case '?': value += ARITH_QMARK - '?'; break; case ':': value += ARITH_COLON - ':'; break; } break; } buf++; out: arith_buf = buf; return value; } Index: head/bin/sh/shell.h =================================================================== --- head/bin/sh/shell.h (revision 343980) +++ head/bin/sh/shell.h (revision 343981) @@ -1,78 +1,77 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Kenneth Almquist. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)shell.h 8.2 (Berkeley) 5/4/95 * $FreeBSD$ */ #ifndef SHELL_H_ #define SHELL_H_ #include /* * The follow should be set to reflect the type of system you have: * JOBS -> 1 if you have Berkeley job control, 0 otherwise. * define DEBUG=1 to compile in debugging (set global "debug" to turn on) * define DEBUG=2 to compile in and turn on debugging. * * When debugging is on, debugging info will be written to ./trace and * a quit signal will generate a core dump. */ #define JOBS 1 /* #define DEBUG 1 */ /* * Type of used arithmetics. SUSv3 requires us to have at least signed long. */ typedef intmax_t arith_t; #define ARITH_FORMAT_STR "%" PRIdMAX -#define strtoarith_t(nptr, endptr, base) (intmax_t)strtoumax(nptr, endptr, base) #define ARITH_MIN INTMAX_MIN #define ARITH_MAX INTMAX_MAX typedef void *pointer; #include extern char nullstr[1]; /* null string */ #ifdef DEBUG #define TRACE(param) sh_trace param #else #define TRACE(param) #endif #endif /* !SHELL_H_ */ Index: head/bin/sh/tests/expansion/Makefile =================================================================== --- head/bin/sh/tests/expansion/Makefile (revision 343980) +++ head/bin/sh/tests/expansion/Makefile (revision 343981) @@ -1,110 +1,112 @@ # $FreeBSD$ PACKAGE= tests TESTSDIR= ${TESTSBASE}/bin/sh/${.CURDIR:T} .PATH: ${.CURDIR:H} ATF_TESTS_SH= functional_test ${PACKAGE}FILES+= arith1.0 ${PACKAGE}FILES+= arith2.0 ${PACKAGE}FILES+= arith3.0 ${PACKAGE}FILES+= arith4.0 ${PACKAGE}FILES+= arith5.0 ${PACKAGE}FILES+= arith6.0 ${PACKAGE}FILES+= arith7.0 ${PACKAGE}FILES+= arith8.0 ${PACKAGE}FILES+= arith9.0 ${PACKAGE}FILES+= arith10.0 ${PACKAGE}FILES+= arith11.0 ${PACKAGE}FILES+= arith12.0 ${PACKAGE}FILES+= arith13.0 ${PACKAGE}FILES+= arith14.0 ${PACKAGE}FILES+= arith15.0 +${PACKAGE}FILES+= arith16.0 +${PACKAGE}FILES+= arith17.0 ${PACKAGE}FILES+= assign1.0 ${PACKAGE}FILES+= cmdsubst1.0 ${PACKAGE}FILES+= cmdsubst2.0 ${PACKAGE}FILES+= cmdsubst3.0 ${PACKAGE}FILES+= cmdsubst4.0 ${PACKAGE}FILES+= cmdsubst5.0 ${PACKAGE}FILES+= cmdsubst6.0 ${PACKAGE}FILES+= cmdsubst7.0 ${PACKAGE}FILES+= cmdsubst8.0 ${PACKAGE}FILES+= cmdsubst9.0 ${PACKAGE}FILES+= cmdsubst10.0 ${PACKAGE}FILES+= cmdsubst11.0 ${PACKAGE}FILES+= cmdsubst12.0 ${PACKAGE}FILES+= cmdsubst13.0 ${PACKAGE}FILES+= cmdsubst14.0 ${PACKAGE}FILES+= cmdsubst15.0 ${PACKAGE}FILES+= cmdsubst16.0 ${PACKAGE}FILES+= cmdsubst17.0 ${PACKAGE}FILES+= cmdsubst18.0 ${PACKAGE}FILES+= cmdsubst19.0 ${PACKAGE}FILES+= cmdsubst20.0 ${PACKAGE}FILES+= cmdsubst21.0 ${PACKAGE}FILES+= cmdsubst22.0 ${PACKAGE}FILES+= cmdsubst23.0 ${PACKAGE}FILES+= cmdsubst24.0 ${PACKAGE}FILES+= cmdsubst25.0 ${PACKAGE}FILES+= cmdsubst26.0 ${PACKAGE}FILES+= export1.0 ${PACKAGE}FILES+= export2.0 ${PACKAGE}FILES+= export3.0 ${PACKAGE}FILES+= heredoc1.0 ${PACKAGE}FILES+= heredoc2.0 ${PACKAGE}FILES+= ifs1.0 ${PACKAGE}FILES+= ifs2.0 ${PACKAGE}FILES+= ifs3.0 ${PACKAGE}FILES+= ifs4.0 ${PACKAGE}FILES+= ifs5.0 ${PACKAGE}FILES+= ifs6.0 ${PACKAGE}FILES+= ifs7.0 ${PACKAGE}FILES+= length1.0 ${PACKAGE}FILES+= length2.0 ${PACKAGE}FILES+= length3.0 ${PACKAGE}FILES+= length4.0 ${PACKAGE}FILES+= length5.0 ${PACKAGE}FILES+= length6.0 ${PACKAGE}FILES+= length7.0 ${PACKAGE}FILES+= length8.0 ${PACKAGE}FILES+= local1.0 ${PACKAGE}FILES+= local2.0 ${PACKAGE}FILES+= pathname1.0 ${PACKAGE}FILES+= pathname2.0 ${PACKAGE}FILES+= pathname3.0 ${PACKAGE}FILES+= pathname4.0 ${PACKAGE}FILES+= pathname5.0 ${PACKAGE}FILES+= pathname6.0 ${PACKAGE}FILES+= plus-minus1.0 ${PACKAGE}FILES+= plus-minus2.0 ${PACKAGE}FILES+= plus-minus3.0 ${PACKAGE}FILES+= plus-minus4.0 ${PACKAGE}FILES+= plus-minus5.0 ${PACKAGE}FILES+= plus-minus6.0 ${PACKAGE}FILES+= plus-minus7.0 ${PACKAGE}FILES+= plus-minus8.0 ${PACKAGE}FILES+= plus-minus9.0 ${PACKAGE}FILES+= question1.0 ${PACKAGE}FILES+= question2.0 ${PACKAGE}FILES+= readonly1.0 ${PACKAGE}FILES+= redir1.0 ${PACKAGE}FILES+= set-u1.0 ${PACKAGE}FILES+= set-u2.0 ${PACKAGE}FILES+= set-u3.0 ${PACKAGE}FILES+= tilde1.0 ${PACKAGE}FILES+= tilde2.0 ${PACKAGE}FILES+= trim1.0 ${PACKAGE}FILES+= trim2.0 ${PACKAGE}FILES+= trim3.0 ${PACKAGE}FILES+= trim4.0 ${PACKAGE}FILES+= trim5.0 ${PACKAGE}FILES+= trim6.0 ${PACKAGE}FILES+= trim7.0 ${PACKAGE}FILES+= trim8.0 ${PACKAGE}FILES+= trim9.0 ${PACKAGE}FILES+= trim10.0 ${PACKAGE}FILES+= trim11.0 .include Index: head/bin/sh/tests/expansion/arith16.0 =================================================================== --- head/bin/sh/tests/expansion/arith16.0 (nonexistent) +++ head/bin/sh/tests/expansion/arith16.0 (revision 343981) @@ -0,0 +1,26 @@ +# $FreeBSD$ + +failures=0 + +for x in \ + 0x10000000000000000 \ + -0x8000000000000001 \ + 0xfffffffffffffffffffffffffffffffff \ + -0xfffffffffffffffffffffffffffffffff \ + 02000000000000000000000 \ + 9223372036854775808 \ + 9223372036854775809 \ + -9223372036854775809 \ + 9999999999999999999999999 \ + -9999999999999999999999999 +do + msg=$({ + v=$((x)) || : + } 3>&1 >&2 2>&3 3>&-) + r=$? + if [ "$r" = 0 ] || [ -z "$msg" ]; then + printf 'Failed: %s\n' "$x" + : $((failures += 1)) + fi +done +exit $((failures > 0)) Property changes on: head/bin/sh/tests/expansion/arith16.0 ___________________________________________________________________ Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Index: head/bin/sh/tests/expansion/arith17.0 =================================================================== --- head/bin/sh/tests/expansion/arith17.0 (nonexistent) +++ head/bin/sh/tests/expansion/arith17.0 (revision 343981) @@ -0,0 +1,3 @@ +# $FreeBSD$ + +[ $((9223372036854775809)) -gt 0 ] Property changes on: head/bin/sh/tests/expansion/arith17.0 ___________________________________________________________________ Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property