WebSVN – Kolibri OS – Diff – /programs/other/table/parser.cpp


#include "func.h"
#include "parser.h"
//#include 
//#include 
//#include 
 
// token types
#define DELIMITER 1
#define VARIABLE 2
#define NUMBER 3
#define FUNCTION 4
#define FINISHED 10
 
//#define allocmem(x) malloc(x)
//#define freemem(x) free(x)
 
double epsilon = 1e-6;
 
// structure for most parser functions
 
	char token[80];
	int token_type;
	char *prog;
 
	int code;    // error code
 
 
variable_callback *find_var;
 
struct double_list  
{
	double val;
	int code;			// êîä îøèáêè
	double_list *next; 
};
 
double tg(double d)
{
	double cosd = cos(d);
	if (fabs(cosd) < epsilon)
	{
		serror(ERR_OVERFLOW);
		return 0.0;
	}
	return sin(d) / cosd;
}
 
double ctg(double d)
{
	double sind = sin(d);
	if (fabs(sind) < epsilon)
	{
		serror(ERR_OVERFLOW);
		return 0.0;
	}
	return cos(d) / sind;
}
 
double exp(double x)
{
	__asm {
		fld	x 
		FLDL2E
		FMUL 
 
		FLD st(0) 
 
		FLD1
 
		FXCH 
		FPREM 
		F2XM1 
		fadd 
		FSCALE
		FSTP st(1)
	}
	
}
 
double log(double x)
{
	//return 0.0;
	if (x <= 0)
	{
		serror(ERR_OVERFLOW);
		//return 0.0;
		__asm {
			fldz
		}
	}
	__asm {
		FLD1
		FLD     x
		FYL2X
		FLDLN2
		FMUL
	}
}
 
double sqrt(double x)
{
	if (x < 0)
	{
		serror(ERR_BADPARAM);
		__asm {
			fldz
		}
	}
	__asm {
		fld x
		fsqrt
	}
}
 
double atan(double x)
{
	serror(ERR_GENERAL);
	return 0.0; // â ëîì
}
 
double pow(double x, double y)
{
	return exp(y * log(x)); // 
}
 
double func_pi()
{
	return 3.14159265358979;
}
 
double func_eps()
{
	return epsilon;
}
 
double func_if(double_list *p)
{
	double_list *a, *b, *c;
	a = p;
	b = a->next;
	if (!b)
	{
		serror(ERR_BADPARAM);
		return 0.0;
	}
	c = b->next;
	if (!c || c->next)
	{
		serror(ERR_BADPARAM);
		return 0.0;
	}
	if (a->val != 0.0)
	{
		if (b->code)
			code = b->code;
		return b->val;
	}
	else
	{
		if (c->code)
			code = c->code;
		return c->val;
	}
}
 
double sum(double_list *p)
{
	double res = 0.0;
	while (p)
	{
		res += p->val;
		if (p->code)
			code = p->code;
		p = p->next;
	}
	return res;
}
 
double func_min(double_list *p)
{
	if (!p)
		serror(ERR_BADPARAM);
	double res = p->val;
	p = p->next;
	while (p)
	{
		if (p->code)
			code = p->code;
		if (p->val < res)
			res = p->val;
		p = p->next;
	}
	return res;
}
 
double func_max(double_list *p)
{
	if (!p)
		serror(ERR_BADPARAM);
	double res = p->val;
	p = p->next;
	while (p)
	{
		if (p->code)
			code = p->code;
		if (p->val > res)
			res = p->val;
		p = p->next;
	}
	return res;
}
 
double avg(double_list *p)
{
	double res = 0.0;
	int count = 0;
	while (p)
	{
		if (p->code)
			code = p->code;
		res += p->val;
		count++;
		p = p->next;
	}
	return res / count;
}
 
double func_isnull(char *str)
{
	if (code != 0)
		return 0.0;
	double tmp = find_var(str);
	int c = code;
	code = 0;
	if (c != 0)
		return 1.0;
	return 0.0;
}
 
const double HALF = 0.5;
double func_ceil(double val)	// õîòåë round, à ïîëó÷èëñÿ ceil...
{
	int x;
	__asm fld val
	__asm fld HALF				// äà, êðèâîðóêî ^_^
	__asm fadd
	__asm fistp x
	__asm fild x
}
 
double func_round(double val)
{
	int x;
	__asm fld val
	__asm fld epsilon
	__asm fadd
	__asm fistp x
	__asm fild x
}
 
//const double ALMOST_HALF = 0.5 - epsilon;
double ALMOST_HALF;
extern void ALMOST_HALF_init(void)
{ ALMOST_HALF = 0.5 - epsilon; }
double func_floor(double val)
{
	int x;
	__asm fld val
	__asm fld ALMOST_HALF
	__asm fsub
	__asm fistp x
	__asm fild x
}
 
double logic_xor(double a, double b)
{
	if (a == 0.0)
		if (b == 0.0)
			return 0.0;
		else
			return 1.0;
	else
		if (b == 0.0)
			return 1.0;
		else
			return 0.0;
}
 
double logic_and(double a, double b)
{
	if (a == 0.0)
		return 0.0;
	else
		if (b == 0.0)
			return 0.0;
		else
			return 1.0;
}
 
double logic_or(double a, double b)
{
	if (a == 0.0)
		if (b == 0.0)
			return 0.0;
		else
			return 1.1;
	else
		return 1.0;
}
 
