Detabbed
authormazze <mazze@fb15a70f-31f2-0310-bbcc-cdcc74a49acc>
Wed, 21 Nov 2012 19:47:17 +0000 (21 19:47 +0000)
committermazze <mazze@fb15a70f-31f2-0310-bbcc-cdcc74a49acc>
Wed, 21 Nov 2012 19:47:17 +0000 (21 19:47 +0000)
git-svn-id: https://svn.aros.org/svn/aros/trunk/AROS@46059 fb15a70f-31f2-0310-bbcc-cdcc74a49acc

174 files changed:
rom/dos/abortpkt.c
rom/dos/addbuffers.c
rom/dos/adddosentry.c
rom/dos/addpart.c
rom/dos/addsegment.c
rom/dos/allocdosobject.c
rom/dos/assignadd.c
rom/dos/assignlate.c
rom/dos/assignlock.c
rom/dos/assignpath.c
rom/dos/attemptlockdoslist.c
rom/dos/boot.c
rom/dos/bstr_helper.c
rom/dos/changemode.c
rom/dos/checksignal.c
rom/dos/cli.c
rom/dos/cliinit.c
rom/dos/cliinitnewcli.c
rom/dos/cliinitrun.c
rom/dos/close.c
rom/dos/comparedates.c
rom/dos/createdir.c
rom/dos/createnewproc.c
rom/dos/createproc.c
rom/dos/currentdir.c
rom/dos/datestamp.c
rom/dos/delay.c
rom/dos/deletefile.c
rom/dos/deviceproc.c
rom/dos/displayerror.c
rom/dos/dopkt.c
rom/dos/dos_init.c
rom/dos/dos_intern.h
rom/dos/dosgetstring.c
rom/dos/duplock.c
rom/dos/duplockfromfh.c
rom/dos/endnotify.c
rom/dos/errorreport.c
rom/dos/exall.c
rom/dos/exallend.c
rom/dos/examine.c
rom/dos/examinefh.c
rom/dos/execute.c
rom/dos/exit.c
rom/dos/exnext.c
rom/dos/fault.c
rom/dos/fgetc.c
rom/dos/fgets.c
rom/dos/filepart.c
rom/dos/findarg.c
rom/dos/findcliproc.c
rom/dos/finddosentry.c
rom/dos/findsegment.c
rom/dos/findvar.c
rom/dos/flush.c
rom/dos/format.c
rom/dos/fputc.c
rom/dos/fputs.c
rom/dos/fread.c
rom/dos/freeargs.c
rom/dos/freedeviceproc.c
rom/dos/freedosentry.c
rom/dos/freedosobject.c
rom/dos/fs_driver.c
rom/dos/fwrite.c
rom/dos/getargstr.c
rom/dos/getconsoletask.c
rom/dos/getcurrentdirname.c
rom/dos/getdeviceproc.c
rom/dos/getfilesystask.c
rom/dos/getprogramdir.c
rom/dos/getprogramname.c
rom/dos/getprompt.c
rom/dos/getvar.c
rom/dos/include/loadseg.h
rom/dos/info.c
rom/dos/inhibit.c
rom/dos/input.c
rom/dos/internalflush.c
rom/dos/internalloadseg.c
rom/dos/internalloadseg.h
rom/dos/internalloadseg_aos.c
rom/dos/internalloadseg_elf.c
rom/dos/internalseek.c
rom/dos/internalunloadseg.c
rom/dos/ioerr.c
rom/dos/isbootable.c
rom/dos/isfilesystem.c
rom/dos/isinteractive.c
rom/dos/loadseg.c
rom/dos/lock.c
rom/dos/lockdoslist.c
rom/dos/lockrecord.c
rom/dos/lockrecords.c
rom/dos/makedosentry.c
rom/dos/makelink.c
rom/dos/match_misc.c
rom/dos/match_old.c
rom/dos/matchend.c
rom/dos/matchfirst.c
rom/dos/matchnext.c
rom/dos/matchpattern.c
rom/dos/matchpatternnocase.c
rom/dos/maxcli.c
rom/dos/namefrom.c
rom/dos/namefromfh.c
rom/dos/namefromlock.c
rom/dos/newloadseg.c
rom/dos/nextdosentry.c
rom/dos/open.c
rom/dos/openfromlock.c
rom/dos/output.c
rom/dos/packethelper.c
rom/dos/parentdir.c
rom/dos/parentoffh.c
rom/dos/parsepattern.c
rom/dos/parsepatternnocase.c
rom/dos/pathpart.c
rom/dos/patternmatching.c
rom/dos/printfault.c
rom/dos/putstr.c
rom/dos/read.c
rom/dos/readitem.c
rom/dos/readlink.c
rom/dos/relabel.c
rom/dos/remassignlist.c
rom/dos/remdosentry.c
rom/dos/remsegment.c
rom/dos/rename.c
rom/dos/replypkt.c
rom/dos/rootnode.c
rom/dos/runcommand.c
rom/dos/runhandler.c
rom/dos/samedevice.c
rom/dos/samelock.c
rom/dos/scanvars.c
rom/dos/seek.c
rom/dos/selectinput.c
rom/dos/selectoutput.c
rom/dos/sendpkt.c
rom/dos/setargstr.c
rom/dos/setcomment.c
rom/dos/setconsoletask.c
rom/dos/setcurrentdirname.c
rom/dos/setfiledate.c
rom/dos/setfilesize.c
rom/dos/setfilesystask.c
rom/dos/setioerr.c
rom/dos/setmode.c
rom/dos/setowner.c
rom/dos/setprogramdir.c
rom/dos/setprogramname.c
rom/dos/setprompt.c
rom/dos/setprotection.c
rom/dos/setvar.c
rom/dos/setvbuf.c
rom/dos/splitname.c
rom/dos/startnotify.c
rom/dos/strtodate.c
rom/dos/strtolong.c
rom/dos/systemtaglist.c
rom/dos/ungetc.c
rom/dos/unloadseg.c
rom/dos/unlock.c
rom/dos/unlockdoslist.c
rom/dos/unlockrecord.c
rom/dos/unlockrecords.c
rom/dos/vfprintf.c
rom/dos/vfwritef.c
rom/dos/vprintf.c
rom/dos/waitforchar.c
rom/dos/waitpkt.c
rom/dos/write.c
rom/dos/writechars.c

index a364376..f7ea037 100644 (file)
 #include <dos/dosextens.h>
 #include <proto/dos.h>
 
