2. 程式人生 > >c語言實現讀取ini檔案操作

c語言實現讀取ini檔案操作

阿新 • • 發佈：2019-01-05

二、實現檔案

//ini.c

#include "ini.h"
#include <string.h>
#include <stdio.h>

content* pContent;
char gfilename[255];

void iniGetInt(const char* lpSection, const char* lpKey, unsigned int* nDefault)
{
 char sz[DEF_PROFILE_NUM_LEN + 1] = "";

 iniGetString(lpSection, lpKey, sz);
 sscanf(sz, "%d", nDefault);
}

BOOL iniWriteInt(const char* lpSection, const char* lpKey, unsigned int nValue,
 const char* lpComment)
{
 char szValue[DEF_PROFILE_NUM_LEN + 1] = "";

 sprintf(szValue, "%d", nValue);
 return iniWriteString(lpSection, lpKey, szValue, lpComment);
}

void iniGetBool(const char* lpSection, const char* lpKey, BOOL* bDefault)
{
 char sz[DEF_PROFILE_NUM_LEN + 1] = "";

 iniGetString(lpSection, lpKey, sz);
 sscanf(sz, "%d", bDefault);
 *bDefault > 0 ? 1 : 0;
}

BOOL iniWriteBool(const char* lpSection, const char* lpKey, BOOL bDefault, const char* lpComment)
{
 char szValue[DEF_PROFILE_NUM_LEN + 1] = "";

 sprintf(szValue, "%d", bDefault > 0 ? 1 : 0);
 return iniWriteString(lpSection, lpKey, szValue, lpComment);
}

DWORD iniInvertBool(const char* lpSection, const char* lpKey)
{
 BOOL bDefault;
 char szValue[DEF_PROFILE_NUM_LEN + 1] = "";
 struct _section* psection = iniGetSection(lpSection);
 struct _record* precord = iniGetRecord(psection, lpKey);

 iniGetBool(lpSection,lpKey,&bDefault);
 bDefault > 0 ? 1 : 0;
 sprintf(szValue, "%d", !bDefault);   
 
 if (psection == NULL)
 {
  return ERROR_NO_SECTION;
 } 
  
 if (precord == NULL)
 {
  return ERROR_NO_KEY;
 }

 strcpy(precord->key, lpKey);
 {
  strcpy(precord->value, szValue);
 }
 return ERROR_OK;
}

DWORD iniGetString(const char* lpSection, const char* lpKey, char* lpBuffer)
{
 struct _section* psection = iniGetSection(lpSection);
    struct _record* precord = iniGetRecord(psection, lpKey); 
 if (psection == NULL)
 {
  return ERROR_NO_SECTION;
 }
 
 if (precord == NULL)
 {
  return ERROR_NO_KEY;
 }
 else
 {
  strcpy(lpBuffer, precord->value);
  return ERROR_OK;
 }
}

BOOL iniWriteString(const char* lpSection, const char* lpKey, const char* lpValue,
 const char* lpComment)
{
 struct _section* psection = iniGetSection(lpSection);
    struct _record* precord = iniGetRecord(psection, lpKey);
 if (psection == NULL)
 {
  iniAddSection(lpSection, "");
  psection = iniGetSection(lpSection);
 }
  
 if (precord == NULL)
 {
  precord = (struct _record *) malloc(sizeof(struct _record));
  if (precord == NULL)
  {
   printf("cannot malloc memory !\n");
   return ERROR;
  }
  precord->next = NULL;  

  psection->sizeRecord++;

  if (psection->first == NULL)
  {
   psection->first = precord;
   psection->last = precord;
  }
  else
  {
   psection->last->next = precord;
   psection->last = precord;
  }
 }
 if ((lpComment[0] != '#' || lpComment[0] != ';') && (strlen(lpComment) > 0))
 {
  sprintf(precord->comments, "#%s", lpComment);
 }
 else
 {
  strcpy(precord->comments, lpComment);
 }
 strcpy(precord->key, lpKey);
 {
  strcpy(precord->value, lpValue);
 }
 return ERROR_OK;
}

