d086fe30478ac487493684957d8565426585662c
[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  * \author Andy Powell
24  * \author Mark Spencer <markster@digium.com>
25  */
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <sys/types.h>
31
32 #include "asterisk.h"
33
34 /* ASTERISK_FILE_VERSION(__FILE__, "$Revision$") */
35
36 #include "asterisk/channel.h"
37 #include "asterisk/pbx.h"
38 #include "asterisk/logger.h"
39 #include "asterisk/utils.h"
40 #include "asterisk/app.h"
41 #include "asterisk/config.h"
42
43 enum TypeOfFunctions
44 {
45     ADDFUNCTION,
46     DIVIDEFUNCTION,
47     MULTIPLYFUNCTION,
48     SUBTRACTFUNCTION,
49     MODULUSFUNCTION,
50
51     GTFUNCTION,
52     LTFUNCTION,
53     GTEFUNCTION,
54     LTEFUNCTION,
55     EQFUNCTION
56 };
57
58 enum TypeOfResult
59 {
60     FLOAT_RESULT,
61     INT_RESULT,
62     HEX_RESULT,
63     CHAR_RESULT
64 };
65
66
67 static char *builtin_function_math(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len) 
68 {
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         char *parse;
76         
77         /* dunno, big calulations :D */
78         char user_result[30];
79
80         char *mvalue1, *mvalue2=NULL, *mtype_of_result;
81         
82         AST_DECLARE_APP_ARGS(args,
83                 AST_APP_ARG(argv0);
84                 AST_APP_ARG(argv1);
85         );
86         if (ast_strlen_zero(data)) {
87                 ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
88                 return NULL;
89         }
90
91         parse = ast_strdupa(data);
92         if(!parse) {
93                 ast_log(LOG_ERROR, "Out of memory!\n");
94                 return NULL;
95         }
96
97         AST_STANDARD_APP_ARGS(args, parse);
98         
99         if (args.argc < 1) {
100                 ast_log(LOG_WARNING, "Syntax: Math(<number1><op><number 2>[,<type_of_result>]) - missing argument!\n");
101                 return NULL;
102         }
103
104         mvalue1 = args.argv0;
105         
106         if ((op = strchr(mvalue1, '+'))) {
107                 iaction = ADDFUNCTION;
108                 *op = '\0';
109         } else if ((op = strchr(mvalue1, '-'))) {
110                 iaction = SUBTRACTFUNCTION;
111                 *op = '\0';
112         } else if ((op = strchr(mvalue1, '*'))) {
113                 iaction = MULTIPLYFUNCTION;
114                 *op = '\0';
115         } else if ((op = strchr(mvalue1, '/'))) {
116                 iaction = DIVIDEFUNCTION;
117                 *op = '\0';
118         } else if ((op = strchr(mvalue1, '%'))) {
119                 iaction = MODULUSFUNCTION;
120                 *op = '\0';
121         } else if ((op = strchr(mvalue1, '>'))) {
122                 iaction = GTFUNCTION;
123                 *op = '\0';
124                 if (*(op+1) == '=') {
125                         *++op = '\0';
126                         iaction = GTEFUNCTION;
127                 }
128         } else if ((op = strchr(mvalue1, '<'))) {
129                 iaction = LTFUNCTION;
130                 *op = '\0';
131                 if (*(op+1) == '=') {
132                         *++op = '\0';
133                         iaction = LTEFUNCTION;
134                 }
135         } else if ((op = strchr(mvalue1, '='))) {
136                 iaction = GTFUNCTION;
137                 *op = '\0';
138                 if (*(op+1) == '=') {
139                         *++op = '\0';
140                         iaction = EQFUNCTION;
141                 } else
142                         op = NULL;
143         } 
144         
145         if (op) 
146                 mvalue2 = op + 1;
147
148         /* detect wanted type of result */
149         mtype_of_result = args.argv1;
150         if (mtype_of_result)
151         {
152                 if (!strcasecmp(mtype_of_result,"float") || !strcasecmp(mtype_of_result,"f"))
153                         type_of_result=FLOAT_RESULT;
154                 else if (!strcasecmp(mtype_of_result,"int") || !strcasecmp(mtype_of_result,"i"))
155                         type_of_result=INT_RESULT;
156                 else if (!strcasecmp(mtype_of_result,"hex") || !strcasecmp(mtype_of_result,"h"))
157                         type_of_result=HEX_RESULT;
158                 else if (!strcasecmp(mtype_of_result,"char") || !strcasecmp(mtype_of_result,"c"))
159                         type_of_result=CHAR_RESULT;
160                 else
161                 {
162                         ast_log(LOG_WARNING, "Unknown type of result requested '%s'.\n", mtype_of_result);
163                         return NULL;
164                 }
165         }
166         
167         if (!mvalue1 || !mvalue2) {
168                 ast_log(LOG_WARNING, "Supply all the parameters - just this once, please\n");
169                 return NULL;
170         }
171
172         if (sscanf(mvalue1, "%f", &fnum1) != 1) {
173                 ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue1);
174                 return NULL;
175         }
176
177         if (sscanf(mvalue2, "%f", &fnum2) != 1) {
178                 ast_log(LOG_WARNING, "'%s' is not a valid number\n", mvalue2);
179                 return NULL;
180         }
181
182         switch (iaction) {
183         case ADDFUNCTION :
184                 ftmp = fnum1 + fnum2;
185                 break;
186         case DIVIDEFUNCTION :
187                 if (fnum2 <= 0)
188                         ftmp = 0; /* can't do a divide by 0 */
189                 else
190                         ftmp = (fnum1 / fnum2);
191                 break;
192         case MULTIPLYFUNCTION :
193                 ftmp = (fnum1 * fnum2);
194                 break;
195         case SUBTRACTFUNCTION :
196                 ftmp = (fnum1 - fnum2);
197                 break;
198         case MODULUSFUNCTION :
199         {
200                 int inum1 = fnum1;
201                 int inum2 = fnum2;
202                         
203                 ftmp = (inum1 % inum2);
204                 
205                 break;
206         }
207         case GTFUNCTION :
208                 ast_copy_string (user_result, (fnum1 > fnum2)?"TRUE":"FALSE", sizeof (user_result));
209                 break;
210         case LTFUNCTION :
211                 ast_copy_string (user_result, (fnum1 < fnum2)?"TRUE":"FALSE", sizeof (user_result));
212                 break;
213         case GTEFUNCTION :
214                 ast_copy_string (user_result, (fnum1 >= fnum2)?"TRUE":"FALSE", sizeof (user_result));
215                 break;
216         case LTEFUNCTION :
217                 ast_copy_string (user_result, (fnum1 <= fnum2)?"TRUE":"FALSE", sizeof (user_result));
218                 break;                                  
219         case EQFUNCTION :
220                 ast_copy_string (user_result, (fnum1 == fnum2)?"TRUE":"FALSE", sizeof (user_result));
221                 break;
222         default :
223                 ast_log(LOG_WARNING, "Something happened that neither of us should be proud of %d\n", iaction);
224                 return NULL;
225         }
226
227         if (iaction < GTFUNCTION || iaction > EQFUNCTION) {
228             if (type_of_result == FLOAT_RESULT)
229                     snprintf(user_result, sizeof(user_result), "%f", ftmp);
230             else if (type_of_result == INT_RESULT)
231                     snprintf(user_result, sizeof(user_result), "%i", (int) ftmp);
232             else if (type_of_result == HEX_RESULT)
233                 snprintf(user_result, sizeof(user_result), "%x", (unsigned int) ftmp);
234             else if (type_of_result == CHAR_RESULT)
235                 snprintf(user_result, sizeof(user_result), "%c", (unsigned char) ftmp);
236         }
237                 
238         ast_copy_string(buf, user_result, len);
239         
240         return buf;
241 }
242
243 #ifndef BUILTIN_FUNC
244 static
245 #endif /* BUILTIN_FUNC */
246 struct ast_custom_function math_function = {
247         .name = "MATH",
248         .synopsis = "Performs Mathematical Functions",
249         .syntax = "MATH(<number1><op><number 2>[,<type_of_result>])",
250         .desc = "Perform calculation on number 1 to number 2. Valid ops are: \n"
251             "    +,-,/,*,%,<,>,>=,<=,==\n"
252                 "and behave as their C equivalents.\n"
253                 "<type_of_result> - wanted type of result:\n"
254                 "       f, float - float(default)\n"
255                 "       i, int - integer,\n"
256                 "       h, hex - hex,\n"
257                 "       c, char - char\n"
258                 "Example: Set(i=${MATH(123%16,int)}) - sets var i=11",
259         .read = builtin_function_math
260 };