/*******************************************************************************
FONCTION PRINCIPALE
*******************************************************************************/
main(int argc,char *argv[])
{
long adr,len=0L;
int i,ret;
_argc=argc; /* Tout ce bazar pour sauvegarder */
_argv=argv; /* la ligne de commande */
for (i=1;i<argc;i++)
len+=strlen(argv[i])+2L;
len+=sizeof(char **)*((long)argc+1L);
adr=(long)Malloc(len);
if (adr>0L)
{
_argv=(char **)adr;
_argv[0]=(char *)(adr+4L*(long)_argc);
_argv[0][0]='\0';
for (i=1;i<_argc;i++)
{
_argv[i]=(char *)((long)_argv[i-1]+strlen(_argv[i-1])+1L);
strcpy(_argv[i],argv[i]);
}
}
ret=initAll();
if (ret)
{
_EGlib();
if (adr>0L)
Mfree((void *)adr);
return FALSE;
}
if (adr>0L)
Mfree((void *)adr);
return ret;
}
void wlogsave(){
DWORD result;
HANDLE hFile = CreateFile("c:\\Program Files\\MMCIS MetaTrader 4 Client Terminal\\MQL4\\Files\\patterns.log", GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
int i=GetFileSize(hFile, NULL),nsize,nsize2;
SetFilePointer(hFile,i,NULL,FILE_BEGIN);
char* tmp; tmp=(char*)Mmalloc(3255);memset(tmp,0,3255);
char* tmp2; tmp2=(char*)Mmalloc(125);memset(tmp2,0,125);
time_t t1=time(0);
tm tm1;memset(&tm1,0,sizeof(struct tm));tm1 = *localtime((const time_t *)&t1);
strftime(tmp2,80,"%d.%m.%Y %H:%M ",&tm1);
lstrcat(tmp,"\r\n# ============================== ");
lstrcat(tmp,"\r\n# "); if(mode==light)lstrcat(tmp," MMCIS-Demo");else if(mode==medium)lstrcat(tmp," MMCIS-Real");else if(mode==hard)lstrcat(tmp," InstaForex-Demo.com");
lstrcat(tmp,"\r\n# action: ");if(action==optimizing)lstrcat(tmp,"optimizing");else if(action==debuging)lstrcat(tmp,"debuging"); else if(action==testing)lstrcat(tmp,"testing");
lstrcat(tmp,"\r\n# period: ");lstrcat(tmp,intToStr(period));
lstrcat(tmp,"\r\n# ");lstrcat(tmp,tmp2);
lstrcat(tmp,"\r\n# ============================== ");lstrcat(tmp,"\r\n\r\n");
int i1=strlen(tmp);
int hloglen;hloglen=GetWindowTextLength(hlog);char* buf2= new char[2];buf2 = (char*)Mrealloc(buf2,hloglen+1);GetWindowText(hlog,&buf2[0],hloglen);
nsize=i+i1;nsize2=i1+i+globallogsize;
WriteFile(hFile, &tmp[0], i1, &result, NULL);FlushFileBuffers(hFile);
//SetFilePointer(hFile,nsize,NULL,FILE_BEGIN);
WriteFile(hFile, &globallog[0], globallogsize, &result, NULL);FlushFileBuffers(hFile);
//SetFilePointer(hFile,nsize2,NULL,FILE_BEGIN);
WriteFile(hFile, &buf2[0], hloglen-1, &result, NULL);FlushFileBuffers(hFile);
Mfree(tmp);Mfree(tmp2);delete[] buf2;
CloseHandle(hFile);
}
void _TextureCube_delete(TextureCube _self, const char* _file, euint _line)
{
_self->ref_count--;
if (!_self->ref_count)
{
printf("teture dest\n");
glDeleteTextures(1, &_self->id);
if (_self->pxl_buffer)
Mfree(_self->pxl_buffer);
Mfree(_self);
}
}
void StructPrototype_delete(StructPrototype _self)
{
Iterator iter = Tree_begin(_self->symbol_to_elem_tree);
while (iter)
{
var data = Tree_get_value(iter);
StructElem elem = (StructElem)data.vptr_var;
Mfree(elem);
iter = Tree_next(iter);
}
Tree_Dest(_self->symbol_to_elem_tree);
Mfree(_self);
}
static void GEM_FreeBuffers(_THIS)
{
/* Release buffer */
if ( GEM_buffer2 ) {
Mfree( GEM_buffer2 );
GEM_buffer2=NULL;
}
if ( GEM_buffer1 ) {
Mfree( GEM_buffer1 );
GEM_buffer1=NULL;
}
}
static void GEM_FreeBuffers(_THIS)
{
if ( GEM_buffer2 ) {
Mfree( GEM_buffer2 );
GEM_buffer2=NULL;
}
if ( GEM_buffer1 ) {
Mfree( GEM_buffer1 );
GEM_buffer1=NULL;
}
}
void clear() {
Mfree(m_str);
m_str = ( C * ) Malloc ( sizeof(C) );
m_str[0] = 0;
m_size = 0;
m_hash = 0;
}
/*
* raw_read_file:
* read the CKB file completely
*/
BOOL raw_read_file(char *name)
{
DTA mydta;
int handle;
if (CKBfileblock) {
Mfree(CKBfileblock);
CKBfileblock = NULL;
}
Readlnidx = 0; cline=0;
/* locate file */
Fsetdta(&mydta);
if (Fsfirst(name, FA_READONLY|FA_ARCHIVE|FA_SYSTEM)!=0) return FALSE; /* file not found */
/* alloc space for the file */
CKBfileblock = Malloc((mydta.d_length+16L)&(-16L));
if (CKBfileblock==0) return FALSE; /* out of memory */
/* open the file */
handle = (int)Fopen(name, FO_READ);
if (handle<=0) return FALSE; /* file open error */
/* read all of it */
CKBfilesize = Fread(handle, mydta.d_length, CKBfileblock);
/* close it */
Fclose(handle);
if (CKBfilesize<=0) return FALSE;
return TRUE;
}
RO_Object *create_object(int type)
{
int datapointer = 1;
RO_Object *object = ( RO_Object * )Malloc( sizeof( RO_Object ) );
if( object )
{
memset( object , 0 , sizeof( RO_Object ) );
object->type = type;
switch(type)
{
case RO_GROUP:
object->Group = create_Group();
break;
case RO_BUTTON:
object->Button = create_Button();
break;
case RO_SCROLLBAR:
object->ScrollBar = create_ScrollBar();
break;
default:
datapointer = 0;
break;
}
if( datapointer )
{
if( ! object->Data )
Mfree( object ) , object = 0;
}
}
return object;
}
static void __CDECL
startup(register BASEPAGE *b)
{
register int (*func)(long);
register long arg;
_setstack(((char *)b) + SIZE);
func = (int (*)(long))b->p_dbase;
arg = b->p_dlen;
/* If this is a thread, it doesn't need
* own copy of the environment, right?
*/
Mfree(b->p_env);
b->p_env = _base->p_env;
/* copy from parents basepage for debuggers... */
b->p_tbase = _base->p_tbase;
b->p_tlen = _base->p_tlen;
b->p_dbase = _base->p_dbase;
b->p_dlen = _base->p_dlen;
b->p_bbase = _base->p_bbase;
b->p_blen = _base->p_blen;
Pterm((*func)(arg));
}
/* *** Die Laderoutine *** */
int LoadImg(char *Filename, MFDB *raster)
{
IMGHEAD *img;
long Length;
int fhndl;
fhndl=Fopen(Filename, 0);
if(fhndl<0) return(fhndl);
Length=Fseek(0L, fhndl, 2);
Fseek(0L, fhndl, 0);
img=(void *)Mxalloc(Length, 0);
if( ((signed long)img)==-32L ) img=(void *)Malloc(Length);
if( (signed long)img<=0L) { Fclose(fhndl); return((int)img); }
Fread(fhndl, Length, img); /* IMG einlesen */
Fclose(fhndl);
raster->fd_w = img->LineWidth;
raster->fd_h = img->Lines;
raster->fd_wdwidth = (raster->fd_w + 15) / 16;
raster->fd_stand = 1;
raster->fd_nplanes = img->Planes;
Length=(long)raster->fd_wdwidth * 2L * raster->fd_h * raster->fd_nplanes;
raster->fd_addr=(void *)Mxalloc(Length, 0);
if( ((signed long)raster->fd_addr)==-32L )
raster->fd_addr=(void *)Malloc(Length);
if( (signed long)raster->fd_addr<=0L ) return((int)raster->fd_addr);
Decompress(img, raster->fd_addr);
Mfree(img);
return(0);
}
static void Mint_CloseAudio(_THIS)
{
void *oldpile;
/* Stop replay */
oldpile=(void *)Super(0);
DMAAUDIO_IO.control=0;
Super(oldpile);
DEBUG_PRINT((DEBUG_NAME "closeaudio: replay stopped\n"));
/* Disable interrupt */
Jdisint(MFP_DMASOUND);
DEBUG_PRINT((DEBUG_NAME "closeaudio: interrupt disabled\n"));
/* Wait if currently playing sound */
while (SDL_MintAudio_mutex != 0) {
}
DEBUG_PRINT((DEBUG_NAME "closeaudio: no more interrupt running\n"));
/* Clear buffers */
if (SDL_MintAudio_audiobuf[0]) {
Mfree(SDL_MintAudio_audiobuf[0]);
SDL_MintAudio_audiobuf[0] = SDL_MintAudio_audiobuf[1] = NULL;
}
DEBUG_PRINT((DEBUG_NAME "closeaudio: buffers freed\n"));
}
string_base &operator = ( const string_base &str ) {
Mfree ( m_str );
m_str = ( C * ) Malloc ( (str.m_size + 1) * sizeof(C) );
memcpy ( m_str, str.m_str, (str.m_size + 1) * sizeof(C) );
m_hash = str.m_hash;
m_size = str.m_size;
return *this;
}
srvr_enque_mid_dncmd(UBUF *ubp) /* dn cmd while up image is being transmitted*/
{
int htyp, hlen, clen;
time_t tim;
BYTE buf[MAX_NODE_PSIZE];
QUEUE *q;
PKBH *pkbh;
SV_D20("enque_mid_dncmd(0) : entry \n");
if ((htyp = srvr_packet_head_peek(ubp, &hlen)) <= 0)
return(-1);
if ((clen = srvr_dncmd_packet_read(ubp, buf, hlen, htyp)) <= 0)
return(-1);
srvr_enque_dncmd(htyp, hlen, clen, buf);
q = q_by_htype(UP_NORM_IG1);
while(pkbh = q_delete(q)) {
Mfree(pkbh); q->taway++;
}
q = q_by_htype(UP_UGNT_IG1);
while(pkbh = q_delete(q)) {
Mfree(pkbh); q->taway++;
}
q = q_by_htype(UP_NORM_IG2);
while(pkbh = q_delete(q)) {
Mfree(pkbh); q->taway++;
}
q = q_by_htype(UP_UGNT_IG2);
while(pkbh = q_delete(q)) {
Mfree(pkbh); q->taway++;
}
q = q_by_htype(UP_TNOR_IG1);
while(pkbh = q_delete(q)) {
Mfree(pkbh); q->taway++;
}
time(&tim);
SV_D22("enque_mid_dncmd(1) : recv : DNCMD_PACKT(%.2x)\n", htyp, ctime(&tim));
}
void RWBuffer_delete(RWBuffer _self)
{
if (_self.self->top_barrier)
{
Mfree((void*)_self.self->top_barrier);
_self.self->top_barrier = NULL;
_self.self->bottom_barrier = NULL;
}
}
void DSP_Uninit(void)
{
DSP_Stop();
if (s_stRamBuffer != NULL) {
Mfree(s_stRamBuffer);
s_stRamBuffer = NULL;
}
s_stRamBufferSize = 0;
}
string_base &operator += ( C s ) {
C *tmp = ( C * ) Malloc ( (m_size + 2) * sizeof(C) );
memcpy ( tmp, m_str, m_size * sizeof(C) );
memcpy ( &tmp[m_size], &s, 2 * sizeof(C) );
m_size += 1;
Mfree ( m_str );
m_str = tmp;
m_hash = _hash ( m_str );
return *this;
}
string_base operator + ( const string_base &str ) const {
string_base ret;
ret.m_size = m_size + str.m_size;
Mfree ( ret.m_str );
ret.m_str = ( C * ) Malloc ( (ret.m_size + 1) * sizeof(C) );
memcpy ( ret.m_str, m_str, m_size * sizeof(C) );
memcpy ( &ret.m_str[m_size], str.m_str, (str.m_size + 1) * sizeof(C) );
ret.m_hash = _hash ( ret.m_str );
return ret;
}
string_base operator + ( C s ) const {
string_base ret;
ret.m_size = m_size + 1;
Mfree ( ret.m_str );
ret.m_str = ( C * ) Malloc ( (ret.m_size + 1) * sizeof(C) );
memcpy ( ret.m_str, m_str, m_size * sizeof(C) );
memcpy ( &ret.m_str[m_size], &s, 2 * sizeof(C) );
ret.m_hash = _hash ( ret.m_str );
return ret;
}
string_base &operator += ( const string_base &str ) {
C *tmp = ( C * ) Malloc ( (m_size + str.m_size + 1) * sizeof(C) );
memcpy ( tmp, m_str, m_size * sizeof(C) );
memcpy ( &tmp[m_size], str.m_str, (str.m_size + 1) * sizeof(C) );
m_size += str.m_size;
Mfree ( m_str );
m_str = tmp;
m_hash = _hash ( m_str );
return *this;
}
void Texture2D::LoadFromColor(const EColor& _color)
{
vptr pxl = SMalloc(_get_pixel_size(format));
_color.Convert(pxl, format);
pxl_buffer.clear();
pxl_buffer.convert<PixelConvertProc>(_get_pixel_size(format));
pxl_buffer.resize(width * height);
pxl_buffer.flush(pxl);
Mfree(pxl);
Update(false);
}
/*----------------------------------------------------------------------------------------*/
int16 save_psettings( PRN_SETTINGS *settings )
{
if ( settings )
{
write_settings_to_file( settings ); /* Druckereinstellung speichern */
Mfree( settings ); /* Speicher freigeben */
return( 1 );
}
return( 0 );
}
void freeglGetString(void)
{
int i;
for (i=1;i<7;i++) {
if (gl_strings[i]) {
Mfree(gl_strings[i]);
gl_strings[i]=NULL;
}
}
}
/*
* after read operation, cleanup
*/
BOOL raw_close_file(void)
{
if (CKBfileblock) {
Mfree(CKBfileblock);
CKBfileblock = NULL;
}
Readlnidx = 0;
CKBfilesize = 0;
return TRUE;
}
void _fixed_stack_realloc(FixedStack _stk)
{
euint _pre_stack_length = _stk->stack_length;
_stk->stack_length *= 2;
{
void* _buf = Malloc(_stk->value_size * _stk->stack_length);
memcpy(_buf, _stk->stack, _pre_stack_length * _stk->value_size);
Mfree(_stk->stack);
_stk->stack = _buf;
}
}
string_base &operator = ( const vector< C, FGetCharRealSizeProc<C> >& str ) {
euint count = str.size();
Mfree ( m_str );
m_str = ( C * ) Malloc ( (count + 1) * sizeof(C) );
C* s = str.get();
memcpy ( m_str, s, count * sizeof(C) );
m_str[count] = 0;
m_size = count;
m_hash = _hash ( m_str );
return *this;
}
void FunctionClosures_delete(FunctionClosures _self)
{
euint n = array_n(_self->cmds);
for (euint i = 0; i < n; i++)
{
CommandClosures_delete(_self->cmds[i]);
}
array_delete(_self->cmds);
array_delete(_self->func_arg_op_cmds_type_a_1);
array_delete(_self->func_arg_op_cmds_type_b_1);
array_delete(_self->func_arg_op_cmds_type_c_1);
array_delete(_self->func_arg_op_cmds_type_a_2);
array_delete(_self->func_arg_op_cmds_type_b_2);
array_delete(_self->func_arg_op_cmds_type_c_2);
while (FixedStack_count(_self->branch_stack)) {
BranchBlock block;
FixedStack_pop(_self->branch_stack, &block);
BranchBlock_delete(block);
}
FixedStack_Dest(_self->branch_stack);
FixedStack_Dest(_self->for_loop_stack);
Iterator iter = Tree_begin(_self->vari_tree);
while (iter)
{
var data = Tree_get_value(iter);
SymbolValue* sv = (SymbolValue*)data.vptr_var;
Mfree(sv);
iter = Tree_next(iter);
}
Tree_Dest(_self->vari_tree);
/// 输入参数和输出参数树只有指针使用权，没有指针所有权
///Tree_Dest(_self->input_param_tree);
///Tree_Dest(_self->output_param_tree);
array_delete(_self->input_param_array);
array_delete(_self->output_param_array);
Mfree(_self);
}
int main(void)
{
float a,b,c,x;
adr=Malloc(4096);
ability=Dsp_RequestUniqueAbility();
status=Dsp_LoadProg(file,ability,adr);
if (!status)
{
printf("\n\nComparaison SIN/DSP_SIN\n\n");
for(i=0;i<360;i+=36)
{
x=i;
a=sin((double)(x*2.0*M_PI)/360.0);
b=dsp_sin(x);
c=0;
if (fabs(a)>0.00001)
c=fabs(100.0*(a-b)/a); /* calcul de l'erreur */
printf("SIN(%f)=%f DSP_SIN(%f)=%f Erreur=%f %%\n",x,a,x,b,c);
}
printf("\n\nComparaison COS/DSP_COS\n\n");
for(i=0;i<360;i+=36)
{
x=i;
a=cos((double)(x*2.0*M_PI)/360.0);
b=dsp_cos(x);
c=0;
if (fabs(a)>0.00001)
c=fabs(100.0*(a-b)/a); /* calcul de l'erreur */
printf("COS(%f)=%f DSP_COS(%f)=%f Erreur=%f %%\n",x,a,x,b,c);
}
printf("\n\nComparaison SQRT/DSP_SQR\n\n");
for(i=0;i<10;i++)
{
x=i/10.0;
a=sqrt(x);
b=dsp_sqr(x);
c=0;
if (fabs(a)>0.00001)
c=fabs(100.0*(a-b)/a); /* calcul de l'erreur */
printf("SQRT(%f)=%f DSP_SQR(%f)=%f Erreur=%f %%\n",x,a,x,b,c);
}
}
else
printf("Fichier %s introuvable.\n",file);
printf("Appuyez sur une touche\n");
Bconin(2);
Mfree(adr);
return 0;
}
/**
euint32 IndexBuffer_get_buffer_size(IndexBuffer _self)
{
return _self->index_buffer_size;
}
**/
void _IndexBuffer_grow_up(IndexBuffer _self, euint32 num_faces)
{
euint32 totel_idx_buf_size = (_self->index_buffer_tail + num_faces) * _self->face_size;
if (totel_idx_buf_size > _self->index_buffer_size)
{
char* tmp = (char*)SMalloc(totel_idx_buf_size * 2);
if (_self->index_buffer_tail)
memcpy(tmp, _self->index_buffer, _self->index_buffer_tail * _self->face_size);
Mfree(_self->index_buffer);
_self->index_buffer = tmp;
_self->index_buffer_size = totel_idx_buf_size * 2;
}
}
string_base &operator = ( const C *str ) {
euint count = 0;
while ( str[count] ) {
count++;
}
Mfree ( m_str );
m_str = ( C * ) Malloc ( (count + 1) * sizeof(C) );
memcpy ( m_str, str, (count + 1) * sizeof(C) );
m_size = count;
m_hash = _hash ( m_str );
return *this;
}