double rand_seed;
double func_rand(double max)
{
	double q = (257.0 * rand_seed + 739.0);	// ÷èñëà îò áàëäû. íàäî âñòàâèòü ïðàâèëüíûå.
	rand_seed = q - 65536.0 * func_floor(q / 65536.0); // äëÿ õîðîøåãî ðàñïðåäåëåíèÿ
	return q - max * func_floor(q / max);	 // äëÿ ìîäóëÿ
}
 
/*
double func_case(double_list *p)
{
	if (!p || !p->next)
	{
		serror(ERR_BADPARAM);
		return 0.0;
	}
	double x = p->val;
	int count = (int)p->next->val;
	int i, k;
 
	double_list *cur = p->next->next;
	k = count;
	for (i = 0; i < count; i++)
	{
		if (!cur)
		{
			serror(ERR_BADPARAM);
			return 0.0;
		}
		if (fabs(x - cur->val) < epsilon)
		{
			if (k != count + 1)
			{
				serror(ERR_GENERAL);
				return 0.0;
			}
			k = i;
		}
		cur = cur->next;
	}
 
	for (i = 0; i < k; i++)
	{
		if (!cur)
		{
			serror(ERR_BADPARAM);
			return 0.0;
		}
		cur = cur->next;
	}
	if (!cur)					// ïðîâåðêè áèï. äîñòàëè áèï.
	{
		serror(ERR_BADPARAM);
		return 0.0;
	}
	if (cur->code)
		code = cur->code;
	return cur->val;
}
*/
 
#define INF_ARGS -1
#define STR_ARG -2
 
// represents general mathematical function
typedef double(*matfunc0)();
typedef double(*matfunc)(double);
typedef double(*matfunc2)(double,double);
typedef double(*matfunc3)(double,double,double);
typedef double(*matfunc_inf)(double_list*);
typedef double(*matfunc_str)(char*);
 
// used to link function name to the function
typedef struct  
{
	char name[10];
	int args;
	void * f;
} func;
 
// the list of functions
const int max_func = 28;
func functions[max_func] = 
{
	"", 1, NULL,								// íå ïîìíþ, ñ êàêîé öåëüþ
	"sin", 1, &sin,
	"cos", 1, &cos,
	"exp", 1, &exp,
	"sqrt", 1, &sqrt,
	"log", 1, &log,
	"tg", 1, &tg,
	"ctg", 1, &ctg,
	"arcsin", 1, &asin,
	"arccos", 1, &acos,
	"arctg", 1, &atan,							// íå ðåàëèçîâàíî. âîçâðàùàåò îøèáêó ERR_GENERAL
	"abs", 1, &fabs,
	"pow", 2, &pow,
	"if", INF_ARGS, &func_if,
	"sum",INF_ARGS,&sum,
	"isnull",STR_ARG,&func_isnull,				// ñëåãêà ÷/æ
	"min",INF_ARGS,&func_min,
	"max",INF_ARGS,&func_max,
	"avg",INF_ARGS,&avg,
	"ceil",1,&func_ceil,
	"round",1,&func_round,
	"floor",1,&func_floor,
	"and",2,&logic_and,
	"or",2,&logic_or,
	"xor",2,&logic_xor,
	"rand",1,&func_rand,
	//"case",INF_ARGS,&func_case,
	"pi",0,&func_pi,
	"eps",0,&func_eps
};
 
// all delimiters
#define MAXDELIM 17
const char delim[MAXDELIM]="+-*^/%=;(),><#! ";		// not bad words
 
 
int isdelim(char c)
{
	//return strchr(delim, c) != 0;
	for (int i = 0; i < MAXDELIM; i++)
		if (c == delim[i])
			return 1;
	return 0;
}
 
int isdigit(char c)
{
	return (c >= '0' && c <= '9');
}
 
int isalpha2(char c)
{
	return ((c >= 'a' && c <= 'z')
		|| (c >= 'A' && c <= 'Z') || (c=='$'));
}
 
int iswhite(char c)
{
	return (c==' ' || c=='\t');
}
 
 
void serror(int acode)
{
	if (acode != 0)
		code = acode;
}
 
void set_exp(char *exp)
{
	prog = exp;
}
 
int get_token()
{
	int tok;
	char *temp;
	(token_type) = 0;
	tok = 0;
	temp = (token);
 
	if (*(prog) == '\0')
	{
		*(token) = 0;
		tok = FINISHED;
		return ((token_type) = DELIMITER);
	}
	while (iswhite(*(prog))) ++(prog);
	if (isdelim(*(prog)))
	{
		char t=*temp = *(prog);
		(prog)++;
		temp++;
		if ((t == '>' || t == '<' || t == '!') && (*prog) && (*prog == '='))
		{
			*temp = *(prog);
			(prog)++;
			temp++;
		}
		*temp = 0;
		return ((token_type) = DELIMITER);
	}
	if (isdigit(*(prog)))
	{
		while (!isdelim(*(prog)))
			*temp++=*(prog)++;
		*temp = '\0';
		return ((token_type) = NUMBER);
	}
	if (isalpha2(*(prog)))
	{
		while (!isdelim(*(prog)))
			*temp++=*(prog)++;
		(token_type) = VARIABLE;
	}
	*temp = '\0';
	if ((token_type) == VARIABLE)
	{
		tok = look_up((token));
		if (tok)
			(token_type) = FUNCTION;
	}
	return (token_type);
}
 
