mfcalc.cpp

Linux/windows 环境下跨平台开发程序

  /* YYACCEPT comes here.  */
  if (yyfree_stacks)
    {
      free (yyss);
      free (yyvs);
#ifdef YYLSP_NEEDED
      free (yyls);
#endif
    }
  return 0;

 yyabortlab:
  /* YYABORT comes here.  */
  if (yyfree_stacks)
    {
      free (yyss);
      free (yyvs);
#ifdef YYLSP_NEEDED
      free (yyls);
#endif
    }
  return 1;
}


// The symrec class
symrec::symrec(unsigned int h_n, int typ, symrec *nxt) 
{
	h_name = h_n;
	type = typ;
	next = nxt;
	row = col = -1;
	name = text = 0L;
	var = 0.0;
	isSSval = false;
	fnctptr = (double (*)(...))nop;
}

symrec::~symrec()
{
	if(name) free(name);	name = 0L;
	if(text) free(text);	text = 0L;
}

double
symrec::GetValue()
{
	anyResult ares;

	if(isSSval) {
		if(row < 0 && col < 0) InitSS();
		//GetResult( , , ,true) inhibits reentrance into parser !
		if(curr_data->GetResult(&ares, row, col, parse_level > MAX_PARSE)){
			return var = ares.value;
			}
		isSSval = false;
		row = col = -1;
		}
	return var;
}

void
symrec::GetValue(void *re)
{
	anyResult ares;
	YYSTYPE *res = (YYSTYPE*)re;

	if(isSSval) {
		if(row < 0 && col < 0) InitSS();
		res->a_data = 0L;	res->a_count = 0;
		//GetResult( , , ,true) inhibits reentrance into parser !
		if(curr_data->GetResult(&ares, row, col, parse_level > MAX_PARSE)){
			if(text) free(text);		text = 0L;
			if(ares.type == ET_VALUE) {
				res->type = VAR;	res->val = ares.value;
				res->text = 0L;
				}
			else if(ares.type == ET_TEXT && ares.text) {
				res->type = STR;	res->val = 0.0;
				text = strdup(ares.text);
				res->text = text;
				}
			else {
				res->type = NUM;	res->val = var;
				res->text = 0L;
				}
			var = res->val;
			return;
			}
		isSSval = false;
		row = col = -1;
		}
	if(text && text[0]) {
		res->text = strdup(text);
		res->val = var;		res->type = STR;
		}
	else {
		res->type = NUM;	res->val = var;
		res->text = 0L;
		}
	res->a_data = 0L;	res->a_count = 0L;
}

double 
symrec::SetValue(double v)
{
	if(isSSval) {
		if(row < 0 && col < 0) InitSS();
		if(curr_data->SetValue(row, col, v)){
			if(curr_data) curr_data->Command(CMD_UPDATE, 0L, 0L);
			return var = v;
			}
		isSSval = false;
		row = col = -1;
		}
	return var = v;
}

void 
symrec::SetValue(void* d, void* s)
{
	YYSTYPE *dest = (YYSTYPE*)d;
	YYSTYPE *src = (YYSTYPE*)s;

	if(isSSval && curr_data) {
		if(row < 0 && col < 0) InitSS();
		if(last_err_desc) curr_data->SetText(row, col, last_err_desc);
		else if(src->type == STR) curr_data->SetText(row, col, src->text);
		else if(src->type == ARR || (src->a_data)) curr_data->SetText(row, col, "#ARRAY");
		else if(src->type == VAR && src->tptr->type == TXT) curr_data->SetText(row, col, src->tptr->text);
		else curr_data->SetValue(row, col, src->val);
		curr_data->Command(CMD_UPDATE, 0L, 0L);
		}
	var = src->val;
	if(text) free(text);		text = 0L;
	if(src->text && src->text[0]) 	text = strdup(src->text);
	GetValue(d);
	return;
}

