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