finish const-ifying ast_func_read()
[asterisk/asterisk.git] / funcs / func_math.c
old mode 100755 (executable)
new mode 100644 (file)
index e53eb40..4dbfac8
@@ -1,7 +1,7 @@
 /*
  * Asterisk -- An open source telephony toolkit.
  *
- * Copyright (C) 2004 - 2005, Andy Powell 
+ * Copyright (C) 2004 - 2006, Andy Powell 
  *
  * Updated by Mark Spencer <markster@digium.com>
  *
 
 /*! \file
  *
- * \brief Maths relatad dialplan functions
- * 
+ * \brief Math related dialplan function
+ *
+ * \author Andy Powell
+ * \author Mark Spencer <markster@digium.com>
  */
 
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
+#include <math.h>
 #include <sys/types.h>
 
-#include "asterisk.h"
-
-/* ASTERISK_FILE_VERSION(__FILE__, "$Revision$") */
-
+#include "asterisk/module.h"
 #include "asterisk/channel.h"
 #include "asterisk/pbx.h"
 #include "asterisk/logger.h"
 #include "asterisk/app.h"
 #include "asterisk/config.h"
 
-enum TypeOfFunctions
-{
-    ADDFUNCTION,
-    DIVIDEFUNCTION,
-    MULTIPLYFUNCTION,
-    SUBTRACTFUNCTION,
-    MODULUSFUNCTION,
-
-    GTFUNCTION,
-    LTFUNCTION,
-    GTEFUNCTION,
-    LTEFUNCTION,
-    EQFUNCTION
+enum TypeOfFunctions {
+       ADDFUNCTION,
+       DIVIDEFUNCTION,
+       MULTIPLYFUNCTION,
+       SUBTRACTFUNCTION,
+       MODULUSFUNCTION,
+       POWFUNCTION,
+       SHLEFTFUNCTION,
+       SHRIGHTFUNCTION,
+       GTFUNCTION,
+       LTFUNCTION,
+       GTEFUNCTION,
+       LTEFUNCTION,
+       EQFUNCTION
 };
 
-enum TypeOfResult
-{
-    FLOAT_RESULT,
-    INT_RESULT,
-    HEX_RESULT,
-    CHAR_RESULT
+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) 
+static int math(struct ast_channel *chan, const char *cmd, char *parse,
+               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];
+       int iaction = -1;
+       int type_of_result = FLOAT_RESULT;
+       char *mvalue1, *mvalue2 = NULL, *mtype_of_result;
+       AST_DECLARE_APP_ARGS(args,
+                            AST_APP_ARG(argv0);
+                            AST_APP_ARG(argv1);
+       );
 
-       char *mvalue1, *mvalue2=NULL, *mtype_of_result;
-               
-       if (ast_strlen_zero(data)) {
+       if (ast_strlen_zero(parse)) {
                ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
-               return NULL;
+               return -1;
        }
 
-       args = ast_strdupa(data);       
-       argc = ast_app_separate_args(args, '|', argv, sizeof(argv) / sizeof(argv[0]));
+       AST_STANDARD_APP_ARGS(args, parse);
 
-       if (argc < 1) {
+       if (args.argc < 1) {
                ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
-               return NULL;
+               return -1;
        }
 
-       mvalue1 = argv[0];
-       
+       mvalue1 = args.argv0;
+
        if ((op = strchr(mvalue1, '+'))) {
                iaction = ADDFUNCTION;
                *op = '\0';
@@ -108,137 +109,165 @@ static char *builtin_function_math(struct ast_channel *chan, char *cmd, char *da
        } else if ((op = strchr(mvalue1, '%'))) {
                iaction = MODULUSFUNCTION;
                *op = '\0';
+       } else if ((op = strchr(mvalue1, '^'))) {
+               iaction = POWFUNCTION;
+               *op = '\0';
        } else if ((op = strchr(mvalue1, '>'))) {
                iaction = GTFUNCTION;
                *op = '\0';
-               if (*(op+1) == '=') {
+               if (*(op + 1) == '=') {
                        *++op = '\0';
                        iaction = GTEFUNCTION;
+               } else if (*(op + 1) == '>') {
+                       *++op = '\0';
+                       iaction = SHRIGHTFUNCTION;
                }
        } else if ((op = strchr(mvalue1, '<'))) {
                iaction = LTFUNCTION;
                *op = '\0';
-               if (*(op+1) == '=') {
+               if (*(op + 1) == '=') {
                        *++op = '\0';
                        iaction = LTEFUNCTION;
+               } else if (*(op + 1) == '<') {
+                       *++op = '\0';
+                       iaction = SHLEFTFUNCTION;
                }
        } else if ((op = strchr(mvalue1, '='))) {
-               iaction = GTFUNCTION;
                *op = '\0';
-               if (*(op+1) == '=') {
+               if (*(op + 1) == '=') {
                        *++op = '\0';
                        iaction = EQFUNCTION;
                } else
                        op = NULL;
-       } 
-       
-       if (op) 
+       }
+
+       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;
+       mtype_of_result = args.argv1;
+       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 -1;
                }
        }
-       
+
        if (!mvalue1 || !mvalue2) {
-               ast_log(LOG_WARNING, "Supply all the parameters - just this once, please\n");
-               return NULL;
+               ast_log(LOG_WARNING,
+                               "Supply all the parameters - just this once, please\n");
+               return -1;
        }
 
        if (sscanf(mvalue1, "%f", &fnum1) != 1) {
                ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue1);
-               return NULL;
+               return -1;
        }
 
        if (sscanf(mvalue2, "%f", &fnum2) != 1) {
                ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue2);
-               return NULL;
+               return -1;
        }
 
        switch (iaction) {
-       case ADDFUNCTION :
+       case ADDFUNCTION:
                ftmp = fnum1 + fnum2;
                break;
-       case DIVIDEFUNCTION :
+       case DIVIDEFUNCTION:
                if (fnum2 <= 0)
-                       ftmp = 0; /* can't do a divide by 0 */
+                       ftmp = 0;                       /* can't do a divide by 0 */
                else
                        ftmp = (fnum1 / fnum2);
                break;
-       case MULTIPLYFUNCTION :
+       case MULTIPLYFUNCTION:
                ftmp = (fnum1 * fnum2);
                break;
-       case SUBTRACTFUNCTION :
+       case SUBTRACTFUNCTION:
                ftmp = (fnum1 - fnum2);
                break;
-       case MODULUSFUNCTION :
-       {
-               int inum1 = fnum1;
-               int inum2 = fnum2;
-                       
-               ftmp = (inum1 % inum2);
-               
+       case MODULUSFUNCTION:
+               {
+                       int inum1 = fnum1;
+                       int inum2 = fnum2;
+
+                       ftmp = (inum1 % inum2);
+
+                       break;
+               }
+       case POWFUNCTION:
+               ftmp = pow(fnum1, fnum2);
                break;
-       }
-       case GTFUNCTION :
-               ast_copy_string (user_result, (fnum1 > fnum2)?"TRUE":"FALSE", sizeof (user_result));
+       case SHLEFTFUNCTION:
+               {
+                       int inum1 = fnum1;
+                       int inum2 = fnum2;
+
+                       ftmp = (inum1 << inum2);
+                       break;
+               }
+       case SHRIGHTFUNCTION:
+               {
+                       int inum1 = fnum1;
+                       int inum2 = fnum2;
+
+                       ftmp = (inum1 >> inum2);
+                       break;
+               }
+       case GTFUNCTION:
+               ast_copy_string(buf, (fnum1 > fnum2) ? "TRUE" : "FALSE", len);
+               break;
+       case LTFUNCTION:
+               ast_copy_string(buf, (fnum1 < fnum2) ? "TRUE" : "FALSE", len);
                break;
-       case LTFUNCTION :
-               ast_copy_string (user_result, (fnum1 < fnum2)?"TRUE":"FALSE", sizeof (user_result));
+       case GTEFUNCTION:
+               ast_copy_string(buf, (fnum1 >= fnum2) ? "TRUE" : "FALSE", len);
                break;
-       case GTEFUNCTION :
-               ast_copy_string (user_result, (fnum1 >= fnum2)?"TRUE":"FALSE", sizeof (user_result));
+       case LTEFUNCTION:
+               ast_copy_string(buf, (fnum1 <= fnum2) ? "TRUE" : "FALSE", len);
                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));
+       case EQFUNCTION:
+               ast_copy_string(buf, (fnum1 == fnum2) ? "TRUE" : "FALSE", len);
                break;
-       default :
-               ast_log(LOG_WARNING, "Something happened that neither of us should be proud of %d\n", iaction);
-               return NULL;
+       default:
+               ast_log(LOG_WARNING,
+                               "Something happened that neither of us should be proud of %d\n",
+                               iaction);
+               return -1;
        }
 
        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);
