跨平台INI文件读写API(C版本)

3228阅读　0评论2011-10-13　Liuqz2009
分类：C/C++

1、inifile.c 的内容：
 
  1. /**
  2.  * @file
  3.  * @brief initialization file read and write API implementation
  4.  * @author Deng Yangjun
  5.  * @date 2007-1-9
  6.  * @version 0.1
  7.  */
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <assert.h>
  11. #include <string.h>
  12. #include <ctype.h>

  14. #include "inifile.h"

  16. #ifdef __cplusplus
  17. extern "C"
  18. {
  19. #endif

  21. #define MAX_FILE_SIZE 1024*16
  22. #define LEFT_BRACE '['
  23. #define RIGHT_BRACE ']'

  25. static int load_ini_file(const char *file, char *buf,int *file_size)
  26. {
  27.     FILE *in = NULL;
  28.     int i=0;
  29.     *file_size =0;

  31.     assert(file !=NULL);
  32.     assert(buf !=NULL);

  34.     in = fopen(file,"r");
  35.     if( NULL == in) {
  36.         return 0;
  37.     }

  39.     buf[i]=fgetc(in);
  40.     
  41.     //load initialization file
  42.     while( buf[i]!= (char)EOF) {
  43.         i++;
  44.         assert( i < MAX_FILE_SIZE); //file too big
  45.         buf[i]=fgetc(in);
  46.     }
  47.     
  48.     buf[i]='\0';
  49.     *file_size = i;

  51.     fclose(in);
  52.     return 1;
  53. }

  55. static int isnewline(char c)
  56. {
  57.     return ('\n' == c || '\r' == c )? 1 : 0;
  58. }
  59. static int isend(char c)
  60. {
  61.     return '\0'==c? 1 : 0;
  62. }
  63. static int isleftbarce(char c)
  64. {
  65.     return LEFT_BRACE == c? 1 : 0;
  66. }
  67. static int isrightbrace(char c )
  68. {
  69.     return RIGHT_BRACE == c? 1 : 0;
  70. }
  71. static int parse_file(const char *section, const char *key, const char *buf,int *sec_s,int *sec_e,
  72.                      int *key_s,int *key_e, int *value_s, int *value_e)
  73. {
  74.     const char *p = buf;
  75.     int i=0;

  77.     assert(buf!=NULL);
  78.     assert(section != NULL && strlen(section));
  79.     assert(key != NULL && strlen(key));

  81.     *sec_e = *sec_s = *key_e = *key_s = *value_s = *value_e = -1;

  83.     while( !isend(p[i]) ) {
  84.         //find the section
  85.         if( ( 0==i || isnewline(p[i-1]) ) && isleftbarce(p[i]) )
  86.         {
  87.             int section_start=i+1;

  89.             //find the ']'
  90.             do {
  91.                 i++;
  92.             } while( !isrightbrace(p[i]) && !isend(p[i]));

  94.             if( 0 == strncmp(p+section_start,section, i-section_start)) {
  95.                 int newline_start=0;

  97.                 i++;

  99.                 //Skip over space char after ']'
  100.                 while(isspace(p[i])) {
  101.                     i++;
  102.                 }

  104.                 //find the section
  105.                 *sec_s = section_start;
  106.                 *sec_e = i;

  108.                 while( ! (isnewline(p[i-1]) && isleftbarce(p[i]))
  109.                 && !isend(p[i]) ) {
  110.                     int j=0;
  111.                     //get a new line
  112.                     newline_start = i;

  114.                     while( !isnewline(p[i]) && !isend(p[i]) ) {
  115.                         i++;
  116.                     }
  117.                     
  118.                     //now i is equal to end of the line
  119.                     j = newline_start;

  121.                     if(';' != p[j]) //skip over comment
  122.                     {
  123.                         while(j < i && p[j]!='=') {
  124.                             j++;
  125.                             if('=' == p[j]) {
  126.                                 if(strncmp(key,p+newline_start,j-newline_start)==0)
  127.                                 {
  128.                                     //find the key ok
  129.                                     *key_s = newline_start;
  130.                                     *key_e = j-1;

  132.                                     *value_s = j+1;
  133.                                     *value_e = i;

  135.                                     return 1;
  136.                                 }
  137.                             }
  138.                         }
  139.                     }

  141.                     i++;
  142.                 }
  143.             }
  144.         }
  145.         else
  146.         {
  147.             i++;
  148.         }
  149.     }
  150.     return 0;
  151. }

  153. /**
  154. *@brief read string in initialization file\n
  155. * retrieves a string from the specified section in an initialization file
  156. *@param section [in] name of the section containing the key name
  157. *@param key [in] name of the key pairs to value
  158. *@param value [in] pointer to the buffer that receives the retrieved string
  159. *@param size [in] size of value buffer
  160. *@param default_value [in] defualt value of result
  161. *@param file [in] path of the initialization file
  162. *@return 1 : read success; \n 0 : read fail
  163. */
  164. int read_profile_string( const char *section, const char *key,char *value,
  165.          int size, const char *default_value, const char *file)
  166. {
  167.     char buf[MAX_FILE_SIZE]={0};
  168.     int file_size;
  169.     int sec_s,sec_e,key_s,key_e, value_s, value_e;

  171.     //check parameters
  172.     assert(section != NULL && strlen(section));
  173.     assert(key != NULL && strlen(key));
  174.     assert(value != NULL);
  175.     assert(size > 0);
  176.     assert(file !=NULL &&strlen(key));

  178.     if(!load_ini_file(file,buf,&file_size))
  179.     {
  180.         if(default_value!=NULL)
  181.         {
  182.             strncpy(value,default_value, size);
  183.         }
  184.         return 0;
  185.     }

  187.     if(!parse_file(section,key,buf,&sec_s,&sec_e,&key_s,&key_e,&value_s,&value_e))
  188.     {
  189.         if(default_value!=NULL)
  190.         {
  191.             strncpy(value,default_value, size);
  192.         }
  193.         return 0; //not find the key
  194.     }
  195.     else
  196.     {
  197.         int cpcount = value_e -value_s;

  199.         if( size-1 < cpcount)
  200.         {
  201.             cpcount = size-1;
  202.         }
  203.     
  204.         memset(value, 0, size);
  205.         memcpy(value,buf+value_s, cpcount );
  206.         value[cpcount] = '\0';

  208.         return 1;
  209.     }
  210. }

  212. /**
  213. *@brief int value in initialization file\n
  214. * retrieves int value from the specified section in an initialization file
  215. *@param section [in] name of the section containing the key name
  216. *@param key [in] name of the key pairs to value
  217. *@param default_value [in] defualt value of result
  218. *@param file [in] path of the initialization file
  219. *@return profile int value,if read fail, return default value
  220. */
  221. int read_profile_int( const char *section, const char *key,int default_value,
  222.                 const char *file)
  223. {
  224.     char value[32] = {0};
  225.     if(!read_profile_string(section,key,value, sizeof(value),NULL,file))
  226.     {
  227.         return default_value;
  228.     }
  229.     else
  230.     {
  231.         return atoi(value);
  232.     }
  233. }

  235. /**
  236.  * @brief write a profile string to a ini file
  237.  * @param section [in] name of the section,can't be NULL and empty string
  238.  * @param key [in] name of the key pairs to value, can't be NULL and empty string
  239.  * @param value [in] profile string value
  240.  * @param file [in] path of ini file
  241.  * @return 1 : success\n 0 : failure
  242.  */
  243. int write_profile_string(const char *section, const char *key,
  244.                     const char *value, const char *file)
  245. {
  246.     char buf[MAX_FILE_SIZE]={0};
  247.     char w_buf[MAX_FILE_SIZE]={0};
  248.     int sec_s,sec_e,key_s,key_e, value_s, value_e;
  249.     int value_len = (int)strlen(value);
  250.     int file_size;
  251.     FILE *out;

  253.     //check parameters
  254.     assert(section != NULL && strlen(section));
  255.     assert(key != NULL && strlen(key));
  256.     assert(value != NULL);
  257.     assert(file !=NULL &&strlen(key));

  259.     if(!load_ini_file(file,buf,&file_size))
  260.     {
  261.         sec_s = -1;
  262.     }
  263.     else
  264.     {
  265.         parse_file(section,key,buf,&sec_s,&sec_e,&key_s,&key_e,&value_s,&value_e);
  266.     }

  268.     if( -1 == sec_s)
  269.     {
  270.         
  271.         if(0==file_size)
  272.         {
  273.             sprintf(w_buf+file_size,"[%s]\n%s=%s\n",section,key,value);
  274.         }
  275.         else
  276.         {
  277.             //not find the section, then add the new section at end of the file
  278.             memcpy(w_buf,buf,file_size);
  279.             sprintf(w_buf+file_size,"\n[%s]\n%s=%s\n",section,key,value);
  280.         }
  281.     }
  282.     else if(-1 == key_s)
  283.     {
  284.         //not find the key, then add the new key & value at end of the section
  285.         memcpy(w_buf,buf,sec_e);
  286.         sprintf(w_buf+sec_e,"%s=%s\n",key,value);
  287.         sprintf(w_buf+sec_e+strlen(key)+strlen(value)+2,buf+sec_e, file_size - sec_e);
  288.     }
  289.     else
  290.     {
  291.         //update value with new value
  292.         memcpy(w_buf,buf,value_s);
  293.         memcpy(w_buf+value_s,value, value_len);
  294.         memcpy(w_buf+value_s+value_len, buf+value_e, file_size - value_e);
  295.     }
  296.     
  297.     out = fopen(file,"w");
  298.     if(NULL == out)
  299.     {
  300.         return 0;
  301.     }
  302.     
  303.     if(-1 == fputs(w_buf,out) )
  304.     {
  305.         fclose(out);
  306.         return 0;
  307.     }

  309.     fclose(out);
  310.     return 1;
  311. }


  314. #ifdef __cplusplus
  315. }; //end of extern "C" {
  316. #endif
