home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Frozen Fish 2: PC
/
frozenfish_august_1995.bin
/
bbs
/
d09xx
/
d0995.lha
/
WhatIs
/
c
/
For.c
< prev
next >
Wrap
C/C++ Source or Header
|
1994-04-05
|
20KB
|
710 lines
/*
* Copyright ⌐ 1991 by S.R. & P.C.
*
* Created: 23 May 1992 12:00:40
* Modified: 18 Mar 1993 22:35:21
*
* Make>> sc <file>.c
* Make>> SLink LIB:cs.o <file>.o SC SD BATCH NOICONS LIB LIB:Startup.lib LIB:String.lib
*/
#include <libraries/WhatIsBase.h>
#include <proto/WhatIs.h>
struct Library *WhatIsBase = NULL;
/* have problem whith stack size so I reduce string len */
#define MAXSTRINGLEN 255/2
#define MAXCMDLEN 512/2
#define MAX_PATHLEN 512
/*ULONG const MaxStringLen = MAXSTRINGLEN;*/
#define MAXNUMARGS 64
#define MAXDEFAULTLEN 512/2
/* char used in the filetype spec string */
#define NOTFileType '!'
#define ONLYFileType '%'
#define WHITHSubSub '#'
STRPTR Template = "Pattern/M,Files/K,Dirs/K,Since/K,Before/K,MinSize/K/N,MaxSize/K/N,PosProtect/K,NegProtect/K,Type/K,ALL/K/S,ASYNC/K/S,READSIZE/N,SHOWBYTE/N,D=DEEP/K/N,SFT=SHOWFILETYPE/K/S,DO/K/F";
#define ARG_NameA 0
#define ARG_Files 1
#define ARG_Dirs 2
#define ARG_Since 3
#define ARG_Before 4
#define ARG_MinSize 5
#define ARG_MaxSize 6
#define ARG_PosProtect 7
#define ARG_NegProtect 8
#define ARG_Type 9
#define ARG_ALL 10
#define ARG_ASYNC 11
#define ARG_READSIZE 12
#define ARG_SHOWBYTE 13
#define ARG_DEEPWHATIS 14
#define ARG_SHOWFILETYPE 15
#define ARG_CMD 16
#define ARG_ENDARG 17
STRPTR CliHelp = "For V2.0
⌐ 1992 S.R. & P.C.
\n\
Usage: For <Pattern> [FILES <MATCH|YES|NO>] [DIRS <MATCH|YES|NO>] [Since <Date>] [Before <Date>] [MinSize <Number>] [MaxSize <Number>] [PosProtect <L|C|H|S|P|A|R|W|E|D>] [NegProtect <L|C|H|S|P|A|R|W|E|D>] [Type <FileType0...FileType9|%=ONLY|*=SUB|!=EXLC>] [ALL] [ASYNC] [READSIZE] [SHOWBYTE] [DEEPWHATIS] [SHOWFILETYPE] [DO <Command [args] [,Command [args] [,...]]>]\n";
/*******************************************************/
/* not in dos.h !! */
#define FIBB_HIDDEN 7
#define FIBF_HIDDEN (1<<FIBB_HIDDEN)
/* it is my own definition: not standard */
#define FIBB_COMMENT 8
#define FIBF_COMMENT (1<<FIBB_COMMENT)
#define FIBB_LINK 9
#define FIBF_LINK (1<<FIBB_LINK)
#define PATTERN_BUF_SIZE 32
#define MAX_FTS 10 /* Max FileTypeSpec in SelectInfo */
struct FileTypeSpec {
FileType fs_FileType;
UWORD fs_Flags;
};
/* FileTypeSpec flags */
#define FTSF_EXCLUDETYPE 0x0001 /* Exclude this type (otherwise include) */
#define FTSF_WITHSUBTYPES 0x0002 /* Affect Include/Exclude to subtypes */
struct SelectInfo {
UBYTE si_Pattern[PATTERN_BUF_SIZE]; /* Pattern */
UBYTE si_PatTok[PATTERN_BUF_SIZE]; /* PreParsed pattern */
LONG si_MinSize; /* Show files bigger than that */
LONG si_MaxSize; /* and smaller than that */
struct DateStamp si_SinceDate; /* Show files newer than that */
struct DateStamp si_BeforeDate; /* and older than that */
LONG si_SinceSecs; /* date in seconds */
LONG si_BeforeSecs; /* date in seconds */
UWORD si_PosProtect; /* Show files that have these bits set */
UWORD si_NegProtect; /* Show files that have these bits clear */
struct FileTypeSpec si_FileTypes[MAX_FTS]; /* Include and Exclude file types */
UWORD si_NumFts; /* Number of FileTypeSpec in previous array */
UWORD si_Flags; /* Flags. See below */
};
/* SelectInfo flags */
#define SI_ALL_FILES 0x0001
#define SI_MATCH_FILES 0x0002
#define SI_ALL_DIRS 0x0004
#define SI_MATCH_DIRS 0x0008
#define SI_AFFECT_SUBDIRS 0x0010
#define SI_NAME 0x0020
#define SI_SIZE 0x0040
#define SI_SINCEDATE 0x0080
#define SI_BEFOREDATE 0x0100
#define SI_POSPROTECTION 0x0200
#define SI_NEGPROTECTION 0x0400
//
#define SI_INVERT 0x0800 /* Invert filters */
//
#define SI_AFFECT_INFO 0x1000 /* do actions on .info files too (WARNING: also defined as an option (for menu)) */
#define SI_POSFILETYPE 0x2000
#define SI_NEGFILETYPE 0x4000
#define SI_FILETYPE (SI_POSFILETYPE|SI_NEGFILETYPE)
#define SI_MATCHBITS (SI_NAME|SI_SIZE|SI_SINCEDATE|SI_BEFOREDATE|SI_POSPROTECTION|SI_NEGPROTECTION|SI_FILETYPE)
/*************************************************/
/*#pragma tagcall WhatIsBase WhatIs 1E 9802*/
FileType _WhatIsTags(char *Name, Tag FirstTag,...)
{
return (WhatIsBase) ? WhatIs(Name, (struct TagItem *) & FirstTag) : TYPE_UNSCANNED;
}
/*************************************************/
/*
* return pointer to the first non blank char in a string, or to the '\0' if
* the string is empty
*/
static char *FirstNonBlank(char *buf)
{
while (*buf && *buf == ' ')
buf++;
return buf;
}
/* check if buffer is empty or not */
static BOOL IsEmpty(char *buf)
{
return (BOOL) ((*FirstNonBlank(buf)) ? FALSE : TRUE);
}
static BOOL String2Date(char *src, struct DateStamp * ds)
{
struct DateTime *dt;
BOOL Ok = TRUE;
char *s1, *s2;
char buf[PATTERN_BUF_SIZE];
if (!(dt = AllocMem(sizeof(struct DateTime), MEMF_PUBLIC | MEMF_CLEAR)))
return FALSE;
strcpy(buf, src);
s1 = s2 = FirstNonBlank(buf);
if (*s1) {
dt->dat_StrDate = s1;
while (*s2 && *s2 != ' ')
s2++;
if (*s2) {
*s2++ = '\0';
s2 = FirstNonBlank(s2);
}
if (*s2) {
dt->dat_StrTime = s2;
if (!StrToDate(dt))
Ok = FALSE;
}
else if (!StrToDate(dt)) {
dt->dat_StrDate = NULL;
dt->dat_StrTime = s1;
if (!StrToDate(dt))
Ok = FALSE;
}
if (Ok)
*ds = dt->dat_Stamp;
}
FreeMem(dt, sizeof(struct DateTime));
return Ok;
}
/* Convert DateStamp into a number of seconds since 1-Jan-78 */
long Date2Secs(struct DateStamp * ds)
{
return ds->ds_Days * 86400 + ds->ds_Minute * 60 + ds->ds_Tick / 50;
}
/*************************************************/
long __regargs _Main(void)
{
char *ArgV[MAXNUMARGS];
struct RDArgs *RA;
struct RDArgs *DefaultRDArgs;
LONG RC = 20; /* assumle the worst */
if (DOSBase->dl_lib.lib_Version < 37)
return 20;
if (RA = AllocDosObject(DOS_RDARGS, NULL)) {
memset(ArgV, 0, MAXNUMARGS * sizeof(APTR));
RA->RDA_ExtHelp = CliHelp;
/* first read default */
/* getting the default string */
if (DefaultRDArgs = AllocDosObject(DOS_RDARGS, NULL)) {
UBYTE Default[MAXDEFAULTLEN];
if ((DefaultRDArgs->RDA_Source.CS_Length = GetVar("For.DefOpts", Default, MAXDEFAULTLEN - 1, 0L)) > 0) {
/* let ReadArgs() allocate neccesary buffer sinc I use diferrent RDArgs for Default and CLI opts */
/* Ok I succefuly read a Default Option string now parse it */
Default[DefaultRDArgs->RDA_Source.CS_Length++] = '\n'; /* this is need by ReadArgs() */
Default[DefaultRDArgs->RDA_Source.CS_Length] = '\0'; /* this is need by ReadArgs() */
DefaultRDArgs->RDA_Source.CS_Buffer = Default;
DefaultRDArgs->RDA_Source.CS_CurChr = 0;
DefaultRDArgs->RDA_Flags = RDAF_NOPROMPT;
if (!ReadArgs(Template, (long *) ArgV, DefaultRDArgs)) {
PutStr("Error in Default:");
PrintFault(IoErr(), NULL);
memset(ArgV, 0, MAXNUMARGS * sizeof(APTR));
}
DefaultRDArgs->RDA_Source.CS_Buffer = NULL; /* Now ReadArgs() from Command line */
/* the ArgV is leaving unchanged: the second ReadArgs() take actual value as default */
}
}
/* Let ReadArgs() allocate necessay buffer rather using stack space */
if (ReadArgs(Template, (long *) ArgV, RA))
RC = Main(ArgV, NULL);
else
PrintFault(IoErr(), NULL);
FreeDosObject(DOS_RDARGS, RA);
/* Free RDargs now I don't need the option value */
if (DefaultRDArgs)
FreeDosObject(DOS_RDARGS, DefaultRDArgs);
}
return RC;
}
/**** ****/
void RemoveDir(char FullDir[])
{
char *s;
if (s = PathPart(FullDir))
*s = '\0';
}
void PrintByte(UBYTE Buffer[], long BufLen, UBYTE Num)
{
register short i;
for (i = 0; i < Num && i < BufLen; i++)
Printf("%02lx", (long) Buffer[i]);
}
/*
* Parse a line that may contain comas. Backslash ('\') is the override char.
*/
void ParseCmdLine(char *cmd)
{
char *s, *d, c;
s = d = cmd;
while (c = *d++ = *s++) {
if (c == '\\')
*(d - 1) = *s++;
else if (c == ',')
*(d - 1) = '\n';
}
}
void MakeFmt(char Cmd[], char CmdFmt[])
{
char *s;
BOOL Found = FALSE;
strcpy(CmdFmt, Cmd);
ParseCmdLine(CmdFmt); /* Replace , by \n to separate commands */
s = CmdFmt;
while (*s) {
if (*s == '%' && *(s + 1) == '%') {
*(s + 1) = 's';
Found = TRUE;
}
s++;
}
if (!Found)
StrnCat(CmdFmt, " %s", MAXCMDLEN - 1);
}
UWORD ProtectBit(char P[])
{
UWORD PB = 0;
while (*P) {
switch (*P) {
case 'L':
case 'l':
PB |= FIBF_LINK; /* another magic bit! */
break;
case 'C':
case 'c':
PB |= FIBF_COMMENT; /* our magic bit! */
break;
case 'H':
case 'h':
PB |= FIBF_HIDDEN;
break;
case 'S':
case 's':
PB |= FIBF_SCRIPT;
break;
case 'P':
case 'p':
PB |= FIBF_PURE;
break;
case 'A':
case 'a':
PB |= FIBF_ARCHIVE;
break;
case 'R':
case 'r':
PB |= FIBF_READ;
break;
case 'W':
case 'w':
PB |= FIBF_WRITE;
break;
case 'E':
case 'e':
PB |= FIBF_EXECUTE;
break;
case 'D':
case 'd':
PB |= FIBF_DELETE;
break;
default: /* nothing to do */
break;
}
P++;
}
return PB;
}
UWORD EasyProtect(LONG Protection)
{
return (UWORD) ((Protection ^ 0x0F) & 0x00FF); /* Complement 4 lower bits so all work the same way */
}
BOOL Match(struct SelectInfo * SelectInfo, struct FileInfoBlock * FIB)
{
if (FIB->fib_DirEntryType < 0) { /* this is a file */
if (SelectInfo->si_Flags & SI_ALL_FILES)
return TRUE;
else if (!(SelectInfo->si_Flags & SI_MATCH_FILES))
return FALSE;
}
else { /* Dir */
if (SelectInfo->si_Flags & SI_ALL_DIRS)
return TRUE;
else if (!(SelectInfo->si_Flags & SI_MATCH_DIRS))
return FALSE;
}
if (SelectInfo->si_Flags & SI_NAME) {
if (!MatchPatternNoCase(SelectInfo->si_PatTok, FIB->fib_FileName))
return FALSE;
}
{
long Secs = Date2Secs(&FIB->fib_Date);
if (SelectInfo->si_Flags & SI_SINCEDATE) {
if (Secs < SelectInfo->si_SinceSecs)
return FALSE;
}
if (SelectInfo->si_Flags & SI_BEFOREDATE) {
if (Secs > SelectInfo->si_BeforeSecs)
return FALSE;
}
}
if (FIB->fib_Size < SelectInfo->si_MinSize)
return FALSE;
if (SelectInfo->si_MaxSize && (FIB->fib_Size > SelectInfo->si_MaxSize))
return FALSE;
{
UWORD Protection = EasyProtect(FIB->fib_Protection);
if (SelectInfo->si_Flags & SI_POSPROTECTION) {
if (!(Protection & SelectInfo->si_PosProtect))
return FALSE;
}
if (SelectInfo->si_Flags & SI_NEGPROTECTION) {
if ((Protection & SelectInfo->si_NegProtect))
return FALSE;
}
}
return TRUE;
}
BOOL MatchFileType(struct SelectInfo * SelectInfo, struct FileInfoBlock * FIB, FileType Type)
{
if (WhatIsBase && (SelectInfo->si_Flags & SI_FILETYPE)) {
UWORD Flags, i;
for (i = 0; i < SelectInfo->si_NumFts; i++) {
Flags = SelectInfo->si_FileTypes[i].fs_Flags;
if (!CmpFileType(SelectInfo->si_FileTypes[i].fs_FileType, Type))
return (BOOL) ((Flags & FTSF_EXCLUDETYPE) ? FALSE : TRUE);
if ((Flags & FTSF_WITHSUBTYPES) && IsSubTypeOf(Type, SelectInfo->si_FileTypes[i].fs_FileType))
return (BOOL) ((Flags & FTSF_EXCLUDETYPE) ? FALSE : TRUE);
}
if (SelectInfo->si_Flags & SI_POSFILETYPE)
return FALSE; /* no match within include FileTypes, exclude file */
else
return TRUE; /* Only exclude types, and not found in them, include file */
}
return TRUE;
}
long __regargs Main(char *ArgV[], struct WBStartup *WBenchMsg)
{
LONG rc = 0;
long ReadSize = 480;
UBYTE ShowByte = 8;
ULONG Deep = 0;
BOOL ShowFileType;
char FmtCmd[MAXCMDLEN], Cmd[MAXCMDLEN];
struct SelectInfo SelectInfo;
WhatIsBase = OpenLibrary("whatis.library", 3L);
memset(&SelectInfo, 0, sizeof(SelectInfo));
if (ArgV[ARG_Files]) {
if (!Stricmp(ArgV[ARG_Files], "MATCH"))
SelectInfo.si_Flags |= SI_MATCH_FILES;
else if (!Stricmp(ArgV[ARG_Files], "YES"))
SelectInfo.si_Flags |= SI_ALL_FILES;
}
else /* set default */
SelectInfo.si_Flags |= SI_MATCH_FILES;
if (ArgV[ARG_Dirs]) {
if (!Stricmp(ArgV[ARG_Dirs], "MATCH"))
SelectInfo.si_Flags |= SI_MATCH_DIRS;
else if (!Stricmp(ArgV[ARG_Dirs], "YES"))
SelectInfo.si_Flags |= SI_ALL_DIRS;
}
else /* set default */
SelectInfo.si_Flags |= SI_MATCH_DIRS;
if (ArgV[ARG_Since]) {
struct DateStamp DateStamp;
String2Date(ArgV[ARG_Since], &DateStamp);
SelectInfo.si_SinceDate = DateStamp;
SelectInfo.si_SinceSecs = Date2Secs(&DateStamp);
SelectInfo.si_Flags |= SI_SINCEDATE;
}
if (ArgV[ARG_Before]) {
struct DateStamp DateStamp;
String2Date(ArgV[ARG_Before], &DateStamp);
SelectInfo.si_BeforeDate = DateStamp;
SelectInfo.si_BeforeSecs = Date2Secs(&DateStamp);
SelectInfo.si_Flags |= SI_BEFOREDATE;
}
if (ArgV[ARG_MinSize])
SelectInfo.si_MinSize = *(ULONG *) ArgV[ARG_MinSize];
if (ArgV[ARG_MaxSize])
SelectInfo.si_MaxSize = *(ULONG *) ArgV[ARG_MaxSize];
if (ArgV[ARG_PosProtect]) {
SelectInfo.si_Flags |= SI_POSPROTECTION;
SelectInfo.si_PosProtect = ProtectBit(ArgV[ARG_PosProtect]);
}
if (ArgV[ARG_NegProtect]) {
SelectInfo.si_Flags |= SI_NEGPROTECTION;
SelectInfo.si_NegProtect = ProtectBit(ArgV[ARG_NegProtect]);
}
if (ArgV[ARG_Type] && WhatIsBase) {
UBYTE NumFT = 0;
UWORD Flags = 0;
char *c;
for (c = ArgV[ARG_Type]; *c; c++) {
Printf("\"%s\"\n", c);
switch (*c) {
case ONLYFileType:
Flags &= ~FTSF_EXCLUDETYPE;
break;
case NOTFileType:
Flags |= FTSF_EXCLUDETYPE;
break;
case WHITHSubSub:
Flags |= FTSF_WITHSUBTYPES;
break;
case '(': /* for ReadArgs()/Template reaseon, the quote '"' can't be used */
{
char IDType[100];
char *i = IDType;
c++; /* skip '(' */
while (*c != ')')
*i++ = *c++; /* copy until ')' */
*i = '\0'; /* NULL terminate the string */
/* BUG: the SAS don't warn on this : i = '\0' */
SelectInfo.si_FileTypes[NumFT].fs_FileType = GetIDType(IDType);
SelectInfo.si_FileTypes[NumFT].fs_Flags = Flags;
if (TYPE_UNKNOWNIDSTRING == SelectInfo.si_FileTypes[NumFT].fs_FileType)
Printf("Unknown FileType:\"%s\"\n", IDType);
else
NumFT++;
}
break;
case ')':
/* just the mark of the end of and FileType ident, nothing to do */
case ',':
/* just a separator, nothing to do */
break;
delault:
Printf("FileType spec have errors at:%s\n", c);
}
}
SelectInfo.si_NumFts = NumFT;
SelectInfo.si_Flags |= (Flags & FTSF_EXCLUDETYPE) ? SI_NEGFILETYPE : SI_POSFILETYPE;
}
if (ArgV[ARG_READSIZE])
ReadSize = *(long *) ArgV[ARG_READSIZE];
if (ArgV[ARG_SHOWBYTE])
ShowByte = (UBYTE) * (long *) ArgV[ARG_SHOWBYTE];
if (ArgV[ARG_DEEPWHATIS])
Deep = *(long *) ArgV[ARG_DEEPWHATIS];
ShowFileType = (BOOL) ArgV[ARG_SHOWFILETYPE];
if (ArgV[ARG_CMD])
MakeFmt(ArgV[ARG_CMD], FmtCmd);
else
ShowFileType = TRUE; /* If user don't supply cmd I suppose he call "For" for somthing */
/* SASBUG: this line generte incorrect code:
move.l 03c(a5), a0
move #1,(a0)
( BOOL )ArgV[ ARG_SHOWFILETYPE] = TRUE;
*/
{
LONG ReturnCode = RETURN_ERROR;
FileType Type = TYPE_UNSCANNED;
char FullDir[MAXSTRINGLEN];
BPTR InputFH, OutputFH;
BPTR InputLock, OutputLock;
UBYTE *Buffer;
//BPTR InitialDir;
FullDir[0] = '\0';
//InitialDir = Lock("", ACCESS_READ);
//CurrentDir(((struct Process *) SysBase->ThisTask)->pr_CurrentDir);
InputFH = Input();
OutputFH = Output();
if (ArgV[ARG_ASYNC]) {
InputLock = DupLockFromFH(Input());
OutputLock = DupLockFromFH(Output());
}
if (Buffer = AllocVec(ReadSize + 1, MEMF_ANY)) {
struct AnchorPath *AP;
if (AP = AllocVec(sizeof(struct AnchorPath) + MAX_PATHLEN, MEMF_ANY | MEMF_CLEAR)) {
char Buf[MAXSTRINGLEN];
char *Pat;
UBYTE i;
AP->ap_BreakBits = SIGBREAKF_CTRL_C; /* Break on these bits */
AP->ap_Strlen = MAX_PATHLEN;
AP->ap_Flags = (ArgV[ARG_ALL]) ? APF_DODOT : APF_DODOT | APF_DOWILD; /* allow convertion of '.' to CurrentDir */
/* Well I have one probleme here: how corectly handle the
ALL flags: if the user specify a pattern the MatchNext()
hide all file and DIRS which don't match to the
pattern, so I don't see dir and in fact can't ask
MatchNext() to enter it. This limitation is STUPID and
important liumitation. I hope is only because I don't
know how to do it. I hope...
*/
for (i = 0, Pat = ((char **) ArgV[ARG_NameA])[0]; Pat; i++, Pat = ((char **) ArgV[ARG_NameA])[i]) {
char ScanDir[MAXSTRINGLEN] =
{'#', '?', '\0'};
BOOL DoIt = TRUE;
{
char *FilePattern;
FilePattern = FilePart(Pat);
if (*FilePattern) {
SelectInfo.si_Flags |= SI_NAME;
strcpy(SelectInfo.si_Pattern, FilePattern);
ParsePatternNoCase(FilePattern, SelectInfo.si_PatTok, PATTERN_BUF_SIZE);
}
*FilePattern = '\0'; /* terminate the full name at end of path */
strcpy(ScanDir, Pat);
StrCat(ScanDir, "#?");
}
for (ReturnCode = MatchFirst(ScanDir, AP);
ReturnCode == 0;
ReturnCode = MatchNext(AP)
) {
if (AP->ap_Flags & APF_DirChanged) {
}
if (AP->ap_Info.fib_DirEntryType > 0) {
if (AP->ap_Flags & APF_DIDDIR) {
RemoveDir(FullDir);
Printf("
\"%s\"
\n", FullDir);
DoIt = FALSE; /* we have treated this dir before entering in it so don't treat it twice */
}
else if (ArgV[ARG_ALL]) {
AddPart(FullDir, AP->ap_Info.fib_FileName, MAXSTRINGLEN);
Printf("
\"%s\"
\n", FullDir);
/* make it enter the directory */
AP->ap_Flags |= APF_DODIR;
}
/* clear the completed directory flag */
AP->ap_Flags &= ~APF_DIDDIR;
}
/* Here is code for handling each particular file */
if (DoIt && Match(&SelectInfo, &AP->ap_Info)) {
long Readed;
SPrintf(Buf, "\"%s\"", AP->ap_Buf);
if (Deep) {
if (AP->ap_Info.fib_DirEntryType <= 0) {
BPTR FH;
if (FH = Open(AP->ap_Buf, MODE_OLDFILE)) {
Readed = Read(FH, Buffer, ReadSize);
Buffer[Readed] = '\0'; /* whatis.library need that */
Type = _WhatIsTags(AP->ap_Buf, WI_Deep, Deep, WI_FIB, &AP->ap_Info, WI_Buffer, Buffer, WI_BufLen, Readed, TAG_DONE);
Close(FH);
}
else
Type = _WhatIsTags(AP->ap_Buf, WI_Deep, Deep, WI_FIB, &AP->ap_Info, TAG_DONE);
}
else
Type = _WhatIsTags(AP->ap_Buf, WI_Deep, Deep, WI_FIB, &AP->ap_Info, TAG_DONE);
}
else
Type = _WhatIsTags(AP->ap_Buf, WI_Deep, LIGHTTYPE, WI_FIB, &AP->ap_Info, TAG_DONE);
if (MatchFileType(&SelectInfo, &AP->ap_Info, Type)) {
if (ShowFileType) {
Printf("%-32s\t", AP->ap_Info.fib_FileName); /* due my print of dir herarhy, only print base name here */
Printf("%-9s \t", GetIDString(Type));
if (AP->ap_Info.fib_DirEntryType <= 0)
PrintByte(Buffer, Readed, ShowByte);
PutStr("\n");
}
if (ArgV[ARG_CMD]) {
if (ArgV[ARG_ASYNC]) {
/* Need to do this because Async mode close the Input/Output */
InputFH = OpenFromLock(InputLock);
OutputFH = OpenFromLock(OutputLock);
}
/* Allow 5 %% in cmd */
SPrintf(Cmd, FmtCmd, Buf, Buf, Buf, Buf, Buf); /* building comand line */
SystemTags(Cmd,
SYS_Input, InputFH,
SYS_Output, OutputFH,
SYS_Asynch, ArgV[ARG_ASYNC],
SYS_UserShell, TRUE,
TAG_DONE
);
}
}
}
DoIt = TRUE;
}
MatchEnd(AP); /* This absolutely, positively must be called, all of the time. */
if (ReturnCode != ERROR_NO_MORE_ENTRIES) {
PrintFault(ReturnCode, NULL);
}
//CurrentDir(InitialDir);
}
FreeVec(AP);
}
FreeVec(Buffer);
}
else
PutStr("Can't allocate Memory for Buffer\n");
//UnLock(InitialDir);
if (ArgV[ARG_ASYNC]) {
UnLock(InputLock);
UnLock(OutputLock);
}
}
if (WhatIsBase)
CloseLibrary((struct Library *) WhatIsBase);
return rc;
}