1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1992-2010 AT&T Intellectual Property * 5 * and is licensed under the * 6 * Common Public License, Version 1.0 * 7 * by AT&T Intellectual Property * 8 * * 9 * A copy of the License is available at * 10 * http://www.opensource.org/licenses/cpl1.0.txt * 11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * 12 * * 13 * Information and Software Systems Research * 14 * AT&T Research * 15 * Florham Park NJ * 16 * * 17 * Glenn Fowler <gsf@research.att.com> * 18 * David Korn <dgk@research.att.com> * 19 * * 20 ***********************************************************************/ 21 #pragma prototyped 22 23 /* 24 * expr.c 25 * Written by David Korn 26 * Tue Oct 31 08:48:11 EST 1995 27 */ 28 29 static const char usage[] = 30 "[-?\n@(#)$Id: expr (AT&T Research) 2008-01-30 $\n]" 31 USAGE_LICENSE 32 "[+NAME?expr - evaluate arguments as an expression]" 33 "[+DESCRIPTION?\bexpr\b evaluates an expression given as arguments and writes " 34 "the result to standard output. The character \b0\b will be written " 35 "to indicate a zero value and nothing will be written to indicate an " 36 "empty string.]" 37 "[+?Most of the functionality of \bexpr\b is provided in a more natural " 38 "way by the shell, \bsh\b(1), and \bexpr\b is provided primarily " 39 "for backward compatibility.]" 40 "[+?Terms of the expression must be separate arguments. A string argument is " 41 "one that can not be identified as an integer. Integer-valued " 42 "arguments may be preceded by a unary plus or minus sign. Because " 43 "many of the operators use characters that have special meaning to " 44 "the shell, they must be quoted when entered from the shell.]" 45 46 "[+?Expressions are formed from the operators listed below in order " 47 "of increasing precedence within groups. All of the operators are " 48 "left associative. The symbols \aexpr1\a and \aexpr2\a represent " 49 "expressions formed from strings and integers and the following " 50 "operators:]{" 51 "[+\aexpr1\a \b|\b \aexpr2\a?Returns the evaluation of \aexpr1\a if " 52 "it is neither null nor 0, otherwise returns the evaluation of expr2.]" 53 54 "[+\aexpr1\a \b&\b \aexpr2\a?Returns the evaluation of \aexpr1\a if " 55 "neither expression evaluates to null or 0, otherwise returns 0.]" 56 57 "[+\aexpr1\a \aop\a \aexpr2\a?Returns the result of a decimal integer " 58 "comparison if both arguments are integers; otherwise, returns the " 59 "result of a string comparison using the locale-specific collation " 60 "sequence. The result of each comparison will be 1 if the specified " 61 "relationship is true, or 0 if the relationship is false. \aop\a " 62 "can be one of the following:]{" 63 "[+=?Equal.]" 64 "[+==?Equal.]" 65 "[+>?Greater than.]" 66 "[+>=?Greater than or equal to.]" 67 "[+<?Less than.]" 68 "[+<=?Less than or equal to.]" 69 "[+!=?Not equal to.]" 70 "}" 71 72 "[+\aexpr1\a \aop\a \aexpr2\a?Where \aop\a is \b+\b or \b-\b; " 73 "addition or subtraction of decimal integer-valued arguments.]" 74 "[+\aexpr1\a \aop\a \aexpr2\a?Where \aop\a is \b*\b, \b/\b or \b%\b; " 75 "multiplication, division, or remainder of the decimal " 76 "integer-valued arguments.]" 77 "[+\aexpr1\a \b::\b \aexpr2\a?The matching operator : compares " 78 "\aexpr1\a with \aexpr2\a, which must be a BRE. Normally, " 79 "the matching operator returns the number of bytes matched " 80 "and 0 on failure. However, if the pattern contains at " 81 "least one sub-expression [\\( . . .\\)]], the string " 82 "corresponding to \\1 will be returned.]" 83 "[+( \aexpr1\a )?Grouping symbols. An expression can " 84 "be placed within parenthesis to change precedence.]" 85 "[+match\b \astring\a \aexpr\a?Equivalent to \astring\a \b:\b " 86 "\aexpr\a.]" 87 "[+substr\b \astring\a \apos\a \alength\a?\alength\a character " 88 "substring of \astring\a starting at \apos\a " 89 "(counting from 1).]" 90 "[+index\b \astring\a \achars\a?The position in \astring\a " 91 "(counting from 1) of the leftmost occurrence of any " 92 "character in \achars\a.]" 93 "[+length\b \astring\a?The number of characters in \astring\a.]" 94 "[+quote\b \atoken\a?Treat \atoken\a as a string operand.]" 95 "}" 96 "[+?For backwards compatibility, unrecognized options beginning with " 97 "a \b-\b will be treated as operands. Portable applications " 98 "should use \b--\b to indicate end of options.]" 99 100 "\n" 101 "\n operand ...\n" 102 "\n" 103 104 "[+EXIT STATUS?]{" 105 "[+0?The expression is neither null nor 0.]" 106 "[+1?The expression is null or 0.]" 107 "[+2?Invalid expressions.]" 108 "[+>2?An error occurred.]" 109 "}" 110 "[+SEE ALSO?\bregcomp\b(5), \bgrep\b(1), \bsh\b(1)]" 111 ; 112 113 #include <cmd.h> 114 #include <regex.h> 115 116 #define T_ADD 0x100 117 #define T_MULT 0x200 118 #define T_CMP 0x400 119 #define T_FUN 0x800 120 #define T_OP 7 121 #define T_NUM 1 122 #define T_STR 2 123 124 #define OP_EQ (T_CMP|0) 125 #define OP_GT (T_CMP|1) 126 #define OP_LT (T_CMP|2) 127 #define OP_GE (T_CMP|3) 128 #define OP_LE (T_CMP|4) 129 #define OP_NE (T_CMP|5) 130 #define OP_PLUS (T_ADD|0) 131 #define OP_MINUS (T_ADD|1) 132 #define OP_MULT (T_MULT|0) 133 #define OP_DIV (T_MULT|1) 134 #define OP_MOD (T_MULT|2) 135 #define OP_INDEX (T_FUN|0) 136 #define OP_LENGTH (T_FUN|1) 137 #define OP_MATCH (T_FUN|2) 138 #define OP_QUOTE (T_FUN|3) 139 #define OP_SUBSTR (T_FUN|4) 140 141 #define numeric(np) ((np)->type&T_NUM) 142 143 static const struct Optable_s 144 { 145 const char opname[3]; 146 int op; 147 } 148 optable[] = 149 { 150 "|", '|', 151 "&", '&', 152 "=", OP_EQ, 153 "==", OP_EQ, 154 ">", OP_GT, 155 "<", OP_LT, 156 ">=", OP_GE, 157 "<=", OP_LE, 158 "!=", OP_NE, 159 "+", OP_PLUS, 160 "-", OP_MINUS, 161 "*", OP_MULT, 162 "/", OP_DIV, 163 "%", OP_MOD, 164 ":", ':', 165 "(", '(', 166 ")", ')' 167 }; 168 169 typedef struct Node_s 170 { 171 int type; 172 long num; 173 char *str; 174 } Node_t; 175 176 typedef struct State_s 177 { 178 int standard; 179 char** arglist; 180 char buf[36]; 181 } State_t; 182 183 static int expr_or(State_t*, Node_t*); 184 185 static int getnode(State_t* state, Node_t *np) 186 { 187 register char* sp; 188 register char* cp; 189 register int i; 190 register int j; 191 register int k; 192 register int tok; 193 char* ep; 194 195 if (!(cp = *state->arglist++)) 196 error(ERROR_exit(2), "argument expected"); 197 if (!state->standard) 198 switch (cp[0]) 199 { 200 case 'i': 201 if (cp[1] == 'n' && !strcmp(cp, "index")) 202 { 203 if (!(cp = *state->arglist++)) 204 error(ERROR_exit(2), "string argument expected"); 205 if (!(ep = *state->arglist++)) 206 error(ERROR_exit(2), "chars argument expected"); 207 np->num = (ep = strpbrk(cp, ep)) ? (ep - cp + 1) : 0; 208 np->type = T_NUM; 209 goto next; 210 } 211 break; 212 case 'l': 213 if (cp[1] == 'e' && !strcmp(cp, "length")) 214 { 215 if (!(cp = *state->arglist++)) 216 error(ERROR_exit(2), "string argument expected"); 217 np->num = strlen(cp); 218 np->type = T_NUM; 219 goto next; 220 } 221 break; 222 case 'm': 223 if (cp[1] == 'a' && !strcmp(cp, "match")) 224 { 225 if (!(np->str = *state->arglist++)) 226 error(ERROR_exit(2), "pattern argument expected"); 227 np->type = T_STR; 228 return ':'; 229 } 230 break; 231 case 'q': 232 if (cp[1] == 'u' && !strcmp(cp, "quote") && !(cp = *state->arglist++)) 233 error(ERROR_exit(2), "string argument expected"); 234 break; 235 case 's': 236 if (cp[1] == 'u' && !strcmp(cp, "substr")) 237 { 238 if (!(sp = *state->arglist++)) 239 error(ERROR_exit(2), "string argument expected"); 240 if (!(cp = *state->arglist++)) 241 error(ERROR_exit(2), "position argument expected"); 242 i = strtol(cp, &ep, 10); 243 if (*ep || --i < 0) 244 i = -1; 245 if (!(cp = *state->arglist++)) 246 error(ERROR_exit(2), "length argument expected"); 247 j = strtol(cp, &ep, 10); 248 if (*ep) 249 j = -1; 250 k = strlen(sp); 251 if (i < 0 || i >= k || j < 0) 252 sp = ""; 253 else 254 { 255 sp += i; 256 k -= i; 257 if (j < k) 258 sp[j] = 0; 259 } 260 np->type = T_STR; 261 np->str = sp; 262 goto next; 263 } 264 break; 265 } 266 if (*cp=='(' && cp[1]==0) 267 { 268 tok = expr_or(state, np); 269 if (tok != ')') 270 error(ERROR_exit(2),"closing parenthesis missing"); 271 } 272 else 273 { 274 np->type = T_STR; 275 np->str = cp; 276 if (*cp) 277 { 278 np->num = strtol(np->str,&ep,10); 279 if (!*ep) 280 np->type |= T_NUM; 281 } 282 } 283 next: 284 if (!(cp = *state->arglist)) 285 return 0; 286 state->arglist++; 287 for (i=0; i < sizeof(optable)/sizeof(*optable); i++) 288 if (*cp==optable[i].opname[0] && cp[1]==optable[i].opname[1]) 289 return optable[i].op; 290 error(ERROR_exit(2),"%s: unknown operator argument",cp); 291 return 0; 292 } 293 294 static int expr_cond(State_t* state, Node_t *np) 295 { 296 register int tok = getnode(state, np); 297 298 while (tok==':') 299 { 300 regex_t re; 301 regmatch_t match[2]; 302 int n; 303 Node_t rp; 304 char *cp; 305 tok = getnode(state, &rp); 306 if (np->type&T_STR) 307 cp = np->str; 308 else 309 sfsprintf(cp=state->buf,sizeof(state->buf),"%d",np->num); 310 np->num = 0; 311 np->type = T_NUM; 312 if (n = regcomp(&re, rp.str, REG_LEFT|REG_LENIENT)) 313 regfatal(&re, ERROR_exit(2), n); 314 if (!(n = regexec(&re, cp, elementsof(match), match, 0))) 315 { 316 if (re.re_nsub > 0) 317 { 318 np->type = T_STR; 319 if (match[1].rm_so >= 0) 320 { 321 np->str = cp + match[1].rm_so; 322 np->str[match[1].rm_eo - match[1].rm_so] = 0; 323 np->num = strtol(np->str,&cp,10); 324 if (cp!=np->str && *cp==0) 325 np->type |= T_NUM; 326 } 327 else 328 np->str = ""; 329 } 330 else 331 np->num = match[0].rm_eo - match[0].rm_so; 332 } 333 else if (n != REG_NOMATCH) 334 regfatal(&re, ERROR_exit(2), n); 335 else if (re.re_nsub) 336 { 337 np->str = ""; 338 np->type = T_STR; 339 } 340 regfree(&re); 341 } 342 return tok; 343 } 344 345 static int expr_mult(State_t* state, Node_t *np) 346 { 347 register int tok = expr_cond(state, np); 348 349 while ((tok&~T_OP)==T_MULT) 350 { 351 Node_t rp; 352 int op = (tok&T_OP); 353 tok = expr_cond(state, &rp); 354 if (!numeric(np) || !numeric(&rp)) 355 error(ERROR_exit(2),"non-numeric argument"); 356 if (op && rp.num==0) 357 error(ERROR_exit(2),"division by zero"); 358 switch(op) 359 { 360 case 0: 361 np->num *= rp.num; 362 break; 363 case 1: 364 np->num /= rp.num; 365 break; 366 case 2: 367 np->num %= rp.num; 368 } 369 np->type = T_NUM; 370 } 371 return tok; 372 } 373 374 static int expr_add(State_t* state, Node_t *np) 375 { 376 register int tok = expr_mult(state, np); 377 378 while ((tok&~T_OP)==T_ADD) 379 { 380 Node_t rp; 381 int op = (tok&T_OP); 382 tok = expr_mult(state, &rp); 383 if (!numeric(np) || !numeric(&rp)) 384 error(ERROR_exit(2),"non-numeric argument"); 385 if (op) 386 np->num -= rp.num; 387 else 388 np->num += rp.num; 389 np->type = T_NUM; 390 } 391 return tok; 392 } 393 394 static int expr_cmp(State_t* state, Node_t *np) 395 { 396 register int tok = expr_add(state, np); 397 398 while ((tok&~T_OP)==T_CMP) 399 { 400 Node_t rp; 401 register char *left,*right; 402 char buff1[36],buff2[36]; 403 int op = (tok&T_OP); 404 tok = expr_add(state, &rp); 405 if (numeric(&rp) && numeric(np)) 406 op |= 010; 407 else 408 { 409 if (np->type&T_STR) 410 left = np->str; 411 else 412 sfsprintf(left=buff1,sizeof(buff1),"%d",np->num); 413 if (rp.type&T_STR) 414 right = rp.str; 415 else 416 sfsprintf(right=buff2,sizeof(buff2),"%d",rp.num); 417 } 418 switch(op) 419 { 420 case 0: 421 np->num = streq(left,right); 422 break; 423 case 1: 424 np->num = (strcoll(left,right)>0); 425 break; 426 case 2: 427 np->num = (strcoll(left,right)<0); 428 break; 429 case 3: 430 np->num = (strcoll(left,right)>=0); 431 break; 432 case 4: 433 np->num = (strcoll(left,right)<=0); 434 break; 435 case 5: 436 np->num = !streq(left,right); 437 break; 438 case 010: 439 np->num = (np->num==rp.num); 440 break; 441 case 011: 442 np->num = (np->num>rp.num); 443 break; 444 case 012: 445 np->num = (np->num<rp.num); 446 break; 447 case 013: 448 np->num = (np->num>=rp.num); 449 break; 450 case 014: 451 np->num = (np->num<=rp.num); 452 break; 453 case 015: 454 np->num = (np->num!=rp.num); 455 break; 456 } 457 np->type = T_NUM; 458 } 459 return tok; 460 } 461 462 static int expr_and(State_t* state, Node_t *np) 463 { 464 register int tok = expr_cmp(state, np); 465 while (tok=='&') 466 { 467 Node_t rp; 468 tok = expr_cmp(state, &rp); 469 if ((numeric(&rp) && rp.num==0) || *rp.str==0) 470 { 471 np->num = 0; 472 np->type=T_NUM; 473 } 474 } 475 return tok; 476 } 477 478 static int expr_or(State_t* state, Node_t *np) 479 { 480 register int tok = expr_and(state, np); 481 while (tok=='|') 482 { 483 Node_t rp; 484 tok = expr_and(state, &rp); 485 if ((numeric(np) && np->num==0) || *np->str==0) 486 *np = rp; 487 } 488 return tok; 489 } 490 491 int 492 b_expr(int argc, char *argv[], void *context) 493 { 494 State_t state; 495 Node_t node; 496 int n; 497 498 cmdinit(argc, argv,context, ERROR_CATALOG, 0); 499 state.standard = !strcmp(astconf("CONFORMANCE", NiL, NiL), "standard"); 500 #if 0 501 if (state.standard) 502 state.arglist = argv+1; 503 else 504 #endif 505 { 506 while (n=optget(argv, usage)) 507 { 508 /* 509 * NOTE: this loop ignores all but literal -- and -? 510 * out of kindness for obsolescent usage 511 * (and is ok with the standard) but strict 512 * getopt conformance would give usage for all 513 * unknown - options 514 */ 515 if(n=='?') 516 error(ERROR_usage(2), "%s", opt_info.arg); 517 if (opt_info.option[1] != '?') 518 break; 519 error(ERROR_usage(2), "%s", opt_info.arg); 520 } 521 if (error_info.errors) 522 error(ERROR_usage(2),"%s",optusage((char*)0)); 523 state.arglist = argv+opt_info.index; 524 } 525 if (expr_or(&state, &node)) 526 error(ERROR_exit(2),"syntax error"); 527 if (node.type&T_STR) 528 { 529 if (*node.str) 530 sfprintf(sfstdout,"%s\n",node.str); 531 } 532 else 533 sfprintf(sfstdout,"%d\n",node.num); 534 return numeric(&node)?node.num==0:*node.str==0; 535 } 536