SHARE
TWEET

RegEx

Fro Apr 14th, 2011 1,116 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*----------------------------------------------------------------------------------------------------*-
  2.  
  3. Автор:
  4.         Fro он же Fro1sha
  5.        
  6. Описание:
  7.         Regular Expression
  8.  
  9. Права:
  10.     Copyright © 2009-2011 TBG
  11.        
  12.         1)      Запрещается любое коммерческое использование плагина.
  13.         2)      Данный плагин поставляется по принципу "as is"("как есть").
  14.                 Никаких гарантий не прилагается и не предусматривается.
  15.                 Вы используете плагин на свой страх и риск.
  16.                 Авторы не будут отвечать ни за какие потери или искажения данных,
  17.                 любую упущенную выгоду в процессе использования или неправильного использования плагина.
  18.         3)  Вы НЕ имеете права где-либо размещать, а также модифицировать плагин или любую его часть,
  19.                 предварительно не получив согласия Авторов.
  20.         4)  Установка и использование данного плагина означает, что Вы ознакомились и понимаете
  21.                 положения настоящего лицензионного соглашения и согласны с ними.
  22.  
  23.                             ______              __________            
  24.                             ___  /______  __    ___  ____/____________
  25.                             __  __ \_  / / /    __  /_   __  ___/  __ \
  26.                             _  /_/ /  /_/ /     _  __/   _  /   / /_/ /
  27.                             /_.___/_\__, /      /_/      /_/    \____/
  28.                                    /____/                              
  29.                                                                              
  30.                                                                                                                                                                
  31.            _______________       _________                                              
  32.            ___  __/__  __ )      __  ____/_____ _______ ________________ ___________  __
  33.            __  /  __  __  |_______  / __ _  __ `/_  __ `__ \  _ \_  ___/ __  ___/  / / /
  34.            _  /   _  /_/ /_/_____/ /_/ / / /_/ /_  / / / / /  __/(__  )___  /   / /_/ /
  35.            /_/    /_____/        \____/  \__,_/ /_/ /_/ /_/\___//____/_(_)_/    \__,_/  
  36.                                                                                        
  37.  
  38.         http://tb-games.ru/
  39.        
  40. -*----------------------------------------------------------------------------------------------------*/
  41.  
  42.  
  43.  
  44. #define PLUGIN_VERSION                                                  "0.2.1"
  45.  
  46. // -------------------------------------------------------------------------------------*-
  47.  
  48. #ifdef WIN32
  49. #       define WIN32_LEAN_AND_MEAN
  50. #       include <windows.h>
  51. #endif
  52.  
  53. #include <malloc.h>
  54. #include <string.h>
  55.  
  56. #include <boost/intrusive_ptr.hpp>
  57. #include <boost/unordered_map.hpp>
  58.  
  59. #include <boost/regex.hpp>
  60.  
  61. #include "SDK/amx/amx.h"
  62. #include "SDK/plugincommon.h"
  63.  
  64.  
  65. // -------------------------------------------------------------------------------------*-
  66.  
  67. typedef void (* logprintf_t)(char *, ...);
  68.  
  69. // -------------------------------------------------------------------------------------*-
  70.  
  71. #define CHECK_PARAMS(m, n) \
  72.         if (params[0] != (m * 4)) \
  73.         { \
  74.                 logprintf("Erorr native function %s: Expecting %d parameter(s), but found %d", n, m, params[0] / 4); \
  75.                 return 0; \
  76.         }
  77.  
  78. // -------------------------------------------------------------------------------------*-
  79.  
  80. logprintf_t
  81.         logprintf;
  82.  
  83. extern void *
  84.         pAMXFunctions;
  85.  
  86. // -------------------------------------------------------------------------------------*-
  87.  
  88. struct
  89.         RegularExpression
  90. {
  91.         RegularExpression()
  92.         {
  93.                 references = 0;
  94.         }
  95.  
  96.         AMX
  97.                 * amx
  98.         ;
  99.  
  100.         int
  101.                 references
  102.         ;
  103.  
  104.         boost::regex expression;
  105. };
  106.  
  107. // -------------------------------------------------------------------------------------*-
  108.  
  109. typedef boost::intrusive_ptr<RegularExpression> RegEx;
  110.  
  111. boost::unordered_map<int, RegEx> regEx;
  112.  
  113. // -------------------------------------------------------------------------------------*-
  114.  
  115. namespace boost
  116. {
  117.         void intrusive_ptr_add_ref(RegularExpression * regex)
  118.         {
  119.                 ++regex->references;           
  120.         }
  121.  
  122.         void intrusive_ptr_release(RegularExpression * regex)
  123.         {
  124.                 if ( !(--regex->references) )
  125.                 {
  126.                         delete regex;
  127.                 }
  128.         }
  129. }
  130. // -------------------------------------------------------------------------------------*-
  131.  
  132. PLUGIN_EXPORT unsigned int PLUGIN_CALL
  133.         Supports()
  134. {
  135.         return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES;
  136. }
  137.  
  138. // -------------------------------------------------------------------------------------*-
  139.  
  140. PLUGIN_EXPORT bool PLUGIN_CALL
  141.         Load(void ** ppData)
  142. {              
  143.         pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
  144.         logprintf = (logprintf_t)ppData[PLUGIN_DATA_LOGPRINTF];
  145.  
  146.         logprintf("\n\r");
  147.         logprintf("______________________________________\n\r");
  148.         logprintf(" Regular Expression Plugin v"PLUGIN_VERSION" loaded");
  149.         logprintf("______________________________________\n\r");
  150.         logprintf(" By: Fro (c) Copyright <TBG> 2009-2011");
  151.         logprintf("______________________________________\n\r");
  152.         return true;
  153. }
  154.  
  155. // -------------------------------------------------------------------------------------*-
  156.  
  157. PLUGIN_EXPORT void PLUGIN_CALL
  158.         Unload()
  159. {
  160.         logprintf("\n\r");
  161.         logprintf("______________________________________\n\r");
  162.         logprintf(" Regular Expression Plugin v"PLUGIN_VERSION" unloaded");
  163.         logprintf("______________________________________\n\r");
  164. }
  165.  
  166. // -------------------------------------------------------------------------------------*-
  167.  
  168. // native RegEx:regex_build(const expression[]);
  169. static cell AMX_NATIVE_CALL
  170.         n_regex_build(AMX * amx, cell * params)
  171. {
  172.         CHECK_PARAMS(1, "regex_build");
  173.  
  174.         char
  175.                 * expression
  176.         ;      
  177.  
  178.         amx_StrParam(amx, params[1], expression);      
  179.  
  180.         if ( expression )
  181.         {
  182.                 int
  183.                         expID = 1
  184.                 ;
  185.  
  186.                 for ( boost::unordered_map<int, RegEx>::const_iterator e = regEx.begin(); e != regEx.end(); ++e )
  187.                 {
  188.                         if ( e->first != expID )
  189.                         {
  190.                                 break;
  191.                         }
  192.                         ++expID;
  193.                 }
  194.  
  195.                 RegEx
  196.                         exp(new RegularExpression)
  197.                 ;
  198.  
  199.                 exp->amx = amx;
  200.                 exp->expression = expression;
  201.  
  202.                 regEx.insert(std::make_pair(expID, exp));
  203.                 return (cell)expID;
  204.         }
  205.         return 0;
  206. }
  207.  
  208. // -------------------------------------------------------------------------------------*-
  209.  
  210. // native regex_delete(RegEx:expID);
  211. static cell AMX_NATIVE_CALL
  212.         n_regex_delete(AMX * amx, cell * params)
  213. {
  214.         CHECK_PARAMS(1, "regex_delete");
  215.  
  216.         boost::unordered_map<int, RegEx>::iterator e = regEx.find((int)params[1]);
  217.         if ( e != regEx.end() )
  218.         {
  219.                 regEx.quick_erase(e);
  220.                 return 1;
  221.         }
  222.         return 0;
  223. }
  224.  
  225. // -------------------------------------------------------------------------------------*-
  226.  
  227. // native regex_isvalid(RegEx:expID);
  228. static cell AMX_NATIVE_CALL
  229.         n_regex_isvalid(AMX * amx, cell * params)
  230. {
  231.         CHECK_PARAMS(1, "regex_isvalid");
  232.  
  233.         boost::unordered_map<int, RegEx>::iterator e = regEx.find((int)params[1]);
  234.         if ( e != regEx.end() )
  235.         {
  236.                 return 1;
  237.         }
  238.         return 0;
  239. }
  240.  
  241. // -------------------------------------------------------------------------------------*-
  242.  
  243. // native regex_delete_all();
  244. static cell AMX_NATIVE_CALL
  245.         n_regex_delete_all(AMX * amx, cell * params)
  246. {
  247.         if ( !regEx.empty() )
  248.         {
  249.                 regEx.clear();
  250.                 return 1;
  251.         }
  252.         return 0;
  253. }
  254.  
  255. // -------------------------------------------------------------------------------------*-
  256.  
  257. // native regex_match(const string[], const expression[]);
  258. static cell AMX_NATIVE_CALL
  259.         n_regex_match(AMX * amx, cell * params)
  260. {
  261.         CHECK_PARAMS(2, "regex_match");
  262.  
  263.         char
  264.                 * string,
  265.                 * expression
  266.         ;      
  267.  
  268.         amx_StrParam(amx, params[1], string);
  269.         amx_StrParam(amx, params[2], expression);      
  270.  
  271.         if ( string && expression )
  272.         {
  273.                 return (cell)boost::regex_match(string, boost::regex(expression));
  274.         }
  275.         return 0;
  276. }
  277.  
  278. // -------------------------------------------------------------------------------------*-
  279.  
  280. // native regex_search(const string[], const expression[]);
  281. static cell AMX_NATIVE_CALL
  282.         n_regex_search(AMX * amx, cell * params)
  283. {
  284.         CHECK_PARAMS(2, "regex_search");
  285.  
  286.         char
  287.                 * string,
  288.                 * expression
  289.         ;      
  290.  
  291.         amx_StrParam(amx, params[1], string);
  292.         amx_StrParam(amx, params[2], expression);      
  293.  
  294.         if ( string && expression )
  295.         {      
  296.                 return (cell)boost::regex_search(string, boost::regex(expression));
  297.         }
  298.         return 0;
  299. }
  300.  
  301. // -------------------------------------------------------------------------------------*-
  302.  
  303. // regex_replace(const string[], const expression[], const to[], dest[], size = sizeof dest);
  304. static cell AMX_NATIVE_CALL
  305.         n_regex_replace(AMX * amx, cell * params)
  306. {
  307.         CHECK_PARAMS(5, "regex_replace");
  308.  
  309.         char
  310.                 * string,              
  311.                 * expression,
  312.                 * to
  313.         ;      
  314.  
  315.         amx_StrParam(amx, params[1], string);  
  316.         amx_StrParam(amx, params[2], expression);      
  317.         amx_StrParam(amx, params[3], to);
  318.  
  319.         if ( string && expression )
  320.         {
  321.                 std::string
  322.                         text
  323.                 ;
  324.  
  325.                 text.append(string);
  326.  
  327.                 text = boost::regex_replace(text, boost::regex(expression), to);
  328.  
  329.                 cell
  330.                         * buf
  331.                 ;
  332.                 int
  333.                         size = text.length()
  334.                 ;
  335.  
  336.                 if ( (int)params[5] < size ) size = (int)params[5];
  337.                
  338.                 amx_GetAddr(amx, params[4], &buf);
  339.                 amx_SetString(buf, text.c_str(), 0, 0, size + 1);
  340.                 return 1;
  341.         }
  342.         return 0;
  343. }
  344.  
  345. // -------------------------------------------------------------------------------------*-
  346.  
  347. // native regex_match_exid(const string[], RegEx:expID);
  348. static cell AMX_NATIVE_CALL
  349.         n_regex_match_exid(AMX * amx, cell * params)
  350. {
  351.         CHECK_PARAMS(2, "regex_match_exid");
  352.  
  353.         boost::unordered_map<int, RegEx>::iterator e = regEx.find((int)params[2]);
  354.         if ( e != regEx.end() )
  355.         {
  356.                 char
  357.                         * string
  358.                 ;      
  359.  
  360.                 amx_StrParam(amx, params[1], string);
  361.  
  362.                 if ( string )
  363.                 {
  364.                         return (cell)boost::regex_match(string, e->second->expression);
  365.                 }
  366.         }
  367.         return 0;
  368. }
  369.  
  370. // -------------------------------------------------------------------------------------*-
  371.  
  372. // native regex_search_exid(const string[], RegEx:expID);
  373. static cell AMX_NATIVE_CALL
  374.         n_regex_search_exid(AMX * amx, cell * params)
  375. {
  376.         CHECK_PARAMS(2, "regex_search_exid");
  377.  
  378.         boost::unordered_map<int, RegEx>::iterator e = regEx.find((int)params[2]);
  379.         if ( e != regEx.end() )
  380.         {
  381.                 char
  382.                         * string
  383.                 ;      
  384.  
  385.                 amx_StrParam(amx, params[1], string);
  386.  
  387.                 if ( string )
  388.                 {      
  389.                         return (cell)boost::regex_search(string, e->second->expression);
  390.                 }
  391.         }
  392.         return 0;
  393. }
  394.  
  395. // -------------------------------------------------------------------------------------*-
  396.  
  397. // regex_replace_exid(const string[], RegEx:expID, const to[], dest[], size = sizeof dest);
  398. static cell AMX_NATIVE_CALL
  399.         n_regex_replace_exid(AMX * amx, cell * params)
  400. {
  401.         CHECK_PARAMS(5, "regex_replace_exid");
  402.  
  403.         boost::unordered_map<int, RegEx>::iterator e = regEx.find((int)params[2]);
  404.         if ( e != regEx.end() )
  405.         {
  406.                 char
  407.                         * string,              
  408.                         * to
  409.                 ;      
  410.  
  411.                 amx_StrParam(amx, params[1], string);  
  412.                 amx_StrParam(amx, params[3], to);
  413.  
  414.                 if ( string )
  415.                 {
  416.                         std::string
  417.                                 text
  418.                         ;
  419.  
  420.                         text.append(string);
  421.  
  422.                         text = boost::regex_replace(text, e->second->expression, to);
  423.  
  424.                         cell
  425.                                 * buf
  426.                         ;
  427.                         int
  428.                                 size = text.length()
  429.                         ;
  430.  
  431.                         if ( (int)params[5] < size ) size = (int)params[5];
  432.                        
  433.                         amx_GetAddr(amx, params[4], &buf);
  434.                         amx_SetString(buf, text.c_str(), 0, 0, size + 1);
  435.                         return 1;
  436.                 }
  437.         }
  438.         return 0;
  439. }
  440.  
  441. // -------------------------------------------------------------------------------------*-
  442.  
  443. AMX_NATIVE_INFO
  444.         regex_natives[] =
  445. {
  446.         { "regex_build", n_regex_build },
  447.         { "regex_delete", n_regex_delete },
  448.         { "regex_isvalid", n_regex_isvalid },
  449.         { "regex_delete_all", n_regex_delete_all },
  450.  
  451.         { "regex_match", n_regex_match },
  452.         { "regex_search", n_regex_search },
  453.         { "regex_replace", n_regex_replace },
  454.  
  455.         { "regex_match_exid", n_regex_match_exid },
  456.         { "regex_search_exid", n_regex_search_exid },
  457.         { "regex_replace_exid", n_regex_replace_exid },
  458.  
  459.         { 0, 0 }
  460. };
  461.  
  462. // -------------------------------------------------------------------------------------*-
  463.  
  464. PLUGIN_EXPORT int PLUGIN_CALL
  465.         AmxLoad(AMX * amx)
  466. {
  467.         return amx_Register(amx, regex_natives, -1);
  468. }
  469.  
  470. // -------------------------------------------------------------------------------------*-
  471.  
  472. PLUGIN_EXPORT int PLUGIN_CALL
  473.         AmxUnload(AMX * amx)
  474. {
  475.         boost::unordered_map<int, RegEx>::const_iterator e = regEx.begin();
  476.         while ( e != regEx.end() )
  477.         {
  478.                 if ( e->second->amx == amx )
  479.                 {
  480.                         regEx.quick_erase(e);
  481.                 }
  482.                 else
  483.                 {
  484.                         ++e;
  485.                 }
  486.         }
  487.         return AMX_ERR_NONE;
  488. }
  489.  
  490. // -------------------------------------------------------------------------------------*-
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top