double sign(double d)
{
  if (d > 0.0)
    return 1.0;
  if (d < 0.0)
    return -1.0;
  return 0.0;
}
 
void putback()
{
	char *t;
	t = (token);
	for (;*t;t++)
		(prog)--;
}
 
int get_exp(double *hold)
{
	code = 0;
 
	get_token();
	if (!*(token))
	{
		return 0;
	}
	level1( hold);
	putback();
  return code==0;
}
 
void level1(double *hold)
{
	char op[2];
	double h;
 
	level1_5( hold);
	while (op[0] = *token, op[1] = (*(token+1)) ? *(token + 1) : 0,
		*op == '<' || *op == '>' || *op == '=' || *op == '#' || *op == '!')
	{
		get_token();
		level1_5( &h);
		logic(op, hold, &h);
	}
}
 
void level1_5(double *hold)
{
	char op;
 
	op = 0;
	if (((token_type) == DELIMITER) && *(token) == '!')
	{
		op = *(token);
		get_token();
	}
	level2( hold);
 
	if (op)
	{
		if (*hold == 0.0)
			*hold = 1.0;
		else
			*hold = 0.0;
	}
}
 
void level2(double *hold)
{
	char op;
	double h;
 
	level3( hold);
	while ((op=*(token)) == '+' || op == '-')
	{
		get_token();
		level3( &h);
		arith(op, hold, &h);
	}
}
 
void level3(double *hold)
{
	char op;
	double h;
 
	level4( hold);
	while ((op=*(token)) == '*' || op == '/' || op == '%')
	{
		get_token();
		level4( &h);
		arith( op, hold, &h);
	}
}
 
void level4(double *hold)
{
	double h;
	level5( hold);
 
	if (*(token) == '^')
	{
		get_token();
		level5( &h);
		arith( '^', hold, &h);
	}
}
 
void level5(double *hold)
{
	char op;
 
	op = 0;
	if (((token_type) == DELIMITER) && *(token) == '+' || *(token) == '-')
	{
		op = *(token);
		get_token();
	}
	level6( hold);
 
	if (op)
		unary(op, hold);
}
 
void level6(double *hold)
{
	if ((*(token) == '(') && ((token_type) == DELIMITER))
	{
		get_token();
		level1( hold);
		if (*(token) != ')')
			  serror( ERR_NOBRACKET);
		get_token();
	}
	else
		primitive( hold);
}
 
void calc_function(double *hold)
{
  double_list *args = NULL, *last = NULL, *t;		
  double d;
	int i,argc=0,save_code;
 
	save_code = code;
	code = 0;
	i = look_up(token);
 
	if (i == 0)
		serror(ERR_BADFUNCTION);	// error
 
	get_token();
	if (*(token) != '(')
		serror(ERR_NOBRACKET);	// error
	//get_token();
	if (functions[i].args == STR_ARG)
	{
		get_token();
		d = ((matfunc_str)(functions[i].f))(token);
		*hold = d;
		get_token();
		if (save_code)
			code = save_code;
		return;
	}
 
	//last = args = (double_list*)malloc(sizeof(double_list));
	//args->next = NULL;
	//level1(&args->val);
	//get_token();
	argc=0;
	do 
	{
		get_token();
		if (*token == ')')
			break;
		t = (double_list*)allocmem(sizeof(double_list));
		code = 0;
		level1(&t->val);
		t->code = code;
		t->next = NULL;
		if (last)
			last->next = t;
		else
			args = t;
		last = t;
		argc++;
	} while (*token == ',');
 
	code = save_code;
 
	if (argc != functions[i].args && functions[i].args >= 0)
	{
		serror(ERR_BADPARAM);
	}
	else
	{
		switch (functions[i].args)
		{
			case 0:
				d = ((matfunc0)(functions[i].f))();
				break;
			case 1:
				d = ((matfunc)(functions[i].f))(args->val);
				break;			
			case 2:
				d = ((matfunc2)(functions[i].f))(args->val,args->next->val);
				break;			
			case 3:
				d = ((matfunc3)(functions[i].f))(args->val,args->next->val,args->next->next->val);
				break;		
			case INF_ARGS:
				d = ((matfunc_inf)(functions[i].f))(args);
				break;
		}
	}
 
	t = args;
	while (t)
	{
		args = t->next;
		freemem(t);
		t = args;
	}
	
  *hold = d;
//  else
//    serror( ERR_OVERFLOW);
 
}
 
void primitive(double *hold)
{
	switch (token_type)
	{
	case VARIABLE:
		*hold = find_var(token);
		get_token();
		return;
	case NUMBER:
    //
		*hold = atof((token));
    //if (sscanf(token, "%lf", hold) != 1)
	*hold = convert(token);
	if (convert_error == ERROR)
      serror( ERR_BADNUMER);
		get_token();
		return;
	case FUNCTION:
		calc_function( hold);
		if (*token != ')')
			serror(ERR_NOBRACKET);
		get_token();
		return;
	default:	// error
		return;
	}
}
 
