config.c

来自「Calc Software Package for Number Calc」· C语言 代码 · 共 1,477 行 · 第 1/3 页

 *	src	copy this configuration
 *
 * returns:
 *	pointer to the configuration copy
 */
CONFIG *
config_copy(CONFIG *src)
{
	CONFIG *dest;		/* the new CONFIG to return */

	/*
	 * firewall
	 */
	if (src == NULL || src->epsilon == NULL || src->prompt1 == NULL ||
	    src->prompt2 == NULL) {
		math_error("bad CONFIG value");
		/*NOTREACHED*/
	}

	/*
	 * malloc the storage
	 */
	dest = (CONFIG *)malloc(sizeof(CONFIG));
	if (dest == NULL) {
		math_error("malloc of CONFIG failed");
		/*NOTREACHED*/
	}

	/*
	 * copy over the values
	 */
	memcpy((void *)dest, (void *)src, sizeof(CONFIG));

	/*
	 * clone the pointer values
	 */
	dest->epsilon = qlink(src->epsilon);
	dest->prompt1 = strdup(src->prompt1);
	dest->prompt2 = strdup(src->prompt2);
	if (src->program == NULL) {
		dest->program = strdup(program);
	} else {
		dest->program = strdup(src->program);
	}
	if (src->base_name == NULL) {
		dest->base_name = strdup(base_name);
	} else {
		dest->base_name = strdup(src->base_name);
	}
	/* NOTE: allow_custom points to a global variable, so do not clone it */
	if (src->version == NULL) {
		dest->version = strdup(version());
	} else {
		dest->version = strdup(src->version);
	}

	/*
	 * return the new value
	 */
	return dest;
}


/*
 * config_free - free a CONFIG value
 *
 * given:
 *	cfg		the CONFIG value to free
 */
void
config_free(CONFIG *cfg)
{
	/*
	 * firewall
	 */
	if (cfg == NULL) {
		return;
	}

	/*
	 * free pointer values
	 */
	if (cfg->epsilon != NULL) {
		qfree(cfg->epsilon);
	}
	if (cfg->prompt1 != NULL) {
		free(cfg->prompt1);
	}
	if (cfg->prompt2 != NULL) {
		free(cfg->prompt2);
	}
	if (cfg->program != NULL) {
		free(cfg->program);
	}
	if (cfg->base_name != NULL) {
		free(cfg->base_name);
	}
	/* NOTE: allow_custom points to a global variable, so do not free it */
	if (cfg->version != NULL) {
		free(cfg->version);
	}

	/*
	 * free the CONFIG value itself
	 */
	free(cfg);
	return;
}


/*
 * config_value - return a CONFIG element as a value
 *
 * given:
 *	cfg		CONFIG from which an element will be returned
 *	type		the type of CONFIG element to print
 *	ret		where to return the value
 *
 * returns:
 *	ret points to the VALUE returned
 */
