Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: BoredGuest en 31 Enero 2015, 05:00 am


Título: Interpretador de brainfuck.
Publicado por: BoredGuest en 31 Enero 2015, 05:00 am
Hola gente! estoy haciendo un plugin utilizando el SDK de una edición de un juego online que utiliza Pawn para la creación de sus modos de juego para interpretar códigos BrainFuck, me topé con un problema y no sé como resolverlo, seguramente sea sencillo pero estoy perdido  :rolleyes:

Código
  1. // BrainFuck Interpretar - PAWN .. 
  2.  
  3. #include <iostream>
  4.  
  5. #include "SDK\amx\amx.h"
  6. #include "SDK\plugincommon.h"
  7.  
  8. char data[30000];
  9. char *d;
  10. const char *p;
  11.  
  12. typedef void (*logprintf_t)(char* format, ...);
  13.  
  14. logprintf_t logprintf;
  15. extern void *pAMXFunctions;
  16.  
  17. void concatenate_string(char*, char*);
  18.  
  19. void concatenate_string(char *original, char *add)
  20. {
  21.    while(*original)
  22.       original++;
  23.  
  24.    while(*add)
  25.    {
  26.       *original = *add;
  27.       add++;
  28.  
  29.       original++;
  30.    }
  31.  
  32.    *original = '\0';
  33. }
  34.  
  35. /* _BFInterpret(dest[], code[], len = sizeof); */
  36. cell AMX_NATIVE_CALL _BFInterpret(AMX* amx, cell* params)
  37. {
  38.  
  39. 	char *string = NULL;
  40. 	int _loop;
  41. 	cell *buf = NULL;
  42. 	char *file = new char;
  43.  
  44. 	amx_StrParam(amx, params[2], string);
  45. 	if((string ? string : NULL) != NULL){
  46. 		 d = data;
  47. 		 p = string;
  48.  
  49. 		 while (*p) 
  50. 		 {
  51. 			switch (*p) 
  52. 			{
  53. 				case '>':
  54. 				{
  55. 					d++;
  56. 					break;
  57. 				}
  58. 				case '<':
  59. 				{
  60. 					d--;
  61. 					break;
  62. 				}
  63. 				case '+':
  64. 				{
  65. 					(*d)++;
  66. 					break;
  67. 				}
  68. 				case '-':
  69. 				{
  70. 					(*d)--;
  71. 					break;
  72. 				}
  73. 				case '.':
  74. 				{ 
  75. 					concatenate_string(file, d);
  76. 					break;
  77. 				}
  78. 				case '[':
  79. 				{
  80. 					_loop = 1;
  81. 					if (*d == '\0') 
  82. 					{
  83. 						do 
  84. 						{
  85. 							p++;
  86. 							if(*p == '[')
  87. 							{
  88. 								_loop++;
  89. 							}
  90. 							else if(*p == ']')
  91. 							{
  92. 								_loop--;
  93. 							}
  94. 						} while ( _loop != 0 );
  95. 					}
  96. 					break;
  97. 				}
  98. 				case ']':
  99. 				{
  100. 					_loop = 0;
  101. 					do 
  102. 					{
  103. 						if (*p == '['){
  104. 							_loop++;
  105. 						}
  106. 						else if (*p == ']'){
  107. 							_loop--;
  108. 						}
  109. 						p--;
  110. 					} while (_loop != 0 );
  111. 					break;
  112. 				}
  113. 			}
  114. 			p++;
  115. 		}
  116.  
  117. 		amx_GetAddr(amx, params[1], &buf);
  118. 		amx_SetString(buf, file, 0, 0, params[3] > 0 ? params[3] : strlen(file) + 1);
  119.  
  120.     }
  121.     return 1;
  122. }
  123.  
  124. PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports() 
  125. {
  126.     return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES;
  127. }
  128.  
  129. PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData) 
  130. {
  131.     pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
  132.     logprintf = (logprintf_t) ppData[PLUGIN_DATA_LOGPRINTF];
  133.  
  134.     logprintf(" * BrainFuck Interpreter Loaded!");
  135.     return true;
  136. }
  137.  
  138. PLUGIN_EXPORT void PLUGIN_CALL Unload()
  139. {
  140.     logprintf(" * BrainFuck Interpreter Unload!");
  141. }
  142.  
  143. AMX_NATIVE_INFO PluginNatives[] =
  144. {
  145.     {"_BFInterpret", _BFInterpret},
  146.     {0, 0}
  147. };
  148.  
  149.  
  150. PLUGIN_EXPORT int PLUGIN_CALL AmxLoad( AMX *amx ) 
  151. {
  152.     return amx_Register(amx, PluginNatives, -1);
  153. }
  154.  
  155.  
  156. PLUGIN_EXPORT int PLUGIN_CALL AmxUnload( AMX *amx ) 
  157. {
  158.     return AMX_ERR_NONE;
  159. }

El código ya funciona pero no en su totalidad, añade unos carácteres raros:

(http://i.imgur.com/UHdiQHz.png)

tendría que imprimir sólo "Hola amigo!"
pero necesito almacenarla en las variables que se añadan al argumento  :rolleyes:

Código:
native _BFInterpret(const dest[], const code[], len = sizeof(dest));

main()
{
	new
		str[150]
		;
	_BFInterpret(str, "-[------->+<]>-.-[--->+<]>++.---.-----------.-[->+++<]>.[->+++<]>+.++++++++++++.----.--.++++++++.[--->+<]>----.");

	printf("%s", str);
}

Título: Re: Interpretador de brainfuck.
Publicado por: BoredGuest en 31 Enero 2015, 05:01 am

Si lo muestro asi todo bien:

Código:
std::cout << *d;

pero necesito almacenarla en las variables que se añadan al argumento  :rolleyes:

PD: Perdón, creé una respuesta, pensé que estaba editando el tema.

Título: Re: Interpretador de brainfuck.
Publicado por: eferion en 2 Febrero 2015, 08:15 am
Este código tiene bastante lógica de punteros y no es algo obvio de seguir con la mirada... deberías preparar una versión que pudiesemos compilar cada uno en casa sin dependencias. Dado que tu problema no tiene nada que ver con el SDK, deberías ser capaz de eliminar todo ese código hasta lograr una versión mínima que únicamente incorpore la lógica del "brainfuck"


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines