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