void
symrec::SetName(char *nam)
{
	if(name || !nam || !nam[0]) return;
	name = strdup(nam);
	if((name && curr_data) && (isalpha(name[0]) || name[0] == '$') && isdigit(name[strlen(name)-1])) isSSval=true;
}

void
symrec::InitSS()
{
	AccRange *ar;

	if(row<0 && col<0 &&(ar = new AccRange(name))) {
		ar->GetFirst(&col, &row);
		delete(ar);
		}
}

static void yyerror(char *s)
{  
	//called by yyparse on error
	if(curr_data) curr_data->Command(CMD_ERROR, last_error = s, 0L);
	else printf("%s\n", s);
}

static void yyargserr(char *s)
{
	//call from function on argument type/number mismatch
	yyerror(s);
	last_err_desc = "#ARGS";
}

static void store_res(YYSTYPE *res)
{
	if(last_err_desc) {
		line_res.type = ET_TEXT;
		line_res.value = 0.0;
		strcpy(res_txt, last_err_desc);
		}
	else if(res->type == STR) {
		line_res.type = ET_TEXT;
		line_res.value = 0.0;
		if(res->text) strcpy(res_txt, res->text);
		}
	else if((res->type == ARR || (res->a_data)) && res->a_count == 1) {
		line_res.type = ET_VALUE;
		line_res.value = res->a_data[0];
		}
	else if(res->type == ARR && !(res->a_data) && !(res->a_count)) {
		line_res.type = ET_VALUE;
		line_res.value = res->val;
		}
	else if(res->type == ARR || (res->a_data)) {
		line_res.type = ET_TEXT;
		line_res.value = 0.0;
		strcpy(res_txt, "#ARRAY");
		}
	else if(res->tptr && res->tptr->type == TXT) {
		line_res.type = ET_TEXT;
		line_res.value = 0.0;
		if(res->tptr->text) strcpy(res_txt, res->tptr->text);
		}
	else {
		line_res.type = ET_VALUE;
		line_res.value = res->val;
		}
}

static char *add_strings(char *st1, char *st2)
{
	char *newstr, *ret;

	if(st1 && st2) {
		if(newstr = (char*)malloc(strlen(st1) +strlen(st2) +4)) {
			sprintf(newstr, "%s%s", st1, st2);
			ret = PushString(newstr);
			free(newstr);
			return ret;
			}
		else return 0L;
		}
	if(st1) return st1;
	if(st2) return st2;
	return 0L;
}

static char *string_value(YYSTYPE *exp)
{
	char *st1, tmp[50];

	if(exp->type == STR){
		st1 = exp->text;
		}
	else if(exp->tptr && exp->tptr->type == TXT) {
		st1 = exp->tptr->text;
		}
	else {
		sprintf(tmp,"%g", exp->val);
		st1 = tmp;
		}
	return PushString(st1);
}

// store syntactical information
static void push_syntax()
{
	syntax_info *next;

	if(!(next = (syntax_info*)calloc(1, sizeof(syntax_info)))) return;
	if(syntax_level)memcpy(next, syntax_level, sizeof(syntax_info));
	next->next=syntax_level;
	syntax_level = next;
}

static void pop_syntax()
{
	syntax_info *si;

	if(si = syntax_level) {
		syntax_level = si->next;
		free(si);
		}
}

static double eval(YYSTYPE *sr, YYSTYPE *dst) 
{
	anyResult *ar;

	if(!sr || !sr->text) return 0.0;
	parse_level++;
	ar = do_formula(0L, sr->text);
	yylval.a_data = 0L;	yylval.a_count = 0;
	switch(ar->type) {
	case ET_VALUE:
		dst->type = NUM;
		dst->val = ar->value;
		dst->text = 0L;
		break;
	case ET_TEXT:
		dst->type = STR;
		dst->val = 0.0;
		dst->text = PushString(ar->text);
		break;
	default:
		dst->type = NUM;
		dst->val = 0.0;
		dst->text = 0L;
		break;
		}
	parse_level--;
	return dst->val;
}

// more functions
static double sign(double v)
{
	if(v > 0.0) return 1.0;
	if(v < 0.0) return -1.0;
	return 0.0;
}

static long idum=0;

static double rand(double v)
{
	return ran2(&idum);
}

static double srand(double v)
{
	idum = (long)v;
	return v;
}

static double factorial(double v)
{
	return factrl((int)v);
}

static void close_arr_func(YYSTYPE *sr)
{
	if(sr->a_data) free(sr->a_data);
	sr->a_data = 0L;		sr->a_count = 0;
}

static double _strlen(YYSTYPE *sr, YYSTYPE *dst)
{
	if(!sr || !sr->text) return 0.0;
	return (double)strlen(sr->text);
}

#undef min
static double min(YYSTYPE *sr) 
{
	int i;

	if(!sr || !sr->a_count) return 0.0;
	if(sr->a_data && sr->a_data){
		for(i = 1, sr->val = sr->a_data[0]; i < sr->a_count; i++) 
			if(sr->a_data[i] < sr->val) sr->val = sr->a_data[i];
		close_arr_func(sr);
		}
	return sr->val;
}

#undef max
static double max(YYSTYPE *sr) 
{
	int i;

	if(!sr || !sr->a_count) return 0.0;
	if(sr->a_data){
		for(i = 1, sr->val = sr->a_data[0]; i < sr->a_count; i++) 
			if(sr->a_data[i] > sr->val) sr->val = sr->a_data[i];
		close_arr_func(sr);
		}
	return sr->val;
}

static double count(YYSTYPE *sr)
{
	if(!sr) return 0.0;
	if(sr->a_data){
		sr->val = (double)sr->a_count;
		close_arr_func(sr);
		}
	else sr->val = 0.0;
	return sr->val;
}

static double sum(YYSTYPE *sr) 
{
	int i;

	if(!sr) return 0.0;
	if(sr->a_data){
		for(i = 0, sr->val = 0.0; i < sr->a_count; i++) sr->val += sr->a_data[i];
		close_arr_func(sr);
		}
	else sr->val = 0.0;
	return sr->val;
}

static double calc_variance(double *values, int n)
{
	int i;
	double ss, d, mean = d_amean(n, values);

	for(i=0, ss=0.0; i < n; i++) ss += ((d=values[i]-mean)*d);
	return (ss/(n-1));
}

static double mean(YYSTYPE *sr) 
{
	if(!sr) return 0.0;
	if(sr->a_data && sr->a_count){
		sr->val = d_amean(sr->a_count, sr->a_data );
		close_arr_func(sr);
		}
	return sr->val;
}

static double gmean(YYSTYPE *sr) 
{
	if(!sr) return 0.0;
	if(sr->a_data && sr->a_count){
		sr->val = d_gmean(sr->a_count, sr->a_data );
		close_arr_func(sr);
		}
	return sr->val;
}

static double hmean(YYSTYPE *sr) 
{
	if(!sr) return 0.0;
	if(sr->a_data && sr->a_count){
		sr->val = d_hmean(sr->a_count, sr->a_data );
		close_arr_func(sr);
		}
	return sr->val;
}

static double quartile1(YYSTYPE *sr)
{
	if(!sr) return 0.0;
	if(sr->a_data && sr->a_count){
		d_quartile(sr->a_count, sr->a_data, &sr->val, 0L, 0L);
		close_arr_func(sr);
		}
	return sr->val;
}

static double quartile2(YYSTYPE *sr)
{
	if(!sr) return 0.0;
	if(sr->a_data && sr->a_count){
		d_quartile(sr->a_count, sr->a_data, 0L, &sr->val, 0L);
		close_arr_func(sr);
		}
	return sr->val;
}

static double quartile3(YYSTYPE *sr)
{
	if(!sr) return 0.0;
	if(sr->a_data && sr->a_count){