-       AROS_LH2(void, AbortPkt,
+        AROS_LH2(void, AbortPkt,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct MsgPort   *, port, D1),
-       AROS_LHA(struct DosPacket *, pkt, D2),
+        AROS_LHA(struct MsgPort   *, port, D1),
+        AROS_LHA(struct DosPacket *, pkt, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 44, Dos)
+        struct DosLibrary *, DOSBase, 44, Dos)
 
 /*  FUNCTION
-       Tries to abort an asynchronous packet. There is no guarantee
-       that this succeeds. You must wait for the packet to return
-       before you can reuse or deallocate it.
+        Tries to abort an asynchronous packet. There is no guarantee
+        that this succeeds. You must wait for the packet to return
+        before you can reuse or deallocate it.
 
     INPUTS
-       port - the message port to where the packet was sent
-       pkt  - the packet to be aborted
+        port - the message port to where the packet was sent
+        pkt  - the packet to be aborted
 
     RESULT
 
index 15838eb..0d3bf20 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(LONG, AddBuffers,
+        AROS_LH2(LONG, AddBuffers,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, devicename, D1),
-       AROS_LHA(LONG,         numbuffers, D2),
+        AROS_LHA(CONST_STRPTR, devicename, D1),
+        AROS_LHA(LONG,         numbuffers, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 122, Dos)
+        struct DosLibrary *, DOSBase, 122, Dos)
 
 /*  FUNCTION
-       Add or remove cache memory from a filesystem.
+        Add or remove cache memory from a filesystem.
 
     INPUTS
-       devicename  --  NUL terminated dos device name.
-       numbuffers  --  Number of buffers to add. May be negative.
+        devicename  --  NUL terminated dos device name.
+        numbuffers  --  Number of buffers to add. May be negative.
 
     RESULT
-       != 0 on success (IoErr() gives the actual number of buffers),
-       0 else (IoErr() gives the error code).
+        != 0 on success (IoErr() gives the actual number of buffers),
+        0 else (IoErr() gives the error code).
 
     NOTES
 
dissimilarity index 60%
index a13c98b..53e880a 100644 (file)
-/*
-    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
-    $Id$
-
-    Desc:
-    Lang: english
-*/
-
-#include <aros/debug.h>
-#include <dos/dosextens.h>
-#include <proto/exec.h>
-#include <proto/utility.h>
-#include "dos_intern.h"
-
-/*****************************************************************************
-
-    NAME */
-#include <proto/dos.h>
-
-       AROS_LH1(LONG, AddDosEntry,
-
-/*  SYNOPSIS */
-       AROS_LHA(struct DosList *, dlist, D1),
-
-/*  LOCATION */
-       struct DosLibrary *, DOSBase, 113, Dos)
-
-/*  FUNCTION
-       Adds a given dos list entry to the dos list. Automatically
-       locks the list for writing. There may be not more than one device
-       or assign node of the same name. There are no restrictions on
-       volume nodes.
-
-    INPUTS
-       dlist - pointer to dos list entry.
-
-    RESULT
-       != 0 if all went well, 0 otherwise.
-
-    NOTES
-       Since anybody who wants to use a device or volume node in the
-       dos list has to lock the list, filesystems may be called with
-       the dos list locked. So if you want to add a dos list entry
-       out of a filesystem don't just wait on the lock but serve all
-       incoming requests until the dos list is free instead.
-
-    EXAMPLE
-
-    BUGS
-
-    SEE ALSO
-
-    INTERNALS
-       Behaviour of this function is slightly different from AmigaOS 3.x
-       and MorphOS. Instead of LDF_WRITE it locks DosList with LDF_READ
-       flag. This is done because in AROS handlers are run with DosList
-       locked with LDF_READ flag and this could cause a lockup if we use
-       LDF_WRITE here.
-       
-       Due to nature of the DosList it is safe to read the list while
-       someone is adding a node, adding operation is atomic to other
-       readers. The only problem here would happen if more than one
-       process attempts to add a DosNode at the same time. In order to
-       avoid this race condition we make this call single-threaded
-       using an LDF_ENTRY lock in LDF_WRITE mode.
-       
-       LDF_ENTRY is NOT touched when a handler is started up in this
-       dos.library implementation. LDF_DELETE is not used at all.
-
-*****************************************************************************/
-{
-    AROS_LIBFUNC_INIT
-
-    LONG success = DOSTRUE;
-    struct DosList *dl;
-
-    if (dlist == NULL)
-       return success;
-
-    D(bug("[AddDosEntry] Adding '%b' type %d from addr %x Task '%s'\n",
-        dlist->dol_Name, dlist->dol_Type, dlist,
-        FindTask(NULL)->tc_Node.ln_Name));
-
-    dl = LockDosList(LDF_ALL | LDF_READ);
-
-    LockDosList(LDF_ENTRY|LDF_WRITE);
-    if(dlist->dol_Type != DLT_VOLUME)
-    {
-       while(TRUE)
-       {
-           dl = BADDR(dl->dol_Next);
-
-           if(dl == NULL)
-               break;
-
-           if(dl->dol_Type != DLT_VOLUME && !CMPBSTR(dl->dol_Name, dlist->dol_Name))
-           {
-               D(bug("[AddDosEntry] Name clash for %08lx->dol_Name: %b and %08lx->dol_Name %b\n", dl, dl->dol_Name, dlist, dlist->dol_Name));
-               success = DOSFALSE;
-               break;
-           }
-       }
-    }
-
-    if(success)
-    {
-        struct DosInfo *dinf = BADDR(DOSBase->dl_Root->rn_Info);
-
-       dlist->dol_Next = dinf->di_DevInfo;
-       dinf->di_DevInfo = MKBADDR(dlist);
-    }
-
-    UnLockDosList(LDF_ENTRY|LDF_WRITE);
-    UnLockDosList(LDF_ALL | LDF_READ);
-
-    return success;    
-
-    AROS_LIBFUNC_EXIT
-} /* AddDosEntry */
+/*
+    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
+    $Id$
+
+    Desc:
+    Lang: english
+*/
+
+#include <aros/debug.h>
+#include <dos/dosextens.h>
+#include <proto/exec.h>
+#include <proto/utility.h>
+#include "dos_intern.h"
+
+/*****************************************************************************
+
+    NAME */
+#include <proto/dos.h>
+
+        AROS_LH1(LONG, AddDosEntry,
+
+/*  SYNOPSIS */
+        AROS_LHA(struct DosList *, dlist, D1),
+
+/*  LOCATION */
+        struct DosLibrary *, DOSBase, 113, Dos)
+
+/*  FUNCTION
+        Adds a given dos list entry to the dos list. Automatically
+        locks the list for writing. There may be not more than one device
+        or assign node of the same name. There are no restrictions on
+        volume nodes.
+
+    INPUTS
+        dlist - pointer to dos list entry.
+
+    RESULT
+        != 0 if all went well, 0 otherwise.
+
+    NOTES
+        Since anybody who wants to use a device or volume node in the
+        dos list has to lock the list, filesystems may be called with
+        the dos list locked. So if you want to add a dos list entry
+        out of a filesystem don't just wait on the lock but serve all
+        incoming requests until the dos list is free instead.
+
+    EXAMPLE
+
+    BUGS
+
+    SEE ALSO
+
+    INTERNALS
+        Behaviour of this function is slightly different from AmigaOS 3.x
+        and MorphOS. Instead of LDF_WRITE it locks DosList with LDF_READ
+        flag. This is done because in AROS handlers are run with DosList
+        locked with LDF_READ flag and this could cause a lockup if we use
+        LDF_WRITE here.
+        
+        Due to nature of the DosList it is safe to read the list while
+        someone is adding a node, adding operation is atomic to other
+        readers. The only problem here would happen if more than one
+        process attempts to add a DosNode at the same time. In order to
+        avoid this race condition we make this call single-threaded
+        using an LDF_ENTRY lock in LDF_WRITE mode.
+        
+        LDF_ENTRY is NOT touched when a handler is started up in this
+        dos.library implementation. LDF_DELETE is not used at all.
+
+*****************************************************************************/
+{
+    AROS_LIBFUNC_INIT
+
+    LONG success = DOSTRUE;
+    struct DosList *dl;
+
+    if (dlist == NULL)
+        return success;
+
+    D(bug("[AddDosEntry] Adding '%b' type %d from addr %x Task '%s'\n",
+        dlist->dol_Name, dlist->dol_Type, dlist,
+        FindTask(NULL)->tc_Node.ln_Name));
+
+    dl = LockDosList(LDF_ALL | LDF_READ);
+
+    LockDosList(LDF_ENTRY|LDF_WRITE);
+    if(dlist->dol_Type != DLT_VOLUME)
+    {
+        while(TRUE)
+        {
+            dl = BADDR(dl->dol_Next);
+
+            if(dl == NULL)
+                break;
+
+            if(dl->dol_Type != DLT_VOLUME && !CMPBSTR(dl->dol_Name, dlist->dol_Name))
+            {
+                D(bug("[AddDosEntry] Name clash for %08lx->dol_Name: %b and %08lx->dol_Name %b\n", dl, dl->dol_Name, dlist, dlist->dol_Name));
+                success = DOSFALSE;
+                break;
+            }
+        }
+    }
+
+    if(success)
+    {
+        struct DosInfo *dinf = BADDR(DOSBase->dl_Root->rn_Info);
+
+        dlist->dol_Next = dinf->di_DevInfo;
+        dinf->di_DevInfo = MKBADDR(dlist);
+    }
+
+    UnLockDosList(LDF_ENTRY|LDF_WRITE);
+    UnLockDosList(LDF_ALL | LDF_READ);
+
+    return success;    
+
+    AROS_LIBFUNC_EXIT
+} /* AddDosEntry */
dissimilarity index 75%
index 9f76bb0..9fb5272 100644 (file)
-/*
-    Copyright © 1995-2008, The AROS Development Team. All rights reserved.
-    $Id$
-
-    Desc:
-    Lang: english
-*/
-#include "dos_intern.h"
-
-#include <string.h>
-
-/*****************************************************************************
-
-    NAME */
-#include <proto/dos.h>
-
-       AROS_LH3(BOOL, AddPart,
-
-/*  SYNOPSIS */
-       AROS_LHA(STRPTR,       dirname, D1),
-       AROS_LHA(CONST_STRPTR, filename, D2),
-       AROS_LHA(ULONG,        size, D3),
-
-/*  LOCATION */
-       struct DosLibrary *, DOSBase, 147, Dos)
-
-/*  FUNCTION
-       AddPart() will add a file, directory or other path name to a
-       directory path. It will take into account any pre-existing
-       separator characters (':','/').
-
-       If filename is a fully qualified path, then it will replace
-       the current value of dirname.
-
-    INPUTS
-       dirname     -   the path to add the new path to
-       filename    -   the path you wish added
-       size        -   The size of the dirname buffer (must NOT be 0)
-
-    RESULT
-       Non-zero if everything succeeded, FALSE if the buffer would have
-       overflowed.
-
-       If the buffer would have overflowed, then dirname will not have
-       been changed.
-
-    NOTES
-
-    EXAMPLE
-       UBYTE buffer[80];
-       buffer[0]='\0';
-       AddPart(buffer, "Work:", 80);
-       AddPart(buffer, "Programming/Include/exec", 80);
-
-       FPuts(Output(), buffer);
-       --> Work:Programming/Include/exec
-
-       AddPart(buffer, "/graphics", 80);
-
-       FPuts(Output(), buffer);
-       --> Work:Programming/Include/graphics
-
-       AddPart(buffer, "gfxmacros.h", 80);
-       FPuts(Output(), buffer);
-       --> Work:Programming/Include/graphics/gfxmacros.h
-
-    BUGS
-
-    SEE ALSO
-       FilePart(), PathPart()
-
-    INTERNALS
-
-*****************************************************************************/
-{
-    AROS_LIBFUNC_INIT
-
-#if 1
-    /* stegerg: a bit simple, but since the other code does not
-                work correctly. And then even AmigaOS AddPart()
-               does not seem to do things like eliminating
-               "dead" path components like:
-               
-                   "test/test2//test3" --> "test/test3"
-                   
-               It just makes sure that the path is correct
-    */
-
-    char *stringpos;
-    LONG stringlen;
-    WORD mustaddslash = 0;
-    
-    stringpos = strchr(filename, ':');
-    if (stringpos)
-    {
-       if (stringpos == (char *)filename)
-       {
-           /* The first char of filename is a ':' */
-           
-           /* Find dirname position to where we copy filename later */
-           
-           stringpos = strchr(dirname, ':');
-           if (!stringpos) stringpos = dirname;
-       }       
-       else
-       {
-           /* Filename is a fully qualified path including
-              volume/device name -> replace dirname with filename */
-              
-           stringpos = dirname;
-       }
-    }
-    else
-    {
-       /* filename did not contain ':' */
-       
-       stringlen = strlen(dirname);
-       stringpos = dirname + stringlen;
-       
-       /* Check if we must add a slash */
-       
-       if (stringlen > 0)
-       {
-           if ((stringpos[-1] != ':') && (stringpos[-1] != '/'))
-               mustaddslash = 1;
-       }
-    }
-    
-    /* Check if dirname buffer is big enough */
-    
-    stringlen = ((LONG)(stringpos - (char *)dirname)) + strlen(filename) + 1 + mustaddslash;
-    if (stringlen <= size)
-    {
-       if (mustaddslash) *stringpos++ = '/';
-       strcpy(stringpos, filename);
-       return DOSTRUE;
-    }
-    else
-    {
-       SetIoErr(ERROR_LINE_TOO_LONG);
-       return DOSFALSE;
-    }
-    
-#else
-               
-    /* stegerg: this is buggy, because in some places it accesses
-                chars in dirname behind the (initial) string in
-               there (after the 0 char). For example:
-               
-               char buffer[256];
-               
-               strcpy(buffer, "LOCALE:Catalogs");
-               AddPart(buffer, "deutsch", 256);
-               
-               gives correct "LOCALE:Catalogs/deutsch"
-               
-          but: exactly the same, but buffer before was used for
-               something else:
-               
-               char buffer[256];
-
-               strcpy(buffer, "PROGDIR:Catalogs");
-               AddPart(buffer, "deutsch", 256);
-               
-               gives correct "PROGDIR:Catalogs/deutsch"
-               
-               strcpy(buffer, "LOCALE:Catalogs");
-               AddPart(buffer, "deutsch", 256);
-               
-               gives wrong "LOCALE:Catalogs//deutsch"
-                                           ^^
-               
-    */
-    
-    LONG didx, fidx;
-    BOOL gotfull = FALSE;
-
-    /*
-       Make sure the buffer wouldn't overflow, also finds the ends
-       of the strings...
-    */
-
-    didx = fidx = 0;
-
-    while(dirname[didx])    didx++;
-    while(filename[fidx])
-    {
-       /*
-           If this has a colon, and its not the first char,
-           then this is probably a FQ path.
-       */
-       if((filename[fidx] == ':') && (fidx != 0))
-           gotfull = TRUE;
-
-       fidx++;
-    }
-
-    /* If we got a fully qualified path, then just do a copy. */
-    if(gotfull == TRUE)
-    {
-       /* +1 for NULL byte */
-       if( fidx + 1 > size ) {
-           SetIoErr(ERROR_LINE_TOO_LONG);
-           return DOSFALSE;
-
-       while(*filename)
-       {
-           *dirname++ = *filename++;
-       }
-       *dirname = '\0';
-       return DOSTRUE;
-    }
-
-    /* Otherwise correctly add the subpath on to the end */
-    else
-    {
-       /* +1 for NULL byte, +1 for '/' */
-       if((didx + fidx + 2) > size) {
-           SetIoErr(ERROR_LINE_TOO_LONG);
-           return DOSFALSE;
-       }
-
-       /*
-           Add a '/' onto the end of the current path, unless of course
-           the new path has a ':' or '/' on it already or current path
-           is emtpy (stegerg) ...
-       */
-       if(    (*filename != '/')
-           && (didx != 0 )
-           && (dirname[didx - 1] != ':')
-           && (dirname[didx - 1] != '/')
-         )
-       {
-           dirname[didx++] = '/';
-       }
-       
-       /*
-           Handle leading '/'s 
-       */
-       while (*filename == '/')
-       {
-           filename ++; 
-           while ((dirname[didx] != '/') && (dirname[didx] != ':') && didx)
-               didx --;
-           
-           /*
-               if we are at start of dirname buf then break even
-               if there are more leading '/'s
-           */
-           if  (!didx)
-               break;
-           
-           /* 
-               Another leading '/' ?.
-               Only move up a dir if we are not at the root
-           */
-           if ((*filename== '/') && (dirname[didx] != ':'))
-               didx --;
-               
-       }
-       /* If at root, don't overwrite the ':' */ 
-       if (dirname[didx] == ':')
-            didx ++;
-       /* 
-           if filename not only was a number of '/'s but also contained
-           a subpath, then be sure to skip the found '/' of dirname.
-       */
-       else if ((dirname[didx] == '/') && *filename)
-           didx ++;
-
-       /* Now add the parts, making sure to do any backtracking... */
-       while(*filename)
-       {
-           if(*filename == ':')
-           {
-               /*
-                   Search back for a ':' or the start of the buffer
-                   do the ':' test first, so we test for didx = 0 after...
-               */
-               while( (dirname[didx] != ':') && didx)
-               {
-                   didx--;
-               }
-               dirname[didx++] = *filename++;
-           }
-           else
-               dirname[didx++] = *filename++;
-       } /* while(*filename) */
-
-       dirname[didx] = '\0';
-    }
-    return DOSTRUE;
-#endif
-
-    AROS_LIBFUNC_EXIT
-} /* AddPart */
+/*
+    Copyright © 1995-2008, The AROS Development Team. All rights reserved.
+    $Id$
+
+    Desc:
+    Lang: english
+*/
+#include "dos_intern.h"
+
+#include <string.h>
+
+/*****************************************************************************
+
+    NAME */
+#include <proto/dos.h>
+
+        AROS_LH3(BOOL, AddPart,
+
+/*  SYNOPSIS */
+        AROS_LHA(STRPTR,       dirname, D1),
+        AROS_LHA(CONST_STRPTR, filename, D2),
+        AROS_LHA(ULONG,        size, D3),
+
+/*  LOCATION */
+        struct DosLibrary *, DOSBase, 147, Dos)
+
+/*  FUNCTION
+        AddPart() will add a file, directory or other path name to a
+        directory path. It will take into account any pre-existing
+        separator characters (':','/').
+
+        If filename is a fully qualified path, then it will replace
+        the current value of dirname.
+
+    INPUTS
+        dirname     -   the path to add the new path to
+        filename    -   the path you wish added
+        size        -   The size of the dirname buffer (must NOT be 0)
+
+    RESULT
+        Non-zero if everything succeeded, FALSE if the buffer would have
+        overflowed.
+
+        If the buffer would have overflowed, then dirname will not have
+        been changed.
+
+    NOTES
+
+    EXAMPLE
+        UBYTE buffer[80];
+        buffer[0]='\0';
+        AddPart(buffer, "Work:", 80);
+        AddPart(buffer, "Programming/Include/exec", 80);
+
+        FPuts(Output(), buffer);
+        --> Work:Programming/Include/exec
+
+        AddPart(buffer, "/graphics", 80);
+
+        FPuts(Output(), buffer);
+        --> Work:Programming/Include/graphics
+
+        AddPart(buffer, "gfxmacros.h", 80);
+        FPuts(Output(), buffer);
+        --> Work:Programming/Include/graphics/gfxmacros.h
+
+    BUGS
+
+    SEE ALSO
+        FilePart(), PathPart()
+
+    INTERNALS
+
+*****************************************************************************/
+{
+    AROS_LIBFUNC_INIT
+
+#if 1
+    /* stegerg: a bit simple, but since the other code does not
+                work correctly. And then even AmigaOS AddPart()
+                does not seem to do things like eliminating
+                "dead" path components like:
+                
+                    "test/test2//test3" --> "test/test3"
+                    
+                It just makes sure that the path is correct
+    */
+
+    char *stringpos;
+    LONG stringlen;
+    WORD mustaddslash = 0;
+    
+    stringpos = strchr(filename, ':');
+    if (stringpos)
+    {
+        if (stringpos == (char *)filename)
+        {
+            /* The first char of filename is a ':' */
+            
+            /* Find dirname position to where we copy filename later */
+            
+            stringpos = strchr(dirname, ':');
+            if (!stringpos) stringpos = dirname;
+        }       
+        else
+        {
+            /* Filename is a fully qualified path including
+               volume/device name -> replace dirname with filename */
+               
+            stringpos = dirname;
+        }
+    }
+    else
+    {
+        /* filename did not contain ':' */
+        
+        stringlen = strlen(dirname);
+        stringpos = dirname + stringlen;
+        
+        /* Check if we must add a slash */
+        
+        if (stringlen > 0)
+        {
+            if ((stringpos[-1] != ':') && (stringpos[-1] != '/'))
+                mustaddslash = 1;
+        }
+    }
+    
+    /* Check if dirname buffer is big enough */
+    
+    stringlen = ((LONG)(stringpos - (char *)dirname)) + strlen(filename) + 1 + mustaddslash;
+    if (stringlen <= size)
+    {
+        if (mustaddslash) *stringpos++ = '/';
+        strcpy(stringpos, filename);
+        return DOSTRUE;
+    }
+    else
+    {
+        SetIoErr(ERROR_LINE_TOO_LONG);
+        return DOSFALSE;
+    }
+    
+#else
+                
+    /* stegerg: this is buggy, because in some places it accesses
+                chars in dirname behind the (initial) string in
+                there (after the 0 char). For example:
+                
+                char buffer[256];
+                
+                strcpy(buffer, "LOCALE:Catalogs");
+                AddPart(buffer, "deutsch", 256);
+                
+                gives correct "LOCALE:Catalogs/deutsch"
+                
+           but: exactly the same, but buffer before was used for
+                something else:
+                
+                char buffer[256];
+
+                strcpy(buffer, "PROGDIR:Catalogs");
+                AddPart(buffer, "deutsch", 256);
+                
+                gives correct "PROGDIR:Catalogs/deutsch"
+                
+                strcpy(buffer, "LOCALE:Catalogs");
+                AddPart(buffer, "deutsch", 256);
+                
+                gives wrong "LOCALE:Catalogs//deutsch"
+                                            ^^
+                
+    */
+    
+    LONG didx, fidx;
+    BOOL gotfull = FALSE;
+
+    /*
+        Make sure the buffer wouldn't overflow, also finds the ends
+        of the strings...
+    */
+
+    didx = fidx = 0;
+
+    while(dirname[didx])    didx++;
+    while(filename[fidx])
+    {
+        /*
+            If this has a colon, and its not the first char,
+            then this is probably a FQ path.
+        */
+        if((filename[fidx] == ':') && (fidx != 0))
+            gotfull = TRUE;
+
+        fidx++;
+    }
+
+    /* If we got a fully qualified path, then just do a copy. */
+    if(gotfull == TRUE)
+    {
+        /* +1 for NULL byte */
+        if( fidx + 1 > size ) {
+            SetIoErr(ERROR_LINE_TOO_LONG);
+            return DOSFALSE;
+
+        while(*filename)
+        {
+            *dirname++ = *filename++;
+        }
+        *dirname = '\0';
+        return DOSTRUE;
+    }
+
+    /* Otherwise correctly add the subpath on to the end */
+    else
+    {
+        /* +1 for NULL byte, +1 for '/' */
+        if((didx + fidx + 2) > size) {
+            SetIoErr(ERROR_LINE_TOO_LONG);
+            return DOSFALSE;
+        }
+
+        /*
+            Add a '/' onto the end of the current path, unless of course
+            the new path has a ':' or '/' on it already or current path
+            is emtpy (stegerg) ...
+        */
+        if(    (*filename != '/')
+            && (didx != 0 )
+            && (dirname[didx - 1] != ':')
+            && (dirname[didx - 1] != '/')
+          )
+        {
+            dirname[didx++] = '/';
+        }
+        
+        /*
+            Handle leading '/'s 
+        */
+        while (*filename == '/')
+        {
+            filename ++; 
+            while ((dirname[didx] != '/') && (dirname[didx] != ':') && didx)
+                didx --;
+            
+            /*
+                if we are at start of dirname buf then break even
+                if there are more leading '/'s
+            */
+            if  (!didx)
+                break;
+            
+            /* 
+                Another leading '/' ?.
+                Only move up a dir if we are not at the root
+            */
+            if ((*filename== '/') && (dirname[didx] != ':'))
+                didx --;
+                
+        }
+        /* If at root, don't overwrite the ':' */ 
+        if (dirname[didx] == ':')
+             didx ++;
+        /* 
+            if filename not only was a number of '/'s but also contained
+            a subpath, then be sure to skip the found '/' of dirname.
+        */
+        else if ((dirname[didx] == '/') && *filename)
+            didx ++;
+
+        /* Now add the parts, making sure to do any backtracking... */
+        while(*filename)
+        {
+            if(*filename == ':')
+            {
+                /*
+                    Search back for a ':' or the start of the buffer
+                    do the ':' test first, so we test for didx = 0 after...
+                */
+                while( (dirname[didx] != ':') && didx)
+                {
+                    didx--;
+                }
+                dirname[didx++] = *filename++;
+            }
+            else
+                dirname[didx++] = *filename++;
+        } /* while(*filename) */
+
+        dirname[didx] = '\0';
+    }
+    return DOSTRUE;
+#endif
+
+    AROS_LIBFUNC_EXIT
+} /* AddPart */
index 9c12961..c93cbd3 100644 (file)
 #include <dos/dosextens.h>
 #include <proto/dos.h>
 
-       AROS_LH3(BOOL, AddSegment,
+        AROS_LH3(BOOL, AddSegment,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
-       AROS_LHA(BPTR  , seg, D2),
-       AROS_LHA(LONG  , type, D3),
+        AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(BPTR  , seg, D2),
+        AROS_LHA(LONG  , type, D3),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 129, Dos)
+        struct DosLibrary *, DOSBase, 129, Dos)
 
 /*  FUNCTION
-       Adds a program segment to the system resident list. You can later
-       use these segments to run programs.
+        Adds a program segment to the system resident list. You can later
+        use these segments to run programs.
 
-       The name field should refer to a NULL terminated strings, which
-       will be copied. The type field determines the type of resident
-       program. Normal programs should have type >= 0, system segments
-       should have type == CMD_SYSTEM.
+        The name field should refer to a NULL terminated strings, which
+        will be copied. The type field determines the type of resident
+        program. Normal programs should have type >= 0, system segments
+        should have type == CMD_SYSTEM.
 
-       Note that all other values of type are reserved.
+        Note that all other values of type are reserved.
 
     INPUTS
-       name            - Name of the segment. This is used by FindSegment().
-       seg             - Segment to add.
-       type            - What type of segment (initial use count).
+        name            - Name of the segment. This is used by FindSegment().
+        seg             - Segment to add.
+        type            - What type of segment (initial use count).
 
     RESULT
-       Segment will have been added to the DOS resident list.
+        Segment will have been added to the DOS resident list.
 
-       != 0    success
-       == 0    failure
+        != 0    success
+        == 0    failure
 
     NOTES
 
     EXAMPLE
 
     BUGS
-       Uses Forbid() based locking.
+        Uses Forbid() based locking.
 
     SEE ALSO
-       FindSegment(), RemSegment()
+        FindSegment(), RemSegment()
 
     INTERNALS
 
@@ -75,7 +75,7 @@
     }
 
     sptr = AllocVec(sizeof(struct Segment) + namelen - 4 + 1,
-                   MEMF_CLEAR | MEMF_PUBLIC);
+                    MEMF_CLEAR | MEMF_PUBLIC);
 
     if( sptr == NULL ) {
         Permit();
dissimilarity index 64%
index 8afe5f1..fab282d 100644 (file)
-/*
-    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
-    $Id$
-
-    Desc:
-    Lang: English
-*/
-#include <exec/memory.h>
-#include <proto/exec.h>
-#include <dos/exall.h>
-#include <utility/tagitem.h>
-#include <proto/utility.h>
-#include <dos/rdargs.h>
-#include <dos/dostags.h>
-#include "dos_intern.h"
-
-/*****************************************************************************
-
-    NAME */
-#include <proto/dos.h>
-
-       AROS_LH2(APTR, AllocDosObject,
-
-/*  SYNOPSIS */
-       AROS_LHA(ULONG                 , type, D1),
-       AROS_LHA(const struct TagItem *, tags, D2),
-
-/*  LOCATION */
-       struct DosLibrary *, DOSBase, 38, Dos)
-
-/*  FUNCTION
-       Creates a new dos object of a given type. This memory has to be
-       freed with FreeDosObject().
-
-    INPUTS
-       type - Object type.
-       tags - Pointer to taglist array with additional information. See
-              <dos/dostags.h> for a list of all supported tags.
-
-    RESULT
-       Pointer to new object or NULL, to indicate an error.
-
-    NOTES
-
-    EXAMPLE
-
-    BUGS
-
-    SEE ALSO
-
-    INTERNALS
-
-*****************************************************************************/
-{
-    AROS_LIBFUNC_INIT
-    APTR mem;
-
-    switch(type)
-    {
-    case DOS_FILEHANDLE:
-       mem = AllocVec(sizeof(struct FileHandle), MEMF_CLEAR);
-
-       if (mem != NULL)
-       {
-           struct FileHandle *fh = (struct FileHandle *)mem;
-
-           fh->fh_Pos = -1;
-           fh->fh_End = -1;
-       }
-       return mem;
-
-    case DOS_FIB:
-       return AllocVec(sizeof(struct FileInfoBlock), MEMF_CLEAR);
-
-    case DOS_STDPKT:
-       return allocdospacket();
-
-    case DOS_EXALLCONTROL:
-       return AllocVec(sizeof(struct InternalExAllControl), MEMF_CLEAR);
-
-    case DOS_CLI:
-       {
-           struct CommandLineInterface *cli = NULL;
-           struct TagItem defaults[] =
-           {
-               /* 0 */ { ADO_DirLen,       255 },
-               /* 1 */ { ADO_CommNameLen,  255 },
-               /* 2 */ { ADO_CommFileLen,  255 },
-               /* 3 */ { ADO_PromptLen,    255 },
-                       { TAG_END, 0 }
-           };
-           
-           STRPTR  dir     = NULL;
-           STRPTR  command = NULL;
-           STRPTR  file    = NULL;
-           STRPTR  prompt  = NULL;
-
-           /* C has no exceptions. This is a simple replacement. */
-#define ENOMEM_IF(a)  if(a) goto enomem      /* Throw out of memory. */
-
-           cli = AllocVec(sizeof(struct CommandLineInterface), MEMF_CLEAR);
-           ENOMEM_IF(cli == NULL);
-           
-           cli->cli_FailLevel  = RETURN_ERROR;
-           cli->cli_Background = DOSTRUE;
-           ApplyTagChanges(defaults, (struct TagItem *)tags);
-           
-           dir = AllocVec(defaults[0].ti_Data + 1, MEMF_PUBLIC | MEMF_CLEAR);
-           ENOMEM_IF(dir == NULL);
-
-           AROS_BSTR_setstrlen(MKBADDR(dir), 0);
-           cli->cli_SetName = MKBADDR(dir);
-
-           command = AllocVec(defaults[1].ti_Data + 1,
-                              MEMF_PUBLIC | MEMF_CLEAR);
-           ENOMEM_IF(command == NULL);
-
-           AROS_BSTR_setstrlen(MKBADDR(command), 0);
-           cli->cli_CommandName = MKBADDR(command);
-
-           file = AllocVec(defaults[2].ti_Data + 1, MEMF_PUBLIC | MEMF_CLEAR);
-           ENOMEM_IF(file == NULL);
-
-           AROS_BSTR_setstrlen(MKBADDR(file), 0);
-           cli->cli_CommandFile = MKBADDR(file);
-
-           prompt = AllocVec(defaults[3].ti_Data + 1,
-                             MEMF_PUBLIC | MEMF_CLEAR);
-           ENOMEM_IF(prompt == NULL);
-
-           AROS_BSTR_setstrlen(MKBADDR(prompt), 0);
-           cli->cli_Prompt = MKBADDR(prompt);
-           
-           return cli;
-           
-enomem:
-           if(cli != NULL)
-               FreeVec(cli);
-           
-           FreeVec(dir);
-           FreeVec(command);
-           FreeVec(file);
-           FreeVec(prompt);
-           
-           SetIoErr(ERROR_NO_FREE_STORE);
-
-           return NULL;
-       }
-       
-    case DOS_RDARGS:
-       return AllocVec(sizeof(struct RDArgs), MEMF_CLEAR);
-    }
-
-    SetIoErr(ERROR_BAD_NUMBER);
-
-    return NULL;
-
-    AROS_LIBFUNC_EXIT
-} /* AllocDosObject */
-
-/* Internal routines for packet allocation. Does not require DOSBase. */
-struct DosPacket *allocdospacket(void)
-{
-    struct StandardPacket *sp = AllocVec(sizeof(struct StandardPacket), MEMF_CLEAR);
-
-    if (sp == NULL)
-       return NULL;
-
-    sp->sp_Pkt.dp_Link = &sp->sp_Msg;
-    sp->sp_Msg.mn_Node.ln_Name = (char *)&sp->sp_Pkt;
-
-    return &sp->sp_Pkt;
-}
+/*
+    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
+    $Id$
+
+    Desc:
+    Lang: English
+*/
+#include <exec/memory.h>
+#include <proto/exec.h>
+#include <dos/exall.h>
+#include <utility/tagitem.h>
+#include <proto/utility.h>
+#include <dos/rdargs.h>
+#include <dos/dostags.h>
+#include "dos_intern.h"
+
+/*****************************************************************************
+
+    NAME */
+#include <proto/dos.h>
+
+        AROS_LH2(APTR, AllocDosObject,
+
+/*  SYNOPSIS */
+        AROS_LHA(ULONG                 , type, D1),
+        AROS_LHA(const struct TagItem *, tags, D2),
+
+/*  LOCATION */
+        struct DosLibrary *, DOSBase, 38, Dos)
+
+/*  FUNCTION
+        Creates a new dos object of a given type. This memory has to be
+        freed with FreeDosObject().
+
+    INPUTS
+        type - Object type.
+        tags - Pointer to taglist array with additional information. See
+               <dos/dostags.h> for a list of all supported tags.
+
+    RESULT
+        Pointer to new object or NULL, to indicate an error.
+
+    NOTES
+
+    EXAMPLE
+
+    BUGS
+
+    SEE ALSO
+
+    INTERNALS
+
+*****************************************************************************/
+{
+    AROS_LIBFUNC_INIT
+    APTR mem;
+
+    switch(type)
+    {
+    case DOS_FILEHANDLE:
+        mem = AllocVec(sizeof(struct FileHandle), MEMF_CLEAR);
+
+        if (mem != NULL)
+        {
+            struct FileHandle *fh = (struct FileHandle *)mem;
+
+            fh->fh_Pos = -1;
+            fh->fh_End = -1;
+        }
+        return mem;
+
+    case DOS_FIB:
+        return AllocVec(sizeof(struct FileInfoBlock), MEMF_CLEAR);
+
+    case DOS_STDPKT:
+        return allocdospacket();
+
+    case DOS_EXALLCONTROL:
+        return AllocVec(sizeof(struct InternalExAllControl), MEMF_CLEAR);
+
+    case DOS_CLI:
+        {
+            struct CommandLineInterface *cli = NULL;
+            struct TagItem defaults[] =
+            {
+                /* 0 */ { ADO_DirLen,       255 },
+                /* 1 */ { ADO_CommNameLen,  255 },
+                /* 2 */ { ADO_CommFileLen,  255 },
+                /* 3 */ { ADO_PromptLen,    255 },
+                        { TAG_END, 0 }
+            };
+            
+            STRPTR  dir     = NULL;
+            STRPTR  command = NULL;
+            STRPTR  file    = NULL;
+            STRPTR  prompt  = NULL;
+
+            /* C has no exceptions. This is a simple replacement. */
+#define ENOMEM_IF(a)  if(a) goto enomem      /* Throw out of memory. */
+
+            cli = AllocVec(sizeof(struct CommandLineInterface), MEMF_CLEAR);
+            ENOMEM_IF(cli == NULL);
+            
+            cli->cli_FailLevel  = RETURN_ERROR;
+            cli->cli_Background = DOSTRUE;
+            ApplyTagChanges(defaults, (struct TagItem *)tags);
+            
+            dir = AllocVec(defaults[0].ti_Data + 1, MEMF_PUBLIC | MEMF_CLEAR);
+            ENOMEM_IF(dir == NULL);
+
+            AROS_BSTR_setstrlen(MKBADDR(dir), 0);
+            cli->cli_SetName = MKBADDR(dir);
+
+            command = AllocVec(defaults[1].ti_Data + 1,
+                               MEMF_PUBLIC | MEMF_CLEAR);
+            ENOMEM_IF(command == NULL);
+
+            AROS_BSTR_setstrlen(MKBADDR(command), 0);
+            cli->cli_CommandName = MKBADDR(command);
+
+            file = AllocVec(defaults[2].ti_Data + 1, MEMF_PUBLIC | MEMF_CLEAR);
+            ENOMEM_IF(file == NULL);
+
+            AROS_BSTR_setstrlen(MKBADDR(file), 0);
+            cli->cli_CommandFile = MKBADDR(file);
+
+            prompt = AllocVec(defaults[3].ti_Data + 1,
+                              MEMF_PUBLIC | MEMF_CLEAR);
+            ENOMEM_IF(prompt == NULL);
+
+            AROS_BSTR_setstrlen(MKBADDR(prompt), 0);
+            cli->cli_Prompt = MKBADDR(prompt);
+            
+            return cli;
+            
+enomem:
+            if(cli != NULL)
+                FreeVec(cli);
+            
+            FreeVec(dir);
+            FreeVec(command);
+            FreeVec(file);
+            FreeVec(prompt);
+            
+            SetIoErr(ERROR_NO_FREE_STORE);
+
+            return NULL;
+        }
+        
+    case DOS_RDARGS:
+        return AllocVec(sizeof(struct RDArgs), MEMF_CLEAR);
+    }
+
+    SetIoErr(ERROR_BAD_NUMBER);
+
+    return NULL;
+
+    AROS_LIBFUNC_EXIT
+} /* AllocDosObject */
+
+/* Internal routines for packet allocation. Does not require DOSBase. */
+struct DosPacket *allocdospacket(void)
+{
+    struct StandardPacket *sp = AllocVec(sizeof(struct StandardPacket), MEMF_CLEAR);
+
+    if (sp == NULL)
+        return NULL;
+
+    sp->sp_Pkt.dp_Link = &sp->sp_Msg;
+    sp->sp_Msg.mn_Node.ln_Name = (char *)&sp->sp_Pkt;
+
+    return &sp->sp_Pkt;
+}
index 92a0607..3fe15b2 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(BOOL, AssignAdd,
+        AROS_LH2(BOOL, AssignAdd,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
-       AROS_LHA(BPTR  , lock, D2),
+        AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(BPTR  , lock, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 105, Dos)
+        struct DosLibrary *, DOSBase, 105, Dos)
 
 /*  FUNCTION
-       Create a multi-directory assign, or adds to it if it already was one.
-       Do not use or free the lock after calling this function - it becomes
-       the assign and will be freed by the system when the assign is removed.
+        Create a multi-directory assign, or adds to it if it already was one.
+        Do not use or free the lock after calling this function - it becomes
+        the assign and will be freed by the system when the assign is removed.
 
     INPUTS
-       name - NULL terminated name of the assign.
-       lock - Lock on the assigned directory.
+        name - NULL terminated name of the assign.
+        lock - Lock on the assigned directory.
 
     RESULT
-       != 0 success, 0 on failure. IoErr() gives additional information
-       in that case. The lock is not freed on failure.
+        != 0 success, 0 on failure. IoErr() gives additional information
+        in that case. The lock is not freed on failure.
 
     NOTES
-       This will only work with an assign created with AssignLock() or
-       a resolved AssignLate() assign.
+        This will only work with an assign created with AssignLock() or
+        a resolved AssignLate() assign.
 
     EXAMPLE
 
     BUGS
 
     SEE ALSO
-       Lock(), AssignLock(), AssignPath(), AssignLate(), DupLock(),
-       RemAssignList()
+        Lock(), AssignLock(), AssignPath(), AssignLate(), DupLock(),
+        RemAssignList()
 
     INTERNALS
 
     struct AssignList **al, *newal;
 
     if(lock == BNULL)
-       return DOSFALSE;
+        return DOSFALSE;
 
     dl = LockDosList(LDF_ASSIGNS | LDF_WRITE);
     dl = FindDosEntry(dl, name, LDF_ASSIGNS);
 
     if((dl == NULL) || (dl->dol_Type != DLT_DIRECTORY))
     {
-       UnLockDosList(LDF_ASSIGNS | LDF_WRITE);
-       SetIoErr(ERROR_OBJECT_WRONG_TYPE);
+        UnLockDosList(LDF_ASSIGNS | LDF_WRITE);
+        SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 
-       return DOSFALSE;
+        return DOSFALSE;
     }
     
     newal = AllocVec(sizeof(struct AssignList), MEMF_PUBLIC | MEMF_CLEAR);
 
     if(newal == NULL)
     {
-       UnLockDosList(LDF_ASSIGNS | LDF_WRITE);
-       SetIoErr(ERROR_NO_FREE_STORE);
+        UnLockDosList(LDF_ASSIGNS | LDF_WRITE);
+        SetIoErr(ERROR_NO_FREE_STORE);
 
-       return DOSFALSE;
+        return DOSFALSE;
     }
     
     newal->al_Lock = lock;
index e4e2e15..f1b5221 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(BOOL, AssignLate,
+        AROS_LH2(BOOL, AssignLate,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
-       AROS_LHA(CONST_STRPTR, path, D2),
+        AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(CONST_STRPTR, path, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 103, Dos)
+        struct DosLibrary *, DOSBase, 103, Dos)
 
 /*  FUNCTION
-       Create an assign for the given name, which will be resolved upon the
-       first reference to it. If this succeeds (i.e. the path exists and
-       can be locked) it will be turned into an AssignLock() type assign.
-       This way you can create assigns to unmounted volumes which will only
-       be requested when accessed.
+        Create an assign for the given name, which will be resolved upon the
+        first reference to it. If this succeeds (i.e. the path exists and
+        can be locked) it will be turned into an AssignLock() type assign.
+        This way you can create assigns to unmounted volumes which will only
+        be requested when accessed.
 
     INPUTS
-       name  --  NULL terminated name of the assign.
-       path  --  NULL terminated path to be resolved on the first reference.
+        name  --  NULL terminated name of the assign.
+        path  --  NULL terminated path to be resolved on the first reference.
 
     RESULT
-       != 0 success, 0 on failure. IoErr() gives additional information
-       in that case.
+        != 0 success, 0 on failure. IoErr() gives additional information
+        in that case.
 
     NOTES
 
@@ -47,7 +47,7 @@
     BUGS
 
     SEE ALSO
-       Lock(), AssignAdd(), AssignPath(), AssignLock()
+        Lock(), AssignAdd(), AssignPath(), AssignLock()
 
     INTERNALS
 
     newdl = MakeDosEntry(name, DLT_LATE);
 
     if (newdl == NULL)
-       return DOSFALSE;
+        return DOSFALSE;
     
     s2 = path;
 
     while(*s2++)
-       ;
+        ;
 
     namelen = s2 - path + 1;
     pathcopy = AllocVec(namelen, MEMF_PUBLIC | MEMF_CLEAR);
 
     if(pathcopy == NULL)
     {
-       FreeDosEntry(newdl);
-       SetIoErr(ERROR_NO_FREE_STORE);
+        FreeDosEntry(newdl);
+        SetIoErr(ERROR_NO_FREE_STORE);
 
-       return DOSFALSE;
+        return DOSFALSE;
     }
     
     CopyMem(path, pathcopy, namelen);
 
     if(dl == NULL)
     {
-       AddDosEntry(newdl);
+        AddDosEntry(newdl);
     }
     else if(dl->dol_Type == DLT_VOLUME || dl->dol_Type == DLT_DEVICE)
     {
-       dl = NULL;
-       FreeVec(newdl->dol_misc.dol_assign.dol_AssignName);
-       FreeDosEntry(newdl);
-       SetIoErr(ERROR_OBJECT_EXISTS);
-       result = DOSFALSE;
+        dl = NULL;
+        FreeVec(newdl->dol_misc.dol_assign.dol_AssignName);
+        FreeDosEntry(newdl);
+        SetIoErr(ERROR_OBJECT_EXISTS);
+        result = DOSFALSE;
     }
     else
     {
-       RemDosEntry(dl);
-       AddDosEntry(newdl);
+        RemDosEntry(dl);
+        AddDosEntry(newdl);
     }
     
     if(dl != NULL)
     {
-       UnLock(dl->dol_Lock);
-
-       if(dl->dol_misc.dol_assign.dol_List != NULL)
-       {
-           struct AssignList *al, *oal;
-           
-           for(al = dl->dol_misc.dol_assign.dol_List; al; )
-           {
-               UnLock(al->al_Lock);
-               oal = al;
-               al = al->al_Next;
-               FreeVec(oal);
-           }
-       }
-       
-       FreeVec(dl->dol_misc.dol_assign.dol_AssignName);
-       FreeDosEntry(dl);
+        UnLock(dl->dol_Lock);
+
+        if(dl->dol_misc.dol_assign.dol_List != NULL)
+        {
+            struct AssignList *al, *oal;
+            
+            for(al = dl->dol_misc.dol_assign.dol_List; al; )
+            {
+                UnLock(al->al_Lock);
+                oal = al;
+                al = al->al_Next;
+                FreeVec(oal);
+            }
+        }
+        
+        FreeVec(dl->dol_misc.dol_assign.dol_AssignName);
+        FreeDosEntry(dl);
     }
     
     UnLockDosList(LDF_ALL | LDF_WRITE);
index 1c156e5..624a68a 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(LONG, AssignLock,
+        AROS_LH2(LONG, AssignLock,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
-       AROS_LHA(BPTR,   lock, D2),
+        AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(BPTR,   lock, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 102, Dos)
+        struct DosLibrary *, DOSBase, 102, Dos)
 
 /*  FUNCTION
-       Create an assign from a given name to a lock. Replaces any older
-       assignments from that name, 0 cancels the assign completely. Do not
-       use or free the lock after calling this function - it becomes
-       the assign and will be freed by the system if the assign is removed.
+        Create an assign from a given name to a lock. Replaces any older
+        assignments from that name, 0 cancels the assign completely. Do not
+        use or free the lock after calling this function - it becomes
+        the assign and will be freed by the system if the assign is removed.
 
     INPUTS
-       name -- NUL terminated name of the assign.
-       lock -- Lock to assigned directory.
+        name -- NUL terminated name of the assign.
+        lock -- Lock to assigned directory.
 
     RESULT
-       != 0 success, 0 on failure. IoErr() gives additional information
-       in that case. The lock is not freed on failure.
+        != 0 success, 0 on failure. IoErr() gives additional information
+        in that case. The lock is not freed on failure.
 
     NOTES
 
 
     if (lock != BNULL)
     {
-       newdl = MakeDosEntry(name, DLT_DIRECTORY);
+        newdl = MakeDosEntry(name, DLT_DIRECTORY);
 
-       if (newdl == NULL)
-           return DOSFALSE;
-       else
-       {
-           struct FileLock *fl = BADDR(lock);
+        if (newdl == NULL)
+            return DOSFALSE;
+        else
+        {
+            struct FileLock *fl = BADDR(lock);
 
-           newdl->dol_Task = fl->fl_Task;
-           newdl->dol_Lock = lock;
-       }
+            newdl->dol_Task = fl->fl_Task;
+            newdl->dol_Lock = lock;
+        }
     }
 
     dl = LockDosList(LDF_ALL | LDF_WRITE);
 
     if (dl == NULL)
     {
-       AddDosEntry(newdl);
+        AddDosEntry(newdl);
     }
     else if (dl->dol_Type == DLT_DEVICE || dl->dol_Type == DLT_VOLUME)
     {
-       dl = NULL;
-       FreeDosEntry(newdl);
-       SetIoErr(ERROR_OBJECT_EXISTS);
-       success = DOSFALSE;
+        dl = NULL;
+        FreeDosEntry(newdl);
+        SetIoErr(ERROR_OBJECT_EXISTS);
+        success = DOSFALSE;
     }
     else
     {
-       RemDosEntry(dl);
+        RemDosEntry(dl);
 
-       AddDosEntry(newdl);
+        AddDosEntry(newdl);
     }
     
     if (dl != NULL)
     {
-       if (dl->dol_Lock)
-       {
-           UnLock(dl->dol_Lock);
-       }
-
-       if (dl->dol_misc.dol_assign.dol_List != NULL)
-       {
-           struct AssignList *al, *oal;
-
-           for (al = dl->dol_misc.dol_assign.dol_List; al; )
-           {
-               UnLock(al->al_Lock);
-               oal = al;
-               al = al->al_Next;
-               FreeVec(oal);
-           }
-       }
-       
-       FreeVec(dl->dol_misc.dol_assign.dol_AssignName);
-       FreeDosEntry(dl);
+        if (dl->dol_Lock)
+        {
+            UnLock(dl->dol_Lock);
+        }
+
+        if (dl->dol_misc.dol_assign.dol_List != NULL)
+        {
+            struct AssignList *al, *oal;
+
+            for (al = dl->dol_misc.dol_assign.dol_List; al; )
+            {
+                UnLock(al->al_Lock);
+                oal = al;
+                al = al->al_Next;
+                FreeVec(oal);
+            }
+        }
+        
+        FreeVec(dl->dol_misc.dol_assign.dol_AssignName);
+        FreeDosEntry(dl);
     }
     
     UnLockDosList(LDF_ALL | LDF_WRITE);
index f17f9c0..bb79f1b 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(BOOL, AssignPath,
+        AROS_LH2(BOOL, AssignPath,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
-       AROS_LHA(CONST_STRPTR, path, D2),
+        AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(CONST_STRPTR, path, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 104, Dos)
+        struct DosLibrary *, DOSBase, 104, Dos)
 
 /*  FUNCTION
-       Create an assign for the given name, which will be resolved upon
-       each reference to it. There will be no permanent lock kept on the
-       specified path. This way you can create assigns to unmounted volumes
-       which will only be requested when accessed. Also, using AssignPath()
-       to assign C: to df0:c would make references go to to df0:c even if
-       you change the disk.
+        Create an assign for the given name, which will be resolved upon
+        each reference to it. There will be no permanent lock kept on the
+        specified path. This way you can create assigns to unmounted volumes
+        which will only be requested when accessed. Also, using AssignPath()
+        to assign C: to df0:c would make references go to to df0:c even if
+        you change the disk.
 
     INPUTS
-       name  -- NULL terminated name of the assign.
-       path  -- NULL terminated path to be resolved on each reference.
+        name  -- NULL terminated name of the assign.
+        path  -- NULL terminated path to be resolved on each reference.
 
     RESULT
-       != 0 in case of success, 0 on failure. IoErr() gives additional
-       information in that case.
+        != 0 in case of success, 0 on failure. IoErr() gives additional
+        information in that case.
 
     NOTES
 
@@ -48,7 +48,7 @@
     BUGS
 
     SEE ALSO
-       AssignAdd(), AssignLock(), AssignLate(), Open()
+        AssignAdd(), AssignLock(), AssignLate(), Open()
 
     INTERNALS
 
     newdl = MakeDosEntry(name, DLT_NONBINDING);
 
     if(newdl == NULL)
-       return DOSFALSE;
+        return DOSFALSE;
 
     s2 = path;
 
     while(*s2++)
-       ;
+        ;
     
     namelen = s2 - path + 1;
     pathcopy = AllocVec(namelen, MEMF_PUBLIC | MEMF_CLEAR);
 
     if(pathcopy == NULL)
     {
-       FreeDosEntry(newdl);
-       SetIoErr(ERROR_NO_FREE_STORE);
+        FreeDosEntry(newdl);
+        SetIoErr(ERROR_NO_FREE_STORE);
 
-       return DOSFALSE;
+        return DOSFALSE;
     }
 
     CopyMem(path, pathcopy, namelen);
 
     if(dl == NULL)
     {
-       AddDosEntry(newdl);
+        AddDosEntry(newdl);
     }
     else if(dl->dol_Type == DLT_VOLUME || dl->dol_Type == DLT_DEVICE)
     {
-       dl = NULL;
-       FreeVec(newdl->dol_misc.dol_assign.dol_AssignName);
-       FreeDosEntry(newdl);
-       SetIoErr(ERROR_OBJECT_EXISTS);
+        dl = NULL;
+        FreeVec(newdl->dol_misc.dol_assign.dol_AssignName);
+        FreeDosEntry(newdl);
+        SetIoErr(ERROR_OBJECT_EXISTS);
 
-       result = DOSFALSE;
+        result = DOSFALSE;
     }
     else
     {
-       RemDosEntry(dl);
-       AddDosEntry(newdl);
+        RemDosEntry(dl);
+        AddDosEntry(newdl);
     }
     
     if(dl != NULL)
     {
-       UnLock(dl->dol_Lock);
-       
-       if(dl->dol_misc.dol_assign.dol_List != NULL)
-       {
-           struct AssignList *al, *oal;
-
-           for(al = dl->dol_misc.dol_assign.dol_List; al; )
-           {
-               UnLock(al->al_Lock);
-               oal = al;
-               al = al->al_Next;
-               FreeVec(oal);
-           }
-       }
-       
-       FreeVec(dl->dol_misc.dol_assign.dol_AssignName);
-       FreeDosEntry(dl);
+        UnLock(dl->dol_Lock);
+        
+        if(dl->dol_misc.dol_assign.dol_List != NULL)
+        {
+            struct AssignList *al, *oal;
+
+            for(al = dl->dol_misc.dol_assign.dol_List; al; )
+            {
+                UnLock(al->al_Lock);
+                oal = al;
+                al = al->al_Next;
+                FreeVec(oal);
+            }
+        }
+        
+        FreeVec(dl->dol_misc.dol_assign.dol_AssignName);
+        FreeDosEntry(dl);
     }
     
     UnLockDosList(LDF_ALL | LDF_WRITE);
index 1bbfffc..f3e7bad 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(struct DosList *, AttemptLockDosList,
+        AROS_LH1(struct DosList *, AttemptLockDosList,
 
 /*  SYNOPSIS */
-       AROS_LHA(ULONG, flags, D1),
+        AROS_LHA(ULONG, flags, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 111, Dos)
+        struct DosLibrary *, DOSBase, 111, Dos)
 
 /*  FUNCTION
-       Tries to get a lock on some of the dos lists. If all went
-       well a handle is returned that can be used for FindDosEntry().
-       Don't try to busy wait until the lock can be granted - use
-       LockDosList() instead.
+        Tries to get a lock on some of the dos lists. If all went
+        well a handle is returned that can be used for FindDosEntry().
+        Don't try to busy wait until the lock can be granted - use
+        LockDosList() instead.
 
     INPUTS
-       flags  --  what lists to lock
+        flags  --  what lists to lock
 
     RESULT
-       Handle to the dos list or NULL. This is not a direct pointer
-       to the first list element but to a pseudo element instead.
+        Handle to the dos list or NULL. This is not a direct pointer
+        to the first list element but to a pseudo element instead.
 
     NOTES
 
     D(bug("AttemptLockDosList: flags = $%lx\n", flags));
 
     if (((flags & (LDF_READ|LDF_WRITE)) != LDF_READ &&
-        (flags & (LDF_READ|LDF_WRITE)) != LDF_WRITE) ||
-       (flags & ~(LDF_READ|LDF_WRITE|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS|LDF_ENTRY|LDF_DELETE)))
-       return NULL;
+         (flags & (LDF_READ|LDF_WRITE)) != LDF_WRITE) ||
+        (flags & ~(LDF_READ|LDF_WRITE|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS|LDF_ENTRY|LDF_DELETE)))
+        return NULL;
 
     if (flags & LDF_ALL)
     {
-       if (flags & LDF_WRITE)
-           DevSem = AttemptSemaphore(&di->di_DevLock);
-       else
-           DevSem = AttemptSemaphoreShared(&di->di_DevLock);
-       if (!DevSem)
-           dl = NULL;
+        if (flags & LDF_WRITE)
+            DevSem = AttemptSemaphore(&di->di_DevLock);
+        else
+            DevSem = AttemptSemaphoreShared(&di->di_DevLock);
+        if (!DevSem)
+            dl = NULL;
     }
 
     if (flags & LDF_ENTRY)
     {
-       if (flags & LDF_WRITE)
-           EntrySem = AttemptSemaphore(&di->di_EntryLock);
-       else
-           EntrySem = AttemptSemaphoreShared(&di->di_EntryLock);
-       if (!EntrySem)
-           dl = NULL;
+        if (flags & LDF_WRITE)
+            EntrySem = AttemptSemaphore(&di->di_EntryLock);
+        else
+            EntrySem = AttemptSemaphoreShared(&di->di_EntryLock);
+        if (!EntrySem)
+            dl = NULL;
     }
 
     if (flags & LDF_DELETE)
     {
-       if (flags & LDF_WRITE)
-           DelSem = AttemptSemaphore(&di->di_DeleteLock);
-       else
-           DelSem = AttemptSemaphoreShared(&di->di_DeleteLock);
-       if (!DelSem)
-           dl = NULL;
+        if (flags & LDF_WRITE)
+            DelSem = AttemptSemaphore(&di->di_DeleteLock);
+        else
+            DelSem = AttemptSemaphoreShared(&di->di_DeleteLock);
+        if (!DelSem)
+            dl = NULL;
     }
 
 /* This came from MorphOS source code, however looks strange.
    Commented out but left for reference.    
     if (dl)
-       Forbid(); */
+        Forbid(); */
     if (!dl) {
-       if (DevSem)
-           ReleaseSemaphore(&di->di_DevLock);
-       if (EntrySem)
-           ReleaseSemaphore(&di->di_EntryLock);
-       if (DelSem)
-           ReleaseSemaphore(&di->di_DeleteLock);
+        if (DevSem)
+            ReleaseSemaphore(&di->di_DevLock);
+        if (EntrySem)
+            ReleaseSemaphore(&di->di_EntryLock);
+        if (DelSem)
+            ReleaseSemaphore(&di->di_DeleteLock);
     }
 
     D(bug("AttemptLockDosList: result = $%lx\n", dl));
index 0bcd1ba..62b9c84 100644 (file)
@@ -45,14 +45,14 @@ static void load_system_configuration(struct DosLibrary *DOSBase)
 
     fh = Open("DEVS:system-configuration", MODE_OLDFILE);
     if (!fh)
-       return;
+        return;
     len = Read(fh, &prefs, sizeof prefs);
     Close(fh);
     if (len != sizeof prefs)
-       return;
+        return;
     IntuitionBase = TaggedOpenLibrary(TAGGEDOPEN_INTUITION);
     if (IntuitionBase)
-       SetPrefs(&prefs, len, FALSE);
+        SetPrefs(&prefs, len, FALSE);
     CloseLibrary(IntuitionBase);
 }
 
@@ -69,7 +69,7 @@ void __dos_Boot(struct DosLibrary *DOSBase, ULONG BootFlags, UBYTE Flags)
     BPTR cis = BNULL;
 
     /*  We have been created as a process by DOS, we should now
-       try and boot the system. */
+        try and boot the system. */
 
     D(bug("[__dos_Boot] generic boot sequence, BootFlags 0x%08X Flags 0x%02X\n", BootFlags, Flags));
 
@@ -94,16 +94,16 @@ void __dos_Boot(struct DosLibrary *DOSBase, ULONG BootFlags, UBYTE Flags)
             STRPTR args = "";
             BPTR oldin, oldout;
 
-           /*
-            * Argument strings MUST contain terminating LF because of ReadItem() bugs.
-            * Their absence causes ReadArgs() crash.
-            */
+            /*
+             * Argument strings MUST contain terminating LF because of ReadItem() bugs.
+             * Their absence causes ReadArgs() crash.
+             */
             if (BootFlags & BF_NO_COMPOSITION)
-               args = "NOCOMPOSITION\n";
+                args = "NOCOMPOSITION\n";
             else if (BootFlags & BF_NO_DISPLAY_DRIVERS)
-               args = "ONLYCOMPOSITION\n";
+                args = "ONLYCOMPOSITION\n";
 
-           D(bug("[__dos_Boot] Running AROSMonDrvs %s\n", args));
+            D(bug("[__dos_Boot] Running AROSMonDrvs %s\n", args));
 
             /* RunCommand needs a valid Input() handle
              * for passing in its arguments.
index a699cf6..a366bd0 100644 (file)
 
 static void BSTR2CINLINE(char *s)
 {
-       UBYTE len = s[0];
-       memmove(s, s + 1, len);
-       s[len] = 0;
+        UBYTE len = s[0];
+        memmove(s, s + 1, len);
+        s[len] = 0;
 }
 
 void fixfib(struct FileInfoBlock *fib)
 {
-       BSTR2CINLINE(fib->fib_FileName);
-       BSTR2CINLINE(fib->fib_Comment);
+        BSTR2CINLINE(fib->fib_FileName);
+        BSTR2CINLINE(fib->fib_Comment);
 }
index 81439c2..68958fa 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH3(BOOL, ChangeMode,
+        AROS_LH3(BOOL, ChangeMode,
 
 /*  SYNOPSIS */
-       AROS_LHA(ULONG, type,    D1),
-       AROS_LHA(BPTR,  object,  D2),
-       AROS_LHA(ULONG, newmode, D3),
+        AROS_LHA(ULONG, type,    D1),
+        AROS_LHA(BPTR,  object,  D2),
+        AROS_LHA(ULONG, newmode, D3),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 75, Dos)
+        struct DosLibrary *, DOSBase, 75, Dos)
 
 /*  FUNCTION
-       Try to change the access mode of a lock or filehandle.
+        Try to change the access mode of a lock or filehandle.
 
     INPUTS
-       type    - CHANGE_FH or CHANGE_LOCK.
-       object  - Filehandle or lock.
-       newmode - New mode, either SHARED_LOCK or EXCLUSIVE_LOCK.
+        type    - CHANGE_FH or CHANGE_LOCK.
+        object  - Filehandle or lock.
+        newmode - New mode, either SHARED_LOCK or EXCLUSIVE_LOCK.
 
     RESULT
-       != 0 if all went well, otherwise 0. IoErr() gives additional
-       information in the latter case.
+        != 0 if all went well, otherwise 0. IoErr() gives additional
+        information in the latter case.
 
     NOTES
 
@@ -47,8 +47,8 @@
     SEE ALSO
 
     INTERNALS
-       Since filehandles and locks are identical under AROS the type
-       argument is ignored.
+        Since filehandles and locks are identical under AROS the type
+        argument is ignored.
 
 *****************************************************************************/
 {
@@ -60,8 +60,8 @@
     LONG ret;
     
     if (type != CHANGE_LOCK && type != CHANGE_FH) {
-       SetIoErr(ERROR_BAD_NUMBER);
-       return FALSE;
+        SetIoErr(ERROR_BAD_NUMBER);
+        return FALSE;
     }
     D(bug("[ChangeMode] %d %x %d\n", type, fh, newmode));
     ret = dopacket3(DOSBase, NULL, type == CHANGE_LOCK ? fl->fl_Task : fh->fh_Type, ACTION_CHANGE_MODE, type, object, newmode);
index fde1cef..1ba573c 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(LONG, CheckSignal,
+        AROS_LH1(LONG, CheckSignal,
 
 /*  SYNOPSIS */
-       AROS_LHA(LONG, mask, D1),
+        AROS_LHA(LONG, mask, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 132, Dos)
+        struct DosLibrary *, DOSBase, 132, Dos)
 
 /*  FUNCTION
-       Checks the current task to see if any of the signals specified in
-       the mask have been set. The mask of all signals which were set is
-       returned. The signals specified in the mask will be cleared.
+        Checks the current task to see if any of the signals specified in
+        the mask have been set. The mask of all signals which were set is
+        returned. The signals specified in the mask will be cleared.
 
     INPUTS
-       mask - The signal mask to check.
+        mask - The signal mask to check.
 
     RESULT
-       The mask of all signals which were set.
+        The mask of all signals which were set.
 
     NOTES
 
index 486e767..434db83 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH0(struct CommandLineInterface *, Cli,
+        AROS_LH0(struct CommandLineInterface *, Cli,
 
 /*  SYNOPSIS */
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 82, Dos)
+        struct DosLibrary *, DOSBase, 82, Dos)
 
 /*  FUNCTION
-       Returns a pointer to the CLI structure of the current process.
+        Returns a pointer to the CLI structure of the current process.
 
     INPUTS
 
     RESULT
-       Pointer to CLI structure.
+        Pointer to CLI structure.
 
     NOTES
-       Do not use this function to test if the process was started from
-       the shell. Check pr_CLI instead.
+        Do not use this function to test if the process was started from
+        the shell. Check pr_CLI instead.
 
     EXAMPLE
 
index 650e70a..e22a08e 100644 (file)
@@ -28,12 +28,12 @@ static void PRINT_DOSTYPE(ULONG dt)
 
     for (i = 0; i < 4; i++)
     {
-       unsigned char c = dt >> (24 - i * 8);
+        unsigned char c = dt >> (24 - i * 8);
 
-       if (isprint(c))
-           RawPutChar(c);
-       else
-           bug("\\%02X", c);
+        if (isprint(c))
+            RawPutChar(c);
+        else
+            bug("\\%02X", c);
     }
 
     RawPutChar('\n');
@@ -53,13 +53,13 @@ static long internalBootCliHandler(void);
 #include <dos/dosextens.h>
 #include <proto/dos.h>
 
-       AROS_LH1(IPTR, CliInit,
+        AROS_LH1(IPTR, CliInit,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct DosPacket *, dp, A0),
+        AROS_LHA(struct DosPacket *, dp, A0),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 154, Dos)
+        struct DosLibrary *, DOSBase, 154, Dos)
 
 /*  FUNCTION
 
@@ -169,7 +169,7 @@ static long internalBootCliHandler(void);
         return RETURN_OK;
     /* Make sure we return non-zero error code, 0 == RETURN_OK */
     if (Res2 == 0)
