API tools faq
paste
Guest User

Untitled

a guest
May 7th, 2013
651
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.17 KB | None | 0 0
raw download clone embed print report
  1. /*=================================================================
  2. _ ____ _____ __ __
  3. (_) _ \ ___ |_ _|__ __ _| \/ |
  4. | | |_) / __| | |/ _ \/ _` | |\/| |
  5. | | __/\__ \ | | __/ (_| | | | |
  6. |_|_| |___/ |_|\___|\__,_|_| |_|
  7.  
  8. Created by Bruno da Silva
  9. www.ips-team.blogspot.com
  10. sscanf Compactible with 0.3d Version!
  11.  
  12. =================================================================*/
  13.  
  14. ////////////////////////////////////////////////////////////
  15. //
  16. //
  17. // Versão atual: 13/09/2011 - 18:20
  18. // Versão: Testes Beta (próximo lançamento 15/11)
  19. //
  20. // Returns:
  21. // false: error and true: sucess
  22. //
  23. // Format:
  24. // u - name or id player
  25. // s ~ z - string
  26. // i ~ d - numbers
  27. // c - caractere
  28. // f - float
  29. // r(iszd) - reverte string/número/float
  30. // p<delimiter> - novo delimitador
  31. // e<formatenum> - alocar formatação na enum
  32. // a<formatarray> - alocar formatação aqui
  33. // g(searchstring) - procurar string e retornar o inicio e o fim dela
  34. // {comentários na formatação}
  35. //
  36. //
  37. //
  38. // NOT FINISHED (security problems)
  39. //
  40. // Autor: [iPs] BrunoSilva (Copyright iPsTeaM)
  41. // Thank Y_Less (designed it from the script his)
  42. //
  43. // www.ips-team.blogspot.com
  44. //
  45. ///////////////////////////////////////////////////////////
  46.  
  47.  
  48. sscanf(string[], format[],{Float,_}:...)
  49. {
  50.  
  51. #if !defined isNull
  52. #define isNull(%0) (!%0[0] || %0[0] == '\1' && !%0[1])
  53. #endif
  54.  
  55. #if defined strcpy
  56. #undef strcpy
  57. #endif
  58.  
  59. #if !defined foreach
  60. #define foreach(%0,%1) for (new %1 = 0; %1 != MAX_PLAYERS; ++%1) if(IsPlayerConnected(%1))
  61. #endif
  62.  
  63. #define strcpy(%0,%1) strcat((%0[0] = '\0', %0), %1, sizeof(%0))
  64.  
  65. #define MAX_BUFFER 128
  66.  
  67. if(isNull(string))
  68. {
  69. return false;
  70.  
  71. }
  72.  
  73. new
  74. formatCount = -1,
  75. stringCount = -1,
  76. paramsCount = 2,
  77. delim = 0x20,
  78. bool:silentMod = false,
  79. totalParams = numargs()
  80. ;
  81.  
  82. static
  83. temporaria[MAX_BUFFER]
  84. ;
  85.  
  86. strcpy(temporaria, string);
  87.  
  88. #pragma unused string
  89.  
  90. while(format[++formatCount])
  91. {
  92. switch(format[formatCount])
  93. {
  94. case '{':
  95.  
  96. {
  97. silentMod = true;
  98. continue;
  99.  
  100. }
  101.  
  102. case '}':
  103.  
  104. {
  105. silentMod = false;
  106. continue;
  107.  
  108. }
  109.  
  110.  
  111. }
  112.  
  113. if(silentMod)
  114. {
  115. continue;
  116.  
  117.  
  118. }
  119.  
  120. switch(format[formatCount])
  121. {
  122. case 'i', 'd':
  123.  
  124. {
  125. new
  126. numero,
  127. caractere = temporaria[stringCount + 1],
  128. negativo = 1 ;
  129.  
  130. if(caractere == '-')
  131. {
  132. ++stringCount;
  133. negativo = -1;
  134.  
  135. }
  136.  
  137. while((caractere = temporaria[++stringCount]) != delim && caractere)
  138. {
  139. if ('0' <= caractere <= '9')
  140. {
  141. numero = (numero * 10) + (caractere - '0');
  142.  
  143. }
  144. else
  145. {
  146. return false;
  147.  
  148. }
  149.  
  150.  
  151. }
  152.  
  153. setarg(paramsCount, 0, numero * negativo);
  154. ++paramsCount;
  155. continue;
  156.  
  157.  
  158. }
  159.  
  160. case 'f':
  161.  
  162. {
  163.  
  164. new sscanfValor = -1;
  165.  
  166. new
  167. stringFloat[15]
  168. ;
  169.  
  170. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  171. {
  172. stringFloat[++sscanfValor] = temporaria[stringCount];
  173.  
  174. }
  175.  
  176. if(sscanfValor != -1)
  177. {
  178. setarg(paramsCount, 0, _:floatstr(stringFloat));
  179. ++paramsCount;
  180. }
  181.  
  182. #pragma unused sscanfValor
  183. continue;
  184.  
  185.  
  186. }
  187.  
  188. case 'u':
  189.  
  190. {
  191. new
  192. texto,
  193. tempVal = stringCount,
  194. stringTemp[MAX_BUFFER],
  195. caractere = temporaria[stringCount + 1] ;
  196.  
  197. while((caractere = temporaria[++tempVal]) != delim && temporaria[stringCount]) if ('0' > caractere || '9' < caractere)
  198. {
  199. texto = 1;
  200. break;
  201.  
  202. }
  203.  
  204. if(!texto)
  205. {
  206. while((caractere = temporaria[++stringCount])!= delim && caractere)
  207. {
  208. texto = (texto * 10) + (caractere - '0');
  209.  
  210.  
  211. }
  212. texto = 10;
  213. setarg(paramsCount, 0, texto);
  214.  
  215.  
  216. }
  217. else
  218. {
  219. texto = -1;
  220. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  221. {
  222. stringTemp[++texto] = temporaria[stringCount];
  223.  
  224. }
  225.  
  226. foreach(Player, i)
  227. {
  228. static
  229. name[MAX_PLAYER_NAME]
  230. ;
  231.  
  232. GetPlayerName(i, name, MAX_PLAYER_NAME);
  233. if(-1 != strfind(name, stringTemp, true))
  234. {
  235. setarg(paramsCount, 0, i);
  236. texto = 10;
  237. break;
  238.  
  239.  
  240. }
  241.  
  242.  
  243. }
  244.  
  245.  
  246. }
  247.  
  248. if(10 != texto)
  249. {
  250. setarg(paramsCount, 0, -1);
  251.  
  252. }
  253.  
  254. ++paramsCount;
  255. continue;
  256.  
  257.  
  258. }
  259.  
  260. case 's', 'z':
  261.  
  262. {
  263. new
  264. sscanfValor = -1
  265. ;
  266.  
  267. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  268. {
  269. setarg(paramsCount, ++sscanfValor, temporaria[stringCount]);
  270.  
  271. }
  272.  
  273. if(sscanfValor != -1)
  274. {
  275. ++paramsCount;
  276.  
  277. }
  278. #pragma unused sscanfValor
  279. continue;
  280.  
  281.  
  282. }
  283.  
  284. case 'c':
  285.  
  286. {
  287. if(!temporaria[++stringCount]) return false;
  288. setarg(paramsCount, 0, temporaria[stringCount]);
  289. continue;
  290.  
  291.  
  292. }
  293.  
  294. case '(':
  295.  
  296. {
  297. switch(format[formatCount - 1])
  298. {
  299. case 'g':
  300.  
  301. {
  302. new
  303. findString[MAX_BUFFER],
  304. sscanfValor = -1
  305. ;
  306.  
  307. while(format[++formatCount] != ')')
  308. {
  309. findString[++sscanfValor] = format[formatCount];
  310.  
  311. }
  312.  
  313. if(-1 != sscanfValor)
  314. {
  315. sscanfValor = strfind(temporaria, findString, true);
  316. if(-1 != sscanfValor)
  317. {
  318. setarg(paramsCount, 0, sscanfValor);
  319. stringCount = sscanfValor+strlen(findString)+1;
  320. setarg(++paramsCount, 0, stringCount);
  321.  
  322. }
  323.  
  324. }
  325.  
  326. ++paramsCount;
  327. #pragma unused sscanfValor
  328. continue;
  329.  
  330.  
  331. }
  332.  
  333. case 'r':
  334.  
  335.  
  336. {
  337. while(format[++formatCount] )
  338. {
  339.  
  340. switch(format[formatCount])
  341. {
  342. case ')':
  343.  
  344. {
  345. break;
  346.  
  347. }
  348.  
  349. case 's' , 'z':
  350.  
  351. {
  352. new
  353. sscanfValor = -1,
  354. bufferString[MAX_BUFFER] ;
  355.  
  356. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  357. {
  358. bufferString[++sscanfValor] = temporaria[stringCount];
  359.  
  360.  
  361. }
  362.  
  363. new
  364. i = sscanfValor
  365. ;
  366.  
  367. sscanfValor = -1;
  368.  
  369. for( ; 0xFFFFFFFF != i; --i)
  370. {
  371. setarg(paramsCount, ++sscanfValor, bufferString[i]);
  372.  
  373.  
  374. }
  375.  
  376. if(sscanfValor != -1)
  377. {
  378. ++paramsCount;
  379.  
  380. }
  381. #pragma unused sscanfValor
  382.  
  383. }
  384.  
  385. case 'f':
  386.  
  387.  
  388. {
  389. new
  390. sscanfValor = -1,
  391. stringFloat[MAX_BUFFER] ;
  392.  
  393. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  394. {
  395. stringFloat[++sscanfValor] = temporaria[stringCount];
  396.  
  397.  
  398. }
  399.  
  400. new
  401. i = sscanfValor
  402. ;
  403.  
  404. sscanfValor = -1;
  405.  
  406. for( ; -1 != i; --i)
  407. {
  408. stringFloat[++sscanfValor] = stringFloat[i];
  409.  
  410. }
  411.  
  412. if(sscanfValor != -1)
  413. {
  414. setarg(++paramsCount, 0, _:floatstr(stringFloat));
  415.  
  416. }
  417. #pragma unused sscanfValor
  418.  
  419.  
  420. }
  421.  
  422. case 'd' , 'i':
  423.  
  424.  
  425. {
  426. new
  427. sscanfValor = -1,
  428. stringValue[MAX_BUFFER] ;
  429.  
  430. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  431. {
  432. stringValue[++sscanfValor] = temporaria[stringCount];
  433.  
  434.  
  435. }
  436.  
  437. new
  438. i = sscanfValor
  439. ;
  440.  
  441. sscanfValor = -1;
  442.  
  443. for( ; -1 != i; --i)
  444. {
  445. stringValue[++sscanfValor] = stringValue[i];
  446.  
  447. }
  448.  
  449. if(sscanfValor != -1)
  450. {
  451. setarg(++paramsCount, 0, strval(stringValue));
  452.  
  453. }
  454. #pragma unused sscanfValor
  455.  
  456. }
  457.  
  458. }
  459.  
  460. }
  461. continue;
  462.  
  463.  
  464. }
  465.  
  466. }
  467.  
  468.  
  469. }
  470.  
  471. case '<':
  472.  
  473.  
  474. {
  475. new
  476. paramEnum = -1
  477. ;
  478.  
  479. switch(format[formatCount-1])
  480. {
  481. case 'e' , 'a':
  482.  
  483.  
  484. {
  485. while(format[++formatCount])
  486. {
  487. switch(format[formatCount])
  488. {
  489. case '>':
  490.  
  491. {
  492. break ;
  493.  
  494. }
  495.  
  496. case 'i', 'd':
  497.  
  498.  
  499. {
  500.  
  501. new
  502. numero,
  503. caractere = temporaria[stringCount + 1],
  504. negativo = 1 ;
  505.  
  506. if(caractere == '-')
  507. {
  508.  
  509. ++stringCount;
  510. negativo = -1;
  511.  
  512.  
  513. }
  514.  
  515. while((caractere = temporaria[++stringCount]) != delim && caractere)
  516. {
  517.  
  518. if ('0' <= caractere <= '9')
  519. {
  520. numero = (numero * 10) + (caractere - '0');
  521.  
  522.  
  523. }
  524. else
  525. {
  526. return false;
  527.  
  528.  
  529. }
  530.  
  531.  
  532. }
  533. setarg(paramsCount, ++paramEnum, numero * negativo);
  534. continue;
  535.  
  536.  
  537. }
  538.  
  539. case 'u':
  540.  
  541.  
  542. {
  543. new
  544. texto,
  545. tempVal = stringCount,
  546. stringTemp[MAX_BUFFER],
  547. caractere = temporaria[stringCount + 1] ;
  548.  
  549. while((caractere = temporaria[++tempVal]) != delim && temporaria[stringCount]) if ('0' > caractere || '9' < caractere)
  550. {
  551. texto = 1;
  552. break;
  553.  
  554. }
  555.  
  556. if(!texto)
  557. {
  558. while((caractere = temporaria[++stringCount])!= delim && caractere)
  559. {
  560. texto = (texto * 10) + (caractere - '0');
  561.  
  562. }
  563. texto = 10;
  564.  
  565. setarg(paramsCount, ++paramEnum, texto);
  566.  
  567.  
  568. }
  569. else
  570. {
  571. texto = -1;
  572. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  573. {
  574. stringTemp[++texto] = temporaria[stringCount];
  575.  
  576.  
  577. }
  578.  
  579. foreach(Player, i)
  580. {
  581. static
  582. name[MAX_PLAYER_NAME]
  583. ;
  584.  
  585. GetPlayerName(i, name, MAX_PLAYER_NAME);
  586. if(-1 != strfind(name, stringTemp, true))
  587. {
  588. setarg(paramsCount, ++paramEnum, i);
  589. texto = 10;
  590. break;
  591.  
  592.  
  593. }
  594.  
  595.  
  596. }
  597.  
  598.  
  599. }
  600.  
  601. if(10 != texto)
  602. {
  603. setarg(paramsCount, ++paramEnum, -1) ;
  604.  
  605.  
  606. }
  607. continue;
  608.  
  609.  
  610. }
  611.  
  612. case 'f':
  613.  
  614.  
  615. {
  616. new
  617. sscanfValor = -1,
  618. stringFloat[15] ;
  619.  
  620. while(temporaria[++stringCount] != delim && temporaria[stringCount])
  621. {
  622.  
  623. stringFloat[++sscanfValor] = temporaria[stringCount];
  624.  
  625.  
  626. }
  627.  
  628. if(sscanfValor != -1)
  629. {
  630. setarg(paramsCount, ++paramEnum, _:floatstr(stringFloat));
  631.  
  632.  
  633. }
  634. #pragma unused sscanfValor
  635. continue;
  636.  
  637.  
  638. }
  639.  
  640. case 'c':
  641.  
  642.  
  643. {
  644. setarg(paramsCount, ++paramEnum, temporaria[++stringCount]);
  645. continue;
  646.  
  647.  
  648. }
  649.  
  650.  
  651. }
  652.  
  653.  
  654. }
  655. ++paramsCount;
  656.  
  657.  
  658. }
  659.  
  660. case 'p':
  661.  
  662.  
  663. {
  664.  
  665. delim = format[++formatCount];
  666.  
  667. while(format[++formatCount] != '>') continue;
  668.  
  669.  
  670. }
  671.  
  672.  
  673. }
  674.  
  675.  
  676. }
  677.  
  678.  
  679. }
  680.  
  681. }
  682. return paramsCount == totalParams;
  683. }
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!