parsecfg.c

串口调试工具。非常好的串口调试助手

			}
			if ((ptr = realloc(*(double **) (cfg[num].value), sizeof(double) * (*section + 1))) == NULL) {
				return (CFG_MEM_ALLOC_FAIL);
			}
			*(double **) (cfg[num].value) = ptr;
			*(*((double **) (cfg[num].value)) + *section) = 0;
			break;

		default:
			return (CFG_INTERNAL_ERROR);
		}
	}
	return (CFG_NO_ERROR);
}


/* --------------------------------------------------
   NAME       rm_first_spaces
   FUNCTION   remove lead-off spaces and tabs in the string
   INPUT      ptr ... pointer to string
   OUTPUT     new poniter after removing
   -------------------------------------------------- */
static char *rm_first_spaces(char *ptr)
{
	while (*ptr == ' ' || *ptr == '\t') {
		ptr++;
	}
	return (ptr);
}


/* --------------------------------------------------
   NAME       get_single_line_without_first_spaces
   FUNCTION   get a single line without lead-off spaces
              and tabs from file
   INPUT      fp ....... file pointer
              gotptr ... pointer stored got string
	      line ..... pointer to line number
   OUTPUT     new pointer after removing
   -------------------------------------------------- */
static char *get_single_line_without_first_spaces(FILE *fp, char **gotstr, int *line)
{
	char *ptr;

	for (;;) {
		if ((*gotstr = dynamic_fgets(fp)) == NULL) {
			return (NULL);
		}
		(*line)++;
		ptr = rm_first_spaces(*gotstr);
		if (*ptr != '#' && *ptr != '\0') {
			return (ptr);
		}
		free(*gotstr);
	}
}


/* --------------------------------------------------
   NAME       dynamic_fgets
   FUNCTION   fgets with dynamic allocated memory
   INPUT      fp ... file pointer
   OUTPUT     pointer to got strings
              NULL on error
   -------------------------------------------------- */
static char *dynamic_fgets(FILE *fp)
{
	char *ptr;
	char temp[128];
	int i;

	ptr = malloc(1);
	if (ptr == NULL) {
		cfgFatalFunc(CFG_MEM_ALLOC_FAIL, "unknown", 0, "");
		return (NULL);
	}
	*ptr = '\0';
	for (i = 0;; i++) {
		if (fgets(temp, 128, fp) == NULL) {
			if (ferror(fp) != 0 || i == 0) {
				free(ptr);
				return (NULL);
			}
			return (ptr);
		}
		ptr = realloc(ptr, 127 * (i + 1) + 1);
		if (ptr == NULL) {
			cfgFatalFunc(CFG_MEM_ALLOC_FAIL, "unknown", 0, "");
			return (NULL);
		}
		strcat(ptr, temp);
		if (strchr(temp, '\n') != NULL) {
			*strchr(ptr, '\n') = '\0';
			return (ptr);
		}
	}
}


/* --------------------------------------------------
   NAME       dump_simple
   FUNCTION   
   INPUT      
   OUTPUT     0 on success, -1 on error
   -------------------------------------------------- */
static int dump_simple(FILE *fp, cfgStruct cfg[], cfgFileType type)
{
	int i;
	char c[2];
	cfgList *l;

	for (i = 0; cfg[i].type != CFG_END; i++) {
		switch (cfg[i].type) {
		case CFG_BOOL:
			fprintf(fp, "%s\t= %s\n", cfg[i].parameterName, (*(int *) (cfg[i].value)) ? "True" : "False");
			break;
		case CFG_INT:
			fprintf(fp, "%s\t= %d\n", cfg[i].parameterName, *(int *) (cfg[i].value));
			break;
		case CFG_UINT:
			fprintf(fp, "%s\t= %u\n", cfg[i].parameterName, *(unsigned int *) (cfg[i].value));
			break;
		case CFG_LONG:
			fprintf(fp, "%s\t= %ld\n", cfg[i].parameterName, *(long *) (cfg[i].value));
			break;
		case CFG_ULONG:
			fprintf(fp, "%s\t= %lu\n", cfg[i].parameterName, *(unsigned long *) (cfg[i].value));
			break;
		case CFG_STRING:
			if (*(char **) (cfg[i].value) == NULL) {
				break;
			}
			single_or_double_quote(*(char **) (cfg[i].value), c);
			fprintf(fp, "%s\t= %s%s%s\n", cfg[i].parameterName, c, *(char **) (cfg[i].value), c);
			break;
		case CFG_STRING_LIST:
			for (l = *(cfgList **) (cfg[i].value); l != NULL; l = l->next) {
				single_or_double_quote(l->str, c);
				fprintf(fp, "%s\t= %s%s%s\n", cfg[i].parameterName, c, l->str, c);
			}
			break;
		case CFG_FLOAT:
			fprintf(fp, "%s\t= %f\n", cfg[i].parameterName, *(float *) (cfg[i].value));
			break;
		case CFG_DOUBLE:
			fprintf(fp, "%s\t= %f\n", cfg[i].parameterName, *(double *) (cfg[i].value));
			break;
		default:
			cfgFatal(CFG_INTERNAL_ERROR, "?", 0, NULL);
			return (-1);
		}
	}
	return (0);
}