-       Res2 = ERROR_UNKNOWN;
+        Res2 = ERROR_UNKNOWN;
 
     return Res2;
 
@@ -233,7 +233,7 @@ static void internalPatchBootNode(struct FileSysResource *fsr, struct DeviceNode
     /* If the DosType is 0 and dn_Handler == BNULL, use the default handler */
     if (de->de_DosType == 0 && dn->dn_Handler == BNULL)
     {
-       D(bug("Dos/CliInit: Neither DosType nor Handler specified, using default filesystem\n"));
+        D(bug("Dos/CliInit: Neither DosType nor Handler specified, using default filesystem\n"));
         dn->dn_SegList = defseg;
         dn->dn_GlobalVec = (BPTR)-1;
         return;
@@ -279,7 +279,7 @@ static struct MsgPort *mountBootNode(struct DeviceNode *dn, struct FileSysResour
     struct DosList *dl;
 
     if ((dn == NULL) || (dn->dn_Name == BNULL))
-       return NULL;
+        return NULL;
 
     D(bug("Dos/CliInit: Mounting 0x%p (%b)...\n", dn, dn->dn_Name));
 
@@ -288,8 +288,8 @@ static struct MsgPort *mountBootNode(struct DeviceNode *dn, struct FileSysResour
     
     while ((dl = NextDosEntry(dl, LDF_DEVICES)))
     {
-       if (dl == (struct DosList *)dn)
-           break;
+        if (dl == (struct DosList *)dn)
+            break;
     }
 
     UnLockDosList(LDF_DEVICES | LDF_READ);
@@ -297,7 +297,7 @@ static struct MsgPort *mountBootNode(struct DeviceNode *dn, struct FileSysResour
     /* Found in DOS list? Do nothing. */
     if (dl)
     {
-       return dl->dol_Task;
+        return dl->dol_Task;
     }
 
     /* Patch it up, if needed */
@@ -305,8 +305,8 @@ static struct MsgPort *mountBootNode(struct DeviceNode *dn, struct FileSysResour
 
     if (!dn->dn_Handler && !dn->dn_SegList)
     {
-       /* Don't know how to mount? Error... */
-       return NULL;
+        /* Don't know how to mount? Error... */
+        return NULL;
     }
 
     if (AddDosEntry((struct DosList *)dn) != DOSFALSE)
@@ -314,7 +314,7 @@ static struct MsgPort *mountBootNode(struct DeviceNode *dn, struct FileSysResour
         /*
          * Do not check for ANDF_STARTPROC because:
          * a) On the Amiga ADNF_STARTPROC was not present in KS 1.3 and earlier, there was no deferred mount.
-        * b) In fact if we have something in ExpansionBase, we for sure want it to be mounted.
+         * b) In fact if we have something in ExpansionBase, we for sure want it to be mounted.
          */
         D(bug("Dos/CliInit: Added to DOS list, starting up handler... "));
 
@@ -374,7 +374,7 @@ static BPTR internalBootLock(struct DosLibrary *DOSBase, struct ExpansionBase *E
     name = AllocVec(name_len + 2, MEMF_ANY);
     if (name != NULL)
     {
-       SIPTR err = 0;
+        SIPTR err = 0;
 
         /* Make the volume name a volume: name */
         CopyMem(AROS_BSTR_ADDR(dn->dn_Name), name, name_len);
@@ -389,10 +389,10 @@ static BPTR internalBootLock(struct DosLibrary *DOSBase, struct ExpansionBase *E
         {
             /* If we have a lock, check the per-platform conditional boot code. */
             if (!__dos_IsBootable(DOSBase, lock))
-           {
-                       UnLock(lock);
-               lock = BNULL;
-               err = ERROR_OBJECT_WRONG_TYPE; /* Something to more or less reflect "This disk is not bootable" */
+            {
+                UnLock(lock);
+                lock = BNULL;
+                err = ERROR_OBJECT_WRONG_TYPE; /* Something to more or less reflect "This disk is not bootable" */
             }
         }
         else
@@ -402,7 +402,7 @@ static BPTR internalBootLock(struct DosLibrary *DOSBase, struct ExpansionBase *E
 
         if (!lock)
         {
-           SIPTR dead;
+            SIPTR dead;
 
             /* Darn. Not bootable. Try to unmount it. */
             D(bug("Dos/CliInit:   Does not have a bootable filesystem, unmounting...\n"));
@@ -411,18 +411,18 @@ static BPTR internalBootLock(struct DosLibrary *DOSBase, struct ExpansionBase *E
             dead = DoPkt(mp, ACTION_DIE, 0, 0, 0, 0, 0);
             D(bug("Dos/CliInit:  ACTION_DIE returned %ld\n", dead));
 
-           if (dead)
-           {
-               /*
-                * Handlers usually won't remove their DeviceNoces themselves.
-                * And even if they do (ACTION_DIE is poorly documented), RemDosEntry()
-                * on an already removed entry is safe due to nature of DOS list.
-                * What is really prohibited, it's unloading own seglist. Well, resident
-                * handlers will never do it, they know...
-                */
-               RemDosEntry((struct DosList *)dn);
-               dn->dn_Task = NULL;
-           }
+            if (dead)
+            {
+                /*
+                 * Handlers usually won't remove their DeviceNoces themselves.
+                 * And even if they do (ACTION_DIE is poorly documented), RemDosEntry()
+                 * on an already removed entry is safe due to nature of DOS list.
+                 * What is really prohibited, it's unloading own seglist. Well, resident
+                 * handlers will never do it, they know...
+                 */
+                RemDosEntry((struct DosList *)dn);
+                dn->dn_Task = NULL;
+            }
             /* DoPkt() clobbered IoErr() */
             SetIoErr(err);
         }
@@ -437,7 +437,7 @@ static void AddBootAssign(CONST_STRPTR path, CONST_STRPTR assign, APTR DOSBase)
 {
     BPTR lock;
     if (!(lock = Lock(path, SHARED_LOCK)))
-       lock = Lock("SYS:", SHARED_LOCK);
+        lock = Lock("SYS:", SHARED_LOCK);
     if (lock)
         AssignLock(assign, lock);
 }
@@ -472,7 +472,7 @@ static long internalBootCliHandler(void)
 
     ExpansionBase = (APTR)OpenLibrary("expansion.library", 0);
     if (!ExpansionBase)
-       return ERROR_INVALID_RESIDENT_LIBRARY;
+        return ERROR_INVALID_RESIDENT_LIBRARY;
 
     /* It's perfectly fine if this fails. */
     fsr = OpenResource("FileSystem.resource");
@@ -483,20 +483,20 @@ static long internalBootCliHandler(void)
 
     if (lock == BNULL)
     {
-       /*
-        * We've failed. Inform our parent and exit.
-        * Immediately after we reply the packet, the parent (Boot Task) can expunge DOSBase.
-        * This is why we first cleanup, then use internal_ReplyPkt (DOSBase is considered
-        * invalid).
-        * Alternatively we could Forbid() before ReplyPkt(), but... Forbid() is so unpolite...
-        */
-       IPTR err = IoErr();
-
-       CloseLibrary(&ExpansionBase->LibNode);
-       CloseLibrary(&DOSBase->dl_lib);
-
-       /* Immediately after ReplyPkt() DOSBase can be freed. So Forbid() until we really quit. */
-       internal_ReplyPkt(dp, mp, DOSFALSE, err);
+        /*
+         * We've failed. Inform our parent and exit.
+         * Immediately after we reply the packet, the parent (Boot Task) can expunge DOSBase.
+         * This is why we first cleanup, then use internal_ReplyPkt (DOSBase is considered
+         * invalid).
+         * Alternatively we could Forbid() before ReplyPkt(), but... Forbid() is so unpolite...
+         */
+        IPTR err = IoErr();
+
+        CloseLibrary(&ExpansionBase->LibNode);
+        CloseLibrary(&DOSBase->dl_lib);
+
+        /* Immediately after ReplyPkt() DOSBase can be freed. So Forbid() until we really quit. */
+        internal_ReplyPkt(dp, mp, DOSFALSE, err);
         return err;
     }
 
@@ -562,7 +562,7 @@ static long internalBootCliHandler(void)
          * read mappings for disk-based handlers from file.
          * This way we could automount e. g. FAT, NTFS, EXT3/2, whatever else, partitions.
          */
-       mountBootNode(bn->bn_DeviceNode, fsr, DOSBase);
+        mountBootNode(bn->bn_DeviceNode, fsr, DOSBase);
     }
 
     CloseLibrary((APTR)ExpansionBase);
index bb78978..c7966e8 100644 (file)
 #include <dos/dosextens.h>
 #include <proto/dos.h>
 
-       AROS_LH1(IPTR, CliInitNewcli,
+        AROS_LH1(IPTR, CliInitNewcli,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct DosPacket *, dp, A0),
+        AROS_LHA(struct DosPacket *, dp, A0),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 155, Dos)
+        struct DosLibrary *, DOSBase, 155, Dos)
 
 /*  FUNCTION
 
index baf0b93..c61d4d5 100644 (file)
 #include <dos/dosextens.h>
 #include <proto/dos.h>
 
-       AROS_LH1(IPTR, CliInitRun,
+        AROS_LH1(IPTR, CliInitRun,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct DosPacket *, dp, A0),
+        AROS_LHA(struct DosPacket *, dp, A0),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 156, Dos)
+        struct DosLibrary *, DOSBase, 156, Dos)
 
 /*  FUNCTION
 
index 2a4926a..a1b9bd0 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(BOOL, Close,
+        AROS_LH1(BOOL, Close,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR, file, D1),
+        AROS_LHA(BPTR, file, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 6, Dos)
+        struct DosLibrary *, DOSBase, 6, Dos)
 
 /*  FUNCTION
-       Close a filehandle opened with Open(). If the file was used
-       with buffered I/O the final write may fail and thus Close()
-       return an error. The file is closed in any case.
+        Close a filehandle opened with Open(). If the file was used
+        with buffered I/O the final write may fail and thus Close()
+        return an error. The file is closed in any case.
 
     INPUTS
-       file  --  filehandle
+        file  --  filehandle
 
     RESULT
-       0 if there was an error. != 0 on success.
+        0 if there was an error. != 0 on success.
 
     NOTES
 
 
     /* 0 handles are OK */
     if(file == BNULL)
-       return ret;
+        return ret;
 
     /* Func3 == -1: file was already closed. */
     if (fh->fh_Func3 == -1)
-       Alert(AN_FileReclosed);
+        Alert(AN_FileReclosed);
 
     /* If the filehandle has a pending write on it Flush() the buffer. */
     if(fh->fh_Flags & FHF_WRITE)
-       ret = Flush(file);
+        ret = Flush(file);
 
     ret = dopacket1(DOSBase, NULL, fh->fh_Type, ACTION_END, fh->fh_Arg1);
 
index fe2c5b7..953a8e5 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(LONG, CompareDates,
+        AROS_LH2(LONG, CompareDates,
 
 /*  SYNOPSIS */
-       AROS_LHA(const struct DateStamp *, date1, D1),
-       AROS_LHA(const struct DateStamp *, date2, D2),
+        AROS_LHA(const struct DateStamp *, date1, D1),
+        AROS_LHA(const struct DateStamp *, date2, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 123, Dos)
+        struct DosLibrary *, DOSBase, 123, Dos)
 
 /*  FUNCTION
-       Compares two dates.
+        Compares two dates.
 
     INPUTS
-       date1, date2 - The two dates to compare.
+        date1, date2 - The two dates to compare.
 
     RESULT
-       < 0 if date1 is later than date2, == 0 if they are equal or > 0 
-       if date2 is later than date1.
+        < 0 if date1 is later than date2, == 0 if they are equal or > 0 
+        if date2 is later than date1.
 
     NOTES
-       This is NOT the same ordering as strcmp() !
+        This is NOT the same ordering as strcmp() !
 
     EXAMPLE
 
 
     if (diff == 0)
     {
-       diff = date2->ds_Minute - date1->ds_Minute;
+        diff = date2->ds_Minute - date1->ds_Minute;
 
-       if (diff == 0)
-           diff = date2->ds_Tick - date1->ds_Tick;
+        if (diff == 0)
+            diff = date2->ds_Tick - date1->ds_Tick;
     }
 
     return diff;
index 5ac0527..c112e1c 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(BPTR, CreateDir,
+        AROS_LH1(BPTR, CreateDir,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(CONST_STRPTR, name, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 20, Dos)
+        struct DosLibrary *, DOSBase, 20, Dos)
 
 /*  FUNCTION
-       Creates a new directory under the given name. If all went well, an
-       exclusive lock on the new diretory is returned.
+        Creates a new directory under the given name. If all went well, an
+        exclusive lock on the new diretory is returned.
 
     INPUTS
-       name  -- NUL terminated name.
+        name  -- NUL terminated name.
 
     RESULT
-       Exclusive lock to the new directory or 0 if it couldn't be created.
-       IoErr() gives additional information in that case.
+        Exclusive lock to the new directory or 0 if it couldn't be created.
+        IoErr() gives additional information in that case.
 
     NOTES
 
@@ -59,8 +59,8 @@
     D(bug("[CreateDir] '%s'\n", name));
 
     if (getpacketinfo(DOSBase, name, &phs)) {
-       lock = (BPTR)dopacket2(DOSBase, NULL, phs.port, ACTION_CREATE_DIR, phs.lock, phs.name);
-       freepacketinfo(DOSBase, &phs);
+        lock = (BPTR)dopacket2(DOSBase, NULL, phs.port, ACTION_CREATE_DIR, phs.lock, phs.name);
+        freepacketinfo(DOSBase, &phs);
     }
 
     return lock;
index 4f89eb1..5f0a6bd 100644 (file)
@@ -41,29 +41,29 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(struct Process *, CreateNewProc,
+        AROS_LH1(struct Process *, CreateNewProc,
 
 /*  SYNOPSIS */
-       AROS_LHA(const struct TagItem *, tags, D1),
+        AROS_LHA(const struct TagItem *, tags, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 83, Dos)
+        struct DosLibrary *, DOSBase, 83, Dos)
 
 /*  FUNCTION
-       Create a new process using the tagitem array.
+        Create a new process using the tagitem array.
 
     INPUTS
-       tags - information on the new process.
+        tags - information on the new process.
 
     RESULT
-       Pointer to the new process or NULL on error.
+        Pointer to the new process or NULL on error.
 
     NOTES
-       It is possible to supply NP_Input, NP_Output and NP_Error tags
-       with BNULL values. This is equal to NIL: handle, however if NP_Input
-       is set to BNULL, NP_Arguments tag will not work. Arguments are
-       passed to the process via input stream, and the stream needs
-       to be a valid handle for this. This is original AmigaOS(tm) feature.
+        It is possible to supply NP_Input, NP_Output and NP_Error tags
+        with BNULL values. This is equal to NIL: handle, however if NP_Input
+        is set to BNULL, NP_Arguments tag will not work. Arguments are
+        passed to the process via input stream, and the stream needs
+        to be a valid handle for this. This is original AmigaOS(tm) feature.
 
     EXAMPLE
 
@@ -78,13 +78,13 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     AROS_LIBFUNC_INIT
 
     /* Allocated resources */
-    struct Process             *process = NULL;
-    BPTR                        input = 0, output = 0, ces = 0, curdir = 0, homedir = 0, segList, *segArray;
-    STRPTR                      stack = NULL, name = NULL, argptr = NULL;
-    ULONG                       namesize = 0, argsize = 0;
-    struct MemList             *memlist = NULL;
+    struct Process              *process = NULL;
+    BPTR                         input = 0, output = 0, ces = 0, curdir = 0, homedir = 0, segList, *segArray;
+    STRPTR                       stack = NULL, name = NULL, argptr = NULL;
+    ULONG                        namesize = 0, argsize = 0;
+    struct MemList              *memlist = NULL;
     struct CommandLineInterface *cli = NULL;
-    struct Process             *me = (struct Process *)FindTask(NULL);
+    struct Process              *me = (struct Process *)FindTask(NULL);
     ULONG                        old_sig = 0;
     APTR                         entry;
 
@@ -94,32 +94,32 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
 
     struct TagItem defaults[]=
     {
-    /* 0 */    { NP_Seglist      , 0                           },
-    /* 1 */    { NP_Entry        , (IPTR)NULL                  },
-    /* 2 */    { NP_Input        , TAGDATA_NOT_SPECIFIED       },
-    /* 3 */    { NP_CloseInput   , 1                           },
-    /* 4 */    { NP_Output       , TAGDATA_NOT_SPECIFIED       },
-    /* 5 */    { NP_CloseOutput   , 1                          },
-    /* 6 */    { NP_Error        , TAGDATA_NOT_SPECIFIED       },
-    /* 7 */    { NP_CloseError   , 1                           },
-    /* 8 */    { NP_CurrentDir   , TAGDATA_NOT_SPECIFIED       },
-    /* 9 */    { NP_StackSize    , AROS_STACKSIZE              },
-    /*10 */    { NP_Name         , (IPTR)"New Process"         },
-    /*11 */    { NP_Priority     , me->pr_Task.tc_Node.ln_Pri  },
-    /*12 */    { NP_Arguments    , TAGDATA_NOT_SPECIFIED       },
-    /*13 */    { NP_Cli          , 0                           },
-    /*14 */    { NP_UserData     , (IPTR)NULL                  },
-    /*15 */    { NP_ExitCode     , (IPTR)NULL                  },
-    /*16 */    { NP_ExitData     , (IPTR)NULL                  },
-    /*17 */    { NP_WindowPtr    , (IPTR)NULL                  }, /* Default: default public screen */
-    /*18 */    { NP_CopyVars     , (IPTR)TRUE                  },
-    /*19 */    { NP_Synchronous   , (IPTR)FALSE                },
-    /*20 */    { NP_FreeSeglist   , (IPTR)TRUE                 },
-    /*21 */    { NP_HomeDir      , TAGDATA_NOT_SPECIFIED       },
+    /* 0 */    { NP_Seglist       , 0                           },
+    /* 1 */    { NP_Entry         , (IPTR)NULL                  },
+    /* 2 */    { NP_Input         , TAGDATA_NOT_SPECIFIED       },
+    /* 3 */    { NP_CloseInput    , 1                           },
+    /* 4 */    { NP_Output        , TAGDATA_NOT_SPECIFIED       },
+    /* 5 */    { NP_CloseOutput   , 1                           },
+    /* 6 */    { NP_Error         , TAGDATA_NOT_SPECIFIED       },
+    /* 7 */    { NP_CloseError    , 1                           },
+    /* 8 */    { NP_CurrentDir    , TAGDATA_NOT_SPECIFIED       },
+    /* 9 */    { NP_StackSize     , AROS_STACKSIZE              },
+    /*10 */    { NP_Name          , (IPTR)"New Process"         },
+    /*11 */    { NP_Priority      , me->pr_Task.tc_Node.ln_Pri  },
+    /*12 */    { NP_Arguments     , TAGDATA_NOT_SPECIFIED       },
+    /*13 */    { NP_Cli           , 0                           },
+    /*14 */    { NP_UserData      , (IPTR)NULL                  },
+    /*15 */    { NP_ExitCode      , (IPTR)NULL                  },
+    /*16 */    { NP_ExitData      , (IPTR)NULL                  },
+    /*17 */    { NP_WindowPtr     , (IPTR)NULL                  }, /* Default: default public screen */
+    /*18 */    { NP_CopyVars      , (IPTR)TRUE                  },
+    /*19 */    { NP_Synchronous   , (IPTR)FALSE                 },
+    /*20 */    { NP_FreeSeglist   , (IPTR)TRUE                  },
+    /*21 */    { NP_HomeDir       , TAGDATA_NOT_SPECIFIED       },
     /*22 */    { NP_Path          , TAGDATA_NOT_SPECIFIED       }, /* Default: copy path from parent */
     /*23 */    { NP_NotifyOnDeath , (IPTR)FALSE                 },
     /*24 */    { NP_ConsoleTask   , TAGDATA_NOT_SPECIFIED       },
-              { TAG_END          , 0                           }
+               { TAG_END          , 0                           }
     };
 
     /* C has no exceptions. This is a simple replacement. */
@@ -131,18 +131,18 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     /* Inherit the parent process' stacksize if possible */
     if (__is_process(me))
     {
-       struct CommandLineInterface *cli = Cli();
+        struct CommandLineInterface *cli = Cli();
 
-       if (cli)
-       {
-           LONG parentstack = cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT;
+        if (cli)
+        {
+            LONG parentstack = cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT;
 
-           D(bug("[createnewproc] Parent stack: %u (0x%08X)\n", parentstack, parentstack));
-           if (parentstack > AROS_STACKSIZE)
-           {
-               defaults[9].ti_Data = parentstack;
-           }
-       }
+            D(bug("[createnewproc] Parent stack: %u (0x%08X)\n", parentstack, parentstack));
+            if (parentstack > AROS_STACKSIZE)
+            {
+                defaults[9].ti_Data = parentstack;
+            }
+        }
     }
 
     ApplyTagChanges(defaults, (struct TagItem *)tags);
@@ -215,7 +215,7 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     /* We need a minimum stack to handle interrupt contexts */
     if (process->pr_StackSize < AROS_STACKSIZE)
     {
-       process->pr_StackSize = AROS_STACKSIZE;
+        process->pr_StackSize = AROS_STACKSIZE;
     }
 
     stack = AllocMem(process->pr_StackSize, MEMF_PUBLIC);
@@ -228,26 +228,26 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     /* NP_Arguments */
     if (defaults[12].ti_Data != TAGDATA_NOT_SPECIFIED)
     {
-       CONST_STRPTR args = (CONST_STRPTR)defaults[12].ti_Data;
+        CONST_STRPTR args = (CONST_STRPTR)defaults[12].ti_Data;
 
-       /* If NULL, then it was provided by the user,
-        * so use the empty "" arg list
-        */
-       if (args == NULL)
-       {
-           args = "";
-       }
+        /* If NULL, then it was provided by the user,
+         * so use the empty "" arg list
+         */
+        if (args == NULL)
+        {
+            args = "";
+        }
 
         argsize = strlen(args);
         argptr  = (STRPTR)AllocVec(argsize+1, MEMF_PUBLIC);
         ENOMEM_IF(argptr == NULL);
         CopyMem(args, argptr, argsize+1);
 
-       D(bug("[createnewproc] Arguments \"%s\"\n", argptr));
+        D(bug("[createnewproc] Arguments \"%s\"\n", argptr));
     }
 
     memlist = AllocMem(sizeof(struct MemList) + 2*sizeof(struct MemEntry),
-                      MEMF_ANY);
+                       MEMF_ANY);
     ENOMEM_IF(memlist == NULL);
 
     /* NP_Cli */
@@ -255,32 +255,32 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     {
         BPTR oldpath = BNULL;
         
-       /* Don't forget to pass tags to AllocDosObject() */
-       cli = (struct CommandLineInterface *)AllocDosObject(DOS_CLI, (struct TagItem *)tags);
-       ENOMEM_IF(cli == NULL);
+        /* Don't forget to pass tags to AllocDosObject() */
+        cli = (struct CommandLineInterface *)AllocDosObject(DOS_CLI, (struct TagItem *)tags);
+        ENOMEM_IF(cli == NULL);
 
-       cli->cli_DefaultStack = (process->pr_StackSize + CLI_DEFAULTSTACK_UNIT - 1) / CLI_DEFAULTSTACK_UNIT;
+        cli->cli_DefaultStack = (process->pr_StackSize + CLI_DEFAULTSTACK_UNIT - 1) / CLI_DEFAULTSTACK_UNIT;
 
-       if (__is_process(me))
-       {
-           struct CommandLineInterface *oldcli = Cli();
+        if (__is_process(me))
+        {
+            struct CommandLineInterface *oldcli = Cli();
 
-           if (oldcli != NULL)
-           {
-               LONG oldlen = AROS_BSTR_strlen(oldcli->cli_Prompt);
-               LONG newlen = GetTagData(ADO_PromptLen, 255, tags);
+            if (oldcli != NULL)
+            {
+                LONG oldlen = AROS_BSTR_strlen(oldcli->cli_Prompt);
+                LONG newlen = GetTagData(ADO_PromptLen, 255, tags);
 
-               oldpath = oldcli->cli_CommandDir;
+                oldpath = oldcli->cli_CommandDir;
 
-               CopyMem(BADDR(oldcli->cli_Prompt), BADDR(cli->cli_Prompt), (newlen<oldlen?newlen:oldlen) + 1);
-           }
+                CopyMem(BADDR(oldcli->cli_Prompt), BADDR(cli->cli_Prompt), (newlen<oldlen?newlen:oldlen) + 1);
+            }
 
-           process->pr_CLI = MKBADDR(cli);
-           addprocesstoroot(process, DOSBase);
-       }
+            process->pr_CLI = MKBADDR(cli);
+            addprocesstoroot(process, DOSBase);
+        }
 
 
-       if (defaults[22].ti_Data != TAGDATA_NOT_SPECIFIED)
+        if (defaults[22].ti_Data != TAGDATA_NOT_SPECIFIED)
         {
             cli->cli_CommandDir = (BPTR) defaults[22].ti_Data;
         }
@@ -294,65 +294,65 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
 
     if (defaults[2].ti_Data == TAGDATA_NOT_SPECIFIED)
     {
-       input = OpenNIL(DOSBase);
-       ERROR_IF(!input);
+        input = OpenNIL(DOSBase);
+        ERROR_IF(!input);
 
-       defaults[2].ti_Data = (IPTR)input;
+        defaults[2].ti_Data = (IPTR)input;
     }
 
     /* NP_Output */
 
     if (defaults[4].ti_Data == TAGDATA_NOT_SPECIFIED)
     {
-       output = OpenNIL(DOSBase);
-       ERROR_IF(!output);
+        output = OpenNIL(DOSBase);
+        ERROR_IF(!output);
 
-       defaults[4].ti_Data = (IPTR)output;
+        defaults[4].ti_Data = (IPTR)output;
     }
 
     /* NP_Error */
 
     if (defaults[6].ti_Data == TAGDATA_NOT_SPECIFIED)
     {
-       ces = OpenNIL(DOSBase);
-       ERROR_IF(!ces);
+        ces = OpenNIL(DOSBase);
+        ERROR_IF(!ces);
 
-       defaults[6].ti_Data = (IPTR)ces;
+        defaults[6].ti_Data = (IPTR)ces;
     }
 
     /* NP_CurrentDir */
 
     if (defaults[8].ti_Data == TAGDATA_NOT_SPECIFIED)
     {
-       if (__is_process(me) && me->pr_CurrentDir)
-       {
-           curdir = Lock("", SHARED_LOCK);
-           ERROR_IF(!curdir);
+        if (__is_process(me) && me->pr_CurrentDir)
+        {
+            curdir = Lock("", SHARED_LOCK);
+            ERROR_IF(!curdir);
 
-           defaults[8].ti_Data = (IPTR)curdir;
-       }
-       else
-       {
-           defaults[8].ti_Data = 0;
-       }
+            defaults[8].ti_Data = (IPTR)curdir;
+        }
+        else
+        {
+            defaults[8].ti_Data = 0;
+        }
     }
 
     /* NP_HomeDir */
 
     if (defaults[21].ti_Data == TAGDATA_NOT_SPECIFIED)
     {
-       defaults[21].ti_Data = 0;
+        defaults[21].ti_Data = 0;
 
-       if (__is_process(me))
-       {
-           if (me->pr_HomeDir)
-           {
-               homedir = DupLock(me->pr_HomeDir);
-               ERROR_IF(!homedir);
+        if (__is_process(me))
+        {
+            if (me->pr_HomeDir)
+            {
+                homedir = DupLock(me->pr_HomeDir);
+                ERROR_IF(!homedir);
 
-               defaults[21].ti_Data = (IPTR)homedir;
-           }
-       }
+                defaults[21].ti_Data = (IPTR)homedir;
+            }
+        }
     }
 
     CopyMem((APTR)defaults[10].ti_Data, name, namesize);
@@ -398,13 +398,13 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
 
     /* Inherit pr_ConsoleTask and pr_FileSystemTask from parent */
     if (defaults[24].ti_Data != TAGDATA_NOT_SPECIFIED)
-       process->pr_ConsoleTask = (struct MsgPort*)defaults[24].ti_Data;
+        process->pr_ConsoleTask = (struct MsgPort*)defaults[24].ti_Data;
     else if (__is_process(me))
-       process->pr_ConsoleTask = me->pr_ConsoleTask;
+        process->pr_ConsoleTask = me->pr_ConsoleTask;
     if (__is_process(me))
-       process->pr_FileSystemTask = me->pr_FileSystemTask;
+        process->pr_FileSystemTask = me->pr_FileSystemTask;
     else
-       process->pr_FileSystemTask = DOSBase->dl_Root->rn_BootProc;
+        process->pr_FileSystemTask = DOSBase->dl_Root->rn_BootProc;
     D(bug("[createnewproc] pr_ConsoleTask = %p\n", process->pr_ConsoleTask));
     D(bug("[createnewproc] pr_FileSystemTask = %p\n", process->pr_FileSystemTask));
 
@@ -417,23 +417,23 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     process->pr_WindowPtr = (struct Window *)defaults[17].ti_Data;
     process->pr_HomeDir = (BPTR)defaults[21].ti_Data;
     process->pr_Flags = (defaults[3].ti_Data  ? PRF_CLOSEINPUT    : 0) |
-                       (defaults[5].ti_Data  ? PRF_CLOSEOUTPUT   : 0) |
-                       (defaults[7].ti_Data  ? PRF_CLOSEERROR    : 0) |
-                       (defaults[8].ti_Data  ? PRF_FREECURRDIR   : 0) |
-                       (defaults[13].ti_Data ? PRF_FREECLI       : 0) |
-                       (defaults[19].ti_Data ? PRF_SYNCHRONOUS   : 0) |
-                       (defaults[20].ti_Data ? PRF_FREESEGLIST   : 0) |
-                       (defaults[23].ti_Data ? PRF_NOTIFYONDEATH : 0) |
-                       (argptr               ? PRF_FREEARGS      : 0);
+                        (defaults[5].ti_Data  ? PRF_CLOSEOUTPUT   : 0) |
+                        (defaults[7].ti_Data  ? PRF_CLOSEERROR    : 0) |
+                        (defaults[8].ti_Data  ? PRF_FREECURRDIR   : 0) |
+                        (defaults[13].ti_Data ? PRF_FREECLI       : 0) |
+                        (defaults[19].ti_Data ? PRF_SYNCHRONOUS   : 0) |
+                        (defaults[20].ti_Data ? PRF_FREESEGLIST   : 0) |
+                        (defaults[23].ti_Data ? PRF_NOTIFYONDEATH : 0) |
+                        (argptr               ? PRF_FREEARGS      : 0);
     process->pr_ExitCode = (APTR)defaults[15].ti_Data;
     process->pr_ExitData = defaults[16].ti_Data;
     process->pr_Arguments = argptr;
 
     if ((BOOL)defaults[18].ti_Data)      /* NP_CopyVars */
     {
-       BOOL res = copyVars(me, process, DOSBase);
+        BOOL res = copyVars(me, process, DOSBase);
 
-       ENOMEM_IF(res == FALSE);
+        ENOMEM_IF(res == FALSE);
     }
 
     process->pr_ShellPrivate = 0;
@@ -442,7 +442,7 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
     if (defaults[19].ti_Data)
     {
         me->pr_Flags |= PRF_WAITINGFORCHILD;
-       
+        
         old_sig = SetSignal(0L, SIGF_SINGLE) & SIGF_SINGLE; 
     }
 
@@ -466,9 +466,9 @@ void internal_ChildFree(APTR tid, struct DosLibrary * DOSBase);
 
     D(bug("[createnewproc] Creating SegArray %p, segList=%p\n", segArray, BADDR(segList)));
     segArray[0] = (BPTR)SEGARRAY_LENGTH;
-    segArray[1] = (BPTR)-1;    /* 'system' segment */
-    segArray[2] = (BPTR)-2;    /* 'dosbase' segment */
-    segArray[3] = segList;     /* Program segment */
+    segArray[1] = (BPTR)-1;     /* 'system' segment */
+    segArray[2] = (BPTR)-2;     /* 'dosbase' segment */
+    segArray[3] = segList;      /* Program segment */
 
     process->pr_SegList = MKBADDR(segArray);
 
@@ -536,7 +536,7 @@ enomem:
 
     if (__is_process(me))
     {
-       SetIoErr(ERROR_NO_FREE_STORE);
+        SetIoErr(ERROR_NO_FREE_STORE);
     }
 
     freeLocalVars(process, DOSBase);
@@ -547,59 +547,59 @@ error:
 
     if (cli != NULL)
     {
-       FreeDosObject(DOS_CLI, cli);
+        FreeDosObject(DOS_CLI, cli);
     }
 
     if (homedir != BNULL)
     {
-       UnLock(homedir);
+        UnLock(homedir);
     }
 
     if (curdir != BNULL)
     {
-       UnLock(curdir);
+        UnLock(curdir);
     }
 
     if (output != BNULL)
     {
-       Close(output);
+        Close(output);
     }
 
     if (input != BNULL)
     {
-       Close(input);
+        Close(input);
     }
 
     if (ces != BNULL)
     {
-       Close(ces);
+        Close(ces);
     }
 
     if (argptr != NULL)
     {
-       FreeVec(argptr);
+        FreeVec(argptr);
     }
 
     if (memlist != NULL)
     {
-       FreeMem(memlist, sizeof(struct MemList) + 2*sizeof(struct MemEntry));
+        FreeMem(memlist, sizeof(struct MemList) + 2*sizeof(struct MemEntry));
     }
 
     if (name != NULL)
     {
-       FreeMem(name, namesize);
+        FreeMem(name, namesize);
     }
 
     if (stack != NULL)
     {
-       FreeMem(stack, process->pr_StackSize);
+        FreeMem(stack, process->pr_StackSize);
     }
 
     if (process != NULL)
     {
-       FreeMem(process, sizeof(struct Process));
+        FreeMem(process, sizeof(struct Process));
 
-       process = NULL;
+        process = NULL;
     }
 
 end:
@@ -618,13 +618,13 @@ static void freeLocalVars(struct Process *process, struct DosLibrary *DOSBase)
     struct Node     *tempNode;
     
     ForeachNodeSafe(&process->pr_LocalVars,
-                   varNode, tempNode)
+                    varNode, tempNode)
     {
-       D(bug("Freeing variable %s with value %s at %p\n",
-                 varNode->lv_Node.ln_Name, varNode->lv_Value, varNode));
-       FreeMem(varNode->lv_Value, varNode->lv_Len);
-       Remove((struct Node *)varNode);
-       FreeVec(varNode);
+        D(bug("Freeing variable %s with value %s at %p\n",
+                  varNode->lv_Node.ln_Name, varNode->lv_Value, varNode));
+        FreeMem(varNode->lv_Value, varNode->lv_Len);
+        Remove((struct Node *)varNode);
+        FreeVec(varNode);
     }
 }
 
@@ -677,44 +677,44 @@ BOOL copyVars(struct Process *fromProcess, struct Process *toProcess, struct Dos
     /* We must have variables to copy... */
     if (__is_process(fromProcess))
     {
-       struct LocalVar *varNode;
-       struct LocalVar *newVar;
-       
-       /* We use the same strategy as in the ***Var() functions */
-       ForeachNode(&fromProcess->pr_LocalVars, varNode)
-       {
-           LONG  copyLength = strlen(varNode->lv_Node.ln_Name) + 1 +
-               sizeof(struct LocalVar);
-           
-           newVar = (struct LocalVar *)AllocVec(copyLength,
-                                                MEMF_PUBLIC | MEMF_CLEAR);
-           if (newVar == NULL)
-               return FALSE;
-
-           CopyMem(varNode, newVar, copyLength);
-           newVar->lv_Node.ln_Name = (char *)newVar +
-               sizeof(struct LocalVar);
-           D(bug("Variable with name %s copied.\n", 
-                     newVar->lv_Node.ln_Name));
-           
+        struct LocalVar *varNode;
+        struct LocalVar *newVar;
+        
+        /* We use the same strategy as in the ***Var() functions */
+        ForeachNode(&fromProcess->pr_LocalVars, varNode)
+        {
+            LONG  copyLength = strlen(varNode->lv_Node.ln_Name) + 1 +
+                sizeof(struct LocalVar);
+            
+            newVar = (struct LocalVar *)AllocVec(copyLength,
+                                                 MEMF_PUBLIC | MEMF_CLEAR);
+            if (newVar == NULL)
+                return FALSE;
+
+            CopyMem(varNode, newVar, copyLength);
+            newVar->lv_Node.ln_Name = (char *)newVar +
+                sizeof(struct LocalVar);
+            D(bug("Variable with name %s copied.\n", 
+                      newVar->lv_Node.ln_Name));
+            
             if (varNode->lv_Len)
             {
-               newVar->lv_Value = AllocMem(varNode->lv_Len, MEMF_PUBLIC);
-           
-               if (newVar->lv_Value == NULL)
-               {
-                   /* Free variable node before shutting down */
-                   FreeVec(newVar);
-               
-                   return FALSE;
-               }
-           
+                newVar->lv_Value = AllocMem(varNode->lv_Len, MEMF_PUBLIC);
+            
+                if (newVar->lv_Value == NULL)
+                {
+                    /* Free variable node before shutting down */
+                    FreeVec(newVar);
+                
+                    return FALSE;
+                }
+            
                 CopyMem(varNode->lv_Value, newVar->lv_Value, varNode->lv_Len);
-           }
+            }
 
-           AddTail((struct List *)&toProcess->pr_LocalVars,
-                   (struct Node *)newVar);
-       }
+            AddTail((struct List *)&toProcess->pr_LocalVars,
+                    (struct Node *)newVar);
+        }
     }
 
     return TRUE;
@@ -755,31 +755,31 @@ static void DosEntry(void)
     if (me->pr_ExitCode != NULL)
     {
         /* 
-          The Ralph Babel's guru book says that pr_ExitCode
-          is passed the process return code in D0 and pr_ExitData in D1,
-          but the Matt Dillon's DICE C implementation of vfork shows that
-          those parameters are passed also on the stack.          
-        */
+           The Ralph Babel's guru book says that pr_ExitCode
+           is passed the process return code in D0 and pr_ExitData in D1,
+           but the Matt Dillon's DICE C implementation of vfork shows that
+           those parameters are passed also on the stack.          
+         */
 #ifdef __mc68000
-       asm volatile (
-               "move.l %0, %%d0\n"
-               "move.l %1, %%d1\n"
-               "move.l %2, %%a0\n"
-               "move.l %%d0, %%sp@-\n"
-               "move.l %%d1, %%sp@-\n"
-               "jsr (%%a0)\n"
-               "addq.l #8, %%sp\n"
-               : /* No return values */
-               : "g" (result), "g" (me->pr_ExitData), "g" (me->pr_ExitCode)
-               : "d0", "d1", "a0", "a1"
-       );
+        asm volatile (
+                "move.l %0, %%d0\n"
+                "move.l %1, %%d1\n"
+                "move.l %2, %%a0\n"
+                "move.l %%d0, %%sp@-\n"
+                "move.l %%d1, %%sp@-\n"
+                "jsr (%%a0)\n"
+                "addq.l #8, %%sp\n"
+                : /* No return values */
+                : "g" (result), "g" (me->pr_ExitData), "g" (me->pr_ExitCode)
+                : "d0", "d1", "a0", "a1"
+        );
 #else
-       /* 
-          The AROS macros for functions with register parameters don't
-          support both register and stack parameters at once, so we use 
-          the stack only on non-m68k. This oughta be fixed somehow.
+        /* 
+           The AROS macros for functions with register parameters don't
+           support both register and stack parameters at once, so we use 
+           the stack only on non-m68k. This oughta be fixed somehow.
          */
-       me->pr_ExitCode(result, me->pr_ExitData);
+        me->pr_ExitCode(result, me->pr_ExitData);
 #endif
     }
 
@@ -809,38 +809,38 @@ static void DosEntry(void)
 
     if (me->pr_Flags & PRF_CLOSEINPUT)
     {
-       Close(cis);
+        Close(cis);
     }
 
     D(bug("Closing output stream\n"));
 
     if (me->pr_Flags & PRF_CLOSEOUTPUT)
     {
-       Close(cos);
+        Close(cos);
     }
 
     D(bug("Closing error stream\n"));
 
     if (me->pr_Flags & PRF_CLOSEERROR)
     {
-       Close(ces);
+        Close(ces);
     }
 
     D(bug("Freeing arguments\n"));
 
     if (me->pr_Flags & PRF_FREEARGS)
     {
-       FreeVec(me->pr_Arguments);
+        FreeVec(me->pr_Arguments);
     }
 
     D(bug("Unloading segment\n"));
 
     if (me->pr_Flags & PRF_FREESEGLIST)
     {
-       BPTR *segarray = BADDR(me->pr_SegList);
+        BPTR *segarray = BADDR(me->pr_SegList);
 
-       if (segarray && segarray[3])
-           UnLoadSeg(segarray[3]);
+        if (segarray && segarray[3])
+            UnLoadSeg(segarray[3]);
     }
 
     if (me->pr_SegList)
@@ -855,7 +855,7 @@ static void DosEntry(void)
 
     if (me->pr_Flags & PRF_FREECURRDIR)
     {
-       UnLock(me->pr_CurrentDir);
+        UnLock(me->pr_CurrentDir);
     }
 
     D(bug("Unlocking home dir\n"));
@@ -865,9 +865,9 @@ static void DosEntry(void)
 
     if (me->pr_Flags & PRF_FREECLI)
     {
-       FreeDosObject(DOS_CLI, BADDR(me->pr_CLI));
-       removefromrootnode(me, DOSBase);
-       me->pr_CLI = BNULL;
+        FreeDosObject(DOS_CLI, BADDR(me->pr_CLI));
+        removefromrootnode(me, DOSBase);
+        me->pr_CLI = BNULL;
     }
 
     /* Synchronous completion must be before
dissimilarity index 72%
index 3511125..ddb1ed0 100644 (file)
-/*
-    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
-    $Id$
-
-    Desc: Create a new process (in an old way).
-    Lang: English
-*/
-
-#include "dos_intern.h"
-#include <dos/dostags.h>
-#include <proto/exec.h>
-
-/*****************************************************************************
-
-    NAME */
-#include <proto/dos.h>
-
-       AROS_LH4(struct MsgPort *, CreateProc,
-
-/*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
-       AROS_LHA(LONG, pri, D2),
-       AROS_LHA(BPTR, segList, D3),
-       AROS_LHA(LONG, stackSize, D4),
-
-/*  LOCATION */
-       struct DosLibrary *, DOSBase, 23, Dos)
-
-/*  FUNCTION
-       CreateProc() will create a new process (a process is a superset
-       of an exec Task), with the name 'name' and the priority 'pri'.
-
-       You should pass a segList as returned by LoadSeg() (or similar)
-       in the 'segList' parameter, and specify the stack size in
-       'stackSize'.
-
-       You should really use CreateNewProc() rather than this function
-       as it is much more flexible.
-
-    INPUTS
-       name        --   Name of the new process.
-       pri         --   Starting priority.
-       segList     --   BCPL pointer to a seglist.
-       stackSize   --   The size of the initial process stack.
-
-    RESULT
-       Pointer to the pr_MsgPort in the Process structure. Will
-       return NULL on failure.
-
-    NOTES
-       This will not free the seglist when the process finishes.
-
-       This does not return a pointer to the Process structure, but
-       rather the MsgPort structure contained within it. You can
-       get the real Process structure by:
-
-       struct Process *pr;
-       struct MsgPort *mp;
-
-       mp = CreateProc(...);
-       pr = (struct Process *)((struct Task *)mp - 1);
-
-       // Shouldn't use mp after this point
-
-    EXAMPLE
-
-    BUGS
-
-    SEE ALSO
-       CreateNewProc(), LoadSeg(), UnLoadSeg()
-
-    INTERNALS
-       Basically passes this call to CreateNewProc().
-
-*****************************************************************************/
-{
-    AROS_LIBFUNC_INIT
-
-    struct Process *pr;              /* The process to create */
-    struct Process *parent = (struct Process *)FindTask(NULL);
-    APTR            windowPtr = NULL;
-
-    /* If the caller is a process, inherit its window pointer */
-    if (__is_process(parent))
-    {
-       windowPtr = parent->pr_WindowPtr;
-    }
-
-    {
-       /* Don't forget to find out some extra defaults here */
-       struct TagItem procTags[] =
-       {
-           { NP_Seglist        , (IPTR)segList   },
-           { NP_FreeSeglist    , FALSE           },
-           { NP_StackSize      , stackSize       },
-           { NP_Name           , (IPTR)name      },
-           { NP_Priority       , pri             },
-           { NP_WindowPtr      , (IPTR)windowPtr },
-           /* These arguments are necessary, for
-            * AOS 3.x compatability. Specifically,
-            * CreateProc() must *not* break Forbid()
-            * locking.
-            */
-           { NP_CurrentDir     , 0               },
-           { NP_HomeDir        , 0               },
-           { NP_Input          , 0               },
-           { NP_Output         , 0               },
-           { NP_CloseInput     , FALSE           },
-           { NP_CloseOutput    , FALSE           },
-           { TAG_DONE          , 0               }
-       };
-       
-       if ((pr = CreateNewProc(procTags)))
-       {
-           return (struct MsgPort *)&pr->pr_MsgPort;
-       }
-       else
-       {
-           return NULL;
-       }
-    }
-
-    AROS_LIBFUNC_EXIT
-} /* CreateProc */
+/*
+    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
+    $Id$
+
+    Desc: Create a new process (in an old way).
+    Lang: English
+*/
+
+#include "dos_intern.h"
+#include <dos/dostags.h>
+#include <proto/exec.h>
+
+/*****************************************************************************
+
+    NAME */
+#include <proto/dos.h>
+
+        AROS_LH4(struct MsgPort *, CreateProc,
+
+/*  SYNOPSIS */
+        AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(LONG, pri, D2),
+        AROS_LHA(BPTR, segList, D3),
+        AROS_LHA(LONG, stackSize, D4),
+
+/*  LOCATION */
+        struct DosLibrary *, DOSBase, 23, Dos)
+
+/*  FUNCTION
+        CreateProc() will create a new process (a process is a superset
+        of an exec Task), with the name 'name' and the priority 'pri'.
+
+        You should pass a segList as returned by LoadSeg() (or similar)
+        in the 'segList' parameter, and specify the stack size in
+        'stackSize'.
+
+        You should really use CreateNewProc() rather than this function
+        as it is much more flexible.
+
+    INPUTS
+        name        --   Name of the new process.
+        pri         --   Starting priority.
+        segList     --   BCPL pointer to a seglist.
+        stackSize   --   The size of the initial process stack.
+
+    RESULT
+        Pointer to the pr_MsgPort in the Process structure. Will
+        return NULL on failure.
+
+    NOTES
+        This will not free the seglist when the process finishes.
+
+        This does not return a pointer to the Process structure, but
+        rather the MsgPort structure contained within it. You can
+        get the real Process structure by:
+
+        struct Process *pr;
+        struct MsgPort *mp;
+
+        mp = CreateProc(...);
+        pr = (struct Process *)((struct Task *)mp - 1);
+
+        // Shouldn't use mp after this point
+
+    EXAMPLE
+
+    BUGS
+
+    SEE ALSO
+        CreateNewProc(), LoadSeg(), UnLoadSeg()
+
+    INTERNALS
+        Basically passes this call to CreateNewProc().
+
+*****************************************************************************/
+{
+    AROS_LIBFUNC_INIT
+
+    struct Process *pr;       /* The process to create */
+    struct Process *parent = (struct Process *)FindTask(NULL);
+    APTR            windowPtr = NULL;
+
+    /* If the caller is a process, inherit its window pointer */
+    if (__is_process(parent))
+    {
+        windowPtr = parent->pr_WindowPtr;
+    }
+
+    {
+        /* Don't forget to find out some extra defaults here */
+        struct TagItem procTags[] =
+        {
+            { NP_Seglist        , (IPTR)segList   },
+            { NP_FreeSeglist    , FALSE           },
+            { NP_StackSize      , stackSize       },
+            { NP_Name           , (IPTR)name      },
+            { NP_Priority       , pri             },
+            { NP_WindowPtr      , (IPTR)windowPtr },
+            /* These arguments are necessary, for
+             * AOS 3.x compatability. Specifically,
+             * CreateProc() must *not* break Forbid()
+             * locking.
+             */
+            { NP_CurrentDir     , 0               },
+            { NP_HomeDir        , 0               },
+            { NP_Input          , 0               },
+            { NP_Output         , 0               },
+            { NP_CloseInput     , FALSE           },
+            { NP_CloseOutput    , FALSE           },
+            { TAG_DONE          , 0               }
+        };
+        
+        if ((pr = CreateNewProc(procTags)))
+        {
+            return (struct MsgPort *)&pr->pr_MsgPort;
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+
+    AROS_LIBFUNC_EXIT
+} /* CreateProc */
index d2d9374..285dc10 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(BPTR, CurrentDir,
+        AROS_LH1(BPTR, CurrentDir,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR, lock, D1),
+        AROS_LHA(BPTR, lock, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 21, Dos)
+        struct DosLibrary *, DOSBase, 21, Dos)
 
 /*  FUNCTION
-       Sets a new directory as the current directory. Returns the old one.
-       0 is valid in both cases and represents the boot filesystem.
+        Sets a new directory as the current directory. Returns the old one.
+        0 is valid in both cases and represents the boot filesystem.
 
     INPUTS
-       lock - Lock for the new current directory.
+        lock - Lock for the new current directory.
 
     RESULT
-       Old current directory.
+        Old current directory.
 
     NOTES
 
index 6b04513..ea46c54 100644 (file)
 
 #define SECONDS_PER_DAY     (60UL * 60 * 24)
 #define SECONDS_PER_MINUTE  (60UL)
-#define uSEC_PER_SEC       (1000000UL)
-#define TICKS_PER_SEC      (50UL)
-#define uSEC_PER_TICK      (uSEC_PER_SEC / TICKS_PER_SEC)
+#define uSEC_PER_SEC        (1000000UL)
+#define TICKS_PER_SEC       (50UL)
+#define uSEC_PER_TICK       (uSEC_PER_SEC / TICKS_PER_SEC)
 
 /*****************************************************************************
 
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(struct DateStamp *, DateStamp,
+        AROS_LH1(struct DateStamp *, DateStamp,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct DateStamp *, date, D1),
+        AROS_LHA(struct DateStamp *, date, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 32, Dos)
+        struct DosLibrary *, DOSBase, 32, Dos)
 
 /*  FUNCTION
-       Fills the structure with the current time. Time is measured from
-       Jan 1, 1978.
+        Fills the structure with the current time. Time is measured from
+        Jan 1, 1978.
 
     INPUTS
-       date - The structure to fill.
+        date - The structure to fill.
 
     RESULT
-       date->ds_Days is filled with the days from Jan 1, 1978.
-       date->ds_Minute is filled with the number of minutes elapsed in the
-       day. date->ds_Tick is the number of ticks elapsed in the current
-       minute. A tick happens 50 times a second. DateStamp() ensures that
-       the day and minute are consistent. All three elements are zero if
-       the date is unset.
+        date->ds_Days is filled with the days from Jan 1, 1978.
+        date->ds_Minute is filled with the number of minutes elapsed in the
+        day. date->ds_Tick is the number of ticks elapsed in the current
+        minute. A tick happens 50 times a second. DateStamp() ensures that
+        the day and minute are consistent. All three elements are zero if
+        the date is unset.
 
     NOTES
-       The original function could only return even multiples of 50 ticks.
+        The original function could only return even multiples of 50 ticks.
 
     EXAMPLE
 
@@ -67,7 +67,7 @@
     date->ds_Minute = tv.tv_secs / SECONDS_PER_MINUTE;
     tv.tv_secs %= SECONDS_PER_MINUTE;
     date->ds_Tick = (tv.tv_micro + tv.tv_secs * uSEC_PER_SEC) /
-           uSEC_PER_TICK;
+            uSEC_PER_TICK;
 
     return date;
     AROS_LIBFUNC_EXIT
index a55a976..4233d0d 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(void, Delay,
+        AROS_LH1(void, Delay,
 
 /*  SYNOPSIS */
-       AROS_LHA(ULONG, timeout, D1),
+        AROS_LHA(ULONG, timeout, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 33, Dos)
+        struct DosLibrary *, DOSBase, 33, Dos)
 
 /*  FUNCTION
         Waits for at least the time specified as timeout.
     AROS_LIBFUNC_INIT
 
     struct timerequest  timerio;
-    struct MsgPort     timermp;
+    struct MsgPort      timermp;
 
     memset(&timermp, 0, sizeof(timermp));
     
     timermp.mp_Node.ln_Type = NT_MSGPORT;
-    timermp.mp_Flags       = PA_SIGNAL;
-    timermp.mp_SigBit      = SIGB_SINGLE;
-    timermp.mp_SigTask     = FindTask(NULL);    
+    timermp.mp_Flags        = PA_SIGNAL;
+    timermp.mp_SigBit       = SIGB_SINGLE;
+    timermp.mp_SigTask      = FindTask(NULL);    
     NEWLIST(&timermp.mp_MsgList);
     
     /* clone timerequest in DOSBase */
 
     timerio.tr_node.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
     timerio.tr_node.io_Message.mn_ReplyPort    = &timermp;    
-    timerio.tr_node.io_Command                        = TR_ADDREQUEST;
+    timerio.tr_node.io_Command                 = TR_ADDREQUEST;
     timerio.tr_time.tv_secs                    = timeout / TICKS_PER_SECOND;
-    timerio.tr_time.tv_micro                  = 1000000UL / TICKS_PER_SECOND * (timeout % TICKS_PER_SECOND);
+    timerio.tr_time.tv_micro                   = 1000000UL / TICKS_PER_SECOND * (timeout % TICKS_PER_SECOND);
 
     SetSignal(0, SIGF_SINGLE);
-       
+        
     DoIO(&timerio.tr_node);
     
     AROS_LIBFUNC_EXIT
index eee211f..889a364 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(BOOL, DeleteFile,
+        AROS_LH1(BOOL, DeleteFile,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(CONST_STRPTR, name, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 12, Dos)
+        struct DosLibrary *, DOSBase, 12, Dos)
 
 /*  FUNCTION
-       Tries to delete a file or directory by a given name.
-       May fail if the file is in use or protected from deletion.
+        Tries to delete a file or directory by a given name.
+        May fail if the file is in use or protected from deletion.
 
     INPUTS
-       name       - NUL terminated name.
+        name       - NUL terminated name.
 
     RESULT
-       != 0 if the file is gone, 0 if is still there.
-       IoErr() gives additional information in that case.
+        != 0 if the file is gone, 0 if is still there.
+        IoErr() gives additional information in that case.
 
     NOTES
 
@@ -58,8 +58,8 @@
     D(bug("[DeleteFile] '%s'\n", name));
 
     if (getpacketinfo(DOSBase, name, &phs)) {
-       status = dopacket2(DOSBase, NULL, phs.port, ACTION_DELETE_OBJECT, phs.lock, phs.name);
-       freepacketinfo(DOSBase, &phs);
+        status = dopacket2(DOSBase, NULL, phs.port, ACTION_DELETE_OBJECT, phs.lock, phs.name);
+        freepacketinfo(DOSBase, &phs);
     }
     
     return status;
index 29609cd..f61eaa1 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(struct MsgPort *, DeviceProc,
+        AROS_LH1(struct MsgPort *, DeviceProc,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, name, D1),
+        AROS_LHA(CONST_STRPTR, name, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 29, Dos)
+        struct DosLibrary *, DOSBase, 29, Dos)
 
 /*  FUNCTION
-       DeviceProc() is an obsolete function that returns the
-       MsgPort responsible for a DOS device.
+        DeviceProc() is an obsolete function that returns the
+        MsgPort responsible for a DOS device.
 
-       DeviceProc() will fail if you ask for the MsgPort of a device
-       created with AssignPath() as there is no process to return.
-       If the device requested is an assign, the IoErr() will contain
-       the Lock to the directory (the function will return the device
-       on which the lock is set).
+        DeviceProc() will fail if you ask for the MsgPort of a device
+        created with AssignPath() as there is no process to return.
+        If the device requested is an assign, the IoErr() will contain
+        the Lock to the directory (the function will return the device
+        on which the lock is set).
 
     INPUTS
-       name - The name of the DOS device, INCLUDING the ':'.
+        name - The name of the DOS device, INCLUDING the ':'.
 
     RESULT
-       Either a pointer to the MsgPort, or NULL.
+        Either a pointer to the MsgPort, or NULL.
 
     NOTES
-       You should really use GetDeviceProc(), as that function
-       returns a more useful structure (DevProc), that will
-       persist until FreeDeviceProc() is called on it.
+        You should really use GetDeviceProc(), as that function
+        returns a more useful structure (DevProc), that will
+        persist until FreeDeviceProc() is called on it.
 
     EXAMPLE
 
     BUGS
-       Does not support late- and non-bound assigns, or multiple
-       path assigns very well.
+        Does not support late- and non-bound assigns, or multiple
+        path assigns very well.
 
     SEE ALSO
-       GetDeviceProc(), FreeDeviceProc()
+        GetDeviceProc(), FreeDeviceProc()
 
     INTERNALS
 
      * can't return it as there's no cleanup function, so we have to error */
     if (dvp->dvp_Flags & DVPF_UNLOCK)
     {
-       res = NULL;
-       err = ERROR_DEVICE_NOT_MOUNTED;
+        res = NULL;
+        err = ERROR_DEVICE_NOT_MOUNTED;
     }
     else
     {
         /* all good. get the lock and device */
-       res = dvp->dvp_Port;
-       err = (SIPTR)dvp->dvp_Lock;
+        res = dvp->dvp_Port;
+        err = (SIPTR)dvp->dvp_Lock;
     }
 
     FreeDeviceProc(dvp);
index 56bd85d..c0b9448 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH3(LONG, DisplayError,
+        AROS_LH3(LONG, DisplayError,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, formatStr, A0),
-       AROS_LHA(ULONG       , flags    , D0),
-       AROS_LHA(APTR        , args     , A1),
+        AROS_LHA(CONST_STRPTR, formatStr, A0),
+        AROS_LHA(ULONG       , flags    , D0),
+        AROS_LHA(APTR        , args     , A1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 81, Dos)
+        struct DosLibrary *, DOSBase, 81, Dos)
 
 /*  FUNCTION
-       Displays an error message to and gets response from a user.
+        Displays an error message to and gets response from a user.
 
     INPUTS
-       formatStr   --  printf-style formatted string
-       flags       --  arguments to EasyRequestArgs()
-       args        --  arguments to 'formatStr'
+        formatStr   --  printf-style formatted string
+        flags       --  arguments to EasyRequestArgs()
+        args        --  arguments to 'formatStr'
 
     RESULT
-       Nothing
+        Nothing
 
     NOTES
-       This is a PRIVATE dos function.
+        This is a PRIVATE dos function.
 
     EXAMPLE
 
@@ -52,8 +52,8 @@
     SEE ALSO
 
     INTERNALS
-       The purpose of this function is to put up a requester when an error
-       has occurred that is connected to the filesystem.
+        The purpose of this function is to put up a requester when an error
+        has occurred that is connected to the filesystem.
 
 *****************************************************************************/
 {
 
     struct IntuitionBase *IntuitionBase = NULL;
     struct Process *me = (struct Process *)FindTask(NULL);
-    struct Window *window;     /* The window to put the requester in */
-    char          gadTexts[128];
+    struct Window *window;      /* The window to put the requester in */
+    char           gadTexts[128];
     char          *gtPtr = (char *)gadTexts;
-    ULONG         idcmp = flags;
-    ULONG         res;
+    ULONG          idcmp = flags;
+    ULONG          res;
 
     struct EasyStruct es =
     {
-       sizeof(struct EasyStruct),
-       0,                                  /* flags */
-       DosGetString(MSG_STRING_REQUESTTITLE),  /* "System Requester" */
-       (STRPTR)formatStr,
-       gadTexts                            /* "Retry|Cancel" */
+        sizeof(struct EasyStruct),
+        0,                                  /* flags */
+        DosGetString(MSG_STRING_REQUESTTITLE),  /* "System Requester" */
+        (STRPTR)formatStr,
+        gadTexts                            /* "Retry|Cancel" */
     };
 
     ASSERT_VALID_PROCESS(me);
     /* Supress requesters? */
     if ((IPTR)window == (IPTR)-1L)
     {
-       return 1;
+        return 1;
     }
 
     if (DOSBase->dl_IntuitionBase == NULL)
     {
-       DOSBase->dl_IntuitionBase = OpenLibrary("intuition.library", 37L);
+        DOSBase->dl_IntuitionBase = OpenLibrary("intuition.library", 37L);
     }
 
     if (DOSBase->dl_IntuitionBase == NULL)
     {
-       return 1;
+        return 1;
     }
     else
     {
-       IntuitionBase = (struct IntuitionBase *)DOSBase->dl_IntuitionBase;
+        IntuitionBase = (struct IntuitionBase *)DOSBase->dl_IntuitionBase;
     }
 
     /* Create localised gadget texts */
 
     if (res == 0)
     {
-       return 1;
+        return 1;
     }
     else
     {
-       return 0;
+        return 0;
     }
 
     AROS_LIBFUNC_EXIT
index e95457c..2b99d55 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH7I(SIPTR, DoPkt,
+        AROS_LH7I(SIPTR, DoPkt,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct MsgPort *, port, D1),
-       AROS_LHA(LONG            , action, D2),
-       AROS_LHA(SIPTR           , arg1, D3),
-       AROS_LHA(SIPTR           , arg2, D4),
-       AROS_LHA(SIPTR           , arg3, D5),
-       AROS_LHA(SIPTR           , arg4, D6),
-       AROS_LHA(SIPTR           , arg5, D7),
+        AROS_LHA(struct MsgPort *, port, D1),
+        AROS_LHA(LONG            , action, D2),
+        AROS_LHA(SIPTR           , arg1, D3),
+        AROS_LHA(SIPTR           , arg2, D4),
+        AROS_LHA(SIPTR           , arg3, D5),
+        AROS_LHA(SIPTR           , arg4, D6),
+        AROS_LHA(SIPTR           , arg5, D7),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 40, Dos)
+        struct DosLibrary *, DOSBase, 40, Dos)
 
 /*  FUNCTION
 
@@ -75,36 +75,36 @@ SIPTR dopacket(SIPTR *res2, struct MsgPort *port, LONG action, SIPTR arg1, SIPTR
 
     if (port == NULL)
     {
-       /* NIL: */
-       D(bug("null port\n"));
-       return TRUE;
+        /* NIL: */
+        D(bug("null port\n"));
+        return TRUE;
     }
 
     /* First I create a regular dos packet */
     dp = allocdospacket();
     if (NULL == dp)
-       return FALSE;
+        return FALSE;
 
     if (__is_process(me))
-       replyPort = &me->pr_MsgPort;
+        replyPort = &me->pr_MsgPort;
     else
     {
-       /*
-        * Make sure that tasks can use DoPkt().
-        * This is needed, for example, by Dos/Init()
-        * when creating the initial Shell.
-        */
-       replyPort = CreateMsgPort();
-
-       if (NULL == replyPort)
-       {
-           freedospacket(dp);
-           return FALSE;
-       }
+        /*
+         * Make sure that tasks can use DoPkt().
+         * This is needed, for example, by Dos/Init()
+         * when creating the initial Shell.
+         */
+        replyPort = CreateMsgPort();
+
+        if (NULL == replyPort)
+        {
+            freedospacket(dp);
+            return FALSE;
+        }
     }
     
     D(bug("dp=0x%p act=%d port=0x%p reply=0x%p proc=%d 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx '%s'\n",
-         dp, action, port, replyPort, __is_process(me), arg1, arg2, arg3, arg4, arg5, arg6, arg7, me->pr_Task.tc_Node.ln_Name));
+          dp, action, port, replyPort, __is_process(me), arg1, arg2, arg3, arg4, arg5, arg6, arg7, me->pr_Task.tc_Node.ln_Name));
     dp->dp_Type = action;
     dp->dp_Arg1 = arg1;
     dp->dp_Arg2 = arg2;
@@ -120,18 +120,18 @@ SIPTR dopacket(SIPTR *res2, struct MsgPort *port, LONG action, SIPTR arg1, SIPTR
 
     /* Did we get different packet back? System is in unstable state. */
     if (internal_WaitPkt(replyPort) != dp)
-       Alert(AN_AsyncPkt);
+        Alert(AN_AsyncPkt);
 
     D(bug("res1=%x res2=%x\n", dp->dp_Res1, dp->dp_Res2));
 
     res = dp->dp_Res1;
     if (res2)
-       *res2 = dp->dp_Res2;
+        *res2 = dp->dp_Res2;
 
     if (__is_process(me))
-       me->pr_Result2 = dp->dp_Res2;
+        me->pr_Result2 = dp->dp_Res2;
     else
-       DeleteMsgPort(replyPort);
+        DeleteMsgPort(replyPort);
 
     freedospacket(dp);
     return res;
index a2479e0..0185a60 100644 (file)
@@ -39,7 +39,7 @@ const struct Resident Dos_resident =
     RTC_MATCHWORD,
     (struct Resident *)&Dos_resident,
     (APTR)&LIBEND,
-    0,                 /* We don't autoinit */
+    0,                  /* We don't autoinit */
     VERSION_NUMBER,
     NT_LIBRARY,
     RESIDENTPRI,
@@ -77,45 +77,45 @@ static void init_fs(struct DosLibrary *DOSBase)
         CloseLibrary(PartitionBase);
     }
 
-       /*
-        * Set dl_Root->rn_FileHandlerSegment to the AFS handler,
-        * if it's been loaded. Otherwise, use the first handler
-        * on the FileSystemResource list that has fse_PatchFlags
-        * set to mark it with a valid SegList
-        */
-       if ((fsr = OpenResource("FileSystem.resource")))
-       {
+        /*
+         * Set dl_Root->rn_FileHandlerSegment to the AFS handler,
+         * if it's been loaded. Otherwise, use the first handler
+         * on the FileSystemResource list that has fse_PatchFlags
+         * set to mark it with a valid SegList
+         */
+        if ((fsr = OpenResource("FileSystem.resource")))
+        {
         struct FileSysEntry *fse;
-           BPTR defseg = BNULL;
-           const ULONG DosMagic = 0x444f5301; /* DOS\001 */
-
-           ForeachNode(&fsr->fsr_FileSysEntries, fse)
-           {
-               if ((fse->fse_PatchFlags & FSEF_SEGLIST) && fse->fse_SegList)
-               {
-                   /* We prefer DOS\001 */
+            BPTR defseg = BNULL;
+            const ULONG DosMagic = 0x444f5301; /* DOS\001 */
+
+            ForeachNode(&fsr->fsr_FileSysEntries, fse)
+            {
+                if ((fse->fse_PatchFlags & FSEF_SEGLIST) && fse->fse_SegList)
+                {
+                    /* We prefer DOS\001 */
                 if (fse->fse_DosType == DosMagic)
-                   {
-                       defseg = fse->fse_SegList;
-                       break;
-                   }
-               /* This will remember the first defined seglist */
-                   if (!defseg)
-                       defseg = fse->fse_SegList;
-               }
-           }
+                    {
+                        defseg = fse->fse_SegList;
+                        break;
+                    }
+                /* This will remember the first defined seglist */
+                    if (!defseg)
+                        defseg = fse->fse_SegList;
+                }
+            }
         DOSBase->dl_Root->rn_FileHandlerSegment = defseg;
         /* Add all that have both Handler and SegList defined to the Resident list */
         ForeachNode(&fsr->fsr_FileSysEntries, fse)
         {
-               if ((fse->fse_PatchFlags & FSEF_HANDLER) &&
-                   (fse->fse_PatchFlags & FSEF_SEGLIST) &&
-                   (fse->fse_Handler != BNULL) &&
-                   (fse->fse_SegList != BNULL))
-               {
-                   D(bug("[DosInit] Adding \"%b\" (%p) at %p to the resident list\n",
-                       fse->fse_Handler, BADDR(fse->fse_Handler), BADDR(fse->fse_SegList)));
-                   AddSegment(AROS_BSTR_ADDR(fse->fse_Handler), fse->fse_SegList, CMD_SYSTEM);
+                if ((fse->fse_PatchFlags & FSEF_HANDLER) &&
+                    (fse->fse_PatchFlags & FSEF_SEGLIST) &&
+                    (fse->fse_Handler != BNULL) &&
+                    (fse->fse_SegList != BNULL))
+                {
+                    D(bug("[DosInit] Adding \"%b\" (%p) at %p to the resident list\n",
+                        fse->fse_Handler, BADDR(fse->fse_Handler), BADDR(fse->fse_SegList)));
+                    AddSegment(AROS_BSTR_ADDR(fse->fse_Handler), fse->fse_SegList, CMD_SYSTEM);
             }
         }
     }
@@ -150,113 +150,113 @@ AROS_UFH3S(struct DosLibrary *, DosInit,
 
     if (!DOSBase)
     {
-       IPTR *taskarray;
-       struct DosInfo *dosinfo;
-
-       D(bug("[DosInit] Creating dos.library...\n"));
-
-       DOSBase = (struct DosLibrary *)MakeLibrary(GM_UNIQUENAME(FuncTable), NULL, NULL, sizeof(struct IntDosBase), BNULL);
-       if (!DOSBase)
-           return NULL;
-
-       /* Initialize our header */
-       DOSBase->dl_lib.lib_Node.ln_Name = MOD_NAME_STRING;
-       DOSBase->dl_lib.lib_Node.ln_Type = NT_LIBRARY;
-       DOSBase->dl_lib.lib_Node.ln_Pri  = RESIDENTPRI;
-       DOSBase->dl_lib.lib_Version      = VERSION_NUMBER;
-       DOSBase->dl_lib.lib_Revision     = REVISION_NUMBER;
-       DOSBase->dl_lib.lib_IdString     = (char *)&version[6];
-       DOSBase->dl_lib.lib_Flags        = LIBF_SUMUSED|LIBF_CHANGED;
-
-       /*
-        * These two are allocated together with DOSBase, for reduced fragmentation.
-        * Structure pointed to by dl_Errors is intentionally read-write - who knows...
-        */
-       DOSBase->dl_Root   = &((struct IntDosBase *)DOSBase)->rootNode;
-       DOSBase->dl_Errors = &((struct IntDosBase *)DOSBase)->errors;
-
-       DOSBase->dl_Errors->estr_Nums    = (LONG *)err_Numbers;
-       DOSBase->dl_Errors->estr_Strings = (STRPTR)err_Strings;
-
-       /* Init the RootNode structure */
-       dosinfo = AllocMem(sizeof(struct DosInfo), MEMF_PUBLIC|MEMF_CLEAR);
-       if (!dosinfo)
-       {
-           DosExpunge(DOSBase);
-           return NULL;
-       }
-
-       DOSBase->dl_Root->rn_Info = MKBADDR(dosinfo);
-
-       taskarray = AllocMem(sizeof(IPTR) + sizeof(APTR) * 20, MEMF_CLEAR);
-       if (!taskarray)
-       {
-           DosExpunge(DOSBase);
-           return NULL;
-       }
-
-       taskarray[0] = 20;
-       DOSBase->dl_Root->rn_TaskArray = MKBADDR(taskarray);
-
-       NEWLIST((struct List *)&DOSBase->dl_Root->rn_CliList);
-       InitSemaphore(&DOSBase->dl_Root->rn_RootLock);
-
-       InitSemaphore(&dosinfo->di_DevLock);
-       InitSemaphore(&dosinfo->di_EntryLock);
-       InitSemaphore(&dosinfo->di_DeleteLock);
-
-       /* Initialize for Stricmp */
-       DOSBase->dl_UtilityBase = TaggedOpenLibrary(TAGGEDOPEN_UTILITY);
-       if (!DOSBase->dl_UtilityBase)
-       {
-           DosExpunge(DOSBase);
-           return NULL;
-       }
-
-       /* Initialize for the fools that illegally used this field */
-       DOSBase->dl_IntuitionBase = TaggedOpenLibrary(TAGGEDOPEN_INTUITION);
-
-       /*
-        * iaint:
-        * I know this is bad, but I also know that the timer.device
-        * will never go away during the life of dos.library. I also
-        * don't intend to make any I/O calls using this.
-        *
-        * I also know that timer.device does exist in the device list
-        * at this point in time.
-        *
-        * I can't allocate a timerequest/MsgPort pair here anyway,
-        * because I need a separate one for each caller to Delay().
-        * However, CreateIORequest() will fail if MsgPort == NULL, so we
-        * supply some dummy value.
-        */
-       DOSBase->dl_TimeReq = CreateIORequest((APTR)0xC0DEBAD0, sizeof(struct timerequest));
-       if (!DOSBase->dl_TimeReq)
-       {
-           DosExpunge(DOSBase);
-           return NULL;
-       }
-
-       if (OpenDevice("timer.device", UNIT_VBLANK, &DOSBase->dl_TimeReq->tr_node, 0))
-       {
-           DeleteIORequest(DOSBase->dl_TimeReq);
-           DOSBase->dl_TimeReq = NULL;
-           DosExpunge(DOSBase);
-           return NULL;
-       }
-
-       /* Call platform-specific init code (if any) */
-       if (!set_call_libfuncs(SETNAME(INITLIB), 1, 1, DOSBase))
-       {
-           DosExpunge(DOSBase);
-           return NULL;
-       }
-
-       /* debug.library is optional, so don't check result */
-       DebugBase = OpenLibrary("debug.library", 0);
-
-       /* Initialization finished */
-       AddLibrary(&DOSBase->dl_lib);
+        IPTR *taskarray;
+        struct DosInfo *dosinfo;
+
+        D(bug("[DosInit] Creating dos.library...\n"));
+
+        DOSBase = (struct DosLibrary *)MakeLibrary(GM_UNIQUENAME(FuncTable), NULL, NULL, sizeof(struct IntDosBase), BNULL);
+        if (!DOSBase)
+            return NULL;
+
+        /* Initialize our header */
+        DOSBase->dl_lib.lib_Node.ln_Name = MOD_NAME_STRING;
+        DOSBase->dl_lib.lib_Node.ln_Type = NT_LIBRARY;
+        DOSBase->dl_lib.lib_Node.ln_Pri  = RESIDENTPRI;
+        DOSBase->dl_lib.lib_Version      = VERSION_NUMBER;
+        DOSBase->dl_lib.lib_Revision     = REVISION_NUMBER;
+        DOSBase->dl_lib.lib_IdString     = (char *)&version[6];
+        DOSBase->dl_lib.lib_Flags        = LIBF_SUMUSED|LIBF_CHANGED;
+
+        /*
+         * These two are allocated together with DOSBase, for reduced fragmentation.
+         * Structure pointed to by dl_Errors is intentionally read-write - who knows...
+         */
+        DOSBase->dl_Root   = &((struct IntDosBase *)DOSBase)->rootNode;
+        DOSBase->dl_Errors = &((struct IntDosBase *)DOSBase)->errors;
+
+        DOSBase->dl_Errors->estr_Nums    = (LONG *)err_Numbers;
+        DOSBase->dl_Errors->estr_Strings = (STRPTR)err_Strings;
+
+        /* Init the RootNode structure */
+        dosinfo = AllocMem(sizeof(struct DosInfo), MEMF_PUBLIC|MEMF_CLEAR);
+        if (!dosinfo)
+        {
+            DosExpunge(DOSBase);
+            return NULL;
+        }
+
+        DOSBase->dl_Root->rn_Info = MKBADDR(dosinfo);
+
+        taskarray = AllocMem(sizeof(IPTR) + sizeof(APTR) * 20, MEMF_CLEAR);
+        if (!taskarray)
+        {
+            DosExpunge(DOSBase);
+            return NULL;
+        }
+
+        taskarray[0] = 20;
+        DOSBase->dl_Root->rn_TaskArray = MKBADDR(taskarray);
+
+        NEWLIST((struct List *)&DOSBase->dl_Root->rn_CliList);
+        InitSemaphore(&DOSBase->dl_Root->rn_RootLock);
+
+        InitSemaphore(&dosinfo->di_DevLock);
+        InitSemaphore(&dosinfo->di_EntryLock);
+        InitSemaphore(&dosinfo->di_DeleteLock);
+
+        /* Initialize for Stricmp */
+        DOSBase->dl_UtilityBase = TaggedOpenLibrary(TAGGEDOPEN_UTILITY);
+        if (!DOSBase->dl_UtilityBase)
+        {
+            DosExpunge(DOSBase);
+            return NULL;
+        }
+
+        /* Initialize for the fools that illegally used this field */
+        DOSBase->dl_IntuitionBase = TaggedOpenLibrary(TAGGEDOPEN_INTUITION);
+
+        /*
+         * iaint:
+         * I know this is bad, but I also know that the timer.device
+         * will never go away during the life of dos.library. I also
+         * don't intend to make any I/O calls using this.
+         *
+         * I also know that timer.device does exist in the device list
+         * at this point in time.
+         *
+         * I can't allocate a timerequest/MsgPort pair here anyway,
+         * because I need a separate one for each caller to Delay().
+         * However, CreateIORequest() will fail if MsgPort == NULL, so we
+         * supply some dummy value.
+         */
+        DOSBase->dl_TimeReq = CreateIORequest((APTR)0xC0DEBAD0, sizeof(struct timerequest));
+        if (!DOSBase->dl_TimeReq)
+        {
+            DosExpunge(DOSBase);
+            return NULL;
+        }
+
+        if (OpenDevice("timer.device", UNIT_VBLANK, &DOSBase->dl_TimeReq->tr_node, 0))
+        {
+            DeleteIORequest(DOSBase->dl_TimeReq);
+            DOSBase->dl_TimeReq = NULL;
+            DosExpunge(DOSBase);
+            return NULL;
+        }
+
+        /* Call platform-specific init code (if any) */
+        if (!set_call_libfuncs(SETNAME(INITLIB), 1, 1, DOSBase))
+        {
+            DosExpunge(DOSBase);
+            return NULL;
+        }
+
+        /* debug.library is optional, so don't check result */
+        DebugBase = OpenLibrary("debug.library", 0);
+
+        /* Initialization finished */
+        AddLibrary(&DOSBase->dl_lib);
 
     init_fs(DOSBase);
    }
@@ -264,13 +264,13 @@ AROS_UFH3S(struct DosLibrary *, DosInit,
    /* Try to boot */
    if (CliInit(NULL) == RETURN_OK)
    {
-       /*
-        * We now restart the multitasking - this is done
-        * automatically by RemTask() when it switches.
-        */
-       RemTask(NULL);
+        /*
+         * We now restart the multitasking - this is done
+         * automatically by RemTask() when it switches.
+         */
+        RemTask(NULL);
 
-       /* We really really shouldn't ever get to this line. */
+        /* We really really shouldn't ever get to this line. */
     }
 
     DosExpunge(DOSBase);
@@ -305,19 +305,19 @@ static void DosExpunge(struct DosLibrary *DOSBase)
 
     if (DOSBase->dl_lib.lib_OpenCnt)
     {
-       /*
-        * Someone is holding us... Perhaps some handler started subprocess
-        * which didn't quit. Who knows...
-        */
-       D(bug("[DosInit] Open count is %d, can't expunge\n"));
-       return;
+        /*
+         * Someone is holding us... Perhaps some handler started subprocess
+         * which didn't quit. Who knows...
+         */
+        D(bug("[DosInit] Open count is %d, can't expunge\n"));
+        return;
     }
 
     /* Call platform-specific expunge code (if any) */
     if (!set_call_libfuncs(SETNAME(EXPUNGELIB), -1, 1, DOSBase))
     {
-       D(bug("[DosInit] Platform-dependent code failed to expunge\n"));
-       return;
+        D(bug("[DosInit] Platform-dependent code failed to expunge\n"));
+        return;
     }
 
     /* Close some libraries */
@@ -328,19 +328,19 @@ static void DosExpunge(struct DosLibrary *DOSBase)
     /* Free the timer device */
     if (DOSBase->dl_TimeReq)
     {
-       CloseDevice(&DOSBase->dl_TimeReq->tr_node);
-       DeleteIORequest(DOSBase->dl_TimeReq);
+        CloseDevice(&DOSBase->dl_TimeReq->tr_node);
+        DeleteIORequest(DOSBase->dl_TimeReq);
     }
 
     if (dinfo)
     {
-       /* Remove all segments */
-       for (seg = BADDR(dinfo->di_ResList); seg != NULL; seg = stmp)
-       {
+        /* Remove all segments */
+        for (seg = BADDR(dinfo->di_ResList); seg != NULL; seg = stmp)
+        {
             stmp = BADDR(seg->seg_Next);
             FreeVec(seg);
-       }
-       FreeMem(dinfo, sizeof(*dinfo));
+        }
+        FreeMem(dinfo, sizeof(*dinfo));
     }
 
     /* Free memory */
@@ -348,11 +348,11 @@ static void DosExpunge(struct DosLibrary *DOSBase)
 
     if (DOSBase->dl_lib.lib_Node.ln_Succ)
     {
-       /*
-        * A fresh DOSBase after creation is filled with NULLs.
-        * ln_Succ will be set to something only after AddLibrary().
-        */
-       Remove(&DOSBase->dl_lib.lib_Node);
+        /*
+         * A fresh DOSBase after creation is filled with NULLs.
+         * ln_Succ will be set to something only after AddLibrary().
+         */
+        Remove(&DOSBase->dl_lib.lib_Node);
     }
 
     FreeMem((char *)DOSBase - DOSBase->dl_lib.lib_NegSize, DOSBase->dl_lib.lib_NegSize + DOSBase->dl_lib.lib_PosSize);
index 4c56fa9..9bd280c 100644 (file)
@@ -103,10 +103,10 @@ void internal_ReplyPkt(struct DosPacket *dp, struct MsgPort *replyPort, SIPTR re
 
 #define dopacket5(base, res2, port, action, arg1, arg2, arg3, arg4, arg5) dopacket(res2, port, action, (SIPTR)(arg1), (SIPTR)(arg2), (SIPTR)(arg3), (SIPTR)(arg4), (SIPTR)(arg5), 0, 0)
 #define dopacket4(base, res2, port, action, arg1, arg2, arg3, arg4)       dopacket(res2, port, action, (SIPTR)(arg1), (SIPTR)(arg2), (SIPTR)(arg3), (SIPTR)(arg4), 0, 0, 0)
-#define dopacket3(base, res2, port, action, arg1, arg2, arg3)            dopacket(res2, port, action, (SIPTR)(arg1), (SIPTR)(arg2), (SIPTR)(arg3), 0, 0, 0, 0)
-#define dopacket2(base, res2, port, action, arg1, arg2)                          dopacket(res2, port, action, (SIPTR)(arg1), (SIPTR)(arg2), 0, 0, 0, 0, 0)
-#define dopacket1(base, res2, port, action, arg1)                        dopacket(res2, port, action, (SIPTR)(arg1), 0, 0, 0, 0, 0, 0)
-#define dopacket0(base, res2, port, action)                              dopacket(res2, port, action, 0, 0, 0, 0, 0, 0, 0)
+#define dopacket3(base, res2, port, action, arg1, arg2, arg3)             dopacket(res2, port, action, (SIPTR)(arg1), (SIPTR)(arg2), (SIPTR)(arg3), 0, 0, 0, 0)
+#define dopacket2(base, res2, port, action, arg1, arg2)                   dopacket(res2, port, action, (SIPTR)(arg1), (SIPTR)(arg2), 0, 0, 0, 0, 0)
+#define dopacket1(base, res2, port, action, arg1)                         dopacket(res2, port, action, (SIPTR)(arg1), 0, 0, 0, 0, 0, 0)
+#define dopacket0(base, res2, port, action)                               dopacket(res2, port, action, 0, 0, 0, 0, 0, 0, 0)
 
 #ifdef __mc68000
 extern void BCPL_Fixup(struct Process *me);
@@ -132,7 +132,7 @@ BPTR internal_CopyPath(BPTR boldpath, struct DosLibrary * DOSBase);
 
 /* Pattern matching function used by MatchPattern() and MatchPatternNoCase() */
 BOOL patternMatch(CONST_STRPTR pat, CONST_STRPTR str, BOOL useCase,
-                 struct DosLibrary *DOSBase);
+                  struct DosLibrary *DOSBase);
 
 /* Pattern parsing function used by ParsePattern() and ParsePatternNoCase() */
 LONG patternParse(CONST_STRPTR Source, STRPTR Dest, LONG DestLength,
@@ -154,7 +154,7 @@ LONG InternalFlush( struct FileHandle *fh, struct DosLibrary *DOSBase );
 struct AChain *Match_AllocAChain(LONG extrasize, struct DosLibrary *DOSBase);
 void Match_FreeAChain(struct AChain *ac, struct DosLibrary *DOSBase);
 LONG Match_BuildAChainList(CONST_STRPTR pattern, struct AnchorPath *ap,
-                          struct AChain **retac, struct DosLibrary *DOSBase);
+                           struct AChain **retac, struct DosLibrary *DOSBase);
 LONG Match_MakeResult(struct AnchorPath *ap, struct DosLibrary *DOSBase);
 
 void addprocesstoroot(struct Process * , struct DosLibrary *);
@@ -175,60 +175,60 @@ struct markerarray
 };
 
 #define PUSH(t,p,s)                                                     \
-{                                                                      \
+{                                                                       \
     if(macnt==128)                                                      \
-    {                                                                  \
-       if(macur->next==NULL)                                           \
-       {                                                               \
-           macur->next=AllocMem(sizeof(struct markerarray),MEMF_ANY);  \
-           if(macur->next==NULL)                                       \
-               ERROR(ERROR_NO_FREE_STORE);                             \
-           macur->next->prev=macur;                                    \
-       }                                                               \
-       macur=macur->next;                                              \
-       macnt=0;                                                        \
-    }                                                                  \
+    {                                                                   \
+        if(macur->next==NULL)                                           \
+        {                                                               \
+            macur->next=AllocMem(sizeof(struct markerarray),MEMF_ANY);  \
+            if(macur->next==NULL)                                       \
+                ERROR(ERROR_NO_FREE_STORE);                             \
+            macur->next->prev=macur;                                    \
+        }                                                               \
+        macur=macur->next;                                              \
+        macnt=0;                                                        \
+    }                                                                   \
     macur->marker[macnt].type=(t);                                      \
     macur->marker[macnt].pat=(p);                                       \
     macur->marker[macnt].str=(s);                                       \
-    macnt++;                                                           \
+    macnt++;                                                            \
 }
 
 #define POP(t,p,s)                      \
-{                                      \
-    macnt--;                           \
+{                                       \
+    macnt--;                            \
     if(macnt<0)                         \
-    {                                  \
-       macnt=127;                      \
-       macur=macur->prev;              \
-       if(macur==NULL)                 \
-           ERROR(0);                   \
-    }                                  \
+    {                                   \
+        macnt=127;                      \
+        macur=macur->prev;              \
+        if(macur==NULL)                 \
+            ERROR(0);                   \
+    }                                   \
     (t)=macur->marker[macnt].type;      \
     (p)=macur->marker[macnt].pat;       \
     (s)=macur->marker[macnt].str;       \
 }
 
-#define MP_ESCAPE              0x81 /* Before characters in [0x81;0x8a] */
-#define MP_MULT                0x82 /* _#(_a) */
-#define MP_MULT_END            0x83 /* #(a_)_ */
-#define MP_NOT                 0x84 /* _~(_a) */
-#define MP_NOT_END             0x85 /* ~(a_)_ */
-#define MP_OR                  0x86 /* _(_a|b) */
-#define MP_OR_NEXT             0x87 /* (a_|_b) */
-#define MP_OR_END              0x88 /* (a|b_)_ */
-#define MP_SINGLE              0x89 /* ? */
-#define MP_ALL                 0x8a /* #? or * */
-#define MP_SET                 0x8b /* _[_ad-g] */
-#define MP_NOT_SET             0x8c /* _[~_ad-g] */
-#define MP_DASH                0x8d /* [ad_-g_] */
-#define MP_SET_END             0x8e /* [ad-g_]_ */
+#define MP_ESCAPE               0x81 /* Before characters in [0x81;0x8a] */
+#define MP_MULT                 0x82 /* _#(_a) */
+#define MP_MULT_END             0x83 /* #(a_)_ */
+#define MP_NOT                  0x84 /* _~(_a) */
+#define MP_NOT_END              0x85 /* ~(a_)_ */
+#define MP_OR                   0x86 /* _(_a|b) */
+#define MP_OR_NEXT              0x87 /* (a_|_b) */
+#define MP_OR_END               0x88 /* (a|b_)_ */
+#define MP_SINGLE               0x89 /* ? */
+#define MP_ALL                  0x8a /* #? or * */
+#define MP_SET                  0x8b /* _[_ad-g] */
+#define MP_NOT_SET              0x8c /* _[~_ad-g] */
+#define MP_DASH                 0x8d /* [ad_-g_] */
+#define MP_SET_END              0x8e /* [ad-g_]_ */
 
 /* Whether MatchFirst/MatchNext/MatchEnd in case of the base
    AChain should just take the currentdir lock pointer, or
    make a real duplicate with DupLock() */
 
-#define MATCHFUNCS_NO_DUPLOCK  0
+#define MATCHFUNCS_NO_DUPLOCK   0
 
 #define  __is_task(task)  (((struct Task *)task)->tc_Node.ln_Type == NT_TASK)
 #define  __is_process(task)  (((struct Task *)task)->tc_Node.ln_Type == NT_PROCESS)
@@ -245,7 +245,7 @@ struct debug_segnode
     struct MinNode node;
     UBYTE          name[200];
     BPTR           seglist;
-    IPTR          start_address; // start address of loaded executable segment
+    IPTR           start_address; // start address of loaded executable segment
     struct MinList seginfos;
 };
 
@@ -271,7 +271,7 @@ LONG FWriteChars(BPTR file, CONST UBYTE* buffer, ULONG length, struct DosLibrary
 
 #define CMPBSTR(x, y)       Stricmp(BADDR(x), BADDR(y))
 #define CMPNICBSTR(x, y, n) Strnicmp(x, BADDR(y), n)
-#define BSTR2C(s)          ((STRPTR)BADDR(s))
+#define BSTR2C(s)           ((STRPTR)BADDR(s))
 #define FreeCSTR(s)
 
 #else
@@ -285,10 +285,10 @@ char *BSTR2C(BSTR);
 #endif
 
 #ifdef AROS_FAST_BSTR
-#define C2BSTR(x)      ((char *)(x))
-#define FREEC2BSTR(x)  do { } while (0)
-#define CMPCBSTR(a,b)  strcmp(a,b)
-#define CMPICBSTR(a,b) Stricmp(a,b)
+#define C2BSTR(x)       ((char *)(x))
+#define FREEC2BSTR(x)   do { } while (0)
+#define CMPCBSTR(a,b)   strcmp(a,b)
+#define CMPICBSTR(a,b)  Stricmp(a,b)
 #else
 BSTR C2BSTR(CONST_STRPTR);
 #define FREEC2BSTR(bstr) FreeVec(BADDR(bstr))
@@ -300,10 +300,10 @@ void fixfib(struct FileInfoBlock*);
 
 struct PacketHelperStruct
 {
-       BSTR name;
-       struct MsgPort *port;
-       BPTR lock;
-       struct DevProc *dp;
+        BSTR name;
+        struct MsgPort *port;
+        BPTR lock;
+        struct DevProc *dp;
 };
 
 BOOL getpacketinfo(struct DosLibrary *DOSBase, CONST_STRPTR, struct PacketHelperStruct*);
@@ -311,10 +311,10 @@ BOOL getdevpacketinfo(struct DosLibrary *DOSBase, CONST_STRPTR devname, CONST_ST
 void freepacketinfo(struct DosLibrary *DOSBase, struct PacketHelperStruct*);
 
 #define ASSERT_VALID_FILELOCK(lock) do { \
-       struct FileLock *fl = BADDR(lock); \
-       if (fl && fl->fl_Access != SHARED_LOCK && fl->fl_Access != EXCLUSIVE_LOCK) { \
-           bug("%s() called with a bogus FileLock! Lock=%x FL=%x Access %d %s/%s/%d\n", __FUNCTION__, lock, fl, fl->fl_Access, __FILE__,__FUNCTION__,__LINE__); \
-       } \
+        struct FileLock *fl = BADDR(lock); \
+        if (fl && fl->fl_Access != SHARED_LOCK && fl->fl_Access != EXCLUSIVE_LOCK) { \
+            bug("%s() called with a bogus FileLock! Lock=%x FL=%x Access %d %s/%s/%d\n", __FUNCTION__, lock, fl, fl->fl_Access, __FILE__,__FUNCTION__,__LINE__); \
+        } \
     } while (0);
 
 /* Shell utilities */
index bef8ce1..9d13c28 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(STRPTR, DosGetString,
+        AROS_LH1(STRPTR, DosGetString,
 
 /*  SYNOPSIS */
-       AROS_LHA(LONG, stringNum, D1),
+        AROS_LHA(LONG, stringNum, D1),
 
 /* LOCATION */
-       struct DosLibrary *, DOSBase, 163, Dos)
+        struct DosLibrary *, DOSBase, 163, Dos)
 
 /*  FUNCTION
-       Internal DOS function, will return the string corresponding to
-       the number stringNum. 
+        Internal DOS function, will return the string corresponding to
+        the number stringNum. 
 
     INPUTS
-       stringNum   -   The number of the string you want.
+        stringNum   -   The number of the string you want.
 
     RESULT
-       A pointer to a string, or NULL if no string could be found with
-       a matching number.
+        A pointer to a string, or NULL if no string could be found with
+        a matching number.
 
     NOTES
-       Error strings will ALWAYS be less than 80 characters, and should
-       ideally be less than 60 characters.
+        Error strings will ALWAYS be less than 80 characters, and should
+        ideally be less than 60 characters.
 
-       This is a private function, whose the only purpose is to be patched
-       by locale.library.
+        This is a private function, whose the only purpose is to be patched
+        by locale.library.
 
     EXAMPLE
 
@@ -46,7 +46,7 @@
     SEE ALSO
 
     INTERNALS
-       This is dosPrivate5()
+        This is dosPrivate5()
 
 ******************************************************************************/
 {
 
     do
     {
-       LONG n = p[0];
-       LONG m = p[1];
+        LONG n = p[0];
+        LONG m = p[1];
 
-       while (n <= m)
-       {
-           if (n == stringNum)
-               return q + 1;
+        while (n <= m)
+        {
+            if (n == stringNum)
+                return q + 1;
 
-           q += q[0] + 1;
-           ++n;
-       }
+            q += q[0] + 1;
+            ++n;
+        }
 
-       p += 2;
+        p += 2;
     }
     while (p[0] != 0);
 
index 6ed9525..576c36c 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(BPTR, DupLock,
+        AROS_LH1(BPTR, DupLock,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR, lock, D1),
+        AROS_LHA(BPTR, lock, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 16, Dos)
+        struct DosLibrary *, DOSBase, 16, Dos)
 
 /*  FUNCTION
-       Clone a lock on a file or directory. This will only work on shared
-       locks.
+        Clone a lock on a file or directory. This will only work on shared
+        locks.
 
     INPUTS
-       lock - Old lock.
+        lock - Old lock.
 
     RESULT
-       The new lock or NULL in case of an error. IoErr() will give additional
-       information in that case.
+        The new lock or NULL in case of an error. IoErr() will give additional
+        information in that case.
 
     NOTES
 
@@ -52,7 +52,7 @@
     BPTR ret;
 
     if (lock == BNULL)
-       return BNULL;
+        return BNULL;
     ret = (BPTR)dopacket1(DOSBase, NULL, fl->fl_Task, ACTION_COPY_DIR, lock);
     D(bug("[DupLock] %x -> %x\n", fl, BADDR(ret)));
     return ret;
index e68abe8..544d4db 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(BPTR, DupLockFromFH,
+        AROS_LH1(BPTR, DupLockFromFH,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR, handle, D1),
+        AROS_LHA(BPTR, handle, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 62, Dos)
+        struct DosLibrary *, DOSBase, 62, Dos)
 
 /*  FUNCTION
-       Clone a lock on a file or directory. This will only work on shared
-       locks.
+        Clone a lock on a file or directory. This will only work on shared
+        locks.
 
     INPUTS
-       lock - Old lock.
+        lock - Old lock.
 
     RESULT
-       The new lock or NULL in case of an error. IoErr() will give additional
-       information in that case.
+        The new lock or NULL in case of an error. IoErr() will give additional
+        information in that case.
 
     NOTES
 
index ac5a46e..057b313 100644 (file)
 
 #include <string.h>
 
-       AROS_LH1(void, EndNotify,
+        AROS_LH1(void, EndNotify,
 
 /*  SYNOPSIS */
-       AROS_LHA(struct NotifyRequest *, notify, D1),
+        AROS_LHA(struct NotifyRequest *, notify, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 149, Dos)
+        struct DosLibrary *, DOSBase, 149, Dos)
 
 /*  FUNCTION
 
 
     /* if the filesystem has outstanding messages, they need to be replied */
     if ((notify->nr_Flags & NRF_SEND_MESSAGE) &&
-       ((notify->nr_Flags & NRF_WAIT_REPLY) || notify->nr_MsgCount > 0))
+        ((notify->nr_Flags & NRF_WAIT_REPLY) || notify->nr_MsgCount > 0))
     {
-       struct MsgPort *port = notify->nr_stuff.nr_Msg.nr_Port;
-       struct NotifyMessage *nm, *tmp;
+        struct MsgPort *port = notify->nr_stuff.nr_Msg.nr_Port;
+        struct NotifyMessage *nm, *tmp;
 
-       notify->nr_Flags &= ~NRF_MAGIC;
+        notify->nr_Flags &= ~NRF_MAGIC;
 
         /* protect access to the message list */
-       Disable();
+        Disable();
 
         /* loop over the messages */
-       ForeachNodeSafe(&port->mp_MsgList, nm, tmp) {
+        ForeachNodeSafe(&port->mp_MsgList, nm, tmp) {
             /* if its one of our notify messages */
-           if (nm->nm_Class == NOTIFY_CLASS &&
-               nm->nm_Code == NOTIFY_CODE &&
-               nm->nm_NReq == notify) {
+            if (nm->nm_Class == NOTIFY_CLASS &&
+                nm->nm_Code == NOTIFY_CODE &&
+                nm->nm_NReq == notify) {
 
                 /* remove and reply */
-               Remove((struct Node *) nm);
-               ReplyMsg((struct Message *) nm);
+                Remove((struct Node *) nm);
+                ReplyMsg((struct Message *) nm);
 
                 /* decrement the count. bail early if we've done them all */
                 notify->nr_MsgCount--;
                 if (notify->nr_MsgCount == 0)
                     break;
-           }
-       }
+            }
+        }
 
         /* unlock the list */
-       Enable();
+        Enable();
     }
 
     AROS_LIBFUNC_EXIT
index 47bff1c..1d2d71e 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH4(BOOL, ErrorReport,
+        AROS_LH4(BOOL, ErrorReport,
 
 /*  SYNOPSIS */
-       AROS_LHA(LONG            , code  , D1),
-       AROS_LHA(LONG            , type  , D2),
-       AROS_LHA(IPTR            , arg1  , D3),
-       AROS_LHA(struct MsgPort *, device, D4),
+        AROS_LHA(LONG            , code  , D1),
+        AROS_LHA(LONG            , type  , D2),
+        AROS_LHA(IPTR            , arg1  , D3),
+        AROS_LHA(struct MsgPort *, device, D4),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 80, Dos)
+        struct DosLibrary *, DOSBase, 80, Dos)
 
 /*  FUNCTION
     Displays a requester with Retry/Cancel buttons for an error.
     IoErr() is set to "code".
-       
+        
     INPUTS
 
     code    --  The error to put up the requester for
@@ -44,8 +44,8 @@
 
                 REPORT_LOCK    --  arg1 is a lock (BPTR).
                 REPORT_FH      --  arg1 is a filehandle (BPTR).
-               REPORT_VOLUME  --  arg1 is a volumenode (C pointer).
-               REPORT_INSERT  --  arg1 is the string for the volumename
+                REPORT_VOLUME  --  arg1 is a volumenode (C pointer).
+                REPORT_INSERT  --  arg1 is the string for the volumename
 
     arg1    --  Argument according to type (see above)
     device  --  Optional handler task address (obsolete!)
@@ -53,7 +53,7 @@
     RESULT
     DOSFALSE - user has selected "Retry"
     DOSTRUE  - user has selected "Cancel" or code wasn't understood or
-              pr_WindowPtr is -1 or if an attempt to open the requester fails.
+               pr_WindowPtr is -1 or if an attempt to open the requester fails.
 
     NOTES
 
             msgport = ((struct FileHandle *) BADDR(arg1))->fh_Type;
             dl = (struct DeviceList*)BADDR(dopacket1(DOSBase, NULL, msgport, ACTION_CURRENT_VOLUME, ((struct FileHandle *) BADDR(arg1))->fh_Arg1));
             if (dl)
-               volname = (char*)BADDR(dl->dl_Name) + 1;
+                volname = (char*)BADDR(dl->dl_Name) + 1;
             break;
             
         case REPORT_TASK:
         {
             struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, 0);
             if (!fib)
-               return DOSTRUE;
+                return DOSTRUE;
             /* if they provided a lock, just use it */
             if (arg1 != (IPTR)NULL) {
-               msgport = ((struct FileLock *) BADDR(arg1))->fl_Task;
+                msgport = ((struct FileLock *) BADDR(arg1))->fl_Task;
             } else {
-               msgport = device;
+                msgport = device;
             }
             if (dopacket2(DOSBase, NULL, msgport, ACTION_EXAMINE_OBJECT, arg1, (SIPTR)MKBADDR(fib))) {
-               fixfib(fib);
-               strncpy(buf, fib->fib_FileName, sizeof (buf) - 1);
-               buf[sizeof(buf) - 1] = 0;
+                fixfib(fib);
+                strncpy(buf, fib->fib_FileName, sizeof (buf) - 1);
+                buf[sizeof(buf) - 1] = 0;
             }
             FreeDosObject(DOS_FIB, fib);
             if (buf[0] == 0)
-               return DOSTRUE;
+                return DOSTRUE;
             volname = buf;
         }
         break;
             if (arg1 == (IPTR)NULL)
                 return DOSTRUE;
             if (!getpacketinfo(DOSBase, (STRPTR)arg1, &phs))
-               return DOSTRUE;
+                return DOSTRUE;
             msgport = phs.port;
             volname = (STRPTR) arg1;
             /* rip off any trailing stuff, if its there */
index d6e0f52..bfef36d 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH5(BOOL, ExAll,
+        AROS_LH5(BOOL, ExAll,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR,                  lock,    D1),
-       AROS_LHA(struct ExAllData *,    buffer,  D2),
-       AROS_LHA(LONG,                  size,    D3),
-       AROS_LHA(LONG,                  data,    D4),
-       AROS_LHA(struct ExAllControl *, control, D5),
+        AROS_LHA(BPTR,                  lock,    D1),
+        AROS_LHA(struct ExAllData *,    buffer,  D2),
+        AROS_LHA(LONG,                  size,    D3),
+        AROS_LHA(LONG,                  data,    D4),
+        AROS_LHA(struct ExAllControl *, control, D5),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 72, Dos)
+        struct DosLibrary *, DOSBase, 72, Dos)
 
 /*  FUNCTION
 
@@ -39,7 +39,7 @@
     lock     --  lock on the directory to be examined
     buffer   --  buffer for the data that is returned (must be aligned)
                  which is filled with (partial) ExAllData structures
-                (see NOTES)
+                 (see NOTES)
     size     --  size of 'buffer' in bytes
     data     --  type of the data to be returned
     control  --  a control structure allocated by AllocDosObject()
     eac_MatchString : if NULL then information on all files will be returned.
                       If non-NULL it's interpreted as a pointer to a string
                       used for pattern matching which files to return
-                     information on. This string must have been parsed by
-                     ParsePatternNoCase()!
+                      information on. This string must have been parsed by
+                      ParsePatternNoCase()!
 
     eac_MatchFunc : pointer to a hook that will be called to decide if an
                     entry should be included in the buffer. If NULL, no
-                   matching function will be called. The hook is called as
-                   follows
+                    matching function will be called. The hook is called as
+                    follows
 
-                       BOOL = MatchFunc(hook, data, typeptr)
+                        BOOL = MatchFunc(hook, data, typeptr)
 
     EXAMPLE
 
        handler.  */
     if (((struct InternalExAllControl *)control)->fib != NULL)
     {
-       err = ERROR_ACTION_NOT_KNOWN;
+        err = ERROR_ACTION_NOT_KNOWN;
     }
     else
     {
-       status = dopacket5(DOSBase, &err, fl->fl_Task, ACTION_EXAMINE_ALL, (SIPTR)lock, (IPTR)buffer, (IPTR)size, (IPTR)data, (IPTR)control);
-       if (status != DOSFALSE)
-           err = RETURN_OK;
+        status = dopacket5(DOSBase, &err, fl->fl_Task, ACTION_EXAMINE_ALL, (SIPTR)lock, (IPTR)buffer, (IPTR)size, (IPTR)data, (IPTR)control);
+        if (status != DOSFALSE)
+            err = RETURN_OK;
     }
     
     if
     (
         err == ERROR_NOT_IMPLEMENTED ||
-       err == ERROR_ACTION_NOT_KNOWN
+        err == ERROR_ACTION_NOT_KNOWN
     )
     {
-       /* Try to emulate it */
-       STRPTR end  = (STRPTR)buffer + size;
-       STRPTR next;
-
-       struct ExAllData *last = buffer, *curr = buffer;
-       
-       struct InternalExAllControl *icontrol = (struct InternalExAllControl *)control;
-
-       static const ULONG sizes[]=
-       {
-           0,
-           offsetof(struct ExAllData,ed_Type),
-           offsetof(struct ExAllData,ed_Size),
-           offsetof(struct ExAllData,ed_Prot),
-           offsetof(struct ExAllData,ed_Days),
-           offsetof(struct ExAllData,ed_Comment),
-           offsetof(struct ExAllData,ed_OwnerUID),
-           sizeof(struct ExAllData)
-       };
-
-       /* Reset the 'fake' error */
-       err = 0;
-       
-       /* Allocate the FIB structure, if not allocated yet. It will be deallocated
-          by DeleteDosObject().  */
-       if (!icontrol->fib)
-       {
-           icontrol->fib = AllocDosObject(DOS_FIB, NULL);
-           if (!icontrol->fib)
-           {
-               err = IoErr();
-               goto end;
-           }
-       }
+        /* Try to emulate it */
+        STRPTR end  = (STRPTR)buffer + size;
+        STRPTR next;
+
+        struct ExAllData *last = buffer, *curr = buffer;
+        
+        struct InternalExAllControl *icontrol = (struct InternalExAllControl *)control;
+
+        static const ULONG sizes[]=
+        {
+            0,
+            offsetof(struct ExAllData,ed_Type),
+            offsetof(struct ExAllData,ed_Size),
+            offsetof(struct ExAllData,ed_Prot),
+            offsetof(struct ExAllData,ed_Days),
+            offsetof(struct ExAllData,ed_Comment),
+            offsetof(struct ExAllData,ed_OwnerUID),
+            sizeof(struct ExAllData)
+        };
+
+        /* Reset the 'fake' error */
+        err = 0;
+        
+        /* Allocate the FIB structure, if not allocated yet. It will be deallocated
+           by DeleteDosObject().  */
+        if (!icontrol->fib)
+        {
+            icontrol->fib = AllocDosObject(DOS_FIB, NULL);
+            if (!icontrol->fib)
+            {
+                err = IoErr();
+                goto end;
+            }
+        }
 
         /* No entries found as of now yet.  */
         control->eac_Entries = 0;
-       
-       /* If LastKey == 0 it means this is the first time we're getting called,
-          in which case we need to initialize the FIB structure and a few other things. 
-          A "nice" side effect of this, is that if one wants to restart the scanning, 
-          he/she just has to set LastKey to 0.  */
-       if (control->eac_LastKey == 0)
-       {    
-           if (!Examine(lock, icontrol->fib))
-           {
-               err = IoErr();
-               goto end;
-           }
-           if (icontrol->fib->fib_DirEntryType <= 0)
-           {
-                       err = ERROR_OBJECT_WRONG_TYPE;
-               goto end;
-           }
-       }
-       
-       /* Macro used when the data doesn't fit in the provided buffer.
-          In case not even one element fit in the buffer, return a buffer
-          overflow error, so that the user knows he/she has to increase the
-          buffer.  */
-       #define ReturnOverflow()                               \
-       do {                                                   \
-           if (last == curr)                                  \
-               err = ERROR_BUFFER_OVERFLOW;                   \
-                                                              \
-           icontrol->fib->fib_DiskKey = control->eac_LastKey; \
-           goto end;                                          \
-       } while (0)
-
-       /* Copy a string pointer by _source into the buffer provided
-          to the ExAll function. This macro gracefully handles buffer
-          overflows.  */
-       #define CopyStringSafe(_source)     \
-       do {                                \
-           STRPTR source = _source;        \
-                                           \
-           for (;;)                        \
-           {                               \
-               if (next >= end)            \
-                   ReturnOverflow();       \
-               if (!(*next++ = *source++)) \
-                  break;                   \
-               }                           \
-           } while (0)
-
-           
-       if (data > ED_OWNER)
-           /* We don't have that many fields to fill in... */
-           err = ERROR_BAD_NUMBER;
-       else
-       {
-           for
-           (   ;
-               ExNext(lock, icontrol->fib); 
-               /* Record the latest DiskKey into LastKey so that we can roll back to it
-                  in case of a buffer overflow and when getting called again.  */         
-               control->eac_LastKey = icontrol->fib->fib_DiskKey
-           )
-           {    
-               /* Try to match the filename, if required.  */
-               if (control->eac_MatchString &&
-                   !MatchPatternNoCase(control->eac_MatchString,
-                                       icontrol->fib->fib_FileName))
-                   continue;
-
-               next = (STRPTR)curr + sizes[data];
-
-               /* Oops, the buffer is full.  */
-               if (next > end)
-                   ReturnOverflow();
-
-               /* Switch over the requested fields and fill them as appropriate.  */
-               switch(data)
-               {
-                   case ED_OWNER:
-                       curr->ed_OwnerUID = icontrol->fib->fib_OwnerUID;
-                       curr->ed_OwnerGID = icontrol->fib->fib_OwnerGID;
-
-                       /* Fall through */
-                   case ED_COMMENT:
-                       curr->ed_Comment = next;
-                       CopyStringSafe(icontrol->fib->fib_Comment);
-
-                       /* Fall through */
-                   case ED_DATE:
-                       curr->ed_Days  = icontrol->fib->fib_Date.ds_Days;
-                       curr->ed_Mins  = icontrol->fib->fib_Date.ds_Minute;
-                       curr->ed_Ticks = icontrol->fib->fib_Date.ds_Tick;
-
-                       /* Fall through */
-                   case ED_PROTECTION:
-                       curr->ed_Prot = icontrol->fib->fib_Protection;
-
-                       /* Fall through */
-                   case ED_SIZE:
-                       curr->ed_Size = icontrol->fib->fib_Size;
-
-                       /* Fall through */
-                   case ED_TYPE:
-                       curr->ed_Type = icontrol->fib->fib_DirEntryType;
-
-                       /* Fall through */
-                   case ED_NAME:
-                       curr->ed_Name = next;
-                       CopyStringSafe(icontrol->fib->fib_FileName);
-
-                       /* Fall through */
-                   case 0:
-                       curr->ed_Next = (struct ExAllData *)(((IPTR)next + AROS_PTRALIGN - 1) & ~(AROS_PTRALIGN - 1));
-               }
-                   
-               /* Do some more matching... */
-               if (control->eac_MatchFunc && !CALLHOOKPKT(control->eac_MatchFunc, curr, &data))
-                   continue;
-                   
-               /* Finally go to the next entry in the buffer.  */
-               last = curr;
-               curr = curr->ed_Next;
-               control->eac_Entries++;
-           }
-           err = IoErr();
-       }
+        
+        /* If LastKey == 0 it means this is the first time we're getting called,
+           in which case we need to initialize the FIB structure and a few other things. 
+           A "nice" side effect of this, is that if one wants to restart the scanning, 
+           he/she just has to set LastKey to 0.  */
+        if (control->eac_LastKey == 0)
+        {    
+            if (!Examine(lock, icontrol->fib))
+            {
+                err = IoErr();
+                goto end;
+            }
+            if (icontrol->fib->fib_DirEntryType <= 0)
+            {
+                err = ERROR_OBJECT_WRONG_TYPE;
+                goto end;
+            }
+        }
+        
+        /* Macro used when the data doesn't fit in the provided buffer.
+           In case not even one element fit in the buffer, return a buffer
+           overflow error, so that the user knows he/she has to increase the
+           buffer.  */
+        #define ReturnOverflow()                               \
+        do {                                                   \
+            if (last == curr)                                  \
+                err = ERROR_BUFFER_OVERFLOW;                   \
+                                                               \
+            icontrol->fib->fib_DiskKey = control->eac_LastKey; \
+            goto end;                                          \
+        } while (0)
+
+        /* Copy a string pointer by _source into the buffer provided
+           to the ExAll function. This macro gracefully handles buffer
+           overflows.  */
+        #define CopyStringSafe(_source)     \
+        do {                                \
+            STRPTR source = _source;        \
+                                            \
+            for (;;)                        \
+            {                               \
+                if (next >= end)            \
+                    ReturnOverflow();       \
+                if (!(*next++ = *source++)) \
+                   break;                   \
+                }                           \
+            } while (0)
+
+            
+        if (data > ED_OWNER)
+            /* We don't have that many fields to fill in... */
+            err = ERROR_BAD_NUMBER;
+        else
+        {
+            for
+            (   ;
+                ExNext(lock, icontrol->fib); 
+                /* Record the latest DiskKey into LastKey so that we can roll back to it
+                   in case of a buffer overflow and when getting called again.  */         
+                control->eac_LastKey = icontrol->fib->fib_DiskKey
+            )
+            {    
+                /* Try to match the filename, if required.  */
+                if (control->eac_MatchString &&
+                    !MatchPatternNoCase(control->eac_MatchString,
+                                        icontrol->fib->fib_FileName))
+                    continue;
+
+                next = (STRPTR)curr + sizes[data];
+
+                /* Oops, the buffer is full.  */
+                if (next > end)
+                    ReturnOverflow();
+
+                /* Switch over the requested fields and fill them as appropriate.  */
+                switch(data)
+                {
+                    case ED_OWNER:
+                        curr->ed_OwnerUID = icontrol->fib->fib_OwnerUID;
+                        curr->ed_OwnerGID = icontrol->fib->fib_OwnerGID;
+
+                        /* Fall through */
+                    case ED_COMMENT:
+                        curr->ed_Comment = next;
+                        CopyStringSafe(icontrol->fib->fib_Comment);
+
+                        /* Fall through */
+                    case ED_DATE:
+                        curr->ed_Days  = icontrol->fib->fib_Date.ds_Days;
+                        curr->ed_Mins  = icontrol->fib->fib_Date.ds_Minute;
+                        curr->ed_Ticks = icontrol->fib->fib_Date.ds_Tick;
+
+                        /* Fall through */
+                    case ED_PROTECTION:
+                        curr->ed_Prot = icontrol->fib->fib_Protection;
+
+                        /* Fall through */
+                    case ED_SIZE:
+                        curr->ed_Size = icontrol->fib->fib_Size;
+
+                        /* Fall through */
+                    case ED_TYPE:
+                        curr->ed_Type = icontrol->fib->fib_DirEntryType;
+
+                        /* Fall through */
+                    case ED_NAME:
+                        curr->ed_Name = next;
+                        CopyStringSafe(icontrol->fib->fib_FileName);
+
+                        /* Fall through */
+                    case 0:
+                        curr->ed_Next = (struct ExAllData *)(((IPTR)next + AROS_PTRALIGN - 1) & ~(AROS_PTRALIGN - 1));
+                }
+                    
+                /* Do some more matching... */
+                if (control->eac_MatchFunc && !CALLHOOKPKT(control->eac_MatchFunc, curr, &data))
+                    continue;
+                    
+                /* Finally go to the next entry in the buffer.  */
+                last = curr;
+                curr = curr->ed_Next;
+                control->eac_Entries++;
+            }
+            err = IoErr();
+        }
 end:
         /* This is the last one, after it there's nothing.  */
-       last->ed_Next = NULL;
+        last->ed_Next = NULL;
     }
 
     /* Set error code and return */
index 7ac533d..3b72a3a 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH5(void, ExAllEnd,
+        AROS_LH5(void, ExAllEnd,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR,                  lock,    D1),
-       AROS_LHA(struct ExAllData *,    buffer,  D2),
-       AROS_LHA(LONG,                  size,    D3),
-       AROS_LHA(LONG,                  data,    D4),
-       AROS_LHA(struct ExAllControl *, control, D5),
+        AROS_LHA(BPTR,                  lock,    D1),
+        AROS_LHA(struct ExAllData *,    buffer,  D2),
+        AROS_LHA(LONG,                  size,    D3),
+        AROS_LHA(LONG,                  data,    D4),
+        AROS_LHA(struct ExAllControl *, control, D5),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 165, Dos)
+        struct DosLibrary *, DOSBase, 165, Dos)
 
 /*  FUNCTION
 
@@ -66,7 +66,7 @@
     {
         /* Get pointer to filehandle */
         struct FileLock *fl = (struct FileLock *)BADDR(lock);
-       dopacket5(DOSBase, NULL, fl->fl_Task, ACTION_EXAMINE_ALL_END, (SIPTR)lock, (IPTR)buffer, (IPTR)size, (IPTR)data, (IPTR)control);
+        dopacket5(DOSBase, NULL, fl->fl_Task, ACTION_EXAMINE_ALL_END, (SIPTR)lock, (IPTR)buffer, (IPTR)size, (IPTR)data, (IPTR)control);
     }
     else
     {
index 0da26a9..62641a5 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(LONG, Examine,
+        AROS_LH2(LONG, Examine,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR,                   lock, D1),
-       AROS_LHA(struct FileInfoBlock *, fib,  D2),
+        AROS_LHA(BPTR,                   lock, D1),
+        AROS_LHA(struct FileInfoBlock *, fib,  D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 17, Dos)
+        struct DosLibrary *, DOSBase, 17, Dos)
 
 /*  FUNCTION
 
@@ -69,8 +69,8 @@
     D(bug("[Examine] lock=%x fib=%x\n", fl, fib));
     ret = dopacket2(DOSBase, NULL, fl->fl_Task, ACTION_EXAMINE_OBJECT, lock, MKBADDR(fib));
     if (ret) {
-       fixfib(fib);
-       D(bug("[Examine] '%s'\n", fib->fib_FileName));
+        fixfib(fib);
+        D(bug("[Examine] '%s'\n", fib->fib_FileName));
     }
     return ret;
 
index 08f1cab..4702b1a 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(BOOL, ExamineFH,
+        AROS_LH2(BOOL, ExamineFH,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR,                   lock, D1),
-       AROS_LHA(struct FileInfoBlock *, fib,  D2),
+        AROS_LHA(BPTR,                   lock, D1),
+        AROS_LHA(struct FileInfoBlock *, fib,  D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 65, Dos)
+        struct DosLibrary *, DOSBase, 65, Dos)
 /*
     FUNCTION
 
@@ -52,8 +52,8 @@
     D(bug("[ExamineFH] fh=%x fib=%x\n", fh, fib));
     ret = dopacket2(DOSBase, NULL, fh->fh_Type, ACTION_EXAMINE_FH, fh->fh_Arg1, MKBADDR(fib));
     if (ret) {
-       fixfib(fib);
-       D(bug("[ExamineFH] '%s'\n", fib->fib_FileName));
+        fixfib(fib);
+        D(bug("[ExamineFH] '%s'\n", fib->fib_FileName));
     }
 
     return ret;
index 105df51..a62a9c8 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH3(BOOL, Execute,
+        AROS_LH3(BOOL, Execute,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, string, D1),
-       AROS_LHA(BPTR  , input , D2),
-       AROS_LHA(BPTR  , output, D3),
+        AROS_LHA(CONST_STRPTR, string, D1),
+        AROS_LHA(BPTR  , input , D2),
+        AROS_LHA(BPTR  , output, D3),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 37, Dos)
+        struct DosLibrary *, DOSBase, 37, Dos)
 
 /*  FUNCTION
 
     {
         { SYS_Background, TRUE         },
         { SYS_Asynch,     FALSE        },
-       { SYS_Input,      (IPTR)input  },
-       { SYS_Output,     (IPTR)output },
-       { SYS_Error,      (IPTR)NULL   },
-       { TAG_DONE,       0            }
+        { SYS_Input,      (IPTR)input  },
+        { SYS_Output,     (IPTR)output },
+        { SYS_Error,      (IPTR)NULL   },
+        { TAG_DONE,       0            }
     };
 
     D(bug("[Execute] input = %p, output = %p, cmd = \"%s\"\n", input, output, string));
@@ -97,9 +97,9 @@
     result = SystemTagList(string, tags);
 
     if(result == 0)
-       return DOSTRUE;
+        return DOSTRUE;
     else
-       return DOSFALSE;
+        return DOSFALSE;
 
     AROS_LIBFUNC_EXIT
 } /* Execute */
index 2e6a536..3891b76 100644 (file)
@@ -41,28 +41,28 @@ struct StackState
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(void, Exit,
+        AROS_LH1(void, Exit,
 
 /*  SYNOPSIS */
-       AROS_LHA(LONG, returnCode, D1),
+        AROS_LHA(LONG, returnCode, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 24, Dos)
+        struct DosLibrary *, DOSBase, 24, Dos)
 
 /*  FUNCTION
-       Instantly terminate the program.
+        Instantly terminate the program.
 
     INPUTS
-       returnCode - Process' return code.
+        returnCode - Process' return code.
 
     RESULT
-       None.
+        None.
 
     NOTES
-       Calling this function bypasses normal termination sequence of your program.
-       Automatically opened libraries will not be closed, destructors will not be
-       called, etc. Do this only if you really know what are you doing. It's not
-       adviced to use this function at all.
+        Calling this function bypasses normal termination sequence of your program.
+        Automatically opened libraries will not be closed, destructors will not be
+        called, etc. Do this only if you really know what are you doing. It's not
+        adviced to use this function at all.
 
     EXAMPLE
 
@@ -113,21 +113,21 @@ ULONG CallEntry(STRPTR argptr, ULONG argsize, LONG_FUNC entry, struct Process *m
 
     if (setjmp(ss.state))
     {
-       /*
-        * We came here from Exit().
-        * Restore stack limits because the program might have swapped stack.
-        * We are clever enough to recover from this.
-        */
-       me->pr_Task.tc_SPLower = ss.stackLower;
-       me->pr_Task.tc_SPUpper = ss.stackUpper;
+        /*
+         * We came here from Exit().
+         * Restore stack limits because the program might have swapped stack.
+         * We are clever enough to recover from this.
+         */
+        me->pr_Task.tc_SPLower = ss.stackLower;
+        me->pr_Task.tc_SPUpper = ss.stackUpper;
 
-       Enable(); /* We Disable()d in Exit() */
+        Enable(); /* We Disable()d in Exit() */
 
-       return ss.retval;
+        return ss.retval;
     }
     else
-       return AROS_UFC3(ULONG, entry,
-                        AROS_UFCA(STRPTR, argptr, A0),
-                        AROS_UFCA(ULONG, argsize, D0),
-                        AROS_UFCA(struct ExecBase *, SysBase, A6));
+        return AROS_UFC3(ULONG, entry,
+                         AROS_UFCA(STRPTR, argptr, A0),
+                         AROS_UFCA(ULONG, argsize, D0),
+                         AROS_UFCA(struct ExecBase *, SysBase, A6));
 }
index a2b884f..e97c971 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH2(LONG, ExNext,
+        AROS_LH2(LONG, ExNext,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR                  , lock, D1),
-       AROS_LHA(struct FileInfoBlock *, fileInfoBlock, D2),
+        AROS_LHA(BPTR                  , lock, D1),
+        AROS_LHA(struct FileInfoBlock *, fileInfoBlock, D2),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 18, Dos)
+        struct DosLibrary *, DOSBase, 18, Dos)
 
 /*  FUNCTION
 
@@ -39,7 +39,7 @@
 
     success  --  a boolean telling whether the operation was successful
                  or not. A failure occurs also if there is no "next" entry in
-                the directory. Then IoErr() equals ERROR_NO_MORE_ENTRIES.
+                 the directory. Then IoErr() equals ERROR_NO_MORE_ENTRIES.
 
     NOTES
 
@@ -56,7 +56,7 @@
     3.  Do something with the FileInfoBlock returned.
     4.  Call ExNext() repeatedly until it returns FALSE and use the
         information you are provided. When ExNext returns FALSE, check IoErr()
-       to make sure that there was no real failure (ERROR_NO_MORE_ENTRIES).
+        to make sure that there was no real failure (ERROR_NO_MORE_ENTRIES).
 
     BUGS
 
     D(bug("[ExNext] lock=%x fib=%x\n", fl, fileInfoBlock));
     ret = dopacket2(DOSBase, NULL,  fl->fl_Task, ACTION_EXAMINE_NEXT, lock, MKBADDR(fileInfoBlock));
     if (ret) {
-       fixfib(fileInfoBlock);
-       D(bug("[ExNext] '%s'\n", fileInfoBlock->fib_FileName));
+        fixfib(fileInfoBlock);
+        D(bug("[ExNext] '%s'\n", fileInfoBlock->fib_FileName));
     } else {
-       D(bug("[ExNext] ret=%d err=%d\n", ret, IoErr()));
+        D(bug("[ExNext] ret=%d err=%d\n", ret, IoErr()));
     }
     return ret;
 
dissimilarity index 62%
index d35cce0..0927c79 100644 (file)
-/*
-    Copyright © 1995-2008, The AROS Development Team. All rights reserved.
-    $Id$
-
-    Desc: dos.library function Fault()
-    Lang: english
-*/
-#include <aros/system.h>
-#include "dos_intern.h"
-#if PassThroughErrnos
-#   include <errno.h>
-#endif
-#include <string.h>
-
-/*****************************************************************************
-
-    NAME */
-#include <proto/dos.h>
-
-       AROS_LH4(BOOL, Fault,
-
-/*  SYNOPSIS */
-       AROS_LHA(LONG,         code,   D1),
-       AROS_LHA(CONST_STRPTR, header, D2),
-       AROS_LHA(STRPTR,       buffer, D3),
-       AROS_LHA(LONG,         len,    D4),
-
-/*  LOCATION */
-       struct DosLibrary *, DOSBase, 78, Dos)
-
-/*  FUNCTION
-       Fault will obtain the error message string for the given error
-       code. First the header string is copied to the buffer, followed
-       by a ":" (colon), then the NULL terminated string for the error
-       message into the buffer.
-
-       By convention, error messages are ALWAYS less than 80 (plus 1 for
-       NULL termination), and ideally less than 60 characters.
-
-       If the error code is not know, then the string "Unknown error"
-       followed by the error number will be added to the string.
-
-    INPUTS
-       code    -   The error code.
-       header  -   The string to prepend to the buffer before the error
-                   text. This may be NULL in which case nothing is prepended.
-       buffer  -   The destination buffer.
-       len     -   Length of the buffer.
-
-    RESULT
-       Number of characters placed in the buffer, may be 0.
-
-    NOTES
-
-    EXAMPLE
-
-    BUGS
-
-    SEE ALSO
-
-    INTERNALS
-
-*****************************************************************************/
-{
-    AROS_LIBFUNC_INIT
-
-    LONG index = 0;
-    STRPTR theString;
-
-    if (code == 0)
-    {
-       *buffer = '\0';
-       return 0;
-    }
-
-    /* Do this to make sure there is room for a NULL terminator */
-    len--;
-
-    if (header)
-    {
-       while((index < len) && *header)
-       {
-           buffer[index++] = *header++;
-       }
-
-       buffer[index++] = ':';
-       buffer[index++] = ' ';
-    }
-
-    theString = DosGetString(code);
-#if PassThroughErrnos
-    if ((!theString) && (code & PassThroughErrnos))
-    {
-       theString = strerror (code ^ PassThroughErrnos);
-    }
-#endif
-    if(theString)
-    {
-       while((index < len) && *theString)
-       {
-           buffer[index++] = *theString++;
-       }
-    }
-    else
-    {
-       /* String buffer/index for long 2 string */
-       UBYTE l2str[12], l2idx = 11;
-
-       theString = "Error";
-       while((index < len) && *theString)
-       {
-           buffer[index++] = *theString++;
-       }
-
-       /* If the number is negative, whack in a - sign. */
-       if(code < 0)
-       {
-           code = -code;
-           buffer[index++] = '-';
-       }
-
-       /* Convert the number to a string, I work backwards, its easier */
-       l2str[l2idx--] = '\0';
-       while(code != 0)
-       {
-           l2str[l2idx--] = (code % 10) + '0';
-           code /= 10;
-       }
-
-       l2str[l2idx] = ' ';
-
-       /* Copy the number onto the fault string */
-       while((index < len) && l2str[l2idx])
-       {
-           buffer[index++] = l2str[l2idx++];
-       }
-    }
-    buffer[index] = '\0';
-    return (len - index + 1);
-
-    AROS_LIBFUNC_EXIT
-} /* Fault */
+/*
+    Copyright © 1995-2008, The AROS Development Team. All rights reserved.
+    $Id$
+
+    Desc: dos.library function Fault()
+    Lang: english
+*/
+#include <aros/system.h>
+#include "dos_intern.h"
+#if PassThroughErrnos
+#   include <errno.h>
+#endif
+#include <string.h>
+
+/*****************************************************************************
+
+    NAME */
+#include <proto/dos.h>
+
+        AROS_LH4(BOOL, Fault,
+
+/*  SYNOPSIS */
+        AROS_LHA(LONG,         code,   D1),
+        AROS_LHA(CONST_STRPTR, header, D2),
+        AROS_LHA(STRPTR,       buffer, D3),
+        AROS_LHA(LONG,         len,    D4),
+
+/*  LOCATION */
+        struct DosLibrary *, DOSBase, 78, Dos)
+
+/*  FUNCTION
+        Fault will obtain the error message string for the given error
+        code. First the header string is copied to the buffer, followed
+        by a ":" (colon), then the NULL terminated string for the error
+        message into the buffer.
+
+        By convention, error messages are ALWAYS less than 80 (plus 1 for
+        NULL termination), and ideally less than 60 characters.
+
+        If the error code is not know, then the string "Unknown error"
+        followed by the error number will be added to the string.
+
+    INPUTS
+        code    -   The error code.
+        header  -   The string to prepend to the buffer before the error
+                    text. This may be NULL in which case nothing is prepended.
+        buffer  -   The destination buffer.
+        len     -   Length of the buffer.
+
+    RESULT
+        Number of characters placed in the buffer, may be 0.
+
+    NOTES
+
+    EXAMPLE
+
+    BUGS
+
+    SEE ALSO
+
+    INTERNALS
+
+*****************************************************************************/
+{
+    AROS_LIBFUNC_INIT
+
+    LONG index = 0;
+    STRPTR theString;
+
+    if (code == 0)
+    {
+        *buffer = '\0';
+        return 0;
+    }
+
+    /* Do this to make sure there is room for a NULL terminator */
+    len--;
+
+    if (header)
+    {
+        while((index < len) && *header)
+        {
+            buffer[index++] = *header++;
+        }
+
+        buffer[index++] = ':';
+        buffer[index++] = ' ';
+    }
+
+    theString = DosGetString(code);
+#if PassThroughErrnos
+    if ((!theString) && (code & PassThroughErrnos))
+    {
+        theString = strerror (code ^ PassThroughErrnos);
+    }
+#endif
+    if(theString)
+    {
+        while((index < len) && *theString)
+        {
+            buffer[index++] = *theString++;
+        }
+    }
+    else
+    {
+        /* String buffer/index for long 2 string */
+        UBYTE l2str[12], l2idx = 11;
+
+        theString = "Error";
+        while((index < len) && *theString)
+        {
+            buffer[index++] = *theString++;
+        }
+
+        /* If the number is negative, whack in a - sign. */
+        if(code < 0)
+        {
+            code = -code;
+            buffer[index++] = '-';
+        }
+
+        /* Convert the number to a string, I work backwards, its easier */
+        l2str[l2idx--] = '\0';
+        while(code != 0)
+        {
+            l2str[l2idx--] = (code % 10) + '0';
+            code /= 10;
+        }
+
+        l2str[l2idx] = ' ';
+
+        /* Copy the number onto the fault string */
+        while((index < len) && l2str[l2idx])
+        {
+            buffer[index++] = l2str[l2idx++];
+        }
+    }
+    buffer[index] = '\0';
+    return (len - index + 1);
+
+    AROS_LIBFUNC_EXIT
+} /* Fault */
index 6465799..b6ca1b1 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(LONG, FGetC,
+        AROS_LH1(LONG, FGetC,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR, file, D1),
+        AROS_LHA(BPTR, file, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 51, Dos)
+        struct DosLibrary *, DOSBase, 51, Dos)
 
 /*  FUNCTION
-       Get a character from a buffered file. Buffered I/O is more efficient
-       for small amounts of data but less for big chunks. You have to
-       use Flush() between buffered and non-buffered I/O or you'll
-       clutter your I/O stream.
+        Get a character from a buffered file. Buffered I/O is more efficient
+        for small amounts of data but less for big chunks. You have to
+        use Flush() between buffered and non-buffered I/O or you'll
+        clutter your I/O stream.
 
     INPUTS
-       file   - filehandle
+        file   - filehandle
 
     RESULT
-       The character read or EOF if the file ended or an error happened.
-       IoErr() gives additional information in that case.
+        The character read or EOF if the file ended or an error happened.
+        IoErr() gives additional information in that case.
 
     NOTES
 
@@ -49,7 +49,7 @@
     BUGS
 
     SEE ALSO
-       IoErr(), Flush()
+        IoErr(), Flush()
 
     INTERNALS
 
@@ -65,7 +65,7 @@
 
     if (fh == NULL)
     {
-       return EOF;
+        return EOF;
     }
     
     /* If the file is in write mode... */
@@ -80,7 +80,7 @@
 
             /* An error happened? Return it. */
             if(size < 0)
-           {
+            {
                 return EOF;
             }
 
 
         /* No data read? Return EOF. */
         if(size == 0)
-       {
+        {
             D(bug("FGetC: Tried to Read() to a %d byte buffer, got 0)\n", bufsize));
             return EOF;
-       }
+        }
     }
 
     /* If fh_End == 0, simulate an EOF */
index afba1fb..3ab87a7 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH3(STRPTR, FGets,
+        AROS_LH3(STRPTR, FGets,
 
 /*  SYNOPSIS */
-       AROS_LHA(BPTR  , fh, D1),
-       AROS_LHA(STRPTR, buf, D2),
-       AROS_LHA(ULONG , buflen, D3),
+        AROS_LHA(BPTR  , fh, D1),
+        AROS_LHA(STRPTR, buf, D2),
+        AROS_LHA(ULONG , buflen, D3),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 56, Dos)
+        struct DosLibrary *, DOSBase, 56, Dos)
 
 /*  FUNCTION
-       Read until NEWLINE (\n), EOF is encountered or buflen-1
-       characters have been read. If a NEWLINE is read, it will
-       be the last character in the buffer. The buffer will always
-       be \0-terminated.
+        Read until NEWLINE (\n), EOF is encountered or buflen-1
+        characters have been read. If a NEWLINE is read, it will
+        be the last character in the buffer. The buffer will always
+        be \0-terminated.
 
     INPUTS
-       fh - Read buffered from this filehandle
-       buf - Put read chars in this buffer
-       buflen - The size of the buffer
+        fh - Read buffered from this filehandle
+        buf - Put read chars in this buffer
+        buflen - The size of the buffer
 
     RESULT
-       buf or NULL if the first thing read is EOF.
+        buf or NULL if the first thing read is EOF.
 
     NOTES
 
 
     do
     {
-       c = FGetC (fh);
+        c = FGetC (fh);
 
-       if (c == EOF)
-       {
-           if (len == 0)
-               return NULL;
-           else
-               break;
-       }
+        if (c == EOF)
+        {
+            if (len == 0)
+                return NULL;
+            else
+                break;
+        }
 
-       buf[len++] = c;
+        buf[len++] = c;
     }
     while ((len<buflen) && (c != '\n'));
 
index cc59412..13db7ea 100644 (file)
     NAME */
 #include <proto/dos.h>
 
-       AROS_LH1(STRPTR, FilePart,
+        AROS_LH1(STRPTR, FilePart,
 
 /*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, path, D1),
+        AROS_LHA(CONST_STRPTR, path, D1),
 
 /*  LOCATION */
-       struct DosLibrary *, DOSBase, 145, Dos)
+        struct DosLibrary *, DOSBase, 145, Dos)
 
 /*  FUNCTION
-       Get a pointer to the last component of a path, which is normally the
-       filename.
+        Get a pointer to the last component of a path, which is normally the
+        filename.
 
     INPUTS
-       path - pointer AmigaDOS path string
-           May be relative to the current directory or the current disk.
+        path - pointer AmigaDOS path string
+            May be relative to the current directory or the current disk.
 
     RESULT
-       A pointer to the first char of the filename!
+        A pointer to the first char of the filename!
 
     NOTES
 
     EXAMPLE
-       FilePart("xxx:yyy/zzz/qqq") returns a pointer to the first 'q'.
-       FilePart("xxx:yyy")         returns a pointer to the first 'y'.
-       FilePart("yyy")             returns a pointer to the first 'y'.
+        FilePart("xxx:yyy/zzz/qqq") returns a pointer to the first 'q'.
+        FilePart("xxx:yyy")         returns a pointer to the first 'y'.
+        FilePart("yyy")             returns a pointer to the first 'y'.
 
     BUGS
-       None known.
+        None known.
 
     SEE ALSO
-       PathPart(), AddPart()
+        PathPart(), AddPart()
 
     INTERNALS
-       Goes from the last char of the pathname back until it finds a ':',
-       a '/' or until the first char reached.
+        Goes from the last char of the pathname back until it finds a ':',
+        a '/' or until the first char reached.
 
 *****************************************************************************/
 {
 
     if(path)
     {
-       CONST_STRPTR i;
+        CONST_STRPTR i;
 
-       /* set i to last char of path */
+        /* set i to last char of path */
 
-       if (!*path) /* path == "" ? */
-         return (STRPTR)path;
+        if (!*path) /* path == "" ? */
+          return (STRPTR)path;
 
-       i = path + strlen (path) -1;   /* set i to the \0-byte */
+        i = path + strlen (path) -1;   /* set i to the \0-byte */
 
-       /* decrease pointer as long as there is no ':', no '/' or till
-         the first char anyway. hope this works in all situations */
-       while ((*i != ':') && (*i != '/') && (i != path))
-           i--;
+        /* decrease pointer as long as there is no ':', no '/' or till
+          the first char anyway. hope this works in all situations */
+        while ((*i != ':') && (*i != '/') && (i != path))
+            i--;
 
-       if ((*i == ':')) i++;
-       if ((*i == '/')) i++;
+        if ((*i == ':')) i++;
+        if ((*i == '/')) i++;
 
-       return (STRPTR)i;
+        return (STRPTR)i;
     } /* path */
 
     return NULL;  /* if no path is given, return NULL pointer (shouldn't happen) */
@@ -100,10 +100,10 @@ int main (int argc, char ** argv)
 
     while (--argc)
     {
-       s = *++argv;
-       fileptr = FilePart(s);
+        s = *++argv;
+        fileptr = FilePart(s);
 
-       printf("Pfad:  %s\nDatei: %s\n", s, fileptr);
+        printf("Pfad:  %s\nDatei: %s\n", s, fileptr);
     }
 }
 
dissimilarity index 63%
index b3485a5..23f945e 100644 (file)
-/*
-    Copyright © 1995-2007, The AROS Development Team. All rights reserved.
-    $Id$
-
-    Desc:
-    Lang: english
-*/
-#include <proto/utility.h>
-#include "dos_intern.h"
-
-/*****************************************************************************
-
-    NAME */
-#include <proto/dos.h>
-
-       AROS_LH2(LONG, FindArg,
-
-/*  SYNOPSIS */
-       AROS_LHA(CONST_STRPTR, template, D1),
-       AROS_LHA(CONST_STRPTR, keyword,  D2),
-
-/*  LOCATION */
-       struct DosLibrary *, DOSBase, 134, Dos)
-
-/*  FUNCTION
-       Search for keyword in the template string.
-       Abbreviations are handled.
-
-    INPUTS
-       template - template string to be searched
-       keyword  - keyword to search for
-
-    RESULT
-       Index of the keyword or -1 if not found.
-
-    NOTES
-
-    EXAMPLE
-
-    BUGS
-
-    SEE ALSO
-
-    INTERNALS
-
-*****************************************************************************/
-{
-    AROS_LIBFUNC_INIT
-
-    LONG count=0;
-    CONST_STRPTR key;
-
-    /* Loop over template */
-    for(;;)
-    {
-       /* Compare key to template */
-       key=keyword;
-       for(;;)
-       {
-           UBYTE lkey;
-
-           /* If the keyword has ended check the template */
-           if(!*key)
-           {
-               if(!*template||*template=='='||*template=='/'||*template==',')
-                   /* The template has ended, too. Return count. */
-                   return count;
-               /* The template isn't finished. Stop comparison. */
-               break;
-           }
-           /* If the two differ stop comparison. */
-           lkey=ToLower(*key);
-           if(lkey!=ToLower(*template))
-               break;
-           /* Go to next character */
-           key++;
-           template++;
-       }
-       /* Find next keyword in template */
-       for(;;)
-       {
-           if(!*template)
-               return -1;
-           if(*template=='=')
-           {
-               /* Alias found */
-               template++;
-               break;
-           }
-           if(*template==',')
-           {
-               /* Next item found */
-               template++;
-               count++;
-               break;
-           }
-           template++;
-       }
-    }
-    AROS_LIBFUNC_EXIT
-} /* FindArg */
+/*
+    Copyright © 1995-2007, The AROS Development Team. All rights reserved.
+    $Id$
+
+    Desc:
+    Lang: english
+*/
+#include <proto/utility.h>
+#include "dos_intern.h"
+
+/*****************************************************************************
+
+    NAME */
+#include <proto/dos.h>
+
+        AROS_LH2(LONG, FindArg,
+
+/*  SYNOPSIS */
+        AROS_LHA(CONST_STRPTR, template, D1),
+        AROS_LHA(CONST_STRPTR, keyword,  D2),
+
+/*  LOCATION */
+        struct DosLibrary *, DOSBase, 134, Dos)
+
+/*  FUNCTION
+        Search for keyword in the template string.
+        Abbreviations are handled.
+
+    INPUTS
+        template - template string to be searched
+        keyword  - keyword to search for
+
+    RESULT
+        Index of the keyword or -1 if not found.
+
+    NOTES
+
+    EXAMPLE
+
+    BUGS
+
+    SEE ALSO
+
+    INTERNALS
+
+*****************************************************************************/
+{
+    AROS_LIBFUNC_INIT
+
+    LONG count=0;
+    CONST_STRPTR key;
+
+    /* Loop over template */
+    for(;;)
+    {
+        /* Compare key to template */
+        key=keyword;
+        for(;;)
+        {
+            UBYTE lkey;
+
+            /* If the keyword has ended check the template */
+            if(!*key)
+            {
+                if(!*template||*template=='='||*template=='/'||*template==',')
+                    /* The template has ended, too. Return count. */
+                    return count;
+                /* The template isn't finished. Stop comparison. */
+                break;
+            }
+            /* If the two differ stop comparison. */
+            lkey=ToLower(*key);
+            if(lkey!=ToLower(*template))
+                break;
+            /* Go to next character */
+            key++;
+            template++;
+        }
+        /* Find next keyword in template */
+        for(;;)
+        {
+            if(!*template)
+                return -1;
+            if(*template=='=')
+            {
+                /* Alias found */
+                template++;
+                break;
+            }
+            if(*template==',')
+            {
+                /* Next item found */
+                template++;
+                count++;
+                break;
+            }
+            template++;
+        }
+    }
+    AROS_LIBFUNC_EXIT
+} /* FindArg */