void arith(char op, double *r, double *h)
{
	double t;
	switch(op)
	{
	case '-':
		*r = *r - *h;
		break;
	case '+':
		*r = *r + *h;
		break;
	case '*':
		*r = *r * *h;
		break;
	case '/':
	    if (fabs(*h) < epsilon)
			serror( ERR_OVERFLOW);
		else
		  *r = (*r) / (*h);
		break;
	case '%':
	    if (fabs(*h) < epsilon)
			serror( ERR_OVERFLOW);
		else
		{
			t = func_floor ((*r) / (*h));
			*r = *r - (t * (*h));
		}
		break;
	case '^':
		*r = pow(*r, *h);
		break;
	}
}
 
void logic(char *op, double *r, double *h)
{
	double t;
	switch (*op)
	{
	case '<':
		if (*(op+1) && *(op+1) == '=')
			t = *r <= *h + epsilon ? 1.0 : 0.0;
		else				
			t = *r < *h - epsilon? 1.0 : 0.0;	
		break;
	case '>':
		if (*(op+1) && *(op+1) == '=')
			t = *r >= *h - epsilon ? 1.0 : 0.0;
		else				
			t = *r > *h + epsilon ? 1.0 : 0.0;
		break;
	case '=':
		t = fabs(*r - *h) <= epsilon ? 1.0 : 0.0;
		break;
	case '#':
		t = fabs(*r - *h) > epsilon ? 1.0 : 0.0;
		break;
	case '!':
		if (*(op+1) && *(op+1) == '=')
			t = fabs(*r - *h) > epsilon ? 1.0 : 0.0;
		else
			serror(ERR_GENERAL);
		break;
	}
	*r = t;
}
 
 
void unary(char op, double *r)
{
	if (op == '-')
		*r = -(*r);
}
 