bool iniStart(const char* lpFile)
{
 pContent = (content *) malloc(sizeof(content));
 if (pContent == NULL)
 {
  printf("cannot malloc memory !\n");
  return false;
 }

 pContent->sizeSection = 0; 
 pContent->first = NULL;
 pContent->last = NULL;

 memcpy(gfilename, lpFile, sizeof(gfilename));
 if (iniLoad(gfilename) == false)
 {
  printf("initial parse file error !\n");
  return false;
 };
 return true;
}

bool iniLoad(const char* lpFile)
{
 FILE* fp;
 char buffer[255];
 char comments[1024];
 char NowSection[255];  
 char key[255];
 char value[255];
 char* pdest;
 int index;

 strcpy(comments, "");
 strcpy(NowSection, "");

 if ((fp = fopen(lpFile, "r")) != NULL)
 {
  while (fgets(buffer, sizeof(buffer), fp) != NULL)
  {
   if (buffer[strlen(buffer) - 1] == '\n')
   {
    buffer[strlen(buffer) - 1] = '\0';
   }
   switch (buffer[0])
   {
   case '[':
    pdest = strrchr(buffer, ']');
    if (pdest == NULL)
    {
     fclose(fp);
     printf("parse ini error!\n");
     return false;
    }
    index = pdest - buffer;
    memcpy(NowSection, buffer + 1, index - 1);
    NowSection[index - 1] = '\0';
    iniAddSection(NowSection, comments); 
    strcpy(comments, "");
    break;
   case '#' :
   case ';' :
    if (strlen(comments) > 0)
    {
     strcat(comments, "\n");
    }
    strcat(comments, buffer);
    break;
   default :
    pdest = strrchr(buffer, '=');
    if (pdest == NULL)
    {
     fclose(fp);
     printf("parse ini error\n");
     return false;
    }
    index = pdest - buffer;
    memcpy(key, buffer, index);
    key[index] = '\0';
    memcpy(value, buffer + index + 1, strlen(buffer) - index);

    if (strcmp(NowSection, "") == 0)
    {
     fclose(fp);
     printf("parse ini error\n");
     return false;
    }
    else
    {
     iniWriteString(NowSection, key, value, comments);
     strcpy(comments, "");
    }
    break;
   }
  }
  fclose(fp);
 }
 else
 {
  printf("open file error !\n");
  return false;
 }
 return true;
}

void iniAddSection(const char* lpSection, const char* lpComment)
{
 struct _section* psection;
 psection = iniGetSection(lpSection);

 if (psection == NULL)
 {
  psection = (struct _section *) malloc(sizeof(struct _section));

  if (psection == NULL)
  {
   printf("cannot malloc memory !\n");
   return;
  }

  strcpy(psection->name, lpSection);

  if ((lpComment[0] != '#' || lpComment[0] != ';') && (strlen(lpComment) > 0))
  {
   sprintf(psection->comments, "#%s", lpComment);
  }
  else
  {
   strcpy(psection->comments, lpComment);
  }

  psection->first = NULL;
  psection->last = NULL;
  psection->next = NULL;
  psection->sizeRecord = 0;

  pContent->sizeSection++;

  if (pContent->first == NULL)
  {
   pContent->first = psection;
   pContent->last = psection;
  }
  else
  {
   pContent->last->next = psection;
   pContent->last = psection;
  }
 }
 else
 {
  strcpy(psection->name, lpSection);
  if ((lpComment[0] != '#' || lpComment[0] != ';') && (strlen(lpComment) > 0))
  {
   sprintf(psection->comments, "#%s", lpComment);
  }
  else
  {
   strcpy(psection->comments, lpComment);
  }
 }
}

struct _section* iniGetSection(const char* lpSection)
{
 bool found = false;

 struct _section* psection = pContent->first;
 while (psection != NULL)
 {
  if (strcmp(psection->name, lpSection) == 0)
  {
   found = true;
   break;
  }    
  psection = psection->next;
 }

 if (found == true)
 {
  return psection;
 }
 else
 {
  return NULL;
 }
}

struct _record* iniGetRecord(struct _section* psection, const char* lpKey)
{
 bool found = false;
 struct _record* pRecord;

