API tools faq
paste
Advertisement
Guest User

n_ini by Neufox

a guest
Nov 28th, 2014
374
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 26.24 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.     Include: n_ini
  3.     Brief: Simple, fast, easy INI-File manager. Generally used for saving stuff!
  4.     Update: v1 (29/11/14)
  5.     Creator: Neufox
  6.  
  7.     Credits:
  8.         * Thanks to Neufox        -   Creating this script
  9.         * Thanks to [DRuG]Slick   -   Base SII include
  10.         * Thanks to SAMP Team     -   You know why i stated this!
  11.    
  12.     Converts:
  13.         * DINI
  14.         * DUDB
  15.         * SFM(Southclaw's File Manager)
  16.         * FINI
  17.         * SII
  18.         * SF(Simple File)
  19.         * dFile
  20.     - If you want to have more conversions, then post down your suggestion in main topic page!
  21.    
  22.     NOTE: Checkout line (715 - 716) if you want to edit UDB Settings.
  23.           Line (60 - 65), some configurations!
  24.    
  25. */
  26. #include <a_samp>
  27.  
  28. /*
  29. native INI_Create(const filename[]);
  30. native INI_Remove(const filename[]);
  31. native INI_Open(const filename[]);
  32. native INI_Close();
  33. native INI_Save();
  34. native INI_Rename(const newname[]);
  35. native INI_Copy(const copyname[]);
  36. native INI_WriteString(const key[], const value[]);
  37. native INI_WriteInt(const key[], value);
  38. native INI_WriteFloat(const key[], Float: value);
  39. native INI_WriteBool(const key[], bool:value);
  40. native INI_ReadString(const key[]);
  41. native INI_ReadInt(const key[]);
  42. native Float:INI_ReadFloat(const key[]);
  43. native bool:INI_ReadBool(const key[]);
  44. native INI_MultiWrite(format[], {Float,_}:...);
  45. native INI_MultiRead(format[],{Float,_}:...);
  46. native INI_RemoveKey(const key[]);
  47. native INI_KeyExist(const key[]);
  48. native INI_ReturnFile();
  49. native INI_ReturnFilename();
  50. */
  51.  
  52. #pragma dynamic 45000 // Change accordingly!!
  53.  
  54. #if defined MAX_STRING
  55.     #define INI_MAX_VALUE MAX_STRING
  56. #else
  57.     #define INI_MAX_VALUE 256
  58. #endif
  59.  
  60. //Some configs
  61. #define INI_MAX_KEY         24//maximum number of keys/entries in a file
  62. #define INI_MAX_LINE        (INI_MAX_KEY + INI_MAX_VALUE + 3)
  63. #define INI_MAX_FILENAME    256//the max file name string can be!
  64. #define INI_MAX_LINES       256
  65. #define INI_AUTO_SAVE       true//true = Automatically saves and write cache to file on closing
  66. #define INI_CONVERT         true//true = Converts all other ini/file systems to n_ini automatically
  67. //
  68.  
  69. enum E_CACHE
  70. {
  71.     E_KEY[INI_MAX_KEY],
  72.     E_VALUE[INI_MAX_VALUE]
  73. }
  74.  
  75. enum E_FILE
  76. {
  77.     E_FILENAME[INI_MAX_FILENAME],
  78.     bool:E_OPEN
  79. }
  80.  
  81. static gCache[INI_MAX_LINES][E_CACHE];
  82. static gEmptyCache[E_CACHE];
  83. static gFile[E_FILE];
  84. static gNoFile[E_FILE];
  85.  
  86. #define INI_Exist fexist
  87.  
  88. stock INI_Create(const filename[], bool:open = false)
  89. {
  90.     if(!filename[0]) return false;
  91.     if(INI_Exist(filename)) return false;
  92.  
  93.     if(open == false)
  94.     {
  95.         new File: h;
  96.         h = fopen(filename, io_readwrite);
  97.         if(h)
  98.         {
  99.             fclose(h);
  100.             return true;
  101.         }
  102.     }
  103.     else INI_Open(filename);
  104.     return false;
  105. }
  106.  
  107. stock INI_Remove(const filename[])
  108. {
  109.     if (!filename[0]) return false;
  110.     if ((gFile[E_OPEN]) && (!strcmp(gFile[E_FILENAME], filename, true))) gFile = gNoFile;
  111.     return fremove(filename);
  112. }
  113.  
  114. stock INI_Open(const filename[])
  115. {
  116.     if (!filename[0]) return false;
  117.     if (gFile[E_OPEN])
  118.     {
  119.         if (!strcmp(gFile[E_FILENAME], filename, true)) return true;
  120.         INI_Close();
  121.     }
  122.     new File: h;
  123.     h = fopen(filename, io_readwrite);
  124.     if (h)
  125.     {
  126.         INI_strcpy(gFile[E_FILENAME], filename, INI_MAX_FILENAME, INI_MAX_FILENAME);
  127.         new line[INI_MAX_LINE];
  128.         new ln = -1;
  129.         new separator;
  130.         while (((ln + 1) < INI_MAX_LINES) && (fread(h, line)))
  131.         {
  132.             ln ++;
  133.             INI_StripLine(line);
  134.             separator = strfind(line, "=", false);
  135.             if ((line[0] == ';') || (line[0] == '=') || (separator == -1) || (separator > INI_MAX_KEY))
  136.             {
  137.                 if (line[0] == ';')
  138.                 {
  139.                     INI_strcpy(gCache[ln][E_VALUE], line, INI_MAX_VALUE, INI_MAX_VALUE);
  140.                 }
  141.                 else
  142.                 {
  143.                     INI_strcpy(gCache[ln][E_VALUE][1], line, INI_MAX_VALUE - 1, INI_MAX_VALUE - 1);
  144.                     gCache[ln][E_VALUE][0] = ';';
  145.                 }
  146.                 continue;
  147.             }
  148.             INI_strcpy(gCache[ln][E_KEY], line, separator, INI_MAX_KEY);
  149.             INI_strcpy(gCache[ln][E_VALUE], line[separator + 1], INI_MAX_VALUE, INI_MAX_VALUE);
  150.             if (!gCache[ln][E_VALUE][0]) gCache[ln][E_VALUE][0] = ' ';
  151.         }
  152.         fclose(h);
  153.         gFile[E_OPEN] = true;
  154.         return 1;
  155.     }
  156.     return 0;
  157. }
  158.  
  159. stock INI_Close()
  160. {
  161.     if (!gFile[E_OPEN]) return false;
  162.     #if(INI_AUTO_SAVE)
  163.         INI_Save();
  164.     #endif
  165.     for (new ln; ln < INI_MAX_LINES; ln++) gCache[ln] = gEmptyCache;
  166.     gFile = gNoFile;
  167.     return true;
  168. }
  169.  
  170. stock INI_Save()
  171. {
  172.     if (!gFile[E_OPEN]) return false;
  173.     new File: h;
  174.     h = fopen(gFile[E_FILENAME], io_write);
  175.     if (h)
  176.     {
  177.         new line[INI_MAX_LINE];
  178.         new ln = -1;
  179.         while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  180.         {
  181.             ln ++;
  182.             if (gCache[ln][E_VALUE][0] == ';')
  183.             {
  184.                 if (gCache[ln][E_VALUE][1])
  185.                 {
  186.                     format(line, sizeof(line), "%s\r\n", gCache[ln][E_VALUE]);
  187.                     fwrite(h, line);
  188.                     continue;
  189.                 }
  190.                 fwrite(h, "\r\n");
  191.                 continue;
  192.             }
  193.             format(line, sizeof(line), "%s=%s\r\n", gCache[ln][E_KEY], gCache[ln][E_VALUE]);
  194.             fwrite(h, line);
  195.         }
  196.         fclose(h);
  197.         return true;
  198.     }
  199.     return false;
  200. }
  201.  
  202. stock INI_Rename(const newname[])
  203. {
  204.     if (!gFile[E_OPEN]) return false;
  205.  
  206.     INI_Create(newname, false);
  207.  
  208.     new File: h, File: g, string[INI_MAX_VALUE];
  209.     h = fopen(gFile[E_FILENAME], io_read);
  210.     g = fopen(newname, io_write);
  211.  
  212.     if (!h) return false;
  213.     if (!g) return false;
  214.  
  215.     while(fread(h, string)) fwrite(g, string);
  216.     fclose(h);
  217.     fclose(g);
  218.     fremove(gFile[E_FILENAME);
  219.     return true;
  220. }
  221.  
  222. stock INI_Copy(const copyname[])
  223. {
  224.     if (!gFile[E_OPEN]) return false;
  225.  
  226.     INI_Create(copyname, false);
  227.  
  228.     new File: h, File: g, string[INI_MAX_VALUE];
  229.     h = fopen(gFile[E_FILENAME], io_read);
  230.     g = fopen(copyname, io_write);
  231.  
  232.     if (!h) return false;
  233.     if (!g) return false;
  234.  
  235.     while(fread(h, string)) fwrite(g, string);
  236.     fclose(h);
  237.     fclose(g);
  238.     return true;
  239. }
  240.  
  241. stock INI_WriteString(const key[], const value[])
  242. {
  243.     if ((!gFile[E_OPEN]) || (!key[0]) || (key[0] == ';') || (strfind(key, "=", false) != -1)) return false;
  244.     new ln = -1;
  245.     while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  246.     {
  247.         ln ++;
  248.         if (gCache[ln][E_VALUE][0] == ';') continue;
  249.         if (!strcmp(gCache[ln][E_KEY], key, false))
  250.         {
  251.             INI_strcpy(gCache[ln][E_VALUE], value, INI_MAX_VALUE, INI_MAX_VALUE);
  252.             return true;
  253.         }
  254.     }
  255.     ln ++;
  256.     if (ln < INI_MAX_LINES)
  257.     {
  258.         INI_strcpy(gCache[ln][E_KEY], key, INI_MAX_KEY, INI_MAX_KEY);
  259.         INI_strcpy(gCache[ln][E_VALUE], value, INI_MAX_VALUE, INI_MAX_VALUE);
  260.         return true;
  261.     }
  262.     return false;
  263. }
  264.  
  265. stock INI_WriteInt(const key[], value)
  266. {
  267.     new dest[12];
  268.     format(dest, sizeof(dest), "%i", value);
  269.     return INI_WriteString(key, dest);
  270. }
  271.  
  272. stock INI_WriteFloat(const key[], Float: value)
  273. {
  274.     new dest[12];
  275.     format(dest, sizeof(dest), "%0.4f", value);
  276.     return INI_WriteString(key, dest);
  277. }
  278.  
  279. stock INI_WriteBool(const key[], bool:value)
  280. {
  281.     new dest[12];
  282.     if(value)
  283.     {
  284.         format(dest, sizeof(dest), "1");
  285.     }
  286.     else format(dest, sizeof(dest), "0");
  287.     return INI_WriteString(key, dest);
  288. }
  289.  
  290. stock INI_ReadString(const key[])
  291. {
  292.     new dest[INI_MAX_VALUE];
  293.  
  294.     if ((!gFile[E_OPEN]) || (!key[0])) return dest;
  295.     new ln = -1;
  296.     while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  297.     {
  298.         ln ++;
  299.         if (gCache[ln][E_VALUE][0] == ';') continue;
  300.         if (!strcmp(gCache[ln][E_KEY], key, false))
  301.         {
  302.             INI_strcpy(dest, gCache[ln][E_VALUE], INI_MAX_VALUE, INI_MAX_VALUE);
  303.             return dest;
  304.         }
  305.     }
  306.     return dest;
  307. }
  308.  
  309. stock INI_ReadInt(const key[])
  310. {
  311.     return strval(INI_ReadString(key));
  312. }
  313.  
  314. stock Float:INI_ReadFloat(const key[])
  315. {
  316.     return floatstr(INI_ReadString(key));
  317. }
  318.  
  319. stock bool:INI_ReadBool(const key[])
  320. {
  321.     if(strval(INI_ReadString(key)))
  322.     {
  323.         return true;
  324.     }
  325.     else return false;
  326. }
  327.  
  328. stock INI_MultiWrite(format[], {Float,_}:...)
  329. {
  330.     new E_i = 0x-1;
  331.  
  332.     while(++E_i < strlen(format))
  333.     {
  334.         new E_l = 0x-1,
  335.             E_loop = -1,
  336.             E_string[INI_MAX_VALUE],
  337.             E_paramtar[0x80];
  338.  
  339.         while(++E_l < 0x80)
  340.         {
  341.             E_paramtar[E_l] = getarg(1 + (E_i * 2), E_l);
  342.         }
  343.         switch(format[E_i])
  344.         {
  345.             case 'b':       INI_WriteBool(E_paramtar, bool:getarg(2 + (E_i * 2)));
  346.             case 'd', 'i':  INI_WriteInt(E_paramtar, getarg(2 + (E_i * 2)));
  347.             case 'f':       INI_WriteFloat(E_paramtar, Float:(getarg(2 + (E_i * 2))));
  348.             case 's':
  349.             {
  350.                 while(++E_loop != 0x100)
  351.                 {
  352.                     E_string[E_loop] = getarg(2 + (E_i * 2), E_loop);
  353.                 }
  354.                 INI_WriteString(E_paramtar, E_string);
  355.             }
  356.         }
  357.     }
  358.     return true;
  359. }
  360.  
  361. stock INI_MultiRead(format[], {Float,_}:...)
  362. {
  363.     new E_i = 0x-1;
  364.  
  365.     while(++E_i < strlen(format))
  366.     {
  367.         new E_l = 0x-1,
  368.             E_loop = 0x-1,
  369.             E_parameter[0x80],
  370.             E_string[INI_MAX_VALUE];
  371.  
  372.         while(++E_l < 0x80)
  373.         {
  374.             E_parameter[E_l] = getarg(1 + (E_i * 2), E_l);
  375.         }
  376.         switch(format[E_i])
  377.         {
  378.             case 'b':       setarg(2 + (E_i * 2), 0, INI_ReadBool(E_parameter));
  379.             case 'd', 'i':  setarg(2 + (E_i * 2), 0, INI_ReadInt(E_parameter));
  380.             case 'f':       setarg(2 + (E_i * 2), 0, _:INI_ReadFloat(E_parameter));
  381.             case 's':
  382.             {
  383.                 E_string = INI_ReadString(E_parameter);
  384.  
  385.                 while(strlen(E_string) != E_loop++)
  386.                 {
  387.                     setarg(2 + (E_i * 2), E_loop, E_string[E_loop]);
  388.                 }
  389.             }
  390.         }
  391.     }
  392.     return true;
  393. }
  394.  
  395. stock INI_RemoveKey(const key[])
  396. {
  397.     if ((!gFile[E_OPEN]) || (!key[0]) || (strfind(key, "=", false) != -1)) return false;
  398.     new ln = -1;
  399.     while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  400.     {
  401.         ln ++;
  402.         if (gCache[ln][E_VALUE][0] == ';') continue;
  403.         if (!strcmp(gCache[ln][E_KEY], key, false))
  404.         {
  405.             for (; ln < (INI_MAX_LINES - 1); ln ++)
  406.             {
  407.                 INI_strcpy(gCache[ln][E_KEY], gCache[ln + 1][E_KEY], INI_MAX_KEY, INI_MAX_KEY);
  408.                 INI_strcpy(gCache[ln][E_VALUE], gCache[ln + 1][E_VALUE], INI_MAX_VALUE, INI_MAX_VALUE);
  409.             }
  410.             return true;
  411.         }
  412.     }
  413.     return false;
  414. }
  415.  
  416. stock INI_KeyExist(const key[])
  417. {
  418.     if ((!gFile[E_OPEN]) || (!key[0]) || (strfind(key, "=", false) != -1)) return false;
  419.     new ln = -1;
  420.     while (((ln + 1) < INI_MAX_LINES) && (gCache[ln + 1][E_VALUE][0]))
  421.     {
  422.         ln ++;
  423.         if (gCache[ln][E_VALUE][0] == ';') continue;
  424.         if (!strcmp(gCache[ln][E_KEY], key, false))
  425.         {
  426.             return true;
  427.         }
  428.     }
  429.     return false;
  430. }
  431.  
  432. stock INI_ReturnFile()
  433. {
  434.     if ((!gFile[E_OPEN])) return false;
  435.     else return gFile[E_OPEN];
  436. }
  437.  
  438. stock INI_ReturnFilename()
  439. {
  440.     if ((!gFile[E_OPEN])) return gFile[E_FILENAME];
  441.     else return gFile[E_FILENAME];
  442. }
  443.  
  444. //system functions
  445. stock INI_strcpy(dest[], const source[], numcells = sizeof(source), maxlength = sizeof(dest))
  446. {
  447.     new i;
  448.     while ((source[i]) && (i < numcells) && (i < maxlength))
  449.     {
  450.         dest[i] = source[i];
  451.         i ++;
  452.     }
  453.     dest[(i == maxlength) ? (i - 1) : (i)] = '\0';
  454. }
  455.  
  456. stock INI_StripLine(string[])
  457. {
  458.     new l;
  459.     l = strlen(string);
  460.     if (string[l - 2] == '\r') string[l - 2] = '\0';
  461.     if (string[l - 1] == '\n') string[l - 1] = '\0';
  462. }
  463.  
  464. //converting system
  465. #if(INI_CONVERT)
  466.  
  467.     //  -> converting DINI(one of the best ini code!)
  468.     #if defined dini_Exists
  469.         #undef dini_Exists
  470.     #endif
  471.     #define dini_Exists     fexist
  472.  
  473.     #if defined dini_Remove
  474.         #undef dini_Remove
  475.     #endif
  476.     #define dini_Remove     INI_Remove
  477.  
  478.     #if defined dini_Create
  479.         #undef dini_Create
  480.     #endif
  481.     #define dini_Create     INI_Create
  482.  
  483.     #if defined dini_Close
  484.         #undef dini_Close
  485.     #endif
  486.     #define dini_Close      INI_Close
  487.  
  488.     stock dini_Set(filename[],key[],value[])
  489.     {
  490.         if(! INI_Exist(filename))
  491.         {
  492.             INI_Create(filename);
  493.         }
  494.         INI_Open(filename);
  495.         return INI_WriteString(key, value);
  496.     }
  497.  
  498.     stock dini_IntSet(filename[],key[],value)
  499.     {
  500.         if(! INI_Exist(filename))
  501.         {
  502.             INI_Create(filename);
  503.         }
  504.         INI_Open(filename);
  505.         return INI_WriteInt(key, value);
  506.     }
  507.  
  508.     stock dini_FloatSet(filename[],key[],Float:value)
  509.     {
  510.         if(! INI_Exist(filename))
  511.         {
  512.             INI_Create(filename);
  513.         }
  514.         INI_Open(filename);
  515.         return INI_WriteFloat(key, value);
  516.     }
  517.  
  518.     stock dini_BoolSet(filename[],key[],value)
  519.     {
  520.         if(! INI_Exist(filename))
  521.         {
  522.             INI_Create(filename);
  523.         }
  524.         INI_Open(filename);
  525.         if(value)
  526.         {
  527.             return INI_WriteBool(key, true);
  528.         }
  529.         return INI_WriteBool(key, false);
  530.     }
  531.  
  532.     stock dini_Get(filename[],key[])
  533.     {
  534.         if(! INI_Exist(filename))
  535.         {
  536.             INI_Create(filename);
  537.         }
  538.         INI_Open(filename);
  539.         return INI_ReadString(key);
  540.     }
  541.  
  542.     stock dini_Int(filename[],key[])
  543.     {
  544.         if(! INI_Exist(filename))
  545.         {
  546.             INI_Create(filename);
  547.         }
  548.         INI_Open(filename);
  549.         return INI_ReadInt(key);
  550.     }
  551.  
  552.     stock Float:dini_Float(filename[],key[])
  553.     {
  554.         if(! INI_Exist(filename))
  555.         {
  556.             INI_Create(filename);
  557.         }
  558.         INI_Open(filename);
  559.         return INI_ReadFloat(key);
  560.     }
  561.  
  562.     stock dini_Bool(filename[],key[])
  563.     {
  564.         if(! INI_Exist(filename))
  565.         {
  566.             INI_Create(filename);
  567.         }
  568.         INI_Open(filename);
  569.         if(INI_ReadBool(key))
  570.         {
  571.             return 1;
  572.         }
  573.         else return 0;
  574.     }
  575.  
  576.     stock dini_UnSet(filename[],key[])
  577.     {
  578.         if(! INI_Exist(filename))
  579.         {
  580.             INI_Create(filename);
  581.         }
  582.         INI_Open(filename);
  583.         return INI_RemoveKey(key);
  584.     }
  585.  
  586.     stock dini_Isset(filename[],key[])
  587.     {
  588.         if(! INI_Exist(filename))
  589.         {
  590.             INI_Create(filename);
  591.         }
  592.         INI_Open(filename);
  593.         return INI_KeyExist(key);
  594.     }
  595.  
  596.     #if defined DINI_StripNewLine
  597.         #undef DINI_StripNewLine
  598.     #endif
  599.     #define DINI_StripNewLine INI_StripLine
  600.  
  601.     stock DINI_fcopytextfile(filename[],copyname[])
  602.     {
  603.         if(! INI_Exist(filename))
  604.         {
  605.             INI_Create(filename);
  606.         }
  607.         INI_Open(filename);
  608.         return INI_Copy(copyname);
  609.     }
  610.  
  611.     #if defined dini_Copy
  612.         #undef dini_Copy
  613.     #endif
  614.     #define dini_Copy       DINI_fcopytextfile
  615.  
  616.     stock dini_Rename(filename[],newname[])
  617.     {
  618.         if(! INI_Exist(filename))
  619.         {
  620.             INI_Create(filename);
  621.         }
  622.         INI_Open(filename);
  623.         return INI_Rename(newname);
  624.     }
  625.  
  626.     //  -> converting SMF(Southclaw file manager)
  627.     #if defined file_Create
  628.         #undef file_Create
  629.     #endif
  630.     #define file_Create     INI_Create
  631.  
  632.     #if defined file_Delete
  633.         #undef file_Delete
  634.     #endif
  635.     #define file_Delete     INI_Remove
  636.  
  637.     #if defined file_Open
  638.         #undef file_Open
  639.     #endif
  640.     #define file_Open       INI_Open
  641.  
  642.     #if defined file_Save
  643.         #undef file_Save
  644.     #endif
  645.     #define file_Save       INI_Save
  646.  
  647.     #if defined file_Close
  648.         #undef file_Close
  649.     #endif
  650.     #define file_Close      INI_Close
  651.  
  652.     #if defined file_SetStr
  653.         #undef file_SetStr
  654.     #endif
  655.     #define file_SetStr     INI_WriteString
  656.  
  657.     #if defined file_SetVal
  658.         #undef file_SetVal
  659.     #endif
  660.     #define file_SetVal     INI_WriteInt
  661.  
  662.     #if defined file_SetFloat
  663.         #undef file_SetFloat
  664.     #endif
  665.     #define file_SetFloat   INI_WriteFloat
  666.  
  667.     #if defined file_RemoveKey
  668.         #undef file_RemoveKey
  669.     #endif
  670.     #define file_RemoveKey  INI_RemoveKey
  671.  
  672.     #if defined file_IncVal
  673.         #undef file_IncVal
  674.     #endif
  675.     #define file_IncVal(%1,%2) INI_WriteInt(%1, INI_ReadInt(%1) + %2)
  676.  
  677.     #if defined file_GetStr
  678.         #undef file_GetStr
  679.     #endif
  680.     #define file_GetStr     INI_ReadString
  681.  
  682.     #if defined file_GetVal
  683.         #undef file_GetVal
  684.     #endif
  685.     #define file_GetVal     INI_ReadInt
  686.  
  687.     #if defined file_GetFloat
  688.         #undef file_GetFloat
  689.     #endif
  690.     #define file_GetFloat   INI_ReadFloat
  691.  
  692.     #if defined file_IsKey
  693.         #undef file_IsKey
  694.     #endif
  695.     #define file_IsKey      INI_KeyExist
  696.  
  697.     #if defined file_dGetStr
  698.         #undef file_dGetStr
  699.     #endif
  700.     #define file_dGetStr    dini_Get
  701.  
  702.     #if defined file_dGetVal
  703.         #undef file_dGetVal
  704.     #endif
  705.     #define file_dGetVal    dini_Int
  706.  
  707.     #if defined file_dGetFloat
  708.         #undef file_dGetFloat
  709.     #endif
  710.     #define file_dGetFloat  dini_Float
  711.  
  712.     //  -> converting DUDB
  713.     #define UDB_ACCOUNT_PATH        "Accounts"//specify the path where the user files will be made!
  714.     #define UDB_AUTOCLOSE_TIME      5000//specify the time after which the opened file will be auto closed!
  715.  
  716.     #if defined dUserADD
  717.         #undef dUserADD
  718.     #endif
  719.     #define dUserADD(%1,%2)         UDB_Create(%1,%2)
  720.  
  721.     #if defined dUserDELETE
  722.         #undef dUserDELETE
  723.     #endif
  724.     #define dUserDELETE(%1)         UDB_Remove(%1)
  725.  
  726.     #if defined dUser
  727.         #undef dUser
  728.     #endif
  729.     #define dUser(%1).(             UDB_ReadString(%1,
  730.  
  731.     #if defined dUserSet
  732.         #undef dUserSet
  733.     #endif
  734.     #define dUserSet(%1).(          UDB_WriteString(%1,
  735.  
  736.     #if defined dUserINT
  737.         #undef dUserINT
  738.     #endif
  739.     #define dUserINT(%1).(          UDB_ReadInt(%1,
  740.  
  741.     #if defined dUserSetINT
  742.         #undef dUserSetINT
  743.     #endif
  744.     #define dUserSetINT(%1).(       UDB_WriteInt(%1,
  745.  
  746.     #if defined dUserFLOAT
  747.         #undef dUserFLOAT
  748.     #endif
  749.     #define dUserFLOAT(%1).(        UDB_ReadFloat(%1,
  750.  
  751.     #if defined dUserSetFLOAT
  752.         #undef dUserSetFLOAT
  753.     #endif
  754.     #define dUserSetFLOAT(%1).(     UDB_WriteFloat(%1,
  755.  
  756.     #if defined dUserBOOL
  757.         #undef dUserBOOL
  758.     #endif
  759.     #define dUserBOOL(%1).(         UDB_ReadBool(%1,
  760.  
  761.     #if defined dUserSetBOOL
  762.         #undef dUserSetBOOL
  763.     #endif
  764.     #define dUserSetBOOL(%1).(      UDB_WriteBool(%1,
  765.  
  766.     #if defined udb_Exists
  767.         #undef udb_Exists
  768.     #endif
  769.     #define udb_Exists              UDB_Exist
  770.  
  771.     #if defined udb_Remove
  772.         #undef udb_Remove
  773.     #endif
  774.     #define udb_Remove              UDB_Remove
  775.  
  776.     #if defined udb_Create
  777.         #undef udb_Create
  778.     #endif
  779.     #define udb_Create              UDB_Create
  780.  
  781.     #if defined udb_RenameUser
  782.         #undef udb_RenameUser
  783.     #endif
  784.     #define udb_RenameUser          UDB_Rename
  785.  
  786.     #if defined udb_CopyUser
  787.         #undef udb_CopyUser
  788.     #endif
  789.     #define udb_CopyUser            UDB_Copy
  790.  
  791.     #if defined udb_CheckLogin
  792.         #undef udb_CheckLogin
  793.     #endif
  794.     #define udb_CheckLogin          UDB_CheckPassword
  795.  
  796.     new UDB_Timer = -1;
  797.  
  798.     stock UDB_Exist(username[])
  799.     {
  800.         new string[INI_MAX_VALUE];
  801.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  802.         return fexist(string);
  803.     }
  804.  
  805.     stock UDB_Create(username[], password[])
  806.     {
  807.         new string[INI_MAX_VALUE];
  808.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  809.         INI_Create(string, true);
  810.         INI_WriteString("Password", password);
  811.         INI_Close();
  812.     }
  813.  
  814.     stock UDB_Remove(username[])
  815.     {
  816.         new string[INI_MAX_VALUE];
  817.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  818.         if(UDB_Timer != -1)
  819.         {
  820.             KillTimer(UDB_Timer);
  821.             UDB_Timer = -1;
  822.         }
  823.         return INI_Remove(string);
  824.     }
  825.  
  826.     stock UDB_WriteInt(username[], key[], value)
  827.     {
  828.         new string[INI_MAX_VALUE];
  829.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  830.         if(UDB_Timer != -1)
  831.         {
  832.             KillTimer(UDB_Timer);
  833.         }
  834.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  835.         return dini_IntSet(string, key, value);
  836.     }
  837.  
  838.     stock UDB_WriteFloat(username[], key[], Float:value)
  839.     {
  840.         new string[INI_MAX_VALUE];
  841.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  842.         if(UDB_Timer != -1)
  843.         {
  844.             KillTimer(UDB_Timer);
  845.         }
  846.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  847.         return dini_FloatSet(string, key, value);
  848.     }
  849.  
  850.     stock UDB_WriteBool(username[], key[], bool:value)
  851.     {
  852.         new string[INI_MAX_VALUE];
  853.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  854.         if(UDB_Timer != -1)
  855.         {
  856.             KillTimer(UDB_Timer);
  857.         }
  858.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  859.         return dini_BoolSet(string, key, value);
  860.     }
  861.  
  862.     stock UDB_WriteString(username[], key[], value[])
  863.     {
  864.         new string[INI_MAX_VALUE];
  865.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  866.         if(UDB_Timer != -1)
  867.         {
  868.             KillTimer(UDB_Timer);
  869.         }
  870.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  871.         return dini_Set(string, key, value);
  872.     }
  873.  
  874.     stock UDB_ReadInt(username[], key[])
  875.     {
  876.         new string[INI_MAX_VALUE];
  877.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  878.         if(UDB_Timer != -1)
  879.         {
  880.             KillTimer(UDB_Timer);
  881.         }
  882.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  883.         return dini_Int(string, key);
  884.     }
  885.  
  886.     stock Float:UDB_ReadFloat(username[], key[])
  887.     {
  888.         new string[INI_MAX_VALUE];
  889.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  890.         if(UDB_Timer != -1)
  891.         {
  892.             KillTimer(UDB_Timer);
  893.         }
  894.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  895.         return dini_Float(string, key);
  896.     }
  897.  
  898.     stock UDB_ReadBool(username[], key[])
  899.     {
  900.         new string[INI_MAX_VALUE];
  901.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  902.         if(UDB_Timer != -1)
  903.         {
  904.             KillTimer(UDB_Timer);
  905.         }
  906.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  907.         return dini_Bool(string, key);
  908.     }
  909.  
  910.     stock UDB_ReadString(username[], key[])
  911.     {
  912.         new string[INI_MAX_VALUE];
  913.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  914.         if(UDB_Timer != -1)
  915.         {
  916.             KillTimer(UDB_Timer);
  917.         }
  918.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  919.         return dini_Get(string, key);
  920.     }
  921.  
  922.     stock UDB_Rename(username[], newname[])
  923.     {
  924.         new string[INI_MAX_VALUE];
  925.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  926.         if(UDB_Timer != -1)
  927.         {
  928.             KillTimer(UDB_Timer);
  929.         }
  930.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  931.         return dini_Rename(string, newname);
  932.     }
  933.  
  934.     stock UDB_Copy(username[], copyname[])
  935.     {
  936.         new string[INI_MAX_VALUE];
  937.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  938.         if(UDB_Timer != -1)
  939.         {
  940.             KillTimer(UDB_Timer);
  941.         }
  942.         UDB_Timer = SetTimer("UDB_AutoClose", UDB_AUTOCLOSE_TIME, false);
  943.         return dini_Copy(string, copyname);
  944.     }
  945.    
  946.     stock UDB_CheckPassword(username[], password[])
  947.     {
  948.         new string[INI_MAX_VALUE];
  949.         format(string, sizeof(string),""UDB_ACCOUNT_PATH"/%s.udb",username);
  950.         INI_Open(string);
  951.        
  952.         if(! strcmp(password, INI_ReadString("Password")))
  953.         {
  954.             INI_Close();
  955.             return true;
  956.         }
  957.         else
  958.         {
  959.             INI_Close();
  960.             return false;
  961.         }
  962.     }
  963.  
  964.     stock UDB_Close()
  965.     {
  966.         if(UDB_Timer != -1)
  967.         {
  968.             KillTimer(UDB_Timer);
  969.             UDB_Timer = -1;
  970.         }
  971.         #if(!INI_AUTO_SAVE)
  972.             INI_Save();
  973.         #endif
  974.         return INI_Close();
  975.     }
  976.  
  977.     forward UDB_AutoClose();
  978.     public UDB_AutoClose()
  979.     {
  980.         UDB_Close();
  981.         return true;
  982.     }
  983.  
  984.     //  -> converting FINI
  985.     //   INI_WriteString("key", "valor") //already defined in n_ini
  986.     //   INI_WriteFloat("key", valor) //already defined in n_ini
  987.     //   INI_WriteInt("key", valor) //already defined in n_ini
  988.     //   INI_ReadString("key") //already defined in n_ini
  989.     //   INI_ReadInt("key") //already defined in n_ini
  990.     //   INI_ReadFloat("key") //already defined in n_ini
  991.     //   INI_Create() //already defined in n_ini
  992.     //   INI_Open("arquivo") //already defined in n_ini
  993.  
  994.     #if defined INI_Isset
  995.         #undef INI_Isset
  996.     #endif
  997.     #define INI_Isset           INI_KeyExist
  998.  
  999.     //   INI_Close() //already defined in n_ini
  1000.     //   INI_Save() //already defined in n_ini
  1001.  
  1002.     //  -> Converting SF - Simple File
  1003.     #if defined FileCreate
  1004.         #undef FileCreate
  1005.     #endif
  1006.     #define FileCreate(%1,%2)           INI_Create(%1)
  1007.  
  1008.     #if defined FileDelete
  1009.         #undef FileDelete
  1010.     #endif
  1011.     #define FileDelete                  INI_Remove
  1012.  
  1013.     #if defined FileExist
  1014.         #undef FileExist
  1015.     #endif
  1016.     #define FileExist                   INI_Exist
  1017.  
  1018.     #if defined SaveFileString
  1019.         #undef SaveFileString
  1020.     #endif
  1021.     #define SaveFileString(%1,%2,%3)    dini_Set(%1,%2,%3)
  1022.  
  1023.     #if defined SaveFileInteger
  1024.         #undef SaveFileInteger
  1025.     #endif
  1026.     #define SaveFileInteger(%1,%2,%3)   dini_IntSet(%1,%2,%3)
  1027.  
  1028.     #if defined SaveFileFloat
  1029.         #undef SaveFileFloat
  1030.     #endif
  1031.     #define SaveFileFloat(%1,%2,%3)     dini_FloatSet(%1,%2,%3)
  1032.  
  1033.     #if defined GetFileString
  1034.         #undef GetFileString
  1035.     #endif
  1036.     #define GetFileString(%1,%2)        dini_Get(%1,%2)
  1037.  
  1038.     #if defined GetFileInteger
  1039.         #undef GetFileInteger
  1040.     #endif
  1041.     #define GetFileInteger(%1,%2)       dini_IntGet(%1,%2)
  1042.  
  1043.     #if defined GetFileFloat
  1044.         #undef GetFileFloat
  1045.     #endif
  1046.     #define GetFileFloat(%1,%2)         dini_FloatGet(%1,%2)
  1047.  
  1048.     #if defined EditFileName
  1049.         #undef EditFileName
  1050.     #endif
  1051.     #define EditFileName(%1,%2)         dini_Rename(%1,%2)
  1052.  
  1053.     //  -> Converting dFile
  1054.     #if defined dfile_Create
  1055.         #undef dfile_Create
  1056.     #endif
  1057.     #define dfile_Create                INI_Create
  1058.  
  1059.     #if defined dfile_Delete
  1060.         #undef dfile_Delete
  1061.     #endif
  1062.     #define dfile_Delete                INI_Remove
  1063.  
  1064.     #if defined dfile_Open
  1065.         #undef dfile_Open
  1066.     #endif
  1067.     #define dfile_Open                  INI_Open
  1068.  
  1069.     #if defined dfile_WriteString
  1070.         #undef dfile_WriteString
  1071.     #endif
  1072.     #define dfile_WriteString           INI_WriteString
  1073.  
  1074.     #if defined dfile_WriteInt
  1075.         #undef dfile_WriteInt
  1076.     #endif
  1077.     #define dfile_WriteInt              INI_WriteInt
  1078.  
  1079.     #if defined dfile_WriteBool
  1080.         #undef dfile_WriteBool
  1081.     #endif
  1082.     #define dfile_WriteBool             INI_WriteBool
  1083.  
  1084.     #if defined dfile_WriteFloat
  1085.         #undef dfile_WriteFloat
  1086.     #endif
  1087.     #define dfile_WriteFloat            INI_WriteFloat
  1088.  
  1089.     #if defined dfile_ReadString
  1090.         #undef dfile_ReadString
  1091.     #endif
  1092.     #define dfile_ReadString            INI_ReadString
  1093.  
  1094.     #if defined dfile_ReadInt
  1095.         #undef dfile_ReadInt
  1096.     #endif
  1097.     #define dfile_ReadInt               INI_ReadInt
  1098.  
  1099.     #if defined dfile_ReadFloat
  1100.         #undef dfile_ReadFloat
  1101.     #endif
  1102.     #define dfile_ReadFloat             INI_ReadFloat
  1103.  
  1104.     #if defined dfile_ReadBool
  1105.         #undef dfile_ReadBool
  1106.     #endif
  1107.     #define dfile_ReadBool              INI_ReadBool
  1108.  
  1109.     #if defined dfile_MoveFile
  1110.         #undef dfile_MoveFile
  1111.     #endif
  1112.     #define dfile_MoveFile              INI_Rename
  1113.  
  1114.     #if defined dfile_RenameFile
  1115.         #undef dfile_RenameFile
  1116.     #endif
  1117.     #define dfile_RenameFile            INI_Rename
  1118.  
  1119.     #if defined dfile_SaveFile
  1120.         #undef dfile_SaveFile
  1121.     #endif
  1122.     #define dfile_SaveFile              INI_Save
  1123.  
  1124.     #if defined dfile_FileExists
  1125.         #undef dfile_FileExists
  1126.     #endif
  1127.     #define dfile_FileExists            fexist
  1128.  
  1129.     #if defined dfile_ParseString
  1130.         #undef dfile_ParseString
  1131.     #endif
  1132.     #define dfile_ParseString           dini_Get
  1133.  
  1134.     #if defined dfile_ParseInt
  1135.         #undef dfile_ParseInt
  1136.     #endif
  1137.     #define dfile_ParseInt              dini_Int
  1138.  
  1139.     #if defined dfile_ParseFloat
  1140.         #undef dfile_ParseFloat
  1141.     #endif
  1142.     #define dfile_ParseFloat            dini_Float
  1143.  
  1144.     #if defined dfile_ParseBool
  1145.         #undef dfile_ParseBool
  1146.     #endif
  1147.     #define dfile_ParseBool             dini_Bool
  1148.  
  1149.     #if defined dfile_IsSet
  1150.         #undef dfile_IsSet
  1151.     #endif
  1152.     #define dfile_IsSet                 INI_KeyExist
  1153.  
  1154.     #if defined dfile_UnSet
  1155.         #undef dfile_UnSet
  1156.     #endif
  1157.     #define dfile_UnSet                 INI_RemoveKey
  1158.  
  1159.     #if defined dfile_MultiSet
  1160.         #undef dfile_MultiSet
  1161.     #endif
  1162.     #define dfile_MultiSet              INI_MultiWrite
  1163.  
  1164.     #if defined dfile_MultiGet
  1165.         #undef dfile_MultiGet
  1166.     #endif
  1167.     #define dfile_MultiGet              INI_MultiRead
  1168.  
  1169. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!