main()
{
/*
char buf[512], bbuf[512];
int i;
long srchndl, dsthndl, ret;
/**/
/*
for (i = 0; i < 512*3;) {
buf[i++] = 'M';
buf[i++] = 'I';
buf[i++] = 'N';
buf[i++] = 'O';
}
/**/
/* physical operation on unit 0 */
/*
Lrwabs(9, buf, 1, 0x10000, 2);
Lrwabs(8, bbuf, 1, 0x10000, 3);
/**/
/* logical operation on D: */
/*
i = 1;
while (i == 1) {
Mediach(3);
Getbpb(3);
Rwabs(1, buf, 1, 0x700, 3);
}
/**/
/*
Lrwabs(0, bbuf, 1, 0x10000, 3);
Rwabs(1, buf+1, 3, 102, 3);
Rwabs(0, buf, 3, 102, 3);
Rwabs(9, bbuf, 1, 0, 11);
Rwabs(8, bbuf, 1, 0, 11);
Rwabs(9, bbuf, 1, 0, 11);
char *buf256;
buf256 = (char *)Malloc(131072L);
Rwabs(8, buf256+1, 2, 0, 18);
Rwabs(9, buf256+1, 2, 0xa35a, 18);
/**/
/*
Rwabs(8, buf256+1, 255, 0, 10);
Rwabs(9, buf256+1, 255, 0, 10);
/**/
Fsfirst("h:\\*.*", 0);
while (!(Cconis()))
;
Fsfirst("g:\\*.*", 0);
Fsfirst("h:\\*.*", 0);
Pterm(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;
}
/*******************************************************************************
Test if a folder exists
*******************************************************************************/
int _dexist(char *name)
{
char old_path[FILENAME_MAX];
char myname[FILENAME_MAX];
int old_drv;
int i,ok=FALSE;
DTA *old,dta;
old=Fgetdta();
old_drv=Dgetdrv();
Dgetpath(old_path,1+old_drv);
if (name[1]==':')
Dsetdrv((int)name[1]-65);
Fsetdta(&dta);
strcpy(myname,name);
i=(int)strlen(myname);
if (myname[i-1]=='\\')
strcat(myname,"*.*");
else
strcat(myname,"\\*.*");
if (!Fsfirst(myname,FA_READONLY+FA_HIDDEN+FA_SYSTEM+FA_ARCHIVE+FA_SUBDIR))
ok=TRUE;
Dsetdrv(old_drv);
Dsetpath(old_path);
Fsetdta(old);
return ok;
}
/*
** Description
** Get program name and command line
*/
static
void
get_loadinfo (WORD pid,
WORD fnamelen,
BYTE * cmdlin,
BYTE * fname)
{
BYTE pname[30];
_DTA *olddta,newdta;
olddta = Fgetdta();
Fsetdta(&newdta);
sprintf(pname,"u:\\proc\\*.%03d",pid);
if(Fsfirst(pname,0) == 0) {
LONG fd;
sprintf(pname,"u:\\proc\\%s",newdta.dta_name);
if((fd = Fopen(pname,0)) >= 0) {
struct ploadinfo li;
li.fnamelen = fnamelen;
li.cmdlin = cmdlin;
li.fname = fname;
Fcntl((WORD)fd,&li,PLOADINFO);
Fclose((WORD)fd);
}
}
Fsetdta(olddta);
}
WORD file_exists(BYTE *dir, BYTE *name)
{
BYTE f_name[80];
strcpy( dir, f_name );
strcat( f_name, name );
#if GEMDOS
return( Fsfirst( ADDR(f_name), 0 ) );
#else
return( dos_sfirst( ADDR(f_name), 0 ) );
#endif
}
char *load_avr( char *name )
{
char fname[80] = "D:\\SOUNDS\\";
char *avr, *p;
int handle;
DTA file_info;
strcat( fname, name );
p = name;
if ( Fsfirst( name, 0 ) != 0 ) {
Fsfirst( fname, 0 );
p = fname;
}
file_info = *Fgetdta();
avr = Malloc( file_info.d_length );
handle = (int)Fopen( p, FO_READ );
Fread( handle, 1000000L, avr );
Fclose( handle );
return( avr );
}
/****************************************************************
* *
* test la chaŒne renvoy‚e par scrp_read() *
* *
****************************************************************/
boolean test_scrap_path(char *scrap_path)
{
int len = (int)strlen(scrap_path);
if (len == 0)
{
int device, err;
/* C:\ existe ? */
if (Drvmap() & (1<<2))
device = 'C';
else
device = 'A';
sprintf(scrap_path, "%c:\\CLIPBRD", device);
/* cr‚e le r‚pertoire */
if ((err = Dcreate(scrap_path)) < 0 && err != -36)
{
error_msg(err);
return TRUE;
}
strcat(scrap_path, "\\");
/* on pr‚vient l'AES */
if (!scrp_write(scrap_path))
{
error_msg(Z_CLIPBOARD_NOT_INSTALLABLE);
return TRUE;
}
}
else
if (scrap_path[len-1] != '\\')
{
if (Fsfirst(scrap_path, FA_SUBDIR))
{
/* c'est un r‚pertoire sans \ … la fin (C:\CLIPBRD) */
scrap_path[len] = '\\';
scrap_path[len+1] = '\0';
}
else
/* c'est pas un r‚pertoire (C:\CLIPBRD\SCRAP.TXT) */
*(strrchr(scrap_path, '\\')+1) = '\0';
}
return FALSE;
} /* test_scrap_path */
char *open_dir(const char *dirname)
/* open a directory for examination */
{
struct Dir *d;
if (d = malloc(sizeof(struct Dir))) {
strncpy(d->name,dirname,MAX_PATH_LEN);
d->olddta = Fgetdta();
Fsetdta(&d->dta);
d->err = Fsfirst(d->name,FA_READONLY|FA_ARCHIVE);
if (d->err != E_OK) {
Fsetdta(d->olddta);
free(d);
d = NULL;
}
}
return (char *)d;
}
void test0301(void)
{
char dta[44];
int cnt, res;
BYTE ok;
cnt = countFoundItems(dta, "*.*", 0x3f, TRUE, -1);
(cnt == 77) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0301, "Fsfirst & Fsnext - match everything", ok, cnt);
cnt = countFoundItems(dta, "*.*", 0x10, TRUE, -1);
(cnt == 27 || cnt == 77) ? (ok = 1) : (ok = 0); // TOS bug? It shoud find only 27 directories, but instead it finds everything?
out_tr_bw(0x0302, "Fsfirst & Fsnext - match all dirs", ok, cnt);
cnt = countFoundItems(dta, "*.*", 0x00, TRUE, -1);
(cnt == 50) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0303, "Fsfirst & Fsnext - match all files", ok, cnt);
cnt = countFoundItems(dta, "FILE_1*.*", 0x3f, TRUE, -1);
(cnt == 10) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0304, "Fsfirst & Fsnext - wildcard * in fname", ok, cnt);
cnt = countFoundItems(dta, "FILE_?5.*", 0x3f, TRUE, -1);
(cnt == 2) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0305, "Fsfirst & Fsnext - wildcard ? in fname", ok, cnt);
cnt = countFoundItems(dta, "FILENAME.*2", 0x3f, TRUE, -1);
(cnt == 2 || cnt == 25) ? (ok = 1) : (ok = 0); // TOS bug? Steam drive finds only 2 files (which is correct), TOS finds all 25 files like there would be no '2' after '*'
out_tr_bw(0x0306, "Fsfirst & Fsnext - wildcard * in ext", ok, cnt);
cnt = countFoundItems(dta, "FILENAME.X0?", 0x3f, TRUE, -1);
(cnt == 15) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0307, "Fsfirst & Fsnext - wildcard ? in ext", ok, cnt);
cnt = countFoundItems(dta, "FILE_05", 0x00, TRUE, -1);
(cnt == 1) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0308, "Fsfirst & Fsnext - exact file", ok, cnt);
Fsetdta(dta); // set DTA
res = Fsfirst("DOESNT.EXS", 0x00);
(res == -33) ? (ok = 1) : (ok = 0);
out_tr_bw(0x0309, "Fsfirst & Fsnext - non-existing file", ok, res);
}
int initiatedcc(char *usr,char *ftg){
short temp;
struct FILEINFO finf;
uint32 length;
uint32 cip;
char temps2[2048];
if(!strlen(ftg)){form_alert(1,"[1][DCC Error:|Please specify a file][Okay]");return 0;}
if(!strlen(usr)){form_alert(1,"[1][DCC Error:|Please specify recipient][Okay]");return 0;}
temp=findfreedc();
if(temp==-1){form_alert(1,"[1][DCC Error:|No free channels!][Okay]");return 0;}
dcc[temp].dcfh=Fopen(ftg,0);
if(dcc[temp].dcfh<0){form_alert(1,"[DCC Error:|Unable to open file][Okay]");return 0;}
dcc[temp].cn=TCP_open(0L,0,0,4096);
if(dcc[temp].cn<0){form_alert(1,"[1][DCC Error:|Unable to open socket][Okay]");return 0;}
dcc[temp].stat=SAWAIT;
dcc[temp].dir=DCOUT;
Fsetdta(&finf);
Fsfirst(ftg,0);
length=finf.size;
strcpy(dname,ftg);
basename(dname);
cb=CNgetinfo(cn[wn[cwin].cnn].cn);
cip=stik_cfg->client_ip;
if(cip==0||cip==0x7F000001)
cip=cb->lhost;
cb=CNgetinfo(dcc[temp].cn);
sprintf(temps2,":%s PRIVMSG %s :\001DCC SEND %s %lu %u %lu\001\n",cn[wn[cwin].cnn].nick,usr,dname,cip,cb->lport,length);
TCP_send(cn[wn[cwin].cnn].cn,(char *)&temps2,(int16)strlen(temps2));
dcc[temp].rport=cb->lport;
dcc[temp].rip=cip;
strcpy(dcc[temp].fname,dname);
dcc[temp].len=length;
strcpy(dcc[temp].avec,usr);
if(!conf.boldnicks)
sprintf(temps2,"--Initiating DCC send to %s: %s",usr,dname);
else
sprintf(temps2,"--Initiating DCC send to %s: %s",usr,dname);
sendout(temps2,cwin,col[CDCCINFO]);
if(conf.autodcd)opendccsenddialog(temp,dname);
return 0;
}
void GetLDVLanguages(LDV_MODULE *ldv, char *buf)
{
DTA dta, *old_dta ;
char name[PATH_MAX] ;
char ini_name[PATH_MAX] ;
char ldv_nameextini[50] ;
char *dot ;
int ret ;
if ( ldv->FileName ) strcpy( ldv_nameextini, ldv->FileName ) ;
else return ;
dot = strrchr( ldv_nameextini, '.' ) ;
if ( dot )
{
*dot = 0 ;
strcat( ldv_nameextini, ".INI" ) ;
}
sprintf( ini_name, "%s\\%s", config.path_ldv, ldv_nameextini ) ;
if ( FileExist( ini_name ) ) sprintf( buf, "English " ) ;
else buf[0] = 0 ;
sprintf( name, "%s\\*.*", config.path_ldv ) ;
old_dta = Fgetdta() ;
Fsetdta( &dta ) ;
ret = Fsfirst( name, FA_SUBDIR ) ;
while ( ret == 0 )
{
if ( ( dta.d_fname[0] != '.' ) && ( dta.d_attrib & FA_SUBDIR ) )
{
sprintf( ini_name, "%s\\%s\\%s", config.path_ldv, dta.d_fname, ldv_nameextini ) ;
if ( FileExist( ini_name ) )
{
strlwr( &dta.d_fname[1] ) ;
strcat( buf, dta.d_fname ) ;
strcat( buf, " " ) ;
}
}
ret = Fsnext() ;
}
Fsetdta( old_dta ) ;
}
/**
* Process all files in the directory.
*
* @param dirpath path to directory to traverse.
* @param callback function called back for each file found.
* @return True if and only if everything was ok.
*/
bool ReadDir_ProcessAllFiles(const char * dirpath, bool (*callback)(const char *name, const char *path, uint32 size))
{
_DTA dta;
char searchpath[256];
char path[256];
long r;
snprintf(searchpath, sizeof(searchpath), "%s*.*", dirpath);
Fsetdta(&dta);
if(Fsfirst(searchpath, FA_RDONLY | FA_HIDDEN) != 0) {
return false;
} else do {
/* Skip directories */
if (dta.dta_attribute & FA_DIR) continue;
snprintf(path, sizeof(path), "%s%s", dirpath, dta.dta_name);
Debug("Found file %-17s %7ld bytes\n", path, dta.dta_size);
if (!callback(dta.dta_name, path, (uint32)dta.dta_size)) {
return false;
}
} while((r = Fsnext()) == 0);
return (r == -ENMFILES);
}
/*******************************************************************************
Test if a file exists
*******************************************************************************/
int _fexist(char *name,DTA *res)
{
char old_path[FILENAME_MAX];
int old_drv;
int ok=FALSE;
DTA *old,dta;
old=Fgetdta();
old_drv=Dgetdrv();
Dgetpath(old_path,1+old_drv);
if (name[1]==':')
Dsetdrv((int)name[1]-65);
Fsetdta(&dta);
if (!Fsfirst(name,FA_READONLY+FA_HIDDEN+FA_SYSTEM+FA_ARCHIVE+FA_SUBDIR))
ok=TRUE;
if (ok && res)
memcpy((void *)res,(void *)&dta,sizeof(DTA));
Dsetdrv(old_drv);
Dsetpath(old_path);
Fsetdta(old);
return ok;
}
int x_getlabel(int drive, char *label)
{
DTA *olddta, dta;
int error;
char path[10];
#if USE_gemdos
olddta = (DTA *) gemdos(47);
gemdos(26, &dta);
#else
olddta = Fgetdta();
Fsetdta(&dta);
#endif
strcpy(path, "A:\\*.*");
path[0] += (char) drive;
#if USE_gemdos
error = (int) gemdos(78, path, 0x3F);
#else
error = Fsfirst(path, 0x3F);
#endif
/* if ((error == 0) && (dta.d_attrib & 8)) DjV 004 300103 */
if ((error == 0) && (dta.d_attrib & FA_VOLUME)) /* DjV 004 300103 same but more readable */
strcpy(label, dta.d_fname);
else
*label = 0;
#if USE_gemdos
gemdos(26, olddta);
#else
Fsetdta(olddta);
#endif
return ((error == -49) || (error == -33)) ? 0 : error;
}
int countFoundItems(char *dta, char *fspec, WORD attribs, BYTE startNotCont, int stopAfter)
{
int res, found = 0;
if(startNotCont) { // on start clean DTA
memset(dta, 0, 44);
}
Fsetdta(dta); // set DTA
if(startNotCont) { // if should start search, not continue
res = Fsfirst(fspec, attribs);
if(res) { // file not found?
return 0;
}
found++;
}
while(1) {
if(found == stopAfter) { // if we found all we needed, stop
return found;
}
res = Fsnext();
if(res) { // if file not found, quit
return found;
}
found++;
}
return found; // this should never happen
}
/*******************************************************************************
BALAYAGE D'UN DOSSIER
*******************************************************************************/
static int Balaie_Path(char *directory,int wx,int wy,int ww,int wh)
{
char old_path[FILENAME_MAX];
int old_drv;
char pfn[FILENAME_MAX];
DTA *mydta;
int i,Fin=0;
int cnt,pos;
/* long count;*/
t2=0;
old_drv=Dgetdrv();
Dgetpath(old_path,1+old_drv);
mydta=Fgetdta();
if (directory[1]==':')
Dsetdrv((int)directory[1]-65);
strcpy(pfn,directory);
strcat(pfn,"\\*.*");
if (glb.opt.sl_rec)
i=Fsfirst(pfn,FA_READONLY|FA_SUBDIR|FA_ARCHIVE);
else
i=Fsfirst(pfn,FA_READONLY|FA_ARCHIVE);
pos=0;
loop1:
cnt=0;
while (!i)
{
cnt+=1;
if (mydta->d_fname[0]!='.' && cnt>pos)
{
strcpy(pfn,directory);
strcat(pfn,"\\");
strcat(pfn,mydta->d_fname);
if (mydta->d_attrib&FA_SUBDIR)
{
pos=cnt;
if (Balaie_Path(pfn,wx,wy,ww,wh))
return TRUE;
strcpy(pfn,directory);
strcat(pfn,"\\*.*");
if (glb.opt.sl_rec)
i=Fsfirst(pfn,FA_READONLY|FA_SUBDIR|FA_ARCHIVE);
else
i=Fsfirst(pfn,FA_READONLY|FA_ARCHIVE);
goto loop1;
}
}
if (Kbshift(-1)!=shift)
return TRUE;
i=Fsnext();
/*
if (i!=0)
{
time(&t1);
if(glb.opt.sl_pause)
{
count=1000L*max( 0 , (long)glb.opt.sl_ptime - (t1-t2) );
evnt_timer( (int)(count&0xFFFFUL),(int)(count>>16) );
}
else
count=0;
}
*/
}
strcpy(pfn,directory);
strcat(pfn,"\\");
strcat(pfn,glb.opt.sl_name);
if (glb.opt.sl_rec)
i=Fsfirst(pfn,FA_READONLY|FA_SUBDIR|FA_ARCHIVE);
else
i=Fsfirst(pfn,FA_READONLY|FA_ARCHIVE);
pos=0;
cnt=0;
while (!i)
{
cnt+=1;
if (mydta->d_fname[0]!='.' && cnt>pos)
{
strcpy(pfn,directory);
strcat(pfn,"\\");
strcat(pfn,mydta->d_fname);
if (!(mydta->d_attrib&FA_SUBDIR))
affiche(pfn,wx,wy,ww,wh);
}
if (Kbshift(-1)!=shift)
return TRUE;
i=Fsnext();
/*
if (i!=0)
{
time(&t1);
if(glb.opt.sl_pause)
count=1000L*max( 0 , (long)glb.opt.sl_ptime - (t1-t2) );
else
count=0;
evnt_timer( (int)(count&0xFFFFUL),(int)(count>>16) );
}
*/
}
Dsetdrv(old_drv);
Dsetpath(old_path);
return Fin;
}
WORD
wrfile( char *fstr )
{
REG int ret, retmsg;
int inhand,outhand;
int time[2];
DMABUFFER *mydta, *saved;
char *buffer;
long copysiz, bufsiz, wrsiz, tmpsiz;
int crted,sttime;
char buf[2];
crted = 0;
sttime = 1;
retmsg = TRUE;
rename = 0;
open: /* open the source file */
if ( ( inhand = (WORD)Fopen(fixsrc, 0) ) < 0 )
{ /* seek error or drive not ready */
/* if ( (inhand == E_SEEK) || (inhand == EDRVNR) )
return( FALSE );
*/ /* skip */
if ( ( ret = fill_string( fixsrc, CNTOPEN ) ) == 1 )
{
updatnum(NUMFILE, --numfiles);
return SKIP;
}
else if (ret == 2) /* retry */
goto open;
else /* abort */
goto ww_3;
}
if ( !ch_undo() || f_cancel ) /* user want to stop */
{
Fclose( inhand );
ww_3: f_abort = 1;
return( FALSE );
}
saved = (DMABUFFER *)Fgetdta();
Fsetdta(mydta=(DMABUFFER *)malloc( (long)sizeof(DMABUFFER)));
if ( Fsfirst( fixsrc, 0x37 ) )
{
retmsg = SKIP;
if ( do1_alert( RDERROR ) == 2 ) /* abort */
{
f_abort = 1;
retmsg = FALSE;
}
goto y2;
}
copysiz = mydta->d_fsize;
buffer = (char *)malloc( copysiz );
if ( buffer )
{
bufsiz = copysiz;
}
else
{
for (bufsiz = 128*1024L; bufsiz >= 1024L; bufsiz /= 2)
{
if ((buffer = (char *)malloc( bufsiz )) != 0)
break;
}
if (!buffer)
goto y2;
}
Fdatime( &time, inhand, 0 ); /* read the time and date */
rechkd:
switch(chkdf(fstr, CPFILE))
{
case CHECK:
goto rechkd;
case SKIP:
retmsg = SKIP;
goto y1;
case QUIT:
f_abort = 1;
retmsg = FALSE;
goto y1;
case FALSE:
retmsg = FALSE;
goto y1;
}
/* if it is move operation, then try rename first */
if ( opcode == OP_MOVE )
{ /* if same name and path, don't do it */
if ( strcmp( fixsrc, fixdst ) )
goto y22;
Fclose( inhand );
if ( Frename(0, fixsrc, fixdst) >= 0 )
{
inhand = (WORD)Fopen( fixdst, 0 );
if ( !p_timedate ) /* get the new time and date */
{
time[0] = Tgettime();
time[1] = Tgetdate();
Fdatime( &time, inhand, 1 );
}
y22:
rename = 1;
goto y1;
}
else
inhand = (WORD)Fopen( fixsrc, 0 );
}
while ( copysiz >= 0 ) /* let it passes through for zero file */
{
tmpsiz = (copysiz > bufsiz) ? bufsiz : copysiz;
if (Fread(inhand, tmpsiz, buffer) < 0)
{
retmsg = SKIP;
if ( crted )
Fdelete( fixdst );
if (do1_alert( RDERROR ) == 2)
{ /* abort */
f_abort = 1;
retmsg = FALSE;
}
goto y1; /* skip */
}
create:
if ( sttime )
{
sttime = 0;
if ((outhand = (WORD)Fcreate(fixdst, mydta->d_fattr&7)) < 0)
{
if ( ( ret = fill_string( fixdst, CNTCRTFL ) ) == 2 )
goto create;
else if (ret == 3) /* abort */
{
f_abort = 1;
retmsg = FALSE;
}
else
retmsg = SKIP;
goto y1;
}
crted = 1;
}
if ((wrsiz = Fwrite(outhand, tmpsiz, buffer)) < 0)
{
retmsg = SKIP;
Fclose(outhand);
Fdelete(fixdst);
if (do1_alert( WRERROR ) == 2)
{ /* abort */
f_abort = 1;
retmsg = FALSE;
}
goto y1;
}
/* check if there are sufficent memory */
if (wrsiz != tmpsiz)
{ /* not sufficent memory ??*/
f_abort = 1;
retmsg = FALSE;
Fclose(outhand);
Fdelete(fixdst);
buf[0] = *fixdst;
buf[1] = 0;
fill_string( buf, STDISKFU );
goto y1;
}
copysiz -= tmpsiz;
if ( !copysiz )
break;
}
if ( p_timedate )
Fdatime( &time, outhand, 1 );
y0:
Fclose(outhand);
y1:
free(buffer);
y2:
updatnum(NUMFILE, --numfiles);
Fsetdta(saved);
y3:
Fclose(inhand);
free(mydta);
if ( ( opcode == OP_MOVE ) && ( retmsg == TRUE ) )
upfdesk( fixsrc, fixdst );
return(retmsg);
}
WORD
countrec( VOID )
{
/* char *saved; */
DMABUFFER *dumb, *saved;
REG int retmsg;
dumb = (DMABUFFER *)malloc( (LONG)sizeof(DMABUFFER) );
if ( !dumb )
{
do1_alert( STFO8DEE );
return( FALSE );
}
retmsg = TRUE;
saved = (DMABUFFER *)Fgetdta(); /* save the current dta */
Fsetdta( dumb );
if (!Fsfirst(curall, 0x37))
{
do
{
if (dumb->d_fname[0] != HOME)
{
if (SUBDIR & dumb->d_fattr)
{ /* setpath to one more down */
if (Dsetpath(dumb->d_fname))
{
retmsg = FALSE;
goto endrec;
}
numdirs++;
if ( ++f_level > COPYMAXDEPTH )
{
do1_alert( STFO8DEE );
retmsg = FALSE;
goto endrec;
}
if (!countrec()) /* to the recursion setpath to one back */
{
retmsg = FALSE;
goto endrec;
}
f_level--;
if (Dsetpath(baklvl))
{
retmsg = FALSE;
goto endrec;
}
}
else
{
numfiles++; /* add up the file count and size */
tolsize += dumb->d_fsize;
}
}
} while (!Fsnext());
}
endrec:
Fsetdta( saved ); /* reset the dta */
free( dumb );
return(retmsg);
}
int
doact( VOID )
{
/* char *saved; */
DMABUFFER *dumb, * saved;
REG int ret, retmsg;
int error;
if ( f_level >= ( COPYMAXDEPTH + 1 ) )
{
act_1: do1_alert( STFO8DEE );
return( FALSE );
}
/* changed CHAR * to DMABUFFER * in expression below - JTT */
if ( !( dumb = (DMABUFFER *)malloc( (LONG)sizeof( DMABUFFER ) ) ) )
goto act_1;
f_level++;
retmsg = TRUE;
saved = (DMABUFFER *)Fgetdta();
Fsetdta( dumb );
strcat(getall, fixsrc);
if ( !( error = Fsfirst(fixsrc, 0x37) ) )
{
do
{
if ( !ch_undo( ) || f_cancel ) /* user want to abort */
{
f_abort = 1;
retmsg = FALSE;
goto mvend;
}
if (dumb->d_fname[0] != HOME)
{
if (SUBDIR & dumb->d_fattr)
{
chkbuf(srclen, srcbuf, &fixsrc); /* check buf size */
addfile(fixsrc, dumb->d_fname); /* add a dir into the path */
strcat(bckslsh, fixsrc);
if (opcode != OP_DELETE)
{
chkbuf(dstlen, dstbuf, &fixdst); /* check buf size */
strcat(dumb->d_fname, fixdst);
}
else
goto dorec;
updatbox(dumb->d_fname);
rechkd1: /* update check the dir existing or not */
switch( chkdf( dumb->d_fname, CPDIR ) )
{
case QUIT:
f_abort = 1;
retmsg = FALSE;
goto mvend;
case SKIP:
backdir(fixsrc);
backdir(fixdst);
updatnum(NUMDIR, --numdirs);
srclen -= FILE_LEN; /* subtract the add lenth */
dstlen -= FILE_LEN; /* subtract the add lenth */
retmsg = TRUE;
continue;
case FALSE:
goto mvend;
case CHECK:
goto rechkd1;
case OK:
recrtd:
if (Dcreate(fixdst))
{
if ( write_save )
goto kk_1;
switch( fill_string( fixdst, CNTCRTDR ) )
{
case 1: /* skip */
backdir(fixsrc);
backdir(fixdst);
updatnum(NUMDIR, --numdirs);
srclen -= FILE_LEN; /* subtract the add lenth */
dstlen -= FILE_LEN; /* subtract the add lenth */
continue;
case 2: /* retry */
goto recrtd;
default: /* quit */
f_abort = 1;
retmsg = FALSE;
goto mvend;
}/* switch */
}/* if recrtd */
break;
}
kk_1:
updatnum(NUMDIR, --numdirs);
strcat(bckslsh, fixdst);
dorec:
if (!doact()) /* do the recursion */
{
retmsg = FALSE;
goto mvend;
}
if (opcode == OP_COPY)
goto clndir;
rmstarb(fixsrc); /* after call, -> c:\d1\ */
if (opcode == OP_DELETE)
{
getlastpath(filestr, fixsrc);
updatbox(filestr);
}
remvd:
if (Ddelete(fixsrc))
{ /* delete a dir */
if ( ( ret = fill_string( fixsrc, CNTDELD ) ) == 2 )
goto remvd; /* retry */
else if (ret == 3)
{ /* abort */
f_abort = 1;
retmsg = FALSE;
goto mvend;
}
}
else /* No error */
upfdesk( fixsrc, (BYTE*)0 );
clndir:
backdir(fixsrc); /* back one dir */
srclen -= FILE_LEN; /* subtract the add lenth */
if (opcode == OP_DELETE)
updatnum(NUMDIR, --numdirs);
else
{
backdir(fixdst); /* back one dir */
dstlen -= FILE_LEN; /* subtract the add lenth */
}
}
else
{
getlastpath(filestr, fixdst);
updatname(CPDIR, filestr); /* update the dir */
updatname( CPFILE, dumb->d_fname ); /* update the file */
chkbuf(srclen, srcbuf, &fixsrc); /* check buf size */
addfile(fixsrc, dumb->d_fname);
if (opcode != OP_DELETE)
{
chkbuf(dstlen, dstbuf, &fixdst); /* check buf size */
addfile(fixdst, dumb->d_fname);
rename = 0;
if (!(retmsg = wrfile(dumb->d_fname)))
goto mvend;
if ((rename) || (retmsg == SKIP))
goto clnfile;
}
if (opcode == OP_COPY)
goto clnfile;
remvf:
if (ret = (WORD)(Fdelete(fixsrc))) /* rm the file from source */
{ /* seek error or drive not ready */
/* if ((ret == E_SEEK) || (ret == EDRVNR))
{
retmsg = FALSE;
goto mvend;
}
*/ /* retry */
if ( ( ret = fill_string( fixsrc, CNTDELF ) ) == 2 )
goto remvf;
else
if ( ret == 3 )
{ /* abort */
f_abort = 1;
retmsg = FALSE;
goto mvend;
}
}
else
upfdesk( fixsrc, (BYTE*)0 );
clnfile:
backdir(fixsrc); /* back one dir */
srclen -= FILE_LEN; /* subtract the add lenth */
if (opcode == OP_DELETE)
updatnum(NUMFILE, --numfiles);
else
{
backdir(fixdst); /* back one dir */
dstlen -= FILE_LEN; /* subtract the add lenth */
}
}
}
} while (!Fsnext());
}
else
{
if ( error != EFILNF ) /* if not file not found */
retmsg = FALSE; /* then return error */
}
mvend:
Fsetdta( saved );
f_level--;
free( dumb );
return( retmsg );
}
int
__quickstat (const char *_path, struct stat *st, int lflag)
{
char tmpbuf[PATH_MAX];
char *path = (char *) _path;
int nval;
long r;
if (!_path) {
__set_errno (EFAULT);
return -1;
}
if (*_path == '\0') {
__set_errno (ENOENT);
return -1;
}
if (__libc_unix_names)
nval = 0;
else {
/* _unx2dos returns 1 for device names (like /dev/con) */
path = tmpbuf;
nval = _unx2dos(_path, path, sizeof (tmpbuf));
}
r = __sys_stat (path, st, lflag, 0);
if (r != -ENOSYS) {
if (r) {
if ((r == -ENOTDIR) && _enoent (path)) {
r = -ENOENT;
}
__set_errno (-r);
return -1;
}
return 0;
}
{
char *ext, drv;
_DTA d;
_DTA *olddta;
int isdot = 0;
int isdir = 0;
__bzero (st, sizeof (*st));
/* Otherwise, check to see if we have a name like CON: or AUX: */
if (nval == 1) {
st->st_mode = S_IFCHR | 0600;
st->st_flags = 0;
st->st_ino = __inode++;
st->st_rdev = 0;
st->st_mtime = st->st_ctime = st->st_atime = 0;
st->st_dev = 0;
st->st_nlink = 1;
st->st_uid = geteuid();
st->st_gid = getegid();
st->st_size = st->st_blocks = 0;
st->st_blksize = 1024;
return 0;
}
/* A file name: check for root directory of a drive */
if (path[0] == '\\' && path[1] == 0) {
drv = Dgetdrv() + 'A';
isdir = 1;
goto rootdir;
}
if (((drv = path[0]) != 0) && path[1] == ':' &&
(path[2] == 0 || (path[2] == '\\' && path[3] == 0)) ) {
rootdir:
isdir = 1;
st->st_mode = S_IFDIR | 0755;
st->st_flags = 0;
st->st_dev = isupper(drv) ? drv - 'A' : drv - 'a';
st->st_ino = 2;
st->st_mtime = st->st_ctime = st->st_atime = 0;
goto fill_dir;
}
/* Forbid wildcards in path names */
if (index(path, '*') || index (path, '?')) {
__set_errno (ENOENT);
return -1;
}
/* NOTE: Fsfirst(".",-1) or Fsfirst("..",-1) both fail under TOS,
* so we kludge around this by using the fact that Fsfirst(".\*.*"
* or "..\*.*" will return the correct file first (except, of course,
* in root directories :-( ).
* NOTE2: Some versions of TOS don't like Fsfirst("RCS\\", -1) either,
* so we do the same thing if the path ends in '\\'.
*/
/* Find the end of the string. */
for (ext = path; ext[0] && ext[1]; ext++) ;
/* Add appropriate kludge if necessary. */
if (*ext == '.' && (ext == path || ext[-1] == '\\' || ext[-1] == '.')) {
isdot = 1;
strcat (path, "\\*.*");
} else if (*ext == '\\') {
isdot = 1;
strcat (path, "*.*");
}
olddta = Fgetdta();
Fsetdta(&d);
r = Fsfirst (path, 0xff);
Fsetdta (olddta);
if (r < 0) {
if (isdot && r == -ENOENT) goto rootdir;
__set_errno (-r);
return -1;
}
if (isdot && ((d.dta_name[0] != '.') || (d.dta_name[1]))) {
goto rootdir;
}
if (((drv = *path) != 0) && path[1] == ':')
st->st_dev = _toupper (drv) - 'A';
else
st->st_dev = Dgetdrv ();
st->st_ino = __inode++;
st->st_flags = 0;
st->st_mode = 0644 | (isdir ? S_IFDIR | 0111 : S_IFREG);
if (st->st_flags & FA_RDONLY)
st->st_mode &= ~0222; /* no write permission */
if (st->st_flags & FA_HIDDEN)
st->st_mode &= ~0444; /* no read permission */
/* Check for a file with an executable extension */
ext = strrchr(_path, '.');
if (ext) {
if (!strcmp (ext, ".app") || !strcmp (ext, ".gtp") ||
!strcmp (ext, ".ttp") || !strcmp (ext, ".prg") ||
!strcmp (ext, ".tos")) {
st->st_mode |= 0111;
}
}
if ((st->st_mode & S_IFMT) == S_IFREG) {
st->st_size = d.dta_size;
/* In Unix, blocks are measured in 512 bytes */
st->st_blocks = (st->st_size + 511) / 512;
st->st_nlink = 1; /* we dont have hard links */
} else {
fill_dir:
st->st_size = 1024;
st->st_blocks = 2;
st->st_nlink = 2; /* "foo" && "foo/.." */
}
st->st_uid = geteuid(); /* the current user owns every file */
st->st_gid = getegid();
st->st_blksize = 1024;
}
return 0;
}
/* Read_Data()
* ================================================================
*/
BOOLEAN
Read_Data( void )
{
DTA thedta, *saved;
int fd;
int *DataPtr;
long EndIndex;
BOOLEAN flag;
flag = FALSE;
saved = Fgetdta();
Fsetdta( &thedta );
if( Fsfirst( FPath, 0 ) <= -1 ) /* Can't find the file... */
{
Objc_draw( tree, ROOT, MAX_DEPTH, NULL );
form_alert( 1, alert2 );
}
else
{
DataBuf = calloc( 1, thedta.d_length * 2L );
if( DataBuf )
{
fd = Fopen( FPath, 0 );
if( fd <= 0 )
{
form_alert( 1, alert1 );
}
else
{
Buffer = ( long )DataBuf;
Buffer = ( Buffer + 15L ) & 0xFFFFFFF0L;
DataHdr = ( int *)Buffer;
Fread( fd, thedta.d_length, DataHdr );
Fclose( fd );
EndIndex = thedta.d_length;
DataPtr = FindString( DataHdr, DataHdr + EndIndex - 8 );
if( DataPtr )
{
hdr = ( HEADER *)DataPtr;
hdr_buffer = ( HEADER )*hdr;
hdr = &hdr_buffer;
strcpy( title, hdr->fname );
flag = TRUE;
}
else
{
Objc_draw( tree, ROOT, MAX_DEPTH, NULL );
form_alert( 1, alert3 );
}
free( DataBuf );
}
}
else
form_alert( 1, alert4 );
}
Fsetdta( saved );
return( flag );
}
LOCAL WORD rs_read (WORD *global, CONST BYTE *fname)
{
WORD i, fh;
BYTE tmpnam[128];
DTA dta, *old_dta;
LONG size;
WORD ret = TRUE;
strcpy (tmpnam, fname);
if (!shel_find (tmpnam))
{
form_error (-33);
return (FALSE);
}
rs_global = global;
old_dta = Fgetdta ();
Fsetdta (&dta);
if (Fsfirst (tmpnam, 0x10) == 0)
size = dta.d_length;
else
size = 0;
Fsetdta (old_dta);
if (size > sizeof (RSHDR) && (fh = Fopen (tmpnam, 0)) > 0)
{
if ((hdr_buf = (RSXHDR *)malloc (size + sizeof (RSXHDR))) != NULL)
{
(LONG)rs_hdr = (LONG)hdr_buf + sizeof (RSXHDR);
if (Fread (fh, size, rs_hdr) == size)
{
if (((RSHDR *)rs_hdr)->rsh_vrsn == 3)
memcpy (hdr_buf, rs_hdr, sizeof (RSXHDR));
else
for (i = 0; i < sizeof (RSXHDR) / sizeof (LONG); i++)
((ULONG *)hdr_buf)[i] = ((UWORD *)rs_hdr)[i];
do_rsfix (hdr_buf->rsh_rssize);
if (size > hdr_buf->rsh_rssize + 72L) /* Farbicons in der Resource? */
do_ciconfix ((ULONG)rs_hdr, hdr_buf, size);
}
else
ret = FALSE;
}
else
{
form_error (-39);
ret = FALSE;
}
Fclose (fh);
}
else
ret = FALSE;
return (ret);
}
copy_dir () /* source und dest sind global; bei Fehler: return (1) */
{
int source_len, dest_len, fd_source, fd_dest, error;
char dta[44];
long old_dta, fail, size, count;
error=0;
source_len=strlen(source);
dest_len=strlen(dest);
old_dta=Fgetdta();
Fsetdta(dta);
strcat(source,"\\*.*");
fail=Fsfirst(source,16);
source[source_len]=0;
while (!fail)
{ strcat(source,"\\");
strcat(source,dta+30);
strcat(dest,"\\");
strcat(dest,dta+30);
if (dta[21]==16) /* Directory */
{ if (strcmp(dta+30,".")&&strcmp(dta+30,".."))
if (Dcreate(dest))
{ printf("Ordner %s l„žt sich nicht anlegen.\n",dest);
error=1;
}
else
error|=copy_dir(source,dest);
}
else /* File */
{ printf("%s nach %s\n",source,dest);
if ((fd_source=Fopen(source,0))<0)
{ printf("Datei %s l„žt sich nicht ”ffnen.\n",source);
error=1;
}
else
if ((fd_dest=Fcreate(dest,dta[21]&~1))<0)
{ printf("Datei %s l„žt sich nicht einrichten.\n",dest);
error=1;
}
else
{ size=*(long*)(dta+26);
while (size)
{ count=(size<buf_size)?size:buf_size;
size-=count;
if (Fread(fd_source,count,buffer)!=count)
{ printf("Fehler beim Lesen von %s .\n",source);
error=1;
break;
}
if (Fwrite(fd_dest,count,buffer)!=count)
{ printf("Fehler beim Schreiben von %s .\n",dest);
error=1;
break;
}
}
Fclose(fd_source);
Fclose(fd_dest);
fd_dest=Fopen(dest,1);
Fdatime(fd_dest,dta+22,1);
Fclose(fd_dest);
}
}
source[source_len]=0;
dest[dest_len]=0;
fail=Fsnext();
}
if (fail!=-49l)
{ printf("Ordner %s nicht gefunden.\n",source);
error=1;
}
Fsetdta(old_dta);
return (error);
}
int
main(int argc, char **argv)
{
long size[NUMFILES];
long totsize;
char buf[20], name[40];
byte *inbuf, *ptr;
byte *outbuf;
long outsize;
int i, fd;
DTA *dt;
int compress, noheader;
int interactive = 1;
dt = (DTA *)Fgetdta();
compress = 0;
noheader = 0;
printf("\nSuperglue v1.0\n");
while (argc > 1) {
ptr = (byte *)argv[1];
argv++;
--argc;
if (*ptr == '-') {
ptr++;
switch (*ptr) {
case 'c':
compress = 1;
i = atoi(ptr+1);
if (i) gl_matchsize = i;
break;
case 'n':
noheader = 1;
break;
default:
printf("usage: superglu [-n][-c#] [extension]\n");
break;
}
} else {
interactive = 0;
break;
}
}
puts(compress ? "COMPRESSING resources" : "storing resources" );
if (interactive) {
printf("\nPlease enter the 3 letter country abbreviation, or\n");
printf("type 'exit' to quit\n");
}
do {
totsize = HEADERSIZE;
if (interactive) {
printf("> ");
fflush(stdout);
gets(buf);
if (strlen(buf) > 3) break;
} else {
strcpy(buf, *argv);
}
/* first, find the sizes of the pieces */
for (i = 0; i < NUMFILES; i++) {
sprintf(name, fname[i], buf);
if (Fsfirst(name, 0) != 0) {
printf("%s: not found\n", name);
goto top;
}
size[i] = dt->dta_size;
/* we round all file sizes up to the next even number when we
* read them into memory, so everything will be on a word boundary
*/
totsize += ROUND(size[i]);
}
ptr = inbuf = (byte *)Malloc( totsize );
if (!inbuf) {
printf("not enough memory: couldn't allocate %ld bytes\n",
totsize);
goto top;
}
ptr += HEADERSIZE;
/* now, go read the files */
for (i = 0; i < NUMFILES; i++) {
sprintf(name, fname[i], buf);
fd = Fopen(name, 0);
if (fd < 0) {
printf("couldn't open %s\n", name);
Mfree(inbuf);
goto top;
}
puts(name);
if (Fread(fd, size[i], ptr) != size[i]) {
printf("Error during read\n");
Mfree(inbuf);
Fclose(fd);
goto top;
}
Fclose(fd);
ptr += ROUND(size[i]);
/* fill in the size in the header */
((long *)inbuf)[i] = ROUND(size[i]);
}
/* OK, now write the result */
sprintf(name, "glue.%s", buf);
fd = Fcreate(name, 0);
if (fd < 0) {
printf("couldn't create %s\n", name);
Mfree(inbuf);
goto top;
}
if (compress) {
outbuf = (byte *)Malloc( totsize * 2 );
if (!outbuf) {
printf("NO MEMORY FOR COMPRESSION!!\n");
printf("storing resource instead\n");
compress = 0;
}
}
if (compress) {
magic[0] = 0xab;
magic[1] = 0x08;
outsize = crunch(inbuf, totsize, outbuf);
} else {
outbuf = inbuf;
outsize = totsize;
magic[0] = magic[1] = 0;
}
printf("Writing %s...\n", name);
/* first, the file header */
if (!noheader) {
Fwrite(fd, 2L, magic);
Fwrite(fd, 4L, &totsize);
Fwrite(fd, 4L, &outsize);
}
/* now write the data */
if (Fwrite(fd, outsize, outbuf) != outsize) {
printf("write error!\n");
}
Fclose(fd);
Mfree(inbuf);
if (compress) Mfree(outbuf);
top:
;
} while (interactive);
return 0;
}
/* Save_Data()
* ======================================================================
*/
BOOLEAN
Save_Data( void )
{
DTA thedta, *saved;
int fd;
int *DataPtr;
long EndIndex;
BOOLEAN flag;
flag = FALSE;
saved = Fgetdta();
Fsetdta( &thedta );
if( Fsfirst( FPath, 0 ) <= -1 ) /* Can't find the file... */
{
Objc_draw( tree, ROOT, MAX_DEPTH, NULL );
form_alert( 1, alert2 );
}
else
{
DataBuf = calloc( 1, thedta.d_length * 2L );
if( DataBuf )
{
fd = Fopen( FPath, 0 );
if( fd <= 0 )
{
form_alert( 1, alert1 );
}
else
{
Buffer = ( long )DataBuf;
Buffer = ( Buffer + 15L ) & 0xFFFFFFF0L;
DataHdr = ( int *)Buffer;
Fread( fd, thedta.d_length, DataHdr );
Fclose( fd );
EndIndex = thedta.d_length;
DataPtr = FindString( DataHdr, DataHdr + EndIndex - 8 );
if( DataPtr )
{
hdr = ( HEADER *)DataPtr;
hdr_buffer.quality = Menu[ MQUALITY ].curvalue;
hdr_buffer.nplanes = Menu[ MCOLOR ].curvalue + 1;
hdr_buffer.PageSize = Menu[ MPAGESIZE ].curvalue;
hdr_buffer.xres = xres_value;
hdr_buffer.yres = yres_value;
hdr_buffer.port = Menu[ MPORT ].curvalue;
hdr_buffer.paper_feed = Menu[ MTRAY ].curvalue;
*hdr = hdr_buffer;
flag = TRUE;
fd = Fcreate( FPath, 0 );
Fwrite( fd, thedta.d_length, DataHdr );
Fclose( fd );
}
else
{
Objc_draw( tree, ROOT, MAX_DEPTH, NULL );
form_alert( 1, alert3 );
}
free( DataBuf );
}
}
else
form_alert( 1, alert4 );
}
Fsetdta( saved );
return( flag );
}
/* GetCDrivers()
* ====================================================================
* Go thru the list of .sys files and try to load them.
* Those that we can load, get the header and see if they are of the
* new driver type. Get the filenames of those that are printer drivers
* and store them in cdriver. Store their index into the driver array
* into our cdriver array position.
*/
void
GetCDrivers( void )
{
DTA thedta, *saved;
int fd;
int *DataPtr;
long EndIndex;
int error;
saved = Fgetdta();
Fsetdta( &thedta );
cdriver_count = 0;
get_bitpath();
strcpy( FPath, epath );
strcat( FPath, "\\*.SYS");
error = Fsfirst( FPath, 0 ); /* Normal file search for 1st file */
if( error != E_OK ) /* No such files! */
{
return;
}
do
{
sprintf( line_buf, "%s\\%s", epath, thedta.d_fname );
DataBuf = calloc( 1, thedta.d_length * 2L );
if( DataBuf )
{
fd = Fopen( line_buf, 0 );
if( fd > 0 )
{
Buffer = ( long )DataBuf;
Buffer = ( Buffer + 15L ) & 0xFFFFFFF0L;
DataHdr = ( int *)Buffer;
Fread( fd, thedta.d_length, DataHdr );
Fclose( fd );
EndIndex = thedta.d_length;
DataPtr = FindString( DataHdr, DataHdr + EndIndex - 8 );
if( DataPtr ) /* Look only for new drivers with headers*/
{
hdr = ( HEADER *)DataPtr;
hdr_buffer = ( HEADER )*hdr;
hdr = &hdr_buffer;
/* want only those drivers with real page sizes */
if( hdr->config_map & 0x3E )
{
/* then get the name...*/
strcpy( cdrivers[ cdriver_count ], hdr->fname );
strcpy( drivers[ cdriver_count ], thedta.d_fname );
cdriver_count++;
}
}
}
free( DataBuf );
}
else
{
/* memory error - break out of loop and exit routine */
form_alert( 1, alert4 );
break;
}
} while ( ( Fsnext() == E_OK ) && ( cdriver_count < MAX_DRIVERS ) );
SortCDriverNames();
Fsetdta( saved );
}
void main(void)
{
long adr,max,length;
int dummy,handle,freq_div=1;
char tch;
DTA *buf;
Cconws(CLEAR_HOME);
Cconws("Amiga 4/6/8 voices & xxCH DSP Replay Routine by Simplet / FATAL DESIGN\r\n");
Cconws("----------------------------------------------------------------------\r\n\n");
dummy=Fsfirst(MODNAME,0);
buf=Fgetdta();
length=buf->d_length;
if (dummy!=0)
{
Cconws("Disk Error!\r\nPress any key...");
Crawcin();exit();
}
Cconws("Allocating Memory...");
adr=Malloc(length+20832); /* Workspace takes up to 20832 bytes */
if (adr<=0)
{
Cconws("Error!\r\nNot enough Memory to load!\r\nPress any key...");
Crawcin();exit();
}
Cconws("Ok!\r\nLoading Module...");
handle=Fopen(MODNAME,FO_READ);
Fread(handle,length,adr);
Fclose(handle);
Cconws("\r\nInitialising Module and Samples...");
dummy=MGTK_Init_Module_Samples(adr,adr+length+20832);
if (dummy==-3)
{
Cconws("Error!\r\n");
Cconws("Not enough workspace to prepare samples!\r\n");
Cconws("Press any key...");
Crawcin();exit();
}
Cconws("Ok!\r\nInitialising DSP Program...");
dummy=MGTK_Init_DSP();
if (dummy!=0)
{
Cconws("Error!\r\n");
Cconws("DSP Program couldn't be loaded!\r\n");
Cconws("Press any key...");
Crawcin();exit();
}
Cconws("Ok!\r\n\n");
MGTK_Save_Sound();
MGTK_Init_Sound();
MGTK_Set_Replay_Frequency(freq_div);
MGTK_Restart_Loop=-1;
MGTK_Play_Music();
Cconws("You can use the following keys :\r\n");
Cconws(" - or + for previous or next music position\r\n");
Cconws(" / or * for previous or next replay frequency\r\n");
Cconws(" L for play, P for pause, S for stop\r\n");
Cconws(" Space to quit\r\n");
do
{
tch=Crawcin();
switch ( tch-32*((97<=tch) && (tch<=122)) )
{
case '-': MGTK_Previous_Position();break;
case '+': MGTK_Next_Position();break;
case '/': if (freq_div>1)
MGTK_Set_Replay_Frequency(--freq_div);break;
case '*': if (freq_div<5)
MGTK_Set_Replay_Frequency(++freq_div);break;
case 'L': MGTK_Play_Music();break;
case 'P': MGTK_Pause_Music();break;
case 'S': MGTK_Stop_Music();break;
}
}
while (tch!=*" ");
MGTK_Stop_Music();
MGTK_Restore_Sound();
}
long x_xreaddir(XDIR *dir, char *buffer, int len, XATTR *attrib)
{
#if _MINT_
if (mint) /* HR 151102 */
{
if (dir->type)
{
/*
* DOS file system.
*/
int error;
if (dir->data.gdata.first != 0)
{
char *fspec;
if ((fspec = x_makepath(dir->path, "*.*", &error)) != NULL)
{
#if USE_gemdos
error = xerror((int) gemdos(78, fspec, 0x37));
#else
error = xerror(Fsfirst(fspec, 0x37));
#endif
free(fspec);
dir->data.gdata.first = 0;
}
}
else
#if USE_gemdos
error = xerror((int) gemdos(79));
#else
error = xerror(Fsnext());
#endif
if (error == 0)
{
if (strlen(dir->data.gdata.dta.d_fname) + 1 > len)
error = EFNTL;
else
{
strupr(dir->data.gdata.dta.d_fname); /* HR 151102: arrogant MiNT tampering with filenames. */
strncpy(buffer, dir->data.gdata.dta.d_fname, len);
dta_to_xattr(&dir->data.gdata.dta, attrib);
}
}
return (long) error;
}
else
{
/*
* File system with long filenames.
* HR 130203: Use Dxreaddir in stead of Dreaddir,
* handle links correctly.
*/
int h;
char str[260];
long error, rep;
if ((error = Dxreaddir(len, dir->data.handle, str, (long)attrib, &rep)) == 0)
strcpy(buffer, &str[4]);
if (error == 0)
return error;
return (long) xerror((int) error);
}
}
else
#endif
{
int error;
if (dir->data.gdata.first != 0)
{
char *fspec;
if ((fspec = x_makepath(dir->path, "*.*", &error)) != NULL)
{
#if USE_gemdos
error = xerror((int) gemdos(78, fspec, 0x37));
#else
error = xerror(Fsfirst(fspec, 0x37));
#endif
free(fspec);
dir->data.gdata.first = 0;
}
}
else
#if USE_gemdos
error = xerror((int) gemdos(79));
#else
error = xerror(Fsnext());
#endif
if (error == 0)
{
if (strlen(dir->data.gdata.dta.d_fname) + 1 > len)
error = EFNTL;
else
{
strncpy(buffer, dir->data.gdata.dta.d_fname, len);
dta_to_xattr(&dir->data.gdata.dta, attrib);
}
}
return (long) error;
}
}
/* HandleCache()
* ===================================================================
*/
int
HandleCache( int button, WORD *msg )
{
int quit;
int out;
int error;
quit = FALSE;
/* Handle Double-clicking of the objects */
if( ( button != -1 ) && ( button & 0x8000 ) )
button &= 0x7FFF;
switch( button )
{
case CCANCEL:
Current.SpeedoCacheSize = OldSpeedoCache;
Current.speedo_percent = OldPercent;
Current.BitMapCacheSize = OldBitMapSize;
case C*K:
Deselect( button );
if( button == C*K )
{
DoValuesCheck();
CacheCheck();
}
Reset_Tree( ad_options );
Objc_draw( tree, ROOT, MAX_DEPTH, NULL );
break;
case LCACHE:
case MCACHE:
case SCACHE:
if( SpeedoFlag )
{
sprintf( cache_path, "%s\\", OutlinePath );
out = fsel_name( FALSE, cache_path, "*.SPC", cache_text[ button - LCACHE ] );
if( ( ( out == A_OK ) || ( out == A_CANCEL )) && ( cache_path[0] != '\0' ) )
{
if( out == A_OK )
{
/* Check if the file exists first */
if(( button == LCACHE ) || ( button == MCACHE ))
{
olddma = Fgetdta();
Fsetdta( &newdma ); /* Point to OUR buffer */
error = Fsfirst( cache_path, 0 );/* Normal file search for 1st file */
if( error != E_OK ) /* No such files! */
{
Fsetdta( olddma ); /* Point to OLD buffer */
form_alert( 1, nofile );
XDeselect( tree, button );
return( quit );
}
}
if( open_vwork() )
{
switch( button )
{
case LCACHE:
out = v_loadcache( vhandle, cache_path, TRUE );
break;
case MCACHE:
out = v_loadcache( vhandle, cache_path, FALSE ); /* append, merge */
break;
case SCACHE:
out = v_savecache( vhandle, cache_path );
break;
default:
break;
}
if( out == -1 )
form_alert( 1, alert19 );
close_vwork();
}
else
form_alert( 1, alert18 );
}
}
Calc_Cache( TRUE );
}
XDeselect( tree, button );
break;
case CCACHE:
if( SpeedoFlag )
{
if( form_alert( 1, alert17 ) == 1 )
{
if( open_vwork())
{
if( v_flushcache( vhandle ) == -1 )
form_alert( 1, alert19 );
close_vwork();
}
else
form_alert( 1, alert18 );
Calc_Cache( TRUE );
}
}
XDeselect( tree, button );
break;
case MUP:
case MDOWN:
Up_Down_Arrow( button, MUP, &MiscSizeText[0], &mcache, MSIZE );
break;
case BUP:
case BDOWN:
Up_Down_Arrow( button, BUP, &BitSizeText[0], &Current.BitMapCacheSize, BSIZE );
break;
case CUP:
case CDOWN:
Up_Down_Arrow( button, CUP, &CharSizeText[0], &ccache, CSIZE );
break;
default:
if( button == -1 )
{
switch( msg[0] )
{
case WM_REDRAW:
break;
case AC_CLOSE:
quit = TRUE;
break;
case WM_CLOSED:
quit = TRUE;
DoValuesCheck();
CloseWindow();
break;
case CT_KEY:
break;
default:
break;
}
}
break;
}
return( quit );
}
/* get_bitpath()
* ====================================================================
* Get the font path from the ASSIGN.SYS
* If there is NO ASSIGN.SYS, we substitute C: or A: instead.
*
*/
void
get_bitpath( void )
{
int i, sys_file;
long j;
int error;
char *fname;
int alen;
olddma = Fgetdta();
Fsetdta( &newdma ); /* Point to OUR buffer */
strcpy( epath, "C:\\ASSIGN.SYS" );
epath[0] = GetBaseDrive();
bufptr = 0L;
BufferSize = 0L;
error = Fsfirst( epath, 0 ); /* Normal file search for 1st file */
if( error == 0 )
{ /* found it! */
bufptr = calloc( 1, newdma.d_length * 2L );
if( bufptr )
{
BufferSize = newdma.d_length;
if( (sys_file = Fopen( epath, 0 )) < 0)
{
Fsetdta( olddma ); /* Point to OLD buffer */
if( bufptr )
{
free( bufptr );
bufptr = 0L;
}
form_alert( 1, alert1 );
return;
}
path_found = FALSE;
do
{
i = 0;
alen = (int)Fread( sys_file, BufferSize, bufptr );
do
{
if( !strncmp( &bufptr[i], "path", 4) ||
!strncmp( &bufptr[i], "PATH", 4) )
{
strcpy( epath, extract_path( &i, alen ) );
path_found = TRUE;
goto done;
}
else
{
while(( bufptr[i] != '\n' ) && ( i < alen )) {
++i; /* Skip to newline */
}
++i;
}
} while( i < alen );
} while( alen == BufferSize );
done:
Fclose( sys_file );
if( bufptr )
{
free( bufptr );
bufptr = 0L;
}
j = strlen( epath );
if( epath[ j - 1 ] == '\\' )
epath[ j - 1 ] = '\0';
}
else
form_alert( 1, alert1 );
}
Fsetdta( olddma ); /* Point to OLD buffer */
fname = &epath[0];
fname = strupr( fname );
}