 if (psection != NULL)
 {
  pRecord = psection->first;

  while (pRecord != NULL)
  {
   if (strcmp(lpKey, pRecord->key) == 0)
   {
    found = true;
    break;
   }
   pRecord = pRecord->next;
  }
  if (found == true)
  {
   return pRecord;
  }
  else
  {
   return NULL;
  }
 }
 else
 {
  return NULL;
 }
}

char* iniGetValue(const char* lpSeciton, const char* lpKey)
{
 struct _section* psection = iniGetSection(lpSeciton);
    struct _record* precord = iniGetRecord(psection, lpKey);
 if (psection == NULL)
 {
  return "NO Section!";
 }
  
 if (precord == NULL)
 {
  return "No Key!";
 }
 else
 {
  return precord->value;
 }
}

bool iniSave(const char* lpFile)
{
 FILE* fp;
 struct _section* psection = pContent->first;
 struct _record* precord; 


 if ((fp = fopen(lpFile, "w")) == NULL)
 {
  printf("open file error\n");
  return false;
 }

 while (psection != NULL)
 {
  if (strlen(psection->comments) != 0)
  {
   fprintf(fp, "%s\n", psection->comments);
  }
  fprintf(fp, "[%s]\n", psection->name);
  precord = psection->first;
  while (precord != NULL)
  {
   if (strlen(precord->comments) != 0)
   {
    fprintf(fp, "%s\n", precord->comments);
   }
   fprintf(fp, "%s=%s\n", precord->key, precord->value);

   precord = precord->next;
  }  
  psection = psection->next;
 } 
 fclose(fp);
 return true;
}

int iniRemoveAllSection(const char* lpSection)
{
 struct _section* psection = iniGetSection(lpSection);
 struct _record* precord;
 int remove = 0;

 if (psection == NULL)
  return 0;

 precord = psection->first;
 while (precord != NULL)
 {
  psection->first = precord->next;
  psection->sizeRecord--;
  free(precord);
  remove++;
  precord = psection->first;
 }
 return remove;
}

int iniRemoveSelSection(const char* lpSection, const char* lpKey)
{
 struct _section* psection = iniGetSection(lpSection);
 struct _record* precord1, * precord2;
 int remove = 0;

 if (psection == NULL)
  return 0;

 precord1 = psection->first;

 if (precord1 == NULL)
  return 0;

 if (strcmp(lpKey, precord1->key) == 0)
 {
  psection->first = precord1->next;
  psection->sizeRecord--;
  free(precord1);
  return 1;
 }

 while (precord1 != NULL)
 {
  if (precord1->next != NULL)
  {
   if (strcmp(lpKey, precord1->next->key) == 0)
   {
    precord2 = precord1->next;    
    precord1->next = precord1->next->next;
    psection->sizeRecord--;
    free(precord2);    
    remove = 1;
    break;
   }
  }  
  precord1 = precord1->next;
 }  
 return remove;
}

相關推薦

c語言實現讀取ini檔案操作

二、實現檔案 //ini.c #include "ini.h" #include <string.h> #include <stdio.h> content* pContent; char gfilename[255]; void iniGetInt(const char* lpSe

C語言 實現讀取檔案，並統計每個字元出現的個數

/***************** 實現讀取檔案，並統計每個字元出現的個數 *****************/ #include <stdio.h> #include <stdlib.h> unsigned long file_size;

c語言實現系統(Linux)檔案許可權的修改，以及系統檔案的建立，寫入和讀取資料

我們都清楚，在Linux要想修改某個檔案的許可權，可以執行chmod命令，（4.為讀許可權，2.為寫許可權，1.為執行許可權）其實我們可以通過編寫C程式來實現這一命令,具體 chmod實現程式如下： #include<stdio.h> #in

C語言實現線性表基本操作

style eal struct fine fin delete class logs destroy #include <stdio.h> #include <tchar.h> #include <stdlib.h> #define

2972: C語言習題5.24--檔案操作1

文字檔案score.dic 中儲存了n名學生的資訊（班級編號,姓名,成績），每個學生資訊佔一行，每行的資料之間使用製表符分割，如下所示： 145811  fuxin 100 145811  chengxian 90 145812  zhangxue 92 145812  lijun 88 ……