bool strcmp(char *s1, char *s2)
{
	int i;
 
	if (s1 == NULL)
		if (s2 == NULL)
			return 0;
		else
			return 1;
	else
		if (s2 == NULL)
			return 1;
 
	for (i = 0;;i++)
	{
		if (s1[i] == '\0')
			if (s2[i] == '\0')
				return 0;
			else
				return 1;
		else
			if (s2[i] == '\0')
				return 1;
			else
			{
				if (s1[i] != s2[i])
					return 1;
			}
	}
	return 0;
}
 
 
bool strncmp(char *s1, char *s2, int n)
{
	int i;
 
	if (s1 == NULL)
		if (s2 == NULL)
			return 0;
		else
			return 1;
	else
		if (s2 == NULL)
			return 1;
 
	for (i = 0;i
	{
		if (s1[i] == '\0')
			if (s2[i] == '\0')
				return 0;
			else
				return 1;
		else
			if (s2[i] == '\0')
				return 1;
			else
			{
				if (s1[i] != s2[i])
					return 1;
			}
	}
	return 0;
}
 
int look_up(char *s)
{
	int i;
 
	for (i = 0; i < max_func; i++)
		if (strcmp(s, functions[i].name) == 0)
			return i;
	return 0;	// search command/function name
}
 
unsigned int chrnum(char* text, char symbol)
{
	int num = 0;
	int i = 0;
	while(text[i])
	{ 
		if (text[i] == symbol) num++;
		i++;
	}
	return num;
}
>
>

Rev 7495	Rev 7516
1	#include "func.h"	1	#include "func.h"
2	#include "parser.h"	2	#include "parser.h"
3	//#include	3	//#include
4	//#include	4	//#include
5	//#include	5	//#include
6		6
7	// token types	7	// token types
8	#define DELIMITER 1	8	#define DELIMITER 1
9	#define VARIABLE 2	9	#define VARIABLE 2
10	#define NUMBER 3	10	#define NUMBER 3
11	#define FUNCTION 4	11	#define FUNCTION 4
12	#define FINISHED 10	12	#define FINISHED 10
13		13
14	//#define allocmem(x) malloc(x)	14	//#define allocmem(x) malloc(x)
15	//#define freemem(x) free(x)	15	//#define freemem(x) free(x)
16		16
17	double epsilon = 1e-6;	17	double epsilon = 1e-6;
18		18
19	// structure for most parser functions	19	// structure for most parser functions
20		20
21	char token[80];	21	char token[80];
22	int token_type;	22	int token_type;
23	char *prog;	23	char *prog;
24		24
25	int code; // error code	25	int code; // error code
26		26
27		27
28	variable_callback *find_var;	28	variable_callback *find_var;
29		29
30	struct double_list	30	struct double_list
31	{	31	{
32	double val;	32	double val;
33	int code; // êîä îøèáêè	33	int code; // êîä îøèáêè
34	double_list *next;	34	double_list *next;
35	};	35	};
36		36
37	double tg(double d)	37	double tg(double d)
38	{	38	{
39	double cosd = cos(d);	39	double cosd = cos(d);
40	if (fabs(cosd) < epsilon)	40	if (fabs(cosd) < epsilon)
41	{	41	{
42	serror(ERR_OVERFLOW);	42	serror(ERR_OVERFLOW);
43	return 0.0;	43	return 0.0;
44	}	44	}
45	return sin(d) / cosd;	45	return sin(d) / cosd;
46	}	46	}
47		47
48	double ctg(double d)	48	double ctg(double d)
49	{	49	{
50	double sind = sin(d);	50	double sind = sin(d);
51	if (fabs(sind) < epsilon)	51	if (fabs(sind) < epsilon)
52	{	52	{
53	serror(ERR_OVERFLOW);	53	serror(ERR_OVERFLOW);
54	return 0.0;	54	return 0.0;
55	}	55	}
56	return cos(d) / sind;	56	return cos(d) / sind;
57	}	57	}
58		58
59	double exp(double x)	59	double exp(double x)
60	{	60	{
61	__asm {	61	__asm {
62	fld x	62	fld x
63	FLDL2E	63	FLDL2E
64	FMUL	64	FMUL
65		65
66	FLD st(0)	66	FLD st(0)
67		67
68	FLD1	68	FLD1
69		69
70	FXCH	70	FXCH
71	FPREM	71	FPREM
72	F2XM1	72	F2XM1
73	fadd	73	fadd
74	FSCALE	74	FSCALE
75	FSTP st(1)	75	FSTP st(1)
76	}	76	}
77		77
78	}	78	}
79		79
80	double log(double x)	80	double log(double x)
81	{	81	{
82	//return 0.0;	82	//return 0.0;
83	if (x <= 0)	83	if (x <= 0)
84	{	84	{
85	serror(ERR_OVERFLOW);	85	serror(ERR_OVERFLOW);
86	//return 0.0;	86	//return 0.0;
87	__asm {	87	__asm {
88	fldz	88	fldz
89	}	89	}
90	}	90	}
91	__asm {	91	__asm {
92	FLD1	92	FLD1
93	FLD x	93	FLD x
94	FYL2X	94	FYL2X
95	FLDLN2	95	FLDLN2
96	FMUL	96	FMUL
97	}	97	}
98	}	98	}
99		99
100	double sqrt(double x)	100	double sqrt(double x)
101	{	101	{
102	if (x < 0)	102	if (x < 0)
103	{	103	{
104	serror(ERR_BADPARAM);	104	serror(ERR_BADPARAM);
105	__asm {	105	__asm {
106	fldz	106	fldz
107	}	107	}
108	}	108	}
109	__asm {	109	__asm {
110	fld x	110	fld x
111	fsqrt	111	fsqrt
112	}	112	}
113	}	113	}
114		114
115	double atan(double x)	115	double atan(double x)
116	{	116	{
117	serror(ERR_GENERAL);	117	serror(ERR_GENERAL);
118	return 0.0; // â ëîì	118	return 0.0; // â ëîì
119	}	119	}
120		120
121	double pow(double x, double y)	121	double pow(double x, double y)
122	{	122	{
123	return exp(y * log(x)); //	123	return exp(y * log(x)); //
124	}	124	}
125		125
126	double func_pi()	126	double func_pi()
127	{	127	{
128	return 3.14159265358979;	128	return 3.14159265358979;
129	}	129	}
130		130
131	double func_eps()	131	double func_eps()
132	{	132	{
133	return epsilon;	133	return epsilon;
134	}	134	}
135		135
136	double func_if(double_list *p)	136	double func_if(double_list *p)
137	{	137	{
138	double_list a, b, *c;	138	double_list a, b, *c;
139	a = p;	139	a = p;
140	b = a->next;	140	b = a->next;
141	if (!b)	141	if (!b)
142	{	142	{
143	serror(ERR_BADPARAM);	143	serror(ERR_BADPARAM);
144	return 0.0;	144	return 0.0;
145	}	145	}
146	c = b->next;	146	c = b->next;
147	if (!c \|\| c->next)	147	if (!c \|\| c->next)
148	{	148	{
149	serror(ERR_BADPARAM);	149	serror(ERR_BADPARAM);
150	return 0.0;	150	return 0.0;
151	}	151	}
152	if (a->val != 0.0)	152	if (a->val != 0.0)
153	{	153	{
154	if (b->code)	154	if (b->code)
155	code = b->code;	155	code = b->code;
156	return b->val;	156	return b->val;
157	}	157	}
158	else	158	else
159	{	159	{
160	if (c->code)	160	if (c->code)
161	code = c->code;	161	code = c->code;
162	return c->val;	162	return c->val;
163	}	163	}
164	}	164	}
165		165
166	double sum(double_list *p)	166	double sum(double_list *p)
167	{	167	{
168	double res = 0.0;	168	double res = 0.0;
169	while (p)	169	while (p)
170	{	170	{
171	res += p->val;	171	res += p->val;
172	if (p->code)	172	if (p->code)
173	code = p->code;	173	code = p->code;
174	p = p->next;	174	p = p->next;
175	}	175	}
176	return res;	176	return res;
177	}	177	}
178		178
179	double func_min(double_list *p)	179	double func_min(double_list *p)
180	{	180	{
181	if (!p)	181	if (!p)
182	serror(ERR_BADPARAM);	182	serror(ERR_BADPARAM);
183	double res = p->val;	183	double res = p->val;
184	p = p->next;	184	p = p->next;
185	while (p)	185	while (p)
186	{	186	{
187	if (p->code)	187	if (p->code)
188	code = p->code;	188	code = p->code;
189	if (p->val < res)	189	if (p->val < res)
190	res = p->val;	190	res = p->val;
191	p = p->next;	191	p = p->next;
192	}	192	}
193	return res;	193	return res;
194	}	194	}
195		195
196	double func_max(double_list *p)	196	double func_max(double_list *p)
197	{	197	{
198	if (!p)	198	if (!p)
199	serror(ERR_BADPARAM);	199	serror(ERR_BADPARAM);
200	double res = p->val;	200	double res = p->val;
201	p = p->next;	201	p = p->next;
202	while (p)	202	while (p)
203	{	203	{
204	if (p->code)	204	if (p->code)
205	code = p->code;	205	code = p->code;
206	if (p->val > res)	206	if (p->val > res)
207	res = p->val;	207	res = p->val;
208	p = p->next;	208	p = p->next;
209	}	209	}
210	return res;	210	return res;
211	}	211	}
212		212
213	double avg(double_list *p)	213	double avg(double_list *p)
214	{	214	{
215	double res = 0.0;	215	double res = 0.0;
216	int count = 0;	216	int count = 0;
217	while (p)	217	while (p)
218	{	218	{
219	if (p->code)	219	if (p->code)
220	code = p->code;	220	code = p->code;
221	res += p->val;	221	res += p->val;
222	count++;	222	count++;
223	p = p->next;	223	p = p->next;
224	}	224	}
225	return res / count;	225	return res / count;
226	}	226	}
227		227
228	double func_isnull(char *str)	228	double func_isnull(char *str)
229	{	229	{
230	if (code != 0)	230	if (code != 0)
231	return 0.0;	231	return 0.0;
232	double tmp = find_var(str);	232	double tmp = find_var(str);
233	int c = code;	233	int c = code;
234	code = 0;	234	code = 0;
235	if (c != 0)	235	if (c != 0)
236	return 1.0;	236	return 1.0;
237	return 0.0;	237	return 0.0;
238	}	238	}
239		239
240	const double HALF = 0.5;	240	const double HALF = 0.5;
241	double func_ceil(double val) // õîòåë round, à ïîëó÷èëñÿ ceil...	241	double func_ceil(double val) // õîòåë round, à ïîëó÷èëñÿ ceil...
242	{	242	{
243	int x;	243	int x;
244	__asm fld val	244	__asm fld val
245	__asm fld HALF // äà, êðèâîðóêî ^_^	245	__asm fld HALF // äà, êðèâîðóêî ^_^
246	__asm fadd	246	__asm fadd
247	__asm fistp x	247	__asm fistp x
248	__asm fild x	248	__asm fild x
249	}	249	}
250		250
251	double func_round(double val)	251	double func_round(double val)
252	{	252	{
253	int x;	253	int x;
254	__asm fld val	254	__asm fld val
255	__asm fld epsilon	255	__asm fld epsilon
256	__asm fadd	256	__asm fadd
257	__asm fistp x	257	__asm fistp x
258	__asm fild x	258	__asm fild x
259	}	259	}
260		260
261	//const double ALMOST_HALF = 0.5 - epsilon;	261	//const double ALMOST_HALF = 0.5 - epsilon;
262	double ALMOST_HALF;	262	double ALMOST_HALF;
263	extern void ALMOST_HALF_init(void)	263	extern void ALMOST_HALF_init(void)
264	{ ALMOST_HALF = 0.5 - epsilon; }	264	{ ALMOST_HALF = 0.5 - epsilon; }
265	double func_floor(double val)	265	double func_floor(double val)
266	{	266	{
267	int x;	267	int x;
268	__asm fld val	268	__asm fld val
269	__asm fld ALMOST_HALF	269	__asm fld ALMOST_HALF
270	__asm fsub	270	__asm fsub
271	__asm fistp x	271	__asm fistp x
272	__asm fild x	272	__asm fild x
273	}	273	}
274		274
275	double logic_xor(double a, double b)	275	double logic_xor(double a, double b)
276	{	276	{
277	if (a == 0.0)	277	if (a == 0.0)
278	if (b == 0.0)	278	if (b == 0.0)
279	return 0.0;	279	return 0.0;
280	else	280	else
281	return 1.0;	281	return 1.0;
282	else	282	else
283	if (b == 0.0)	283	if (b == 0.0)
284	return 1.0;	284	return 1.0;
285	else	285	else
286	return 0.0;	286	return 0.0;
287	}	287	}
288		288
289	double logic_and(double a, double b)	289	double logic_and(double a, double b)
290	{	290	{
291	if (a == 0.0)	291	if (a == 0.0)
292	return 0.0;	292	return 0.0;
293	else	293	else
294	if (b == 0.0)	294	if (b == 0.0)
295	return 0.0;	295	return 0.0;
296	else	296	else
297	return 1.0;	297	return 1.0;
298	}	298	}
299		299
300	double logic_or(double a, double b)	300	double logic_or(double a, double b)
301	{	301	{
302	if (a == 0.0)	302	if (a == 0.0)
303	if (b == 0.0)	303	if (b == 0.0)
304	return 0.0;	304	return 0.0;
305	else	305	else
306	return 1.1;	306	return 1.1;
307	else	307	else
308	return 1.0;	308	return 1.0;
309	}	309	}
310		310
311	double rand_seed;	311	double rand_seed;
312	double func_rand(double max)	312	double func_rand(double max)
313	{	313	{
314	double q = (257.0 * rand_seed + 739.0); // ÷èñëà îò áàëäû. íàäî âñòàâèòü ïðàâèëüíûå.	314	double q = (257.0 * rand_seed + 739.0); // ÷èñëà îò áàëäû. íàäî âñòàâèòü ïðàâèëüíûå.
315	rand_seed = q - 65536.0 * func_floor(q / 65536.0); // äëÿ õîðîøåãî ðàñïðåäåëåíèÿ	315	rand_seed = q - 65536.0 * func_floor(q / 65536.0); // äëÿ õîðîøåãî ðàñïðåäåëåíèÿ
316	return q - max * func_floor(q / max); // äëÿ ìîäóëÿ	316	return q - max * func_floor(q / max); // äëÿ ìîäóëÿ
317	}	317	}
318		318
319	/*	319	/*
320	double func_case(double_list *p)	320	double func_case(double_list *p)
321	{	321	{
322	if (!p \|\| !p->next)	322	if (!p \|\| !p->next)
323	{	323	{
324	serror(ERR_BADPARAM);	324	serror(ERR_BADPARAM);
325	return 0.0;	325	return 0.0;
326	}	326	}
327	double x = p->val;	327	double x = p->val;
328	int count = (int)p->next->val;	328	int count = (int)p->next->val;
329	int i, k;	329	int i, k;
330		330
331	double_list *cur = p->next->next;	331	double_list *cur = p->next->next;
332	k = count;	332	k = count;
333	for (i = 0; i < count; i++)	333	for (i = 0; i < count; i++)
334	{	334	{
335	if (!cur)	335	if (!cur)
336	{	336	{
337	serror(ERR_BADPARAM);	337	serror(ERR_BADPARAM);
338	return 0.0;	338	return 0.0;
339	}	339	}
340	if (fabs(x - cur->val) < epsilon)	340	if (fabs(x - cur->val) < epsilon)
341	{	341	{
342	if (k != count + 1)	342	if (k != count + 1)
343	{	343	{
344	serror(ERR_GENERAL);	344	serror(ERR_GENERAL);
345	return 0.0;	345	return 0.0;
346	}	346	}
347	k = i;	347	k = i;
348	}	348	}
349	cur = cur->next;	349	cur = cur->next;
350	}	350	}
351		351
352	for (i = 0; i < k; i++)	352	for (i = 0; i < k; i++)
353	{	353	{
354	if (!cur)	354	if (!cur)
355	{	355	{
356	serror(ERR_BADPARAM);	356	serror(ERR_BADPARAM);
357	return 0.0;	357	return 0.0;
358	}	358	}
359	cur = cur->next;	359	cur = cur->next;
360	}	360	}
361	if (!cur) // ïðîâåðêè áèï. äîñòàëè áèï.	361	if (!cur) // ïðîâåðêè áèï. äîñòàëè áèï.
362	{	362	{
363	serror(ERR_BADPARAM);	363	serror(ERR_BADPARAM);
364	return 0.0;	364	return 0.0;
365	}	365	}
366	if (cur->code)	366	if (cur->code)
367	code = cur->code;	367	code = cur->code;
368	return cur->val;	368	return cur->val;
369	}	369	}
370	*/	370	*/
371		371
372	#define INF_ARGS -1	372	#define INF_ARGS -1
373	#define STR_ARG -2	373	#define STR_ARG -2
374		374
375	// represents general mathematical function	375	// represents general mathematical function
376	typedef double(*matfunc0)();	376	typedef double(*matfunc0)();
377	typedef double(*matfunc)(double);	377	typedef double(*matfunc)(double);
378	typedef double(*matfunc2)(double,double);	378	typedef double(*matfunc2)(double,double);
379	typedef double(*matfunc3)(double,double,double);	379	typedef double(*matfunc3)(double,double,double);
380	typedef double(matfunc_inf)(double_list);	380	typedef double(matfunc_inf)(double_list);
381	typedef double(matfunc_str)(char);	381	typedef double(matfunc_str)(char);
382		382
383	// used to link function name to the function	383	// used to link function name to the function
384	typedef struct	384	typedef struct
385	{	385	{
386	char name[10];	386	char name[10];
387	int args;	387	int args;
388	void * f;	388	void * f;
389	} func;	389	} func;
390		390
391	// the list of functions	391	// the list of functions
392	const int max_func = 28;	392	const int max_func = 28;
393	func functions[max_func] =	393	func functions[max_func] =
394	{	394	{
395	"", 1, NULL, // íå ïîìíþ, ñ êàêîé öåëüþ	395	"", 1, NULL, // íå ïîìíþ, ñ êàêîé öåëüþ
396	"sin", 1, &sin,	396	"sin", 1, &sin,
397	"cos", 1, &cos,	397	"cos", 1, &cos,
398	"exp", 1, &exp,	398	"exp", 1, &exp,
399	"sqrt", 1, &sqrt,	399	"sqrt", 1, &sqrt,
400	"log", 1, &log,	400	"log", 1, &log,
401	"tg", 1, &tg,	401	"tg", 1, &tg,
402	"ctg", 1, &ctg,	402	"ctg", 1, &ctg,
403	"arcsin", 1, &asin,	403	"arcsin", 1, &asin,
404	"arccos", 1, &acos,	404	"arccos", 1, &acos,
405	"arctg", 1, &atan, // íå ðåàëèçîâàíî. âîçâðàùàåò îøèáêó ERR_GENERAL	405	"arctg", 1, &atan, // íå ðåàëèçîâàíî. âîçâðàùàåò îøèáêó ERR_GENERAL
406	"abs", 1, &fabs,	406	"abs", 1, &fabs,
407	"pow", 2, &pow,	407	"pow", 2, &pow,
408	"if", INF_ARGS, &func_if,	408	"if", INF_ARGS, &func_if,
409	"sum",INF_ARGS,&sum,	409	"sum",INF_ARGS,&sum,
410	"isnull",STR_ARG,&func_isnull, // ñëåãêà ÷/æ	410	"isnull",STR_ARG,&func_isnull, // ñëåãêà ÷/æ
411	"min",INF_ARGS,&func_min,	411	"min",INF_ARGS,&func_min,
412	"max",INF_ARGS,&func_max,	412	"max",INF_ARGS,&func_max,
413	"avg",INF_ARGS,&avg,	413	"avg",INF_ARGS,&avg,
414	"ceil",1,&func_ceil,	414	"ceil",1,&func_ceil,
415	"round",1,&func_round,	415	"round",1,&func_round,
416	"floor",1,&func_floor,	416	"floor",1,&func_floor,
417	"and",2,&logic_and,	417	"and",2,&logic_and,
418	"or",2,&logic_or,	418	"or",2,&logic_or,
419	"xor",2,&logic_xor,	419	"xor",2,&logic_xor,
420	"rand",1,&func_rand,	420	"rand",1,&func_rand,
421	//"case",INF_ARGS,&func_case,	421	//"case",INF_ARGS,&func_case,
422	"pi",0,&func_pi,	422	"pi",0,&func_pi,
423	"eps",0,&func_eps	423	"eps",0,&func_eps
424	};	424	};
425		425
426	// all delimiters	426	// all delimiters
427	#define MAXDELIM 17	427	#define MAXDELIM 17
428	const char delim[MAXDELIM]="+-*^/%=;(),><#! "; // not bad words	428	const char delim[MAXDELIM]="+-*^/%=;(),><#! "; // not bad words
429		429
430		430
431	int isdelim(char c)	431	int isdelim(char c)
432	{	432	{
433	//return strchr(delim, c) != 0;	433	//return strchr(delim, c) != 0;
434	for (int i = 0; i < MAXDELIM; i++)	434	for (int i = 0; i < MAXDELIM; i++)
435	if (c == delim[i])	435	if (c == delim[i])
436	return 1;	436	return 1;
437	return 0;	437	return 0;
438	}	438	}
439		439
440	int isdigit(char c)	440	int isdigit(char c)
441	{	441	{
442	return (c >= '0' && c <= '9');	442	return (c >= '0' && c <= '9');
443	}	443	}
444		444
445	int isalpha2(char c)	445	int isalpha2(char c)
446	{	446	{
447	return ((c >= 'a' && c <= 'z')	447	return ((c >= 'a' && c <= 'z')
448	\|\| (c >= 'A' && c <= 'Z') \|\| (c=='$'));	448	\|\| (c >= 'A' && c <= 'Z') \|\| (c=='$'));
449	}	449	}
450		450
451	int iswhite(char c)	451	int iswhite(char c)
452	{	452	{
453	return (c==' ' \|\| c=='\t');	453	return (c==' ' \|\| c=='\t');
454	}	454	}
455		455
456		456
457	void serror(int acode)	457	void serror(int acode)
458	{	458	{
459	if (acode != 0)	459	if (acode != 0)
460	code = acode;	460	code = acode;
461	}	461	}
462		462
463	void set_exp(char *exp)	463	void set_exp(char *exp)
464	{	464	{
465	prog = exp;	465	prog = exp;
466	}	466	}
467		467
468	int get_token()	468	int get_token()
469	{	469	{
470	int tok;	470	int tok;
471	char *temp;	471	char *temp;
472	(token_type) = 0;	472	(token_type) = 0;
473	tok = 0;	473	tok = 0;
474	temp = (token);	474	temp = (token);
475		475
476	if (*(prog) == '\0')	476	if (*(prog) == '\0')
477	{	477	{
478	*(token) = 0;	478	*(token) = 0;
479	tok = FINISHED;	479	tok = FINISHED;
480	return ((token_type) = DELIMITER);	480	return ((token_type) = DELIMITER);
481	}	481	}
482	while (iswhite(*(prog))) ++(prog);	482	while (iswhite(*(prog))) ++(prog);
483	if (isdelim(*(prog)))	483	if (isdelim(*(prog)))
484	{	484	{
485	char t=temp = (prog);	485	char t=temp = (prog);
486	(prog)++;	486	(prog)++;
487	temp++;	487	temp++;
488	if ((t == '>' \|\| t == '<' \|\| t == '!') && (prog) && (prog == '='))	488	if ((t == '>' \|\| t == '<' \|\| t == '!') && (prog) && (prog == '='))
489	{	489	{
490	temp = (prog);	490	temp = (prog);
491	(prog)++;	491	(prog)++;
492	temp++;	492	temp++;
493	}	493	}
494	*temp = 0;	494	*temp = 0;
495	return ((token_type) = DELIMITER);	495	return ((token_type) = DELIMITER);
496	}	496	}
497	if (isdigit(*(prog)))	497	if (isdigit(*(prog)))
498	{	498	{
499	while (!isdelim(*(prog)))	499	while (!isdelim(*(prog)))
500	temp++=(prog)++;	500	temp++=(prog)++;

Subversion Repositories Kolibri OS

(root)/programs/other/table/parser.cpp @ 5385 – Rev 7495 → 7516