/* --------------------------------------------------
   NAME       dump_ini
   FUNCTION   
   INPUT      
   OUTPUT     0 on success, -1 on error
   -------------------------------------------------- */
static int dump_ini(FILE *fp, cfgStruct cfg[], cfgFileType type, int max)
{
	int i, j;
	char c[2];
	cfgList *l;

	for (j = 0; j < max; j++) {
		single_or_double_quote(cfgSectionNumberToName(j), c);
		fprintf(fp, "[%s%s%s]\n", c, cfgSectionNumberToName(j), c);

		for (i = 0; cfg[i].type != CFG_END; i++) {
			switch (cfg[i].type) {
			case CFG_BOOL:
				fprintf(fp, "%s\t= %s\n", cfg[i].parameterName, (*(int **) (cfg[i].value))[j] ? "True" : "False");
				break;
			case CFG_INT:
				fprintf(fp, "%s\t= %d\n", cfg[i].parameterName, (*(int **) (cfg[i].value))[j]);
				break;
			case CFG_UINT:
				fprintf(fp, "%s\t= %u\n", cfg[i].parameterName, (*(unsigned int **) (cfg[i].value))[j]);
				break;
			case CFG_LONG:
				fprintf(fp, "%s\t= %ld\n", cfg[i].parameterName, (*(long **) (cfg[i].value))[j]);
				break;
			case CFG_ULONG:
				fprintf(fp, "%s\t= %lu\n", cfg[i].parameterName, (*(unsigned long **) (cfg[i].value))[j]);
				break;
			case CFG_STRING:
				if ((*(char ***) (cfg[i].value))[j] == NULL) {
					break;
				}
				single_or_double_quote((*(char ***) (cfg[i].value))[j], c);
				fprintf(fp, "%s\t= %s%s%s\n", cfg[i].parameterName, c, (*(char ***) (cfg[i].value))[j], c);
				break;
			case CFG_STRING_LIST:
				for (l = (*(cfgList ***) (cfg[i].value))[j]; l != NULL; l = l->next) {
					single_or_double_quote(l->str, c);
					fprintf(fp, "%s\t= %s%s%s\n", cfg[i].parameterName, c, l->str, c);
				}
				break;
			case CFG_FLOAT:
				fprintf(fp, "%s\t= %f\n", cfg[i].parameterName, (*(float **) (cfg[i].value))[j]);
				break;
			case CFG_DOUBLE:
				fprintf(fp, "%s\t= %f\n", cfg[i].parameterName, (*(double **) (cfg[i].value))[j]);
				break;
			default:
				cfgFatal(CFG_INTERNAL_ERROR, "?", 0, NULL);
				return (-1);
			}
		}
		fprintf(fp, "\n");
	}
	return (0);
}


/* --------------------------------------------------
   NAME       single_or_double_quote
   FUNCTION   
   INPUT      
   OUTPUT     none
   -------------------------------------------------- */
static void single_or_double_quote(const char *str, char *ret)
{
	ret[1] = '\0';

	if (strchr(str, '\"') != NULL) {
		ret[0] = '\'';
	} else if (strchr(str, '\'') != NULL || strchr(str, '#') != NULL || strchr(str, '\t') != NULL || strchr(str, ' ') != NULL) {
		ret[0] = '\"';
	} else {
		ret[0] = '\0';
	}
}


/* --------------------------------------------------
   NAME       fetch_simple
   FUNCTION   
   INPUT      
   OUTPUT     0 on success, -1 on error
   -------------------------------------------------- */