C#類庫：ini檔案操作類

C#類庫 ——ini檔案操作類 1.類庫介紹     在開發應用軟體時，ini檔案常用於軟體的相關配置，以下為ini檔案的相關結構及示例；ini檔案具有節（section）和鍵（key）兩個層級，節用”[]”包含，然後下一行為對應鍵名以及鍵值，

嚴蔚敏資料結構C語言實現棧的基本操作

int main(){   SqStack S;   SElemType *e;   int n,i;   InitStack(&S);   printf("請輸入需要入棧的資料個數\n");   scanf("%d",&n);   for(i=0;i<n;i++)   {    sca

C語言中常用的檔案操作函式

C函式庫中檔案操作函式： (1)fopen：開啟檔案 函式原型:FILE* fopen(char *path, char *mode); 函式引數:path----開啟檔名及其路徑      mode----r w a …… 函式返回:成功則返回指向該流的檔案指標，失敗則返回NULL並把錯誤存在errno中

C語言實現計算一個檔案中的單詞個數

void count_world() { int nl, nc, nw, state, c; nl = nc = nw = 0; FILE *fp; state = OUT; fp = fopen("./a.txt","r"); while((c = fget

c語言實現圖的基本操作--鄰接矩陣儲存

利用鄰接矩陣容易判定任意兩個頂點之間是否有邊（或弧）相連，並容易求得各個頂點的度。 c語言程式碼實現如下： #include<stdio.h> #include<stdlib.h> #define MAX_VER_NUM 50 typedef cha

C語言實現複製一個檔案內容到另一個檔案裡

首先你的建立兩個txt檔案或者其他檔案也行，然後在第一個檔案中寫一些內容  第二個檔案中不用寫我的兩個檔案是test1.txt   test2.txt     執行程式後test1.txt的內容被複制到

c語言實現windows下檔案遍歷

參考網上的程式碼，寫的註釋比較完整的程式碼。 例程如下，在article目錄下，有若干檔案和目錄。 #include <stdio.h> #include <windows.h> void loopThrough(char* p

C語言基礎之常用檔案操作2（附程式碼）

這裡在上一章的基礎上再介紹幾個常用的檔案操作的函式，包括fprintf、fscanf、ftell、fseek等。 檔案操作函式介紹 1、fprintf 函式 函式原型： int fpringf(FILE* stream,const char *forma

linux平臺下基於C語言實現遍歷檔案目錄

#include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <string.h&g

資料結構之---c語言實現迴圈單鏈表操作

wechat:812716131 ------------------------------------------------------ 技術交流群請聯絡上面wechat ----------------------------------------------

PCM WAVE格式詳解及用C語言實現wave檔案的讀取

1.PCM Wave格式詳解 WAVE檔案格式是微軟RIFF(Resource Interchange File Format,資源交換檔案標準)的一種，是針對於多媒體檔案儲存的一種檔案格式和標準。 一般而言，RIFF檔案由檔案頭和資料兩部分組成，一個WAVE檔案由一個“WAVE”資料塊組成，這個“WAV

在STM32上實現NTFS之5：GPT分區表的C語言實現（2）GPT實現以及統一方式讀取磁盤分區

tfs 下載 數據 特殊 dpt 屬性列表 handle 系統分區 成了 　　上一節實現了主GPT頭的信息提取，這一節繼續提取整個的GPT數據，並且將GPT分區表和MBR分區表兩種格式融合成一個模塊，使主調函數（也可以說是使用者）不需要關心磁盤的分區表類型：它太底層了，確實

C語言實現棧和佇列(棧和佇列的基本操作)

棧： 棧：棧（stack）又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。 特點：先進後出 stack.h #pragma once #include <stdio.h> #include <

操作系統，時間片輪轉算法的C語言實現Round Robin

cst 輪轉 初始 finish ont 建立 c語言 %d stat 1 #include "windows.h" 2 #include <conio.h> 3 #include <stdlib.h> 4 #include <

Go語言基礎（十五）—— Go語言實現json資料檔案讀取與儲存

案例： package main import ( "os" "fmt" "encoding/json" "time" ) type Person2 struct { Name string Age int Sex string Hobby []string } fun