[Freeswitch-svn] [commit] r6242 - freeswitch/trunk/src/mod/applications/mod_expr
Freeswitch SVN
mikej at freeswitch.org
Tue Nov 13 15:23:27 EST 2007
Author: mikej
Date: Tue Nov 13 15:23:26 2007
New Revision: 6242
Modified:
freeswitch/trunk/src/mod/applications/mod_expr/conio.h
freeswitch/trunk/src/mod/applications/mod_expr/exprconf.h
freeswitch/trunk/src/mod/applications/mod_expr/expreval.c
freeswitch/trunk/src/mod/applications/mod_expr/expreval.h
freeswitch/trunk/src/mod/applications/mod_expr/exprfunc.c
freeswitch/trunk/src/mod/applications/mod_expr/exprilfs.h
freeswitch/trunk/src/mod/applications/mod_expr/exprincl.h
freeswitch/trunk/src/mod/applications/mod_expr/exprinit.c
freeswitch/trunk/src/mod/applications/mod_expr/exprmem.c
freeswitch/trunk/src/mod/applications/mod_expr/exprmem.h
freeswitch/trunk/src/mod/applications/mod_expr/exprobj.c
freeswitch/trunk/src/mod/applications/mod_expr/exprpars.c
freeswitch/trunk/src/mod/applications/mod_expr/exprpriv.h
freeswitch/trunk/src/mod/applications/mod_expr/exprutil.c
freeswitch/trunk/src/mod/applications/mod_expr/exprval.c
Log:
dos2unix
Modified: freeswitch/trunk/src/mod/applications/mod_expr/conio.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/conio.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/conio.h Tue Nov 13 15:23:26 2007
@@ -1,161 +1,161 @@
-/* A conio implementation for Mingw/Dev-C++.
- *
- * Written by:
- * Hongli Lai <hongli at telekabel.nl>
- * tkorrovi <tkorrovi at altavista.net> on 2002/02/26.
- * Andrew Westcott <ajwestco at users.sourceforge.net>
- *
- * Offered for use in the public domain without any warranty.
- */
-
-#ifndef _CONIO_H_
-#define _CONIO_H_
-
-
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define BLINK 0
-
-typedef enum
-{
- BLACK,
- BLUE,
- GREEN,
- CYAN,
- RED,
- MAGENTA,
- BROWN,
- LIGHTGRAY,
- DARKGRAY,
- LIGHTBLUE,
- LIGHTGREEN,
- LIGHTCYAN,
- LIGHTRED,
- LIGHTMAGENTA,
- YELLOW,
- WHITE
-} COLORS;
-
-
-#define cgets _cgets
-#define cprintf _cprintf
-#define cputs _cputs
-#define cscanf _cscanf
-#define ScreenClear clrscr
-
-/* blinkvideo */
-
-void clreol (void);
-void clrscr (void);
-
-int _conio_gettext (int left, int top, int right, int bottom,
- char *str);
-/* _conio_kbhit */
-
-void delline (void);
-
-/* gettextinfo */
-void gotoxy(int x, int y);
-/*
-highvideo
-insline
-intensevideo
-lowvideo
-movetext
-normvideo
-*/
-
-void gotoxy(int x, int y);
-
-void puttext (int left, int top, int right, int bottom, char *str);
-
-// Screen Variables
-
-/* ScreenCols
-ScreenGetChar
-ScreenGetCursor
-ScreenMode
-ScreenPutChar
-ScreenPutString
-ScreenRetrieve
-ScreenRows
-ScreenSetCursor
-ScreenUpdate
-ScreenUpdateLine
-ScreenVisualBell
-_set_screen_lines */
-
-void _setcursortype (int type);
-
-void textattr (int _attr);
-
-void textbackground (int color);
-
-void textcolor (int color);
-
-/* textmode */
-
-int wherex (void);
-
-int wherey (void);
-
-/* window */
-
-
-
-/* The code below was part of Mingw's conio.h */
-/*
- * conio.h
- *
- * Low level console I/O functions. Pretty please try to use the ANSI
- * standard ones if you are writing new code.
- *
- * This file is part of the Mingw32 package.
- *
- * Contributors:
- * Created by Colin Peters <colin at bird.fu.is.saga-u.ac.jp>
- *
- * THIS SOFTWARE IS NOT COPYRIGHTED
- *
- * This source code is offered for use in the public domain. You may
- * use, modify or distribute it freely.
- *
- * This code is distributed in the hope that it will be useful but
- * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
- * DISCLAMED. This includes but is not limited to warranties of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * $Revision: 1.4 $
- * $Author: hongli $
- * $Date: 2002/04/26 19:31:25 $
- *
- */
-
-char* _cgets (char*);
-int _cprintf (const char*, ...);
-int _cputs (const char*);
-int _cscanf (char*, ...);
-
-int _getch (void);
-int _getche (void);
-int _kbhit (void);
-int _putch (int);
-int _ungetch (int);
-
-
-int getch (void);
-int getche (void);
-int kbhit (void);
-int putch (int);
-int ungetch (int);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CONIO_H_ */
+/* A conio implementation for Mingw/Dev-C++.
+ *
+ * Written by:
+ * Hongli Lai <hongli at telekabel.nl>
+ * tkorrovi <tkorrovi at altavista.net> on 2002/02/26.
+ * Andrew Westcott <ajwestco at users.sourceforge.net>
+ *
+ * Offered for use in the public domain without any warranty.
+ */
+
+#ifndef _CONIO_H_
+#define _CONIO_H_
+
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BLINK 0
+
+typedef enum
+{
+ BLACK,
+ BLUE,
+ GREEN,
+ CYAN,
+ RED,
+ MAGENTA,
+ BROWN,
+ LIGHTGRAY,
+ DARKGRAY,
+ LIGHTBLUE,
+ LIGHTGREEN,
+ LIGHTCYAN,
+ LIGHTRED,
+ LIGHTMAGENTA,
+ YELLOW,
+ WHITE
+} COLORS;
+
+
+#define cgets _cgets
+#define cprintf _cprintf
+#define cputs _cputs
+#define cscanf _cscanf
+#define ScreenClear clrscr
+
+/* blinkvideo */
+
+void clreol (void);
+void clrscr (void);
+
+int _conio_gettext (int left, int top, int right, int bottom,
+ char *str);
+/* _conio_kbhit */
+
+void delline (void);
+
+/* gettextinfo */
+void gotoxy(int x, int y);
+/*
+highvideo
+insline
+intensevideo
+lowvideo
+movetext
+normvideo
+*/
+
+void gotoxy(int x, int y);
+
+void puttext (int left, int top, int right, int bottom, char *str);
+
+// Screen Variables
+
+/* ScreenCols
+ScreenGetChar
+ScreenGetCursor
+ScreenMode
+ScreenPutChar
+ScreenPutString
+ScreenRetrieve
+ScreenRows
+ScreenSetCursor
+ScreenUpdate
+ScreenUpdateLine
+ScreenVisualBell
+_set_screen_lines */
+
+void _setcursortype (int type);
+
+void textattr (int _attr);
+
+void textbackground (int color);
+
+void textcolor (int color);
+
+/* textmode */
+
+int wherex (void);
+
+int wherey (void);
+
+/* window */
+
+
+
+/* The code below was part of Mingw's conio.h */
+/*
+ * conio.h
+ *
+ * Low level console I/O functions. Pretty please try to use the ANSI
+ * standard ones if you are writing new code.
+ *
+ * This file is part of the Mingw32 package.
+ *
+ * Contributors:
+ * Created by Colin Peters <colin at bird.fu.is.saga-u.ac.jp>
+ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+ * use, modify or distribute it freely.
+ *
+ * This code is distributed in the hope that it will be useful but
+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+ * DISCLAMED. This includes but is not limited to warranties of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * $Revision: 1.4 $
+ * $Author: hongli $
+ * $Date: 2002/04/26 19:31:25 $
+ *
+ */
+
+char* _cgets (char*);
+int _cprintf (const char*, ...);
+int _cputs (const char*);
+int _cscanf (char*, ...);
+
+int _getch (void);
+int _getche (void);
+int _kbhit (void);
+int _putch (int);
+int _ungetch (int);
+
+
+int getch (void);
+int getche (void);
+int kbhit (void);
+int putch (int);
+int ungetch (int);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CONIO_H_ */
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprconf.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprconf.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprconf.h Tue Nov 13 15:23:26 2007
@@ -1,29 +1,29 @@
-/*
- File: exprconf.h
- Auth: Brian Allen Vanderburg II
- Date: Thursday, October 20, 2005
- Desc: Configuration for ExprEval
-
- This file is part of ExprEval.
-*/
-
-#ifndef __BAVII_EXPRCONF_H
-#define __BAVII_EXPRCONF_H
-
-/*
- Error checking level
-
- 0: Don't check any errors (don't use errno). Divide by 0
- is avoided and the part that divides by 0 is 0. For example
- '4+1/0' is 4.
-
- 1: Check math errors.
-*/
-#define EXPR_ERROR_LEVEL_NONE 0
-#define EXPR_ERROR_LEVEL_CHECK 1
-
-#ifndef EXPR_ERROR_LEVEL
-#define EXPR_ERROR_LEVEL EXPR_ERROR_LEVEL_CHECK
-#endif
-
-#endif /* __BAVII_EXPRCONF_H */
+/*
+ File: exprconf.h
+ Auth: Brian Allen Vanderburg II
+ Date: Thursday, October 20, 2005
+ Desc: Configuration for ExprEval
+
+ This file is part of ExprEval.
+*/
+
+#ifndef __BAVII_EXPRCONF_H
+#define __BAVII_EXPRCONF_H
+
+/*
+ Error checking level
+
+ 0: Don't check any errors (don't use errno). Divide by 0
+ is avoided and the part that divides by 0 is 0. For example
+ '4+1/0' is 4.
+
+ 1: Check math errors.
+*/
+#define EXPR_ERROR_LEVEL_NONE 0
+#define EXPR_ERROR_LEVEL_CHECK 1
+
+#ifndef EXPR_ERROR_LEVEL
+#define EXPR_ERROR_LEVEL EXPR_ERROR_LEVEL_CHECK
+#endif
+
+#endif /* __BAVII_EXPRCONF_H */
Modified: freeswitch/trunk/src/mod/applications/mod_expr/expreval.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/expreval.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/expreval.c Tue Nov 13 15:23:26 2007
@@ -1,268 +1,268 @@
-/*
- File: expreval.c
- Auth: Brian Allen Vanderburg II
- Date: Wednesday, April 30, 2003
- Desc: Evaluation routines for the ExprEval library
-
- This file is part of ExprEval.
-*/
-
-/* Includes */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-
-/* Defines for error checking */
-#include <errno.h>
-
-#if(EXPR_ERROR_LEVEL >= EXPR_ERROR_LEVEL_CHECK)
-#define EXPR_RESET_ERR() errno = 0
-#define EXPR_CHECK_ERR() if(errno) return EXPR_ERROR_OUTOFRANGE
-#else
-#define EXPR_RESET_ERR()
-#define EXPR_CHECK_ERR()
-#endif
-
-
-/* This routine will evaluate an expression */
-int exprEval(exprObj *obj, EXPRTYPE *val)
- {
- EXPRTYPE dummy;
-
- if(val == NULL)
- val = &dummy;
-
- /* Make sure it was parsed successfully */
- if(!obj->parsedbad && obj->parsedgood && obj->headnode)
- {
- /* Do NOT reset the break count. Let is accumulate
- between calls until breaker function is called */
- return exprEvalNode(obj, obj->headnode, 0, val);
- }
- else
- return EXPR_ERROR_BADEXPR;
- }
-
-/* Evaluate a node */
-int exprEvalNode(exprObj *obj, exprNode *nodes, int curnode, EXPRTYPE *val)
- {
- int err;
- int pos;
- EXPRTYPE d1, d2;
-
- if(obj == NULL || nodes == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Update n to point to correct node */
- nodes += curnode;
-
- /* Check breaker count */
- if(obj->breakcur-- <= 0)
- {
- /* Reset count before returning */
- obj->breakcur = obj->breakcount;
-
- if(exprGetBreakResult(obj))
- {
- return EXPR_ERROR_BREAK;
- }
- }
-
- switch(nodes->type)
- {
- case EXPR_NODETYPE_MULTI:
- {
- /* Multi for multiple expressions in one string */
- for(pos = 0; pos < nodes->data.oper.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.oper.nodes, pos, val);
- if(err)
- return err;
- }
- break;
- }
-
- case EXPR_NODETYPE_ADD:
- {
- /* Addition */
- err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
-
- if(!err)
- *val = d1 + d2;
- else
- return err;
-
- break;
- }
-
- case EXPR_NODETYPE_SUBTRACT:
- {
- /* Subtraction */
- err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
-
- if(!err)
- *val = d1 - d2;
- else
- return err;
-
- break;
- }
-
- case EXPR_NODETYPE_MULTIPLY:
- {
- /* Multiplication */
- err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
-
- if(!err)
- *val = d1 * d2;
- else
- return err;
-
- break;
- }
-
- case EXPR_NODETYPE_DIVIDE:
- {
- /* Division */
- err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
-
- if(!err)
- {
- if(d2 != 0.0)
- *val = d1 / d2;
- else
- {
-#if(EXPR_ERROR_LEVEL >= EXPR_ERROR_LEVEL_CHECK)
- return EXPR_ERROR_DIVBYZERO;
-#else
- *val = 0.0;
- return EXPR_ERROR_NOERROR;
-#endif
- }
- }
- else
- return err;
-
- break;
- }
-
- case EXPR_NODETYPE_EXPONENT:
- {
- /* Exponent */
- err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = pow(d1, d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
- case EXPR_NODETYPE_NEGATE:
- {
- /* Negative value */
- err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
-
- if(!err)
- *val = -d1;
- else
- return err;
-
- break;
- }
-
-
- case EXPR_NODETYPE_VALUE:
- {
- /* Directly access the value */
- *val = nodes->data.value.value;
- break;
- }
-
- case EXPR_NODETYPE_VARIABLE:
- {
- /* Directly access the variable or constant */
- *val = *(nodes->data.variable.vaddr);
- break;
- }
-
- case EXPR_NODETYPE_ASSIGN:
- {
- /* Evaluate assignment subnode */
- err = exprEvalNode(obj, nodes->data.assign.node, 0, val);
-
- if(!err)
- {
- /* Directly assign the variable */
- *(nodes->data.assign.vaddr) = *val;
- }
- else
- return err;
-
- break;
- }
-
- case EXPR_NODETYPE_FUNCTION:
- {
- /* Evaluate the function */
- if(nodes->data.function.fptr == NULL)
- {
- /* No function pointer means we are not using
- function solvers. See if the function has a
- type to solve directly. */
- switch(nodes->data.function.type)
- {
- /* This is to keep the file from being too crowded.
- See exprilfs.h for the definitions. */
-#include "exprilfs.h"
-
-
- default:
- {
- return EXPR_ERROR_UNKNOWN;
- }
- }
- }
- else
- {
- /* Call the correct function */
- return (*(nodes->data.function.fptr))(obj,
- nodes->data.function.nodes, nodes->data.function.nodecount,
- nodes->data.function.refs, nodes->data.function.refcount, val);
- }
-
- break;
- }
-
- default:
- {
- /* Unknown node type */
- return EXPR_ERROR_UNKNOWN;
- }
- }
-
- return EXPR_ERROR_NOERROR;
- }
-
-
-
+/*
+ File: expreval.c
+ Auth: Brian Allen Vanderburg II
+ Date: Wednesday, April 30, 2003
+ Desc: Evaluation routines for the ExprEval library
+
+ This file is part of ExprEval.
+*/
+
+/* Includes */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+
+/* Defines for error checking */
+#include <errno.h>
+
+#if(EXPR_ERROR_LEVEL >= EXPR_ERROR_LEVEL_CHECK)
+#define EXPR_RESET_ERR() errno = 0
+#define EXPR_CHECK_ERR() if(errno) return EXPR_ERROR_OUTOFRANGE
+#else
+#define EXPR_RESET_ERR()
+#define EXPR_CHECK_ERR()
+#endif
+
+
+/* This routine will evaluate an expression */
+int exprEval(exprObj *obj, EXPRTYPE *val)
+ {
+ EXPRTYPE dummy;
+
+ if(val == NULL)
+ val = &dummy;
+
+ /* Make sure it was parsed successfully */
+ if(!obj->parsedbad && obj->parsedgood && obj->headnode)
+ {
+ /* Do NOT reset the break count. Let is accumulate
+ between calls until breaker function is called */
+ return exprEvalNode(obj, obj->headnode, 0, val);
+ }
+ else
+ return EXPR_ERROR_BADEXPR;
+ }
+
+/* Evaluate a node */
+int exprEvalNode(exprObj *obj, exprNode *nodes, int curnode, EXPRTYPE *val)
+ {
+ int err;
+ int pos;
+ EXPRTYPE d1, d2;
+
+ if(obj == NULL || nodes == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Update n to point to correct node */
+ nodes += curnode;
+
+ /* Check breaker count */
+ if(obj->breakcur-- <= 0)
+ {
+ /* Reset count before returning */
+ obj->breakcur = obj->breakcount;
+
+ if(exprGetBreakResult(obj))
+ {
+ return EXPR_ERROR_BREAK;
+ }
+ }
+
+ switch(nodes->type)
+ {
+ case EXPR_NODETYPE_MULTI:
+ {
+ /* Multi for multiple expressions in one string */
+ for(pos = 0; pos < nodes->data.oper.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.oper.nodes, pos, val);
+ if(err)
+ return err;
+ }
+ break;
+ }
+
+ case EXPR_NODETYPE_ADD:
+ {
+ /* Addition */
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
+
+ if(!err)
+ *val = d1 + d2;
+ else
+ return err;
+
+ break;
+ }
+
+ case EXPR_NODETYPE_SUBTRACT:
+ {
+ /* Subtraction */
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
+
+ if(!err)
+ *val = d1 - d2;
+ else
+ return err;
+
+ break;
+ }
+
+ case EXPR_NODETYPE_MULTIPLY:
+ {
+ /* Multiplication */
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
+
+ if(!err)
+ *val = d1 * d2;
+ else
+ return err;
+
+ break;
+ }
+
+ case EXPR_NODETYPE_DIVIDE:
+ {
+ /* Division */
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
+
+ if(!err)
+ {
+ if(d2 != 0.0)
+ *val = d1 / d2;
+ else
+ {
+#if(EXPR_ERROR_LEVEL >= EXPR_ERROR_LEVEL_CHECK)
+ return EXPR_ERROR_DIVBYZERO;
+#else
+ *val = 0.0;
+ return EXPR_ERROR_NOERROR;
+#endif
+ }
+ }
+ else
+ return err;
+
+ break;
+ }
+
+ case EXPR_NODETYPE_EXPONENT:
+ {
+ /* Exponent */
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = pow(d1, d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+ case EXPR_NODETYPE_NEGATE:
+ {
+ /* Negative value */
+ err = exprEvalNode(obj, nodes->data.oper.nodes, 0, &d1);
+
+ if(!err)
+ *val = -d1;
+ else
+ return err;
+
+ break;
+ }
+
+
+ case EXPR_NODETYPE_VALUE:
+ {
+ /* Directly access the value */
+ *val = nodes->data.value.value;
+ break;
+ }
+
+ case EXPR_NODETYPE_VARIABLE:
+ {
+ /* Directly access the variable or constant */
+ *val = *(nodes->data.variable.vaddr);
+ break;
+ }
+
+ case EXPR_NODETYPE_ASSIGN:
+ {
+ /* Evaluate assignment subnode */
+ err = exprEvalNode(obj, nodes->data.assign.node, 0, val);
+
+ if(!err)
+ {
+ /* Directly assign the variable */
+ *(nodes->data.assign.vaddr) = *val;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+ case EXPR_NODETYPE_FUNCTION:
+ {
+ /* Evaluate the function */
+ if(nodes->data.function.fptr == NULL)
+ {
+ /* No function pointer means we are not using
+ function solvers. See if the function has a
+ type to solve directly. */
+ switch(nodes->data.function.type)
+ {
+ /* This is to keep the file from being too crowded.
+ See exprilfs.h for the definitions. */
+#include "exprilfs.h"
+
+
+ default:
+ {
+ return EXPR_ERROR_UNKNOWN;
+ }
+ }
+ }
+ else
+ {
+ /* Call the correct function */
+ return (*(nodes->data.function.fptr))(obj,
+ nodes->data.function.nodes, nodes->data.function.nodecount,
+ nodes->data.function.refs, nodes->data.function.refcount, val);
+ }
+
+ break;
+ }
+
+ default:
+ {
+ /* Unknown node type */
+ return EXPR_ERROR_UNKNOWN;
+ }
+ }
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+
+
Modified: freeswitch/trunk/src/mod/applications/mod_expr/expreval.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/expreval.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/expreval.h Tue Nov 13 15:23:26 2007
@@ -1,127 +1,127 @@
-/*
- File: expreval.h
- Auth: Brian Allen Vanderburg II
- Date: Thursday, April 24, 2003
- Desc: Main include file for ExprEval library
-
- This file is part of ExprEval.
-*/
-
-
-/* Include once */
-#ifndef __BAVII_EXPREVAL_H
-#define __BAVII_EXPREVAL_H
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Define type of data to use */
-typedef double EXPRTYPE;
-
-/* Defines for various things */
-
-/* Max id size */
-#define EXPR_MAXIDENTSIZE 255
-
-/* Error values */
-enum
- {
- EXPR_ERROR_UNKNOWN = -1, /* Unknown error */
- EXPR_ERROR_NOERROR = 0, /* No Error */
- EXPR_ERROR_MEMORY, /* Memory allocation failed */
- EXPR_ERROR_NULLPOINTER, /* Null pointer passed to function */
- EXPR_ERROR_NOTFOUND, /* Item not found in a list */
- EXPR_ERROR_UNMATCHEDCOMMENT, /* Unmatched comment tags */
- EXPR_ERROR_INVALIDCHAR, /* Invalid characters in expression */
- EXPR_ERROR_ALREADYEXISTS, /* An item already called create */
- EXPR_ERROR_ALREADYPARSEDBAD, /* Expression parsed already, but unsuccessfully. call free or clear */
- EXPR_ERROR_ALREADYPARSEDGOOD, /* Expression parsed already, successfully, call free or clear */
- EXPR_ERROR_EMPTYEXPR, /* Empty expression string passed to parse */
- EXPR_ERROR_UNMATCHEDPAREN, /* Unmatched parenthesis */
- EXPR_ERROR_SYNTAX, /* Syntax error in expression */
- EXPR_ERROR_MISSINGSEMICOLON, /* Missing semicolon at end of expression */
- EXPR_ERROR_BADIDENTIFIER, /* Identifier was to big or not formed right */
- EXPR_ERROR_NOSUCHFUNCTION, /* Function does not exist in function list */
- EXPR_ERROR_BADNUMBERARGUMENTS, /* Bad number of arguments in a function call */
- EXPR_ERROR_BADEXPR, /* This is a bad expression to evaluate. It has not been parsed or has unsuccessfully */
- EXPR_ERROR_UNABLETOASSIGN, /* Unable to do an assignment, maybe no variable list */
- EXPR_ERROR_DIVBYZERO, /* Attempted a division by zero */
- EXPR_ERROR_NOVARLIST, /* No variable list found but one is needed */
- EXPR_ERROR_BREAK, /* Expression was broken by break function */
- EXPR_ERROR_CONSTANTASSIGN, /* Assignment to a constant */
- EXPR_ERROR_REFCONSTANT, /* Constant used as a reference parameter */
- EXPR_ERROR_OUTOFRANGE, /* A bad value was passed to a function */
-
- EXPR_ERROR_USER /* Custom errors should be larger than this */
- };
-
-/* Macros */
-
-/* Forward declarations */
-typedef struct _exprNode exprNode;
-typedef struct _exprFuncList exprFuncList;
-typedef struct _exprValList exprValList;
-typedef struct _exprObj exprObj;
-
-/* Function types */
-typedef int (*exprFuncType)(exprObj *obj, exprNode *nodes, int nodecount, EXPRTYPE **refs, int refcount, EXPRTYPE *val);
-typedef int (*exprBreakFuncType)(exprObj *obj);
-
-
-
-/* Functions */
-
-/* Version information function */
-void exprGetVersion(int *major, int *minor);
-
-/* Functions for function lists */
-int exprFuncListCreate(exprFuncList **flist);
-int exprFuncListAdd(exprFuncList *flist, char *name, exprFuncType ptr, int min, int max, int refmin, int refmax);
-int exprFuncListFree(exprFuncList *flist);
-int exprFuncListClear(exprFuncList *flist);
-int exprFuncListInit(exprFuncList *flist);
-
-/* Functions for value lists */
-int exprValListCreate(exprValList **vlist);
-int exprValListAdd(exprValList *vlist, char *name, EXPRTYPE val);
-int exprValListSet(exprValList *vlist, char *name, EXPRTYPE val);
-int exprValListGet(exprValList *vlist, char *name, EXPRTYPE *val);
-int exprValListAddAddress(exprValList *vlist, char *name, EXPRTYPE *addr);
-int exprValListGetAddress(exprValList *vlist, char *name, EXPRTYPE **addr);
-void *exprValListGetNext(exprValList *vlist, char **name, EXPRTYPE *value, EXPRTYPE** addr, void *cookie);
-int exprValListFree(exprValList *vlist);
-int exprValListClear(exprValList *vlist);
-int exprValListInit(exprValList *vlist);
-
-/* Functions for expression objects */
-int exprCreate(exprObj **obj, exprFuncList *flist, exprValList *vlist, exprValList *clist,
- exprBreakFuncType breaker, void *userdata);
-int exprFree(exprObj *obj);
-int exprClear(exprObj *obj);
-int exprParse(exprObj *obj, char *expr);
-int exprEval(exprObj *obj, EXPRTYPE *val);
-int exprEvalNode(exprObj *obj, exprNode *nodes, int curnode, EXPRTYPE *val);
-exprFuncList *exprGetFuncList(exprObj *obj);
-exprValList *exprGetVarList(exprObj *obj);
-exprValList *exprGetConstList(exprObj *obj);
-exprBreakFuncType exprGetBreakFunc(exprObj *obj);
-int exprGetBreakResult(exprObj *obj);
-void* exprGetUserData(exprObj *obj);
-void exprSetUserData(exprObj *obj, void *userdata);
-void exprSetBreakCount(exprObj *obj, int count);
-void exprGetErrorPosition(exprObj *obj, int *start, int *end);
-
-/* Other useful routines */
-int exprValidIdent(char *name);
-
-/* Name mangling */
-#ifdef __cplusplus
-}
-#endif
-
-
-
-#endif /* __BAVII_EXPREVAL_H */
+/*
+ File: expreval.h
+ Auth: Brian Allen Vanderburg II
+ Date: Thursday, April 24, 2003
+ Desc: Main include file for ExprEval library
+
+ This file is part of ExprEval.
+*/
+
+
+/* Include once */
+#ifndef __BAVII_EXPREVAL_H
+#define __BAVII_EXPREVAL_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Define type of data to use */
+typedef double EXPRTYPE;
+
+/* Defines for various things */
+
+/* Max id size */
+#define EXPR_MAXIDENTSIZE 255
+
+/* Error values */
+enum
+ {
+ EXPR_ERROR_UNKNOWN = -1, /* Unknown error */
+ EXPR_ERROR_NOERROR = 0, /* No Error */
+ EXPR_ERROR_MEMORY, /* Memory allocation failed */
+ EXPR_ERROR_NULLPOINTER, /* Null pointer passed to function */
+ EXPR_ERROR_NOTFOUND, /* Item not found in a list */
+ EXPR_ERROR_UNMATCHEDCOMMENT, /* Unmatched comment tags */
+ EXPR_ERROR_INVALIDCHAR, /* Invalid characters in expression */
+ EXPR_ERROR_ALREADYEXISTS, /* An item already called create */
+ EXPR_ERROR_ALREADYPARSEDBAD, /* Expression parsed already, but unsuccessfully. call free or clear */
+ EXPR_ERROR_ALREADYPARSEDGOOD, /* Expression parsed already, successfully, call free or clear */
+ EXPR_ERROR_EMPTYEXPR, /* Empty expression string passed to parse */
+ EXPR_ERROR_UNMATCHEDPAREN, /* Unmatched parenthesis */
+ EXPR_ERROR_SYNTAX, /* Syntax error in expression */
+ EXPR_ERROR_MISSINGSEMICOLON, /* Missing semicolon at end of expression */
+ EXPR_ERROR_BADIDENTIFIER, /* Identifier was to big or not formed right */
+ EXPR_ERROR_NOSUCHFUNCTION, /* Function does not exist in function list */
+ EXPR_ERROR_BADNUMBERARGUMENTS, /* Bad number of arguments in a function call */
+ EXPR_ERROR_BADEXPR, /* This is a bad expression to evaluate. It has not been parsed or has unsuccessfully */
+ EXPR_ERROR_UNABLETOASSIGN, /* Unable to do an assignment, maybe no variable list */
+ EXPR_ERROR_DIVBYZERO, /* Attempted a division by zero */
+ EXPR_ERROR_NOVARLIST, /* No variable list found but one is needed */
+ EXPR_ERROR_BREAK, /* Expression was broken by break function */
+ EXPR_ERROR_CONSTANTASSIGN, /* Assignment to a constant */
+ EXPR_ERROR_REFCONSTANT, /* Constant used as a reference parameter */
+ EXPR_ERROR_OUTOFRANGE, /* A bad value was passed to a function */
+
+ EXPR_ERROR_USER /* Custom errors should be larger than this */
+ };
+
+/* Macros */
+
+/* Forward declarations */
+typedef struct _exprNode exprNode;
+typedef struct _exprFuncList exprFuncList;
+typedef struct _exprValList exprValList;
+typedef struct _exprObj exprObj;
+
+/* Function types */
+typedef int (*exprFuncType)(exprObj *obj, exprNode *nodes, int nodecount, EXPRTYPE **refs, int refcount, EXPRTYPE *val);
+typedef int (*exprBreakFuncType)(exprObj *obj);
+
+
+
+/* Functions */
+
+/* Version information function */
+void exprGetVersion(int *major, int *minor);
+
+/* Functions for function lists */
+int exprFuncListCreate(exprFuncList **flist);
+int exprFuncListAdd(exprFuncList *flist, char *name, exprFuncType ptr, int min, int max, int refmin, int refmax);
+int exprFuncListFree(exprFuncList *flist);
+int exprFuncListClear(exprFuncList *flist);
+int exprFuncListInit(exprFuncList *flist);
+
+/* Functions for value lists */
+int exprValListCreate(exprValList **vlist);
+int exprValListAdd(exprValList *vlist, char *name, EXPRTYPE val);
+int exprValListSet(exprValList *vlist, char *name, EXPRTYPE val);
+int exprValListGet(exprValList *vlist, char *name, EXPRTYPE *val);
+int exprValListAddAddress(exprValList *vlist, char *name, EXPRTYPE *addr);
+int exprValListGetAddress(exprValList *vlist, char *name, EXPRTYPE **addr);
+void *exprValListGetNext(exprValList *vlist, char **name, EXPRTYPE *value, EXPRTYPE** addr, void *cookie);
+int exprValListFree(exprValList *vlist);
+int exprValListClear(exprValList *vlist);
+int exprValListInit(exprValList *vlist);
+
+/* Functions for expression objects */
+int exprCreate(exprObj **obj, exprFuncList *flist, exprValList *vlist, exprValList *clist,
+ exprBreakFuncType breaker, void *userdata);
+int exprFree(exprObj *obj);
+int exprClear(exprObj *obj);
+int exprParse(exprObj *obj, char *expr);
+int exprEval(exprObj *obj, EXPRTYPE *val);
+int exprEvalNode(exprObj *obj, exprNode *nodes, int curnode, EXPRTYPE *val);
+exprFuncList *exprGetFuncList(exprObj *obj);
+exprValList *exprGetVarList(exprObj *obj);
+exprValList *exprGetConstList(exprObj *obj);
+exprBreakFuncType exprGetBreakFunc(exprObj *obj);
+int exprGetBreakResult(exprObj *obj);
+void* exprGetUserData(exprObj *obj);
+void exprSetUserData(exprObj *obj, void *userdata);
+void exprSetBreakCount(exprObj *obj, int count);
+void exprGetErrorPosition(exprObj *obj, int *start, int *end);
+
+/* Other useful routines */
+int exprValidIdent(char *name);
+
+/* Name mangling */
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif /* __BAVII_EXPREVAL_H */
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprfunc.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprfunc.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprfunc.c Tue Nov 13 15:23:26 2007
@@ -1,329 +1,329 @@
-/*
- File: exprfunc.c
- Auth: Brian Allen Vanderburg II
- Date: Thursday, April 24, 2003
- Desc: Expression function list routines
-
- This file is part of ExprEval.
-*/
-
-
-
-/* Includes */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-#include "exprmem.h"
-
-/* Internal functions */
-static exprFunc *exprCreateFunc(char *name, exprFuncType ptr, int type, int min, int max, int refmin, int refmax);
-static void exprFuncListFreeData(exprFunc *func);
-
-
-/* This function creates the function list, */
-int exprFuncListCreate(exprFuncList **flist)
- {
- exprFuncList *tmp;
-
- if(flist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- *flist = NULL; /* Set to NULL initially */
-
- tmp = exprAllocMem(sizeof(exprFuncList));
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY; /* Could not allocate memory */
-
- /* Update pointer */
- *flist = tmp;
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Add a function to the list */
-int exprFuncListAdd(exprFuncList *flist, char *name, exprFuncType ptr, int min, int max, int refmin, int refmax)
- {
- exprFunc *tmp;
- exprFunc *cur;
- int result;
-
- if(flist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Make sure the name is valid */
- if(!exprValidIdent(name))
- return EXPR_ERROR_BADIDENTIFIER;
-
- /* Fix values only if none are negative (negative values mean no limit) */
-
- /* if both are neg, no min or max number of args */
- /* if min is neg, max pos, no min number of args but a maximum */
- /* if min is pos, max neg, there is a min number of args, but no max */
- /* if both pos, then a min and max limit. We swap to make sure it works
- right. I.E. Min of 3 and max of 2 would make function unusable */
- if(min >= 0 && max >= 0)
- {
- if(min > max)
- {
- result = min;
- min = max;
- max = result;
- }
- }
-
- if(refmin >= 0 && refmax >= 0)
- {
- if(refmin > refmax)
- {
- result = refmin;
- refmin = max;
- refmax = result;
- }
- }
-
- if(flist->head == NULL)
- {
- /* Create the node right here */
- tmp = exprCreateFunc(name, ptr, EXPR_NODETYPE_FUNCTION, min, max, refmin, refmax);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- flist->head = tmp;
- return EXPR_ERROR_NOERROR;
- }
-
- /* See if it already exists */
- cur = flist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->fname);
-
- if(result == 0)
- return EXPR_ERROR_ALREADYEXISTS;
-
- cur = cur->next;
- }
-
- /* It did not exist, so add it at the head */
- tmp = exprCreateFunc(name, ptr, EXPR_NODETYPE_FUNCTION, min, max, refmin, refmax);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- tmp->next = flist->head;
- flist->head = tmp;
- return EXPR_ERROR_NOERROR;
- }
-
-/* Add a function node type to the list
- This works pretty much the same way, except the function
- pointer is NULL and the node type specifies the function
- to do. exprEvalNode handles this, instead of calling
- a function solver. */
-int exprFuncListAddType(exprFuncList *flist, char *name, int type, int min, int max, int refmin, int refmax)
- {
- exprFunc *tmp;
- exprFunc *cur;
- int result;
-
- if(flist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Make sure the name is valid */
- if(!exprValidIdent(name))
- return EXPR_ERROR_BADIDENTIFIER;
-
- /* Fix values only if none are negative (negative values mean no limit) */
-
- /* if both are neg, no min or max number of args */
- /* if min is neg, max pos, no min number of args but a maximum */
- /* if min is pos, max neg, there is a min number of args, but no max */
- /* if both pos, then a min and max limit. We swap to make sure it works
- right. I.E. Min of 3 and max of 2 would make function unusable */
- if(min >= 0 && max >= 0)
- {
- if(min > max)
- {
- result = min;
- min = max;
- max = result;
- }
- }
-
- if(refmin >= 0 && refmax >= 0)
- {
- if(refmin > refmax)
- {
- result = refmin;
- refmin = max;
- refmax = result;
- }
- }
-
- if(flist->head == NULL)
- {
- /* Create the node right here */
- tmp = exprCreateFunc(name, NULL, type, min, max, refmin, refmax);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- flist->head = tmp;
- return EXPR_ERROR_NOERROR;
- }
-
- /* See if it already exists */
- cur = flist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->fname);
-
- if(result == 0)
- return EXPR_ERROR_ALREADYEXISTS;
-
- cur = cur->next;
- }
-
- /* It did not exist, so add it at the head */
- tmp = exprCreateFunc(name, NULL, type, min, max, refmin, refmax);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- tmp->next = flist->head;
- flist->head = tmp;
- return EXPR_ERROR_NOERROR;
- }
-
-
-/* Get the function from a list along with it's min an max data */
-int exprFuncListGet(exprFuncList *flist, char *name, exprFuncType *ptr, int *type, int *min, int *max, int *refmin, int *refmax)
- {
- exprFunc *cur;
- int result;
-
- if(flist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- if(name == NULL || name[0] == '\0')
- return EXPR_ERROR_NOTFOUND;
-
- /* Search for the item */
- cur = flist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->fname);
-
- if(result == 0)
- {
- /* We found it. */
- *ptr = cur->fptr;
- *min = cur->min;
- *max = cur->max;
- *refmin = cur->refmin;
- *refmax = cur->refmax;
- *type = cur->type;
-
- /* return now */
- return EXPR_ERROR_NOERROR;
- }
-
- cur = cur->next;
- }
-
- /* If we got here, we did not find the item in the list */
- return EXPR_ERROR_NOTFOUND;
- }
-
-/* This routine will free the function list */
-int exprFuncListFree(exprFuncList *flist)
- {
- /* Make sure it exists, if not it is not error */
- if(flist == NULL)
- return EXPR_ERROR_NOERROR;
-
- /* Free the nodes */
- exprFuncListFreeData(flist->head);
-
- /* Free the container */
- exprFreeMem(flist);
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* This routine will clear the function list */
-int exprFuncListClear(exprFuncList *flist)
- {
- if(flist == NULL)
- return EXPR_ERROR_NOERROR;
-
- /* Free the nodes only */
- if(flist->head)
- {
- exprFuncListFreeData(flist->head);
-
- flist->head = NULL;
- }
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* This routine will free any child nodes, and then free itself */
-void exprFuncListFreeData(exprFunc *func)
- {
- exprFunc *next;
-
- while(func)
- {
- /* Remember the next item */
- next = func->next;
-
- /* Free name */
- exprFreeMem(func->fname);
-
- /* Free ourself */
- exprFreeMem(func);
-
- func = next;
- }
- }
-
-/* This routine will create the function object */
-exprFunc *exprCreateFunc(char *name, exprFuncType ptr, int type, int min, int max, int refmin, int refmax)
- {
- exprFunc *tmp;
- char *vtmp;
-
- /* We already checked the name in exprFuncListAdd */
-
- /* Create it */
- tmp = exprAllocMem(sizeof(exprFunc));
- if(tmp == NULL)
- return NULL;
-
- /* Allocate space for the name */
- vtmp = exprAllocMem(strlen(name) + 1);
-
- if(vtmp == NULL)
- {
- exprFreeMem(tmp);
- return NULL;
- }
-
- /* Copy the data over */
- strcpy(vtmp, name);
- tmp->fname = vtmp;
- tmp->fptr = ptr;
- tmp->min = min;
- tmp->max = max;
- tmp->refmin = refmin;
- tmp->refmax = refmax;
- tmp->type = type;
-
- return tmp;
- }
+/*
+ File: exprfunc.c
+ Auth: Brian Allen Vanderburg II
+ Date: Thursday, April 24, 2003
+ Desc: Expression function list routines
+
+ This file is part of ExprEval.
+*/
+
+
+
+/* Includes */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+#include "exprmem.h"
+
+/* Internal functions */
+static exprFunc *exprCreateFunc(char *name, exprFuncType ptr, int type, int min, int max, int refmin, int refmax);
+static void exprFuncListFreeData(exprFunc *func);
+
+
+/* This function creates the function list, */
+int exprFuncListCreate(exprFuncList **flist)
+ {
+ exprFuncList *tmp;
+
+ if(flist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ *flist = NULL; /* Set to NULL initially */
+
+ tmp = exprAllocMem(sizeof(exprFuncList));
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY; /* Could not allocate memory */
+
+ /* Update pointer */
+ *flist = tmp;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Add a function to the list */
+int exprFuncListAdd(exprFuncList *flist, char *name, exprFuncType ptr, int min, int max, int refmin, int refmax)
+ {
+ exprFunc *tmp;
+ exprFunc *cur;
+ int result;
+
+ if(flist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Make sure the name is valid */
+ if(!exprValidIdent(name))
+ return EXPR_ERROR_BADIDENTIFIER;
+
+ /* Fix values only if none are negative (negative values mean no limit) */
+
+ /* if both are neg, no min or max number of args */
+ /* if min is neg, max pos, no min number of args but a maximum */
+ /* if min is pos, max neg, there is a min number of args, but no max */
+ /* if both pos, then a min and max limit. We swap to make sure it works
+ right. I.E. Min of 3 and max of 2 would make function unusable */
+ if(min >= 0 && max >= 0)
+ {
+ if(min > max)
+ {
+ result = min;
+ min = max;
+ max = result;
+ }
+ }
+
+ if(refmin >= 0 && refmax >= 0)
+ {
+ if(refmin > refmax)
+ {
+ result = refmin;
+ refmin = max;
+ refmax = result;
+ }
+ }
+
+ if(flist->head == NULL)
+ {
+ /* Create the node right here */
+ tmp = exprCreateFunc(name, ptr, EXPR_NODETYPE_FUNCTION, min, max, refmin, refmax);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ flist->head = tmp;
+ return EXPR_ERROR_NOERROR;
+ }
+
+ /* See if it already exists */
+ cur = flist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->fname);
+
+ if(result == 0)
+ return EXPR_ERROR_ALREADYEXISTS;
+
+ cur = cur->next;
+ }
+
+ /* It did not exist, so add it at the head */
+ tmp = exprCreateFunc(name, ptr, EXPR_NODETYPE_FUNCTION, min, max, refmin, refmax);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ tmp->next = flist->head;
+ flist->head = tmp;
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Add a function node type to the list
+ This works pretty much the same way, except the function
+ pointer is NULL and the node type specifies the function
+ to do. exprEvalNode handles this, instead of calling
+ a function solver. */
+int exprFuncListAddType(exprFuncList *flist, char *name, int type, int min, int max, int refmin, int refmax)
+ {
+ exprFunc *tmp;
+ exprFunc *cur;
+ int result;
+
+ if(flist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Make sure the name is valid */
+ if(!exprValidIdent(name))
+ return EXPR_ERROR_BADIDENTIFIER;
+
+ /* Fix values only if none are negative (negative values mean no limit) */
+
+ /* if both are neg, no min or max number of args */
+ /* if min is neg, max pos, no min number of args but a maximum */
+ /* if min is pos, max neg, there is a min number of args, but no max */
+ /* if both pos, then a min and max limit. We swap to make sure it works
+ right. I.E. Min of 3 and max of 2 would make function unusable */
+ if(min >= 0 && max >= 0)
+ {
+ if(min > max)
+ {
+ result = min;
+ min = max;
+ max = result;
+ }
+ }
+
+ if(refmin >= 0 && refmax >= 0)
+ {
+ if(refmin > refmax)
+ {
+ result = refmin;
+ refmin = max;
+ refmax = result;
+ }
+ }
+
+ if(flist->head == NULL)
+ {
+ /* Create the node right here */
+ tmp = exprCreateFunc(name, NULL, type, min, max, refmin, refmax);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ flist->head = tmp;
+ return EXPR_ERROR_NOERROR;
+ }
+
+ /* See if it already exists */
+ cur = flist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->fname);
+
+ if(result == 0)
+ return EXPR_ERROR_ALREADYEXISTS;
+
+ cur = cur->next;
+ }
+
+ /* It did not exist, so add it at the head */
+ tmp = exprCreateFunc(name, NULL, type, min, max, refmin, refmax);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ tmp->next = flist->head;
+ flist->head = tmp;
+ return EXPR_ERROR_NOERROR;
+ }
+
+
+/* Get the function from a list along with it's min an max data */
+int exprFuncListGet(exprFuncList *flist, char *name, exprFuncType *ptr, int *type, int *min, int *max, int *refmin, int *refmax)
+ {
+ exprFunc *cur;
+ int result;
+
+ if(flist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ if(name == NULL || name[0] == '\0')
+ return EXPR_ERROR_NOTFOUND;
+
+ /* Search for the item */
+ cur = flist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->fname);
+
+ if(result == 0)
+ {
+ /* We found it. */
+ *ptr = cur->fptr;
+ *min = cur->min;
+ *max = cur->max;
+ *refmin = cur->refmin;
+ *refmax = cur->refmax;
+ *type = cur->type;
+
+ /* return now */
+ return EXPR_ERROR_NOERROR;
+ }
+
+ cur = cur->next;
+ }
+
+ /* If we got here, we did not find the item in the list */
+ return EXPR_ERROR_NOTFOUND;
+ }
+
+/* This routine will free the function list */
+int exprFuncListFree(exprFuncList *flist)
+ {
+ /* Make sure it exists, if not it is not error */
+ if(flist == NULL)
+ return EXPR_ERROR_NOERROR;
+
+ /* Free the nodes */
+ exprFuncListFreeData(flist->head);
+
+ /* Free the container */
+ exprFreeMem(flist);
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* This routine will clear the function list */
+int exprFuncListClear(exprFuncList *flist)
+ {
+ if(flist == NULL)
+ return EXPR_ERROR_NOERROR;
+
+ /* Free the nodes only */
+ if(flist->head)
+ {
+ exprFuncListFreeData(flist->head);
+
+ flist->head = NULL;
+ }
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* This routine will free any child nodes, and then free itself */
+void exprFuncListFreeData(exprFunc *func)
+ {
+ exprFunc *next;
+
+ while(func)
+ {
+ /* Remember the next item */
+ next = func->next;
+
+ /* Free name */
+ exprFreeMem(func->fname);
+
+ /* Free ourself */
+ exprFreeMem(func);
+
+ func = next;
+ }
+ }
+
+/* This routine will create the function object */
+exprFunc *exprCreateFunc(char *name, exprFuncType ptr, int type, int min, int max, int refmin, int refmax)
+ {
+ exprFunc *tmp;
+ char *vtmp;
+
+ /* We already checked the name in exprFuncListAdd */
+
+ /* Create it */
+ tmp = exprAllocMem(sizeof(exprFunc));
+ if(tmp == NULL)
+ return NULL;
+
+ /* Allocate space for the name */
+ vtmp = exprAllocMem(strlen(name) + 1);
+
+ if(vtmp == NULL)
+ {
+ exprFreeMem(tmp);
+ return NULL;
+ }
+
+ /* Copy the data over */
+ strcpy(vtmp, name);
+ tmp->fname = vtmp;
+ tmp->fptr = ptr;
+ tmp->min = min;
+ tmp->max = max;
+ tmp->refmin = refmin;
+ tmp->refmax = refmax;
+ tmp->type = type;
+
+ return tmp;
+ }
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprilfs.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprilfs.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprilfs.h Tue Nov 13 15:23:26 2007
@@ -1,1064 +1,1064 @@
-/*
- File: exprilfs.h
- Auth: Brian Allen Vanderburg II
- Date: Tuesday, February 28, 2006
- Desc: Inline Function Solvers for exprEvalNode
-
- This file is part of ExprEval.
-*/
-
-/*
- This is here to help prevent expreval.c from getting
- too crowded.
-
- Provided variables:
- obj: expression object point
- nodes: function node with paramters
- d1, d2: variables
- err: error
- val: value pointer for resuld
- pos: integer
-
- Also EXPR_RESET_ERR() and EXPR_CHECK_ERR()
-
- The chunks below are included inside a statement that looks like this:
-
- switch(nodes->data.function.type)
- {
- #include "exprilfs.h"
-
- default:
- {
- return EXPR_ERROR_UNKNOWN;
- }
- }
-*/
-
-
-
-/* abs */
-case EXPR_NODEFUNC_ABS:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- if(d1 >= 0)
- *val = d1;
- else
- *val = -d1;
- }
- else
- return err;
-
- break;
- }
-
-/* mod */
-case EXPR_NODEFUNC_MOD:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = fmod(d1, d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* ipart */
-case EXPR_NODEFUNC_IPART:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- modf(d1, val);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* fpart */
-case EXPR_NODEFUNC_FPART:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = modf(d1, &d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* min */
-case EXPR_NODEFUNC_MIN:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- for(pos = 1; pos < nodes->data.function.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d2);
- if(!err)
- {
- if(d2 < d1)
- d1 = d2;
- }
- else
- return err;
- }
- }
- else
- return err;
-
- *val = d1;
-
- break;
- }
-
-/* max */
-case EXPR_NODEFUNC_MAX:
- {
- int pos;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- for(pos = 1; pos < nodes->data.function.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d2);
- if(!err)
- {
- if(d2 > d1)
- d1 = d2;
- }
- else
- return err;
- }
- }
- else
- return err;
-
- *val = d1;
-
- break;
- }
-
-/* pow */
-case EXPR_NODEFUNC_POW:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = pow(d1, d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* sqrt */
-case EXPR_NODEFUNC_SQRT:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = sqrt(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* sin */
-case EXPR_NODEFUNC_SIN:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = sin(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* sinh */
-case EXPR_NODEFUNC_SINH:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = sinh(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* asin */
-case EXPR_NODEFUNC_ASIN:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = asin(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* cos */
-case EXPR_NODEFUNC_COS:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = cos(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* cosh */
-case EXPR_NODEFUNC_COSH:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = cosh(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* acos */
-case EXPR_NODEFUNC_ACOS:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = acos(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* tan */
-case EXPR_NODEFUNC_TAN:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = tan(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* tanh */
-case EXPR_NODEFUNC_TANH:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = tanh(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* atan */
-case EXPR_NODEFUNC_ATAN:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = atan(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* atan2 */
-case EXPR_NODEFUNC_ATAN2:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = atan2(d1, d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* log */
-case EXPR_NODEFUNC_LOG:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = log10(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* pow10 */
-case EXPR_NODEFUNC_POW10:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = pow(10.0, d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* ln */
-case EXPR_NODEFUNC_LN:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = log(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* exp */
-case EXPR_NODEFUNC_EXP:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = exp(d1);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-case EXPR_NODEFUNC_LOGN:
- {
- EXPRTYPE l1, l2;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- l1 = log(d1);
- EXPR_CHECK_ERR();
- l2 = log(d2);
- EXPR_CHECK_ERR();
-
-
- if(l2 == 0.0)
- {
-#if(EXPR_ERROR_LEVEL >= EXPR_ERROR_LEVEL_CHECK)
- return EXPR_ERROR_OUTOFRANGE;
-#else
- *val = 0.0;
- return EXPR_ERROR_NOERROR;
-#endif
- }
-
- *val = l1 / l2;
- }
- else
- return err;
-
- break;
- }
-
-/* ceil */
-case EXPR_NODEFUNC_CEIL:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- *val = ceil(d1);
- }
- else
- return err;
-
- break;
- }
-
-/* floor */
-case EXPR_NODEFUNC_FLOOR:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- *val = floor(d1);
- }
- else
- return err;
-
- break;
- }
-
-/* rand */
-case EXPR_NODEFUNC_RAND:
- {
- long a;
-
- /* Perform random routine directly */
- a = ((long)(*(nodes->data.function.refs[0]))) * 214013L + 2531011L;
- *(nodes->data.function.refs[0]) = (EXPRTYPE)a;
-
- *val = (EXPRTYPE)((a >> 16) & 0x7FFF) / (EXPRTYPE)(32768);
- break;
- }
-
-/* random */
-case EXPR_NODEFUNC_RANDOM:
- {
- EXPRTYPE diff, rval;
- long a;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- diff = d2 - d1;
-
- /* Perform random routine directly */
- a = ((long)(*(nodes->data.function.refs[0]))) * 214013L + 2531011L;
- *(nodes->data.function.refs[0]) = (EXPRTYPE)a;
-
- rval = (EXPRTYPE)((a >> 16) & 0x7FFF) / (EXPRTYPE)(32767);
-
- *val = (rval * diff) + d1;
- }
- else
- return err;
-
- break;
- }
-
-/* randomize */
-case EXPR_NODEFUNC_RANDOMIZE:
- {
- static int curcall = 0;
-
- curcall++;
-
- *(nodes->data.function.refs[0]) = (EXPRTYPE)((clock() + 1024 + curcall) * time(NULL));
-
- break;
- }
-
-/* deg */
-case EXPR_NODEFUNC_DEG:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- *val = (180.0 * d1) / M_PI;
- }
- else
- return err;
-
- break;
- }
-
-/* rad */
-case EXPR_NODEFUNC_RAD:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- *val = (M_PI * d1) / 180.0;
- }
- else
- return err;
-
- break;
- }
-
-/* recttopolr */
-case EXPR_NODEFUNC_RECTTOPOLR:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = sqrt((d1 * d1) + (d2 * d2));
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* recttopola */
-case EXPR_NODEFUNC_RECTTOPOLA:
- {
- EXPRTYPE tmp;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- tmp = atan2(d2, d1);
- EXPR_CHECK_ERR();
-
- if(tmp < 0.0)
- *val = tmp = (2.0 * M_PI);
- else
- *val = tmp;
- }
- else
- return err;
-
- break;
- }
-
-/* poltorectx */
-case EXPR_NODEFUNC_POLTORECTX:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = d1 * cos(d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* poltorecty */
-case EXPR_NODEFUNC_POLTORECTY:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- *val = d1 * sin(d2);
- EXPR_CHECK_ERR();
- }
- else
- return err;
-
- break;
- }
-
-/* if */
-case EXPR_NODEFUNC_IF:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- if(d1 != 0.0)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, val);
- if(err)
- return err;
- }
- else
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 2, val);
- if(err)
- return err;
- }
- }
- else
- return err;
-
- break;
- }
-
-/* select */
-case EXPR_NODEFUNC_SELECT:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- if(d1 < 0.0)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, val);
- if(err)
- return err;
- }
- else if(d1 == 0.0)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 2, val);
- if(err)
- return err;
- }
- else
- {
- if(nodes->data.function.nodecount == 3)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 2, val);
- if(err)
- return err;
- }
- else
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 3, val);
- if(err)
- return err;
- }
- }
- }
- else
- return err;
-
- break;
- }
-
-/* equal */
-case EXPR_NODEFUNC_EQUAL:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- *val = (d1 == d2) ? 1.0 : 0.0;
- }
- else
- return err;
-
- break;
- }
-
-/* above */
-case EXPR_NODEFUNC_ABOVE:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- *val = (d1 > d2) ? 1.0 : 0.0;
- }
- else
- return err;
-
- break;
- }
-
-/* below */
-case EXPR_NODEFUNC_BELOW:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- *val = (d1 < d2) ? 1.0 : 0.0;
- }
- else
- return err;
-
- break;
- }
-
-/* avg */
-case EXPR_NODEFUNC_AVG:
- {
- d2 = 0.0;
-
- for(pos = 0; pos < nodes->data.function.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d1);
- if(!err)
- {
- d2 += d1;
- }
- else
- return err;
- }
-
- *val = d2 / (EXPRTYPE)(nodes->data.function.nodecount);
-
- break;
- }
-
-/* clip */
-case EXPR_NODEFUNC_CLIP:
- {
- EXPRTYPE v;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &v);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- if(v < d1)
- *val = d1;
- else if(v > d2)
- *val = d2;
- else
- *val = v;
- }
- else
- return err;
-
- break;
- }
-
-/* clamp */
-case EXPR_NODEFUNC_CLAMP:
- {
- EXPRTYPE v, tmp;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &v);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- EXPR_RESET_ERR();
- tmp = fmod(v - d1, d2 - d1);
- EXPR_CHECK_ERR();
-
- if(tmp < 0.0)
- *val = tmp * d2;
- else
- *val = tmp + d1;
- }
- else
- return err;
-
- break;
- }
-
-/* pntchange */
-case EXPR_NODEFUNC_PNTCHANGE:
- {
- EXPRTYPE n1, n2, pnt;
- EXPRTYPE odiff, ndiff, perc;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 2, &n1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 3, &n2);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 4, &pnt);
-
- if(!err)
- {
- odiff = d2 - d1;
- ndiff = n2 - n1;
-
- if(odiff == 0.0)
- {
- *val = d1;
- return EXPR_ERROR_NOERROR;
- }
-
- perc = (pnt - d1) / odiff;
-
- *val = n1 + (perc * ndiff);
- }
- else
- return err;
-
- break;
- }
-
-/* poly */
-case EXPR_NODEFUNC_POLY:
- {
- EXPRTYPE total, curpow;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- curpow = (EXPRTYPE)(nodes->data.function.nodecount) - 2.0;
- total = 0.0;
-
- for(pos = 1; pos < nodes->data.function.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d2);
- if(err)
- return err;
-
- EXPR_RESET_ERR();
- total = total + (d2 * pow(d1, curpow));
- EXPR_CHECK_ERR();
-
- curpow = curpow - 1.0;
- }
- }
- else
- return err;
-
- *val = total;
- break;
- }
-
-/* and */
-case EXPR_NODEFUNC_AND:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- if(d1 == 0.0 || d2 == 0.0)
- *val = 0.0;
- else
- *val = 1.0;
- }
- else
- return err;
-
- break;
- }
-
-/* or */
-case EXPR_NODEFUNC_OR:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
-
- if(!err)
- {
- if(d1 != 0.0 || d2 != 0.0)
- *val = 1.0;
- else
- *val = 0.0;
- }
- else
- return err;
-
- break;
- }
-
-/* not */
-case EXPR_NODEFUNC_NOT:
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- {
- if(d1 != 0.0)
- *val = 0.0;
- else
- *val = 1.0;
- }
- else
- return err;
-
- break;
- }
-
-/* for */
-case EXPR_NODEFUNC_FOR:
- {
- int pos;
- EXPRTYPE test;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
-
- if(!err)
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &test);
-
- if(!err)
- {
- while(test != 0.0)
- {
- for(pos = 3; pos < nodes->data.function.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, pos, val);
- if(err)
- return err;
- }
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 2, &d1);
- if(err)
- return err;
-
- err = exprEvalNode(obj, nodes->data.function.nodes, 1, &test);
- if(err)
- return err;
- }
- }
- else
- return err;
-
- break;
- }
-
-/* many */
-case EXPR_NODEFUNC_MANY:
- {
- for(pos = 0; pos < nodes->data.function.nodecount; pos++)
- {
- err = exprEvalNode(obj, nodes->data.function.nodes, pos, val);
- if(err)
- return err;
- }
-
- break;
- }
-
+/*
+ File: exprilfs.h
+ Auth: Brian Allen Vanderburg II
+ Date: Tuesday, February 28, 2006
+ Desc: Inline Function Solvers for exprEvalNode
+
+ This file is part of ExprEval.
+*/
+
+/*
+ This is here to help prevent expreval.c from getting
+ too crowded.
+
+ Provided variables:
+ obj: expression object point
+ nodes: function node with paramters
+ d1, d2: variables
+ err: error
+ val: value pointer for resuld
+ pos: integer
+
+ Also EXPR_RESET_ERR() and EXPR_CHECK_ERR()
+
+ The chunks below are included inside a statement that looks like this:
+
+ switch(nodes->data.function.type)
+ {
+ #include "exprilfs.h"
+
+ default:
+ {
+ return EXPR_ERROR_UNKNOWN;
+ }
+ }
+*/
+
+
+
+/* abs */
+case EXPR_NODEFUNC_ABS:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ if(d1 >= 0)
+ *val = d1;
+ else
+ *val = -d1;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* mod */
+case EXPR_NODEFUNC_MOD:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = fmod(d1, d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* ipart */
+case EXPR_NODEFUNC_IPART:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ modf(d1, val);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* fpart */
+case EXPR_NODEFUNC_FPART:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = modf(d1, &d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* min */
+case EXPR_NODEFUNC_MIN:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ for(pos = 1; pos < nodes->data.function.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d2);
+ if(!err)
+ {
+ if(d2 < d1)
+ d1 = d2;
+ }
+ else
+ return err;
+ }
+ }
+ else
+ return err;
+
+ *val = d1;
+
+ break;
+ }
+
+/* max */
+case EXPR_NODEFUNC_MAX:
+ {
+ int pos;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ for(pos = 1; pos < nodes->data.function.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d2);
+ if(!err)
+ {
+ if(d2 > d1)
+ d1 = d2;
+ }
+ else
+ return err;
+ }
+ }
+ else
+ return err;
+
+ *val = d1;
+
+ break;
+ }
+
+/* pow */
+case EXPR_NODEFUNC_POW:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = pow(d1, d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* sqrt */
+case EXPR_NODEFUNC_SQRT:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = sqrt(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* sin */
+case EXPR_NODEFUNC_SIN:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = sin(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* sinh */
+case EXPR_NODEFUNC_SINH:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = sinh(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* asin */
+case EXPR_NODEFUNC_ASIN:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = asin(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* cos */
+case EXPR_NODEFUNC_COS:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = cos(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* cosh */
+case EXPR_NODEFUNC_COSH:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = cosh(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* acos */
+case EXPR_NODEFUNC_ACOS:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = acos(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* tan */
+case EXPR_NODEFUNC_TAN:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = tan(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* tanh */
+case EXPR_NODEFUNC_TANH:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = tanh(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* atan */
+case EXPR_NODEFUNC_ATAN:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = atan(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* atan2 */
+case EXPR_NODEFUNC_ATAN2:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = atan2(d1, d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* log */
+case EXPR_NODEFUNC_LOG:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = log10(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* pow10 */
+case EXPR_NODEFUNC_POW10:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = pow(10.0, d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* ln */
+case EXPR_NODEFUNC_LN:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = log(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* exp */
+case EXPR_NODEFUNC_EXP:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = exp(d1);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+case EXPR_NODEFUNC_LOGN:
+ {
+ EXPRTYPE l1, l2;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ l1 = log(d1);
+ EXPR_CHECK_ERR();
+ l2 = log(d2);
+ EXPR_CHECK_ERR();
+
+
+ if(l2 == 0.0)
+ {
+#if(EXPR_ERROR_LEVEL >= EXPR_ERROR_LEVEL_CHECK)
+ return EXPR_ERROR_OUTOFRANGE;
+#else
+ *val = 0.0;
+ return EXPR_ERROR_NOERROR;
+#endif
+ }
+
+ *val = l1 / l2;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* ceil */
+case EXPR_NODEFUNC_CEIL:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ *val = ceil(d1);
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* floor */
+case EXPR_NODEFUNC_FLOOR:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ *val = floor(d1);
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* rand */
+case EXPR_NODEFUNC_RAND:
+ {
+ long a;
+
+ /* Perform random routine directly */
+ a = ((long)(*(nodes->data.function.refs[0]))) * 214013L + 2531011L;
+ *(nodes->data.function.refs[0]) = (EXPRTYPE)a;
+
+ *val = (EXPRTYPE)((a >> 16) & 0x7FFF) / (EXPRTYPE)(32768);
+ break;
+ }
+
+/* random */
+case EXPR_NODEFUNC_RANDOM:
+ {
+ EXPRTYPE diff, rval;
+ long a;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ diff = d2 - d1;
+
+ /* Perform random routine directly */
+ a = ((long)(*(nodes->data.function.refs[0]))) * 214013L + 2531011L;
+ *(nodes->data.function.refs[0]) = (EXPRTYPE)a;
+
+ rval = (EXPRTYPE)((a >> 16) & 0x7FFF) / (EXPRTYPE)(32767);
+
+ *val = (rval * diff) + d1;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* randomize */
+case EXPR_NODEFUNC_RANDOMIZE:
+ {
+ static int curcall = 0;
+
+ curcall++;
+
+ *(nodes->data.function.refs[0]) = (EXPRTYPE)((clock() + 1024 + curcall) * time(NULL));
+
+ break;
+ }
+
+/* deg */
+case EXPR_NODEFUNC_DEG:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ *val = (180.0 * d1) / M_PI;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* rad */
+case EXPR_NODEFUNC_RAD:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ *val = (M_PI * d1) / 180.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* recttopolr */
+case EXPR_NODEFUNC_RECTTOPOLR:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = sqrt((d1 * d1) + (d2 * d2));
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* recttopola */
+case EXPR_NODEFUNC_RECTTOPOLA:
+ {
+ EXPRTYPE tmp;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ tmp = atan2(d2, d1);
+ EXPR_CHECK_ERR();
+
+ if(tmp < 0.0)
+ *val = tmp = (2.0 * M_PI);
+ else
+ *val = tmp;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* poltorectx */
+case EXPR_NODEFUNC_POLTORECTX:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = d1 * cos(d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* poltorecty */
+case EXPR_NODEFUNC_POLTORECTY:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ *val = d1 * sin(d2);
+ EXPR_CHECK_ERR();
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* if */
+case EXPR_NODEFUNC_IF:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ if(d1 != 0.0)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, val);
+ if(err)
+ return err;
+ }
+ else
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 2, val);
+ if(err)
+ return err;
+ }
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* select */
+case EXPR_NODEFUNC_SELECT:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ if(d1 < 0.0)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, val);
+ if(err)
+ return err;
+ }
+ else if(d1 == 0.0)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 2, val);
+ if(err)
+ return err;
+ }
+ else
+ {
+ if(nodes->data.function.nodecount == 3)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 2, val);
+ if(err)
+ return err;
+ }
+ else
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 3, val);
+ if(err)
+ return err;
+ }
+ }
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* equal */
+case EXPR_NODEFUNC_EQUAL:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ *val = (d1 == d2) ? 1.0 : 0.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* above */
+case EXPR_NODEFUNC_ABOVE:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ *val = (d1 > d2) ? 1.0 : 0.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* below */
+case EXPR_NODEFUNC_BELOW:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ *val = (d1 < d2) ? 1.0 : 0.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* avg */
+case EXPR_NODEFUNC_AVG:
+ {
+ d2 = 0.0;
+
+ for(pos = 0; pos < nodes->data.function.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d1);
+ if(!err)
+ {
+ d2 += d1;
+ }
+ else
+ return err;
+ }
+
+ *val = d2 / (EXPRTYPE)(nodes->data.function.nodecount);
+
+ break;
+ }
+
+/* clip */
+case EXPR_NODEFUNC_CLIP:
+ {
+ EXPRTYPE v;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &v);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ if(v < d1)
+ *val = d1;
+ else if(v > d2)
+ *val = d2;
+ else
+ *val = v;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* clamp */
+case EXPR_NODEFUNC_CLAMP:
+ {
+ EXPRTYPE v, tmp;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &v);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ EXPR_RESET_ERR();
+ tmp = fmod(v - d1, d2 - d1);
+ EXPR_CHECK_ERR();
+
+ if(tmp < 0.0)
+ *val = tmp * d2;
+ else
+ *val = tmp + d1;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* pntchange */
+case EXPR_NODEFUNC_PNTCHANGE:
+ {
+ EXPRTYPE n1, n2, pnt;
+ EXPRTYPE odiff, ndiff, perc;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 2, &n1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 3, &n2);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 4, &pnt);
+
+ if(!err)
+ {
+ odiff = d2 - d1;
+ ndiff = n2 - n1;
+
+ if(odiff == 0.0)
+ {
+ *val = d1;
+ return EXPR_ERROR_NOERROR;
+ }
+
+ perc = (pnt - d1) / odiff;
+
+ *val = n1 + (perc * ndiff);
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* poly */
+case EXPR_NODEFUNC_POLY:
+ {
+ EXPRTYPE total, curpow;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ curpow = (EXPRTYPE)(nodes->data.function.nodecount) - 2.0;
+ total = 0.0;
+
+ for(pos = 1; pos < nodes->data.function.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, pos, &d2);
+ if(err)
+ return err;
+
+ EXPR_RESET_ERR();
+ total = total + (d2 * pow(d1, curpow));
+ EXPR_CHECK_ERR();
+
+ curpow = curpow - 1.0;
+ }
+ }
+ else
+ return err;
+
+ *val = total;
+ break;
+ }
+
+/* and */
+case EXPR_NODEFUNC_AND:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ if(d1 == 0.0 || d2 == 0.0)
+ *val = 0.0;
+ else
+ *val = 1.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* or */
+case EXPR_NODEFUNC_OR:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &d2);
+
+ if(!err)
+ {
+ if(d1 != 0.0 || d2 != 0.0)
+ *val = 1.0;
+ else
+ *val = 0.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* not */
+case EXPR_NODEFUNC_NOT:
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ {
+ if(d1 != 0.0)
+ *val = 0.0;
+ else
+ *val = 1.0;
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* for */
+case EXPR_NODEFUNC_FOR:
+ {
+ int pos;
+ EXPRTYPE test;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 0, &d1);
+
+ if(!err)
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &test);
+
+ if(!err)
+ {
+ while(test != 0.0)
+ {
+ for(pos = 3; pos < nodes->data.function.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, pos, val);
+ if(err)
+ return err;
+ }
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 2, &d1);
+ if(err)
+ return err;
+
+ err = exprEvalNode(obj, nodes->data.function.nodes, 1, &test);
+ if(err)
+ return err;
+ }
+ }
+ else
+ return err;
+
+ break;
+ }
+
+/* many */
+case EXPR_NODEFUNC_MANY:
+ {
+ for(pos = 0; pos < nodes->data.function.nodecount; pos++)
+ {
+ err = exprEvalNode(obj, nodes->data.function.nodes, pos, val);
+ if(err)
+ return err;
+ }
+
+ break;
+ }
+
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprincl.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprincl.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprincl.h Tue Nov 13 15:23:26 2007
@@ -1,112 +1,112 @@
-/*
- File: exprincl.h
- Auth: Brian Allen Vanderburg II
- Date: Thursday, April 24, 2003
- Desc: Includes, macros, etc needed by this library
-
- This file is part of ExprEval.
-*/
-
-#ifndef __BAVII_EXPRINCL_H
-#define __BAVII_EXPRINCL_H
-
-
-/* Includes and macros and whatnot for building the library */
-
-#ifdef _MSC_VER
-#if (_MSC_VER >= 1400) // VC8+
-#ifndef _CRT_SECURE_NO_DEPRECATE
-#define _CRT_SECURE_NO_DEPRECATE
-#endif
-#ifndef _CRT_NONSTDC_NO_DEPRECATE
-#define _CRT_NONSTDC_NO_DEPRECATE
-#endif
-#endif // VC8+
-#endif
-
-/* Memory routines. memory.h for VC++, mem.h for BC++ */
-#ifdef __TURBOC__
-#include <mem.h>
-#else
-#include <memory.h>
-#endif
-
-/* Memory allocation */
-#include <malloc.h>
-
-/* String routines */
-#include <string.h>
-
-/* Character manipulation routines */
-#include <ctype.h>
-
-/* Standard routines */
-#include <stdlib.h>
-
-/* Math routines */
-#include <math.h>
-
-/* Time */
-#include <time.h>
-
-
-/* Math constants. VC++ does not seem to have these */
-#ifndef M_E
-#define M_E 2.7182818284590452354
-#endif
-
-#ifndef M_LOG2E
-#define M_LOG2E 1.4426950408889634074
-#endif
-
-#ifndef M_LOG10E
-#define M_LOG10E 0.43429448190325182765
-#endif
-
-#ifndef M_LN2
-#define M_LN2 0.69314718055994530942
-#endif
-
-#ifndef M_LN10
-#define M_LN10 2.30258509299404568402
-#endif
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#ifndef M_PI_2
-#define M_PI_2 1.57079632679489661923
-#endif
-
-#ifndef M_PI_4
-#define M_PI_4 0.78539816339744830962
-#endif
-
-#ifndef M_1_PI
-#define M_1_PI 0.31830988618379067154
-#endif
-
-#ifndef M_2_PI
-#define M_2_PI 0.63661977236758134308
-#endif
-
-#ifndef M_1_SQRTPI
-#define M_1_SQRTPI 0.56418958354776
-#endif
-
-#ifndef M_2_SQRTPI
-#define M_2_SQRTPI 1.12837916709551257390
-#endif
-
-#ifndef M_SQRT2
-#define M_SQRT2 1.41421356237309504880
-#endif
-
-#ifndef M_1_SQRT2
-#define M_1_SQRT2 0.70710678118654752440
-#endif
-
-
-
-#endif /* __BAVII_EXPRINCL_H */
+/*
+ File: exprincl.h
+ Auth: Brian Allen Vanderburg II
+ Date: Thursday, April 24, 2003
+ Desc: Includes, macros, etc needed by this library
+
+ This file is part of ExprEval.
+*/
+
+#ifndef __BAVII_EXPRINCL_H
+#define __BAVII_EXPRINCL_H
+
+
+/* Includes and macros and whatnot for building the library */
+
+#ifdef _MSC_VER
+#if (_MSC_VER >= 1400) // VC8+
+#ifndef _CRT_SECURE_NO_DEPRECATE
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+#ifndef _CRT_NONSTDC_NO_DEPRECATE
+#define _CRT_NONSTDC_NO_DEPRECATE
+#endif
+#endif // VC8+
+#endif
+
+/* Memory routines. memory.h for VC++, mem.h for BC++ */
+#ifdef __TURBOC__
+#include <mem.h>
+#else
+#include <memory.h>
+#endif
+
+/* Memory allocation */
+#include <malloc.h>
+
+/* String routines */
+#include <string.h>
+
+/* Character manipulation routines */
+#include <ctype.h>
+
+/* Standard routines */
+#include <stdlib.h>
+
+/* Math routines */
+#include <math.h>
+
+/* Time */
+#include <time.h>
+
+
+/* Math constants. VC++ does not seem to have these */
+#ifndef M_E
+#define M_E 2.7182818284590452354
+#endif
+
+#ifndef M_LOG2E
+#define M_LOG2E 1.4426950408889634074
+#endif
+
+#ifndef M_LOG10E
+#define M_LOG10E 0.43429448190325182765
+#endif
+
+#ifndef M_LN2
+#define M_LN2 0.69314718055994530942
+#endif
+
+#ifndef M_LN10
+#define M_LN10 2.30258509299404568402
+#endif
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+#ifndef M_PI_2
+#define M_PI_2 1.57079632679489661923
+#endif
+
+#ifndef M_PI_4
+#define M_PI_4 0.78539816339744830962
+#endif
+
+#ifndef M_1_PI
+#define M_1_PI 0.31830988618379067154
+#endif
+
+#ifndef M_2_PI
+#define M_2_PI 0.63661977236758134308
+#endif
+
+#ifndef M_1_SQRTPI
+#define M_1_SQRTPI 0.56418958354776
+#endif
+
+#ifndef M_2_SQRTPI
+#define M_2_SQRTPI 1.12837916709551257390
+#endif
+
+#ifndef M_SQRT2
+#define M_SQRT2 1.41421356237309504880
+#endif
+
+#ifndef M_1_SQRT2
+#define M_1_SQRT2 0.70710678118654752440
+#endif
+
+
+
+#endif /* __BAVII_EXPRINCL_H */
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprinit.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprinit.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprinit.c Tue Nov 13 15:23:26 2007
@@ -1,115 +1,115 @@
-/*
- File: exprinit.c
- Auth: Brian Allen Vanderburg II
- Date: Thursday, May 1, 2003
- Desc: Extra functions and routines for ExprEval
-
- This file is part of ExprEval.
-*/
-
-/* Include files */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-
-
-/* Macro for adding a function node type */
-#define EXPR_ADDFUNC_TYPE(name, type, argmin, argmax, refmin, refmax) \
-err = exprFuncListAddType(flist, name, type, argmin, argmax, refmin, refmax); \
-if(err != EXPR_ERROR_NOERROR) \
- return err;
-
-/* Macro for adding a constant */
-#define EXPR_ADDCONST(name, val) \
-err = exprValListAdd(vlist, name, val); \
-if(err != EXPR_ERROR_NOERROR) \
- return err;
-
-/* Call this function to initialize these functions into a function list */
-int exprFuncListInit(exprFuncList *flist)
- {
- int err;
-
- if(flist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- EXPR_ADDFUNC_TYPE("abs", EXPR_NODEFUNC_ABS, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("mod", EXPR_NODEFUNC_MOD, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("ipart", EXPR_NODEFUNC_IPART, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("fpart", EXPR_NODEFUNC_FPART, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("min", EXPR_NODEFUNC_MIN, 1, -1, 0, 0);
- EXPR_ADDFUNC_TYPE("max", EXPR_NODEFUNC_MAX, 1, -1, 0, 0);
- EXPR_ADDFUNC_TYPE("pow", EXPR_NODEFUNC_POW, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("sqrt", EXPR_NODEFUNC_SQRT, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("sin", EXPR_NODEFUNC_SIN, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("sinh", EXPR_NODEFUNC_SINH, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("asin", EXPR_NODEFUNC_ASIN, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("cos", EXPR_NODEFUNC_COS, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("cosh", EXPR_NODEFUNC_COSH, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("acos", EXPR_NODEFUNC_ACOS, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("tan", EXPR_NODEFUNC_TAN, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("tanh", EXPR_NODEFUNC_TANH, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("atan", EXPR_NODEFUNC_ATAN, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("atan2", EXPR_NODEFUNC_ATAN2, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("log", EXPR_NODEFUNC_LOG, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("pow10", EXPR_NODEFUNC_POW10, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("ln", EXPR_NODEFUNC_LN, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("exp", EXPR_NODEFUNC_EXP, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("logn", EXPR_NODEFUNC_LOGN, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("ceil", EXPR_NODEFUNC_CEIL, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("floor", EXPR_NODEFUNC_FLOOR, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("rand", EXPR_NODEFUNC_RAND, 0, 0, 1, 1);
- EXPR_ADDFUNC_TYPE("random", EXPR_NODEFUNC_RANDOM, 2, 2, 1, 1);
- EXPR_ADDFUNC_TYPE("randomize", EXPR_NODEFUNC_RANDOMIZE, 0, 0, 1, 1);
- EXPR_ADDFUNC_TYPE("deg", EXPR_NODEFUNC_DEG, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("rad", EXPR_NODEFUNC_RAD, 1, 1, 0, 0);
- EXPR_ADDFUNC_TYPE("recttopolr", EXPR_NODEFUNC_RECTTOPOLR, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("recttopola", EXPR_NODEFUNC_RECTTOPOLA, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("poltorectx", EXPR_NODEFUNC_POLTORECTX, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("poltorecty", EXPR_NODEFUNC_POLTORECTY, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("if", EXPR_NODEFUNC_IF, 3, 3, 0, 0);
- EXPR_ADDFUNC_TYPE("select", EXPR_NODEFUNC_SELECT, 3, 4, 0, 0);
- EXPR_ADDFUNC_TYPE("equal", EXPR_NODEFUNC_EQUAL, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("above", EXPR_NODEFUNC_ABOVE, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("below", EXPR_NODEFUNC_BELOW, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("avg", EXPR_NODEFUNC_AVG, 1, -1, 0, 0);
- EXPR_ADDFUNC_TYPE("clip", EXPR_NODEFUNC_CLIP, 3, 3, 0, 0);
- EXPR_ADDFUNC_TYPE("clamp", EXPR_NODEFUNC_CLAMP, 3, 3, 0, 0);
- EXPR_ADDFUNC_TYPE("pntchange", EXPR_NODEFUNC_PNTCHANGE, 5, 5, 0, 0);
- EXPR_ADDFUNC_TYPE("poly", EXPR_NODEFUNC_POLY, 2, -1, 0, 0);
- EXPR_ADDFUNC_TYPE("and", EXPR_NODEFUNC_AND, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("or", EXPR_NODEFUNC_OR, 2, 2, 0, 0);
- EXPR_ADDFUNC_TYPE("not", EXPR_NODEFUNC_NOT, 1 ,1, 0, 0);
- EXPR_ADDFUNC_TYPE("for", EXPR_NODEFUNC_FOR, 4, -1, 0, 0);
- EXPR_ADDFUNC_TYPE("many", EXPR_NODEFUNC_MANY, 1, -1, 0, 0);
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Call this function to initialize some constants into a value list */
-int exprValListInit(exprValList *vlist)
- {
- int err;
-
- if(vlist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- EXPR_ADDCONST("M_E", M_E);
- EXPR_ADDCONST("M_LOG2E", M_LOG2E);
- EXPR_ADDCONST("M_LOG10E", M_LOG10E);
- EXPR_ADDCONST("M_LN2", M_LN2);
- EXPR_ADDCONST("M_LN10", M_LN10);
- EXPR_ADDCONST("M_PI", M_PI);
- EXPR_ADDCONST("M_PI_2", M_PI_2);
- EXPR_ADDCONST("M_PI_4", M_PI_4);
- EXPR_ADDCONST("M_1_PI", M_1_PI);
- EXPR_ADDCONST("M_2_PI", M_2_PI);
- EXPR_ADDCONST("M_1_SQRTPI", M_1_SQRTPI);
- EXPR_ADDCONST("M_2_SQRTPI", M_2_SQRTPI);
- EXPR_ADDCONST("M_SQRT2", M_SQRT2);
- EXPR_ADDCONST("M_1_SQRT2", M_1_SQRT2);
-
- return EXPR_ERROR_NOERROR;
- }
-
-
+/*
+ File: exprinit.c
+ Auth: Brian Allen Vanderburg II
+ Date: Thursday, May 1, 2003
+ Desc: Extra functions and routines for ExprEval
+
+ This file is part of ExprEval.
+*/
+
+/* Include files */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+
+
+/* Macro for adding a function node type */
+#define EXPR_ADDFUNC_TYPE(name, type, argmin, argmax, refmin, refmax) \
+err = exprFuncListAddType(flist, name, type, argmin, argmax, refmin, refmax); \
+if(err != EXPR_ERROR_NOERROR) \
+ return err;
+
+/* Macro for adding a constant */
+#define EXPR_ADDCONST(name, val) \
+err = exprValListAdd(vlist, name, val); \
+if(err != EXPR_ERROR_NOERROR) \
+ return err;
+
+/* Call this function to initialize these functions into a function list */
+int exprFuncListInit(exprFuncList *flist)
+ {
+ int err;
+
+ if(flist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ EXPR_ADDFUNC_TYPE("abs", EXPR_NODEFUNC_ABS, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("mod", EXPR_NODEFUNC_MOD, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("ipart", EXPR_NODEFUNC_IPART, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("fpart", EXPR_NODEFUNC_FPART, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("min", EXPR_NODEFUNC_MIN, 1, -1, 0, 0);
+ EXPR_ADDFUNC_TYPE("max", EXPR_NODEFUNC_MAX, 1, -1, 0, 0);
+ EXPR_ADDFUNC_TYPE("pow", EXPR_NODEFUNC_POW, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("sqrt", EXPR_NODEFUNC_SQRT, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("sin", EXPR_NODEFUNC_SIN, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("sinh", EXPR_NODEFUNC_SINH, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("asin", EXPR_NODEFUNC_ASIN, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("cos", EXPR_NODEFUNC_COS, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("cosh", EXPR_NODEFUNC_COSH, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("acos", EXPR_NODEFUNC_ACOS, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("tan", EXPR_NODEFUNC_TAN, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("tanh", EXPR_NODEFUNC_TANH, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("atan", EXPR_NODEFUNC_ATAN, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("atan2", EXPR_NODEFUNC_ATAN2, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("log", EXPR_NODEFUNC_LOG, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("pow10", EXPR_NODEFUNC_POW10, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("ln", EXPR_NODEFUNC_LN, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("exp", EXPR_NODEFUNC_EXP, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("logn", EXPR_NODEFUNC_LOGN, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("ceil", EXPR_NODEFUNC_CEIL, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("floor", EXPR_NODEFUNC_FLOOR, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("rand", EXPR_NODEFUNC_RAND, 0, 0, 1, 1);
+ EXPR_ADDFUNC_TYPE("random", EXPR_NODEFUNC_RANDOM, 2, 2, 1, 1);
+ EXPR_ADDFUNC_TYPE("randomize", EXPR_NODEFUNC_RANDOMIZE, 0, 0, 1, 1);
+ EXPR_ADDFUNC_TYPE("deg", EXPR_NODEFUNC_DEG, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("rad", EXPR_NODEFUNC_RAD, 1, 1, 0, 0);
+ EXPR_ADDFUNC_TYPE("recttopolr", EXPR_NODEFUNC_RECTTOPOLR, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("recttopola", EXPR_NODEFUNC_RECTTOPOLA, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("poltorectx", EXPR_NODEFUNC_POLTORECTX, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("poltorecty", EXPR_NODEFUNC_POLTORECTY, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("if", EXPR_NODEFUNC_IF, 3, 3, 0, 0);
+ EXPR_ADDFUNC_TYPE("select", EXPR_NODEFUNC_SELECT, 3, 4, 0, 0);
+ EXPR_ADDFUNC_TYPE("equal", EXPR_NODEFUNC_EQUAL, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("above", EXPR_NODEFUNC_ABOVE, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("below", EXPR_NODEFUNC_BELOW, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("avg", EXPR_NODEFUNC_AVG, 1, -1, 0, 0);
+ EXPR_ADDFUNC_TYPE("clip", EXPR_NODEFUNC_CLIP, 3, 3, 0, 0);
+ EXPR_ADDFUNC_TYPE("clamp", EXPR_NODEFUNC_CLAMP, 3, 3, 0, 0);
+ EXPR_ADDFUNC_TYPE("pntchange", EXPR_NODEFUNC_PNTCHANGE, 5, 5, 0, 0);
+ EXPR_ADDFUNC_TYPE("poly", EXPR_NODEFUNC_POLY, 2, -1, 0, 0);
+ EXPR_ADDFUNC_TYPE("and", EXPR_NODEFUNC_AND, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("or", EXPR_NODEFUNC_OR, 2, 2, 0, 0);
+ EXPR_ADDFUNC_TYPE("not", EXPR_NODEFUNC_NOT, 1 ,1, 0, 0);
+ EXPR_ADDFUNC_TYPE("for", EXPR_NODEFUNC_FOR, 4, -1, 0, 0);
+ EXPR_ADDFUNC_TYPE("many", EXPR_NODEFUNC_MANY, 1, -1, 0, 0);
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Call this function to initialize some constants into a value list */
+int exprValListInit(exprValList *vlist)
+ {
+ int err;
+
+ if(vlist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ EXPR_ADDCONST("M_E", M_E);
+ EXPR_ADDCONST("M_LOG2E", M_LOG2E);
+ EXPR_ADDCONST("M_LOG10E", M_LOG10E);
+ EXPR_ADDCONST("M_LN2", M_LN2);
+ EXPR_ADDCONST("M_LN10", M_LN10);
+ EXPR_ADDCONST("M_PI", M_PI);
+ EXPR_ADDCONST("M_PI_2", M_PI_2);
+ EXPR_ADDCONST("M_PI_4", M_PI_4);
+ EXPR_ADDCONST("M_1_PI", M_1_PI);
+ EXPR_ADDCONST("M_2_PI", M_2_PI);
+ EXPR_ADDCONST("M_1_SQRTPI", M_1_SQRTPI);
+ EXPR_ADDCONST("M_2_SQRTPI", M_2_SQRTPI);
+ EXPR_ADDCONST("M_SQRT2", M_SQRT2);
+ EXPR_ADDCONST("M_1_SQRT2", M_1_SQRT2);
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprmem.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprmem.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprmem.c Tue Nov 13 15:23:26 2007
@@ -1,39 +1,39 @@
-/*
- File: exprmem.c
- Auth: Brian Allen Vanderburg II
- Date: Wednesday, April 30, 2003
- Desc: Memory functions for ExprEval
-
- This file is part of ExprEval.
-*/
-
-/* Includes */
-#include "exprincl.h"
-
-#include "exprmem.h"
-
-/* Allocate memory and zero it */
-void* exprAllocMem(size_t size)
- {
- void *data = malloc(size);
-
- if(data)
- {
- memset(data, 0, size);
- }
-
- return data;
- }
-
-/* Free memory */
-void exprFreeMem(void *data)
- {
- if(data)
- free(data);
- }
-
-/* Allocate a list of nodes */
-exprNode *exprAllocNodes(size_t count)
- {
- return exprAllocMem(count * sizeof(exprNode));
- }
+/*
+ File: exprmem.c
+ Auth: Brian Allen Vanderburg II
+ Date: Wednesday, April 30, 2003
+ Desc: Memory functions for ExprEval
+
+ This file is part of ExprEval.
+*/
+
+/* Includes */
+#include "exprincl.h"
+
+#include "exprmem.h"
+
+/* Allocate memory and zero it */
+void* exprAllocMem(size_t size)
+ {
+ void *data = malloc(size);
+
+ if(data)
+ {
+ memset(data, 0, size);
+ }
+
+ return data;
+ }
+
+/* Free memory */
+void exprFreeMem(void *data)
+ {
+ if(data)
+ free(data);
+ }
+
+/* Allocate a list of nodes */
+exprNode *exprAllocNodes(size_t count)
+ {
+ return exprAllocMem(count * sizeof(exprNode));
+ }
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprmem.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprmem.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprmem.h Tue Nov 13 15:23:26 2007
@@ -1,21 +1,21 @@
-/*
- File: exprmem.h
- Auth: Brian Allen Vanderburg II
- Date: Wednesday, April 30, 2003
- Desc: Memory functions for ExprEval
-
- This file is part of ExprEval.
-*/
-
-#ifndef __BAVII_EXPRMEM_H
-#define __BAVII_EXPRMEM_H
-
-/* Needed for exprNode */
-#include "exprpriv.h"
-
-void* exprAllocMem(size_t size);
-void exprFreeMem(void *data);
-exprNode *exprAllocNodes(size_t count);
-
-
-#endif /* __BAVII_EXPRMEM_H */
+/*
+ File: exprmem.h
+ Auth: Brian Allen Vanderburg II
+ Date: Wednesday, April 30, 2003
+ Desc: Memory functions for ExprEval
+
+ This file is part of ExprEval.
+*/
+
+#ifndef __BAVII_EXPRMEM_H
+#define __BAVII_EXPRMEM_H
+
+/* Needed for exprNode */
+#include "exprpriv.h"
+
+void* exprAllocMem(size_t size);
+void exprFreeMem(void *data);
+exprNode *exprAllocNodes(size_t count);
+
+
+#endif /* __BAVII_EXPRMEM_H */
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprobj.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprobj.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprobj.c Tue Nov 13 15:23:26 2007
@@ -1,237 +1,237 @@
-/*
- File: exprobj.c
- Auth: Brian Allen Vanderburg II
- Date: Tuesday, April 29, 2003
- Desc: Functions for the exprObj type
-
- This file is part of ExprEval.
-*/
-
-/* Includes */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-#include "exprmem.h"
-
-/* Internal functions */
-static void exprFreeNodeData(exprNode *node);
-
-
-/* Function to create an expression object */
-int exprCreate(exprObj **obj, exprFuncList *flist, exprValList *vlist, exprValList *clist,
- exprBreakFuncType breaker, void *userdata)
- {
- exprObj *tmp;
-
- /* Allocate memory for the object */
- tmp = exprAllocMem(sizeof(exprObj));
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
-
- /* Assign data */
- tmp->flist = flist;
- tmp->vlist = vlist;
- tmp->clist = clist;
- tmp->breakerfunc = breaker;
- tmp->userdata = userdata;
- tmp->breakcount = 100000; /* Default breaker count setting */
- tmp->breakcur = 0;
-
- /* Update pointer */
- *obj = tmp;
-
- return EXPR_ERROR_NOERROR;
- }
-
-
-/* Free the expression */
-int exprFree(exprObj *obj)
- {
- if(obj == NULL)
- return EXPR_ERROR_NOERROR;
-
- /* First free the node data */
- exprFreeNodeData(obj->headnode);
- exprFreeMem(obj->headnode);
-
- /* Free ourself */
- exprFreeMem(obj);
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Clear expression, keep lists, etc */
-int exprClear(exprObj *obj)
- {
- if(obj == NULL)
- return EXPR_ERROR_NOERROR;
-
- /* Free the node data only, keep function, variable, constant lists */
- exprFreeNodeData(obj->headnode);
- exprFreeMem(obj->headnode);
-
- obj->headnode = NULL;
- obj->parsedbad = 0;
- obj->parsedgood = 0;
-
- return EXPR_ERROR_NOERROR;
- }
-
-
-/* Get functions to get information about the expression object */
-
-/* Get the function list */
-exprFuncList *exprGetFuncList(exprObj *obj)
- {
- return (obj == NULL) ? NULL : obj->flist;
- }
-
-/* Get the variable list */
-exprValList *exprGetVarList(exprObj *obj)
- {
- return (obj == NULL) ? NULL : obj->vlist;
- }
-
-/* Get the constant list */
-exprValList *exprGetConstList(exprObj *obj)
- {
- return (obj == NULL) ? NULL : obj->clist;
- }
-
-/* Get the breaker function */
-exprBreakFuncType exprGetBreakFunc(exprObj *obj)
- {
- return (obj == NULL) ? NULL : obj->breakerfunc;
- }
-
-/* Check for break status */
-int exprGetBreakResult(exprObj *obj)
- {
- if(obj == NULL)
- return 0;
-
- if(obj->breakerfunc == NULL)
- return 0;
-
- return (*(obj->breakerfunc))(obj);
- }
-
-/* Get the user data */
-void *exprGetUserData(exprObj *obj)
- {
- return (obj == NULL) ? NULL : obj->userdata;
- }
-
-
-/* Set functions to set certain data */
-
-/* Set user data */
-void exprSetUserData(exprObj *obj, void *userdata)
- {
- if(obj)
- obj->userdata = userdata;
- }
-
-
-/* Set breaker count */
-void exprSetBreakCount(exprObj *obj, int count)
- {
- if(obj)
- {
- /* If count is negative, make it positive */
- if(count < 0)
- count = -count;
-
- obj->breakcount = count;
-
- /* Make sure the current value is not bigger than count */
- if(obj->breakcur > count)
- obj->breakcur = count;
- }
- }
-
-/* Get error position */
-void exprGetErrorPosition(exprObj *obj, int *start, int *end)
- {
- if(obj)
- {
- if(start)
- *start = obj->starterr;
-
- if(end)
- *end = obj->enderr;
- }
- }
-
-/* This function will free a node's data */
-static void exprFreeNodeData(exprNode *node)
- {
- int pos;
-
- if(node == NULL)
- return;
-
- /* free data based on type */
- switch(node->type)
- {
- case EXPR_NODETYPE_ADD:
- case EXPR_NODETYPE_SUBTRACT:
- case EXPR_NODETYPE_MULTIPLY:
- case EXPR_NODETYPE_DIVIDE:
- case EXPR_NODETYPE_EXPONENT:
- case EXPR_NODETYPE_NEGATE:
- case EXPR_NODETYPE_MULTI:
- /* Free operation data */
- if(node->data.oper.nodes)
- {
- for(pos = 0; pos < node->data.oper.nodecount; pos++)
- exprFreeNodeData(&(node->data.oper.nodes[pos]));
-
- exprFreeMem(node->data.oper.nodes);
- }
-
- break;
-
-
- case EXPR_NODETYPE_VALUE:
- /* Nothing to free for value */
- break;
-
- case EXPR_NODETYPE_VARIABLE:
- /* Nothing to free for variable */
- break;
-
- case EXPR_NODETYPE_FUNCTION:
- /* Free data of each subnode */
- if(node->data.function.nodes)
- {
- for(pos = 0; pos < node->data.function.nodecount; pos++)
- exprFreeNodeData(&(node->data.function.nodes[pos]));
-
- /* Free the subnode array */
- exprFreeMem(node->data.function.nodes);
- }
-
- /* Free reference variable list */
- if(node->data.function.refs)
- exprFreeMem(node->data.function.refs);
-
- break;
-
- case EXPR_NODETYPE_ASSIGN:
- /* Free subnode data */
- if(node->data.assign.node)
- {
- exprFreeNodeData(node->data.assign.node);
-
- /* Free the subnode */
- exprFreeMem(node->data.assign.node);
- }
-
- break;
- }
- }
-
-
+/*
+ File: exprobj.c
+ Auth: Brian Allen Vanderburg II
+ Date: Tuesday, April 29, 2003
+ Desc: Functions for the exprObj type
+
+ This file is part of ExprEval.
+*/
+
+/* Includes */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+#include "exprmem.h"
+
+/* Internal functions */
+static void exprFreeNodeData(exprNode *node);
+
+
+/* Function to create an expression object */
+int exprCreate(exprObj **obj, exprFuncList *flist, exprValList *vlist, exprValList *clist,
+ exprBreakFuncType breaker, void *userdata)
+ {
+ exprObj *tmp;
+
+ /* Allocate memory for the object */
+ tmp = exprAllocMem(sizeof(exprObj));
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+
+ /* Assign data */
+ tmp->flist = flist;
+ tmp->vlist = vlist;
+ tmp->clist = clist;
+ tmp->breakerfunc = breaker;
+ tmp->userdata = userdata;
+ tmp->breakcount = 100000; /* Default breaker count setting */
+ tmp->breakcur = 0;
+
+ /* Update pointer */
+ *obj = tmp;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+
+/* Free the expression */
+int exprFree(exprObj *obj)
+ {
+ if(obj == NULL)
+ return EXPR_ERROR_NOERROR;
+
+ /* First free the node data */
+ exprFreeNodeData(obj->headnode);
+ exprFreeMem(obj->headnode);
+
+ /* Free ourself */
+ exprFreeMem(obj);
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Clear expression, keep lists, etc */
+int exprClear(exprObj *obj)
+ {
+ if(obj == NULL)
+ return EXPR_ERROR_NOERROR;
+
+ /* Free the node data only, keep function, variable, constant lists */
+ exprFreeNodeData(obj->headnode);
+ exprFreeMem(obj->headnode);
+
+ obj->headnode = NULL;
+ obj->parsedbad = 0;
+ obj->parsedgood = 0;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+
+/* Get functions to get information about the expression object */
+
+/* Get the function list */
+exprFuncList *exprGetFuncList(exprObj *obj)
+ {
+ return (obj == NULL) ? NULL : obj->flist;
+ }
+
+/* Get the variable list */
+exprValList *exprGetVarList(exprObj *obj)
+ {
+ return (obj == NULL) ? NULL : obj->vlist;
+ }
+
+/* Get the constant list */
+exprValList *exprGetConstList(exprObj *obj)
+ {
+ return (obj == NULL) ? NULL : obj->clist;
+ }
+
+/* Get the breaker function */
+exprBreakFuncType exprGetBreakFunc(exprObj *obj)
+ {
+ return (obj == NULL) ? NULL : obj->breakerfunc;
+ }
+
+/* Check for break status */
+int exprGetBreakResult(exprObj *obj)
+ {
+ if(obj == NULL)
+ return 0;
+
+ if(obj->breakerfunc == NULL)
+ return 0;
+
+ return (*(obj->breakerfunc))(obj);
+ }
+
+/* Get the user data */
+void *exprGetUserData(exprObj *obj)
+ {
+ return (obj == NULL) ? NULL : obj->userdata;
+ }
+
+
+/* Set functions to set certain data */
+
+/* Set user data */
+void exprSetUserData(exprObj *obj, void *userdata)
+ {
+ if(obj)
+ obj->userdata = userdata;
+ }
+
+
+/* Set breaker count */
+void exprSetBreakCount(exprObj *obj, int count)
+ {
+ if(obj)
+ {
+ /* If count is negative, make it positive */
+ if(count < 0)
+ count = -count;
+
+ obj->breakcount = count;
+
+ /* Make sure the current value is not bigger than count */
+ if(obj->breakcur > count)
+ obj->breakcur = count;
+ }
+ }
+
+/* Get error position */
+void exprGetErrorPosition(exprObj *obj, int *start, int *end)
+ {
+ if(obj)
+ {
+ if(start)
+ *start = obj->starterr;
+
+ if(end)
+ *end = obj->enderr;
+ }
+ }
+
+/* This function will free a node's data */
+static void exprFreeNodeData(exprNode *node)
+ {
+ int pos;
+
+ if(node == NULL)
+ return;
+
+ /* free data based on type */
+ switch(node->type)
+ {
+ case EXPR_NODETYPE_ADD:
+ case EXPR_NODETYPE_SUBTRACT:
+ case EXPR_NODETYPE_MULTIPLY:
+ case EXPR_NODETYPE_DIVIDE:
+ case EXPR_NODETYPE_EXPONENT:
+ case EXPR_NODETYPE_NEGATE:
+ case EXPR_NODETYPE_MULTI:
+ /* Free operation data */
+ if(node->data.oper.nodes)
+ {
+ for(pos = 0; pos < node->data.oper.nodecount; pos++)
+ exprFreeNodeData(&(node->data.oper.nodes[pos]));
+
+ exprFreeMem(node->data.oper.nodes);
+ }
+
+ break;
+
+
+ case EXPR_NODETYPE_VALUE:
+ /* Nothing to free for value */
+ break;
+
+ case EXPR_NODETYPE_VARIABLE:
+ /* Nothing to free for variable */
+ break;
+
+ case EXPR_NODETYPE_FUNCTION:
+ /* Free data of each subnode */
+ if(node->data.function.nodes)
+ {
+ for(pos = 0; pos < node->data.function.nodecount; pos++)
+ exprFreeNodeData(&(node->data.function.nodes[pos]));
+
+ /* Free the subnode array */
+ exprFreeMem(node->data.function.nodes);
+ }
+
+ /* Free reference variable list */
+ if(node->data.function.refs)
+ exprFreeMem(node->data.function.refs);
+
+ break;
+
+ case EXPR_NODETYPE_ASSIGN:
+ /* Free subnode data */
+ if(node->data.assign.node)
+ {
+ exprFreeNodeData(node->data.assign.node);
+
+ /* Free the subnode */
+ exprFreeMem(node->data.assign.node);
+ }
+
+ break;
+ }
+ }
+
+
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprpars.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprpars.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprpars.c Tue Nov 13 15:23:26 2007
@@ -1,1558 +1,1558 @@
-/*
- File: exprpars.c
- Auth: Brian Allen Vanderburg II
- Date: Wednesday, April 30, 2003
- Desc: Actual parsing routines for this library
-
- This file is part of ExprEval.
-*/
-
-/* Includes */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-#include "exprmem.h"
-
-/* Data structure used by parser */
-typedef struct _exprToken
- {
- int type; /* token type */
- int start; /* token start position */
- int end; /* token end position */
-
- union _tdata
- {
- char *str; /* string data */
- EXPRTYPE val; /* value data */
- } data;
- } exprToken;
-
-/* Defines for token types */
-#define EXPR_TOKEN_UNKNOWN 0
-#define EXPR_TOKEN_OPAREN 1
-#define EXPR_TOKEN_CPAREN 2
-#define EXPR_TOKEN_IDENTIFIER 3
-#define EXPR_TOKEN_VALUE 4
-#define EXPR_TOKEN_PLUS 5
-#define EXPR_TOKEN_HYPHEN 6
-#define EXPR_TOKEN_ASTERISK 7
-#define EXPR_TOKEN_FSLASH 8
-#define EXPR_TOKEN_AMPERSAND 9
-#define EXPR_TOKEN_SEMICOLON 10
-#define EXPR_TOKEN_COMMA 11
-#define EXPR_TOKEN_EQUAL 12
-#define EXPR_TOKEN_HAT 13
-
-/* Internal functions */
-int exprMultiParse(exprObj *obj, exprNode *node, exprToken *tokens, int count);
-int exprInternalParse(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end);
-int exprInternalParseAssign(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParseAdd(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParseSub(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParseMul(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParseDiv(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParsePosNeg(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParseExp(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
-int exprInternalParseFunction(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int p1, int p2);
-int exprInternalParseVarVal(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end);
-int exprStringToTokenList(exprObj *obj, char *expr, exprToken **tokens, int *count);
-void exprFreeTokenList(exprToken *tokens, int count);
-
-/* This frees a token list */
-void exprFreeTokenList(exprToken *tokens, int count)
- {
- int pos;
-
- if(tokens == NULL)
- return;
-
- for(pos = 0; pos < count; pos++)
- {
- if(tokens[pos].type == EXPR_TOKEN_IDENTIFIER)
- exprFreeMem(tokens[pos].data.str);
- }
-
- exprFreeMem(tokens);
- }
-
-/* This converts an expression string to a token list */
-int exprStringToTokenList(exprObj *obj, char *expr, exprToken **tokens, int *count)
- {
- int found;
- exprToken *list;
- int pass;
- int pos, len;
- int tpos;
- int comment; /* Is a comment active */
- int start, ilen;
- char buf[EXPR_MAXIDENTSIZE + 1];
-
- /* Set initial variables */
- found = 0;
- tpos = 0;
- list = NULL;
- comment = 0;
- *tokens = NULL;
- *count = 0;
-
-
- /* Check string length */
- len = (int)strlen(expr);
- if(len == 0)
- return EXPR_ERROR_EMPTYEXPR;
-
- /* Two passes, one to count, one to tokenize */
- for(pass = 0; pass <= 1; pass++)
- {
- for(pos = 0; pos < len; pos++)
- {
- switch(expr[pos])
- {
- /* Comment */
- case '#':
- {
- /* Only set it if a comment is not already active */
- if(!comment)
- comment = 1;
-
- break;
- }
-
- /* Newline characters turn off comments */
- case '\r':
- case '\n':
- {
- /* If a comment is active, unset it */
- if(comment)
- comment = 0;
-
- break;
- }
-
- /* Open parenthesis */
- case '(':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_OPAREN;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Close parenthesis */
- case ')':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_CPAREN;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Plus */
- case '+':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_PLUS;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Hyphen */
- case '-':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_HYPHEN;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Asterisk */
- case '*':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_ASTERISK;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Forward slash */
- case '/':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_FSLASH;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Hat */
- case '^':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_HAT;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Ampersand */
- case '&':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_AMPERSAND;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Semicolon */
- case ';':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_SEMICOLON;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Comma */
- case ',':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_COMMA;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Equal sign */
- case '=':
- {
- if(!comment)
- {
- if(pass == 0)
- found++;
- else
- {
- list[tpos].type = EXPR_TOKEN_EQUAL;
- list[tpos].start = pos;
- list[tpos].end = pos;
- tpos++;
- }
- }
-
- break;
- }
-
- /* Identifiers and values */
- default:
- {
- if(!comment)
- {
- if(expr[pos] == '.' || isdigit(expr[pos]))
- {
- /* Value */
- start = pos;
-
- /* Find digits before a period */
- while(isdigit(expr[pos]))
- pos++;
-
- /* Find a period */
- if(expr[pos] == '.')
- pos++;
-
- /* Find digits after a period */
- while(isdigit(expr[pos]))
- pos++;
-
- /* pos is AFTER last item, back up */
- pos--;
-
- if(pass == 0)
- found++;
- else
- {
- ilen = pos - start + 1;
-
- /* Is the value to large */
- if(ilen > EXPR_MAXIDENTSIZE)
- {
- obj->starterr = start;
- obj->enderr = pos;
- exprFreeTokenList(list, found);
- return EXPR_ERROR_BADIDENTIFIER;
- }
-
- /* Create value token */
- strncpy(buf, expr + start, ilen);
- buf[ilen] = '\0';
-
- list[tpos].type = EXPR_TOKEN_VALUE;
- list[tpos].start = start;
- list[tpos].end = pos;
- list[tpos].data.val = (EXPRTYPE)atof(buf);
- tpos++;
- }
- }
- else if(expr[pos] == '_' || isalpha(expr[pos]))
- {
- /* Identifier */
- start = pos;
-
- /* Find rest of identifier */
- while(expr[pos] == '_' || isalnum(expr[pos]))
- pos++;
-
- /* pos is AFTER last item, back up */
- pos--;
-
- if(pass == 0)
- found++;
- else
- {
- ilen = pos - start + 1;
-
- /* Is the value to large */
- if(ilen > EXPR_MAXIDENTSIZE)
- {
- obj->starterr = start;
- obj->enderr = pos;
- exprFreeTokenList(list, found);
- return EXPR_ERROR_BADIDENTIFIER;
- }
-
- /* Create value token */
- strncpy(buf, expr + start, ilen);
- buf[ilen] = '\0';
-
- /* Allocate memory for identifier */
- list[tpos].data.str = exprAllocMem(ilen + 1);
- if(list[tpos].data.str == NULL)
- {
- exprFreeTokenList(list, found);
- return EXPR_ERROR_MEMORY;
- }
-
- list[tpos].type = EXPR_TOKEN_IDENTIFIER;
- list[tpos].start = start;
- list[tpos].end = pos;
- strcpy(list[tpos].data.str, buf);
- tpos++;
- }
- }
- else if(isspace(expr[pos]))
- {
- /* Spaces are ignored, do nothing */
- }
- else
- {
- /* Unknown */
- obj->starterr = obj->enderr = pos;
- exprFreeTokenList(list, found);
- return EXPR_ERROR_INVALIDCHAR;
- }
- }
-
- break;
- }
- }
- }
-
- /* If pass is 0, allocate memory for next pass */
- if(pass == 0)
- {
- /* First, make sure all comments were ended */
- if(comment)
- comment = 0;
-
- /* Make sure the expression is not empty */
- if(found == 0)
- return EXPR_ERROR_EMPTYEXPR;
-
- /* Allocate memory for token list */
- list = exprAllocMem(found * sizeof(exprToken));
- if(list == NULL)
- return EXPR_ERROR_MEMORY;
-
- tpos = 0;
- }
- }
-
- *count = found;
- *tokens = list;
- return EXPR_ERROR_NOERROR;
- }
-
-
-/* This is the main parsing routine */
-int exprParse(exprObj *obj, char *expr)
- {
- exprToken *tokens;
- int count;
- int err;
- exprNode *tmp;
-
- /* Make sure an object was passed */
- if(obj == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Clear expression error position */
- obj->starterr = obj->enderr = -1;
-
- /* Have we already been parsed? */
- if(obj->parsedbad != 0)
- return EXPR_ERROR_ALREADYPARSEDBAD;
-
- if(obj->parsedgood != 0)
- return EXPR_ERROR_ALREADYPARSEDGOOD;
-
- /* Make sure an expression was passed */
- if(expr == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Create token list */
- err = exprStringToTokenList(obj, expr, &tokens, &count);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* Create head pointer */
- tmp = exprAllocNodes(1);
- if(tmp == NULL)
- {
- exprFreeTokenList(tokens, count);
- return EXPR_ERROR_MEMORY;
- }
-
- obj->headnode = tmp;
-
- /* Call the multiparse routine to parse subexpressions */
- err = exprMultiParse(obj, tmp, tokens, count);
-
- /* Free the token list */
- exprFreeTokenList(tokens, count);
-
- /* successful parse? */
- if(err == EXPR_ERROR_NOERROR)
- {
- obj->parsedgood = 1;
- obj->parsedbad = 0;
- }
- else
- {
- obj->parsedbad = 1;
- obj->parsedgood = 0;
- }
-
- return err;
- }
-
-
-/* Parse the subexpressions, each ending with semicolons */
-int exprMultiParse(exprObj *obj, exprNode *node, exprToken *tokens, int count)
- {
- int pos, plevel, last;
- int num, cur, err;
- exprNode *tmp;
-
- plevel = 0;
- num = 0;
- last = -1;
-
- /* First count the number of arguments */
- for(pos = 0; pos < count; pos++)
- {
- switch(tokens[pos].type)
- {
- case EXPR_TOKEN_OPAREN:
- /* increase plevel */
- plevel++;
- break;
-
- case EXPR_TOKEN_CPAREN:
- /* decrease plevel */
- plevel--;
-
- if(plevel < 0)
- {
- obj->starterr = tokens[pos].start;
- obj->enderr = tokens[pos].end;
- return EXPR_ERROR_UNMATCHEDPAREN;
- }
-
- break;
-
- case EXPR_TOKEN_SEMICOLON:
- if(plevel == 0)
- {
- if(last == pos - 1 || pos == 0)
- {
- /* last semicolon is before us or we are at the start */
- obj->starterr = tokens[pos].start;
- obj->enderr = tokens[pos].end;
- return EXPR_ERROR_SYNTAX;
- }
- else
- {
- /* last semicolon is not right before us */
- num++;
- }
- }
- else
- {
- /* Semicolon should not be in a parenthesis */
- obj->starterr = tokens[pos].start;
- obj->enderr = tokens[pos].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- last = pos; /* update position of last semicolon */
- break;
- }
- }
-
- /* plevel should be zero now */
- if(plevel != 0)
- return EXPR_ERROR_UNMATCHEDPAREN;
-
- /* the last character should be a semicolon */
- if(last != pos - 1)
- return EXPR_ERROR_MISSINGSEMICOLON;
-
- /* Now we know how many arguments there are */
-
- /* Allocate array of subnodes */
- tmp = exprAllocNodes(num);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- /* Set the current node's data */
- node->type = EXPR_NODETYPE_MULTI;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = num;
-
- /* now we parse each subexpression */
- last = 0; /* Not for last semicolon, but for first char of subexpr */
- cur = 0;
-
- for(pos = 0; pos < count; pos++)
- {
- if(tokens[pos].type == EXPR_TOKEN_SEMICOLON)
- {
- /* Everything from last up to pos - 1 is a parameter */
- err = exprInternalParse(obj, &(tmp[cur]), tokens, last, pos - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* Update last position and current argument */
- last = pos + 1;
- cur++;
- }
- }
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* This function parses each subnode and recurses if needed */
-int exprInternalParse(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end)
- {
- int pos;
- int plevel = 0; /* Paren level */
- int fgopen = -1; /* First paren group open index */
- int fgclose = -1; /* First paren group close index */
- int assignindex = -1; /* First = at plevel 0 for assignment */
- int addsubindex = -1; /* Last + or - at plevel 0 for adding or subtracting */
- int muldivindex = -1; /* Last * or / at plevel 0 for multiplying or dividing */
- int expindex = -1; /* Last ^ fount at plevel 0 for exponents */
- int posnegindex = -1; /* First +,- at plevel 0 for positive,negative */
-
- /* Make sure some conditions are right */
- if(start > end)
- return EXPR_ERROR_UNKNOWN;
-
- /* Scan the string for certain characters */
- for(pos = start; pos <= end; pos++)
- {
- switch(tokens[pos].type)
- {
- case EXPR_TOKEN_OPAREN:
- plevel++;
-
- /* First group open? */
- if(plevel == 1 && fgopen == -1)
- fgopen = pos;
- break;
-
- case EXPR_TOKEN_CPAREN:
- plevel--;
-
- /* First group close? */
- if(plevel == 0 && fgclose == -1)
- fgclose = pos;
-
- if(plevel < 0)
- {
- obj->starterr = tokens[pos].start;
- obj->enderr = tokens[pos].end;
- return EXPR_ERROR_UNMATCHEDPAREN;
- }
- break;
-
- case EXPR_TOKEN_EQUAL:
- /* Assignment found */
- if(plevel == 0)
- {
- if(assignindex == -1)
- assignindex = pos;
- }
- break;
-
- case EXPR_TOKEN_ASTERISK:
- case EXPR_TOKEN_FSLASH:
- /* Multiplication or division */
- if(plevel == 0)
- muldivindex = pos;
- break;
-
- case EXPR_TOKEN_HAT:
- /* Exponent */
- if(plevel == 0)
- expindex = pos;
- break;
-
-
- case EXPR_TOKEN_PLUS:
- case EXPR_TOKEN_HYPHEN:
- /* Addition or positive or subtraction or negative*/
- if(plevel == 0)
- {
- if(pos == start)
- {
- /* At the start area, positive/negative */
- if(posnegindex == -1)
- posnegindex = pos;
- }
- else
- {
- /* Not at start, check item in front */
- switch(tokens[pos - 1].type)
- {
- case EXPR_TOKEN_EQUAL: /* Equal sign */
- case EXPR_TOKEN_PLUS: /* Add/positive sign */
- case EXPR_TOKEN_HYPHEN: /* Subtract/negative sign */
- case EXPR_TOKEN_ASTERISK: /* Multiply sign */
- case EXPR_TOKEN_FSLASH: /* Divide sign */
- case EXPR_TOKEN_HAT: /* Exponent sign */
-
- /* After theses, it is positive/negative */
- if(posnegindex == -1)
- posnegindex = pos;
-
- break;
-
- default:
- /* Otherwise it is addition/subtraction */
- addsubindex = pos;
- break;
- }
- }
- }
- break;
-
- }
- }
-
- /* plevel should now be zero */
- if(plevel != 0)
- return EXPR_ERROR_UNMATCHEDPAREN;
-
- /* We must parse the data in a certain order to maintain the
- correct order of operators at evaluation time */
-
- /* First, take care of assignment */
- if(assignindex != -1)
- return exprInternalParseAssign(obj, node, tokens, start, end, assignindex);
-
- /* Addition or subtraction is next */
- if(addsubindex != -1)
- {
- if(tokens[addsubindex].type == EXPR_TOKEN_PLUS)
- return exprInternalParseAdd(obj, node, tokens, start, end, addsubindex);
- else
- return exprInternalParseSub(obj, node, tokens, start, end, addsubindex);
- }
-
-
- /* Multiplycation or division */
- if(muldivindex != -1)
- {
- if(tokens[muldivindex].type == EXPR_TOKEN_ASTERISK)
- return exprInternalParseMul(obj, node, tokens, start, end, muldivindex);
- else
- return exprInternalParseDiv(obj, node, tokens, start, end, muldivindex);
- }
-
- /* Exponent */
- if(expindex != -1)
- return exprInternalParseExp(obj, node, tokens, start, end, expindex);
-
- /* Negation */
- if(posnegindex != -1)
- return exprInternalParsePosNeg(obj, node, tokens, start, end, posnegindex);
-
-
- /* Grouped parenthesis */
- if(fgopen == start)
- {
- /* Closing paren. should be at the end */
- if(fgclose == end)
- {
- /* Anything between them */
- if(fgclose > fgopen + 1)
- {
- return exprInternalParse(obj, node, tokens, fgopen + 1, fgclose - 1);
- }
- else
- {
- /* Nothing between them */
- obj->starterr = tokens[fgopen].start;
- obj->enderr = tokens[fgclose].end;
- return EXPR_ERROR_SYNTAX;
- }
- }
- else /* Closing paren not at the end */
- return EXPR_ERROR_SYNTAX;
- }
-
- /* Functions */
- if(fgopen > start)
- {
- /* Closing paren should be at end */
- if(fgclose == end)
- {
- return exprInternalParseFunction(obj, node, tokens, start, end, fgopen, fgclose);
- }
- else /* Closing paren not at end */
- return EXPR_ERROR_SYNTAX;
- }
-
- /* If it was none of the above, it must be a variable or value */
- return exprInternalParseVarVal(obj, node, tokens, start, end);
- }
-
-/* Function to parse an assignment node */
-int exprInternalParseAssign(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
- exprValList *l;
- EXPRTYPE *addr;
-
- /* Make sure the equal sign is not at the start or end */
- if(index != start + 1 || index >= end)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* Make sure item before equal sign is an identifier */
- if(tokens[index - 1].type != EXPR_TOKEN_IDENTIFIER)
- {
- obj->starterr = tokens[index - 1].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* Create expression subnode */
- tmp = exprAllocNodes(1);
- if(tmp == NULL)
- {
- return EXPR_ERROR_MEMORY;
- }
-
-
- /* Set the data */
- node->type = EXPR_NODETYPE_ASSIGN;
- node->data.assign.node = tmp;
-
-
- /*
- The fast access method directly accesses the memory address
- of the variable's value at evaluation time. Because of this,
- we must make sure the variable does exists in the variable list.
- */
-
- /* Make sure name is not a constant name */
- l = exprGetConstList(obj);
- if(l)
- {
- exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
- if(addr)
- {
- obj->starterr = tokens[index - 1].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_CONSTANTASSIGN;
- }
- }
-
- /* Get the variable list */
- l = exprGetVarList(obj);
- if(l == NULL)
- return EXPR_ERROR_NOVARLIST;
-
- /* Get variable address if already in the list */
- exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
- if(addr == NULL) /* Variable not in the list, add it */
- {
- exprValListAdd(l, tokens[index - 1].data.str, 0.0);
-
- /* Try to get address again */
- exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
- if(addr == NULL) /* Could not add variable */
- return EXPR_ERROR_MEMORY; /* Could not add variable to list */
- }
-
- node->data.assign.vaddr = addr;
-
- /* Parse the subnode */
- return exprInternalParse(obj, tmp, tokens, index + 1, end);
- }
-
-/* Function to parse an addition operator */
-int exprInternalParseAdd(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
- int err;
-
- /* Make sure plus sign is at a good place */
- if(index <= start || index >= end)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* Allocate space for 2 subnodes */
- tmp = exprAllocNodes(2);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
-
- /* Set the data */
- node->type = EXPR_NODETYPE_ADD;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = 2;
-
- /* parse the left side */
- err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* parse the right side */
- return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
- }
-
-/* Function to parse a subtraction operator */
-int exprInternalParseSub(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
- int err;
-
- /* Make sure minus sign is at a good place */
- if(index <= start || index >= end)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* Allocate space for 2 subnodes */
- tmp = exprAllocNodes(2);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
-
- /* Set the data */
- node->type = EXPR_NODETYPE_SUBTRACT;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = 2;
-
- /* parse the left side */
- err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* parse the right side */
- return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
- }
-
-/* Function to parse a multiplication operator */
-int exprInternalParseMul(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
- int err;
-
- /* Make sure times sign is at a good place */
- if(index <= start || index >= end)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
-
- /* Allocate space for 2 subnodes */
- tmp = exprAllocNodes(2);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
-
- /* Set the data */
- node->type = EXPR_NODETYPE_MULTIPLY;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = 2;
-
- /* parse the left side */
- err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* parse the right side */
- return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
- }
-
-/* Function to parse a division operator */
-int exprInternalParseDiv(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
- int err;
-
- /* Make sure slash sign is at a good place */
- if(index <= start || index >= end)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
-
- /* Allocate space for 2 subnodes */
- tmp = exprAllocNodes(2);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
-
- /* Set the data */
- node->type = EXPR_NODETYPE_DIVIDE;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = 2;
-
- /* parse the left side */
- err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* parse the right side */
- return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
- }
-
-/* Function to parse an exponent operator */
-int exprInternalParseExp(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
- int err;
-
- /* Make sure exponent sign is at a good place */
- if(index <= start || index >= end)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_SYNTAX;
- }
-
-
- /* Allocate space for 2 subnodes */
- tmp = exprAllocNodes(2);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
-
- /* Set the data */
- node->type = EXPR_NODETYPE_EXPONENT;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = 2;
-
- /* parse the left side */
- err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* parse the right side */
- return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
- }
-
-/* Function to parse for positive and negative */
-int exprInternalParsePosNeg(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
- {
- exprNode *tmp;
-
- /* Position should be the same as start */
- if(index != start)
- {
- obj->starterr = tokens[index].start;
- obj->enderr = tokens[index].end;
- return EXPR_ERROR_UNKNOWN;
- }
-
- /* If it is a positive, just parse the internal of it */
- if(tokens[index].type == EXPR_TOKEN_PLUS)
- return exprInternalParse(obj, node, tokens, index + 1, end);
- else
- {
- /* Allocate subnode */
- tmp = exprAllocNodes(1);
- if(tmp == NULL)
- return EXPR_ERROR_NOERROR;
-
-
- /* Set data */
- node->type = EXPR_NODETYPE_NEGATE;
- node->data.oper.nodes = tmp;
- node->data.oper.nodecount = 1;
-
- /* Parse the subnode */
- return exprInternalParse(obj, tmp, tokens, index + 1, end);
- }
- }
-
-/* Function will parse a call to a function */
-int exprInternalParseFunction(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int p1, int p2)
- {
- int pos;
- int num, cur;
- int refnum, refcur;
- int plevel = 0;
- int lv, err;
- exprNode *tmp;
- exprFuncType fptr;
- int argmin, argmax;
- int refargmin, refargmax;
- int type;
- exprFuncList *l;
- exprValList *vars;
- EXPRTYPE *addr;
- EXPRTYPE **reftmp;
-
- /* We should have a function list */
- l = exprGetFuncList(obj);
- if(l == NULL)
- return EXPR_ERROR_NOSUCHFUNCTION;
-
- /* check paren. location */
- if(p2 <= p1)
- return EXPR_ERROR_SYNTAX;
-
- /* second paren. should not be after the end */
- if(p2 > end)
- return EXPR_ERROR_SYNTAX;
-
- /* Item before parenthesis should be an identifier */
- if(tokens[p1 - 1].type != EXPR_TOKEN_IDENTIFIER)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p1].end;
- return EXPR_ERROR_SYNTAX;
- }
-
-
- /* Look up the function */
- err = exprFuncListGet(l, tokens[p1 - 1].data.str, &fptr, &type, &argmin, &argmax, &refargmin, &refargmax);
- if(err != EXPR_ERROR_NOERROR)
- {
- if(err == EXPR_ERROR_NOTFOUND)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p1 - 1].end;
- return EXPR_ERROR_NOSUCHFUNCTION;
- }
- else
- return err;
- }
-
- /* Make sure the function exists */
- if(fptr == NULL && type == 0)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p1 - 1].end;
- return EXPR_ERROR_NOSUCHFUNCTION;
- }
-
- /* Count arguments */
- if(p2 == p1 + 1)
- {
- num = 0;
- refnum = 0;
- }
- else
- {
- num = 1;
- refnum = 0;
-
-
- /* count commas */
- for(pos = p1 + 1; pos < p2; pos++)
- {
- switch(tokens[pos].type)
- {
- case EXPR_TOKEN_OPAREN:
- plevel++;
- break;
-
- case EXPR_TOKEN_CPAREN:
- plevel--;
- if(plevel < 0)
- {
- obj->starterr = tokens[pos].start;
- obj->enderr = tokens[pos].end;
- return EXPR_ERROR_UNMATCHEDPAREN;
- }
- break;
-
- case EXPR_TOKEN_COMMA:
- /* Found comma */
- if(plevel == 0)
- num++;
- break;
-
- case EXPR_TOKEN_AMPERSAND:
- /* Found reference mark */
- if(plevel == 0)
- {
- /* This may only occur after the open parenthesis or comma */
- if(tokens[pos - 1].type == EXPR_TOKEN_OPAREN || tokens[pos - 1].type == EXPR_TOKEN_COMMA)
- refnum++;
- else
- return EXPR_ERROR_SYNTAX;
- }
- break;
- }
- }
-
- /* plevel should be zero */
- if(plevel != 0)
- return EXPR_ERROR_UNMATCHEDPAREN;
- }
-
- /* We now have the number of total arguments and
- number of ref arguments. Get number of normal
- arguments */
- num = num - refnum;
-
- /* Make sure number of arguments is correct */
- /* Here we make sure the limits are greater
- or equal to zero because any negative number
- could be used to specify no limit */
- if(argmin >= 0 && num < argmin)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p2].end;
- return EXPR_ERROR_BADNUMBERARGUMENTS;
- }
-
- if(argmax >= 0 && num > argmax)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p2].end;
- return EXPR_ERROR_BADNUMBERARGUMENTS;
- }
-
- if(refargmin >= 0 && refnum < refargmin)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p2].end;
- return EXPR_ERROR_BADNUMBERARGUMENTS;
- }
-
- if(refargmax >= 0 && refnum > refargmax)
- {
- obj->starterr = tokens[p1 - 1].start;
- obj->enderr = tokens[p2].end;
- return EXPR_ERROR_BADNUMBERARGUMENTS;
- }
-
- /* Set tmp to null in case of no arguments */
- tmp = NULL;
- reftmp = NULL;
-
- if(num > 0)
- {
- /* Allocate subnodes */
- tmp = exprAllocNodes(num);
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
- }
-
- if(refnum > 0)
- {
- /* Allocate ref pointers */
- reftmp = exprAllocMem(sizeof(EXPRTYPE*) * refnum);
- if(reftmp == NULL)
- {
- exprFreeMem(tmp);
- return EXPR_ERROR_MEMORY;
- }
- }
-
-
-
- /* Set this node's data */
- node->type = EXPR_NODETYPE_FUNCTION;
- node->data.function.fptr = fptr;
- node->data.function.nodecount = num;
- node->data.function.nodes = tmp;
- node->data.function.refcount = refnum;
- node->data.function.refs = reftmp;
- node->data.function.type = type;
-
- /* parse each subnode */
- if(num + refnum > 0)
- {
- plevel = 0;
- cur = 0;
- refcur = 0;
- lv = p1 + 1;
-
- /* look for commas if more than 1 arg */
- if(num + refnum > 1)
- {
- for(pos = p1 + 1; pos < p2; pos++)
- {
- switch(tokens[pos].type)
- {
- case EXPR_TOKEN_OPAREN:
- plevel++;
- break;
-
- case EXPR_TOKEN_CPAREN:
- plevel--;
- break; /* Already checked paren nesting above */
-
- case EXPR_TOKEN_COMMA:
- /* Found comma */
- if(plevel == 0)
- {
- /* parse inside */
- if(tokens[lv].type == EXPR_TOKEN_AMPERSAND)
- {
- if(lv != pos - 2)
- {
- obj->starterr = tokens[lv].start;
- obj->enderr = tokens[pos].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* It is a reference */
- if(tokens[lv + 1].type != EXPR_TOKEN_IDENTIFIER)
- {
- obj->starterr = tokens[lv].start;
- obj->enderr = tokens[lv + 1].end;
- return EXPR_ERROR_SYNTAX;
- }
-
-
- /* Make sure it is not a constant */
- vars = exprGetConstList(obj);
- if(vars)
- {
- exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
- if(addr)
- {
- obj->starterr = tokens[lv].start;
- obj->enderr = tokens[lv + 1].start;
- return EXPR_ERROR_REFCONSTANT;
- }
- }
-
- /* Get variable list */
- vars = exprGetVarList(obj);
- if(vars == NULL)
- return EXPR_ERROR_NOVARLIST;
-
- /* Get variable address */
- exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
- if(addr == NULL)
- {
- /* Add variable to list */
- exprValListAdd(vars, tokens[lv + 1].data.str, 0.0);
-
- /* Try to get address again */
- exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
- if(addr == NULL)
- return EXPR_ERROR_MEMORY; /* Could not add variable */
- }
-
- /* Set reference item */
- reftmp[refcur] = addr;
-
- /* increase ref arg number and lv position*/
- refcur++;
- lv = pos + 1;
- }
- else
- {
- err = exprInternalParse(obj, &(tmp[cur]), tokens, lv, pos - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
-
- /* increase arg number and lv position*/
- lv = pos + 1;
- cur++;
- }
- }
- break;
- }
- }
- }
-
- /* lv should point after the last comma, or open paren. if only 1 arg */
- if(tokens[lv].type == EXPR_TOKEN_AMPERSAND)
- {
- if(lv != p2 - 2)
- {
- obj->starterr = tokens[lv].start;
- obj->enderr = tokens[p2].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* It is a reference */
- if(tokens[lv + 1].type != EXPR_TOKEN_IDENTIFIER)
- {
- obj->starterr = tokens[lv].start;
- obj->enderr = tokens[lv + 1].end;
- return EXPR_ERROR_SYNTAX;
- }
-
- /* Make sure it is not a constant */
- vars = exprGetConstList(obj);
- if(vars)
- {
- exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
- if(addr)
- {
- obj->starterr = tokens[lv].start;
- obj->enderr = tokens[lv + 1].start;
- return EXPR_ERROR_REFCONSTANT;
- }
- }
-
- /* Get variable list */
- vars = exprGetVarList(obj);
- if(vars == NULL)
- return EXPR_ERROR_NOVARLIST;
-
- /* Get variable address */
- exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
- if(addr == NULL)
- {
- /* Add variable to list */
- exprValListAdd(vars, tokens[lv + 1].data.str, 0.0);
-
- /* Try to get address again */
- exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
- if(addr == NULL)
- return EXPR_ERROR_MEMORY; /* Could not add variable */
- }
-
- /* Set reference item */
- reftmp[refcur] = addr;
- }
- else
- {
- err = exprInternalParse(obj, &(tmp[cur]), tokens, lv, p2 - 1);
- if(err != EXPR_ERROR_NOERROR)
- return err;
- }
- }
-
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Parse a variable or value */
-int exprInternalParseVarVal(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end)
- {
- exprValList *l;
- EXPRTYPE *addr;
-
-
- /* Make sure positions are correct */
- if(start != end)
- {
- return EXPR_ERROR_UNKNOWN;
- }
-
-
- /* Are we an identifier */
- if(tokens[start].type == EXPR_TOKEN_IDENTIFIER)
- {
- /* we are an identifier */
-
- /* check to see if it is a constant */
- l = exprGetConstList(obj);
- if(l != NULL)
- {
- if(exprValListGetAddress(l, tokens[start].data.str, &addr) == EXPR_ERROR_NOERROR)
- {
- /* We found it in the constant list */
-
- /*
- Treat is like a variable node so application can change
- constant value and it will reflect in expression
- */
-
- node->type = EXPR_NODETYPE_VARIABLE;
- node->data.variable.vaddr = addr;
- return EXPR_ERROR_NOERROR;
- }
- }
-
- /* Not found in the constant list, so it must be a variable */
-
- /* Set node type */
- node->type = EXPR_NODETYPE_VARIABLE;
-
- /*
- The fast access method directly accesses the memory address
- of the variable's value at evaluation time. Because of this,
- we must make sure the variable does exists in the variable list.
- */
-
- /* Get the variable list */
- l = exprGetVarList(obj);
- if(l == NULL)
- return EXPR_ERROR_NOVARLIST;
-
- /* Get variable address if already in the list */
- exprValListGetAddress(l, tokens[start].data.str, &addr);
- if(addr == NULL) /* Variable not in the list, add it */
- {
- exprValListAdd(l, tokens[start].data.str, 0.0);
-
- /* Try to get address again */
- exprValListGetAddress(l, tokens[start].data.str, &addr);
- if(addr == NULL) /* Could not add variable */
- return EXPR_ERROR_MEMORY; /* Could not add variable to list */
- }
-
- node->data.variable.vaddr = addr;
-
- return EXPR_ERROR_NOERROR;
- }
- else if(tokens[start].type == EXPR_TOKEN_VALUE)
- {
- /* we are a value */
- node->type = EXPR_NODETYPE_VALUE;
- node->data.value.value = tokens[start].data.val;
- return EXPR_ERROR_NOERROR;
- }
- else
- {
- obj->starterr = tokens[start].start;
- obj->enderr = tokens[end].end;
- return EXPR_ERROR_UNKNOWN;
- }
- }
+/*
+ File: exprpars.c
+ Auth: Brian Allen Vanderburg II
+ Date: Wednesday, April 30, 2003
+ Desc: Actual parsing routines for this library
+
+ This file is part of ExprEval.
+*/
+
+/* Includes */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+#include "exprmem.h"
+
+/* Data structure used by parser */
+typedef struct _exprToken
+ {
+ int type; /* token type */
+ int start; /* token start position */
+ int end; /* token end position */
+
+ union _tdata
+ {
+ char *str; /* string data */
+ EXPRTYPE val; /* value data */
+ } data;
+ } exprToken;
+
+/* Defines for token types */
+#define EXPR_TOKEN_UNKNOWN 0
+#define EXPR_TOKEN_OPAREN 1
+#define EXPR_TOKEN_CPAREN 2
+#define EXPR_TOKEN_IDENTIFIER 3
+#define EXPR_TOKEN_VALUE 4
+#define EXPR_TOKEN_PLUS 5
+#define EXPR_TOKEN_HYPHEN 6
+#define EXPR_TOKEN_ASTERISK 7
+#define EXPR_TOKEN_FSLASH 8
+#define EXPR_TOKEN_AMPERSAND 9
+#define EXPR_TOKEN_SEMICOLON 10
+#define EXPR_TOKEN_COMMA 11
+#define EXPR_TOKEN_EQUAL 12
+#define EXPR_TOKEN_HAT 13
+
+/* Internal functions */
+int exprMultiParse(exprObj *obj, exprNode *node, exprToken *tokens, int count);
+int exprInternalParse(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end);
+int exprInternalParseAssign(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParseAdd(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParseSub(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParseMul(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParseDiv(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParsePosNeg(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParseExp(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index);
+int exprInternalParseFunction(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int p1, int p2);
+int exprInternalParseVarVal(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end);
+int exprStringToTokenList(exprObj *obj, char *expr, exprToken **tokens, int *count);
+void exprFreeTokenList(exprToken *tokens, int count);
+
+/* This frees a token list */
+void exprFreeTokenList(exprToken *tokens, int count)
+ {
+ int pos;
+
+ if(tokens == NULL)
+ return;
+
+ for(pos = 0; pos < count; pos++)
+ {
+ if(tokens[pos].type == EXPR_TOKEN_IDENTIFIER)
+ exprFreeMem(tokens[pos].data.str);
+ }
+
+ exprFreeMem(tokens);
+ }
+
+/* This converts an expression string to a token list */
+int exprStringToTokenList(exprObj *obj, char *expr, exprToken **tokens, int *count)
+ {
+ int found;
+ exprToken *list;
+ int pass;
+ int pos, len;
+ int tpos;
+ int comment; /* Is a comment active */
+ int start, ilen;
+ char buf[EXPR_MAXIDENTSIZE + 1];
+
+ /* Set initial variables */
+ found = 0;
+ tpos = 0;
+ list = NULL;
+ comment = 0;
+ *tokens = NULL;
+ *count = 0;
+
+
+ /* Check string length */
+ len = (int)strlen(expr);
+ if(len == 0)
+ return EXPR_ERROR_EMPTYEXPR;
+
+ /* Two passes, one to count, one to tokenize */
+ for(pass = 0; pass <= 1; pass++)
+ {
+ for(pos = 0; pos < len; pos++)
+ {
+ switch(expr[pos])
+ {
+ /* Comment */
+ case '#':
+ {
+ /* Only set it if a comment is not already active */
+ if(!comment)
+ comment = 1;
+
+ break;
+ }
+
+ /* Newline characters turn off comments */
+ case '\r':
+ case '\n':
+ {
+ /* If a comment is active, unset it */
+ if(comment)
+ comment = 0;
+
+ break;
+ }
+
+ /* Open parenthesis */
+ case '(':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_OPAREN;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Close parenthesis */
+ case ')':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_CPAREN;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Plus */
+ case '+':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_PLUS;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Hyphen */
+ case '-':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_HYPHEN;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Asterisk */
+ case '*':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_ASTERISK;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Forward slash */
+ case '/':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_FSLASH;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Hat */
+ case '^':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_HAT;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Ampersand */
+ case '&':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_AMPERSAND;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Semicolon */
+ case ';':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_SEMICOLON;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Comma */
+ case ',':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_COMMA;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Equal sign */
+ case '=':
+ {
+ if(!comment)
+ {
+ if(pass == 0)
+ found++;
+ else
+ {
+ list[tpos].type = EXPR_TOKEN_EQUAL;
+ list[tpos].start = pos;
+ list[tpos].end = pos;
+ tpos++;
+ }
+ }
+
+ break;
+ }
+
+ /* Identifiers and values */
+ default:
+ {
+ if(!comment)
+ {
+ if(expr[pos] == '.' || isdigit(expr[pos]))
+ {
+ /* Value */
+ start = pos;
+
+ /* Find digits before a period */
+ while(isdigit(expr[pos]))
+ pos++;
+
+ /* Find a period */
+ if(expr[pos] == '.')
+ pos++;
+
+ /* Find digits after a period */
+ while(isdigit(expr[pos]))
+ pos++;
+
+ /* pos is AFTER last item, back up */
+ pos--;
+
+ if(pass == 0)
+ found++;
+ else
+ {
+ ilen = pos - start + 1;
+
+ /* Is the value to large */
+ if(ilen > EXPR_MAXIDENTSIZE)
+ {
+ obj->starterr = start;
+ obj->enderr = pos;
+ exprFreeTokenList(list, found);
+ return EXPR_ERROR_BADIDENTIFIER;
+ }
+
+ /* Create value token */
+ strncpy(buf, expr + start, ilen);
+ buf[ilen] = '\0';
+
+ list[tpos].type = EXPR_TOKEN_VALUE;
+ list[tpos].start = start;
+ list[tpos].end = pos;
+ list[tpos].data.val = (EXPRTYPE)atof(buf);
+ tpos++;
+ }
+ }
+ else if(expr[pos] == '_' || isalpha(expr[pos]))
+ {
+ /* Identifier */
+ start = pos;
+
+ /* Find rest of identifier */
+ while(expr[pos] == '_' || isalnum(expr[pos]))
+ pos++;
+
+ /* pos is AFTER last item, back up */
+ pos--;
+
+ if(pass == 0)
+ found++;
+ else
+ {
+ ilen = pos - start + 1;
+
+ /* Is the value to large */
+ if(ilen > EXPR_MAXIDENTSIZE)
+ {
+ obj->starterr = start;
+ obj->enderr = pos;
+ exprFreeTokenList(list, found);
+ return EXPR_ERROR_BADIDENTIFIER;
+ }
+
+ /* Create value token */
+ strncpy(buf, expr + start, ilen);
+ buf[ilen] = '\0';
+
+ /* Allocate memory for identifier */
+ list[tpos].data.str = exprAllocMem(ilen + 1);
+ if(list[tpos].data.str == NULL)
+ {
+ exprFreeTokenList(list, found);
+ return EXPR_ERROR_MEMORY;
+ }
+
+ list[tpos].type = EXPR_TOKEN_IDENTIFIER;
+ list[tpos].start = start;
+ list[tpos].end = pos;
+ strcpy(list[tpos].data.str, buf);
+ tpos++;
+ }
+ }
+ else if(isspace(expr[pos]))
+ {
+ /* Spaces are ignored, do nothing */
+ }
+ else
+ {
+ /* Unknown */
+ obj->starterr = obj->enderr = pos;
+ exprFreeTokenList(list, found);
+ return EXPR_ERROR_INVALIDCHAR;
+ }
+ }
+
+ break;
+ }
+ }
+ }
+
+ /* If pass is 0, allocate memory for next pass */
+ if(pass == 0)
+ {
+ /* First, make sure all comments were ended */
+ if(comment)
+ comment = 0;
+
+ /* Make sure the expression is not empty */
+ if(found == 0)
+ return EXPR_ERROR_EMPTYEXPR;
+
+ /* Allocate memory for token list */
+ list = exprAllocMem(found * sizeof(exprToken));
+ if(list == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ tpos = 0;
+ }
+ }
+
+ *count = found;
+ *tokens = list;
+ return EXPR_ERROR_NOERROR;
+ }
+
+
+/* This is the main parsing routine */
+int exprParse(exprObj *obj, char *expr)
+ {
+ exprToken *tokens;
+ int count;
+ int err;
+ exprNode *tmp;
+
+ /* Make sure an object was passed */
+ if(obj == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Clear expression error position */
+ obj->starterr = obj->enderr = -1;
+
+ /* Have we already been parsed? */
+ if(obj->parsedbad != 0)
+ return EXPR_ERROR_ALREADYPARSEDBAD;
+
+ if(obj->parsedgood != 0)
+ return EXPR_ERROR_ALREADYPARSEDGOOD;
+
+ /* Make sure an expression was passed */
+ if(expr == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Create token list */
+ err = exprStringToTokenList(obj, expr, &tokens, &count);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* Create head pointer */
+ tmp = exprAllocNodes(1);
+ if(tmp == NULL)
+ {
+ exprFreeTokenList(tokens, count);
+ return EXPR_ERROR_MEMORY;
+ }
+
+ obj->headnode = tmp;
+
+ /* Call the multiparse routine to parse subexpressions */
+ err = exprMultiParse(obj, tmp, tokens, count);
+
+ /* Free the token list */
+ exprFreeTokenList(tokens, count);
+
+ /* successful parse? */
+ if(err == EXPR_ERROR_NOERROR)
+ {
+ obj->parsedgood = 1;
+ obj->parsedbad = 0;
+ }
+ else
+ {
+ obj->parsedbad = 1;
+ obj->parsedgood = 0;
+ }
+
+ return err;
+ }
+
+
+/* Parse the subexpressions, each ending with semicolons */
+int exprMultiParse(exprObj *obj, exprNode *node, exprToken *tokens, int count)
+ {
+ int pos, plevel, last;
+ int num, cur, err;
+ exprNode *tmp;
+
+ plevel = 0;
+ num = 0;
+ last = -1;
+
+ /* First count the number of arguments */
+ for(pos = 0; pos < count; pos++)
+ {
+ switch(tokens[pos].type)
+ {
+ case EXPR_TOKEN_OPAREN:
+ /* increase plevel */
+ plevel++;
+ break;
+
+ case EXPR_TOKEN_CPAREN:
+ /* decrease plevel */
+ plevel--;
+
+ if(plevel < 0)
+ {
+ obj->starterr = tokens[pos].start;
+ obj->enderr = tokens[pos].end;
+ return EXPR_ERROR_UNMATCHEDPAREN;
+ }
+
+ break;
+
+ case EXPR_TOKEN_SEMICOLON:
+ if(plevel == 0)
+ {
+ if(last == pos - 1 || pos == 0)
+ {
+ /* last semicolon is before us or we are at the start */
+ obj->starterr = tokens[pos].start;
+ obj->enderr = tokens[pos].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+ else
+ {
+ /* last semicolon is not right before us */
+ num++;
+ }
+ }
+ else
+ {
+ /* Semicolon should not be in a parenthesis */
+ obj->starterr = tokens[pos].start;
+ obj->enderr = tokens[pos].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ last = pos; /* update position of last semicolon */
+ break;
+ }
+ }
+
+ /* plevel should be zero now */
+ if(plevel != 0)
+ return EXPR_ERROR_UNMATCHEDPAREN;
+
+ /* the last character should be a semicolon */
+ if(last != pos - 1)
+ return EXPR_ERROR_MISSINGSEMICOLON;
+
+ /* Now we know how many arguments there are */
+
+ /* Allocate array of subnodes */
+ tmp = exprAllocNodes(num);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ /* Set the current node's data */
+ node->type = EXPR_NODETYPE_MULTI;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = num;
+
+ /* now we parse each subexpression */
+ last = 0; /* Not for last semicolon, but for first char of subexpr */
+ cur = 0;
+
+ for(pos = 0; pos < count; pos++)
+ {
+ if(tokens[pos].type == EXPR_TOKEN_SEMICOLON)
+ {
+ /* Everything from last up to pos - 1 is a parameter */
+ err = exprInternalParse(obj, &(tmp[cur]), tokens, last, pos - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* Update last position and current argument */
+ last = pos + 1;
+ cur++;
+ }
+ }
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* This function parses each subnode and recurses if needed */
+int exprInternalParse(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end)
+ {
+ int pos;
+ int plevel = 0; /* Paren level */
+ int fgopen = -1; /* First paren group open index */
+ int fgclose = -1; /* First paren group close index */
+ int assignindex = -1; /* First = at plevel 0 for assignment */
+ int addsubindex = -1; /* Last + or - at plevel 0 for adding or subtracting */
+ int muldivindex = -1; /* Last * or / at plevel 0 for multiplying or dividing */
+ int expindex = -1; /* Last ^ fount at plevel 0 for exponents */
+ int posnegindex = -1; /* First +,- at plevel 0 for positive,negative */
+
+ /* Make sure some conditions are right */
+ if(start > end)
+ return EXPR_ERROR_UNKNOWN;
+
+ /* Scan the string for certain characters */
+ for(pos = start; pos <= end; pos++)
+ {
+ switch(tokens[pos].type)
+ {
+ case EXPR_TOKEN_OPAREN:
+ plevel++;
+
+ /* First group open? */
+ if(plevel == 1 && fgopen == -1)
+ fgopen = pos;
+ break;
+
+ case EXPR_TOKEN_CPAREN:
+ plevel--;
+
+ /* First group close? */
+ if(plevel == 0 && fgclose == -1)
+ fgclose = pos;
+
+ if(plevel < 0)
+ {
+ obj->starterr = tokens[pos].start;
+ obj->enderr = tokens[pos].end;
+ return EXPR_ERROR_UNMATCHEDPAREN;
+ }
+ break;
+
+ case EXPR_TOKEN_EQUAL:
+ /* Assignment found */
+ if(plevel == 0)
+ {
+ if(assignindex == -1)
+ assignindex = pos;
+ }
+ break;
+
+ case EXPR_TOKEN_ASTERISK:
+ case EXPR_TOKEN_FSLASH:
+ /* Multiplication or division */
+ if(plevel == 0)
+ muldivindex = pos;
+ break;
+
+ case EXPR_TOKEN_HAT:
+ /* Exponent */
+ if(plevel == 0)
+ expindex = pos;
+ break;
+
+
+ case EXPR_TOKEN_PLUS:
+ case EXPR_TOKEN_HYPHEN:
+ /* Addition or positive or subtraction or negative*/
+ if(plevel == 0)
+ {
+ if(pos == start)
+ {
+ /* At the start area, positive/negative */
+ if(posnegindex == -1)
+ posnegindex = pos;
+ }
+ else
+ {
+ /* Not at start, check item in front */
+ switch(tokens[pos - 1].type)
+ {
+ case EXPR_TOKEN_EQUAL: /* Equal sign */
+ case EXPR_TOKEN_PLUS: /* Add/positive sign */
+ case EXPR_TOKEN_HYPHEN: /* Subtract/negative sign */
+ case EXPR_TOKEN_ASTERISK: /* Multiply sign */
+ case EXPR_TOKEN_FSLASH: /* Divide sign */
+ case EXPR_TOKEN_HAT: /* Exponent sign */
+
+ /* After theses, it is positive/negative */
+ if(posnegindex == -1)
+ posnegindex = pos;
+
+ break;
+
+ default:
+ /* Otherwise it is addition/subtraction */
+ addsubindex = pos;
+ break;
+ }
+ }
+ }
+ break;
+
+ }
+ }
+
+ /* plevel should now be zero */
+ if(plevel != 0)
+ return EXPR_ERROR_UNMATCHEDPAREN;
+
+ /* We must parse the data in a certain order to maintain the
+ correct order of operators at evaluation time */
+
+ /* First, take care of assignment */
+ if(assignindex != -1)
+ return exprInternalParseAssign(obj, node, tokens, start, end, assignindex);
+
+ /* Addition or subtraction is next */
+ if(addsubindex != -1)
+ {
+ if(tokens[addsubindex].type == EXPR_TOKEN_PLUS)
+ return exprInternalParseAdd(obj, node, tokens, start, end, addsubindex);
+ else
+ return exprInternalParseSub(obj, node, tokens, start, end, addsubindex);
+ }
+
+
+ /* Multiplycation or division */
+ if(muldivindex != -1)
+ {
+ if(tokens[muldivindex].type == EXPR_TOKEN_ASTERISK)
+ return exprInternalParseMul(obj, node, tokens, start, end, muldivindex);
+ else
+ return exprInternalParseDiv(obj, node, tokens, start, end, muldivindex);
+ }
+
+ /* Exponent */
+ if(expindex != -1)
+ return exprInternalParseExp(obj, node, tokens, start, end, expindex);
+
+ /* Negation */
+ if(posnegindex != -1)
+ return exprInternalParsePosNeg(obj, node, tokens, start, end, posnegindex);
+
+
+ /* Grouped parenthesis */
+ if(fgopen == start)
+ {
+ /* Closing paren. should be at the end */
+ if(fgclose == end)
+ {
+ /* Anything between them */
+ if(fgclose > fgopen + 1)
+ {
+ return exprInternalParse(obj, node, tokens, fgopen + 1, fgclose - 1);
+ }
+ else
+ {
+ /* Nothing between them */
+ obj->starterr = tokens[fgopen].start;
+ obj->enderr = tokens[fgclose].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+ }
+ else /* Closing paren not at the end */
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* Functions */
+ if(fgopen > start)
+ {
+ /* Closing paren should be at end */
+ if(fgclose == end)
+ {
+ return exprInternalParseFunction(obj, node, tokens, start, end, fgopen, fgclose);
+ }
+ else /* Closing paren not at end */
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* If it was none of the above, it must be a variable or value */
+ return exprInternalParseVarVal(obj, node, tokens, start, end);
+ }
+
+/* Function to parse an assignment node */
+int exprInternalParseAssign(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+ exprValList *l;
+ EXPRTYPE *addr;
+
+ /* Make sure the equal sign is not at the start or end */
+ if(index != start + 1 || index >= end)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* Make sure item before equal sign is an identifier */
+ if(tokens[index - 1].type != EXPR_TOKEN_IDENTIFIER)
+ {
+ obj->starterr = tokens[index - 1].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* Create expression subnode */
+ tmp = exprAllocNodes(1);
+ if(tmp == NULL)
+ {
+ return EXPR_ERROR_MEMORY;
+ }
+
+
+ /* Set the data */
+ node->type = EXPR_NODETYPE_ASSIGN;
+ node->data.assign.node = tmp;
+
+
+ /*
+ The fast access method directly accesses the memory address
+ of the variable's value at evaluation time. Because of this,
+ we must make sure the variable does exists in the variable list.
+ */
+
+ /* Make sure name is not a constant name */
+ l = exprGetConstList(obj);
+ if(l)
+ {
+ exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
+ if(addr)
+ {
+ obj->starterr = tokens[index - 1].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_CONSTANTASSIGN;
+ }
+ }
+
+ /* Get the variable list */
+ l = exprGetVarList(obj);
+ if(l == NULL)
+ return EXPR_ERROR_NOVARLIST;
+
+ /* Get variable address if already in the list */
+ exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
+ if(addr == NULL) /* Variable not in the list, add it */
+ {
+ exprValListAdd(l, tokens[index - 1].data.str, 0.0);
+
+ /* Try to get address again */
+ exprValListGetAddress(l, tokens[index - 1].data.str, &addr);
+ if(addr == NULL) /* Could not add variable */
+ return EXPR_ERROR_MEMORY; /* Could not add variable to list */
+ }
+
+ node->data.assign.vaddr = addr;
+
+ /* Parse the subnode */
+ return exprInternalParse(obj, tmp, tokens, index + 1, end);
+ }
+
+/* Function to parse an addition operator */
+int exprInternalParseAdd(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+ int err;
+
+ /* Make sure plus sign is at a good place */
+ if(index <= start || index >= end)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* Allocate space for 2 subnodes */
+ tmp = exprAllocNodes(2);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+
+ /* Set the data */
+ node->type = EXPR_NODETYPE_ADD;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = 2;
+
+ /* parse the left side */
+ err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* parse the right side */
+ return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
+ }
+
+/* Function to parse a subtraction operator */
+int exprInternalParseSub(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+ int err;
+
+ /* Make sure minus sign is at a good place */
+ if(index <= start || index >= end)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* Allocate space for 2 subnodes */
+ tmp = exprAllocNodes(2);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+
+ /* Set the data */
+ node->type = EXPR_NODETYPE_SUBTRACT;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = 2;
+
+ /* parse the left side */
+ err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* parse the right side */
+ return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
+ }
+
+/* Function to parse a multiplication operator */
+int exprInternalParseMul(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+ int err;
+
+ /* Make sure times sign is at a good place */
+ if(index <= start || index >= end)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+
+ /* Allocate space for 2 subnodes */
+ tmp = exprAllocNodes(2);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+
+ /* Set the data */
+ node->type = EXPR_NODETYPE_MULTIPLY;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = 2;
+
+ /* parse the left side */
+ err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* parse the right side */
+ return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
+ }
+
+/* Function to parse a division operator */
+int exprInternalParseDiv(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+ int err;
+
+ /* Make sure slash sign is at a good place */
+ if(index <= start || index >= end)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+
+ /* Allocate space for 2 subnodes */
+ tmp = exprAllocNodes(2);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+
+ /* Set the data */
+ node->type = EXPR_NODETYPE_DIVIDE;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = 2;
+
+ /* parse the left side */
+ err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* parse the right side */
+ return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
+ }
+
+/* Function to parse an exponent operator */
+int exprInternalParseExp(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+ int err;
+
+ /* Make sure exponent sign is at a good place */
+ if(index <= start || index >= end)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+
+ /* Allocate space for 2 subnodes */
+ tmp = exprAllocNodes(2);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+
+ /* Set the data */
+ node->type = EXPR_NODETYPE_EXPONENT;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = 2;
+
+ /* parse the left side */
+ err = exprInternalParse(obj, &(tmp[0]), tokens, start, index - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* parse the right side */
+ return exprInternalParse(obj, &(tmp[1]), tokens, index + 1, end);
+ }
+
+/* Function to parse for positive and negative */
+int exprInternalParsePosNeg(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int index)
+ {
+ exprNode *tmp;
+
+ /* Position should be the same as start */
+ if(index != start)
+ {
+ obj->starterr = tokens[index].start;
+ obj->enderr = tokens[index].end;
+ return EXPR_ERROR_UNKNOWN;
+ }
+
+ /* If it is a positive, just parse the internal of it */
+ if(tokens[index].type == EXPR_TOKEN_PLUS)
+ return exprInternalParse(obj, node, tokens, index + 1, end);
+ else
+ {
+ /* Allocate subnode */
+ tmp = exprAllocNodes(1);
+ if(tmp == NULL)
+ return EXPR_ERROR_NOERROR;
+
+
+ /* Set data */
+ node->type = EXPR_NODETYPE_NEGATE;
+ node->data.oper.nodes = tmp;
+ node->data.oper.nodecount = 1;
+
+ /* Parse the subnode */
+ return exprInternalParse(obj, tmp, tokens, index + 1, end);
+ }
+ }
+
+/* Function will parse a call to a function */
+int exprInternalParseFunction(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end, int p1, int p2)
+ {
+ int pos;
+ int num, cur;
+ int refnum, refcur;
+ int plevel = 0;
+ int lv, err;
+ exprNode *tmp;
+ exprFuncType fptr;
+ int argmin, argmax;
+ int refargmin, refargmax;
+ int type;
+ exprFuncList *l;
+ exprValList *vars;
+ EXPRTYPE *addr;
+ EXPRTYPE **reftmp;
+
+ /* We should have a function list */
+ l = exprGetFuncList(obj);
+ if(l == NULL)
+ return EXPR_ERROR_NOSUCHFUNCTION;
+
+ /* check paren. location */
+ if(p2 <= p1)
+ return EXPR_ERROR_SYNTAX;
+
+ /* second paren. should not be after the end */
+ if(p2 > end)
+ return EXPR_ERROR_SYNTAX;
+
+ /* Item before parenthesis should be an identifier */
+ if(tokens[p1 - 1].type != EXPR_TOKEN_IDENTIFIER)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p1].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+
+ /* Look up the function */
+ err = exprFuncListGet(l, tokens[p1 - 1].data.str, &fptr, &type, &argmin, &argmax, &refargmin, &refargmax);
+ if(err != EXPR_ERROR_NOERROR)
+ {
+ if(err == EXPR_ERROR_NOTFOUND)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p1 - 1].end;
+ return EXPR_ERROR_NOSUCHFUNCTION;
+ }
+ else
+ return err;
+ }
+
+ /* Make sure the function exists */
+ if(fptr == NULL && type == 0)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p1 - 1].end;
+ return EXPR_ERROR_NOSUCHFUNCTION;
+ }
+
+ /* Count arguments */
+ if(p2 == p1 + 1)
+ {
+ num = 0;
+ refnum = 0;
+ }
+ else
+ {
+ num = 1;
+ refnum = 0;
+
+
+ /* count commas */
+ for(pos = p1 + 1; pos < p2; pos++)
+ {
+ switch(tokens[pos].type)
+ {
+ case EXPR_TOKEN_OPAREN:
+ plevel++;
+ break;
+
+ case EXPR_TOKEN_CPAREN:
+ plevel--;
+ if(plevel < 0)
+ {
+ obj->starterr = tokens[pos].start;
+ obj->enderr = tokens[pos].end;
+ return EXPR_ERROR_UNMATCHEDPAREN;
+ }
+ break;
+
+ case EXPR_TOKEN_COMMA:
+ /* Found comma */
+ if(plevel == 0)
+ num++;
+ break;
+
+ case EXPR_TOKEN_AMPERSAND:
+ /* Found reference mark */
+ if(plevel == 0)
+ {
+ /* This may only occur after the open parenthesis or comma */
+ if(tokens[pos - 1].type == EXPR_TOKEN_OPAREN || tokens[pos - 1].type == EXPR_TOKEN_COMMA)
+ refnum++;
+ else
+ return EXPR_ERROR_SYNTAX;
+ }
+ break;
+ }
+ }
+
+ /* plevel should be zero */
+ if(plevel != 0)
+ return EXPR_ERROR_UNMATCHEDPAREN;
+ }
+
+ /* We now have the number of total arguments and
+ number of ref arguments. Get number of normal
+ arguments */
+ num = num - refnum;
+
+ /* Make sure number of arguments is correct */
+ /* Here we make sure the limits are greater
+ or equal to zero because any negative number
+ could be used to specify no limit */
+ if(argmin >= 0 && num < argmin)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p2].end;
+ return EXPR_ERROR_BADNUMBERARGUMENTS;
+ }
+
+ if(argmax >= 0 && num > argmax)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p2].end;
+ return EXPR_ERROR_BADNUMBERARGUMENTS;
+ }
+
+ if(refargmin >= 0 && refnum < refargmin)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p2].end;
+ return EXPR_ERROR_BADNUMBERARGUMENTS;
+ }
+
+ if(refargmax >= 0 && refnum > refargmax)
+ {
+ obj->starterr = tokens[p1 - 1].start;
+ obj->enderr = tokens[p2].end;
+ return EXPR_ERROR_BADNUMBERARGUMENTS;
+ }
+
+ /* Set tmp to null in case of no arguments */
+ tmp = NULL;
+ reftmp = NULL;
+
+ if(num > 0)
+ {
+ /* Allocate subnodes */
+ tmp = exprAllocNodes(num);
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+ }
+
+ if(refnum > 0)
+ {
+ /* Allocate ref pointers */
+ reftmp = exprAllocMem(sizeof(EXPRTYPE*) * refnum);
+ if(reftmp == NULL)
+ {
+ exprFreeMem(tmp);
+ return EXPR_ERROR_MEMORY;
+ }
+ }
+
+
+
+ /* Set this node's data */
+ node->type = EXPR_NODETYPE_FUNCTION;
+ node->data.function.fptr = fptr;
+ node->data.function.nodecount = num;
+ node->data.function.nodes = tmp;
+ node->data.function.refcount = refnum;
+ node->data.function.refs = reftmp;
+ node->data.function.type = type;
+
+ /* parse each subnode */
+ if(num + refnum > 0)
+ {
+ plevel = 0;
+ cur = 0;
+ refcur = 0;
+ lv = p1 + 1;
+
+ /* look for commas if more than 1 arg */
+ if(num + refnum > 1)
+ {
+ for(pos = p1 + 1; pos < p2; pos++)
+ {
+ switch(tokens[pos].type)
+ {
+ case EXPR_TOKEN_OPAREN:
+ plevel++;
+ break;
+
+ case EXPR_TOKEN_CPAREN:
+ plevel--;
+ break; /* Already checked paren nesting above */
+
+ case EXPR_TOKEN_COMMA:
+ /* Found comma */
+ if(plevel == 0)
+ {
+ /* parse inside */
+ if(tokens[lv].type == EXPR_TOKEN_AMPERSAND)
+ {
+ if(lv != pos - 2)
+ {
+ obj->starterr = tokens[lv].start;
+ obj->enderr = tokens[pos].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* It is a reference */
+ if(tokens[lv + 1].type != EXPR_TOKEN_IDENTIFIER)
+ {
+ obj->starterr = tokens[lv].start;
+ obj->enderr = tokens[lv + 1].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+
+ /* Make sure it is not a constant */
+ vars = exprGetConstList(obj);
+ if(vars)
+ {
+ exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
+ if(addr)
+ {
+ obj->starterr = tokens[lv].start;
+ obj->enderr = tokens[lv + 1].start;
+ return EXPR_ERROR_REFCONSTANT;
+ }
+ }
+
+ /* Get variable list */
+ vars = exprGetVarList(obj);
+ if(vars == NULL)
+ return EXPR_ERROR_NOVARLIST;
+
+ /* Get variable address */
+ exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
+ if(addr == NULL)
+ {
+ /* Add variable to list */
+ exprValListAdd(vars, tokens[lv + 1].data.str, 0.0);
+
+ /* Try to get address again */
+ exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
+ if(addr == NULL)
+ return EXPR_ERROR_MEMORY; /* Could not add variable */
+ }
+
+ /* Set reference item */
+ reftmp[refcur] = addr;
+
+ /* increase ref arg number and lv position*/
+ refcur++;
+ lv = pos + 1;
+ }
+ else
+ {
+ err = exprInternalParse(obj, &(tmp[cur]), tokens, lv, pos - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+
+ /* increase arg number and lv position*/
+ lv = pos + 1;
+ cur++;
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ /* lv should point after the last comma, or open paren. if only 1 arg */
+ if(tokens[lv].type == EXPR_TOKEN_AMPERSAND)
+ {
+ if(lv != p2 - 2)
+ {
+ obj->starterr = tokens[lv].start;
+ obj->enderr = tokens[p2].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* It is a reference */
+ if(tokens[lv + 1].type != EXPR_TOKEN_IDENTIFIER)
+ {
+ obj->starterr = tokens[lv].start;
+ obj->enderr = tokens[lv + 1].end;
+ return EXPR_ERROR_SYNTAX;
+ }
+
+ /* Make sure it is not a constant */
+ vars = exprGetConstList(obj);
+ if(vars)
+ {
+ exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
+ if(addr)
+ {
+ obj->starterr = tokens[lv].start;
+ obj->enderr = tokens[lv + 1].start;
+ return EXPR_ERROR_REFCONSTANT;
+ }
+ }
+
+ /* Get variable list */
+ vars = exprGetVarList(obj);
+ if(vars == NULL)
+ return EXPR_ERROR_NOVARLIST;
+
+ /* Get variable address */
+ exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
+ if(addr == NULL)
+ {
+ /* Add variable to list */
+ exprValListAdd(vars, tokens[lv + 1].data.str, 0.0);
+
+ /* Try to get address again */
+ exprValListGetAddress(vars, tokens[lv + 1].data.str, &addr);
+ if(addr == NULL)
+ return EXPR_ERROR_MEMORY; /* Could not add variable */
+ }
+
+ /* Set reference item */
+ reftmp[refcur] = addr;
+ }
+ else
+ {
+ err = exprInternalParse(obj, &(tmp[cur]), tokens, lv, p2 - 1);
+ if(err != EXPR_ERROR_NOERROR)
+ return err;
+ }
+ }
+
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Parse a variable or value */
+int exprInternalParseVarVal(exprObj *obj, exprNode *node, exprToken *tokens, int start, int end)
+ {
+ exprValList *l;
+ EXPRTYPE *addr;
+
+
+ /* Make sure positions are correct */
+ if(start != end)
+ {
+ return EXPR_ERROR_UNKNOWN;
+ }
+
+
+ /* Are we an identifier */
+ if(tokens[start].type == EXPR_TOKEN_IDENTIFIER)
+ {
+ /* we are an identifier */
+
+ /* check to see if it is a constant */
+ l = exprGetConstList(obj);
+ if(l != NULL)
+ {
+ if(exprValListGetAddress(l, tokens[start].data.str, &addr) == EXPR_ERROR_NOERROR)
+ {
+ /* We found it in the constant list */
+
+ /*
+ Treat is like a variable node so application can change
+ constant value and it will reflect in expression
+ */
+
+ node->type = EXPR_NODETYPE_VARIABLE;
+ node->data.variable.vaddr = addr;
+ return EXPR_ERROR_NOERROR;
+ }
+ }
+
+ /* Not found in the constant list, so it must be a variable */
+
+ /* Set node type */
+ node->type = EXPR_NODETYPE_VARIABLE;
+
+ /*
+ The fast access method directly accesses the memory address
+ of the variable's value at evaluation time. Because of this,
+ we must make sure the variable does exists in the variable list.
+ */
+
+ /* Get the variable list */
+ l = exprGetVarList(obj);
+ if(l == NULL)
+ return EXPR_ERROR_NOVARLIST;
+
+ /* Get variable address if already in the list */
+ exprValListGetAddress(l, tokens[start].data.str, &addr);
+ if(addr == NULL) /* Variable not in the list, add it */
+ {
+ exprValListAdd(l, tokens[start].data.str, 0.0);
+
+ /* Try to get address again */
+ exprValListGetAddress(l, tokens[start].data.str, &addr);
+ if(addr == NULL) /* Could not add variable */
+ return EXPR_ERROR_MEMORY; /* Could not add variable to list */
+ }
+
+ node->data.variable.vaddr = addr;
+
+ return EXPR_ERROR_NOERROR;
+ }
+ else if(tokens[start].type == EXPR_TOKEN_VALUE)
+ {
+ /* we are a value */
+ node->type = EXPR_NODETYPE_VALUE;
+ node->data.value.value = tokens[start].data.val;
+ return EXPR_ERROR_NOERROR;
+ }
+ else
+ {
+ obj->starterr = tokens[start].start;
+ obj->enderr = tokens[end].end;
+ return EXPR_ERROR_UNKNOWN;
+ }
+ }
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprpriv.h
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprpriv.h (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprpriv.h Tue Nov 13 15:23:26 2007
@@ -1,215 +1,215 @@
-/*
- File: exprpriv.h
- Auth: Brian Allen Vanderburg II
- Date: Tuesday, February 28, 2006
- Desc: Private include file for ExprEval library
-
- This file is part of ExprEval.
-*/
-
-
-/* Include once */
-#ifndef __BAVII_EXPRPRIV_H
-#define __BAVII_EXPRPRIV_H
-
-/* Need some definitions, NULL, etc */
-#include <stddef.h>
-
-/* Include config and main expreval header */
-#include "expreval.h"
-#include "exprconf.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- Version number
-*/
-#define EXPR_VERSIONMAJOR 2
-#define EXPR_VERSIONMINOR 7
-
-/* Node types */
-enum
- {
- EXPR_NODETYPE_UNKNOWN = 0,
- EXPR_NODETYPE_MULTI,
- EXPR_NODETYPE_ADD,
- EXPR_NODETYPE_SUBTRACT,
- EXPR_NODETYPE_MULTIPLY,
- EXPR_NODETYPE_DIVIDE,
- EXPR_NODETYPE_EXPONENT,
- EXPR_NODETYPE_NEGATE,
- EXPR_NODETYPE_VALUE,
- EXPR_NODETYPE_VARIABLE,
- EXPR_NODETYPE_ASSIGN,
- EXPR_NODETYPE_FUNCTION
- };
-
-/* Functions can be evaluated directly in EXPREVAL. If fptr
- is NULL, type is used to determine what the function is */
-enum
- {
- EXPR_NODEFUNC_UNKNOWN = 0,
- EXPR_NODEFUNC_ABS,
- EXPR_NODEFUNC_MOD,
- EXPR_NODEFUNC_IPART,
- EXPR_NODEFUNC_FPART,
- EXPR_NODEFUNC_MIN,
- EXPR_NODEFUNC_MAX,
- EXPR_NODEFUNC_POW,
- EXPR_NODEFUNC_SQRT,
- EXPR_NODEFUNC_SIN,
- EXPR_NODEFUNC_SINH,
- EXPR_NODEFUNC_ASIN,
- EXPR_NODEFUNC_COS,
- EXPR_NODEFUNC_COSH,
- EXPR_NODEFUNC_ACOS,
- EXPR_NODEFUNC_TAN,
- EXPR_NODEFUNC_TANH,
- EXPR_NODEFUNC_ATAN,
- EXPR_NODEFUNC_ATAN2,
- EXPR_NODEFUNC_LOG,
- EXPR_NODEFUNC_POW10,
- EXPR_NODEFUNC_LN,
- EXPR_NODEFUNC_EXP,
- EXPR_NODEFUNC_LOGN,
- EXPR_NODEFUNC_CEIL,
- EXPR_NODEFUNC_FLOOR,
- EXPR_NODEFUNC_RAND,
- EXPR_NODEFUNC_RANDOM,
- EXPR_NODEFUNC_RANDOMIZE,
- EXPR_NODEFUNC_DEG,
- EXPR_NODEFUNC_RAD,
- EXPR_NODEFUNC_RECTTOPOLR,
- EXPR_NODEFUNC_RECTTOPOLA,
- EXPR_NODEFUNC_POLTORECTX,
- EXPR_NODEFUNC_POLTORECTY,
- EXPR_NODEFUNC_IF,
- EXPR_NODEFUNC_SELECT,
- EXPR_NODEFUNC_EQUAL,
- EXPR_NODEFUNC_ABOVE,
- EXPR_NODEFUNC_BELOW,
- EXPR_NODEFUNC_AVG,
- EXPR_NODEFUNC_CLIP,
- EXPR_NODEFUNC_CLAMP,
- EXPR_NODEFUNC_PNTCHANGE,
- EXPR_NODEFUNC_POLY,
- EXPR_NODEFUNC_AND,
- EXPR_NODEFUNC_OR,
- EXPR_NODEFUNC_NOT,
- EXPR_NODEFUNC_FOR,
- EXPR_NODEFUNC_MANY
- };
-
-/* Forward declarations */
-typedef struct _exprFunc exprFunc;
-typedef struct _exprVal exprVal;
-
-/* Expression object */
-struct _exprObj
- {
- struct _exprFuncList *flist; /* Functions */
- struct _exprValList *vlist; /* Variables */
- struct _exprValList *clist; /* Constants */
- struct _exprNode *headnode; /* Head parsed node */
-
- exprBreakFuncType breakerfunc; /* Break function type */
-
- void *userdata; /* User data, can be any 32 bit value */
- int parsedgood; /* non-zero if successfully parsed */
- int parsedbad; /* non-zero if parsed but unsuccessful */
- int breakcount; /* how often to check the breaker function */
- int breakcur; /* do we check the breaker function yet */
- int starterr; /* start position of an error */
- int enderr; /* end position of an error */
- };
-
-/* Object for a function */
-struct _exprFunc
- {
- char *fname; /* Name of the function */
- exprFuncType fptr; /* Function pointer */
- int min, max; /* Min and max args for the function. */
- int refmin, refmax; /* Min and max ref. variables for the function */
- int type; /* Function node type. exprEvalNOde solves the function */
-
- struct _exprFunc *next; /* For linked list */
- };
-
-/* Function list object */
-struct _exprFuncList
- {
- struct _exprFunc *head;
- };
-
-/* Object for values */
-struct _exprVal
- {
- char *vname; /* Name of the value */
- EXPRTYPE vval; /* Value of the value */
- EXPRTYPE *vptr; /* Pointer to a value. Used only if not NULL */
-
- struct _exprVal *next; /* For linked list */
- };
-
-/* Value list */
-struct _exprValList
- {
- struct _exprVal *head;
- };
-
-/* Expression node type */
-struct _exprNode
- {
- int type; /* Node type */
-
- union _data /* Union of info for various types */
- {
- struct _oper
- {
- struct _exprNode *nodes; /* Operation arguments */
- int nodecount; /* Number of arguments */
- } oper;
-
- struct _variable
- {
- EXPRTYPE *vaddr; /* Used if EXPR_FAST_VAR_ACCESS defined */
- } variable;
-
- struct _value
- {
- EXPRTYPE value; /* Value if type is value */
- } value;
-
- struct _assign /* Assignment struct */
- {
- EXPRTYPE *vaddr; /* Used if EXPR_FAST_VAR_ACCESS defined */
- struct _exprNode *node; /* Node to evaluate */
- } assign;
-
- struct _function
- {
- exprFuncType fptr; /* Function pointer */
- struct _exprNode *nodes; /* Array of argument nodes */
- int nodecount; /* Number of argument nodes */
- EXPRTYPE **refs; /* Reference variables */
- int refcount; /* Number of variable references (not a reference counter) */
- int type; /* Type of function for exprEvalNode if fptr is NULL */
- } function;
- } data;
- };
-
-
-
-/* Functions for function lists */
-int exprFuncListAddType(exprFuncList *flist, char *name, int type, int min, int max, int refmin, int refmax);
-int exprFuncListGet(exprFuncList *flist, char *name, exprFuncType *ptr, int *type, int *min, int *max, int *refmin, int *refmax);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __BAVII_EXPRPRIV_H */
-
+/*
+ File: exprpriv.h
+ Auth: Brian Allen Vanderburg II
+ Date: Tuesday, February 28, 2006
+ Desc: Private include file for ExprEval library
+
+ This file is part of ExprEval.
+*/
+
+
+/* Include once */
+#ifndef __BAVII_EXPRPRIV_H
+#define __BAVII_EXPRPRIV_H
+
+/* Need some definitions, NULL, etc */
+#include <stddef.h>
+
+/* Include config and main expreval header */
+#include "expreval.h"
+#include "exprconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ Version number
+*/
+#define EXPR_VERSIONMAJOR 2
+#define EXPR_VERSIONMINOR 7
+
+/* Node types */
+enum
+ {
+ EXPR_NODETYPE_UNKNOWN = 0,
+ EXPR_NODETYPE_MULTI,
+ EXPR_NODETYPE_ADD,
+ EXPR_NODETYPE_SUBTRACT,
+ EXPR_NODETYPE_MULTIPLY,
+ EXPR_NODETYPE_DIVIDE,
+ EXPR_NODETYPE_EXPONENT,
+ EXPR_NODETYPE_NEGATE,
+ EXPR_NODETYPE_VALUE,
+ EXPR_NODETYPE_VARIABLE,
+ EXPR_NODETYPE_ASSIGN,
+ EXPR_NODETYPE_FUNCTION
+ };
+
+/* Functions can be evaluated directly in EXPREVAL. If fptr
+ is NULL, type is used to determine what the function is */
+enum
+ {
+ EXPR_NODEFUNC_UNKNOWN = 0,
+ EXPR_NODEFUNC_ABS,
+ EXPR_NODEFUNC_MOD,
+ EXPR_NODEFUNC_IPART,
+ EXPR_NODEFUNC_FPART,
+ EXPR_NODEFUNC_MIN,
+ EXPR_NODEFUNC_MAX,
+ EXPR_NODEFUNC_POW,
+ EXPR_NODEFUNC_SQRT,
+ EXPR_NODEFUNC_SIN,
+ EXPR_NODEFUNC_SINH,
+ EXPR_NODEFUNC_ASIN,
+ EXPR_NODEFUNC_COS,
+ EXPR_NODEFUNC_COSH,
+ EXPR_NODEFUNC_ACOS,
+ EXPR_NODEFUNC_TAN,
+ EXPR_NODEFUNC_TANH,
+ EXPR_NODEFUNC_ATAN,
+ EXPR_NODEFUNC_ATAN2,
+ EXPR_NODEFUNC_LOG,
+ EXPR_NODEFUNC_POW10,
+ EXPR_NODEFUNC_LN,
+ EXPR_NODEFUNC_EXP,
+ EXPR_NODEFUNC_LOGN,
+ EXPR_NODEFUNC_CEIL,
+ EXPR_NODEFUNC_FLOOR,
+ EXPR_NODEFUNC_RAND,
+ EXPR_NODEFUNC_RANDOM,
+ EXPR_NODEFUNC_RANDOMIZE,
+ EXPR_NODEFUNC_DEG,
+ EXPR_NODEFUNC_RAD,
+ EXPR_NODEFUNC_RECTTOPOLR,
+ EXPR_NODEFUNC_RECTTOPOLA,
+ EXPR_NODEFUNC_POLTORECTX,
+ EXPR_NODEFUNC_POLTORECTY,
+ EXPR_NODEFUNC_IF,
+ EXPR_NODEFUNC_SELECT,
+ EXPR_NODEFUNC_EQUAL,
+ EXPR_NODEFUNC_ABOVE,
+ EXPR_NODEFUNC_BELOW,
+ EXPR_NODEFUNC_AVG,
+ EXPR_NODEFUNC_CLIP,
+ EXPR_NODEFUNC_CLAMP,
+ EXPR_NODEFUNC_PNTCHANGE,
+ EXPR_NODEFUNC_POLY,
+ EXPR_NODEFUNC_AND,
+ EXPR_NODEFUNC_OR,
+ EXPR_NODEFUNC_NOT,
+ EXPR_NODEFUNC_FOR,
+ EXPR_NODEFUNC_MANY
+ };
+
+/* Forward declarations */
+typedef struct _exprFunc exprFunc;
+typedef struct _exprVal exprVal;
+
+/* Expression object */
+struct _exprObj
+ {
+ struct _exprFuncList *flist; /* Functions */
+ struct _exprValList *vlist; /* Variables */
+ struct _exprValList *clist; /* Constants */
+ struct _exprNode *headnode; /* Head parsed node */
+
+ exprBreakFuncType breakerfunc; /* Break function type */
+
+ void *userdata; /* User data, can be any 32 bit value */
+ int parsedgood; /* non-zero if successfully parsed */
+ int parsedbad; /* non-zero if parsed but unsuccessful */
+ int breakcount; /* how often to check the breaker function */
+ int breakcur; /* do we check the breaker function yet */
+ int starterr; /* start position of an error */
+ int enderr; /* end position of an error */
+ };
+
+/* Object for a function */
+struct _exprFunc
+ {
+ char *fname; /* Name of the function */
+ exprFuncType fptr; /* Function pointer */
+ int min, max; /* Min and max args for the function. */
+ int refmin, refmax; /* Min and max ref. variables for the function */
+ int type; /* Function node type. exprEvalNOde solves the function */
+
+ struct _exprFunc *next; /* For linked list */
+ };
+
+/* Function list object */
+struct _exprFuncList
+ {
+ struct _exprFunc *head;
+ };
+
+/* Object for values */
+struct _exprVal
+ {
+ char *vname; /* Name of the value */
+ EXPRTYPE vval; /* Value of the value */
+ EXPRTYPE *vptr; /* Pointer to a value. Used only if not NULL */
+
+ struct _exprVal *next; /* For linked list */
+ };
+
+/* Value list */
+struct _exprValList
+ {
+ struct _exprVal *head;
+ };
+
+/* Expression node type */
+struct _exprNode
+ {
+ int type; /* Node type */
+
+ union _data /* Union of info for various types */
+ {
+ struct _oper
+ {
+ struct _exprNode *nodes; /* Operation arguments */
+ int nodecount; /* Number of arguments */
+ } oper;
+
+ struct _variable
+ {
+ EXPRTYPE *vaddr; /* Used if EXPR_FAST_VAR_ACCESS defined */
+ } variable;
+
+ struct _value
+ {
+ EXPRTYPE value; /* Value if type is value */
+ } value;
+
+ struct _assign /* Assignment struct */
+ {
+ EXPRTYPE *vaddr; /* Used if EXPR_FAST_VAR_ACCESS defined */
+ struct _exprNode *node; /* Node to evaluate */
+ } assign;
+
+ struct _function
+ {
+ exprFuncType fptr; /* Function pointer */
+ struct _exprNode *nodes; /* Array of argument nodes */
+ int nodecount; /* Number of argument nodes */
+ EXPRTYPE **refs; /* Reference variables */
+ int refcount; /* Number of variable references (not a reference counter) */
+ int type; /* Type of function for exprEvalNode if fptr is NULL */
+ } function;
+ } data;
+ };
+
+
+
+/* Functions for function lists */
+int exprFuncListAddType(exprFuncList *flist, char *name, int type, int min, int max, int refmin, int refmax);
+int exprFuncListGet(exprFuncList *flist, char *name, exprFuncType *ptr, int *type, int *min, int *max, int *refmin, int *refmax);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __BAVII_EXPRPRIV_H */
+
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprutil.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprutil.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprutil.c Tue Nov 13 15:23:26 2007
@@ -1,43 +1,43 @@
-/*
- File: exprutil.c
- Auth: Brian Allen Vanderburg II
- Date: Monday, April 28, 2003
- Desc: Utility functions for use by this library
-
- This file is part of ExprEval.
-*/
-
-/* Include files */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-
-
-/* Return the version number */
-void exprGetVersion(int *major, int *minor)
- {
- *major = EXPR_VERSIONMAJOR;
- *minor = EXPR_VERSIONMINOR;
- }
-
-/* This utility function determines if an identifier is valid */
-int exprValidIdent(char *name)
- {
- if(name == NULL) /* Null string */
- return 0;
-
- /* First must be letter or underscore */
- if(isalpha(*name) || *name == '_')
- name++; /* Point to next letter */
- else
- return 0; /* Not letter or underscore, maybe empty*/
-
- /* others can be letter, number, or underscore */
- while(isalnum(*name) || *name == '_')
- name++;
-
- /* When the while breaks out, we should be at the end */
- return (*name == '\0') ? 1 : 0;
- }
-
-
+/*
+ File: exprutil.c
+ Auth: Brian Allen Vanderburg II
+ Date: Monday, April 28, 2003
+ Desc: Utility functions for use by this library
+
+ This file is part of ExprEval.
+*/
+
+/* Include files */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+
+
+/* Return the version number */
+void exprGetVersion(int *major, int *minor)
+ {
+ *major = EXPR_VERSIONMAJOR;
+ *minor = EXPR_VERSIONMINOR;
+ }
+
+/* This utility function determines if an identifier is valid */
+int exprValidIdent(char *name)
+ {
+ if(name == NULL) /* Null string */
+ return 0;
+
+ /* First must be letter or underscore */
+ if(isalpha(*name) || *name == '_')
+ name++; /* Point to next letter */
+ else
+ return 0; /* Not letter or underscore, maybe empty*/
+
+ /* others can be letter, number, or underscore */
+ while(isalnum(*name) || *name == '_')
+ name++;
+
+ /* When the while breaks out, we should be at the end */
+ return (*name == '\0') ? 1 : 0;
+ }
+
+
Modified: freeswitch/trunk/src/mod/applications/mod_expr/exprval.c
==============================================================================
--- freeswitch/trunk/src/mod/applications/mod_expr/exprval.c (original)
+++ freeswitch/trunk/src/mod/applications/mod_expr/exprval.c Tue Nov 13 15:23:26 2007
@@ -1,395 +1,395 @@
-/*
- File: exprval.c
- Auth: Brian Allen Vanderburg II
- Date: Thursday, April 24, 2003
- Desc: Value lists for variables and constants
-
- This file is part of ExprEval.
-*/
-
-/* Includes */
-#include "exprincl.h"
-
-#include "exprpriv.h"
-#include "exprmem.h"
-
-
-/* Internal functions */
-static exprVal *exprCreateVal(char *name, EXPRTYPE val, EXPRTYPE *addr);
-static void exprValListFreeData(exprVal *val);
-static void exprValListResetData(exprVal *val);
-
-/* This function creates the value list, */
-int exprValListCreate(exprValList **vlist)
- {
- exprValList *tmp;
-
- if(vlist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- *vlist = NULL; /* Set to NULL initially */
-
- tmp = exprAllocMem(sizeof(exprValList));
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY; /* Could not allocate memory */
-
- /* Update pointer */
- *vlist = tmp;
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Add a value to the list */
-int exprValListAdd(exprValList *vlist, char *name, EXPRTYPE val)
- {
- exprVal *tmp;
- exprVal *cur;
- int result;
-
- if(vlist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Make sure the name is valid */
- if(!exprValidIdent(name))
- return EXPR_ERROR_BADIDENTIFIER;
-
- if(vlist->head == NULL)
- {
- /* Create the node right here */
- tmp = exprCreateVal(name, val, NULL);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- vlist->head = tmp;
- return EXPR_ERROR_NOERROR;
- }
-
- /* See if already exists */
- cur = vlist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->vname);
-
- if(result == 0)
- return EXPR_ERROR_ALREADYEXISTS;
-
- cur = cur->next;
- }
-
- /* We did not find it, create it and add it to the beginning */
- tmp = exprCreateVal(name, val, NULL);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- tmp->next = vlist->head;
- vlist->head = tmp;
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Set a value in the list */
-int exprValListSet(exprValList *vlist, char *name, EXPRTYPE val)
- {
- exprVal *cur;
- int result;
-
- if(vlist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- if(name == NULL || name[0] == '\0')
- return EXPR_ERROR_NOTFOUND;
-
- /* Find and set it */
- cur = vlist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->vname);
-
- if(result == 0)
- {
- if(cur->vptr)
- *(cur->vptr) = val;
- else
- cur->vval = val;
-
- return EXPR_ERROR_NOERROR;
- }
-
- cur = cur->next;
- }
-
- return EXPR_ERROR_NOTFOUND;
- }
-
-/* Get the value from a list */
-int exprValListGet(exprValList *vlist, char *name, EXPRTYPE *val)
- {
- exprVal *cur;
- int result;
-
- if(vlist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- if(name == NULL || name[0] == '\0')
- return EXPR_ERROR_NOTFOUND;
-
- /* Search for the item */
- cur = vlist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->vname);
-
- if(result == 0)
- {
- /* We found it. */
- if(cur->vptr)
- *val = *(cur->vptr);
- else
- *val = cur->vval;
-
- /* return now */
- return EXPR_ERROR_NOERROR;
- }
-
- cur = cur->next;
- }
-
- /* If we got here, we did not find the item in the list */
- return EXPR_ERROR_NOTFOUND;
- }
-
-/* Add an address to the list */
-int exprValListAddAddress(exprValList *vlist, char *name, EXPRTYPE *addr)
- {
- exprVal *tmp;
- exprVal *cur;
- int result;
-
- if(vlist == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
- /* Make sure the name is valid */
- if(!exprValidIdent(name))
- return EXPR_ERROR_BADIDENTIFIER;
-
- if(vlist->head == NULL)
- {
- /* Create the node right here */
- tmp = exprCreateVal(name, (EXPRTYPE)0.0, addr);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- vlist->head = tmp;
- return EXPR_ERROR_NOERROR;
- }
-
- /* See if it already exists */
- cur = vlist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->vname);
-
- if(result == 0)
- return EXPR_ERROR_ALREADYEXISTS;
-
- cur = cur->next;
- }
-
- /* Add it to the list */
- tmp = exprCreateVal(name, (EXPRTYPE)0.0, addr);
-
- if(tmp == NULL)
- return EXPR_ERROR_MEMORY;
-
- tmp->next = vlist->head;
- vlist->head = tmp;
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* Get memory address of a variable value in a value list */
-int exprValListGetAddress(exprValList *vlist, char *name, EXPRTYPE **addr)
- {
- exprVal *cur;
- int result;
-
- /* Not found yet */
- *addr = NULL;
-
- if(vlist == NULL || addr == NULL)
- return EXPR_ERROR_NULLPOINTER;
-
-
- if(name == NULL || name[0] == '\0')
- return EXPR_ERROR_NOTFOUND;
-
- /* Search for the item */
- cur = vlist->head;
-
- while(cur)
- {
- result = strcmp(name, cur->vname);
-
- if(result == 0)
- {
- /* We found it. */
- if(cur->vptr)
- *addr = cur->vptr;
- else
- *addr = &(cur->vval);
-
- /* return now */
- return EXPR_ERROR_NOERROR;
- }
-
- cur = cur->next;
- }
-
- /* If we got here, we did not find it in the list */
- return EXPR_ERROR_NOTFOUND;
- }
-
-/* This function is used to enumerate the values in a value list */
-void *exprValListGetNext(exprValList *vlist, char **name, EXPRTYPE *value, EXPRTYPE** addr, void *cookie)
- {
- exprVal *cur;
-
- if(vlist == NULL)
- return NULL;
-
- /* Get the current item */
- cur = (exprVal*)cookie;
-
- /* Find the next item */
- if(cur == NULL)
- cur = vlist->head;
- else
- cur = cur->next;
-
- /* Set up the data */
- if(cur)
- {
- if(name)
- *name = cur->vname;
-
- if(value)
- {
- if(cur->vptr)
- *value = *(cur->vptr);
- else
- *value = cur->vval;
- }
-
- if(addr)
- {
- if(cur->vptr)
- *addr = cur->vptr;
- else
- *addr = &(cur->vval);
- }
- }
-
- /* If there was no value, return NULL, otherwise, return the item */
- return (void*)cur;
- }
-
-/* This routine will free the value list */
-int exprValListFree(exprValList *vlist)
- {
- /* Make sure it exists, if not it is not error */
- if(vlist == NULL)
- return EXPR_ERROR_NOERROR;
-
- /* Free the nodes */
- exprValListFreeData(vlist->head);
-
- /* Freethe container */
- exprFreeMem(vlist);
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* This routine will reset the value list to 0.0 */
-int exprValListClear(exprValList *vlist)
- {
- if(vlist == NULL)
- return EXPR_ERROR_NOERROR;
-
- exprValListResetData(vlist->head);
-
- return EXPR_ERROR_NOERROR;
- }
-
-/* This routine will free any child nodes, and then free itself */
-static void exprValListFreeData(exprVal *val)
- {
- exprVal *next;
-
- while(val)
- {
- /* Remember the next */
- next = val->next;
-
- /* Free name */
- exprFreeMem(val->vname);
-
- /* Free ourself */
- exprFreeMem(val);
-
- val = next;
- }
- }
-
-/* This routine will reset variables to 0.0 */
-static void exprValListResetData(exprVal *val)
- {
- while(val)
- {
- /* Reset data */
- if(val->vptr)
- *(val->vptr) = 0.0;
-
- val->vval = 0.0;
-
- val = val->next;
- }
- }
-
-/* This routine will create the value object */
-static exprVal *exprCreateVal(char *name, EXPRTYPE val, EXPRTYPE *addr)
- {
- exprVal *tmp;
- char *vtmp;
-
- /* Name already tested in exprValListAdd */
-
- /* Create it */
- tmp = exprAllocMem(sizeof(exprVal));
- if(tmp == NULL)
- return NULL;
-
- /* Allocate space for the name */
- vtmp = exprAllocMem(strlen(name) + 1);
-
- if(vtmp == NULL)
- {
- exprFreeMem(tmp);
- return NULL;
- }
-
- /* Copy the data over */
- strcpy(vtmp, name);
- tmp->vname = vtmp;
- tmp->vval = val;
- tmp->vptr = addr;
-
- return tmp;
- }
+/*
+ File: exprval.c
+ Auth: Brian Allen Vanderburg II
+ Date: Thursday, April 24, 2003
+ Desc: Value lists for variables and constants
+
+ This file is part of ExprEval.
+*/
+
+/* Includes */
+#include "exprincl.h"
+
+#include "exprpriv.h"
+#include "exprmem.h"
+
+
+/* Internal functions */
+static exprVal *exprCreateVal(char *name, EXPRTYPE val, EXPRTYPE *addr);
+static void exprValListFreeData(exprVal *val);
+static void exprValListResetData(exprVal *val);
+
+/* This function creates the value list, */
+int exprValListCreate(exprValList **vlist)
+ {
+ exprValList *tmp;
+
+ if(vlist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ *vlist = NULL; /* Set to NULL initially */
+
+ tmp = exprAllocMem(sizeof(exprValList));
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY; /* Could not allocate memory */
+
+ /* Update pointer */
+ *vlist = tmp;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Add a value to the list */
+int exprValListAdd(exprValList *vlist, char *name, EXPRTYPE val)
+ {
+ exprVal *tmp;
+ exprVal *cur;
+ int result;
+
+ if(vlist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Make sure the name is valid */
+ if(!exprValidIdent(name))
+ return EXPR_ERROR_BADIDENTIFIER;
+
+ if(vlist->head == NULL)
+ {
+ /* Create the node right here */
+ tmp = exprCreateVal(name, val, NULL);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ vlist->head = tmp;
+ return EXPR_ERROR_NOERROR;
+ }
+
+ /* See if already exists */
+ cur = vlist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->vname);
+
+ if(result == 0)
+ return EXPR_ERROR_ALREADYEXISTS;
+
+ cur = cur->next;
+ }
+
+ /* We did not find it, create it and add it to the beginning */
+ tmp = exprCreateVal(name, val, NULL);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ tmp->next = vlist->head;
+ vlist->head = tmp;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Set a value in the list */
+int exprValListSet(exprValList *vlist, char *name, EXPRTYPE val)
+ {
+ exprVal *cur;
+ int result;
+
+ if(vlist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ if(name == NULL || name[0] == '\0')
+ return EXPR_ERROR_NOTFOUND;
+
+ /* Find and set it */
+ cur = vlist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->vname);
+
+ if(result == 0)
+ {
+ if(cur->vptr)
+ *(cur->vptr) = val;
+ else
+ cur->vval = val;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+ cur = cur->next;
+ }
+
+ return EXPR_ERROR_NOTFOUND;
+ }
+
+/* Get the value from a list */
+int exprValListGet(exprValList *vlist, char *name, EXPRTYPE *val)
+ {
+ exprVal *cur;
+ int result;
+
+ if(vlist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ if(name == NULL || name[0] == '\0')
+ return EXPR_ERROR_NOTFOUND;
+
+ /* Search for the item */
+ cur = vlist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->vname);
+
+ if(result == 0)
+ {
+ /* We found it. */
+ if(cur->vptr)
+ *val = *(cur->vptr);
+ else
+ *val = cur->vval;
+
+ /* return now */
+ return EXPR_ERROR_NOERROR;
+ }
+
+ cur = cur->next;
+ }
+
+ /* If we got here, we did not find the item in the list */
+ return EXPR_ERROR_NOTFOUND;
+ }
+
+/* Add an address to the list */
+int exprValListAddAddress(exprValList *vlist, char *name, EXPRTYPE *addr)
+ {
+ exprVal *tmp;
+ exprVal *cur;
+ int result;
+
+ if(vlist == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+ /* Make sure the name is valid */
+ if(!exprValidIdent(name))
+ return EXPR_ERROR_BADIDENTIFIER;
+
+ if(vlist->head == NULL)
+ {
+ /* Create the node right here */
+ tmp = exprCreateVal(name, (EXPRTYPE)0.0, addr);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ vlist->head = tmp;
+ return EXPR_ERROR_NOERROR;
+ }
+
+ /* See if it already exists */
+ cur = vlist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->vname);
+
+ if(result == 0)
+ return EXPR_ERROR_ALREADYEXISTS;
+
+ cur = cur->next;
+ }
+
+ /* Add it to the list */
+ tmp = exprCreateVal(name, (EXPRTYPE)0.0, addr);
+
+ if(tmp == NULL)
+ return EXPR_ERROR_MEMORY;
+
+ tmp->next = vlist->head;
+ vlist->head = tmp;
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* Get memory address of a variable value in a value list */
+int exprValListGetAddress(exprValList *vlist, char *name, EXPRTYPE **addr)
+ {
+ exprVal *cur;
+ int result;
+
+ /* Not found yet */
+ *addr = NULL;
+
+ if(vlist == NULL || addr == NULL)
+ return EXPR_ERROR_NULLPOINTER;
+
+
+ if(name == NULL || name[0] == '\0')
+ return EXPR_ERROR_NOTFOUND;
+
+ /* Search for the item */
+ cur = vlist->head;
+
+ while(cur)
+ {
+ result = strcmp(name, cur->vname);
+
+ if(result == 0)
+ {
+ /* We found it. */
+ if(cur->vptr)
+ *addr = cur->vptr;
+ else
+ *addr = &(cur->vval);
+
+ /* return now */
+ return EXPR_ERROR_NOERROR;
+ }
+
+ cur = cur->next;
+ }
+
+ /* If we got here, we did not find it in the list */
+ return EXPR_ERROR_NOTFOUND;
+ }
+
+/* This function is used to enumerate the values in a value list */
+void *exprValListGetNext(exprValList *vlist, char **name, EXPRTYPE *value, EXPRTYPE** addr, void *cookie)
+ {
+ exprVal *cur;
+
+ if(vlist == NULL)
+ return NULL;
+
+ /* Get the current item */
+ cur = (exprVal*)cookie;
+
+ /* Find the next item */
+ if(cur == NULL)
+ cur = vlist->head;
+ else
+ cur = cur->next;
+
+ /* Set up the data */
+ if(cur)
+ {
+ if(name)
+ *name = cur->vname;
+
+ if(value)
+ {
+ if(cur->vptr)
+ *value = *(cur->vptr);
+ else
+ *value = cur->vval;
+ }
+
+ if(addr)
+ {
+ if(cur->vptr)
+ *addr = cur->vptr;
+ else
+ *addr = &(cur->vval);
+ }
+ }
+
+ /* If there was no value, return NULL, otherwise, return the item */
+ return (void*)cur;
+ }
+
+/* This routine will free the value list */
+int exprValListFree(exprValList *vlist)
+ {
+ /* Make sure it exists, if not it is not error */
+ if(vlist == NULL)
+ return EXPR_ERROR_NOERROR;
+
+ /* Free the nodes */
+ exprValListFreeData(vlist->head);
+
+ /* Freethe container */
+ exprFreeMem(vlist);
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* This routine will reset the value list to 0.0 */
+int exprValListClear(exprValList *vlist)
+ {
+ if(vlist == NULL)
+ return EXPR_ERROR_NOERROR;
+
+ exprValListResetData(vlist->head);
+
+ return EXPR_ERROR_NOERROR;
+ }
+
+/* This routine will free any child nodes, and then free itself */
+static void exprValListFreeData(exprVal *val)
+ {
+ exprVal *next;
+
+ while(val)
+ {
+ /* Remember the next */
+ next = val->next;
+
+ /* Free name */
+ exprFreeMem(val->vname);
+
+ /* Free ourself */
+ exprFreeMem(val);
+
+ val = next;
+ }
+ }
+
+/* This routine will reset variables to 0.0 */
+static void exprValListResetData(exprVal *val)
+ {
+ while(val)
+ {
+ /* Reset data */
+ if(val->vptr)
+ *(val->vptr) = 0.0;
+
+ val->vval = 0.0;
+
+ val = val->next;
+ }
+ }
+
+/* This routine will create the value object */
+static exprVal *exprCreateVal(char *name, EXPRTYPE val, EXPRTYPE *addr)
+ {
+ exprVal *tmp;
+ char *vtmp;
+
+ /* Name already tested in exprValListAdd */
+
+ /* Create it */
+ tmp = exprAllocMem(sizeof(exprVal));
+ if(tmp == NULL)
+ return NULL;
+
+ /* Allocate space for the name */
+ vtmp = exprAllocMem(strlen(name) + 1);
+
+ if(vtmp == NULL)
+ {
+ exprFreeMem(tmp);
+ return NULL;
+ }
+
+ /* Copy the data over */
+ strcpy(vtmp, name);
+ tmp->vname = vtmp;
+ tmp->vval = val;
+ tmp->vptr = addr;
+
+ return tmp;
+ }
More information about the Freeswitch-svn
mailing list