Interpretador de brainfuck.

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

// BrainFuck Interpretar - PAWN .. 
 
#include <iostream>
 
#include "SDK\amx\amx.h"
#include "SDK\plugincommon.h"
 
char data[30000];
char *d;
const char *p;
 
typedef void (*logprintf_t)(char* format, ...);
 
logprintf_t logprintf;
extern void *pAMXFunctions;
 
void concatenate_string(char*, char*);
 
void concatenate_string(char *original, char *add)
{
   while(*original)
      original++;
 
   while(*add)
   {
      *original = *add;
      add++;
 
      original++;
   }
 
   *original = '\0';
}
 
/* _BFInterpret(dest[], code[], len = sizeof); */
cell AMX_NATIVE_CALL _BFInterpret(AMX* amx, cell* params)
{
 
	char *string = NULL;
	int _loop;
	cell *buf = NULL;
	char *file = new char;
 
	amx_StrParam(amx, params[2], string);
	if((string ? string : NULL) != NULL){
		 d = data;
		 p = string;
 
		 while (*p) 
		 {
			switch (*p) 
			{
				case '>':
				{
					d++;
					break;
				}
				case '<':
				{
					d--;
					break;
				}
				case '+':
				{
					(*d)++;
					break;
				}
				case '-':
				{
					(*d)--;
					break;
				}
				case '.':
				{ 
					concatenate_string(file, d);
					break;
				}
				case '[':
				{
					_loop = 1;
					if (*d == '\0') 
					{
						do 
						{
							p++;
							if(*p == '[')
							{
								_loop++;
							}
							else if(*p == ']')
							{
								_loop--;
							}
						} while ( _loop != 0 );
					}
					break;
				}
				case ']':
				{
					_loop = 0;
					do 
					{
						if (*p == '['){
							_loop++;
						}
						else if (*p == ']'){
							_loop--;
						}
						p--;
					} while (_loop != 0 );
					break;
				}
			}
			p++;
		}
 
		amx_GetAddr(amx, params[1], &buf);
		amx_SetString(buf, file, 0, 0, params[3] > 0 ? params[3] : strlen(file) + 1);
 
    }
    return 1;
}
 
PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports() 
{
    return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES;
}
 
PLUGIN_EXPORT bool PLUGIN_CALL Load(void **ppData) 
{
    pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
    logprintf = (logprintf_t) ppData[PLUGIN_DATA_LOGPRINTF];
 
    logprintf(" * BrainFuck Interpreter Loaded!");
    return true;
}
 
PLUGIN_EXPORT void PLUGIN_CALL Unload()
{
    logprintf(" * BrainFuck Interpreter Unload!");
}
 
AMX_NATIVE_INFO PluginNatives[] =
{
    {"_BFInterpret", _BFInterpret},
    {0, 0}
};
 
 
PLUGIN_EXPORT int PLUGIN_CALL AmxLoad( AMX *amx ) 
{
    return amx_Register(amx, PluginNatives, -1);
}
 
 
PLUGIN_EXPORT int PLUGIN_CALL AmxUnload( AMX *amx ) 
{
    return AMX_ERR_NONE;
}

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

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);
}