void
config_value(CONFIG *cfg, int type, VALUE *vp)
{
	long i=0;
	char *p;

	/*
	 * firewall
	 */
	if (cfg == NULL || cfg->epsilon == NULL || cfg->prompt1 == NULL ||
	    cfg->prompt2 == NULL) {
		math_error("bad CONFIG value");
		/*NOTREACHED*/
	}

	/*
	 * convert element to value
	 */
	vp->v_type = V_NUM;
	vp->v_subtype = V_NOSUBTYPE;
	switch (type) {
	case CONFIG_ALL:
		vp->v_type = V_CONFIG;
		vp->v_config = config_copy(conf);
		return;

	case CONFIG_TRACE:
		i = cfg->traceflags;
		break;

	case CONFIG_DISPLAY:
		i = cfg->outdigits;
		break;

	case CONFIG_MODE:
		vp->v_type = V_STR;
		p = lookup_name(modes, cfg->outmode);
		if (p == NULL) {
			math_error("invalid output mode: %d", cfg->outmode);
			/*NOTREACHED*/
		}
		vp->v_str = makenewstring(p);
		return;

	case CONFIG_MODE2:
		vp->v_type = V_STR;
		p = lookup_name(modes, cfg->outmode2);
		if (p == NULL) {
			math_error("invalid secondary output mode: %d", cfg->outmode2);
			/*NOTREACHED*/
		}
		vp->v_str = makenewstring(p);
		return;

	case CONFIG_EPSILON:
		vp->v_num = qlink(cfg->epsilon);
		return;

	case CONFIG_MAXPRINT:
		i = cfg->maxprint;
		break;

	case CONFIG_MUL2:
		i = cfg->mul2;
		break;

	case CONFIG_SQ2:
		i = cfg->sq2;
		break;

	case CONFIG_POW2:
		i = cfg->pow2;
		break;

	case CONFIG_REDC2:
		i = cfg->redc2;
		break;

	case CONFIG_TILDE:
		i = (cfg->tilde_ok ? 1 : 0);
		break;

	case CONFIG_TAB:
		i = (cfg->tab_ok ? 1 : 0);
		break;

	case CONFIG_QUOMOD:
		i = cfg->quomod;
		break;

	case CONFIG_QUO:
		i = cfg->quo;
		break;

	case CONFIG_MOD:
		i = cfg->mod;
		break;

	case CONFIG_SQRT:
		i = cfg->sqrt;
		break;

	case CONFIG_APPR:
		i = cfg->appr;
		break;

	case CONFIG_CFAPPR:
		i = cfg->cfappr;
		break;

	case CONFIG_CFSIM:
		i = cfg->cfsim;
		break;

	case CONFIG_OUTROUND:
		i = cfg->outround;
		break;

	case CONFIG_ROUND:
		i = cfg->round;
		break;

	case CONFIG_LEADZERO:
		i = (cfg->leadzero ? 1 : 0);
		break;

	case CONFIG_FULLZERO:
		i = (cfg->fullzero ? 1 : 0);
		break;

	case CONFIG_MAXSCAN:
		i = cfg->maxscancount;
		break;

	case CONFIG_PROMPT:
		vp->v_type = V_STR;
		vp->v_str = makenewstring(cfg->prompt1);
		return;

	case CONFIG_MORE:
		vp->v_type = V_STR;
		vp->v_str = makenewstring(cfg->prompt2);
		return;

	case CONFIG_BLKMAXPRINT:
		i = cfg->blkmaxprint;
		break;

	case CONFIG_BLKVERBOSE:
		i = (cfg->blkverbose ? 1 : 0);
		break;

	case CONFIG_BLKBASE:
		vp->v_type = V_STR;
		p = lookup_name(blk_base, cfg->blkbase);
		if (p == NULL) {
			math_error("invalid block base: %d", cfg->blkbase);
			/*NOTREACHED*/
		}
		vp->v_str = makenewstring(p);
		return;

	case CONFIG_BLKFMT:
		vp->v_type = V_STR;
		p = lookup_name(blk_fmt, cfg->blkfmt);
		if (p == NULL) {
			math_error("invalid block format: %d", cfg->blkfmt);
			/*NOTREACHED*/
		}
		vp->v_str = makenewstring(p);
		return;

	case CONFIG_CALC_DEBUG:
		i = cfg->calc_debug;
		break;

	case CONFIG_RESOURCE_DEBUG:
		i = cfg->resource_debug;
		break;

	case CONFIG_USER_DEBUG:
		i = cfg->user_debug;
		break;

	case CONFIG_VERBOSE_QUIT:
		i = (cfg->verbose_quit ? 1 : 0);
		break;

	case CONFIG_CTRL_D:
		vp->v_type = V_STR;
		p = lookup_name(ctrl_d, cfg->ctrl_d);
		if (p == NULL) {
			math_error("invalid Control-D: %d", cfg->ctrl_d);
			/*NOTREACHED*/
		}
		vp->v_str = makenewstring(p);
		return;

	case CONFIG_PROGRAM:
		vp->v_type = V_STR;
		if (cfg->base_name == NULL) {
			vp->v_str = makestring(strdup(program));
		} else {
			vp->v_str = makenewstring(cfg->program);
		}
		return;

	case CONFIG_BASENAME:
		vp->v_type = V_STR;
		if (cfg->base_name == NULL) {
			vp->v_str = makestring(strdup(base_name));
		} else {
			vp->v_str = makenewstring(cfg->base_name);
		}
		return;

	case CONFIG_WINDOWS:
		i = (cfg->windows ? 1 : 0);
		break;

	case CONFIG_CYGWIN:
		i = (cfg->cygwin ? 1 : 0);
		break;

	case CONFIG_COMPILE_CUSTOM:
		i = (cfg->compile_custom ? 1 : 0);
		break;

	case CONFIG_ALLOW_CUSTOM:
		/* firewall */
		if (cfg->allow_custom == NULL) {
			cfg->allow_custom = &allow_custom;
		}
		i = (*(cfg->allow_custom) ? 1 : 0);
		break;

	case CONFIG_VERSION:
		vp->v_type = V_STR;
		if (cfg->version == NULL) {
			vp->v_str = makestring(strdup(version()));
		} else {
			vp->v_str = makenewstring(cfg->version);
		}
		return;

	case CONFIG_BASEB:
		i = BASEB;
		break;

	case CONFIG_REDECL_WARN:
		i = (cfg->redecl_warn ? 1 : 0);
		break;

	case CONFIG_DUPVAR_WARN:
		i = (cfg->dupvar_warn ? 1 : 0);
		break;

	case CONFIG_HZ:
		i = CALC_HZ;
		break;

	default:
		math_error("Getting illegal CONFIG element");
		/*NOTREACHED*/
	}

	/*
	 * if we got this far, we have a V_NUM in i
	 */
	vp->v_num = itoq(i);
	return;
}


/*
 * config_cmp - compare two CONFIG states
 *
 * given:
 *	cfg1 - 1st CONFIG to compare
 *	cfg2 - 2nd CONFIG to compare
 *
 * return:
 *	TRUE if configurations differ
 */
BOOL
config_cmp(CONFIG *cfg1, CONFIG *cfg2)
{
	/*
	 * firewall
	 */
	if (cfg1 == NULL || cfg1->epsilon == NULL || cfg1->prompt1 == NULL ||
	    cfg1->prompt2 == NULL) {
		math_error("CONFIG #1 value is invalid");
		/*NOTREACHED*/
	}
	if (cfg2 == NULL || cfg2->epsilon == NULL || cfg2->prompt1 == NULL ||
	    cfg2->prompt2 == NULL) {
		math_error("CONFIG #2 value is invalid");
		/*NOTREACHED*/
	}

	/*
	 * compare
	 */
	return cfg1->traceflags != cfg2->traceflags ||
	       cfg1->outdigits != cfg2->outdigits ||
	       cfg1->outmode != cfg2->outmode ||
	       cfg1->outmode2 != cfg2->outmode2 ||
	       qcmp(cfg1->epsilon, cfg2->epsilon) ||
	       cfg1->epsilonprec != cfg2->epsilonprec ||
	       cfg1->maxprint != cfg2->maxprint ||
	       cfg1->mul2 != cfg2->mul2 ||
	       cfg1->sq2 != cfg2->sq2 ||
	       cfg1->pow2 != cfg2->pow2 ||
	       cfg1->redc2 != cfg2->redc2 ||
	       cfg1->tilde_ok != cfg2->tilde_ok ||
	       cfg1->tab_ok != cfg2->tab_ok ||
	       cfg1->quomod != cfg2->quomod ||
	       cfg1->quo != cfg2->quo ||
	       cfg1->mod != cfg2->mod ||
	       cfg1->sqrt != cfg2->sqrt ||
	       cfg1->appr != cfg2->appr ||
	       cfg1->cfappr != cfg2->cfappr ||
	       cfg1->cfsim != cfg2->cfsim ||
	       cfg1->outround != cfg2->outround ||
	       cfg1->round != cfg2->round ||
	       cfg1->leadzero != cfg2->leadzero ||
	       cfg1->fullzero != cfg2->fullzero ||
	       cfg1->maxscancount != cfg2->maxscancount ||
	       strcmp(cfg1->prompt1, cfg2->prompt1) != 0 ||
	       strcmp(cfg1->prompt2, cfg2->prompt2) != 0 ||
	       cfg1->blkmaxprint != cfg2->blkmaxprint ||
	       cfg1->blkverbose != cfg2->blkverbose ||
	       cfg1->blkbase != cfg2->blkbase ||
	       cfg1->blkfmt != cfg2->blkfmt ||
	       cfg1->calc_debug != cfg2->calc_debug ||
	       cfg1->resource_debug != cfg2->resource_debug ||
	       cfg1->user_debug != cfg2->user_debug ||
	       cfg1->verbose_quit != cfg2->verbose_quit ||
	       cfg1->ctrl_d != cfg2->ctrl_d ||

	       (cfg1->program == NULL && cfg2->program != NULL) ||
	       (cfg1->program != NULL && cfg2->program == NULL) ||
	       (cfg1->program != NULL && cfg2->program != NULL &&
		strcmp(cfg1->program, cfg2->program) != 0) ||

	       (cfg1->base_name == NULL && cfg2->base_name != NULL) ||
	       (cfg1->base_name != NULL && cfg2->base_name == NULL) ||
	       (cfg1->base_name != NULL && cfg2->base_name != NULL &&
		strcmp(cfg1->base_name, cfg2->base_name) != 0) ||

	       cfg1->windows != cfg2->windows ||

	       cfg1->cygwin != cfg2->cygwin ||

	       cfg1->compile_custom != cfg2->compile_custom ||

	       (cfg1->allow_custom == NULL && cfg2->allow_custom != NULL) ||
	       (cfg1->allow_custom != NULL && cfg2->allow_custom == NULL) ||
	       (cfg1->allow_custom != NULL && cfg2->allow_custom != NULL &&
		*(cfg1->allow_custom) != *(cfg2->allow_custom)) ||

	       (cfg1->version == NULL && cfg2->version != NULL) ||
	       (cfg1->version != NULL && cfg2->version == NULL) ||
	       (cfg1->version != NULL && cfg2->version != NULL &&
		strcmp(cfg1->version, cfg2->version) != 0) ||

	       cfg1->baseb != cfg2->baseb;
}