e53eb40237abcd84e3c4f1f0a8f3f0d63526a09c
[asterisk/asterisk.git] / funcs / func_math.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2004 - 2005, Andy Powell 
5  *
6  * Updated by Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Maths relatad dialplan functions
22  * 
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sys/types.h>
28
29 #include "asterisk.h"
30
31 /* ASTERISK_FILE_VERSION(__FILE__, "$Revision$") */
32
33 #include "asterisk/channel.h"
34 #include "asterisk/pbx.h"
35 #include "asterisk/logger.h"
36 #include "asterisk/utils.h"
37 #include "asterisk/app.h"
38 #include "asterisk/config.h"
39
40 enum TypeOfFunctions
41 {
42     ADDFUNCTION,
43     DIVIDEFUNCTION,
44     MULTIPLYFUNCTION,
45     SUBTRACTFUNCTION,
46     MODULUSFUNCTION,
47
48     GTFUNCTION,
49     LTFUNCTION,
50     GTEFUNCTION,
51     LTEFUNCTION,
52     EQFUNCTION
53 };
54
55 enum TypeOfResult
56 {
57     FLOAT_RESULT,
58     INT_RESULT,
59     HEX_RESULT,
60     CHAR_RESULT
61 };
62
63
64 static char *builtin_function_math(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
65 {
66         int argc;
67         char *argv[2];
68         char *args;
69         float fnum1;
70         float fnum2;
71         float ftmp = 0;
72         char *op;
73         int iaction=-1;
74         int type_of_result=FLOAT_RESULT;
75
76         /* dunno, big calulations :D */
77         char user_result[30];
78
79         char *mvalue1, *mvalue2=NULL, *mtype_of_result;
80                 
81         if (ast_strlen_zero(data)) {
82                 ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
83                 return NULL;
84         }
85
86         args = ast_strdupa(data);       
87         argc = ast_app_separate_args(args, '|', argv, sizeof(argv) / sizeof(argv[0]));
88
89         if (argc < 1) {
90                 ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
91                 return NULL;
92         }
93
94         mvalue1 = argv[0];
95         
96         if ((op = strchr(mvalue1, '+'))) {
97                 iaction = ADDFUNCTION;
98                 *op = '\0';
99         } else if ((op = strchr(mvalue1, '-'))) {
100                 iaction = SUBTRACTFUNCTION;
101                 *op = '\0';
102         } else if ((op = strchr(mvalue1, '*'))) {
103                 iaction = MULTIPLYFUNCTION;
104                 *op = '\0';
105         } else if ((op = strchr(mvalue1, '/'))) {
106                 iaction = DIVIDEFUNCTION;
107                 *op = '\0';
108         } else if ((op = strchr(mvalue1, '%'))) {
109                 iaction = MODULUSFUNCTION;
110                 *op = '\0';
111         } else if ((op = strchr(mvalue1, '>'))) {
112                 iaction = GTFUNCTION;
113                 *op = '\0';
114                 if (*(op+1) == '=') {
115                         *++op = '\0';
116                         iaction = GTEFUNCTION;
117                 }
118         } else if ((op = strchr(mvalue1, '<'))) {
119                 iaction = LTFUNCTION;
120                 *op = '\0';
121                 if (*(op+1) == '=') {
122                         *++op = '\0';
123                         iaction = LTEFUNCTION;
124                 }
125         } else if ((op = strchr(mvalue1, '='))) {
126                 iaction = GTFUNCTION;
127                 *op = '\0';
128                 if (*(op+1) == '=') {
129                         *++op = '\0';
130                         iaction = EQFUNCTION;
131                 } else
132                         op = NULL;
133         } 
134         
135         if (op) 
136                 mvalue2 = op + 1;
137
138         /* detect wanted type of result */
139         mtype_of_result = argv[1];
140         if (mtype_of_result)
141         {
142                 if (!strcasecmp(mtype_of_result,"float") || !strcasecmp(mtype_of_result,"f"))
143                         type_of_result=FLOAT_RESULT;
144                 else if (!strcasecmp(mtype_of_result,"int") || !strcasecmp(mtype_of_result,"i"))
145                         type_of_result=INT_RESULT;
146                 else if (!strcasecmp(mtype_of_result,"hex") || !strcasecmp(mtype_of_result,"h"))
147                         type_of_result=HEX_RESULT;
148                 else if (!strcasecmp(mtype_of_result,"char") || !strcasecmp(mtype_of_result,"c"))
149                         type_of_result=CHAR_RESULT;
150                 else
151                 {
152                         ast_log(LOG_WARNING, "Unknown type of result requested '%s'.\n", mtype_of_result);
153                         return NULL;
154                 }
155         }
156         
157         if (!mvalue1 || !mvalue2) {
158                 ast_log(LOG_WARNING, "Supply all the parameters - just this once, please\n");
159                 return NULL;
160         }
161
162         if (sscanf(mvalue1, "%f", &fnum1) != 1) {
163                 ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue1);
164                 return NULL;
165         }
166
167         if (sscanf(mvalue2, "%f", &fnum2) != 1) {
168                 ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue2);
169                 return NULL;
170         }
171
172         switch (iaction) {
173         case ADDFUNCTION :
174                 ftmp = fnum1 + fnum2;
175                 break;
176         case DIVIDEFUNCTION :
177                 if (fnum2 <= 0)
178                         ftmp = 0; /* can't do a divide by 0 */
179                 else
180                         ftmp = (fnum1 / fnum2);
181                 break;
182         case MULTIPLYFUNCTION :
183                 ftmp = (fnum1 * fnum2);
184                 break;
185         case SUBTRACTFUNCTION :
186                 ftmp = (fnum1 - fnum2);
187                 break;
188         case MODULUSFUNCTION :
189         {
190                 int inum1 = fnum1;
191                 int inum2 = fnum2;
192                         
193                 ftmp = (inum1 % inum2);
194                 
195                 break;
196         }
197         case GTFUNCTION :
198                 ast_copy_string (user_result, (fnum1 > fnum2)?"TRUE":"FALSE", sizeof (user_result));
199                 break;
200         case LTFUNCTION :
201                 ast_copy_string (user_result, (fnum1 < fnum2)?"TRUE":"FALSE", sizeof (user_result));
202                 break;
203         case GTEFUNCTION :
204                 ast_copy_string (user_result, (fnum1 >= fnum2)?"TRUE":"FALSE", sizeof (user_result));
205                 break;
206         case LTEFUNCTION :
207                 ast_copy_string (user_result, (fnum1 <= fnum2)?"TRUE":"FALSE", sizeof (user_result));
208                 break;                                  
209         case EQFUNCTION :
210                 ast_copy_string (user_result, (fnum1 == fnum2)?"TRUE":"FALSE", sizeof (user_result));
211                 break;
212         default :
213                 ast_log(LOG_WARNING, "Something happened that neither of us should be proud of %d\n", iaction);
214                 return NULL;
215         }
216
217         if (iaction < GTFUNCTION || iaction > EQFUNCTION) {
218             if (type_of_result == FLOAT_RESULT)
219                     snprintf(user_result, sizeof(user_result), "%f", ftmp);
220             else if (type_of_result == INT_RESULT)
221                     snprintf(user_result, sizeof(user_result), "%i", (int) ftmp);
222             else if (type_of_result == HEX_RESULT)
223                 snprintf(user_result, sizeof(user_result), "%x", (unsigned int) ftmp);
224             else if (type_of_result == CHAR_RESULT)
225                 snprintf(user_result, sizeof(user_result), "%c", (unsigned char) ftmp);
226         }
227                 
228         ast_copy_string(buf, user_result, len);
229         
230         return buf;
231 }
232
233 #ifndef BUILTIN_FUNC
234 static
235 #endif /* BUILTIN_FUNC */
236 struct ast_custom_function math_function = {
237         .name = "MATH",
238         .synopsis = "Performs Mathematical Functions",
239         .syntax = "MATH(<number1><op><number 2>[,<type_of_result>])",
240         .desc = "Perform calculation on number 1 to number 2. Valid ops are: \n"
241             "    +,-,/,*,%,<,>,>=,<=,==\n"
242                 "and behave as their C equivalents.\n"
243                 "<type_of_result> - wanted type of result:\n"
244                 "       f, float - float(default)\n"
245                 "       i, int - integer,\n"
246                 "       h, hex - hex,\n"
247                 "       c, char - char\n"
248                 "Example: Set(i=${MATH(123%16,int)}) - sets var i=11",
249         .read = builtin_function_math
250 };