+               if (type_of_result == FLOAT_RESULT)
+                       snprintf(buf, len, "%f", ftmp);
+               else if (type_of_result == INT_RESULT)
+                       snprintf(buf, len, "%i", (int) ftmp);
+               else if (type_of_result == HEX_RESULT)
+                       snprintf(buf, len, "%x", (unsigned int) ftmp);
+               else if (type_of_result == CHAR_RESULT)
+                       snprintf(buf, len, "%c", (unsigned char) ftmp);
        }
-               
-       ast_copy_string(buf, user_result, len);
-       
-       return buf;
+
+       return 0;
 }
 
-#ifndef BUILTIN_FUNC
-static
-#endif /* BUILTIN_FUNC */
-struct ast_custom_function math_function = {
+static 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"
+       .syntax = "MATH(<number1><op><number2>[,<type_of_result>])",
+       .desc = "Perform calculation on number1 to number2. 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"
@@ -246,5 +275,17 @@ struct ast_custom_function math_function = {
                "       h, hex - hex,\n"
                "       c, char - char\n"
                "Example: Set(i=${MATH(123%16,int)}) - sets var i=11",
-       .read = builtin_function_math
+       .read = math
 };
+
+static int unload_module(void)
+{
+       return ast_custom_function_unregister(&math_function);
+}
+
+static int load_module(void)
+{
+       return ast_custom_function_register(&math_function);
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Mathematical dialplan function");