@amxts/core 0.1.0

package/amxmodx/base/include/string_const.inc

@@ -0,0 +1,156 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// String Manipulation Constants
+//
+
+#if defined _string_const_included
+  #endinput
+#endif
+#define _string_const_included
+
+#define charsmax(%1) (sizeof(%1)-1)
+
+/**
+ * @global  Unless otherwise noted, all string functions which take in a
+ *          writable buffer and maximum length should NOT have the null terminator INCLUDED
+ *          in the length.  This means that this is valid:
+ *          copy(string, charsmax(string), ...)
+ */
+
+/**
+ * Buffer size used by fmt().
+ */
+#define MAX_FMT_LENGTH 256
+
+/**
+ * Below are the trim flags for strtok2
+ *
+ * You can specify how the left and right buffers will
+ * be trimmed by strtok2. LTRIM trims spaces from the
+ * left side. RTRIM trims from the right side.
+ *
+ * The defines TRIM_INNER, TRIM_OUTER and TRIM_FULL are
+ * shorthands for commonly used flag combinations.
+ *
+ * When the initial string is trimmed, using TRIM_INNER
+ * for all subsequent strtok2 calls will ensure that left
+ * and right are always trimmed from both sides.
+ *
+ * Examples:
+ * str1[] = "  This is  *  some text  "
+ * strtok2(str1, left, 24, right, 24, '*', TRIM_FULL)
+ *  left will be "This is", right will be "some text"
+ *
+ * str2[] = "  Here is  |  an  | example  "
+ * trim(str2)
+ * strtok2(str2, left, 24, right, 24, '|', TRIM_INNER)
+ *  left will be "Here is", right will be "an  | example"
+ * strtok2(right, left, 24, right, 24, '|', TRIM_INNER)
+ *  left will be "an", right will be "example"
+ *
+ * str3[] = "  One  -  more  "
+ * strtok2(str3, left, 24, right, 24, '-', TRIM_OUTER)
+ *  left will be "One  ", right will be "  more"
+ *
+ * str4[] = "  Final  .  example  "
+ * strtok2(str4, left, 24, right, 24, '.', LTRIM_LEFT|LTRIM_RIGHT)
+ *  left will be "Final  ", right will be "example  "
+*/
+#define LTRIM_LEFT (1<<0)
+#define RTRIM_LEFT (1<<1)
+#define LTRIM_RIGHT (1<<2)
+#define RTRIM_RIGHT (1<<3)
+
+#define TRIM_INNER RTRIM_LEFT|LTRIM_RIGHT
+#define TRIM_OUTER LTRIM_LEFT|RTRIM_RIGHT
+#define TRIM_FULL TRIM_OUTER|TRIM_INNER
+
+/**
+ * Category flags to be used with is_string_category(), to check whether code points in a
+ * string are part of that category.
+ */
+#define UTF8C_LETTER_UPPERCASE          0x00000001    // Uppercase letter code points, Lu in the Unicode database.
+#define UTF8C_LETTER_LOWERCASE          0x00000002    // Lowercase letter code points, Ll in the Unicode database.
+#define UTF8C_LETTER_TITLECASE          0x00000004    // Titlecase letter code points, Lt in the Unicode database.
+#define UTF8C_LETTER_MODIFIER           0x00000008    // Modifier letter code points, Lm in the Unicode database.
+#define UTF8C_LETTER_OTHER              0x00000010    // Other letter code points, Lo in the Unicode database.
+
+// Combined flag for all letter categories with case mapping
+// Combined flag for all letter categories
+const UTF8C_LETTER      = (UTF8C_LETTER_UPPERCASE | UTF8C_LETTER_LOWERCASE | UTF8C_LETTER_TITLECASE | UTF8C_LETTER_MODIFIER  | UTF8C_LETTER_OTHER);
+const UTF8C_CASE_MAPPED = (UTF8C_LETTER_UPPERCASE | UTF8C_LETTER_LOWERCASE | UTF8C_LETTER_TITLECASE);
+
+#define UTF8C_MARK_NON_SPACING          0x00000020    // Non-spacing mark code points, Mn in the Unicode database.
+#define UTF8C_MARK_SPACING              0x00000040    // Spacing mark code points, Mc in the Unicode database.
+#define UTF8C_MARK_ENCLOSING            0x00000080    // Enclosing mark code points, Me in the Unicode database.
+
+// Combined flag for all mark categories.
+const UTF8C_MARK = (UTF8C_MARK_NON_SPACING | UTF8C_MARK_SPACING | UTF8C_MARK_ENCLOSING);
+
+#define UTF8C_NUMBER_DECIMAL            0x00000100    // Decimal number code points, Nd in the Unicode database.
+#define UTF8C_NUMBER_LETTER             0x00000200    // Letter number code points, Nl in the Unicode database.
+#define UTF8C_NUMBER_OTHER              0x00000400    // Other number code points, No in the Unicode database.
+
+// Combined flag for all number categories.
+const UTF8C_NUMBER = (UTF8C_NUMBER_DECIMAL | UTF8C_NUMBER_LETTER | UTF8C_NUMBER_OTHER);
+
+#define UTF8C_PUNCTUATION_CONNECTOR     0x00000800    // Connector punctuation category, Pc in the Unicode database.
+#define UTF8C_PUNCTUATION_DASH          0x00001000    // Dash punctuation category, Pd in the Unicode database.
+#define UTF8C_PUNCTUATION_OPEN          0x00002000    // Open punctuation category, Ps in the Unicode database.
+#define UTF8C_PUNCTUATION_CLOSE         0x00004000    // Close punctuation category, Pe in the Unicode database.
+#define UTF8C_PUNCTUATION_INITIAL       0x00008000    // Initial punctuation category, Pi in the Unicode database.
+#define UTF8C_PUNCTUATION_FINAL         0x00010000    // Final punctuation category, Pf in the Unicode database.
+#define UTF8C_PUNCTUATION_OTHER         0x00020000    // Other punctuation category, Po in the Unicode database.
+
+// Combined flag for all punctuation categories.
+const UTF8C_PUNCTUATION  = (UTF8C_PUNCTUATION_CONNECTOR | UTF8C_PUNCTUATION_DASH    | UTF8C_PUNCTUATION_OPEN  | \
+							UTF8C_PUNCTUATION_CLOSE     | UTF8C_PUNCTUATION_INITIAL | UTF8C_PUNCTUATION_FINAL | \
+							UTF8C_PUNCTUATION_OTHER);
+
+#define UTF8C_SYMBOL_MATH               0x00040000    // Math symbol category, Sm in the Unicode database.
+#define UTF8C_SYMBOL_CURRENCY           0x00080000    // Currency symbol category, Sc in the Unicode database.
+#define UTF8C_SYMBOL_MODIFIER           0x00100000    // Modifier symbol category, Sk in the Unicode database.
+#define UTF8C_SYMBOL_OTHER              0x00200000    // Other symbol category, So in the Unicode database.
+
+// Combined flag for all symbol categories.
+const UTF8C_SYMBOL = (UTF8C_SYMBOL_MATH | UTF8C_SYMBOL_CURRENCY | UTF8C_SYMBOL_MODIFIER | UTF8C_SYMBOL_OTHER);
+
+#define UTF8C_SEPARATOR_SPACE           0x00400000    // Space separator category, Zs in the Unicode database.
+#define UTF8C_SEPARATOR_LINE            0x00800000    // Line separator category, Zl in the Unicode database.
+#define UTF8C_SEPARATOR_PARAGRAPH       0x01000000    // Paragraph separator category, Zp in the Unicode database.
+
+// Combined flag for all separator categories.
+const UTF8C_SEPARATOR = (UTF8C_SEPARATOR_SPACE | UTF8C_SEPARATOR_LINE | UTF8C_SEPARATOR_PARAGRAPH);
+
+#define UTF8C_CONTROL                   0x02000000    // Control category, Cc in the Unicode database.
+#define UTF8C_FORMAT                    0x04000000    // Format category, Cf in the Unicode database.
+#define UTF8C_SURROGATE                 0x08000000    // Surrogate category, Cs in the Unicode database.
+#define UTF8C_PRIVATE_USE               0x10000000    // Private use category, Co in the Unicode database.
+#define UTF8C_UNASSIGNED                0x20000000    // Unassigned category, Cn in the Unicode database.
+#define UTF8C_COMPATIBILITY             0x40000000    // Flag used for maintaining backwards compatibility with POSIX
+#define UTF8C_IGNORE_GRAPHEME_CLUSTER   0x80000000    // Flag used for checking only the general category of code points at the start of a grapheme cluster.
+
+// Flag used for maintaining backwards compatibility with POSIX function
+const UTF8C_ISCNTRL  = (UTF8C_COMPATIBILITY | UTF8C_CONTROL);
+const UTF8C_ISPRINT  = (UTF8C_COMPATIBILITY | UTF8C_LETTER | UTF8C_NUMBER | UTF8C_PUNCTUATION | UTF8C_SYMBOL | UTF8C_SEPARATOR);
+const UTF8C_ISSPACE  = (UTF8C_COMPATIBILITY | UTF8C_SEPARATOR_SPACE);
+const UTF8C_ISBLANK  = (UTF8C_COMPATIBILITY | UTF8C_SEPARATOR_SPACE | UTF8C_PRIVATE_USE);
+const UTF8C_ISGRAPH  = (UTF8C_COMPATIBILITY | UTF8C_LETTER | UTF8C_NUMBER | UTF8C_PUNCTUATION | UTF8C_SYMBOL);
+const UTF8C_ISPUNCT  = (UTF8C_COMPATIBILITY | UTF8C_PUNCTUATION | UTF8C_SYMBOL);
+const UTF8C_ISALNUM  = (UTF8C_COMPATIBILITY | UTF8C_LETTER | UTF8C_NUMBER);
+const UTF8C_ISALPHA  = (UTF8C_COMPATIBILITY | UTF8C_LETTER);
+const UTF8C_ISUPPER  = (UTF8C_COMPATIBILITY | UTF8C_LETTER_UPPERCASE);
+const UTF8C_ISLOWER  = (UTF8C_COMPATIBILITY | UTF8C_LETTER_LOWERCASE);
+const UTF8C_ISDIGIT  = (UTF8C_COMPATIBILITY | UTF8C_NUMBER);
+const UTF8C_ISXDIGIT = (UTF8C_COMPATIBILITY | UTF8C_NUMBER | UTF8C_PRIVATE_USE);
+
+// All flags.
+const UTF8C_ALL = 0xFFFFFFFF & (~UTF8C_COMPATIBILITY);

