main/ast_expr2.y

   1 %{
   2 /* Written by Pace Willisson (pace@blitz.com)
   3  * and placed in the public domain.
   4  *
   5  * Largely rewritten by J.T. Conklin (jtc@wimsey.com)
   6  *
   7  * And then overhauled twice by Steve Murphy (murf@digium.com)
   8  * to add double-quoted strings, allow mult. spaces, improve
   9  * error messages, and then to fold in a flex scanner for the
  10  * yylex operation.
  11  *
  12  * $FreeBSD: src/bin/expr/expr.y,v 1.16 2000/07/22 10:59:36 se Exp $
  13  */
  14
  15 #include "asterisk.h"
  16
  17 #include <sys/types.h>
  18 #include <stdio.h>
  19
  20 #if !defined(STANDALONE) && !defined(STANDALONE2)       \
  21
  22 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  23 #else
  24 #ifndef __USE_ISOC99
  25 #define __USE_ISOC99 1
  26 #endif
  27 #endif
  28
  29 #ifdef __USE_ISOC99
  30 #define FP___PRINTF "%.18Lg"
  31 #define FP___TYPE    long double
  32 #else
  33 #define FP___PRINTF "%.16g"
  34 #define FP___TYPE    double
  35 #endif
  36
  37 #ifdef HAVE_COSL
  38 #define FUNC_COS   cosl
  39 #elif defined(HAVE_COS)
  40 #define FUNC_COS        (long double)cos
  41 #endif
  42
  43 #ifdef HAVE_SINL
  44 #define FUNC_SIN   sinl
  45 #elif defined(HAVE_SIN)
  46 #define FUNC_SIN        (long double)sin
  47 #endif
  48
  49 #ifdef HAVE_TANL
  50 #define FUNC_TAN   tanl
  51 #elif defined(HAVE_TAN)
  52 #define FUNC_TAN        (long double)tan
  53 #endif
  54
  55 #ifdef HAVE_ACOSL
  56 #define FUNC_ACOS   acosl
  57 #elif defined(HAVE_ACOS)
  58 #define FUNC_ACOS       (long double)acos
  59 #endif
  60
  61 #ifdef HAVE_ASINL
  62 #define FUNC_ASIN   asinl
  63 #elif defined(HAVE_ASIN)
  64 #define FUNC_ASIN       (long double)asin
  65 #endif
  66
  67 #ifdef HAVE_ATANL
  68 #define FUNC_ATAN   atanl
  69 #elif defined(HAVE_ATAN)
  70 #define FUNC_ATAN       (long double)atan
  71 #endif
  72
  73 #ifdef HAVE_ATAN2L
  74 #define FUNC_ATAN2   atan2l
  75 #elif defined(HAVE_ATAN2)
  76 #define FUNC_ATAN2      (long double)atan2
  77 #endif
  78
  79 #ifdef HAVE_POWL
  80 #define FUNC_POW   powl
  81 #elif defined(HAVE_POW)
  82 #define FUNC_POW        (long double)pow
  83 #endif
  84
  85 #ifdef HAVE_SQRTL
  86 #define FUNC_SQRT   sqrtl
  87 #elif defined(HAVE_SQRT)
  88 #define FUNC_SQRT       (long double)sqrt
  89 #endif
  90
  91 #ifdef HAVE_RINTL
  92 #define FUNC_RINT   rintl
  93 #elif defined(HAVE_RINT)
  94 #define FUNC_RINT       (long double)rint
  95 #endif
  96
  97 #ifdef HAVE_EXPL
  98 #define FUNC_EXP   expl
  99 #elif defined(HAVE_EXP)
 100 #define FUNC_EXP        (long double)exp
 101 #endif
 102
 103 #ifdef HAVE_LOGL
 104 #define FUNC_LOG   logl
 105 #elif defined(HAVE_LOG)
 106 #define FUNC_LOG        (long double)log
 107 #endif
 108
 109 #ifdef HAVE_REMAINDERL
 110 #define FUNC_REMAINDER   remainderl
 111 #elif defined(HAVE_REMAINDER)
 112 #define FUNC_REMAINDER  (long double)remainder
 113 #endif
 114
 115 #ifdef HAVE_FMODL
 116 #define FUNC_FMOD   fmodl
 117 #elif defined(HAVE_FMOD)
 118 #define FUNC_FMOD       (long double)fmod
 119 #endif
 120
 121 #ifdef HAVE_STRTOLD
 122 #define FUNC_STRTOD  strtold
 123 #elif defined(HAVE_STRTOD)
 124 #define FUNC_STRTOD  (long double)strtod
 125 #endif
 126
 127 #ifdef HAVE_FLOORL
 128 #define FUNC_FLOOR      floorl
 129 #elif defined(HAVE_FLOOR)
 130 #define FUNC_FLOOR      (long double)floor
 131 #endif
 132
 133 #ifdef HAVE_CEILL
 134 #define FUNC_CEIL      ceill
 135 #elif defined(HAVE_CEIL)
 136 #define FUNC_CEIL       (long double)ceil
 137 #endif
 138
 139 #ifdef HAVE_ROUNDL
 140 #define FUNC_ROUND     roundl
 141 #elif defined(HAVE_ROUND)
 142 #define FUNC_ROUND     (long double)round
 143 #endif
 144
 145 #ifdef HAVE_TRUNCL
 146 #define FUNC_TRUNC     truncl
 147 #elif defined(HAVE_TRUNC)
 148 #define FUNC_TRUNC     (long double)trunc
 149 #endif
 150
 151 /*! \note
 152  * Oddly enough, some platforms have some ISO C99 functions, but not others, so
 153  * we define the missing functions in terms of their mathematical identities.
 154  */
 155 #ifdef HAVE_EXP2L
 156 #define FUNC_EXP2       exp2l
 157 #elif (defined(HAVE_EXPL) && defined(HAVE_LOGL))
 158 #define FUNC_EXP2(x)    expl((x) * logl(2.0))
 159 #elif (defined(HAVE_EXP) && defined(HAVE_LOG))
 160 #define FUNC_EXP2(x)    (long double)exp((x) * log(2.0))
 161 #endif
 162
 163 #ifdef HAVE_EXP10L
 164 #define FUNC_EXP10       exp10l
 165 #elif (defined(HAVE_EXPL) && defined(HAVE_LOGL))
 166 #define FUNC_EXP10(x)   expl((x) * logl(10.0))
 167 #elif (defined(HAVE_EXP) && defined(HAVE_LOG))
 168 #define FUNC_EXP10(x)   (long double)exp((x) * log(10.0))
 169 #endif
 170
 171 #ifdef HAVE_LOG2L
 172 #define FUNC_LOG2       log2l
 173 #elif defined(HAVE_LOGL)
 174 #define FUNC_LOG2(x)    (logl(x) / logl(2.0))
 175 #elif defined(HAVE_LOG10L)
 176 #define FUNC_LOG2(x)    (log10l(x) / log10l(2.0))
 177 #elif defined(HAVE_LOG2)
 178 #define FUNC_LOG2       (long double)log2
 179 #elif defined(HAVE_LOG)
 180 #define FUNC_LOG2(x)    ((long double)log(x) / log(2.0))
 181 #endif
 182
 183 #ifdef HAVE_LOG10L
 184 #define FUNC_LOG10       log10l
 185 #elif defined(HAVE_LOGL)
 186 #define FUNC_LOG10(x)   (logl(x) / logl(10.0))
 187 #elif defined(HAVE_LOG2L)
 188 #define FUNC_LOG10(x)   (log2l(x) / log2l(10.0))
 189 #elif defined(HAVE_LOG10)
 190 #define FUNC_LOG10(x)   (long double)log10(x)
 191 #elif defined(HAVE_LOG)
 192 #define FUNC_LOG10(x)   ((long double)log(x) / log(10.0))
 193 #endif
 194
 195
 196 #include <stdlib.h>
 197 #ifndef _GNU_SOURCE
 198 #define _GNU_SOURCE
 199 #endif
 200 #include <string.h>
 201 #include <math.h>
 202 #include <locale.h>
 203 #include <unistd.h>
 204 #include <ctype.h>
 205 #if !defined(SOLARIS) && !defined(__CYGWIN__)
 206         /* #include <err.h> */
 207 #else
 208 #define quad_t int64_t
 209 #endif
 210 #include <errno.h>
 211 #include <regex.h>
 212 #include <limits.h>
 213
 214 #include "asterisk/ast_expr.h"
 215 #include "asterisk/logger.h"
 216 #if !defined(STANDALONE) && !defined(STANDALONE2)
 217 #include "asterisk/pbx.h"
 218 #endif
 219
 220 #if defined(LONG_LONG_MIN) && !defined(QUAD_MIN)
 221 #define QUAD_MIN LONG_LONG_MIN
 222 #endif
 223 #if defined(LONG_LONG_MAX) && !defined(QUAD_MAX)
 224 #define QUAD_MAX LONG_LONG_MAX
 225 #endif
 226
 227 #  if ! defined(QUAD_MIN)
 228 #   define QUAD_MIN     (-0x7fffffffffffffffLL-1)
 229 #  endif
 230 #  if ! defined(QUAD_MAX)
 231 #   define QUAD_MAX     (0x7fffffffffffffffLL)
 232 #  endif
 233 #define YYENABLE_NLS 0
 234 #define YYPARSE_PARAM parseio
 235 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
 236 #define YYERROR_VERBOSE 1
 237 extern char extra_error_message[4095];
 238 extern int extra_error_message_supplied;
 239
 240 enum valtype {
 241         AST_EXPR_number, AST_EXPR_numeric_string, AST_EXPR_string
 242 } ;
 243
 244 #if defined(STANDALONE) || defined(STANDALONE2)
 245 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...) __attribute__ ((format (printf,5,6)));
 246 #endif
 247
 248 struct val {
 249         enum valtype type;
 250         union {
 251                 char *s;
 252                 FP___TYPE i; /* either long double, or just double, on a bad day */
 253         } u;
 254 } ;
 255
 256 enum node_type {
 257         AST_EXPR_NODE_COMMA, AST_EXPR_NODE_STRING, AST_EXPR_NODE_VAL
 258 } ;
 259
 260 struct expr_node
 261 {
 262         enum node_type type;
 263         struct val *val;
 264         struct expr_node *left;
 265         struct expr_node *right;
 266 };
 267
 268
 269 typedef void *yyscan_t;
 270
 271 struct parse_io
 272 {
 273         char *string;
 274         struct val *val;
 275         yyscan_t scanner;
 276         struct ast_channel *chan;
 277 };
 278
 279 static int              chk_div __P((FP___TYPE, FP___TYPE));
 280 static int              chk_minus __P((FP___TYPE, FP___TYPE, FP___TYPE));
 281 static int              chk_plus __P((FP___TYPE, FP___TYPE, FP___TYPE));
 282 static int              chk_times __P((FP___TYPE, FP___TYPE, FP___TYPE));
 283 static void             free_value __P((struct val *));
 284 static int              is_zero_or_null __P((struct val *));
 285 static int              isstring __P((struct val *));
 286 static struct val       *make_number __P((FP___TYPE));
 287 static struct val       *make_str __P((const char *));
 288 static struct val       *op_and __P((struct val *, struct val *));
 289 static struct val       *op_colon __P((struct val *, struct val *));
 290 static struct val       *op_eqtilde __P((struct val *, struct val *));
 291 static struct val       *op_tildetilde __P((struct val *, struct val *));
 292 static struct val       *op_div __P((struct val *, struct val *));
 293 static struct val       *op_eq __P((struct val *, struct val *));
 294 static struct val       *op_ge __P((struct val *, struct val *));
 295 static struct val       *op_gt __P((struct val *, struct val *));
 296 static struct val       *op_le __P((struct val *, struct val *));
 297 static struct val       *op_lt __P((struct val *, struct val *));
 298 static struct val       *op_cond __P((struct val *, struct val *, struct val *));
 299 static struct val       *op_minus __P((struct val *, struct val *));
 300 static struct val       *op_negate __P((struct val *));
 301 static struct val       *op_compl __P((struct val *));
 302 static struct val       *op_ne __P((struct val *, struct val *));
 303 static struct val       *op_or __P((struct val *, struct val *));
 304 static struct val       *op_plus __P((struct val *, struct val *));
 305 static struct val       *op_rem __P((struct val *, struct val *));
 306 static struct val       *op_times __P((struct val *, struct val *));
 307 static struct val   *op_func(struct val *funcname, struct expr_node *arglist, struct ast_channel *chan);
 308 static int              to_number __P((struct val *));
 309 static void             to_string __P((struct val *));
 310 static struct expr_node *alloc_expr_node(enum node_type);
 311 static void destroy_arglist(struct expr_node *arglist);
 312
 313 /* uh, if I want to predeclare yylex with a YYLTYPE, I have to predeclare the yyltype... sigh */
 314 typedef struct yyltype
 315 {
 316   int first_line;
 317   int first_column;
 318
 319   int last_line;
 320   int last_column;
 321 } yyltype;
 322
 323 # define YYLTYPE yyltype
 324 # define YYLTYPE_IS_TRIVIAL 1
 325
 326 /* we will get warning about no prototype for yylex! But we can't
 327    define it here, we have no definition yet for YYSTYPE. */
 328
 329 int             ast_yyerror(const char *,YYLTYPE *, struct parse_io *);
 330
 331 /* I wanted to add args to the yyerror routine, so I could print out
 332    some useful info about the error. Not as easy as it looks, but it
 333    is possible. */
 334 #define ast_yyerror(x) ast_yyerror(x,&yyloc,parseio)
 335 #define DESTROY(x) {if((x)->type == AST_EXPR_numeric_string || (x)->type == AST_EXPR_string) free((x)->u.s); (x)->u.s = 0; free(x);}
 336 %}
 337
 338 %pure-parser
 339 %locations
 340 /* %debug  for when you are having big problems */
 341
 342 /* %name-prefix="ast_yy" */
 343
 344 %union
 345 {
 346         struct val *val;
 347         struct expr_node *arglist;
 348 }
 349
 350 %{
 351 extern int              ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
 352 %}
 353 %left <val> TOK_COMMA
 354 %left <val> TOK_COND TOK_COLONCOLON
 355 %left <val> TOK_OR
 356 %left <val> TOK_AND
 357 %left <val> TOK_EQ TOK_GT TOK_LT TOK_GE TOK_LE TOK_NE
 358 %left <val> TOK_PLUS TOK_MINUS
 359 %left <val> TOK_MULT TOK_DIV TOK_MOD
 360 %right <val> TOK_COMPL
 361 %left <val> TOK_COLON TOK_EQTILDE TOK_TILDETILDE
 362 %left <val> TOK_RP TOK_LP
 363
 364 %token <val> TOKEN
 365 %type <arglist> arglist
 366 %type <val> start expr
 367
 368 %destructor {  free_value($$); }  expr TOKEN TOK_COND TOK_COLONCOLON TOK_OR TOK_AND TOK_EQ
 369                                  TOK_GT TOK_LT TOK_GE TOK_LE TOK_NE TOK_PLUS TOK_MINUS TOK_MULT TOK_DIV TOK_MOD TOK_COMPL TOK_COLON TOK_EQTILDE
 370                                  TOK_RP TOK_LP TOK_TILDETILDE
 371
 372 %%
 373
 374 start: expr { ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
 375               ((struct parse_io *)parseio)->val->type = $1->type;
 376               if( $1->type == AST_EXPR_number )
 377                                   ((struct parse_io *)parseio)->val->u.i = $1->u.i;
 378               else
 379                                   ((struct parse_io *)parseio)->val->u.s = $1->u.s;
 380                           free($1);
 381                         }
 382         | {/* nothing */ ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
 383               ((struct parse_io *)parseio)->val->type = AST_EXPR_string;
 384                           ((struct parse_io *)parseio)->val->u.s = strdup("");
 385                         }
 386
 387         ;
 388
 389 arglist: expr { $$ = alloc_expr_node(AST_EXPR_NODE_VAL); $$->val = $1;}
 390        | arglist TOK_COMMA expr %prec TOK_RP {struct expr_node *x = alloc_expr_node(AST_EXPR_NODE_VAL);
 391                                  struct expr_node *t;
 392                                                                  DESTROY($2);
 393                                  for (t=$1;t->right;t=t->right)
 394                                                                   ;
 395                                  $$ = $1; t->right = x; x->val = $3;}
 396        | arglist TOK_COMMA %prec TOK_RP {struct expr_node *x = alloc_expr_node(AST_EXPR_NODE_VAL);
 397                                  struct expr_node *t;  /* NULL args should OK */
 398                                                                  DESTROY($2);
 399                                  for (t=$1;t->right;t=t->right)
 400                                                                   ;
 401                                  $$ = $1; t->right = x; x->val = make_str("");}
 402        ;
 403
 404 expr:
 405       TOKEN TOK_LP arglist TOK_RP { $$ = op_func($1,$3, ((struct parse_io *)parseio)->chan);
 406                                             DESTROY($2);
 407                                                                         DESTROY($4);
 408                                                                         DESTROY($1);
 409                                                                         destroy_arglist($3);
 410                                   }
 411     | TOKEN {$$ = $1;}
 412         | TOK_LP expr TOK_RP { $$ = $2;
 413                                @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 414                                                    @$.first_line=0; @$.last_line=0;
 415                                                         DESTROY($1); DESTROY($3); }
 416         | expr TOK_OR expr { $$ = op_or ($1, $3);
 417                                                 DESTROY($2);
 418                          @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 419                                                  @$.first_line=0; @$.last_line=0;}
 420         | expr TOK_AND expr { $$ = op_and ($1, $3);
 421                                                 DESTROY($2);
 422                               @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 423                           @$.first_line=0; @$.last_line=0;}
 424         | expr TOK_EQ expr { $$ = op_eq ($1, $3);
 425                                                 DESTROY($2);
 426                              @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 427                                                  @$.first_line=0; @$.last_line=0;}
 428         | expr TOK_GT expr { $$ = op_gt ($1, $3);
 429                                                 DESTROY($2);
 430                          @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 431                                                  @$.first_line=0; @$.last_line=0;}
 432         | expr TOK_LT expr { $$ = op_lt ($1, $3);
 433                                                 DESTROY($2);
 434                              @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 435                                                  @$.first_line=0; @$.last_line=0;}
 436         | expr TOK_GE expr  { $$ = op_ge ($1, $3);
 437                                                 DESTROY($2);
 438                               @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 439                                                   @$.first_line=0; @$.last_line=0;}
 440         | expr TOK_LE expr  { $$ = op_le ($1, $3);
 441                                                 DESTROY($2);
 442                               @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 443                                                   @$.first_line=0; @$.last_line=0;}
 444         | expr TOK_NE expr  { $$ = op_ne ($1, $3);
 445                                                 DESTROY($2);
 446                               @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 447                                                   @$.first_line=0; @$.last_line=0;}
 448         | expr TOK_PLUS expr { $$ = op_plus ($1, $3);
 449                                                 DESTROY($2);
 450                                @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 451                                                    @$.first_line=0; @$.last_line=0;}
 452         | expr TOK_MINUS expr { $$ = op_minus ($1, $3);
 453                                                 DESTROY($2);
 454                                 @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 455                                                         @$.first_line=0; @$.last_line=0;}
 456         | TOK_MINUS expr %prec TOK_COMPL { $$ = op_negate ($2);
 457                                                 DESTROY($1);
 458                                 @$.first_column = @1.first_column; @$.last_column = @2.last_column;
 459                                                         @$.first_line=0; @$.last_line=0;}
 460         | TOK_COMPL expr   { $$ = op_compl ($2);
 461                                                 DESTROY($1);
 462                                 @$.first_column = @1.first_column; @$.last_column = @2.last_column;
 463                                                         @$.first_line=0; @$.last_line=0;}
 464         | expr TOK_MULT expr { $$ = op_times ($1, $3);
 465                                                 DESTROY($2);
 466                                @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 467                                                    @$.first_line=0; @$.last_line=0;}
 468         | expr TOK_DIV expr { $$ = op_div ($1, $3);
 469                                                 DESTROY($2);
 470                               @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 471                                                   @$.first_line=0; @$.last_line=0;}
 472         | expr TOK_MOD expr { $$ = op_rem ($1, $3);
 473                                                 DESTROY($2);
 474                               @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 475                                                   @$.first_line=0; @$.last_line=0;}
 476         | expr TOK_COLON expr { $$ = op_colon ($1, $3);
 477                                                 DESTROY($2);
 478                                 @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 479                                                         @$.first_line=0; @$.last_line=0;}
 480         | expr TOK_EQTILDE expr { $$ = op_eqtilde ($1, $3);
 481                                                 DESTROY($2);
 482                                 @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 483                                                         @$.first_line=0; @$.last_line=0;}
 484         | expr TOK_COND expr TOK_COLONCOLON expr  { $$ = op_cond ($1, $3, $5);
 485                                                 DESTROY($2);
 486                                                 DESTROY($4);
 487                                 @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 488                                                         @$.first_line=0; @$.last_line=0;}
 489         | expr TOK_TILDETILDE expr { $$ = op_tildetilde ($1, $3);
 490                                                 DESTROY($2);
 491                                 @$.first_column = @1.first_column; @$.last_column = @3.last_column;
 492                                                         @$.first_line=0; @$.last_line=0;}
 493         ;
 494
 495 %%
 496
 497 static struct expr_node *alloc_expr_node(enum node_type nt)
 498 {
 499         struct expr_node *x = calloc(1,sizeof(struct expr_node));
 500         if (!x) {
 501                 ast_log(LOG_ERROR, "Allocation for expr_node FAILED!!\n");
 502                 return 0;
 503         }
 504         x->type = nt;
 505         return x;
 506 }
 507
 508
 509
 510 static struct val *
 511 make_number (FP___TYPE i)
 512 {
 513         struct val *vp;
 514
 515         vp = (struct val *) malloc (sizeof (*vp));
 516         if (vp == NULL) {
 517                 ast_log(LOG_WARNING, "malloc() failed\n");
 518                 return(NULL);
 519         }
 520
 521         vp->type = AST_EXPR_number;
 522         vp->u.i  = i;
 523         return vp;
 524 }
 525
 526 static struct val *
 527 make_str (const char *s)
 528 {
 529         struct val *vp;
 530         size_t i;
 531         int isint; /* this started out being a test for an integer, but then ended up being a test for a float */
 532
 533         vp = (struct val *) malloc (sizeof (*vp));
 534         if (vp == NULL || ((vp->u.s = strdup (s)) == NULL)) {
 535                 ast_log(LOG_WARNING,"malloc() failed\n");
 536                 return(NULL);
 537         }
 538
 539         for (i = 0, isint = (isdigit(s[0]) || s[0] == '-' || s[0]=='.'); isint && i < strlen(s); i++)
 540         {
 541                 if (!isdigit(s[i]) && s[i] != '.') {
 542                         isint = 0;
 543                         break;
 544                 }
 545         }
 546         if (isint)
 547                 vp->type = AST_EXPR_numeric_string;
 548         else
 549                 vp->type = AST_EXPR_string;
 550
 551         return vp;
 552 }
 553
 554
 555 static void
 556 free_value (struct val *vp)
 557 {
 558         if (vp==NULL) {
 559                 return;
 560         }
 561         if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
 562                 free (vp->u.s);
 563         free(vp);
 564 }
 565
 566
 567 static int
 568 to_number (struct val *vp)
 569 {
 570         FP___TYPE i;
 571
 572         if (vp == NULL) {
 573                 ast_log(LOG_WARNING,"vp==NULL in to_number()\n");
 574                 return(0);
 575         }
 576
 577         if (vp->type == AST_EXPR_number)
 578                 return 1;
 579
 580         if (vp->type == AST_EXPR_string)
 581                 return 0;
 582
 583         /* vp->type == AST_EXPR_numeric_string, make it numeric */
 584         errno = 0;
 585         i  = FUNC_STRTOD(vp->u.s, (char**)0); /* either strtod, or strtold on a good day */
 586         if (errno != 0) {
 587                 ast_log(LOG_WARNING,"Conversion of %s to number under/overflowed!\n", vp->u.s);
 588                 free(vp->u.s);
 589                 vp->u.s = 0;
 590                 return(0);
 591         }
 592         free (vp->u.s);
 593         vp->u.i = i;
 594         vp->type = AST_EXPR_number;
 595         return 1;
 596 }
 597
 598 static void
 599 strip_quotes(struct val *vp)
 600 {
 601         if (vp->type != AST_EXPR_string && vp->type != AST_EXPR_numeric_string)
 602                 return;
 603
 604         if( vp->u.s[0] == '"' && vp->u.s[strlen(vp->u.s)-1] == '"' )
 605         {
 606                 char *f, *t;
 607                 f = vp->u.s;
 608                 t = vp->u.s;
 609
 610                 while( *f )
 611                 {
 612                         if( *f  && *f != '"' )
 613                                 *t++ = *f++;
 614                         else
 615                                 f++;
 616                 }
 617                 *t = *f;
 618         }
 619 }
 620
 621 static void
 622 to_string (struct val *vp)
 623 {
 624         char *tmp;
 625
 626         if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
 627                 return;
 628
 629         tmp = malloc ((size_t)25);
 630         if (tmp == NULL) {
 631                 ast_log(LOG_WARNING,"malloc() failed\n");
 632                 return;
 633         }
 634
 635         sprintf(tmp, FP___PRINTF, vp->u.i);
 636         vp->type = AST_EXPR_string;
 637         vp->u.s  = tmp;
 638 }
 639
 640
 641 static int
 642 isstring (struct val *vp)
 643 {
 644         /* only TRUE if this string is not a valid number */
 645         return (vp->type == AST_EXPR_string);
 646 }
 647
 648
 649 static int
 650 is_zero_or_null (struct val *vp)
 651 {
 652         if (vp->type == AST_EXPR_number) {
 653                 return (vp->u.i == 0);
 654         } else {
 655                 return (*vp->u.s == 0 || (to_number(vp) && vp->u.i == 0));
 656         }
 657         /* NOTREACHED */
 658 }
 659
 660 #ifdef STANDALONE2
 661
 662 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
 663 {
 664         va_list vars;
 665         va_start(vars,fmt);
 666
 667         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
 668                    level, file, line, function);
 669         vprintf(fmt, vars);
 670         fflush(stdout);
 671         va_end(vars);
 672 }
 673
 674
 675 int main(int argc,char **argv) {
 676         char s[4096];
 677         char out[4096];
 678         FILE *infile;
 679
 680         if( !argv[1] )
 681                 exit(20);
 682
 683         if( access(argv[1],F_OK)== 0 )
 684         {
 685                 int ret;
 686
 687                 infile = fopen(argv[1],"r");
 688                 if( !infile )
 689                 {
 690                         printf("Sorry, couldn't open %s for reading!\n", argv[1]);
 691                         exit(10);
 692                 }
 693                 while( fgets(s,sizeof(s),infile) )
 694                 {
 695                         if( s[strlen(s)-1] == '\n' )
 696                                 s[strlen(s)-1] = 0;
 697
 698                         ret = ast_expr(s, out, sizeof(out), NULL);
 699                         printf("Expression: %s    Result: [%d] '%s'\n",
 700                                    s, ret, out);
 701                 }
 702                 fclose(infile);
 703         }
 704         else
 705         {
 706                 if (ast_expr(argv[1], s, sizeof(s), NULL))
 707                         printf("=====%s======\n",s);
 708                 else
 709                         printf("No result\n");
 710         }
 711         return 0;
 712 }
 713
 714 #endif
 715
 716 #undef ast_yyerror
 717 #define ast_yyerror(x) ast_yyerror(x, YYLTYPE *yylloc, struct parse_io *parseio)
 718
 719 /* I put the ast_yyerror func in the flex input file,
 720    because it refers to the buffer state. Best to
 721    let it access the BUFFER stuff there and not trying
 722    define all the structs, macros etc. in this file! */
 723
 724 static void destroy_arglist(struct expr_node *arglist)
 725 {
 726         struct expr_node *arglist_next;
 727
 728         while (arglist)
 729         {
 730                 arglist_next = arglist->right;
 731                 if (arglist->val)
 732                         free_value(arglist->val);
 733                 arglist->val = 0;
 734                 arglist->right = 0;
 735                 free(arglist);
 736                 arglist = arglist_next;
 737         }
 738 }
 739
 740 #if !defined(STANDALONE) && !defined(STANDALONE2)
 741 static char *compose_func_args(struct expr_node *arglist)
 742 {
 743         struct expr_node *t = arglist;
 744         char *argbuf;
 745         int total_len = 0;
 746
 747         while (t) {
 748                 if (t != arglist)
 749                         total_len += 1; /* for the sep */
 750                 if (t->val) {
 751                         if (t->val->type == AST_EXPR_number)
 752                                 total_len += 25; /* worst case */
 753                         else
 754                                 total_len += strlen(t->val->u.s);
 755                 }
 756
 757                 t = t->right;
 758         }
 759         total_len++; /* for the null */
 760         ast_log(LOG_NOTICE,"argbuf allocated %d bytes;\n", total_len);
 761         argbuf = malloc(total_len);
 762         argbuf[0] = 0;
 763         t = arglist;
 764         while (t) {
 765                 char numbuf[30];
 766
 767                 if (t != arglist)
 768                         strcat(argbuf,",");
 769
 770                 if (t->val) {
 771                         if (t->val->type == AST_EXPR_number) {
 772                                 sprintf(numbuf,FP___PRINTF,t->val->u.i);
 773                                 strcat(argbuf,numbuf);
 774                         } else
 775                                 strcat(argbuf,t->val->u.s);
 776                 }
 777                 t = t->right;
 778         }
 779         ast_log(LOG_NOTICE,"argbuf uses %d bytes;\n", (int) strlen(argbuf));
 780         return argbuf;
 781 }
 782
 783 static int is_really_num(char *str)
 784 {
 785         if ( strspn(str,"-0123456789.   ") == strlen(str))
 786                 return 1;
 787         else
 788                 return 0;
 789 }
 790 #endif
 791
 792 static struct val *op_func(struct val *funcname, struct expr_node *arglist, struct ast_channel *chan)
 793 {
 794         if (strspn(funcname->u.s,"ABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789") == strlen(funcname->u.s))
 795         {
 796                 struct val *result;
 797                 if (0) {
 798 #ifdef FUNC_COS
 799                 } else if (strcmp(funcname->u.s,"COS") == 0) {
 800                         if (arglist && !arglist->right && arglist->val){
 801                                 to_number(arglist->val);
 802                                 result = make_number(FUNC_COS(arglist->val->u.i));
 803                                 return result;
 804                         } else {
 805                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 806                                 return make_number(0.0);
 807                         }
 808 #endif
 809 #ifdef FUNC_SIN
 810                 } else if (strcmp(funcname->u.s,"SIN") == 0) {
 811                         if (arglist && !arglist->right && arglist->val){
 812                                 to_number(arglist->val);
 813                                 result = make_number(FUNC_SIN(arglist->val->u.i));
 814                                 return result;
 815                         } else {
 816                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 817                                 return make_number(0.0);
 818                         }
 819 #endif
 820 #ifdef FUNC_TAN
 821                 } else if (strcmp(funcname->u.s,"TAN") == 0) {
 822                         if (arglist && !arglist->right && arglist->val){
 823                                 to_number(arglist->val);
 824                                 result = make_number(FUNC_TAN(arglist->val->u.i));
 825                                 return result;
 826                         } else {
 827                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 828                                 return make_number(0.0);
 829                         }
 830 #endif
 831 #ifdef FUNC_ACOS
 832                 } else if (strcmp(funcname->u.s,"ACOS") == 0) {
 833                         if (arglist && !arglist->right && arglist->val){
 834                                 to_number(arglist->val);
 835                                 result = make_number(FUNC_ACOS(arglist->val->u.i));
 836                                 return result;
 837                         } else {
 838                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 839                                 return make_number(0.0);
 840                         }
 841 #endif
 842 #ifdef FUNC_ASIN
 843                 } else if (strcmp(funcname->u.s,"ASIN") == 0) {
 844                         if (arglist && !arglist->right && arglist->val){
 845                                 to_number(arglist->val);
 846                                 result = make_number(FUNC_ASIN(arglist->val->u.i));
 847                                 return result;
 848                         } else {
 849                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 850                                 return make_number(0.0);
 851                         }
 852 #endif
 853 #ifdef FUNC_ATAN
 854                 } else if (strcmp(funcname->u.s,"ATAN") == 0) {
 855                         if (arglist && !arglist->right && arglist->val){
 856                                 to_number(arglist->val);
 857                                 result = make_number(FUNC_ATAN(arglist->val->u.i));
 858                                 return result;
 859                         } else {
 860                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 861                                 return make_number(0.0);
 862                         }
 863 #endif
 864 #ifdef FUNC_ATAN2
 865                 } else if (strcmp(funcname->u.s,"ATAN2") == 0) {
 866                         if (arglist && arglist->right && !arglist->right->right && arglist->val && arglist->right->val){
 867                                 to_number(arglist->val);
 868                                 to_number(arglist->right->val);
 869                                 result = make_number(FUNC_ATAN2(arglist->val->u.i, arglist->right->val->u.i));
 870                                 return result;
 871                         } else {
 872                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 873                                 return make_number(0.0);
 874                         }
 875 #endif
 876 #ifdef FUNC_POW
 877                 } else if (strcmp(funcname->u.s,"POW") == 0) {
 878                         if (arglist && arglist->right && !arglist->right->right && arglist->val && arglist->right->val){
 879                                 to_number(arglist->val);
 880                                 to_number(arglist->right->val);
 881                                 result = make_number(FUNC_POW(arglist->val->u.i, arglist->right->val->u.i));
 882                                 return result;
 883                         } else {
 884                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 885                                 return make_number(0.0);
 886                         }
 887 #endif
 888 #ifdef FUNC_SQRT
 889                 } else if (strcmp(funcname->u.s,"SQRT") == 0) {
 890                         if (arglist && !arglist->right && arglist->val){
 891                                 to_number(arglist->val);
 892                                 result = make_number(FUNC_SQRT(arglist->val->u.i));
 893                                 return result;
 894                         } else {
 895                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 896                                 return make_number(0.0);
 897                         }
 898 #endif
 899 #ifdef FUNC_FLOOR
 900                 } else if (strcmp(funcname->u.s,"FLOOR") == 0) {
 901                         if (arglist && !arglist->right && arglist->val){
 902                                 to_number(arglist->val);
 903                                 result = make_number(FUNC_FLOOR(arglist->val->u.i));
 904                                 return result;
 905                         } else {
 906                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 907                                 return make_number(0.0);
 908                         }
 909 #endif
 910 #ifdef FUNC_CEIL
 911                 } else if (strcmp(funcname->u.s,"CEIL") == 0) {
 912                         if (arglist && !arglist->right && arglist->val){
 913                                 to_number(arglist->val);
 914                                 result = make_number(FUNC_CEIL(arglist->val->u.i));
 915                                 return result;
 916                         } else {
 917                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 918                                 return make_number(0.0);
 919                         }
 920 #endif
 921 #ifdef FUNC_ROUND
 922                 } else if (strcmp(funcname->u.s,"ROUND") == 0) {
 923                         if (arglist && !arglist->right && arglist->val){
 924                                 to_number(arglist->val);
 925                                 result = make_number(FUNC_ROUND(arglist->val->u.i));
 926                                 return result;
 927                         } else {
 928                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 929                                 return make_number(0.0);
 930                         }
 931 #endif /* defined(FUNC_ROUND) */
 932 #ifdef FUNC_RINT
 933                 } else if (strcmp(funcname->u.s,"RINT") == 0) {
 934                         if (arglist && !arglist->right && arglist->val){
 935                                 to_number(arglist->val);
 936                                 result = make_number(FUNC_RINT(arglist->val->u.i));
 937                                 return result;
 938                         } else {
 939                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 940                                 return make_number(0.0);
 941                         }
 942 #endif
 943 #ifdef FUNC_TRUNC
 944                 } else if (strcmp(funcname->u.s,"TRUNC") == 0) {
 945                         if (arglist && !arglist->right && arglist->val){
 946                                 to_number(arglist->val);
 947                                 result = make_number(FUNC_TRUNC(arglist->val->u.i));
 948                                 return result;
 949                         } else {
 950                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 951                                 return make_number(0.0);
 952                         }
 953 #endif /* defined(FUNC_TRUNC) */
 954 #ifdef FUNC_EXP
 955                 } else if (strcmp(funcname->u.s,"EXP") == 0) {
 956                         if (arglist && !arglist->right && arglist->val){
 957                                 to_number(arglist->val);
 958                                 result = make_number(FUNC_EXP(arglist->val->u.i));
 959                                 return result;
 960                         } else {
 961                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 962                                 return make_number(0.0);
 963                         }
 964 #endif
 965 #ifdef FUNC_EXP2
 966                 } else if (strcmp(funcname->u.s,"EXP2") == 0) {
 967                         if (arglist && !arglist->right && arglist->val){
 968                                 to_number(arglist->val);
 969                                 result = make_number(FUNC_EXP2(arglist->val->u.i));
 970                                 return result;
 971                         } else {
 972                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 973                                 return make_number(0.0);
 974                         }
 975 #endif
 976 #ifdef FUNC_EXP10
 977                 } else if (strcmp(funcname->u.s,"EXP10") == 0) {
 978                         if (arglist && !arglist->right && arglist->val){
 979                                 to_number(arglist->val);
 980                                 result = make_number(FUNC_EXP10(arglist->val->u.i));
 981                                 return result;
 982                         } else {
 983                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 984                                 return make_number(0.0);
 985                         }
 986 #endif
 987 #ifdef FUNC_LOG
 988                 } else if (strcmp(funcname->u.s,"LOG") == 0) {
 989                         if (arglist && !arglist->right && arglist->val){
 990                                 to_number(arglist->val);
 991                                 result = make_number(FUNC_LOG(arglist->val->u.i));
 992                                 return result;
 993                         } else {
 994                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
 995                                 return make_number(0.0);
 996                         }
 997 #endif
 998 #ifdef FUNC_LOG2
 999                 } else if (strcmp(funcname->u.s,"LOG2") == 0) {
1000                         if (arglist && !arglist->right && arglist->val){
1001                                 to_number(arglist->val);
1002                                 result = make_number(FUNC_LOG2(arglist->val->u.i));
1003                                 return result;
1004                         } else {
1005                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
1006                                 return make_number(0.0);
1007                         }
1008 #endif
1009 #ifdef FUNC_LOG10
1010                 } else if (strcmp(funcname->u.s,"LOG10") == 0) {
1011                         if (arglist && !arglist->right && arglist->val){
1012                                 to_number(arglist->val);
1013                                 result = make_number(FUNC_LOG10(arglist->val->u.i));
1014                                 return result;
1015                         } else {
1016                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
1017                                 return make_number(0.0);
1018                         }
1019 #endif
1020 #ifdef FUNC_REMAINDER
1021                 } else if (strcmp(funcname->u.s,"REMAINDER") == 0) {
1022                         if (arglist && arglist->right && !arglist->right->right && arglist->val && arglist->right->val){
1023                                 to_number(arglist->val);
1024                                 to_number(arglist->right->val);
1025                                 result = make_number(FUNC_REMAINDER(arglist->val->u.i, arglist->right->val->u.i));
1026                                 return result;
1027                         } else {
1028                                 ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
1029                                 return make_number(0.0);
1030                         }
1031 #endif
1032                 } else {
1033                         /* is this a custom function we should execute and collect the results of? */
1034 #if !defined(STANDALONE) && !defined(STANDALONE2)
1035                         struct ast_custom_function *f = ast_custom_function_find(funcname->u.s);
1036                         if (!chan)
1037                                 ast_log(LOG_WARNING,"Hey! chan is NULL.\n");
1038                         if (!f)
1039                                 ast_log(LOG_WARNING,"Hey! could not find func %s.\n", funcname->u.s);
1040
1041                         if (f && chan) {
1042                                 if (f->read) {
1043                                         char workspace[512];
1044                                         char *argbuf = compose_func_args(arglist);
1045                                         f->read(chan, funcname->u.s, argbuf, workspace, sizeof(workspace));
1046                                         free(argbuf);
1047                                         if (is_really_num(workspace))
1048                                                 return make_number(FUNC_STRTOD(workspace,(char **)NULL));
1049                                         else
1050                                                 return make_str(workspace);
1051                                 } else {
1052                                         ast_log(LOG_ERROR,"Error! Function '%s' cannot be read!\n", funcname->u.s);
1053                                         return (make_number ((FP___TYPE)0.0));
1054                                 }
1055
1056                         } else {
1057                                 ast_log(LOG_ERROR,"Error! '%s' doesn't appear to be an available function!", funcname->u.s);
1058                                 return (make_number ((FP___TYPE)0.0));
1059                         }
1060 #else
1061                         ast_log(LOG_ERROR,"Error! '%s' is not available in the standalone version!", funcname->u.s);
1062                         return (make_number ((FP___TYPE)0.0));
1063 #endif
1064                 }
1065         }
1066         else
1067         {
1068                 ast_log(LOG_ERROR,"Error! '%s' is not possibly a function name!", funcname->u.s);
1069                 return (make_number ((FP___TYPE)0.0));
1070         }
1071         return (make_number ((FP___TYPE)0.0));
1072 }
1073
1074
1075 static struct val *
1076 op_or (struct val *a, struct val *b)
1077 {
1078         if (is_zero_or_null (a)) {
1079                 free_value (a);
1080                 return (b);
1081         } else {
1082                 free_value (b);
1083                 return (a);
1084         }
1085 }
1086
1087 static struct val *
1088 op_and (struct val *a, struct val *b)
1089 {
1090         if (is_zero_or_null (a) || is_zero_or_null (b)) {
1091                 free_value (a);
1092                 free_value (b);
1093                 return (make_number ((FP___TYPE)0.0));
1094         } else {
1095                 free_value (b);
1096                 return (a);
1097         }
1098 }
1099
1100 static struct val *
1101 op_eq (struct val *a, struct val *b)
1102 {
1103         struct val *r;
1104
1105         if (isstring (a) || isstring (b)) {
1106                 to_string (a);
1107                 to_string (b);
1108                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) == 0));
1109         } else {
1110 #ifdef DEBUG_FOR_CONVERSIONS
1111                 char buffer[2000];
1112                 sprintf(buffer,"Converting '%s' and '%s' ", a->u.s, b->u.s);
1113 #endif
1114                 (void)to_number(a);
1115                 (void)to_number(b);
1116 #ifdef DEBUG_FOR_CONVERSIONS
1117                 ast_log(LOG_WARNING,"%s to '%lld' and '%lld'\n", buffer, a->u.i, b->u.i);
1118 #endif
1119                 r = make_number ((FP___TYPE)(a->u.i == b->u.i));
1120         }
1121
1122         free_value (a);
1123         free_value (b);
1124         return r;
1125 }
1126
1127 static struct val *
1128 op_gt (struct val *a, struct val *b)
1129 {
1130         struct val *r;
1131
1132         if (isstring (a) || isstring (b)) {
1133                 to_string (a);
1134                 to_string (b);
1135                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) > 0));
1136         } else {
1137                 (void)to_number(a);
1138                 (void)to_number(b);
1139                 r = make_number ((FP___TYPE)(a->u.i > b->u.i));
1140         }
1141
1142         free_value (a);
1143         free_value (b);
1144         return r;
1145 }
1146
1147 static struct val *
1148 op_lt (struct val *a, struct val *b)
1149 {
1150         struct val *r;
1151
1152         if (isstring (a) || isstring (b)) {
1153                 to_string (a);
1154                 to_string (b);
1155                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) < 0));
1156         } else {
1157                 (void)to_number(a);
1158                 (void)to_number(b);
1159                 r = make_number ((FP___TYPE)(a->u.i < b->u.i));
1160         }
1161
1162         free_value (a);
1163         free_value (b);
1164         return r;
1165 }
1166
1167 static struct val *
1168 op_ge (struct val *a, struct val *b)
1169 {
1170         struct val *r;
1171
1172         if (isstring (a) || isstring (b)) {
1173                 to_string (a);
1174                 to_string (b);
1175                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) >= 0));
1176         } else {
1177                 (void)to_number(a);
1178                 (void)to_number(b);
1179                 r = make_number ((FP___TYPE)(a->u.i >= b->u.i));
1180         }
1181
1182         free_value (a);
1183         free_value (b);
1184         return r;
1185 }
1186
1187 static struct val *
1188 op_le (struct val *a, struct val *b)
1189 {
1190         struct val *r;
1191
1192         if (isstring (a) || isstring (b)) {
1193                 to_string (a);
1194                 to_string (b);
1195                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) <= 0));
1196         } else {
1197                 (void)to_number(a);
1198                 (void)to_number(b);
1199                 r = make_number ((FP___TYPE)(a->u.i <= b->u.i));
1200         }
1201
1202         free_value (a);
1203         free_value (b);
1204         return r;
1205 }
1206
1207 static struct val *
1208 op_cond (struct val *a, struct val *b, struct val *c)
1209 {
1210         struct val *r;
1211
1212         if( isstring(a) )
1213         {
1214                 if( strlen(a->u.s) && strcmp(a->u.s, "\"\"") != 0 && strcmp(a->u.s,"0") != 0 )
1215                 {
1216                         free_value(a);
1217                         free_value(c);
1218                         r = b;
1219                 }
1220                 else
1221                 {
1222                         free_value(a);
1223                         free_value(b);
1224                         r = c;
1225                 }
1226         }
1227         else
1228         {
1229                 (void)to_number(a);
1230                 if( a->u.i )
1231                 {
1232                         free_value(a);
1233                         free_value(c);
1234                         r = b;
1235                 }
1236                 else
1237                 {
1238                         free_value(a);
1239                         free_value(b);
1240                         r = c;
1241                 }
1242         }
1243         return r;
1244 }
1245
1246 static struct val *
1247 op_ne (struct val *a, struct val *b)
1248 {
1249         struct val *r;
1250
1251         if (isstring (a) || isstring (b)) {
1252                 to_string (a);
1253                 to_string (b);
1254                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) != 0));
1255         } else {
1256                 (void)to_number(a);
1257                 (void)to_number(b);
1258                 r = make_number ((FP___TYPE)(a->u.i != b->u.i));
1259         }
1260
1261         free_value (a);
1262         free_value (b);
1263         return r;
1264 }
1265
1266 static int
1267 chk_plus (FP___TYPE a, FP___TYPE b, FP___TYPE r)
1268 {
1269         /* sum of two positive numbers must be positive */
1270         if (a > 0 && b > 0 && r <= 0)
1271                 return 1;
1272         /* sum of two negative numbers must be negative */
1273         if (a < 0 && b < 0 && r >= 0)
1274                 return 1;
1275         /* all other cases are OK */
1276         return 0;
1277 }
1278
1279 static struct val *
1280 op_plus (struct val *a, struct val *b)
1281 {
1282         struct val *r;
1283
1284         if (!to_number (a)) {
1285                 if( !extra_error_message_supplied )
1286                         ast_log(LOG_WARNING,"non-numeric argument\n");
1287                 if (!to_number (b)) {
1288                         free_value(a);
1289                         free_value(b);
1290                         return make_number(0);
1291                 } else {
1292                         free_value(a);
1293                         return (b);
1294                 }
1295         } else if (!to_number(b)) {
1296                 free_value(b);
1297                 return (a);
1298         }
1299
1300         r = make_number (a->u.i + b->u.i);
1301         if (chk_plus (a->u.i, b->u.i, r->u.i)) {
1302                 ast_log(LOG_WARNING,"overflow\n");
1303         }
1304         free_value (a);
1305         free_value (b);
1306         return r;
1307 }
1308
1309 static int
1310 chk_minus (FP___TYPE a, FP___TYPE b, FP___TYPE r)
1311 {
1312         /* special case subtraction of QUAD_MIN */
1313         if (b == QUAD_MIN) {
1314                 if (a >= 0)
1315                         return 1;
1316                 else
1317                         return 0;
1318         }
1319         /* this is allowed for b != QUAD_MIN */
1320         return chk_plus (a, -b, r);
1321 }
1322
1323 static struct val *
1324 op_minus (struct val *a, struct val *b)
1325 {
1326         struct val *r;
1327
1328         if (!to_number (a)) {
1329                 if( !extra_error_message_supplied )
1330                         ast_log(LOG_WARNING, "non-numeric argument\n");
1331                 if (!to_number (b)) {
1332                         free_value(a);
1333                         free_value(b);
1334                         return make_number(0);
1335                 } else {
1336                         r = make_number(0 - b->u.i);
1337                         free_value(a);
1338                         free_value(b);
1339                         return (r);
1340                 }
1341         } else if (!to_number(b)) {
1342                 if( !extra_error_message_supplied )
1343                         ast_log(LOG_WARNING, "non-numeric argument\n");
1344                 free_value(b);
1345                 return (a);
1346         }
1347
1348         r = make_number (a->u.i - b->u.i);
1349         if (chk_minus (a->u.i, b->u.i, r->u.i)) {
1350                 ast_log(LOG_WARNING, "overflow\n");
1351         }
1352         free_value (a);
1353         free_value (b);
1354         return r;
1355 }
1356
1357 static struct val *
1358 op_negate (struct val *a)
1359 {
1360         struct val *r;
1361
1362         if (!to_number (a) ) {
1363                 free_value(a);
1364                 if( !extra_error_message_supplied )
1365                         ast_log(LOG_WARNING, "non-numeric argument\n");
1366                 return make_number(0);
1367         }
1368
1369         r = make_number (- a->u.i);
1370         if (chk_minus (0, a->u.i, r->u.i)) {
1371                 ast_log(LOG_WARNING, "overflow\n");
1372         }
1373         free_value (a);
1374         return r;
1375 }
1376
1377 static struct val *
1378 op_compl (struct val *a)
1379 {
1380         int v1 = 1;
1381         struct val *r;
1382
1383         if( !a )
1384         {
1385                 v1 = 0;
1386         }
1387         else
1388         {
1389                 switch( a->type )
1390                 {
1391                 case AST_EXPR_number:
1392                         if( a->u.i == 0 )
1393                                 v1 = 0;
1394                         break;
1395
1396                 case AST_EXPR_string:
1397                         if( a->u.s == 0 )
1398                                 v1 = 0;
1399                         else
1400                         {
1401                                 if( a->u.s[0] == 0 )
1402                                         v1 = 0;
1403                                 else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
1404                                         v1 = 0;
1405                         }
1406                         break;
1407
1408                 case AST_EXPR_numeric_string:
1409                         if( a->u.s == 0 )
1410                                 v1 = 0;
1411                         else
1412                         {
1413                                 if( a->u.s[0] == 0 )
1414                                         v1 = 0;
1415                                 else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
1416                                         v1 = 0;
1417                         }
1418                         break;
1419                 }
1420         }
1421
1422         r = make_number (!v1);
1423         free_value (a);
1424         return r;
1425 }
1426
1427 static int
1428 chk_times (FP___TYPE a, FP___TYPE b, FP___TYPE r)
1429 {
1430         /* special case: first operand is 0, no overflow possible */
1431         if (a == 0)
1432                 return 0;
1433         /* cerify that result of division matches second operand */
1434         if (r / a != b)
1435                 return 1;
1436         return 0;
1437 }
1438
1439 static struct val *
1440 op_times (struct val *a, struct val *b)
1441 {
1442         struct val *r;
1443
1444         if (!to_number (a) || !to_number (b)) {
1445                 free_value(a);
1446                 free_value(b);
1447                 if( !extra_error_message_supplied )
1448                         ast_log(LOG_WARNING, "non-numeric argument\n");
1449                 return(make_number(0));
1450         }
1451
1452         r = make_number (a->u.i * b->u.i);
1453         if (chk_times (a->u.i, b->u.i, r->u.i)) {
1454                 ast_log(LOG_WARNING, "overflow\n");
1455         }
1456         free_value (a);
1457         free_value (b);
1458         return (r);
1459 }
1460
1461 static int
1462 chk_div (FP___TYPE a, FP___TYPE b)
1463 {
1464         /* div by zero has been taken care of before */
1465         /* only QUAD_MIN / -1 causes overflow */
1466         if (a == QUAD_MIN && b == -1)
1467                 return 1;
1468         /* everything else is OK */
1469         return 0;
1470 }
1471
1472 static struct val *
1473 op_div (struct val *a, struct val *b)
1474 {
1475         struct val *r;
1476
1477         if (!to_number (a)) {
1478                 free_value(a);
1479                 free_value(b);
1480                 if( !extra_error_message_supplied )
1481                         ast_log(LOG_WARNING, "non-numeric argument\n");
1482                 return make_number(0);
1483         } else if (!to_number (b)) {
1484                 free_value(a);
1485                 free_value(b);
1486                 if( !extra_error_message_supplied )
1487                         ast_log(LOG_WARNING, "non-numeric argument\n");
1488                 return make_number(INT_MAX);
1489         }
1490
1491         if (b->u.i == 0) {
1492                 ast_log(LOG_WARNING, "division by zero\n");
1493                 free_value(a);
1494                 free_value(b);
1495                 return make_number(INT_MAX);
1496         }
1497
1498         r = make_number (a->u.i / b->u.i);
1499         if (chk_div (a->u.i, b->u.i)) {
1500                 ast_log(LOG_WARNING, "overflow\n");
1501         }
1502         free_value (a);
1503         free_value (b);
1504         return r;
1505 }
1506
1507 static struct val *
1508 op_rem (struct val *a, struct val *b)
1509 {
1510         struct val *r;
1511
1512         if (!to_number (a) || !to_number (b)) {
1513                 if( !extra_error_message_supplied )
1514                         ast_log(LOG_WARNING, "non-numeric argument\n");
1515                 free_value(a);
1516                 free_value(b);
1517                 return make_number(0);
1518         }
1519
1520         if (b->u.i == 0) {
1521                 ast_log(LOG_WARNING, "div by zero\n");
1522                 free_value(a);
1523                 return(b);
1524         }
1525
1526         r = make_number (FUNC_FMOD(a->u.i, b->u.i)); /* either fmod or fmodl if FP___TYPE is available */
1527         /* chk_rem necessary ??? */
1528         free_value (a);
1529         free_value (b);
1530         return r;
1531 }
1532
1533
1534 static struct val *
1535 op_colon (struct val *a, struct val *b)
1536 {
1537         regex_t rp;
1538         regmatch_t rm[2];
1539         char errbuf[256];
1540         int eval;
1541         struct val *v;
1542
1543         /* coerce to both arguments to strings */
1544         to_string(a);
1545         to_string(b);
1546         /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
1547         strip_quotes(a);
1548         strip_quotes(b);
1549         /* compile regular expression */
1550         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
1551                 regerror (eval, &rp, errbuf, sizeof(errbuf));
1552                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
1553                 free_value(a);
1554                 free_value(b);
1555                 return make_str("");
1556         }
1557
1558         /* compare string against pattern */
1559         /* remember that patterns are anchored to the beginning of the line */
1560         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 && rm[0].rm_so == 0) {
1561                 if (rm[1].rm_so >= 0) {
1562                         *(a->u.s + rm[1].rm_eo) = '\0';
1563                         v = make_str (a->u.s + rm[1].rm_so);
1564
1565                 } else {
1566                         v = make_number ((FP___TYPE)(rm[0].rm_eo - rm[0].rm_so));
1567                 }
1568         } else {
1569                 if (rp.re_nsub == 0) {
1570                         v = make_number ((FP___TYPE)0);
1571                 } else {
1572                         v = make_str ("");
1573                 }
1574         }
1575
1576         /* free arguments and pattern buffer */
1577         free_value (a);
1578         free_value (b);
1579         regfree (&rp);
1580
1581         return v;
1582 }
1583
1584
1585 static struct val *
1586 op_eqtilde (struct val *a, struct val *b)
1587 {
1588         regex_t rp;
1589         regmatch_t rm[2];
1590         char errbuf[256];
1591         int eval;
1592         struct val *v;
1593
1594         /* coerce to both arguments to strings */
1595         to_string(a);
1596         to_string(b);
1597         /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
1598         strip_quotes(a);
1599         strip_quotes(b);
1600         /* compile regular expression */
1601         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
1602                 regerror (eval, &rp, errbuf, sizeof(errbuf));
1603                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
1604                 free_value(a);
1605                 free_value(b);
1606                 return make_str("");
1607         }
1608
1609         /* compare string against pattern */
1610         /* remember that patterns are anchored to the beginning of the line */
1611         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 ) {
1612                 if (rm[1].rm_so >= 0) {
1613                         *(a->u.s + rm[1].rm_eo) = '\0';
1614                         v = make_str (a->u.s + rm[1].rm_so);
1615
1616                 } else {
1617                         v = make_number ((FP___TYPE)(rm[0].rm_eo - rm[0].rm_so));
1618                 }
1619         } else {
1620                 if (rp.re_nsub == 0) {
1621                         v = make_number ((FP___TYPE)0.0);
1622                 } else {
1623                         v = make_str ("");
1624                 }
1625         }
1626
1627         /* free arguments and pattern buffer */
1628         free_value (a);
1629         free_value (b);
1630         regfree (&rp);
1631
1632         return v;
1633 }
1634
1635 static struct val *  /* this is a string concat operator */
1636 op_tildetilde (struct val *a, struct val *b)
1637 {
1638         struct val *v;
1639         char *vs;
1640
1641         /* coerce to both arguments to strings */
1642         to_string(a);
1643         to_string(b);
1644         /* strip double quotes from both -- */
1645         strip_quotes(a);
1646         strip_quotes(b);
1647
1648         vs = malloc(strlen(a->u.s)+strlen(b->u.s)+1);
1649         strcpy(vs,a->u.s);
1650         strcat(vs,b->u.s);
1651
1652         v = make_str(vs);
1653
1654         /* free arguments */
1655         free_value(a);
1656         free_value(b);
1657
1658         return v;
1659 }