API tools faq
paste
Guest User

mxINI Lite.

a guest
Sep 21st, 2011
422
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Pawn 34.78 KB | None | 0 0
raw download clone embed print report
  1. /*mxINI, облегченная версия*/
  2.  
  3. const
  4.     INI_MAX_OPENED_FILES = 10,
  5.     INI_MAX_FILE_SIZE = 65536,
  6.     INI_MAX_FILENAME_SIZE = 128,
  7.     INI_MAX_KEYS_IN_FILE = 2048,
  8.     INI_INTEGER_SIZE = 12,
  9.     INI_FLOAT_SIZE = 40,
  10.     INI_STRING_DELIMITER = '\n',
  11.     INI_DELIMITER = '=',
  12.     INI_OK = 0,
  13.     INI_FILE_NOT_FOUND = -1,
  14.     INI_FILE_ALREADY_EXIST = -2,
  15.     INI_TOO_LARGE_FILE = -3,
  16.     INI_WRONG_PATH_SIZE = -4,
  17.     INI_READ_ERROR = -5,
  18.     INI_WRITE_ERROR = -6,
  19.     INI_NO_FREE_SLOT = -7,
  20.     INI_WRONG_SLOT = -8,
  21.     INI_KEY_NOT_FOUND = -9,
  22.     INI_WRONG_RETURN_SIZE = -10,
  23.     cellbytes = cellbits / charbits;
  24.  
  25. #define INI_SPACE_CHAR  ' ', '\t'
  26. #define INI_KEY_STARTS  ' ', '\t', '\r', '\n', '\0'
  27. #define INI_STRING_ENDS '\r', '\n', '\0'
  28. #define INI_NUMBER_ENDS ' ', '\t', '\r', '\n', '\0'
  29.  
  30. static stock
  31.     _ini_nSlotUsed[INI_MAX_OPENED_FILES],
  32.     _ini_nFileChanged[INI_MAX_OPENED_FILES],
  33.     _ini_nFileBusy[INI_MAX_OPENED_FILES],
  34.     _ini_nFileSize[INI_MAX_OPENED_FILES],
  35.     _ini_nDelimPos[INI_MAX_OPENED_FILES][INI_MAX_KEYS_IN_FILE],
  36.     _ini_nKeysCount[INI_MAX_OPENED_FILES],
  37.     _ini_szFilePath[INI_MAX_OPENED_FILES][INI_MAX_FILENAME_SIZE],
  38.     _ini_szFileContent[INI_MAX_OPENED_FILES][INI_MAX_FILE_SIZE char];
  39.  
  40. stock ini_createFile(szFilePath[],szDefaultContent[] = "")
  41. {
  42.     new nFileNameSize = strlen(szFilePath);
  43.     if(nFileNameSize <= 0 || nFileNameSize >= INI_MAX_FILENAME_SIZE) return INI_WRONG_PATH_SIZE;
  44.     if(fexist(szFilePath)) return INI_FILE_ALREADY_EXIST;
  45.     for(new slot = 0; slot < INI_MAX_OPENED_FILES; slot++)
  46.     {
  47.         if(_ini_nSlotUsed[slot] != 0 && strcmp(szFilePath,_ini_szFilePath[slot],false) == 0) return INI_FILE_ALREADY_EXIST;
  48.     }
  49.     new nFileSize = strlen(szDefaultContent);
  50.     if(nFileSize < 0 || nFileSize >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  51.     for(new slot = 0; slot < INI_MAX_OPENED_FILES; slot++)
  52.     {
  53.         if(_ini_nSlotUsed[slot] != 1)
  54.         {
  55.             _ini_nSlotUsed[slot] = 1;
  56.             _ini_nFileChanged[slot] = 0;
  57.             _ini_nFileSize[slot] = nFileSize;
  58.             _ini_nKeysCount[slot] = 0;
  59.             for(new i = 0; i < nFileSize && i < INI_MAX_FILE_SIZE;  i++)
  60.             {
  61.                 if(szDefaultContent[i] == INI_DELIMITER && _ini_nKeysCount[slot] < INI_MAX_KEYS_IN_FILE)
  62.                 {
  63.                     _ini_nDelimPos[slot][_ini_nKeysCount[slot]] = i;
  64.                     _ini_nKeysCount[slot]++;
  65.                 }
  66.                 _ini_szFileContent[slot]{i} = szDefaultContent[i];
  67.             }
  68.             _ini_szFileContent[slot]{nFileSize} = 0;
  69.             memcpy(_ini_szFilePath[slot],szFilePath,0,nFileNameSize * cellbytes);
  70.             _ini_szFilePath[slot][nFileNameSize] = 0;
  71.             return slot;
  72.         }
  73.     }
  74.     return INI_NO_FREE_SLOT;
  75. }
  76.  
  77. stock ini_openFile(szFilePath[])
  78. {
  79.     new nFileNameSize = strlen( szFilePath );
  80.     if(nFileNameSize <= 0 || nFileNameSize >= INI_MAX_FILENAME_SIZE) return INI_WRONG_PATH_SIZE;
  81.     if(!fexist(szFilePath)) return INI_FILE_NOT_FOUND;
  82.     for(new slot = 0; slot < INI_MAX_OPENED_FILES; slot++)
  83.     {
  84.         if(_ini_nSlotUsed[slot] != 0 &&  strcmp(szFilePath,_ini_szFilePath[slot],false) == 0) return slot;
  85.     }
  86.     new File:pFile = fopen(szFilePath,io_read);
  87.     if(!pFile) return INI_READ_ERROR;
  88.     new nFileSize = flength(pFile);
  89.     if(nFileSize >= INI_MAX_FILE_SIZE)
  90.     {
  91.         fclose(pFile);
  92.         return INI_TOO_LARGE_FILE;
  93.     }
  94.     for(new slot = 0; slot < INI_MAX_OPENED_FILES; slot++)
  95.     {
  96.         if(_ini_nSlotUsed[slot] != 1)
  97.         {
  98.             _ini_nSlotUsed[slot] = 1;
  99.             _ini_nFileChanged[slot] = 0;
  100.             _ini_nFileSize[slot] = nFileSize;
  101.             _ini_nKeysCount[slot] = 0;
  102.             for(new i = 0, symbol; i < nFileSize && i < INI_MAX_FILE_SIZE; i++)
  103.             {
  104.                 symbol = fgetchar(pFile,0,false);
  105.                 if(symbol == INI_DELIMITER && _ini_nKeysCount[slot] < INI_MAX_KEYS_IN_FILE)
  106.                 {
  107.                     _ini_nDelimPos[slot][_ini_nKeysCount[slot]] = i;
  108.                     _ini_nKeysCount[slot]++;
  109.                 }
  110.                 _ini_szFileContent[slot]{i} = symbol;
  111.             }
  112.             _ini_szFileContent[slot]{nFileSize} = 0;
  113.             fclose(pFile);
  114.             memcpy(_ini_szFilePath[slot],szFilePath,0,nFileNameSize * cellbytes);
  115.             _ini_szFilePath[slot][nFileNameSize] = 0;
  116.             return slot;
  117.         }
  118.     }
  119.     fclose(pFile);
  120.     return INI_NO_FREE_SLOT;
  121. }
  122.  
  123. stock ini_closeFile(nFilePointer)
  124. {
  125.     if(nFilePointer >= 0 && nFilePointer < INI_MAX_OPENED_FILES && _ini_nSlotUsed[nFilePointer] != 0)
  126.     {
  127.         if(_ini_nFileChanged[nFilePointer] != 0)
  128.         {
  129.             new File:pFile = fopen(_ini_szFilePath[nFilePointer],io_write);
  130.             if(!pFile) return INI_WRITE_ERROR;
  131.             for(new i = 0; i < _ini_nFileSize[nFilePointer]; i++) fputchar(pFile,_ini_szFileContent[nFilePointer]{i},false);
  132.             fclose(pFile);
  133.         }
  134.         _ini_nSlotUsed[nFilePointer] = 0;
  135.         return INI_OK;
  136.     }
  137.     return INI_WRONG_SLOT;
  138. }
  139.  
  140. stock ini_getString(nFilePointer,szKeyName[],szReturnValue[],nSizeOfReturn = sizeof(szReturnValue))
  141. {
  142.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  143.     if(nSizeOfReturn <= 0) return INI_WRONG_RETURN_SIZE;
  144.     new nKeyLen = strlen(szKeyName);
  145.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  146.     for(new kPos = 0, curFilePos, found = 0; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  147.     {
  148.         found = 0;
  149.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  150.         {
  151.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  152.             {
  153.                 case INI_SPACE_CHAR: continue;
  154.                 case INI_STRING_DELIMITER: break;
  155.                 default:
  156.                 {
  157.                     found = 1;
  158.                     break;
  159.                 }
  160.             }
  161.         }
  162.         if(found != 1) continue;
  163.         for(new curKeyPos = nKeyLen - 1;  curKeyPos >= 0;  curFilePos--, curKeyPos--)
  164.         {
  165.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  166.             {
  167.                 found = 0;
  168.                 break;
  169.             }
  170.         }
  171.         if(found != 0)
  172.         {
  173.             if(curFilePos >= 0)
  174.             {
  175.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  176.                 {
  177.                     case INI_KEY_STARTS: {}
  178.                     default: continue;
  179.                 }
  180.             }
  181.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  182.             for( ; ; curFilePos++)
  183.             {
  184.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  185.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  186.                 {
  187.                     case INI_SPACE_CHAR: continue;
  188.                     default: break;
  189.                 }
  190.             }
  191.             for(found = 0; found < nSizeOfReturn; found++, curFilePos++)
  192.             {
  193.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  194.                 {
  195.                     case INI_STRING_ENDS:
  196.                     {
  197.                         szReturnValue[found] = 0;
  198.                         break;
  199.                     }
  200.                     default : szReturnValue[found] = _ini_szFileContent[nFilePointer]{curFilePos};
  201.                 }
  202.             }
  203.             szReturnValue[nSizeOfReturn - 1] = 0;
  204.             return INI_OK;
  205.         }
  206.     }
  207.     return INI_KEY_NOT_FOUND;
  208. }
  209.  
  210. stock ini_getInteger(nFilePointer,szKeyName[],&nReturnValue )
  211. {
  212.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  213.     new nKeyLen = strlen(szKeyName);
  214.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  215.     for(new kPos = 0, curFilePos, found = 0; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  216.     {
  217.         found = 0;
  218.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  219.         {
  220.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  221.             {
  222.                 case INI_SPACE_CHAR: continue;
  223.                 case INI_STRING_DELIMITER: break;
  224.                 default:
  225.                 {
  226.                     found = 1;
  227.                     break;
  228.                 }
  229.             }
  230.         }
  231.         if(found != 1) continue;
  232.         for(new curKeyPos = nKeyLen - 1; curKeyPos >= 0; curFilePos--, curKeyPos--)
  233.         {
  234.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  235.             {
  236.                 found = 0;
  237.                 break;
  238.             }
  239.         }
  240.         if(found != 0)
  241.         {
  242.             if(curFilePos >= 0)
  243.             {
  244.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  245.                 {
  246.                     case INI_KEY_STARTS: {}
  247.                     default: continue;
  248.                 }
  249.             }
  250.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  251.             for( ; ; curFilePos++)
  252.             {
  253.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  254.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  255.                 {
  256.                     case INI_SPACE_CHAR: continue;
  257.                     default: break;
  258.                 }
  259.             }
  260.             new strValue[INI_INTEGER_SIZE];
  261.             for(found = 0; found < INI_INTEGER_SIZE; found++, curFilePos++)
  262.             {
  263.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  264.                 {
  265.                     case INI_NUMBER_ENDS:
  266.                     {
  267.                         strValue[found] = 0;
  268.                         break;
  269.                     }
  270.                     default : strValue[found] = _ini_szFileContent[nFilePointer]{curFilePos};
  271.                 }
  272.             }
  273.             strValue[INI_INTEGER_SIZE - 1] = 0;
  274.             nReturnValue = strval(strValue);
  275.             return INI_OK;
  276.         }
  277.     }
  278.     return INI_KEY_NOT_FOUND;
  279. }
  280.  
  281. stock ini_getFloat(nFilePointer,szKeyName[],&Float: fReturnValue)
  282. {
  283.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  284.     new nKeyLen = strlen(szKeyName);
  285.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  286.     for(new kPos = 0, curFilePos, found = 0; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  287.     {
  288.         found = 0;
  289.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  290.         {
  291.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  292.             {
  293.                 case INI_SPACE_CHAR: continue;
  294.                 case INI_STRING_DELIMITER: break;
  295.                 default:
  296.                 {
  297.                     found = 1;
  298.                     break;
  299.                 }
  300.             }
  301.         }
  302.         if(found != 1) continue;
  303.         for(new curKeyPos = nKeyLen - 1; curKeyPos >= 0; curFilePos--, curKeyPos--)
  304.         {
  305.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  306.             {
  307.                 found = 0;
  308.                 break;
  309.             }
  310.         }
  311.         if(found != 0)
  312.         {
  313.             if(curFilePos >= 0)
  314.             {
  315.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  316.                 {
  317.                     case INI_KEY_STARTS: {}
  318.                     default: continue;
  319.                 }
  320.             }
  321.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  322.             for( ; ; curFilePos++)
  323.             {
  324.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  325.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  326.                 {
  327.                     case INI_SPACE_CHAR: continue;
  328.                     default: break;
  329.                 }
  330.             }
  331.             new strValue[INI_FLOAT_SIZE];
  332.             for(found = 0; found < INI_INTEGER_SIZE; found++, curFilePos++)
  333.             {
  334.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  335.                 {
  336.                     case INI_NUMBER_ENDS:
  337.                     {
  338.                         strValue[found] = 0;
  339.                         break;
  340.                     }
  341.                     default: strValue[found] = _ini_szFileContent[nFilePointer]{curFilePos};
  342.                 }
  343.             }
  344.             strValue[INI_FLOAT_SIZE - 1] = 0;
  345.             fReturnValue = floatstr(strValue);
  346.             return INI_OK;
  347.         }
  348.     }
  349.     return INI_KEY_NOT_FOUND;
  350. }
  351.  
  352. stock ini_setString(nFilePointer,szKeyName[],szKeyValue[])
  353. {
  354.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  355.     new nKeyLen = strlen(szKeyName);
  356.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  357.     for(new kPos = 0, curFilePos, found; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  358.     {
  359.         found = 0;
  360.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  361.         {
  362.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  363.             {
  364.                 case INI_SPACE_CHAR: continue;
  365.                 case INI_STRING_DELIMITER: break;
  366.                 default:
  367.                 {
  368.                     found = 1;
  369.                     break;
  370.                 }
  371.             }
  372.         }
  373.         if(found != 1) continue;
  374.         for(new curKeyPos = nKeyLen - 1; curKeyPos >= 0; curFilePos--, curKeyPos--)
  375.         {
  376.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  377.             {
  378.                 found = 0;
  379.                 break;
  380.             }
  381.         }
  382.         if(found != 0)
  383.         {
  384.             if(curFilePos >= 0)
  385.             {
  386.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  387.                 {
  388.                     case INI_KEY_STARTS: {}
  389.                     default: continue;
  390.                 }
  391.             }
  392.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  393.             for( ; ; curFilePos++)
  394.             {
  395.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  396.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  397.                 {
  398.                     case INI_SPACE_CHAR: continue;
  399.                     default: break;
  400.                 }
  401.             }
  402.             new nValueLen = strlen(szKeyValue);
  403.             if((curFilePos + nValueLen) >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  404.             new fileValueStartPos = curFilePos;
  405.             for( ; ; curFilePos++)
  406.             {
  407.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  408.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  409.                 {
  410.                     case INI_STRING_ENDS: break;
  411.                     default: continue;
  412.                 }
  413.             }
  414.             new filePosOffset = nValueLen - (curFilePos - fileValueStartPos);
  415.             if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  416.             _ini_nFileBusy[nFilePointer] = 1;
  417.             if(filePosOffset != 0)
  418.             {
  419.                 if(filePosOffset < 0)
  420.                 {
  421.                     for ( ; curFilePos < _ini_nFileSize[nFilePointer]; curFilePos++ ) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  422.                 }
  423.                 else if(filePosOffset > 0)
  424.                 {
  425.                     new fileValueEndPos = curFilePos;
  426.                     for(curFilePos = _ini_nFileSize[nFilePointer] - 1; curFilePos >= fileValueEndPos; curFilePos--) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  427.                 }
  428.                 for(kPos++;  kPos < _ini_nKeysCount[nFilePointer];  kPos++) _ini_nDelimPos[nFilePointer][kPos] += filePosOffset;
  429.                 _ini_nFileSize[nFilePointer] += filePosOffset;
  430.                 _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = 0;
  431.             }
  432.             curFilePos = fileValueStartPos;
  433.             for(new valuePos = 0; valuePos < nValueLen; curFilePos++, valuePos++ ) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyValue[valuePos];
  434.             _ini_nFileChanged[nFilePointer] = 1;
  435.             _ini_nFileBusy[nFilePointer] = 0;
  436.             return INI_OK;
  437.         }
  438.     }
  439.     new nValueLen = strlen(szKeyValue);
  440.     if((_ini_nFileSize[nFilePointer] + 5 + nKeyLen + nValueLen) >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  441.     if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  442.     _ini_nFileBusy[nFilePointer] = 1;
  443.     if(_ini_nFileSize[nFilePointer] > 0 && _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer] - 1} != INI_STRING_DELIMITER)
  444.     {
  445.         _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = '\r';
  446.         _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer] + 1} = INI_STRING_DELIMITER;
  447.         _ini_nFileSize[nFilePointer] += 2;
  448.     }
  449.     new curFilePos, strPos;
  450.     for(curFilePos = _ini_nFileSize[nFilePointer], strPos = 0; strPos < nKeyLen; curFilePos++, strPos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyName[strPos];
  451.     _ini_szFileContent[nFilePointer]{curFilePos++} = ' ';
  452.     _ini_nDelimPos[nFilePointer][_ini_nKeysCount[nFilePointer]] = curFilePos;
  453.     _ini_nKeysCount[nFilePointer]++;
  454.     _ini_szFileContent[nFilePointer]{curFilePos++} = INI_DELIMITER;
  455.     _ini_szFileContent[nFilePointer]{curFilePos++} = ' ';
  456.     for(strPos = 0; strPos < nValueLen; curFilePos++, strPos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyValue[strPos];
  457.     _ini_szFileContent[nFilePointer]{curFilePos} = 0;
  458.     _ini_nFileSize[nFilePointer] = curFilePos;
  459.     _ini_nFileChanged[nFilePointer] = 1;
  460.     _ini_nFileBusy[nFilePointer] = 0;
  461.     return INI_OK;
  462. }
  463.  
  464. stock ini_setInteger(nFilePointer,szKeyName[],nKeyValue)
  465. {
  466.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  467.     new nKeyLen = strlen(szKeyName);
  468.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  469.     for(new kPos = 0, curFilePos, found; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  470.     {
  471.         found = 0;
  472.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  473.         {
  474.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  475.             {
  476.                 case INI_SPACE_CHAR: continue;
  477.                 case INI_STRING_DELIMITER: break;
  478.                 default:
  479.                 {
  480.                     found = 1;
  481.                     break;
  482.                 }
  483.             }
  484.         }
  485.         if(found != 1) continue;
  486.         for(new curKeyPos = nKeyLen - 1; curKeyPos >= 0; curFilePos--, curKeyPos--)
  487.         {
  488.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  489.             {
  490.                 found = 0;
  491.                 break;
  492.             }
  493.         }
  494.         if(found != 0)
  495.         {
  496.             if(curFilePos >= 0)
  497.             {
  498.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  499.                 {
  500.                     case INI_KEY_STARTS: {}
  501.                     default: continue;
  502.                 }
  503.             }
  504.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  505.             for ( ; ; curFilePos++)
  506.             {
  507.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  508.  
  509.                 switch( _ini_szFileContent[nFilePointer]{curFilePos})
  510.                 {
  511.                     case INI_SPACE_CHAR: continue;
  512.                     default: break;
  513.                 }
  514.             }
  515.             new szKeyValue[INI_INTEGER_SIZE];
  516.             format(szKeyValue,INI_INTEGER_SIZE,"%i",nKeyValue);
  517.             new nValueLen = strlen(szKeyValue);
  518.             if((curFilePos + nValueLen) >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  519.             new fileValueStartPos = curFilePos;
  520.             for ( ; ; curFilePos++)
  521.             {
  522.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  523.  
  524.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  525.                 {
  526.                     case INI_NUMBER_ENDS: break;
  527.                     default: continue;
  528.                 }
  529.             }
  530.             new filePosOffset = nValueLen - (curFilePos - fileValueStartPos);
  531.             if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  532.             _ini_nFileBusy[nFilePointer] = 1;
  533.             if(filePosOffset != 0)
  534.             {
  535.                 if(filePosOffset < 0)
  536.                 {
  537.                     for( ; curFilePos < _ini_nFileSize[nFilePointer]; curFilePos++) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  538.                 }
  539.                 else if(filePosOffset > 0)
  540.                 {
  541.                     new fileValueEndPos = curFilePos;
  542.                     for(curFilePos = _ini_nFileSize[nFilePointer] - 1; curFilePos >= fileValueEndPos; curFilePos--) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  543.                 }
  544.                 for(kPos++; kPos < _ini_nKeysCount[nFilePointer]; kPos++) _ini_nDelimPos[nFilePointer][kPos] += filePosOffset;
  545.                 _ini_nFileSize[nFilePointer] += filePosOffset;
  546.                 _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = 0;
  547.             }
  548.             curFilePos = fileValueStartPos;
  549.             for(new valuePos = 0; valuePos < nValueLen; curFilePos++, valuePos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyValue[valuePos];
  550.             _ini_nFileChanged[nFilePointer] = 1;
  551.             _ini_nFileBusy[nFilePointer] = 0;
  552.             return INI_OK;
  553.         }
  554.     }
  555.     new szKeyValue[INI_INTEGER_SIZE];
  556.     format(szKeyValue, INI_INTEGER_SIZE,"%i",nKeyValue);
  557.     new nValueLen = strlen(szKeyValue);
  558.     if((_ini_nFileSize[nFilePointer] + 5 + nKeyLen + nValueLen) >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  559.     if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  560.     _ini_nFileBusy[nFilePointer] = 1;
  561.     if(_ini_nFileSize[nFilePointer] > 0 && _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer] - 1} != INI_STRING_DELIMITER)
  562.     {
  563.         _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = '\r';
  564.         _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer] + 1} = INI_STRING_DELIMITER;
  565.         _ini_nFileSize[nFilePointer] += 2;
  566.     }
  567.     new curFilePos, strPos;
  568.     for(curFilePos = _ini_nFileSize[nFilePointer], strPos = 0; strPos < nKeyLen; curFilePos++, strPos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyName[strPos];
  569.     _ini_szFileContent[nFilePointer]{curFilePos++} = ' ';
  570.     _ini_nDelimPos[nFilePointer][_ini_nKeysCount[nFilePointer]] = curFilePos;
  571.     _ini_nKeysCount[nFilePointer]++;
  572.     _ini_szFileContent[nFilePointer]{curFilePos++} = INI_DELIMITER;
  573.     _ini_szFileContent[nFilePointer]{curFilePos++} = ' ';
  574.     for(strPos = 0; strPos < nValueLen; curFilePos++, strPos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyValue[strPos];
  575.     _ini_szFileContent[nFilePointer]{curFilePos} = 0;
  576.     _ini_nFileSize[nFilePointer] = curFilePos;
  577.     _ini_nFileChanged[nFilePointer] = 1;
  578.     _ini_nFileBusy[nFilePointer] = 0;
  579.     return INI_OK;
  580. }
  581.  
  582. stock ini_setFloat(nFilePointer,szKeyName[],Float:fKeyValue)
  583. {
  584.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  585.     new nKeyLen = strlen(szKeyName);
  586.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  587.     for(new kPos = 0, curFilePos, found; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  588.     {
  589.         found = 0;
  590.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  591.         {
  592.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  593.             {
  594.                 case INI_SPACE_CHAR: continue;
  595.                 case INI_STRING_DELIMITER: break;
  596.                 default:
  597.                 {
  598.                     found = 1;
  599.                     break;
  600.                 }
  601.             }
  602.         }
  603.         if(found != 1) continue;
  604.         for(new curKeyPos = nKeyLen - 1;  curKeyPos >= 0;  curFilePos--, curKeyPos--)
  605.         {
  606.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  607.             {
  608.                 found = 0;
  609.                 break;
  610.             }
  611.         }
  612.         if(found != 0)
  613.         {
  614.             if(curFilePos >= 0)
  615.             {
  616.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  617.                 {
  618.                     case INI_KEY_STARTS: {}
  619.                     default: continue;
  620.                 }
  621.             }
  622.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  623.             for( ; ; curFilePos++)
  624.             {
  625.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  626.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  627.                 {
  628.                     case INI_SPACE_CHAR: continue;
  629.                     default: break;
  630.                 }
  631.             }
  632.             new szKeyValue[INI_FLOAT_SIZE];
  633.             format(szKeyValue,INI_FLOAT_SIZE,"%f",fKeyValue);
  634.             new nValueLen = strlen(szKeyValue);
  635.             if((curFilePos + nValueLen) >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  636.             new fileValueStartPos = curFilePos;
  637.             for( ; ; curFilePos++)
  638.             {
  639.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  640.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  641.                 {
  642.                     case INI_NUMBER_ENDS: break;
  643.                     default: continue;
  644.                 }
  645.             }
  646.             new filePosOffset = nValueLen - (curFilePos - fileValueStartPos);
  647.             if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  648.             _ini_nFileBusy[nFilePointer] = 1;
  649.             if(filePosOffset != 0)
  650.             {
  651.                 if(filePosOffset < 0)
  652.                 {
  653.                     for( ; curFilePos < _ini_nFileSize[nFilePointer]; curFilePos++ ) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  654.                 }
  655.                 else if ( filePosOffset > 0 )
  656.                 {
  657.                     new fileValueEndPos = curFilePos;
  658.                     for(curFilePos = _ini_nFileSize[nFilePointer] - 1; curFilePos >= fileValueEndPos; curFilePos--) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  659.                 }
  660.                 for(kPos++; kPos < _ini_nKeysCount[nFilePointer]; kPos++) _ini_nDelimPos[nFilePointer][kPos] += filePosOffset;
  661.                 _ini_nFileSize[nFilePointer] += filePosOffset;
  662.                 _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = 0;
  663.             }
  664.             curFilePos = fileValueStartPos;
  665.             for(new valuePos = 0; valuePos < nValueLen; curFilePos++, valuePos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyValue[valuePos];
  666.             _ini_nFileChanged[nFilePointer] = 1;
  667.             _ini_nFileBusy[nFilePointer] = 0;
  668.             return INI_OK;
  669.         }
  670.     }
  671.     new szKeyValue[INI_FLOAT_SIZE];
  672.     format(szKeyValue,INI_FLOAT_SIZE,"%f",fKeyValue);
  673.     new nValueLen = strlen(szKeyValue);
  674.     if((_ini_nFileSize[nFilePointer] + 5 + nKeyLen + nValueLen) >= INI_MAX_FILE_SIZE) return INI_TOO_LARGE_FILE;
  675.     if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  676.     _ini_nFileBusy[nFilePointer] = 1;
  677.     if(_ini_nFileSize[nFilePointer] > 0 && _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer] - 1} != INI_STRING_DELIMITER)
  678.     {
  679.         _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = '\r';
  680.         _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer] + 1} = INI_STRING_DELIMITER;
  681.         _ini_nFileSize[nFilePointer] += 2;
  682.     }
  683.     new curFilePos, strPos;
  684.     for(curFilePos = _ini_nFileSize[nFilePointer], strPos = 0; strPos < nKeyLen; curFilePos++, strPos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyName[strPos];
  685.     _ini_szFileContent[nFilePointer]{curFilePos++} = ' ';
  686.     _ini_nDelimPos[nFilePointer][_ini_nKeysCount[nFilePointer]] = curFilePos;
  687.     _ini_nKeysCount[nFilePointer]++;
  688.     _ini_szFileContent[nFilePointer]{curFilePos++} = INI_DELIMITER;
  689.     _ini_szFileContent[nFilePointer]{curFilePos++} = ' ';
  690.     for(strPos = 0; strPos < nValueLen; curFilePos++, strPos++) _ini_szFileContent[nFilePointer]{curFilePos} = szKeyValue[strPos];
  691.     _ini_szFileContent[nFilePointer]{curFilePos} = 0;
  692.     _ini_nFileSize[nFilePointer] = curFilePos;
  693.     _ini_nFileChanged[nFilePointer] = 1;
  694.     _ini_nFileBusy[nFilePointer] = 0;
  695.     return INI_OK;
  696. }
  697.  
  698. stock ini_removeKey ( nFilePointer, szKeyName[] )
  699. {
  700.     if(nFilePointer < 0 || nFilePointer >= INI_MAX_OPENED_FILES || _ini_nSlotUsed[nFilePointer] != 1) return INI_WRONG_SLOT;
  701.     new nKeyLen = strlen(szKeyName);
  702.     if(nKeyLen <= 0) return INI_KEY_NOT_FOUND;
  703.     for( new kPos = 0, curFilePos, found; kPos < _ini_nKeysCount[nFilePointer]; kPos++)
  704.     {
  705.         found = 0;
  706.         for(curFilePos = _ini_nDelimPos[nFilePointer][kPos] - 1; curFilePos >= 0; curFilePos--)
  707.         {
  708.             switch(_ini_szFileContent[nFilePointer]{curFilePos})
  709.             {
  710.                 case INI_SPACE_CHAR: continue;
  711.                 case INI_STRING_DELIMITER: break;
  712.                 default:
  713.                 {
  714.                     found = 1;
  715.                     break;
  716.                 }
  717.             }
  718.         }
  719.         if(found != 1) continue;
  720.         for(new curKeyPos = nKeyLen - 1; curKeyPos >= 0; curFilePos--,curKeyPos--)
  721.         {
  722.             if(curFilePos < 0 || _ini_szFileContent[nFilePointer]{curFilePos} != szKeyName[curKeyPos] || _ini_szFileContent[nFilePointer]{curFilePos} == INI_STRING_DELIMITER)
  723.             {
  724.                 found = 0;
  725.                 break;
  726.             }
  727.         }
  728.         if(found != 0)
  729.         {
  730.             if(curFilePos >= 0)
  731.             {
  732.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  733.                 {
  734.                     case INI_KEY_STARTS : {}
  735.                     default: continue;
  736.                 }
  737.             }
  738.             new keyStartPos = (curFilePos <= 0) ? 0 : curFilePos + 1;
  739.             curFilePos = _ini_nDelimPos[nFilePointer][kPos] + 1;
  740.             for ( ; ; curFilePos++)
  741.             {
  742.                 if(curFilePos >= _ini_nFileSize[nFilePointer]) break;
  743.                 switch(_ini_szFileContent[nFilePointer]{curFilePos})
  744.                 {
  745.                     case INI_SPACE_CHAR: continue;
  746.                     default: break;
  747.                 }
  748.             }
  749.             for ( ; ; curFilePos++ )
  750.             {
  751.                 if ( curFilePos >= _ini_nFileSize[nFilePointer] ) break;
  752.                 switch ( _ini_szFileContent[nFilePointer]{curFilePos} )
  753.                 {
  754.                     case INI_STRING_ENDS: break;
  755.                     default: continue;
  756.                 }
  757.             }
  758.             new filePosOffset = keyStartPos - curFilePos;
  759.             if(_ini_nFileBusy[nFilePointer] != 0) return INI_WRITE_ERROR;
  760.             _ini_nFileBusy[nFilePointer] = 1;
  761.             for( ; curFilePos <= _ini_nFileSize[nFilePointer]; curFilePos++) _ini_szFileContent[nFilePointer]{curFilePos + filePosOffset} = _ini_szFileContent[nFilePointer]{curFilePos};
  762.             for( ;  kPos < _ini_nKeysCount[nFilePointer];  kPos++) _ini_nDelimPos[nFilePointer][kPos] = _ini_nDelimPos[nFilePointer][kPos + 1] + filePosOffset;
  763.             _ini_nKeysCount[nFilePointer]--;
  764.             _ini_nFileSize[nFilePointer] += filePosOffset;
  765.             _ini_szFileContent[nFilePointer]{_ini_nFileSize[nFilePointer]} = 0;
  766.             _ini_nFileChanged[nFilePointer] = 1;
  767.             _ini_nFileBusy[nFilePointer] = 0;
  768.             return INI_OK;
  769.         }
  770.     }
  771.     return INI_KEY_NOT_FOUND;
  772. }
  773.  
  774. stock ini_getErrorInfo ( nErrorCode )
  775. {
  776.     new error_ms[200] = "Ошибок нет";
  777.     if(nErrorCode >= 0) return error_ms;
  778.     switch(nErrorCode)
  779.     {
  780.         case INI_FILE_NOT_FOUND: error_ms = "INI файл, указанный в `ini_openFile`, не существует, возможно, указан неверный путь к нему";
  781.         case INI_FILE_ALREADY_EXIST: error_ms = "INI файл, указанный в `ini_createFile`, уже существует, укажите другое имя/путь к файлу";
  782.         case INI_TOO_LARGE_FILE: error_ms = "Невозможно добавить новый ключ в INI файл, т.к. размер INI файла превысит допустимый лимит в " #INI_MAX_FILE_SIZE " символ(ов), или будет превышен лимит в " #INI_MAX_KEYS_IN_FILE " ключей";
  783.         case INI_WRONG_PATH_SIZE: error_ms = "Длина пути к INI файлу, указанного в `ini_openFile` / `ini_createFile`, превышает лимит в " #INI_MAX_FILENAME_SIZE " символ(ов)";
  784.         case INI_READ_ERROR: error_ms = "Ошибка при чтении INI файла с диска, возможно, файл занят другим процессом";
  785.         case INI_WRITE_ERROR: error_ms = "Ошибка при записи содержимого INI файла на диск, возможно, файл занят другим процессом";
  786.         case INI_NO_FREE_SLOT: error_ms = "Лимит в " #INI_MAX_OPENED_FILES " одновременно открытых INI файлов исчерпан, поэтому открыть/создать еще 1 файл нельзя, пока не закрыт хоть 1 из открытых файлов";
  787.         case INI_WRONG_SLOT: error_ms = "Указан неверный ID открытого INI файла, возможно, при открытии INI файла произошла ошибка, поэтому вместо ID файла вы получили код ошибки";
  788.         case INI_KEY_NOT_FOUND: error_ms = "Указанный ключ не найден в открытом INI файле";
  789.         case INI_WRONG_RETURN_SIZE: error_ms = "При попытке чтения строкового значения из INI файла, последний параметр `nSizeOfReturn` в `ini_getString` оказался <= 0, укажите вручную значение > 0 для него";
  790.         default: error_ms = "Неизвестная ошибка";
  791.     }
  792.     return error_ms;
  793. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!