Fix chan_phone error code (bug #3692)
[asterisk/asterisk.git] / ast_expr.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  * $FreeBSD: src/bin/expr/expr.y,v 1.16 2000/07/22 10:59:36 se Exp $
8  */
9
10 #include <sys/types.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <locale.h>
15 #include <ctype.h>
16 #ifndef SOLARIS
17 #include <err.h>
18 #else
19 #define quad_t uint64_t
20 #endif
21 #include <errno.h>
22 #include <regex.h>
23 #include <limits.h>
24 #include <asterisk/ast_expr.h>
25 #include <asterisk/logger.h>
26
27 #ifdef LONG_LONG_MIN
28 #define QUAD_MIN LONG_LONG_MIN
29 #endif
30 #ifdef LONG_LONG_MAX
31 #define QUAD_MAX LONG_LONG_MAX
32 #endif
33
34 #  if ! defined(QUAD_MIN)
35 #   define QUAD_MIN     (-0x7fffffffffffffffL-1)
36 #  endif
37 #  if ! defined(QUAD_MAX)
38 #   define QUAD_MAX     (0x7fffffffffffffffL)
39 #  endif
40
41 #define YYPARSE_PARAM kota
42 #define YYLEX_PARAM kota
43
44 /* #define ast_log fprintf
45 #define LOG_WARNING stderr */
46
47 #ifdef SOLARIS
48 #define __P(p) p
49 #endif
50   
51 enum valtype {
52         integer, numeric_string, string
53 } ;
54
55 struct val {
56         enum valtype type;
57         union {
58                 char *s;
59                 quad_t i;
60         } u;
61 } ;
62
63 struct parser_control {
64         struct val *result;
65         int pipa;
66         char *arg_orig;
67         char *argv;
68         char *ptrptr;
69         int firsttoken;
70 } ;
71
72 static int              chk_div __P((quad_t, quad_t));
73 static int              chk_minus __P((quad_t, quad_t, quad_t));
74 static int              chk_plus __P((quad_t, quad_t, quad_t));
75 static int              chk_times __P((quad_t, quad_t, quad_t));
76 static void             free_value __P((struct val *));
77 static int              is_zero_or_null __P((struct val *));
78 static int              isstring __P((struct val *));
79 static struct val       *make_integer __P((quad_t));
80 static struct val       *make_str __P((const char *));
81 static struct val       *op_and __P((struct val *, struct val *));
82 static struct val       *op_colon __P((struct val *, struct val *));
83 static struct val       *op_div __P((struct val *, struct val *));
84 static struct val       *op_eq __P((struct val *, struct val *));
85 static struct val       *op_ge __P((struct val *, struct val *));
86 static struct val       *op_gt __P((struct val *, struct val *));
87 static struct val       *op_le __P((struct val *, struct val *));
88 static struct val       *op_lt __P((struct val *, struct val *));
89 static struct val       *op_minus __P((struct val *, struct val *));
90 static struct val       *op_ne __P((struct val *, struct val *));
91 static struct val       *op_or __P((struct val *, struct val *));
92 static struct val       *op_plus __P((struct val *, struct val *));
93 static struct val       *op_rem __P((struct val *, struct val *));
94 static struct val       *op_times __P((struct val *, struct val *));
95 static quad_t           to_integer __P((struct val *));
96 static void             to_string __P((struct val *));
97
98 /* uh, if I want to predeclare yylex with a YYLTYPE, I have to predeclare the yyltype... sigh */
99 typedef struct yyltype
100 {
101   int first_line;
102   int first_column;
103
104   int last_line;
105   int last_column;
106 } yyltype;
107
108 # define YYLTYPE yyltype
109 # define YYLTYPE_IS_TRIVIAL 1
110
111 static int              ast_yyerror __P((const char *,YYLTYPE *, struct parser_control *));
112
113 #define ast_yyerror(x) ast_yyerror(x,&yyloc,kota)
114
115 %}
116
117 %pure-parser
118 %locations
119 /* %debug  for when you are having big problems */
120
121 /* %name-prefix="ast_yy" */
122
123 %union
124 {
125         struct val *val;
126 }
127
128 %{
129 static int              ast_yylex __P((YYSTYPE *, YYLTYPE *, struct parser_control *));
130 %}
131
132
133 %left <val> '|'
134 %left <val> '&'
135 %left <val> '=' '>' '<' GE LE NE
136 %left <val> '+' '-'
137 %left <val> '*' '/' '%'
138 %left <val> ':'
139
140 %token <val> TOKEN
141 %type <val> start expr
142
143 %%
144
145 start: expr { ((struct parser_control *)kota)->result = $$; }
146         ;
147
148 expr:   TOKEN
149         | '(' expr ')' { $$ = $2; @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
150         | expr '|' expr { $$ = op_or ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
151         | expr '&' expr { $$ = op_and ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
152         | expr '=' expr { $$ = op_eq ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
153         | expr '>' expr { $$ = op_gt ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
154         | expr '<' expr { $$ = op_lt ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
155         | expr GE expr  { $$ = op_ge ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
156         | expr LE expr  { $$ = op_le ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
157         | expr NE expr  { $$ = op_ne ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
158         | expr '+' expr { $$ = op_plus ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
159         | expr '-' expr { $$ = op_minus ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
160         | expr '*' expr { $$ = op_times ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
161         | expr '/' expr { $$ = op_div ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
162         | expr '%' expr { $$ = op_rem ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
163         | expr ':' expr { $$ = op_colon ($1, $3); @$.first_column = @1.first_column; @$.last_column = @3.last_column; @$.first_line=0; @$.last_line=0;}
164         ;
165
166
167 %%
168
169 static struct val *
170 make_integer (i)
171 quad_t i;
172 {
173         struct val *vp;
174
175         vp = (struct val *) malloc (sizeof (*vp));
176         if (vp == NULL) {
177                 ast_log(LOG_WARNING, "malloc() failed\n");
178                 return(NULL);
179         }
180
181         vp->type = integer;
182         vp->u.i  = i;
183         return vp; 
184 }
185
186 static struct val *
187 make_str (s)
188 const char *s;
189 {
190         struct val *vp;
191         size_t i;
192         int isint;
193
194         vp = (struct val *) malloc (sizeof (*vp));
195         if (vp == NULL || ((vp->u.s = strdup (s)) == NULL)) {
196                 ast_log(LOG_WARNING,"malloc() failed\n");
197                 return(NULL);
198         }
199
200         for(i = 1, isint = isdigit(s[0]) || s[0] == '-';
201             isint && i < strlen(s);
202             i++)
203         {
204                 if(!isdigit(s[i]))
205                          isint = 0;
206         }
207
208         if (isint)
209                 vp->type = numeric_string;
210         else    
211                 vp->type = string;
212
213         return vp;
214 }
215
216
217 static void
218 free_value (vp)
219 struct val *vp;
220 {       
221         if (vp==NULL) {
222                 return;
223         }
224         if (vp->type == string || vp->type == numeric_string)
225                 free (vp->u.s); 
226         free (vp);
227 }
228
229
230 static quad_t
231 to_integer (vp)
232 struct val *vp;
233 {
234         quad_t i;
235
236         if (vp == NULL) {
237                 ast_log(LOG_WARNING,"vp==NULL in to_integer()\n");
238                 return(0);
239         }
240
241         if (vp->type == integer)
242                 return 1;
243
244         if (vp->type == string)
245                 return 0;
246
247         /* vp->type == numeric_string, make it numeric */
248         errno = 0;
249         i  = strtoq(vp->u.s, (char**)NULL, 10);
250         if (errno != 0) {
251                 free(vp->u.s);
252                 ast_log(LOG_WARNING,"overflow\n");
253                 return(0);
254         }
255         free (vp->u.s);
256         vp->u.i = i;
257         vp->type = integer;
258         return 1;
259 }
260
261 static void
262 to_string (vp)
263 struct val *vp;
264 {
265         char *tmp;
266
267         if (vp->type == string || vp->type == numeric_string)
268                 return;
269
270         tmp = malloc ((size_t)25);
271         if (tmp == NULL) {
272                 ast_log(LOG_WARNING,"malloc() failed\n");
273                 return;
274         }
275
276         sprintf (tmp, "%lld", (long long)vp->u.i);
277         vp->type = string;
278         vp->u.s  = tmp;
279 }
280
281
282 static int
283 isstring (vp)
284 struct val *vp;
285 {
286         /* only TRUE if this string is not a valid integer */
287         return (vp->type == string);
288 }
289
290 static int
291 ast_yylex (YYSTYPE *lvalp, YYLTYPE *yylloc, struct parser_control *karoto)
292 {
293         char *p=0;
294         char *t1=0;
295         char savep = 0;
296         char *savepp = 0;
297         
298         if (karoto->firsttoken==1) {
299                 t1 = karoto->argv;
300                 karoto->firsttoken = 0;
301         } else {
302                 t1 = karoto->ptrptr;
303         }
304         
305         while(*t1 && *t1 == ' ' )  /* we can remove worries about leading/multiple spaces being present */
306                 t1++;
307         karoto->ptrptr = t1;
308         yylloc->first_column = t1 - karoto->argv;
309         
310         while( *t1 && *t1 != ' ' && *t1 != '"') /* find the next space or quote */
311                 t1++;
312         if( *t1 == ' ' )
313         {
314                 *t1 = 0;
315                 p = karoto->ptrptr;
316                 karoto->ptrptr = t1+1;
317                 yylloc->last_column = t1 - karoto->argv;
318         }
319         else if (*t1 == '"' )
320         {
321                 /* opening quote. find the closing quote */
322                 char *t2=t1+1;
323                 while( *t2 && *t2 != '"')
324                         t2++;
325                 if( *t2 == '"' )
326                 {
327                         if( *(t2+1) == ' ' || *(t2+1) == 0 )
328                         {
329                                 if( *(t2+1) )
330                                 {
331                                         *(t2+1) = 0;
332                                         karoto->ptrptr = t2+2;
333                                 }
334                                 else
335                                 {
336                                         karoto->ptrptr = t2+1;
337                                 }
338                         }
339                         else
340                         {
341                                 /* hmmm. what if another token is here? */
342                                 /* maybe we can insert a space? */
343                                 savep = *(t2+1);
344                                 savepp = t2+1;
345                                 *(t2+1) = 0;
346                                 karoto->ptrptr = t2+1;
347                         }
348                         p = t1;
349                 }
350                 else
351                 {
352                         /* NOT GOOD -- no closing quote! */
353                         p = t1;
354                         karoto->ptrptr = t2;
355                 }
356                 yylloc->last_column = t2 - karoto->argv;
357         }
358         else if( *t1 == 0 )
359         {
360                 if( t1 != karoto->ptrptr )
361                 {
362                         /* this is the last token */
363                         p = karoto->ptrptr;
364                         karoto->ptrptr = t1;
365                 }
366                 else
367                 {
368                         /* we are done. That was quick */
369                         p = karoto->ptrptr;
370                         yylloc->last_column = t1 - karoto->argv;
371                 }
372         }
373         if( *p == 0 )
374                 p = 0;
375         
376         if (p==NULL) {
377                 return (0);
378         }
379
380
381         if (strlen (p) == 1) {
382                 if (strchr ("|&=<>+-*/%:()", *p))
383                         return (*p);
384         } else if (strlen (p) == 2 && p[1] == '=') {
385                 switch (*p) {
386                 case '>': return (GE);
387                 case '<': return (LE);
388                 case '!': return (NE);
389                 }
390         }
391
392         lvalp->val = make_str (p);
393         if( savep )
394         {
395                 *savepp = savep; /* restore the null terminated string */
396                 savepp = 0;
397                 savep = 0;
398         }
399         return (TOKEN);
400 }
401
402 static int
403 is_zero_or_null (vp)
404 struct val *vp;
405 {
406         if (vp->type == integer) {
407                 return (vp->u.i == 0);
408         } else {
409                 return (*vp->u.s == 0 || (to_integer (vp) && vp->u.i == 0));
410         }
411         /* NOTREACHED */
412 }
413
414 char *ast_expr (char *arg)
415 {
416         struct parser_control karoto;
417
418         char *kota;
419         char *pirouni;
420         
421         kota=strdup(arg);
422         karoto.result = NULL;
423         karoto.firsttoken=1;
424         karoto.argv=kota;
425         karoto.arg_orig = arg;
426         /* ast_yydebug = 1; */
427         
428         ast_yyparse ((void *)&karoto);
429
430         free(kota);
431
432         if (karoto.result==NULL) {
433                 pirouni=strdup("0");
434                 return(pirouni);
435         } else {
436                 if (karoto.result->type == integer) {
437                         pirouni=malloc(256);
438                         sprintf (pirouni,"%lld", (long long)karoto.result->u.i);
439                 }
440                 else {
441                         pirouni=strdup(karoto.result->u.s);
442                 }
443                 free(karoto.result);
444         }
445         return(pirouni);
446 }
447
448 #ifdef STANDALONE
449
450 int main(int argc,char **argv) {
451         char *s;
452
453         s=ast_expr(argv[1]);
454
455         printf("=====%s======\n",s);
456 }
457
458 #endif
459
460 #undef ast_yyerror
461 #define ast_yyerror(x) ast_yyerror(x, YYLTYPE *yylloc, struct parser_control *karoto)
462
463 static int
464 ast_yyerror (const char *s)
465 {       
466         char spacebuf[8000]; /* best safe than sorry */
467         char spacebuf2[8000]; /* best safe than sorry */
468         int i=0;
469         spacebuf[0] = 0;
470         
471         if( yylloc->first_column > 7990 ) /* if things get out of whack, why crash? */
472                 yylloc->first_column = 7990;
473         if( yylloc->last_column > 7990 )
474                 yylloc->last_column = 7990;
475         for(i=0;i<yylloc->first_column;i++) spacebuf[i] = ' ';
476         for(   ;i<yylloc->last_column;i++) spacebuf[i] = '^';
477         spacebuf[i] = 0;
478
479         for(i=0;i<karoto->ptrptr-karoto->argv;i++) spacebuf2[i] = ' ';
480         spacebuf2[i++]='^';
481         spacebuf2[i]= 0;
482
483         ast_log(LOG_WARNING,"ast_yyerror(): syntax error: %s; Input:\n%s\n%s\n%s\n",s, 
484                         karoto->arg_orig,spacebuf,spacebuf2);
485         return(0);
486 }
487
488
489 static struct val *
490 op_or (a, b)
491 struct val *a, *b;
492 {
493         if (is_zero_or_null (a)) {
494                 free_value (a);
495                 return (b);
496         } else {
497                 free_value (b);
498                 return (a);
499         }
500 }
501                 
502 static struct val *
503 op_and (a, b)
504 struct val *a, *b;
505 {
506         if (is_zero_or_null (a) || is_zero_or_null (b)) {
507                 free_value (a);
508                 free_value (b);
509                 return (make_integer ((quad_t)0));
510         } else {
511                 free_value (b);
512                 return (a);
513         }
514 }
515
516 static struct val *
517 op_eq (a, b)
518 struct val *a, *b;
519 {
520         struct val *r; 
521
522         if (isstring (a) || isstring (b)) {
523                 to_string (a);
524                 to_string (b);  
525                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) == 0));
526         } else {
527                 (void)to_integer(a);
528                 (void)to_integer(b);
529                 r = make_integer ((quad_t)(a->u.i == b->u.i));
530         }
531
532         free_value (a);
533         free_value (b);
534         return r;
535 }
536
537 static struct val *
538 op_gt (a, b)
539 struct val *a, *b;
540 {
541         struct val *r;
542
543         if (isstring (a) || isstring (b)) {
544                 to_string (a);
545                 to_string (b);
546                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) > 0));
547         } else {
548                 (void)to_integer(a);
549                 (void)to_integer(b);
550                 r = make_integer ((quad_t)(a->u.i > b->u.i));
551         }
552
553         free_value (a);
554         free_value (b);
555         return r;
556 }
557
558 static struct val *
559 op_lt (a, b)
560 struct val *a, *b;
561 {
562         struct val *r;
563
564         if (isstring (a) || isstring (b)) {
565                 to_string (a);
566                 to_string (b);
567                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) < 0));
568         } else {
569                 (void)to_integer(a);
570                 (void)to_integer(b);
571                 r = make_integer ((quad_t)(a->u.i < b->u.i));
572         }
573
574         free_value (a);
575         free_value (b);
576         return r;
577 }
578
579 static struct val *
580 op_ge (a, b)
581 struct val *a, *b;
582 {
583         struct val *r;
584
585         if (isstring (a) || isstring (b)) {
586                 to_string (a);
587                 to_string (b);
588                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) >= 0));
589         } else {
590                 (void)to_integer(a);
591                 (void)to_integer(b);
592                 r = make_integer ((quad_t)(a->u.i >= b->u.i));
593         }
594
595         free_value (a);
596         free_value (b);
597         return r;
598 }
599
600 static struct val *
601 op_le (a, b)
602 struct val *a, *b;
603 {
604         struct val *r;
605
606         if (isstring (a) || isstring (b)) {
607                 to_string (a);
608                 to_string (b);
609                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) <= 0));
610         } else {
611                 (void)to_integer(a);
612                 (void)to_integer(b);
613                 r = make_integer ((quad_t)(a->u.i <= b->u.i));
614         }
615
616         free_value (a);
617         free_value (b);
618         return r;
619 }
620
621 static struct val *
622 op_ne (a, b)
623 struct val *a, *b;
624 {
625         struct val *r;
626
627         if (isstring (a) || isstring (b)) {
628                 to_string (a);
629                 to_string (b);
630                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) != 0));
631         } else {
632                 (void)to_integer(a);
633                 (void)to_integer(b);
634                 r = make_integer ((quad_t)(a->u.i != b->u.i));
635         }
636
637         free_value (a);
638         free_value (b);
639         return r;
640 }
641
642 static int
643 chk_plus (a, b, r)
644 quad_t a, b, r;
645 {
646         /* sum of two positive numbers must be positive */
647         if (a > 0 && b > 0 && r <= 0)
648                 return 1;
649         /* sum of two negative numbers must be negative */
650         if (a < 0 && b < 0 && r >= 0)
651                 return 1;
652         /* all other cases are OK */
653         return 0;
654 }
655
656 static struct val *
657 op_plus (a, b)
658 struct val *a, *b;
659 {
660         struct val *r;
661
662         if (!to_integer (a)) {
663                 ast_log(LOG_WARNING,"non-numeric argument\n");
664                 if (!to_integer (b)) {
665                         free_value(a);
666                         free_value(b);
667                         return make_integer(0);
668                 } else {
669                         free_value(a);
670                         return (b);
671                 }
672         } else if (!to_integer(b)) {
673                 free_value(b);
674                 return (a);
675         }
676
677         r = make_integer (/*(quad_t)*/(a->u.i + b->u.i));
678         if (chk_plus (a->u.i, b->u.i, r->u.i)) {
679                 ast_log(LOG_WARNING,"overflow\n");
680         }
681         free_value (a);
682         free_value (b);
683         return r;
684 }
685
686 static int
687 chk_minus (a, b, r)
688 quad_t a, b, r;
689 {
690         /* special case subtraction of QUAD_MIN */
691         if (b == QUAD_MIN) {
692                 if (a >= 0)
693                         return 1;
694                 else
695                         return 0;
696         }
697         /* this is allowed for b != QUAD_MIN */
698         return chk_plus (a, -b, r);
699 }
700
701 static struct val *
702 op_minus (a, b)
703 struct val *a, *b;
704 {
705         struct val *r;
706
707         if (!to_integer (a)) {
708                 ast_log(LOG_WARNING, "non-numeric argument\n");
709                 if (!to_integer (b)) {
710                         free_value(a);
711                         free_value(b);
712                         return make_integer(0);
713                 } else {
714                         r = make_integer(0 - b->u.i);
715                         free_value(a);
716                         free_value(b);
717                         return (r);
718                 }
719         } else if (!to_integer(b)) {
720                 ast_log(LOG_WARNING, "non-numeric argument\n");
721                 free_value(b);
722                 return (a);
723         }
724
725         r = make_integer (/*(quad_t)*/(a->u.i - b->u.i));
726         if (chk_minus (a->u.i, b->u.i, r->u.i)) {
727                 ast_log(LOG_WARNING, "overflow\n");
728         }
729         free_value (a);
730         free_value (b);
731         return r;
732 }
733
734 static int
735 chk_times (a, b, r)
736 quad_t a, b, r;
737 {
738         /* special case: first operand is 0, no overflow possible */
739         if (a == 0)
740                 return 0;
741         /* cerify that result of division matches second operand */
742         if (r / a != b)
743                 return 1;
744         return 0;
745 }
746
747 static struct val *
748 op_times (a, b)
749 struct val *a, *b;
750 {
751         struct val *r;
752
753         if (!to_integer (a) || !to_integer (b)) {
754                 free_value(a);
755                 free_value(b);
756                 ast_log(LOG_WARNING, "non-numeric argument\n");
757                 return(make_integer(0));
758         }
759
760         r = make_integer (/*(quad_t)*/(a->u.i * b->u.i));
761         if (chk_times (a->u.i, b->u.i, r->u.i)) {
762                 ast_log(LOG_WARNING, "overflow\n");
763         }
764         free_value (a);
765         free_value (b);
766         return (r);
767 }
768
769 static int
770 chk_div (a, b)
771 quad_t a, b;
772 {
773         /* div by zero has been taken care of before */
774         /* only QUAD_MIN / -1 causes overflow */
775         if (a == QUAD_MIN && b == -1)
776                 return 1;
777         /* everything else is OK */
778         return 0;
779 }
780
781 static struct val *
782 op_div (a, b)
783 struct val *a, *b;
784 {
785         struct val *r;
786
787         if (!to_integer (a)) {
788                 free_value(a);
789                 free_value(b);
790                 ast_log(LOG_WARNING, "non-numeric argument\n");
791                 return make_integer(0);
792         } else if (!to_integer (b)) {
793                 free_value(a);
794                 free_value(b);
795                 ast_log(LOG_WARNING, "non-numeric argument\n");
796                 return make_integer(INT_MAX);
797         }
798
799         if (b->u.i == 0) {
800                 ast_log(LOG_WARNING, "division by zero\n");             
801                 free_value(a);
802                 free_value(b);
803                 return make_integer(INT_MAX);
804         }
805
806         r = make_integer (/*(quad_t)*/(a->u.i / b->u.i));
807         if (chk_div (a->u.i, b->u.i)) {
808                 ast_log(LOG_WARNING, "overflow\n");
809         }
810         free_value (a);
811         free_value (b);
812         return r;
813 }
814         
815 static struct val *
816 op_rem (a, b)
817 struct val *a, *b;
818 {
819         struct val *r;
820
821         if (!to_integer (a) || !to_integer (b)) {
822                 ast_log(LOG_WARNING, "non-numeric argument\n");
823                 free_value(a);
824                 free_value(b);
825                 return make_integer(0);
826         }
827
828         if (b->u.i == 0) {
829                 ast_log(LOG_WARNING, "div by zero\n");
830                 free_value(a);
831                 return (b);
832         }
833
834         r = make_integer (/*(quad_t)*/(a->u.i % b->u.i));
835         /* chk_rem necessary ??? */
836         free_value (a);
837         free_value (b);
838         return r;
839 }
840         
841 static struct val *
842 op_colon (a, b)
843 struct val *a, *b;
844 {
845         regex_t rp;
846         regmatch_t rm[2];
847         char errbuf[256];
848         int eval;
849         struct val *v;
850
851         /* coerce to both arguments to strings */
852         to_string(a);
853         to_string(b);
854
855         /* compile regular expression */
856         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
857                 regerror (eval, &rp, errbuf, sizeof(errbuf));
858                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
859                 free_value(a);
860                 free_value(b);
861                 return make_str("");            
862         }
863
864         /* compare string against pattern */
865         /* remember that patterns are anchored to the beginning of the line */
866         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 && rm[0].rm_so == 0) {
867                 if (rm[1].rm_so >= 0) {
868                         *(a->u.s + rm[1].rm_eo) = '\0';
869                         v = make_str (a->u.s + rm[1].rm_so);
870
871                 } else {
872                         v = make_integer ((quad_t)(rm[0].rm_eo - rm[0].rm_so));
873                 }
874         } else {
875                 if (rp.re_nsub == 0) {
876                         v = make_integer ((quad_t)0);
877                 } else {
878                         v = make_str ("");
879                 }
880         }
881
882         /* free arguments and pattern buffer */
883         free_value (a);
884         free_value (b);
885         regfree (&rp);
886
887         return v;
888 }