代码拉取完成,页面将自动刷新
/*
* MIT License
*
* Copyright (c) 2016 wen.gu <454727014@qq.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/***************************************************************************
* Name: tiny_ini_file.c
*
* Purpose: ini file operation API implementation
*
* Developer:
* wen.gu , 2016-08-10
*
* TODO:
*
***************************************************************************/
#define _CRT_SECURE_NO_WARNINGS
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include "tiny_ini_file.h"
/***************************************************************************
*
* macro define
*
***************************************************************************/
#define LOGI printf
#define LOGE printf
/***************************************************************************
*
* data structure define
*
***************************************************************************/
struct key_value_pair_s
{
char* key;
char* value;
void* opaque; /** private data, user cann't modify it */
};
/** ini file parser */
typedef struct my_tiny_ini_file_s
{
tiny_ini_file_t common;
FILE* fp; /** ini file handle */
ini_section_t* sections;
GU32 section_count;
}my_ini_file_t;
/***************************************************************************
*
* API define
*
***************************************************************************/
static inline GBOL isCommentTag(char ch)
{
return (ch == '#' || ch == ';') ? GTRUE : GFALSE;
}
static ini_section_t* iniFileNewSection(const char* name)
{
ini_section_t* isec = NULL;
GU32 len = strlen(name);
char* buf = (char*)malloc(sizeof(ini_section_t) + len + 1);
if (buf)
{
isec = (ini_section_t*)buf;
memset(isec, 0, sizeof(ini_section_t));
isec->name = buf + sizeof(ini_section_t);
memcpy(isec->name, name, len);
isec->name[len] = '\0';
}
else
{
LOGE("alloc section instance failed\n");
}
return isec;
}
static key_value_pair_t* iniFileNewParameter(char* key, GU32 key_len,
char* value, GU32 value_len)
{
key_value_pair_t* param = NULL;
GU32 totalSize = key_len + value_len;
char* buf = (char*)malloc(totalSize + sizeof(key_value_pair_t)+2);
if (buf)
{
param = (key_value_pair_t*)buf;
buf += sizeof(key_value_pair_t);
param->key = buf;
memcpy(buf, key, key_len);
buf[key_len] = '\0';
param->value = buf + key_len + 1;
memcpy(param->value, value, value_len);
buf[totalSize + 1] = '\0';
param->opaque = NULL;
}
else
{
LOGE("alloc buffer for key and value failed\n");
}
return param;
}
static GS32 iniFileAddParameter(ini_section_t* section, key_value_pair_t* param)
{
key_value_pair_t* pair = section->pairs;
if (pair)
{
while (pair->opaque) pair = (key_value_pair_t*)(pair->opaque);
pair->opaque = param;
}
else
{
/** first parameter */
section->pairs = param;
}
section->pair_count++;
return G_OK;
}
static GS32 iniFileAddSection(my_ini_file_t* mif, ini_section_t* section)
{
ini_section_t* isec = mif->sections;
if (isec)
{
while (isec->opaque) isec = (ini_section_t*)isec->opaque;
isec->opaque = section;
}
else
{
/**first section */
mif->sections = section;
}
mif->section_count++;
return G_OK;
}
static GBOL iniFileHasSection_l(my_ini_file_t* mif, const char* name)
{
GBOL ret = GFALSE;
ini_section_t* isec = mif->sections;
while (isec)
{
if (!strcmp(isec->name, name))
{
ret = GTRUE;
break;
}
isec = (ini_section_t*)isec->opaque;
}
return ret;
}
static ini_section_t* iniFileGetSection_l(my_ini_file_t* mif, const char* name)
{
ini_section_t* ret = NULL;
ini_section_t* isec = mif->sections;
while (isec)
{
if (!strcmp(isec->name, name))
{
ret = isec;
break;
}
isec = (ini_section_t*)isec->opaque;
}
return ret;
}
static ini_section_t* iniFileGetNewestSection(my_ini_file_t* mif)
{
ini_section_t* isec = mif->sections;
if (isec)
{
while (isec->opaque) isec = (ini_section_t*)isec->opaque;
}
return isec;
}
static char* iniFileParseSection(my_ini_file_t* mif, char* line,
char* line_end, GU32 line_num, GS32* ret)
{
char* ptr = line;
char* pEnd = line_end;
char* section = strchr(ptr, ']');
/** process section name */
if (section)
{
//char temp = *section;
//*section = '\0';
if (iniFileHasSection_l(mif, ptr) == GTRUE)
{
LOGE("syntax error[line:%d]: section(%s) already exist, end parse \n",
line_num, ptr);
ptr = pEnd;
*ret = G_ErrorUndefined;
}
else
{
char* pLeft = ptr;
char* pRight = section - 1;
/** trim left white-space */
while (isspace(*pLeft) && *pLeft) pLeft++;
/** trim right white-space */
while (isspace(*pRight) && pRight >= pLeft) pRight--;
*(pRight + 1) = '\0';
ini_section_t* isec = iniFileNewSection(pLeft);
if (isec)
{
GS32 result = iniFileAddSection(mif, isec);
if (G_OK == result)
{
ptr = section + 1; /** + 1 indicate skip character ']' */
}
else
{
free(isec); /** release resource */
LOGE("add secition(%s) to list failed(0x%08x)\n", pLeft, *ret);
ptr = pEnd;
*ret = result;
}
}
else
{
LOGE("create section(%s) failed\n", pLeft);
ptr = pEnd;
*ret = G_ErrorInsufficientResources;
}
}
}
else
{
LOGE("syntax error[line:%d]: section doesn't end with ']'\n", line_num);
ptr = pEnd;
*ret = G_ErrorUndefined;
}
return ptr;
}
static char* iniFileParseParameter(ini_section_t* section, char* line,
char* line_end,GU32 line_num, GS32* ret)
{
char* ptr = line;
char* pEnd = line_end;
char* key_end = strchr(ptr, '=');
if (key_end)
{
char* pRight = key_end - 1;
/** strip right white-space */
while (isspace(*pRight) && pRight >= ptr) pRight--;
GU32 key_len = (pRight + 1) - ptr;
char* key = ptr;
char* value = key_end + 1; /** + 1 indicate skip character '=' */
/** strip left white-space */
while (isspace(*value) && value < pEnd) value++;
if (value < pEnd)
{
/** find value end */
char* value_end = value;
/** strip ritght white-space and comment after the value of parameter */
while ((!isspace(*value_end) && (isCommentTag(*value_end) == GFALSE)) &&
(value_end < pEnd))
{
value_end++;
}
if (value_end > value)
{
GU32 value_len = value_end - value;
key_value_pair_t* pair = iniFileNewParameter(key, key_len, value, value_len);
if (pair)
{
iniFileAddParameter(section, pair);
ptr = value_end;
}
else
{
ptr = pEnd;
*ret = G_ErrorInsufficientResources;
}
}
else
{
LOGE("syntax error: the value of parameter is empty(right of \'=\')\n");
ptr = pEnd;
*ret = G_ErrorUndefined;
}
}
else
{
LOGE("syntax error[line:%d]: the value of parameter is empty(right of \'=\')\n", line_num);
ptr = pEnd;
*ret = G_ErrorUndefined;
}
}
else
{
LOGE("syntax error[line:%d]: not complete key, doesn't find end character \'=\' \n", line_num);
ptr = pEnd;
*ret = G_ErrorUndefined;
}
return ptr;
}
static GS32 iniFileParseLine(my_ini_file_t* mif, char* line, GU32 length, GU32 line_num)
{
char* ptr = line;
char* pEnd = line + length;
GS32 ret = G_OK;
while (ptr < pEnd)
{
while (isspace(*ptr)) ptr++; /** skip white-space */
char ch = *ptr;
if (isCommentTag(ch) == GTRUE)
{
/** skip component */
ptr = pEnd;
}
else if (ch == '[')
{
/** ++ indicate skip character '[' */
ptr = iniFileParseSection(mif, ++ptr, pEnd, line_num, &ret);
}
else if (ch == '\0') /** line end */
{
/**do nothing */
}
else
{
if (mif->section_count == 0)
{
/** alloc default section */
ini_section_t* isec = iniFileNewSection(DEFAULT_SECTION_NAME);
if (isec)
{
ret = iniFileAddSection(mif, isec);
if (G_OK != ret)
{
LOGE("add section to list failed(0x%08x)\n", ret);
free(isec);
break;
}
}
else
{
ret = G_ErrorInsufficientResources;
break;
}
}
/**
* current section aways is the newest section ?
* TODO, this case is aways right?
*/
ptr = iniFileParseParameter(iniFileGetNewestSection(mif),
ptr, pEnd, line_num, &ret);
}
}
return ret;
}
static GS32 iniFileParseFile(my_ini_file_t* mif, FILE* fp)
{
GS32 ret = G_OK;
GU32 line_num = 0;
char line_buf[LINE_BUF_MAX_LEN] = { 0 };
while (fgets(line_buf, LINE_BUF_MAX_LEN, fp))
{
line_num++;
ret = iniFileParseLine(mif, line_buf, strlen(line_buf), line_num);
if (G_OK != ret)
{
LOGE("parse line failed\n");
break;
}
}
return ret;
}
static GS32 iniFileLoad(tiny_ini_file_t* ini_file, const char* file_name)
{
GS32 ret = G_ErrorBadParameter;
my_ini_file_t* mif = (my_ini_file_t*)ini_file;
if (file_name)
{
if (ini_file->is_loaded == GFALSE)
{
FILE* fp = fopen(file_name, "r");
if (fp)
{
ret = iniFileParseFile(mif, fp);
if (G_OK == ret)
{
mif->fp = fp;
ini_file->is_loaded = GTRUE;
}
else
{
fclose(fp);
}
}
else
{
LOGE("open ini file(%s) failed(%d, %s)\n", file_name, errno, strerror(errno));
}
}
else
{
LOGE("already load one file, cann't load more\n");
ret = G_ErrorInvalidOperation;
}
}
return ret;
}
static GS32 iniFileGetValue(struct tiny_ini_file_s* ini_file, const char* section,
const char* key, char** value)
{
GS32 ret = G_ErrorBadParameter;
my_ini_file_t* mif = (my_ini_file_t*)ini_file;
if (section && key && value)
{
ini_section_t* isec = iniFileGetSection_l(mif, section);
if (isec)
{
if (isec->pairs)
{
char* retValue = NULL;
key_value_pair_t* param = isec->pairs;
while (param)
{
if (!strcmp(param->key, key))
{
retValue = param->value;
break;
}
param = (key_value_pair_t*)param->opaque;
}
if (retValue)
{
*value = retValue;
ret = G_OK;
}
else
{
LOGE("not find the parameter which key is(%s), in section(%s)\n",
key, section);
ret = G_ErrorNotFound;
}
}
else
{
LOGE("nothing in this section(%s)\n", section);
ret = G_ErrorUndefined;
}
}
else
{
LOGE("not find secontion(%s)\n", section);
ret = G_ErrorNotFound;
}
}
return ret;
}
static GS32 iniFileGetValues(struct tiny_ini_file_s* ini_file, const char* section,
const char* key, char** values[], GU32* count)
{
GS32 ret = G_ErrorBadParameter;
my_ini_file_t* mif = (my_ini_file_t*)ini_file;
if (section && key && values && count)
{
ini_section_t* isec = iniFileGetSection_l(mif, section);
if (isec)
{
if (isec->pairs)
{
GU32 getCount = 0;
GU32 arraySize = 0;
key_value_pair_t* param = isec->pairs;
char** valueArray = NULL;
while (param)
{
if (!strcmp(param->key, key))
{
if (getCount >= arraySize)
{
GU32 newSize = arraySize + 4;
GU32 elementSize = sizeof(char*);
char** newArray = (char**)realloc(valueArray, newSize * elementSize);
if (newArray)
{
arraySize = newSize;
valueArray = newArray;
}
else
{
LOGE("realloc value array failed(oldSize:%d, new:%d)\n",
arraySize* elementSize, newSize * elementSize);
ret = G_ErrorInsufficientResources;
getCount = 0;
break;
}
}
valueArray[getCount++] = param->value;
}
param = (key_value_pair_t*)param->opaque;
}
if (getCount)
{
*values = valueArray;
*count = getCount;
ret = G_OK;
}
else
{
LOGE("not find the parameter which key is(%s), in section(%s)\n",
key, section);
ret = G_ErrorNotFound;
}
}
else
{
LOGE("nothing in this section(%s)\n", section);
ret = G_ErrorUndefined;
}
}
else
{
LOGE("not find secontion(%s)\n", section);
ret = G_ErrorNotFound;
}
}
return ret;
}
static void iniFileFreeValues(struct tiny_ini_file_s* ini_file, char* values[], GU32 count)
{
free(values);
/** todo somethings */
}
static GS32 iniFileGetSection(struct tiny_ini_file_s* ini_file, const char* name, ini_section_t** section)
{
GS32 ret = G_ErrorBadParameter;
if (name && section)
{
*section = iniFileGetSection_l((my_ini_file_t*)ini_file, name);
ret = *section ? G_OK : G_ErrorNotFound;
}
return ret;
}
static GBOL iniFileHasKey(struct tiny_ini_file_s* ini_file, const char* section, const char* key)
{
GBOL ret = GFALSE;
if (key && section)
{
ini_section_t* isec = iniFileGetSection_l((my_ini_file_t*)ini_file, section);
if (isec)
{
key_value_pair_t* param = isec->pairs;
while (param)
{
if (!strcmp(param->key, key))
{
ret = GTRUE;
break;
}
param = (key_value_pair_t*)param->opaque;
}
}
else
{
LOGE("not find section(%s)\n", section);
}
}
return ret;
}
static GBOL iniFileHasSection(struct tiny_ini_file_s* ini_file, const char* section)
{
GBOL ret = GFALSE;
if (section)
{
ret = iniFileHasSection_l((my_ini_file_t*)ini_file, section);
}
return ret;
}
static void iniFileDump(struct tiny_ini_file_s* ini_file)
{
my_ini_file_t* mif = (my_ini_file_t*)ini_file;
ini_section_t* isec = mif->sections;
while (isec)
{
LOGI("\nsection: %s, item_count:%d\n", isec->name, isec->pair_count);
key_value_pair_t* param = isec->pairs;
while (param)
{
LOGI("%s = %s \n", param->key, param->value);
param = (key_value_pair_t*)param->opaque;
}
isec = (ini_section_t*)isec->opaque;
}
}
static void iniFileDestroy(struct tiny_ini_file_s* ini_file)
{
my_ini_file_t* mif = (my_ini_file_t*)ini_file;
ini_section_t* isec = mif->sections;
while (isec)
{
key_value_pair_t* param = isec->pairs;
while (param)
{
key_value_pair_t* temp = param;
param = (key_value_pair_t*)param->opaque;
free(temp); /** free a parameter */
}
ini_section_t* temp = isec;
isec = (ini_section_t*)isec->opaque;
free(temp); /** free a section */
}
if (mif->fp)
{
fclose(mif->fp);
}
free(mif); /** free ini file instance */
}
//////////////////////////////////////////////////////////////////////////
GS32 TinyIniFileCreate(tiny_ini_file_t** ini_file)
{
GS32 ret = G_OK;
my_ini_file_t* mif = (my_ini_file_t*)malloc(sizeof(my_ini_file_t));
if (mif)
{
memset(mif, 0, sizeof(my_ini_file_t));
tiny_ini_file_t* inf = (tiny_ini_file_t*)mif;
inf->load = iniFileLoad;
inf->getValue = iniFileGetValue;
inf->getValues = iniFileGetValues;
inf->freeValues = iniFileFreeValues;
inf->getSection = iniFileGetSection;
inf->hasKey = iniFileHasKey;
inf->hasSection = iniFileHasSection;
inf->dump = iniFileDump;
inf->destroy = iniFileDestroy;
inf->is_loaded = GFALSE;
*ini_file = inf;
}
else
{
LOGE("alloc ini file instance failed\n");
ret = G_ErrorInsufficientResources;
}
return ret;
}
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。