package/amxmodx/base/include/string_stocks.inc

@@ -0,0 +1,325 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// String Manipulation Stocks
+//
+
+#if defined _string_stocks_included
+  #endinput
+#endif
+#define _string_stocks_included
+
+#if !defined _string_included
+	#include <string>
+#endif
+
+/**
+ * @global  Unless otherwise noted, all string functions which take in a
+ *          writable buffer and maximum length should NOT have the null terminator INCLUDED
+ *          in the length.  This means that this is valid:
+ *          copy(string, charsmax(string), ...)
+ */
+
+/**
+ * Returns whether a given string contains only digits.
+ * This returns false for zero-length strings.
+ *
+ * @param sString       Character to test.
+ * @return              True if string contains only digit, otherwise false.
+ */
+stock bool:is_str_num(const sString[])
+{
+	new i = 0;
+
+	while (sString[i] && isdigit(sString[i]))
+	{
+		++i;
+	}
+
+	return sString[i] == 0 && i != 0;
+}
+
+/**
+ * Returns an uppercase character to a lowercase character.
+ *
+ * @note Only available in 1.8.3 and above.
+ *
+ * @param chr           Characer to convert.
+ * @return              Lowercase character on success,
+ *                      no change on failure.
+ */
+stock char_to_upper(chr)
+{
+	if (is_char_lower(chr))
+	{
+		return (chr & ~(1<<5));
+	}
+
+	return chr;
+}
+
+/**
+ * Returns a lowercase character to an uppercase character.
+ *
+ * @note Only available in 1.8.3 and above.
+ *
+ * @param chr           Characer to convert.
+ * @return              Uppercase character on success,
+ *                      no change on failure.
+ */
+stock char_to_lower(chr)
+{
+	if (is_char_upper(chr))
+	{
+		return (chr | (1<<5));
+	}
+
+	return chr;
+}
+
+/**
+ * Backwards compatibility stock - use argbreak or argparse.
+ * @deprecated          this function does not work properly.
+ */
+#pragma deprecated Use argbreak() instead
+stock strbreak(const text[], Left[], leftLen, Right[], rightLen)
+{
+	return argbreak(text, Left, leftLen, Right, rightLen);
+}
+
+/**
+ * Emulates strbreak() using argparse().
+ *
+ * @param text          Source input string.
+ * @param left          Buffer to store string left part.
+ * @param leftlen       Maximum length of the string part buffer.
+ * @param right         Buffer to store string right part.
+ * @param rightlen      Maximum length of the string part buffer.
+ *
+ * @return              -1 if no match was found; otherwise, an index into source
+ *                      marking the first index after the searched text.  The
+ *                      index is always relative to the start of the input string.
+ */
+stock argbreak(const text[], left[], leftlen, right[], rightlen)
+{
+	new pos = argparse(text, 0, left, leftlen);
+
+	if (pos == -1)
+	{
+		return -1;
+	}
+
+	new textlen = strlen(text);
+
+	while (pos < textlen && isspace(text[pos]))
+	{
+		pos++;
+	}
+
+	copy(right, rightlen, text[pos]);
+
+	return pos;
+}
+
+/**
+ * It is basically strbreak but you have a delimiter that is more than one character in length. By Suicid3.
+ *
+ * @param szInput       Source input string.
+ * @param szLeft        Buffer to store left string part.
+ * @param pL_Max        Maximum length of the string part buffer.
+ * @param szRight       Buffer to store right string part.
+ * @param pR_Max        Maximum length of the string part buffer.
+ * @param szDelim       A string which specifies a search point to break at.
+ *
+ * @noreturn
+ */
+stock split(const szInput[], szLeft[], pL_Max, szRight[], pR_Max, const szDelim[])
+{
+	new iEnd = contain(szInput, szDelim);
+	new iStart = iEnd + strlen(szDelim);
+
+	// If delimiter isnt in Input just split the string at max lengths
+	if (iEnd == -1)
+	{
+		iStart = copy(szLeft, pL_Max, szInput);
+		copy(szRight, pR_Max, szInput[iStart]);
+		return;
+	}
+
+	// If delimter is in Input then split at input for max lengths
+	if (pL_Max >= iEnd)
+		copy(szLeft, iEnd, szInput);
+	else
+		copy(szLeft, pL_Max, szInput);
+
+	copy(szRight, pR_Max, szInput[iStart]);
+}
+
+/**
+ * Removes a path from szFilePath leaving the name of the file in szFile for a pMax length.
+ *
+ * @param szFilePath    String to perform search and replacements on.
+ * @param szFile        Buffer to store file name.
+ * @param pMax          Maximum length of the string buffer.
+ *
+ * @noreturn
+ */
+stock remove_filepath(const szFilePath[], szFile[], pMax)
+{
+	new len = strlen(szFilePath);
+
+	while ((--len >= 0) && (szFilePath[len] != '/') && (szFilePath[len] != '\')) { }
+
+	copy(szFile, pMax, szFilePath[len + 1]);
+
+	return;
+}
+
+/**
+ * Replaces a contained string iteratively.
+ *
+ * @note Consider using replace_string() instead.
+ *
+ * @note This ensures that no infinite replacements will take place by
+ *       intelligently moving to the next string position each iteration.
+ *
+ * @param string    String to perform search and replacements on.
+ * @param len       Maximum length of the string buffer.
+ * @param what      String to search for.
+ * @param with      String to replace the search string with.
+ *
+ * @return          Number of replacements on success, otherwise 0.
+ */
+stock replace_all(string[], len, const what[], const with[])
+{
+	new pos = 0;
+
+	if ((pos = contain(string, what)) == -1)
+	{
+		return 0;
+	}
+
+	new total = 0;
+	new with_len = strlen(with);
+	new diff = strlen(what) - with_len;
+	new total_len = strlen(string);
+	new temp_pos = 0;
+
+	while (replace(string[pos], len - pos, what, with) != 0)
+	{
+		total++;
+
+		/* jump to position after replacement */
+		pos += with_len;
+
+		/* update cached length of string */
+		total_len -= diff;
+
+		/* will the next call be operating on the last character? */
+		if (pos >= total_len)
+		{
+			break;
+		}
+
+		/* find the next position from our offset */
+		temp_pos = contain(string[pos], what);
+
+		/* if it's invalid, we're done */
+		if (temp_pos == -1)
+		{
+			break;
+		}
+
+		/* otherwise, reposition and update counters */
+		pos += temp_pos;
+	}
+
+	return total;
+}
+
+/**
+ * Breaks a string into pieces and stores each piece into an array of buffers.
+ *
+ * @param text              The string to split.
+ * @param split             The string to use as a split delimiter.
+ * @param buffers           An array of string buffers (2D array).
+ * @param maxStrings        Number of string buffers (first dimension size).
+ * @param maxStringLength   Maximum length of each string buffer.
+ * @param copyRemainder     False (default) discard excess pieces, true to ignore
+ *                          delimiters after last piece.
+ * @return                  Number of strings retrieved.
+ */
+stock explode_string(const text[], const split[], buffers[][], maxStrings, maxStringLength, bool:copyRemainder = false)
+{
+	new reloc_idx, idx, total;
+
+	if (maxStrings < 1 || !split[0])
+	{
+		return 0;
+	}
+
+	while ((idx = split_string(text[reloc_idx], split, buffers[total], maxStringLength)) != -1)
+	{
+		reloc_idx += idx;
+		if (++total == maxStrings)
+		{
+			if (copyRemainder)
+			{
+				copy(buffers[total-1], maxStringLength, text[reloc_idx-idx]);
+			}
+			return total;
+		}
+	}
+
+	copy(buffers[total++], maxStringLength, text[reloc_idx]);
+
+	return total;
+}
+
+/**
+ * Joins an array of strings into one string, with a "join" string inserted in
+ * between each given string.  This function complements ExplodeString.
+ *
+ * @param strings       An array of strings.
+ * @param numStrings    Number of strings in the array.
+ * @param join          The join string to insert between each string.
+ * @param buffer        Output buffer to write the joined string to.
+ * @param maxLength     Maximum length of the output buffer.
+ * @return              Number of bytes written to the output buffer.
+ */
+stock implode_strings(const strings[][], numStrings, const join[], buffer[], maxLength)
+{
+	new total, length, part_length;
+	new join_length = strlen(join);
+
+	for (new i=0; i<numStrings; i++)
+	{
+		length = copy(buffer[total], maxLength-total, strings[i]);
+		total += length;
+
+		if (length < part_length)
+		{
+			break;
+		}
+
+		if (i != numStrings - 1)
+		{
+			length = copy(buffer[total], maxLength-total, join);
+			total += length;
+
+			if (length < join_length)
+			{
+				break;
+			}
+		}
+	}
+
+	return total;
+}

package/amxmodx/base/include/textparse_ini.inc

@@ -0,0 +1,214 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// INI Parser Functions
+//
+
+#if defined _textparse_ini_included
+	#endinput
+#endif
+#define _textparse_ini_included
+
+/**
+ * This parser API is entirely event based.  
+ * You must hook events to receive data.
+ */
+ 
+/**
+ * The INI file format is defined as:
+ *    WHITESPACE: 0x20, \n, \t, \r
+ *    IDENTIFIER: A-Z a-z 0-9 _ - , + . $ ? / 
+ *    STRING    : Any set of symbols
+ * 
+ * Basic syntax is comprised of SECTIONs.
+ *    A SECTION is defined as:
+ *    [SECTIONNAME]
+ *    OPTION
+ *    OPTION
+ *    OPTION...
+ *
+ * SECTIONNAME is an IDENTIFIER.
+ *    OPTION can be repeated any number of times, once per line.
+ *    OPTION is defined as one of:
+ *      KEY = "VALUE"
+ *      KEY = VALUE
+ *      KEY
+ *    Where KEY is an IDENTIFIER and VALUE is a STRING.
+ * 
+ * WHITESPACE should always be omitted.
+ *    COMMENTS should be stripped, and are defined as text occurring in:
+ *    ;<TEXT>
+ * 
+ * Example file below.  Note that the second line is technically invalid.  
+ * The event handler must decide whether this should be allowed.
+ *    --FILE BELOW--
+ *    [gaben]
+ *    hi = clams
+ *    bye = "NO CLAMS"
+ *
+ *    [valve]
+ *    cannot
+ *    maintain
+ *    products
+ */
+  
+/**
+ * Parser invalid code.
+ */
+enum INIParser
+{
+	Invalid_INIParser = 0
+};
+
+/**
+ * Creates a new INI parser.  
+ * This is used to set parse hooks.
+ *
+ * @return              A new handle to an INI Parse structure.
+ */
+native INIParser:INI_CreateParser();
+
+/**
+ * Disposes of an INI parser.
+ *
+ * @param handle        Handle to an INI Parse structure.
+ *
+ * @return              True if disposed, false otherwise.
+ */
+native INI_DestroyParser(&INIParser:handle);
+
+/**
+ * Parses an INI config file.
+ *
+ * @param handle        A handle to an INI Parse structure.
+ * @param file          A string containing the file path.
+ * @param line          An optional by reference cell to store the last line number read.
+ * @param col           An optional by reference cell to store the last column number read.
+ * @param data          An optional handle or value to pass through to callback functions
+ *
+ * @return              An SMCParseError result.
+ * @error               Invalid or corrupt handle. 
+ */
+native bool:INI_ParseFile(INIParser:handle, const file[], &line = 0, &col = 0, any:data = 0);
+
+/**
+ * Sets the INI_ParseStart function of a parse handle.
+ *
+ * @note  Below is the prototype of callback:
+ *        -
+ *          Called when parsing is started.
+ *
+ *          @param handle        A handle to an INI Parse structure.
+ *          @param data          Handle or value passed in INI_ParseFile
+ *
+ *          @noreturn
+ *
+ *          public OnParseStart(INIParser:handle, any:data)
+ *        -
+ * @param handle        Handle to an INI Parse structure.
+ * @param func          A ParseStart callback.
+ *
+ * @noreturn
+ * @error               Invalid or corrupt handle. 
+ */
+native INI_SetParseStart(INIParser:handle, const func[]);
+
+/**
+ * Sets the INI_ParseEnd function of a parse handle.
+ *
+ * @note  Below is the prototype of callback:
+ *        -
+ *          Called when parsing is halted.
+ *
+ *          @param handle        A handle to an INI Parse structure.
+ *          @param halted        True if abnormally halted, false otherwise.
+ *          @param data          Handle or value passed in INI_ParseFile
+ *
+ *          @noreturn
+ *
+ *          public OnParseEnd(INIParser:handle, bool:halted, any:data)
+ *        -
+ * @param handle        Handle to an INI Parse structure.
+ * @param func          A ParseEnd callback.
+ *
+ * @noreturn
+ * @error               Invalid or corrupt handle. 
+ */
+native INI_SetParseEnd(INIParser:handle, const func[]);
+
+/**
+ * Sets the two main reader functions.
+ *
+ * @note  Below is the prototype of callback:
+ *        -
+ *          NewSection: 
+ *              Called when the parser finds a new section.
+ *
+ *              @param handle           Handle to an INI Parse structure.
+ *              @param section          Name of section in between the [ and ] characters.
+ *              @param invalid_tokens   True if invalid tokens were detected in the name.
+ *              @param close_bracket    True if a closing bracket was detected, false otherwise.
+ *              @param extra_tokens     True if extra tokens were detected on the line.
+ *              @param curtok           Contains current token in the line where the section name starts.
+ *                                      You can add to this offset when failing to point to a token.
+ *              @param data             Handle or value passed in INI_ParseFile
+ *
+ *              @return                 True to keep parsing, false otherwise.
+ *
+ *              public bool:OnNewSection(INIParser:handle, const section[], bool:invalid_tokens, bool:close_bracket, bool:extra_tokens, curtok, any:data)
+ *
+ *          KeyValue: 
+ *              Called when the parser finds a new key/value pair.
+ *
+ *              @param handle           Handle to an INI Parse structure.
+ *              @param key              Name of key.
+ *              @param value            String containing value (with quotes stripped, if any).
+ *              @param invalid_tokens   Whether or not the key contained invalid tokens.
+ *              @param equal_token      There was an '=' sign present (in case the value is missing).
+ *              @param quotes           Whether value was enclosed in quotes.
+ *              @param curtok           Contains the token index of the start of the value string.  
+ *                                      This can be changed when returning false.
+ *              @param data             Handle or value passed in INI_ParseFile
+ *
+ *              @return                 True to keep parsing, false otherwise.
+ * 
+ *              public bool:OnKeyValue(INIParser:handle, const key[], const value[], bool:invalid_tokens, bool:equal_token, bool:quotes, curtok, any:data)
+ *        -  
+ * @param handle        Handle to an INI Parse structure.
+ * @param kv            A KeyValue callback. 
+ * @param ns            An optional NewSection callback. 
+ *
+ * @noreturn
+ */
+native INI_SetReaders(INIParser:smc, const kvFunc[], const nsFunc[] = "" );
+
+/**
+ * Sets a raw line reader on an INI parser handle.
+ *
+ * @note  Below is the prototype of callback:
+ *        -
+ *          Called whenever a raw line is read.
+ *
+ *          @param handle       The INI Parse handle.
+ *          @param line         Contents of line.
+ *          @param lineno       The line number it occurs on.
+ *          @param curtok       Pointer to optionally store failed position in string.
+ *          @param data         Handle or value passed in INI_ParseFile
+ *
+ *          @return             True to keep parsing, false otherwise.
+ *
+ *          public bool:OnRawLine(INIParser:smc, const line[], lineno, curtok, any:data)
+ *
+ * @param handle        Handle to an INI Parse structure.
+ * @param func          A RawLine callback.
+ *
+ * @noreturn
+ */
+native INI_SetRawLine(INIParser:handle, const func[]);