static int fetch_simple(const char *file, FILE *fp, char *parameter_name, void *result_value, cfgValueType value_type)
{
	int store_flag = -1;
	int error_code;
	int line;
	char *line_buf;
	char *ptr;
	char *read_parameter;
	char *read_value;
	cfgStruct fetch_cfg[] = {
		{parameter_name, value_type, result_value},
		{NULL, CFG_END, NULL}
	};

	while ((ptr = get_single_line_without_first_spaces(fp, &line_buf, &line)) != NULL) {	/* malloc line_buf */
		if ((ptr = parse_word(ptr, &read_parameter, CFG_PARAMETER)) == NULL) {	/* malloc read_parameter */
			cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
			free(line_buf);
			return (-1);
		}
		if (strcasecmp(read_parameter, parameter_name) == 0) {
			if (*ptr == '{') {
				ptr = rm_first_spaces(ptr + 1);
				if (*ptr != '\0' && *ptr != '#') {
					cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				if (parse_values_between_braces(file, fp, parameter_name, fetch_cfg, &line, CFG_SIMPLE, 0, line_buf, line) != CFG_NO_ERROR) {
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
			} else {
				if ((ptr = parse_word(ptr, &read_value, CFG_VALUE)) == NULL) {	/* malloc read_value */
					cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				if ((error_code = store_value(fetch_cfg, parameter_name, read_value, CFG_SIMPLE, 0)) != CFG_NO_ERROR) {
					cfgFatal(error_code, file, line, line_buf);
					free(read_value);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				free(read_value);	/* free */
			}
			store_flag = 0;
			free(line_buf);
		} else {
			if (*ptr == '{') {
				ptr = rm_first_spaces(ptr + 1);
				if (*ptr != '\0' && *ptr != '#') {
					cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				free(line_buf);
				while ((ptr = get_single_line_without_first_spaces(fp, &line_buf, &line)) != NULL) {	/* malloc line_buf */
					if (*ptr == '}') {
						ptr = rm_first_spaces(ptr + 1);
						if (*ptr != '\0' && *ptr != '#') {
							cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
							free(line_buf);
							free(read_parameter);
							return (-1);
						}
						break;
					}
					free(line_buf);
				}
			}
		}
		free(read_parameter);
	}
	return (store_flag);
}


/* --------------------------------------------------
   NAME       fetch_ini
   FUNCTION   
   INPUT      
   OUTPUT     0 on success, -1 on error
   -------------------------------------------------- */
static int fetch_ini(const char *file, FILE *fp, char *parameter_name, void *result_value, cfgValueType value_type, int section_num, const char *section_name)
{
	int store_flag = -1;
	int section_flag = -1;
	int error_code;
	int line;
	char *line_buf;
	char *ptr;
	char *read_parameter;
	char *read_value;
	char *read_section_name;
	int current_section_number = 0;

	cfgStruct fetch_cfg[] = {
		{parameter_name, value_type, result_value},
		{NULL, CFG_END, NULL}
	};

	while ((ptr = get_single_line_without_first_spaces(fp, &line_buf, &line)) != NULL) {	/* malloc line_buf */
		if (*ptr == '[') {
			if (section_flag == 0) {
				free(line_buf);
				return (store_flag);
			}
			ptr = rm_first_spaces(ptr + 1);
			if ((ptr = parse_word(ptr, &read_section_name, CFG_SECTION)) == NULL) {	/* malloc read_section_name */
				free(line_buf);
				return (CFG_SYNTAX_ERROR);
			}
			ptr = rm_first_spaces(ptr + 1);
			if (*ptr != '\0' && *ptr != '#') {
				free(line_buf);
				free(read_section_name);
				return (CFG_SYNTAX_ERROR);
			}
			current_section_number++;
			if ((section_num > 0 && current_section_number == section_num) || (section_num <= 0 && strcasecmp(read_section_name, section_name) == 0)) {
				section_flag = 0;
				free(line_buf);
				free(read_section_name);
				continue;
			}
			free(read_section_name);
		}
		if (section_flag == -1) {
			free(line_buf);
			continue;
		}

		if ((ptr = parse_word(ptr, &read_parameter, CFG_PARAMETER)) == NULL) {	/* malloc read_parameter */
			cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
			free(line_buf);
			return (-1);
		}
		if (strcasecmp(read_parameter, parameter_name) == 0) {
			if (*ptr == '{') {
				ptr = rm_first_spaces(ptr + 1);
				if (*ptr != '\0' && *ptr != '#') {
					cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				if (parse_values_between_braces(file, fp, parameter_name, fetch_cfg, &line, CFG_SIMPLE, 0, line_buf, line) != CFG_NO_ERROR) {
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
			} else {
				if ((ptr = parse_word(ptr, &read_value, CFG_VALUE)) == NULL) {	/* malloc read_value */
					cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				if ((error_code = store_value(fetch_cfg, parameter_name, read_value, CFG_SIMPLE, 0)) != CFG_NO_ERROR) {
					cfgFatal(error_code, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					free(read_value);
					return (-1);
				}
				free(read_value);
			}
			store_flag = 0;
			free(line_buf);
		} else {
			if (*ptr == '{') {
				ptr = rm_first_spaces(ptr + 1);
				if (*ptr != '\0' && *ptr != '#') {
					cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
					free(line_buf);
					free(read_parameter);
					return (-1);
				}
				free(line_buf);
				while ((ptr = get_single_line_without_first_spaces(fp, &line_buf, &line)) != NULL) {
					if (*ptr == '}') {
						ptr = rm_first_spaces(ptr + 1);
						if (*ptr != '\0' && *ptr != '#') {
							cfgFatal(CFG_SYNTAX_ERROR, file, line, line_buf);
							free(line_buf);
							free(read_parameter);
							return (-1);
						}
						free(line_buf);
						break;
					}
					free(line_buf);
				}
			}
		}
		free(read_parameter);
	}
	return (store_flag);
}