2、inifile.h的内容：
 
  1. /**
  2.  * @file
  3.  * @brief initialization file read and write API
  4.  * @author Deng Yangjun
  5.  * @date 2007-1-9
  6.  * @version 0.1
  7.  */

  9. #ifndef INI_FILE_H_
  10. #define INI_FILE_H_

  12. #ifdef __cplusplus
  13. extern "C"
  14. {
  15. #endif

  17. int read_profile_string( const char *section, const char *key,char *value, int size,const char *default_value, const char *file);
  18. int read_profile_int( const char *section, const char *key,int default_value, const char *file);
  19. int write_profile_string( const char *section, const char *key,const char *value, const char *file);

  21. #ifdef __cplusplus
  22. }; //end of extern "C" {
  23. #endif

  25. #endif //end of INI_FILE_H_
 
3、测试程序main.cpp
  1. #include <iostream>

  3. #include "inifile.h"

  5. using namespace std;

  7. int main(int argc, char **argv)
  8. {
  9.     char section[256];
  10.     char key[256];
  11.     char file[256];
  12.     char value[256];
  13.     char *default_value = "mm";
  14.     char *qstr = "quit";

  16.     memset(section, 0, sizeof(value));
  17.     memset(key, 0, sizeof(key));
  18.     memset(file, 0, sizeof(file));
  19.     memset(value, 0, sizeof(value));

  21.     while(true)
  22.     {
  23.         cout << "Please input the follow section:\n";
  24.         cout << "\t【section】 【key】 【file】"
  25.             << endl;

  27.         cin >> section;
  28.         if((strncmp(qstr, section, sizeof(qstr)) == 0))
  29.         {
  30.             return 0;
  31.         }
  32.         cin    >> key >> file;

  34.         cout << "The section is " << section << endl;
  35.         cout << "The key is " << key << endl;
  36.         cout << "The file is " << file << endl;

  38.         read_profile_string(section, key, value, sizeof(value), default_value, file);
  39.         cout << "The value of【section】: " << section << "【key】: " << key << " is" << endl;
  40.         cout << "\t" << value << endl;
  41.         cout << endl;
  42.     }    
  43.     return 0;
  44. }
 
转自：http://www.cppblog.com/dyj057/archive/2007/12/07/37958.html
上一篇：Mysql开启远程连接方法
下一篇：stardict安装与词典