add MATH() dialplan function (bug #4473, with mods)
authorKevin P. Fleming <kpfleming@digium.com>
Thu, 9 Jun 2005 22:59:08 +0000 (22:59 +0000)
committerKevin P. Fleming <kpfleming@digium.com>
Thu, 9 Jun 2005 22:59:08 +0000 (22:59 +0000)
deprecate the Math() application

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@5895 65c4cc65-6c06-0410-ace0-fbb531ad65f3

apps/app_math.c
doc/README.math
funcs/Makefile
funcs/func_math.c [new file with mode: 0755]

index fad0ad7..f9e26e6 100755 (executable)
@@ -80,6 +80,12 @@ static int math_exec(struct ast_channel *chan, void *data)
        float ftmp = 0;
        char *op;
        int iaction=-1;
+       static int deprecation_warning = 0;
+
+       if (!deprecation_warning) {
+               ast_log(LOG_WARNING, "Math() is deprecated, please use Set(var=${MATH(...)} instead.\n");
+               deprecation_warning = 1;
+       }
 
        /* dunno, big calulations :D */
        char user_result[30];
index 95f041c..7718f9e 100755 (executable)
@@ -1,19 +1,28 @@
 
-Mathematical functions application
+Mathematical dialplan function
 
 Yeah, I thought it was a little insane too.. 
 
 adds:
 
-Sum, Multiply, Divide, Subtract, Modulus, GT, LT, GTE, LTE, EQ functions to asterisk
+Sum, Multiply, Divide, Subtract, Modulus, GT, LT, GTE, LTE, EQ functions to Asterisk
 
 All functions follow the same basic pattern for parameters:
 
-parameter 1 = the name of the return variable
-parameter 2 = the operation
-parameter 3 = the second number
+parameter 1 = the math expression
+parameter 2 = the type of result
 
-Each action is perfromed as
+Perform calculation on number 1 to number 2. Valid ops are:
+    +,-,/,*,%,<,>,>=,<=,==
+and behave as their C equivalents.
+
+<type_of_result> - wanted type of result:
+       f, float - float(default)
+       i, int - integer,
+       h, hex - hex,
+       c, char - char
+
+Each math expression is performed as
 
  Action param1 on param2
 
@@ -30,31 +39,31 @@ Results in
 
 Example dialplan:
 
-exten => 11099,1,Math(RV,1+20)
-exten => 11099,2,NOOP(${RV})
-exten => 11099,3,Math(RV,10*2)
-exten => 11099,4,NOOP(${RV})
-exten => 11099,5,Math(RV,10*2)
-exten => 11099,6,NOOP(${RV})
-exten => 11099,7,Math(RV,10-2)
-exten => 11099,8,NOOP(${RV})
-exten => 11099,9,Math(RV,2%10)
-exten => 11099,10,NOOP(${RV})
-exten => 11099,11,Math(RV,10/0)
-exten => 11099,12,NOOP(${RV})
-exten => 11099,13,math(RV,10-200)
-exten => 11099,14,NOOP(${RV})
-exten => 11099,15,Math(RV,1-20)
-exten => 11099,16,NOOP(${RV})
-exten => 11099,17,Math(RV,1<20)
-exten => 11099,18,NOOP(${RV})
-exten => 11099,19,Math(RV,1>=20)
-exten => 11099,20,NOOP(${RV})
-exten => 11099,21,Math(RV,101>20)
-exten => 11099,22,NOOP(${RV})
-exten => 11099,23,Math(RV,1==20)
-exten => 11099,24,NOOP(${RV})
-exten => 11099,25,Math(RV,20<=20)
-exten => 11099,26,NOOP(${RV})
-
-
+exten => 11099,1,Set(RV=${MATH(1+20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(10*2)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(10*2)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(10-2)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(2%10)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(10/0)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(10-200)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(1-20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(1<20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(1>=20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(101>20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(1==20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(20<=20)})
+exten => 11099,n,NOOP(${RV})
+exten => 11099,n,Set(RV=${MATH(123%16,int)})
+exten => 11099,n,NOOP(${RV})
index fa240fd..1bee2ae 100755 (executable)
@@ -14,6 +14,7 @@
 FUNCS=pbx_functions.so
 
 BUILTINS=func_md5.o \
+         func_math.o \
          func_groupcount.o \
          func_strings.o \
          func_cdr.o \
diff --git a/funcs/func_math.c b/funcs/func_math.c
new file mode 100755 (executable)
index 0000000..9a6a6ea
--- /dev/null
@@ -0,0 +1,237 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * Maths relatad dialplan functions
+ * 
+ * Copyright (C) 2004 - 2005, Andy Powell 
+ *
+ * Updated by Mark Spencer <markster@digium.com>
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include "asterisk.h"
+
+/* ASTERISK_FILE_VERSION(__FILE__, "$Revision$") */
+
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/logger.h"
+#include "asterisk/utils.h"
+#include "asterisk/app.h"
+#include "asterisk/config.h"
+
+enum TypeOfFunctions
+{
+    ADDFUNCTION,
+    DIVIDEFUNCTION,
+    MULTIPLYFUNCTION,
+    SUBTRACTFUNCTION,
+    MODULUSFUNCTION,
+
+    GTFUNCTION,
+    LTFUNCTION,
+    GTEFUNCTION,
+    LTEFUNCTION,
+    EQFUNCTION
+};
+
+enum TypeOfResult
+{
+    FLOAT_RESULT,
+    INT_RESULT,
+    HEX_RESULT,
+    CHAR_RESULT
+};
+
+
+static char *builtin_function_math(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
+{
+       int argc;
+       char *argv[2];
+       char *args;
+       float fnum1;
+       float fnum2;
+       float ftmp = 0;
+       char *op;
+       int iaction=-1;
+       int type_of_result=FLOAT_RESULT;
+
+       /* dunno, big calulations :D */
+       char user_result[30];
+
+       char *mvalue1, *mvalue2=NULL, *mtype_of_result;
+               
+       if (!data || ast_strlen_zero(data)) {
+               ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
+               return NULL;
+       }
+
+       args = ast_strdupa(data);       
+       argc = ast_separate_app_args(args, '|', argv, sizeof(argv) / sizeof(argv[0]));
+
+       if (argc < 1) {
+               ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
+               return NULL;
+       }
+
+       mvalue1 = argv[0];
+       
+       if ((op = strchr(mvalue1, '+'))) {
+               iaction = ADDFUNCTION;
+               *op = '\0';
+       } else if ((op = strchr(mvalue1, '-'))) {
+               iaction = SUBTRACTFUNCTION;
+               *op = '\0';
+       } else if ((op = strchr(mvalue1, '*'))) {
+               iaction = MULTIPLYFUNCTION;
+               *op = '\0';
+       } else if ((op = strchr(mvalue1, '/'))) {
+               iaction = DIVIDEFUNCTION;
+               *op = '\0';
+       } else if ((op = strchr(mvalue1, '%'))) {
+               iaction = MODULUSFUNCTION;
+               *op = '\0';
+       } else if ((op = strchr(mvalue1, '>'))) {
+               iaction = GTFUNCTION;
+               *op = '\0';
+               if (*(op+1) == '=') {
+                       *++op = '\0';
+                       iaction = GTEFUNCTION;
+               }
+       } else if ((op = strchr(mvalue1, '<'))) {
+               iaction = LTFUNCTION;
+               *op = '\0';
+               if (*(op+1) == '=') {
+                       *++op = '\0';
+                       iaction = LTEFUNCTION;
+               }
+       } else if ((op = strchr(mvalue1, '='))) {
+               iaction = GTFUNCTION;
+               *op = '\0';
+               if (*(op+1) == '=') {
+                       *++op = '\0';
+                       iaction = EQFUNCTION;
+               } else
+                       op = NULL;
+       } 
+       
+       if (op) 
+               mvalue2 = op + 1;
+
+       /* detect wanted type of result */
+       mtype_of_result = argv[1];
+       if (mtype_of_result)
+       {
+               if (!strcasecmp(mtype_of_result,"float") || !strcasecmp(mtype_of_result,"f"))
+                       type_of_result=FLOAT_RESULT;
+               else if (!strcasecmp(mtype_of_result,"int") || !strcasecmp(mtype_of_result,"i"))
+                       type_of_result=INT_RESULT;
+               else if (!strcasecmp(mtype_of_result,"hex") || !strcasecmp(mtype_of_result,"h"))
+                       type_of_result=HEX_RESULT;
+               else if (!strcasecmp(mtype_of_result,"char") || !strcasecmp(mtype_of_result,"c"))
+                       type_of_result=CHAR_RESULT;
+               else
+               {
+                       ast_log(LOG_WARNING, "Unknown type of result requested '%s'.\n", mtype_of_result);
+                       return NULL;
+               }
+       }
+       
+       if (!mvalue1 || !mvalue2) {
+               ast_log(LOG_WARNING, "Supply all the parameters - just this once, please\n");
+               return NULL;
+       }
+
+       if (sscanf(mvalue1, "%f", &fnum1) != 1) {
+               ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue1);
+               return NULL;
+       }
+
+       if (sscanf(mvalue2, "%f", &fnum2) != 1) {
+               ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue2);
+               return NULL;
+       }
+
+       switch (iaction) {
+       case ADDFUNCTION :
+               ftmp = fnum1 + fnum2;
+               break;
+       case DIVIDEFUNCTION :
+               if (fnum2 <= 0)
+                       ftmp = 0; /* can't do a divide by 0 */
+               else
+                       ftmp = (fnum1 / fnum2);
+               break;
+       case MULTIPLYFUNCTION :
+               ftmp = (fnum1 * fnum2);
+               break;
+       case SUBTRACTFUNCTION :
+               ftmp = (fnum1 - fnum2);
+               break;
+       case MODULUSFUNCTION :
+       {
+               int inum1 = fnum1;
+               int inum2 = fnum2;
+                       
+               ftmp = (inum1 % inum2);
+               
+               break;
+       }
+       case GTFUNCTION :
+               ast_copy_string (user_result, (fnum1 > fnum2)?"TRUE":"FALSE", sizeof (user_result));
+               break;
+       case LTFUNCTION :
+               ast_copy_string (user_result, (fnum1 < fnum2)?"TRUE":"FALSE", sizeof (user_result));
+               break;
+       case GTEFUNCTION :
+               ast_copy_string (user_result, (fnum1 >= fnum2)?"TRUE":"FALSE", sizeof (user_result));
+               break;
+       case LTEFUNCTION :
+               ast_copy_string (user_result, (fnum1 <= fnum2)?"TRUE":"FALSE", sizeof (user_result));
+               break;                                  
+       case EQFUNCTION :
+               ast_copy_string (user_result, (fnum1 == fnum2)?"TRUE":"FALSE", sizeof (user_result));
+               break;
+       default :
+               ast_log(LOG_WARNING, "Something happened that neither of us should be proud of %d\n", iaction);
+               return NULL;
+       }
+
+       if (iaction < GTFUNCTION || iaction > EQFUNCTION) {
+           if (type_of_result == FLOAT_RESULT)
+                   snprintf(user_result, sizeof(user_result), "%f", ftmp);
+           else if (type_of_result == INT_RESULT)
+                   snprintf(user_result, sizeof(user_result), "%i", (int) ftmp);
+           else if (type_of_result == HEX_RESULT)
+               snprintf(user_result, sizeof(user_result), "%x", (unsigned int) ftmp);
+           else if (type_of_result == CHAR_RESULT)
+               snprintf(user_result, sizeof(user_result), "%c", (unsigned char) ftmp);
+       }
+               
+       ast_copy_string(buf, user_result, len);
+       
+       return buf;
+}
+
+#ifndef BUILTIN_FUNC
+static
+#endif /* BUILTIN_FUNC */
+struct ast_custom_function math_function = {
+       .name = "MATH",
+       .synopsis = "Performs Mathematical Functions",
+       .syntax = "MATH(<number1><op><number 2>[,<type_of_result>])",
+       .desc = "Perform calculation on number 1 to number 2. Valid ops are: \n"
+           "    +,-,/,*,%,<,>,>=,<=,==\n"
+               "and behave as their C equivalents.\n"
+               "<type_of_result> - wanted type of result:\n"
+               "       f, float - float(default)\n"
+               "       i, int - integer,\n"
+               "       h, hex - hex,\n"
+               "       c, char - char\n"
+               "Example: Set(i=${MATH(123%16,int)}) - sets var i=11",
+       .read = builtin_function_math
+};