SHARE
TWEET

[INC] SII 2.0.6 - Fast cache based INI Reader/Writer

Chip7 Sep 19th, 2012 586 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*VISITE NOSSO SITE: http://www.sampknd.com/
  2.   VISITE NOSSO FACEBOOK: http://www.facebook.com/SampKnd
  3.   SAMP KND MELHOR BLOG DE SAMP DO BRASIL
  4. */  
  5.  
  6. //======================================================
  7. // Slick's INI Include 2.0.7
  8. //
  9. // (c) Copyright 2008-2010, [DRuG]Slick
  10. // This file is provided as is (no warranties).
  11. //======================================================
  12.  
  13.  
  14. #pragma dynamic 45000 // Change accordingly!!
  15.  
  16. #if defined MAX_STRING
  17.         #define INI_MAX_VALUE MAX_STRING
  18. #else
  19.         #define INI_MAX_VALUE 128
  20. #endif
  21. #define INI_MAX_KEY 24
  22. #define INI_MAX_LINE (INI_MAX_KEY + INI_MAX_VALUE + 3)
  23. #define INI_MAX_FILENAME 256
  24. #define INI_MAX_LINES 256
  25.  
  26.  
  27. enum E_CACHE
  28. {
  29.         E_KEY[INI_MAX_KEY],
  30.         E_VALUE[INI_MAX_VALUE]
  31. }
  32.  
  33. enum E_FILE
  34. {
  35.         E_FILENAME[INI_MAX_FILENAME],
  36.         bool: E_OPEN
  37. }
  38.  
  39. static gCache[INI_MAX_LINES][E_CACHE];
  40. static gEmptyCache[E_CACHE];
  41. static gFile[E_FILE];
  42. static gNoFile[E_FILE];
  43.  
  44.  
  45. #define INI_Exist fexist
  46.  
  47.  
  48. stock INI_Open(const filename[])
  49. {
  50.         if (!filename[0]) return false;
  51.         if (gFile[E_OPEN])
  52.         {
  53.                 if (!strcmp(gFile[E_FILENAME], filename, true)) return true;
  54.                 //return false;
  55.                 INI_Close();
  56.         }
  57.         new File: h;
  58.         h = fopen(filename, io_readwrite);
  59.         if (h)
  60.         {
  61.                 INI_strcpy(gFile[E_FILENAME], filename, INI_MAX_FILENAME, INI_MAX_FILENAME);
  62.                 new line[INI_MAX_LINE];
  63.                 new ln = -1;
  64.                 new separator;
  65.                 while (((ln + 1) < INI_MAX_LINES) && (fread(h, line)))
  66.                 {
  67.                         ln ++;
  68.                         INI_StripLine(line);
  69.                         separator = strfind(line, "=", false);
  70.                         if ((line[0] == ';') || (line[0] == '=') || (separator == -1) || (separator > INI_MAX_KEY))
  71.                         {
  72.                                 if (line[0] == ';')
  73.                                 {
  74.                                         INI_strcpy(gCache[ln][E_VALUE], line, INI_MAX_VALUE, INI_MAX_VALUE);
  75.                                 }
  76.                                 else
  77.                                 {
  78.                                         INI_strcpy(gCache[ln][E_VALUE][1], line, INI_MAX_VALUE - 1, INI_MAX_VALUE - 1);
  79.                                         gCache[ln][E_VALUE][0] = ';';
  80.                                 }
  81.                                 continue;
  82.                         }
  83.                         INI_strcpy(gCache[ln][E_KEY], line, separator, INI_MAX_KEY);
  84.                         INI_strcpy(gCache[ln][E_VALUE], line[separator + 1], INI_MAX_VALUE, INI_MAX_VALUE);
  85.                         if (!gCache[ln][E_VALUE][0]) gCache[ln][E_VALUE][0] = ' ';
  86.                 }
  87.                 fclose(h);
  88.                 gFile[E_OPEN] = true;
  89.                 return 1;
  90.         }
  91.         return 0;
  92. }
  93.  
  94.  
  95. stock INI_Save()
  96. {
  97.         if (!gFile[E_OPEN]) return false;
  98.         new File: h;
  99.         h = fopen(gFile[E_FILENAME], io_write);
  100.         if (h)
  101.         {
  102.                 new line[INI_MAX_LINE];
  103.                 new ln = -1;
  104.                 while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  105.                 {
  106.                         ln ++;
  107.                         if (gCache[ln][E_VALUE][0] == ';')
  108.                         {
  109.                                 if (gCache[ln][E_VALUE][1])
  110.                                 {
  111.                                         format(line, sizeof(line), "%s\r\n", gCache[ln][E_VALUE]);
  112.                                         fwrite(h, line);
  113.                                         continue;
  114.                                 }
  115.                                 fwrite(h, "\r\n");
  116.                                 continue;
  117.                         }
  118.                         format(line, sizeof(line), "%s=%s\r\n", gCache[ln][E_KEY], gCache[ln][E_VALUE]);
  119.                         fwrite(h, line);
  120.                 }
  121.                 fclose(h);
  122.                 return true;
  123.         }
  124.         return false;
  125. }
  126.  
  127.  
  128. stock INI_Close()
  129. {
  130.         if (!gFile[E_OPEN]) return false;
  131.         for (new ln; ln < INI_MAX_LINES; ln++) gCache[ln] = gEmptyCache;
  132.         gFile = gNoFile;
  133.         return true;
  134. }
  135.  
  136.  
  137. stock INI_ReadString(dest[], const key[], maxlength = sizeof(dest))
  138. {
  139.         if ((!gFile[E_OPEN]) || (!key[0])) return false;
  140.         new ln = -1;
  141.         while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  142.         {
  143.                 ln ++;
  144.                 if (gCache[ln][E_VALUE][0] == ';') continue;
  145.                 if (!strcmp(gCache[ln][E_KEY], key, false))
  146.                 {
  147.                         INI_strcpy(dest, gCache[ln][E_VALUE], INI_MAX_VALUE, maxlength);
  148.                         return true;
  149.                 }
  150.         }
  151.         return false;
  152. }
  153.  
  154.  
  155. stock INI_ReadInt(const key[])
  156. {
  157.         new dest[12];
  158.         if (INI_ReadString(dest, key)) return strval(dest);
  159.         return false;
  160. }
  161.  
  162.  
  163. stock Float: INI_ReadFloat(const key[])
  164. {
  165.         new dest[12];
  166.         if (INI_ReadString(dest, key)) return floatstr(dest);
  167.         return 0.0;
  168. }
  169.  
  170.  
  171. stock INI_WriteString(const key[], const value[])
  172. {
  173.         if ((!gFile[E_OPEN]) || (!key[0]) || (key[0] == ';') || (strfind(key, "=", false) != -1)) return false;
  174.         new ln = -1;
  175.         while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  176.         {
  177.                 ln ++;
  178.                 if (gCache[ln][E_VALUE][0] == ';') continue;
  179.                 if (!strcmp(gCache[ln][E_KEY], key, false))
  180.                 {
  181.                         INI_strcpy(gCache[ln][E_VALUE], value, INI_MAX_VALUE, INI_MAX_VALUE);
  182.                         return true;
  183.                 }
  184.         }
  185.         ln ++;
  186.         if (ln < INI_MAX_LINES)
  187.         {
  188.                 INI_strcpy(gCache[ln][E_KEY], key, INI_MAX_KEY, INI_MAX_KEY);
  189.                 INI_strcpy(gCache[ln][E_VALUE], value, INI_MAX_VALUE, INI_MAX_VALUE);
  190.                 return true;
  191.         }
  192.         return false;
  193. }
  194.  
  195.  
  196. stock INI_WriteInt(const key[], value)
  197. {
  198.         new dest[12];
  199.         format(dest, sizeof(dest), "%i", value);
  200.         return INI_WriteString(key, dest);
  201. }
  202.  
  203.  
  204. stock INI_WriteFloat(const key[], Float: value)
  205. {
  206.         new dest[12];
  207.         format(dest, sizeof(dest), "%0.4f", value);
  208.         return INI_WriteString(key, dest);
  209. }
  210.  
  211.  
  212. stock INI_RemoveEntry(const key[])
  213. {
  214.         if ((!gFile[E_OPEN]) || (!key[0]) || (strfind(key, "=", false) != -1)) return false;
  215.         new ln = -1;
  216.         while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  217.         {
  218.                 ln ++;
  219.                 if (gCache[ln][E_VALUE][0] == ';') continue;
  220.                 if (!strcmp(gCache[ln][E_KEY], key, false))
  221.                 {
  222.                         for (; ln < (INI_MAX_LINES - 1); ln ++)
  223.                         {
  224.                                 INI_strcpy(gCache[ln][E_KEY], gCache[ln + 1][E_KEY], INI_MAX_KEY, INI_MAX_KEY);
  225.                                 INI_strcpy(gCache[ln][E_VALUE], gCache[ln + 1][E_VALUE], INI_MAX_VALUE, INI_MAX_VALUE);
  226.                         }
  227.                         return true;
  228.                 }
  229.         }
  230.         return false;
  231. }
  232.  
  233.  
  234. stock INI_Remove(const filename[])
  235. {
  236.         if (!filename[0]) return false;
  237.         if ((gFile[E_OPEN]) && (!strcmp(gFile[E_FILENAME], filename, true))) gFile = gNoFile;
  238.         return fremove(filename);
  239. }
  240.  
  241.  
  242. stock INI_strcpy(dest[], const source[], numcells = sizeof(source), maxlength = sizeof(dest))
  243. {
  244.         new i;
  245.         while ((source[i]) && (i < numcells) && (i < maxlength))
  246.         {
  247.                 dest[i] = source[i];
  248.                 i ++;
  249.         }
  250.         dest[(i == maxlength) ? (i - 1) : (i)] = '\0';
  251. }
  252.  
  253.  
  254. stock INI_StripLine(string[])
  255. {
  256.         new l;
  257.         l = strlen(string);
  258.         if (string[l - 2] == '\r') string[l - 2] = '\0';
  259.         if (string[l - 1] == '\n') string[l - 1] = '\0';
  260. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top