/*******************************************************************************
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;
}
mlx_extract()
{
char filename[13],pathname[80];
char *ext;
int nblocks,block;
register int i;
long blockptr[MAXNBLOCKS+1];
long addr[32],leng[32]; /* oversized */
long end_record= idEND;
GLOBRECORD *ptr;
/* load multi-block file containing block to be extracted */
Dsetdrv(mlt_drive); dsetpath(mlt_path);
if (!readdatafile(MLXEXTTITL,mlxfile,mlxpath,MLX_EXT,0)) return;
mlt_drive= Dgetdrv(); Dgetpath(mlt_path,mlt_drive+1);
mlx_mem= tempmem;
/* choose block from it */
nblocks= scan_blocks(heap[mlx_mem].start,blockptr);
if (!nblocks) return; /* can't happen? */
block= select_block(BLOCK2EXT,nblocks,blockptr);
if ( (block<0) || (block>=nblocks) ) return;
/* name of data file defaults to block comment */
Dsetdrv(data_drive); dsetpath(data_path);
ptr= (GLOBRECORD*)(blockptr[block]);
copy_bytes(ptr->comment,filename,12L);
filename[12]=0;
ext=filename;
for (i=0; i<9; i++) if (ext[i]=='.') break;
if (i<9)
ext+=(i+1);
else
ext= ALL_EXT;
if (getfile(pathname,filename,ext,MLXXDATTITL)<=0) return;
data_drive= Dgetdrv(); Dgetpath(data_path,data_drive+1);
/* build file -- */
i=0;
/* -- header */
addr[i]= (long)(&dataheader);
leng[i++]= sizeof(dataheader);
/* -- the selected block */
addr[i]= blockptr[block];
leng[i++]= blockptr[block+1] - blockptr[block] ;
/* -- end record */
addr[i]= (long)(&end_record);
leng[i++]= 4;
save_file(filename,pathname,i,addr,leng);
} /* end mlx_extract() */
void test010203(void)
{
WORD res;
BYTE ok;
WORD drives = Drvmap();
WORD dr2 = drives & (~drive); // remove tested drive
int drvExisting = -1;
int drvNonexisting = -1;
int i;
for(i=15; i>= 0; i--) {
if((dr2 & (1 << i)) != 0) { // drive exists?
drvExisting = i;
}
if((dr2 & (1 << i)) == 0) { // drive doesn't exist?
if(i == drive) { // if it's not in dr2, but it's our drive, skip it
continue;
}
drvNonexisting = i;
}
}
res = Dsetdrv(drvExisting); // switch to existing drive
ok = drives == res; // OK when returns existing drives
if(ok) {
WORD drv = Dgetdrv();
ok = drvExisting == drv; // OK if drive changed
if(!ok) {
out_swsw("Was switching to ", drvExisting, ", Dgetdrv returned ", drv);
}
}
out_tr_b(0x0102, "Dsetdrv to existing drive", ok);
res = Dsetdrv(drvNonexisting); // switch to non-existing drive
ok = drives == res; // OK when returns existing drives
if(ok) {
WORD drv = Dgetdrv();
ok = drvNonexisting == drv; // TOS 1.02: OK if drive change to non-existing anyway
if(!ok) {
out_swsw("Was switching to ", drvNonexisting, ", Dgetdrv returned ", drv);
}
}
out_tr_b(0x0103, "Dsetdrv to non-existing drive", ok);
}
void createTestFiles(void)
{
Dsetdrv(drive); // switch to selected drive
Dsetpath("\\");
(void) Dcreate("TESTDIR");
Dsetpath("\\TESTDIR");
int i, f;
char numString[8];
char fileName[16];
for(i=0; i<25; i++) {
byteToHex(i + 1, numString);
strcpy(fileName, "FILE_");
strcat(fileName, numString);
f = Fcreate(fileName, 0);
Fwrite(f, 7, fileName);
Fclose(f);
strcpy(fileName, "FILENAME.X");
strcat(fileName, numString);
f = Fcreate(fileName, 0);
Fwrite(f, 12, fileName);
Fclose(f);
strcpy(fileName, "DIR_");
strcat(fileName, numString);
(void) Dcreate(fileName);
}
}
mlx_name()
{
int nblocks,block;
GLOBRECORD *blockptr[MAXNBLOCKS+1];
long addr[32],leng[32]; /* oversized */
/* load multi-block file containing block to be renamed */
Dsetdrv(mlt_drive); dsetpath(mlt_path);
if (!readdatafile(MLXNAMTITL,mlxfile,mlxpath,MLX_EXT,0)) return;
mlt_drive= Dgetdrv(); Dgetpath(mlt_path,mlt_drive+1);
mlx_mem= tempmem;
/* choose block from it */
nblocks= scan_blocks(heap[mlx_mem].start,blockptr);
if (!nblocks) return; /* can't happen? */
block= select_block(BLOCK2NAM,nblocks,blockptr);
if ( (block<0) || (block>=nblocks) ) return;
/* edit the comment field in the selected block, and replace file
without warning */
if (_mlx_name(blockptr[block]->comment))
{
addr[0]= heap[mlx_mem].start;
leng[0]= heap[mlx_mem].nbytes;
save_file(mlxfile,mlxpath,-1,addr,leng);
}
} /* end mlx_name() */
ex_loadtem()
{
#if TEMFLAG
char filename[13],pathname[80];
long load_file();
/* overwrite changed template? */
if (change_flag[temCHANGE])
if (form_alert(1,CHNGETEM)==2) return;
filename[0]=0;
Dsetdrv(tem_drive); dsetpath(tem_path);
tempmem= -1;
if (getfile(pathname,filename,TE_EXT,TLDETITL)>0)
{
tem_drive=Dgetdrv(); Dgetpath(tem_path,tem_drive+1);
if (load_file(pathname,filename))
{
if (load_tem(filename))
{
strcpy(temfile,filename);
}
} /* end if file loaded successfully */
} /* end if ok from file selector */
dealloc_mem(tempmem);
#endif
} /* end ex_loadtem() */
long x_setdrv(int drive)
{
#if USE_gemdos
return gemdos(14, drive);
#else
return Dsetdrv(drive);
#endif
}
void test01(void)
{
out_s("Dsetdrv and Dgetdrv");
test0101(); // switch to selected drive
test010203(); // switch to existing and non-existing drive
test0104(); // switch to drive which is out of range (> 15)
Dsetdrv(drive); // back to selected drive
out_s("");
}
mlx_delete()
{
int nblocks,block;
register int i;
long blockptr[MAXNBLOCKS+1];
long addr[32],leng[32]; /* oversized */
long end_record= idEND;
/* load multi-block file containing block to be deleted */
Dsetdrv(mlt_drive); dsetpath(mlt_path);
if (!readdatafile(MLXDELTITL,mlxfile,mlxpath,MLX_EXT,0)) return;
mlt_drive= Dgetdrv(); Dgetpath(mlt_path,mlt_drive+1);
mlx_mem= tempmem;
/* choose block from it */
nblocks= scan_blocks(heap[mlx_mem].start,blockptr);
if (!nblocks) return; /* can't happen? */
if (nblocks==1)
{
form_alert(1,BADMLXDEL);
return;
}
block= select_block(BLOCK2DEL,nblocks,blockptr);
if ( (block<0) || (block>=nblocks) ) return;
/* build file -- */
i=0;
/* -- header */
addr[i]= (long)(&dataheader);
leng[i++]= sizeof(dataheader);
/* -- blocks before the selected block */
if (block>0)
{
addr[i]= blockptr[0];
leng[i++]= blockptr[block] - blockptr[0] ;
}
/* -- blocks after the selected block */
if (block<(nblocks-1))
{
addr[i]= blockptr[block+1];
leng[i++]= blockptr[nblocks] - blockptr[block+1] ;
}
/* -- end record */
addr[i]= (long)(&end_record);
leng[i++]= 4;
save_file(mlxfile,mlxpath,-i,addr,leng); /* replace without warning */
} /* end mlx_delete() */
/*******************************************************************************
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;
}
static void setSpoolPath(void)
{
if (spoolDir) {
if (spoolDir[0] != '\0'
&& spoolDir[1] == ':') { /* drive spec? */
Dsetdrv(tolower(spoolDir[0]) - 'a');
}
if (Dsetpath(spoolDir) < 0) {
uiPrintf(uiH, uiPrERR, "set path|>%s<", spoolDir);
}
}
} /* setSpoolPath */
void test0101(void)
{
WORD res;
BYTE ok;
WORD drives = Drvmap();
res = Dsetdrv(drive);
ok = drives == res; // OK if returning bitmap of drives
if(ok) {
WORD drv = Dgetdrv();
ok = drive == drv; // OK if drive changed
}
out_tr_b(0x0101, "Dsetdrv to selected drive", ok);
}
void test0104(void)
{
WORD res;
BYTE ok;
#define DRIVE_OUT_OF_RANGE 30
WORD drives = Drvmap();
res = Dsetdrv(DRIVE_OUT_OF_RANGE); // switch to out of range drive
ok = drives == res; // OK when returns existing drives
if(ok) {
WORD drv = Dgetdrv();
ok = DRIVE_OUT_OF_RANGE == drv; // OK if drive changed
if(!ok) {
out_swsw("Was switching to ", DRIVE_OUT_OF_RANGE, ", Dgetdrv returned ", drv);
}
}
out_tr_b(0x0104, "Dsetdrv to out of range", ok);
}
ex_paths()
{
#if DISKFLAG
int done,mstate,edit_obj,exit_obj;
register int i,temp;
#define NPATHS 7
char *ptr[NPATHS];
static int obj[NPATHS]= {
PATHCNX,PATHMAC,PATHTEM,PATHLDAT,PATHRDAT,PATHMIDI,PATHMULT
};
static int *drive[NPATHS]= {
&cnx_drive,&mac_drive,&tem_drive,
&ldat_drive,&rdat_drive,&midi_drive,&mlt_drive
};
static char *path[NPATHS]= {
cnx_path,mac_path,tem_path,
ldat_path,rdat_path,midi_path,mlt_path
};
static int findobj[NPATHS]= {
FINDCNX,FINDMAC,FINDTEM,FINDLDAT,FINDRDAT,FINDMIDI,FINDMULT
};
static char *title[NPATHS]= {
FINDCNXMSG,FINDMACMSG,FINDTEMMSG,FINDLDATMSG,
FINDRDATMSG,FINDMIDIMSG,FINDMULTMSG
};
static char *ext[NPATHS]= {
CNXF_EXT, MAXC_EXT, TE_EXT, ALL_EXT, ALL_EXT, ALL_EXT, MLX_EXT
};
char filename[13],pathname[80];
for (i=0; i<NPATHS; i++)
{
ptr[i]= pathaddr[obj[i]].ob_spec;
ptr[i][0]= 'A' + *drive[i];
ptr[i][1]= ':';
strcpy(ptr[i]+2,path[i]);
}
/* draw dialog box, centered */
putdial(pathaddr,-1,0);
edit_obj= -1;
done=0;
do
{
waitmouse(); /* no mouse repeat */
exit_obj= my_form_do(pathaddr,&edit_obj,&mstate,0,&dummy);
switch (exit_obj)
{
case OKPATH:
for (i=0; i<NPATHS; i++)
{
if (ptr[i][1]==':')
{
temp= ptr[i][0]-'A';
if ((temp>=0)&&(temp<16)) *drive[i]=temp;
strcpy(path[i],ptr[i]+2);
}
else
strcpy(path[i],ptr[i]);
}
case CANPATH: done=1; break;
default:
for (i=0; i<NPATHS; i++) if (exit_obj==findobj[i]) break;
putdial(0L,0,exit_obj);
Dsetdrv(ptr[i][0]-'A');
if (ptr[i][1]==':')
dsetpath(ptr[i]+2);
else
dsetpath(ptr[i]);
filename[0]=0;
if (getfile(pathname,filename,ext[i],title[i]))
{
ptr[i][0]= (temp=Dgetdrv()) + 'A';
ptr[i][1]= ':';
Dgetpath(ptr[i]+2,temp+1);
if (!ptr[i][2])
{
ptr[i][2]='\\';
ptr[i][3]=0;
}
}
putdial(pathaddr,-1,0);
} /* end switch */
}
while (!done);
putdial(0L,0,exit_obj);
#endif
} /* end ex_paths() */
int
chkdf( char *str, int flag )
{
REG int ret;
int first,change;
int ret1;
first = TRUE;
change = f_rename;
if ( flag == CPFILE )
{
if ( f_rename )
goto cc_3;
if ( write_save ) /* overwrite existing file */
return( OK );
cc_1: if ( (ret = (WORD)Fopen(fixdst, 0)) >= 0 )
{ /* file exist */
Fclose( ret );
cc_3: ret = edname( str, CPFILE, change );
if ( ret == CHECK )
{
if ( f_rename ) /* do rename */
{
/* first = FALSE; */
change = FALSE;
goto cc_1;
}
}
return( ret );
}
}
else
{
if ( f_rename ) /* if rename then show box first */
goto cc_5;
cc_6: Dsetdrv(*fixdst - 'A');
if ( !( ret = (WORD)Dsetpath( fixdst + 2 ) ) ) /* direcory exist */
{
cc_5: ret1 = edname( str, CPDIR, change ); /* update name conflict box */
change = FALSE;
if ( ( ret1 == CHECK ) || /* user enter new name */
( ( ret1 == COPY ) && f_rename && first ) )
{
first = FALSE;
goto cc_6;
}
return( ret1 );
}
}
/* 0xFFDE: path not found. 0xFFDF: file not found. */
return (((ret == EFILNF)||(ret == EPTHNF))? OK:FALSE);
}
/*******************************************************************************
Multi FileSelect
FileSelect �volu� permettant de traiter un ensemble de fichiers en une
seule passe.
S�lection des fichiers avec Selectric; ou � l'aide de joker.
On appelle ensuite en boucle la fonction (*call) avec comme unique
param�tre le nom complet du fichier.
De plus; le joker # permet de remplacer un num�ro de fichier. Par exemple
le masque TOTO####.TXT cherchera le fichier TOTO0001.TXT puis les suivants.
*******************************************************************************/
int _multifsel(char *pfname,char *pname,char *fname,char *ext,char *title,int cdecl (*call)(char *name))
{
DTA *dta;
long k,n,m;
char path[FILENAME_MAX];
char mask[20];
char *p;
int drvold=-1;
int is_slct_da,num=0;
int i,j=1,Break;
p=glb.div.buf;
is_slct_da=_slctMoreNames(1,512,glb.div.buf);
i=_fselect(pfname,pname,fname,ext,title);
if (i)
{
Break=FALSE;
if (is_slct_da)
{
while (*p && j && !Break)
{
num+=1;
strcpy(path,pname);
fname[0]=0;
while (*p && *p!=' ')
strncat(fname,p++,1L);
strcat(path,"\\");
strcat(path,fname);
p++;
if (call)
j=(*call)(path);
}
}
if (num==0)
{
if (pname[1]==':')
{
drvold=Dgetdrv();
Dsetdrv((int)pfname[0]-65);
}
p=strchr(pfname,'#');
if (p) /* Gestion du masque # */
{
n=0L;
while (*p++=='#')
n+=1L;
p=strchr(pfname,'#'); /* pfname=C:\TOTO\TITI.EXT\TATA##O.JPG" n=2 */
*p='\0';
strcpy(path,pfname); /* path=C:\TOTO\TITI.EXT\TATA */
sprintf(mask,"%%s%%0%lili%%s",n); /* mask='%s%02li%s' */
m=1L;
for (k=0;k<n;k++)
m*=10L;
for (k=0;k<m;k++)
{
sprintf(path,mask,pfname,k,&p[n]);
if (!_fexist(path,NULL))
k=m;
else if (call)
j=(*call)(path);
if (!j)
k=m;
}
}
else
if (!Fsfirst(pfname,FA_READONLY+FA_HIDDEN+FA_SYSTEM+FA_ARCHIVE))
{
dta=Fgetdta();
do
{
strcpy(path,pname);
strcat(path,"\\");
strcat(path,dta->d_fname);
if (call)
j=(*call)(path);
} while (!Fsnext() && j && !Break);
}
if (drvold!=-1)
Dsetdrv(drvold);
}
Break=FALSE;
}
return num;
}
mlx_replace()
{
char filename[13],pathname[80];
int mlxnblocks,mlxblock;
int datnblocks,datblock;
long mlxblockptr[MAXNBLOCKS+1];
long datblockptr[MAXNBLOCKS+1];
register int i;
long addr[32],leng[32]; /* oversized */
long end_record= idEND;
/* load data file containing block to be added */
Dsetdrv(data_drive); dsetpath(data_path);
filename[0]=0;
if (!readdatafile(MLXRDATTITL,filename,pathname,ALL_EXT,0)) return;
data_drive= Dgetdrv(); Dgetpath(data_path,data_drive+1);
data_mem= tempmem;
/* choose block from it */
datnblocks= scan_blocks(heap[data_mem].start,datblockptr);
if (!datnblocks) return; /* can't happen? */
datblock= select_block(BLOCK2REP,datnblocks,datblockptr);
if ( (datblock<0) || (datblock>=datnblocks) ) return;
/* load multi-block file to receive block */
Dsetdrv(mlt_drive); dsetpath(mlt_path);
if (!readdatafile(MLXREPTITL,mlxfile,mlxpath,MLX_EXT,0)) return;
mlt_drive= Dgetdrv(); Dgetpath(mlt_path,mlt_drive+1);
mlx_mem= tempmem;
/* choose block from it */
mlxnblocks= scan_blocks(heap[mlx_mem].start,mlxblockptr);
if (!mlxnblocks) return; /* can't happen? */
mlxblock= select_block(BLOCK2BRP,mlxnblocks,mlxblockptr);
if ( (mlxblock<0) || (mlxblock>=mlxnblocks) ) return;
/* because data_mem may have moved */
scan_blocks(heap[data_mem].start,datblockptr);
/* build file -- */
i=0;
/* -- header */
addr[i]= (long)(&dataheader);
leng[i++]= sizeof(dataheader);
/* -- blocks before the selected block */
if (mlxblock>0)
{
addr[i]= mlxblockptr[0];
leng[i++]= mlxblockptr[mlxblock] - mlxblockptr[0] ;
}
/* -- new block */
addr[i]= datblockptr[datblock];
leng[i++]= datblockptr[datblock+1] - datblockptr[datblock] ;
/* -- blocks after the selected block */
if (mlxblock<(mlxnblocks-1))
{
addr[i]= mlxblockptr[mlxblock+1];
leng[i++]= mlxblockptr[mlxnblocks] - mlxblockptr[mlxblock+1] ;
}
/* -- end record */
addr[i]= (long)(&end_record);
leng[i++]= 4;
save_file(mlxfile,mlxpath,-i,addr,leng); /* replace without warning */
} /* end mlx_replace() */
/*******************************************************************************
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;
}
int analyse_parameter(int argc,char *argv[],void **search_pfade)
{
int zahl_der_pfade;
int i,ARGV;
char *arg;
struct pfadkette *help;
ARGV=0;
if(getenv("ARGV"))
ARGV=1;
for(i=0;i<argc-1-ARGV;i++)
{
if(argv[i+1-ARGV][0]=='\'')
{
int von,nach;
von=1;
nach=0;
do {
if(argv[i+1-ARGV][von]=='\'')
von++;
argv[i+1-ARGV][nach]=argv[i+1-ARGV][von];
nach++;
} while(argv[i+1-ARGV][von++]);
}
}
zahl_der_pfade=0;
for(i=0;i<argc-1-ARGV;i++)
{
arg=argv[i+1-ARGV];
if(arg[0]=='-')
{
if(arg[1]=='D')
{
int i;
i=2;
while(arg[i]!='\0')
{
zahl_der_pfade++;
i++;
}
}
else if(arg[1]=='P')
{
zahl_der_pfade++;
}
}
else
{
zahl_der_pfade++;
}
}
if(zahl_der_pfade==0)
{
int j;
char *dm;
char lwks[]="_______________________";
dm=getenv("DRIVEMAP");
if(!dm || !strlen(dm))
{
long lwk;
dm=lwks;
lwk=Dsetdrv(Dgetdrv());
if(lwk & 0x03effffcl) /* Gibt es ein Laufwerk au�er a,b und u? */
lwk&=0x03effffcl; /* ... dann a,b und u ausblenden */
j=0;
i=0;
do {
if(lwk & 1)
{
lwks[j++]=i+'A';
}
i++;
lwk/=2;
} while(lwk);
lwks[j]='\0';
}
zahl_der_pfade=(int) strlen(dm);
help=(struct pfadkette *)search_pfade;
help->next=NULL;
for(i=0;i<zahl_der_pfade;i++)
{
help->next=malloc(sizeof(struct pfadkette)+3);
if(help->next)
{
help=help->next;
help->next=NULL;
help->selected=0;
help->pfad[0]=dm[i];
help->pfad[1]=':';
help->pfad[2]='\\';
help->pfad[3]='\0';
}
else
{
free_pfade(*search_pfade);
return -1;
}
}
return zahl_der_pfade;
}
help=(struct pfadkette *)search_pfade;
help->next=NULL;
zahl_der_pfade=0;
for(i=0;i<argc-1-ARGV;i++)
{
arg=argv[i+1-ARGV];
if(arg[0]=='-')
{
if(arg[1]=='D')
{
int j;
j=2;
while(arg[j]!='\0')
{
help->next=malloc(sizeof(struct pfadkette)+3);
if(help->next)
{
help=help->next;
help->next=NULL;
help->selected=0;
help->pfad[0]=arg[j];
help->pfad[1]=':';
help->pfad[2]='\\';
help->pfad[3]='\0';
j++;
zahl_der_pfade++;
}
else
{
free_pfade(*search_pfade);
return -1;
}
}
}
else if(arg[1]=='P')
{
/* Struct + String + ggf. '\\' */
help->next=malloc(sizeof(struct pfadkette)+
strlen(&arg[2])+
(arg[strlen(arg)-1]!='\\'));
if(help->next)
{
help=help->next;
help->next=NULL;
help->selected=0;
strcpy(help->pfad,&arg[2]);
if(help->pfad[strlen(help->pfad)-1]!='\\')
strcat(help->pfad,"\\");
zahl_der_pfade++;
}
else
{
free_pfade(*search_pfade);
return -1;
}
}
}
else
{
/* Struct + String + ggf. '\\' */
help->next=malloc(sizeof(struct pfadkette)+
strlen(arg)+
(arg[strlen(arg)-1]!='\\'));
if(help->next)
{
help=help->next;
help->next=NULL;
help->selected=0;
strcpy(help->pfad,arg);
if(help->pfad[strlen(help->pfad)-1]!='\\')
{ /* Unter Umst�nden wurde eine Datei �bergeben */
long j;
/* Hinten ein '\\' anh�ngen */
strcat(help->pfad,"\\");
for(j=strlen(help->pfad)-2;j>=0;j--)
{
if(help->pfad[j]=='\\')
{
help->pfad[j+1]='\0';
j=-1;
}
}
}
zahl_der_pfade++;
}
else
{
free_pfade(*search_pfade);
return -1;
}
}
}
/* doppelte Pfade entfernen */
zahl_der_pfade-=remove_double_paths(&suji.search_pfade);
return zahl_der_pfade;
}
mlx_add()
{
long blockptr[MAXNBLOCKS+1];
char filename[13],pathname[80];
int block,nblocks,create_it;
register int i;
long addr[32],leng[32]; /* oversized */
long end_record= idEND;
/* load data file containing block to be added */
Dsetdrv(data_drive); dsetpath(data_path);
filename[0]=0;
if (!readdatafile(MLXDATTITL,filename,pathname,ALL_EXT,0)) return;
data_drive= Dgetdrv(); Dgetpath(data_path,data_drive+1);
data_mem= tempmem;
/* choose block from it */
nblocks= scan_blocks(heap[data_mem].start,blockptr);
if (!nblocks) return; /* can't happen? */
block= select_block(BLOCK2ADD,nblocks,blockptr);
if ( (block<0) || (block>=nblocks) ) return;
/* load multi-block file to receive block */
Dsetdrv(mlt_drive); dsetpath(mlt_path);
create_it= readdatafile(MLXADDTITL,mlxfile,mlxpath,MLX_EXT,1);
if (!create_it) return;
if (create_it<0)
{
if (form_alert(1,CHEKCREMLX)!=1) return;
create_it=1;
}
else
create_it=0;
mlt_drive= Dgetdrv(); Dgetpath(mlt_path,mlt_drive+1);
mlx_mem= tempmem;
/* because data_mem may have moved */
scan_blocks(heap[data_mem].start,blockptr);
/* build file -- */
i=0;
/* -- header */
addr[i]= (long)(&dataheader);
leng[i++]= sizeof(dataheader);
/* -- if file already exists, chop header off start, end_record off end */
if (!create_it)
{
addr[i]= heap[mlx_mem].start + sizeof(dataheader);
leng[i++]= heap[mlx_mem].nbytes - 4 - sizeof(dataheader);
}
/* -- the new block */
addr[i]= blockptr[block];
leng[i++]= blockptr[block+1] - blockptr[block];
/* -- end_record */
addr[i]= (long)(&end_record);
leng[i++]= 4;
save_file(mlxfile,mlxpath,-i,addr,leng); /* replace without warning */
} /* end mlx_add() */
