workbench/c/Join.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Join - Create a single file from several.
   6 */
   7
   8 /******************************************************************************
   9
  10
  11     NAME
  12
  13     Join [FILE] {(file | pattern)} AS|TO (filename)
  14
  15     SYNOPSIS
  16
  17     FILE/M/A,AS=TO/K/A
  18
  19     LOCATION
  20
  21     C:
  22
  23     FUNCTION
  24
  25     Join makes one big file of all listed files by putting them together
  26     in the order given. The destination file may not have the same name
  27     as any of input files. You must supply a destination file name. The
  28     original files remain unchanged. Any number of files can be Join:ed in
  29     one operation.
  30
  31     INPUTS
  32
  33     FILE   --  files to join
  34     TO=AS  --  the name of the combined file
  35
  36     RESULT
  37
  38     NOTES
  39
  40     EXAMPLE
  41
  42     Join Text1.doc Text2.doc AS Text.doc
  43     (This will merge the two text files into one.)
  44
  45     BUGS
  46
  47     SEE ALSO
  48
  49     INTERNALS
  50
  51 ******************************************************************************/
  52
  53 #define  DEBUG  0
  54 #include <aros/debug.h>
  55
  56 #include <exec/types.h>
  57 #include <exec/memory.h>
  58 #include <dos/dos.h>
  59 #include <dos/dosasl.h>
  60
  61 #include <proto/exec.h>
  62 #include <proto/dos.h>
  63
  64 #define ARG_TEMPLATE "FILE/M/A,AS=TO/K/A"
  65 #define ARG_FILE     0
  66 #define ARG_AS       1
  67 #define ARG_COUNT    2
  68
  69 #define BUFFERSIZE   32768    /* Buffersize used when reading & writing */
  70
  71 /****** StringID's for getstring() **************************************/
  72
  73 #define STR_ABORTED       1   /* Aborted                                */
  74 #define STR_REMOVINGDEST  2   /* Removing destination-file              */
  75 #define STR_ERR_OPENREAD  3   /* Error opening file for reading         */
  76 #define STR_ERR_NOMEM     4   /* Error allocating memory                */
  77 #define STR_ERR_WRITING   5   /* Error while writing to file            */
  78 #define STR_ERR_OPENWRITE 6   /* Error opening file for writing         */
  79 #define STR_ERR_READING   7   /* Error while reading from file          */
  80
  81 /****** Version- and error-header ***************************************/
  82
  83 const TEXT version[] = "$VER: Join 41.1 (7.9.1999)";
  84 static char ERROR_HEADER[]  = "Join";
  85
  86 /****** Prototypes for local functions **********************************/
  87
  88 LONG   append( BPTR destfile , STRPTR srcfilename );
  89 STRPTR getstring( LONG stringid );
  90 int doJoin(STRPTR *files, BPTR destfile);
  91
  92 /****** Functions *******************************************************/
  93
  94 int main( void )
  95 {
  96     struct RDArgs  *rda = NULL ;
  97
  98     IPTR    args[ARG_COUNT] = { (IPTR) NULL , (IPTR) NULL };
  99     STRPTR *files;
 100     STRPTR  destination;
 101     BPTR    destfile = BNULL;
 102     LONG    rc = RETURN_OK;
 103
 104     if( (rda = ReadArgs( ARG_TEMPLATE , args , NULL )) )
 105     {
 106         if( args[ARG_FILE] && args[ARG_AS] )
 107         {
 108             destination = (STRPTR)args[ARG_AS];
 109             files = (STRPTR *)args[ARG_FILE];
 110
 111             if( (destfile = Open( destination , MODE_NEWFILE )) )
 112             {
 113                 rc = doJoin(files, destfile);
 114                 Close(destfile);
 115                 if (rc != RETURN_OK)
 116                 {
 117                     Printf(", %s.\n", getstring(STR_REMOVINGDEST));
 118                     DeleteFile(destination);
 119                 }
 120             }
 121             else
 122             {
 123                 PrintFault(IoErr() , ERROR_HEADER);
 124                 rc = RETURN_FAIL;
 125             }
 126         }
 127         else
 128         {
 129             rc = RETURN_FAIL;
 130         }
 131
 132         FreeArgs(rda);
 133     }
 134     else
 135     {
 136         PrintFault(IoErr(), ERROR_HEADER);
 137         rc = RETURN_FAIL;
 138     }
 139
 140     return rc;
 141 }
 142
 143
 144 #define  MAX_PATH_LEN  512
 145
 146
 147 int doJoin(STRPTR *files, BPTR destfile)
 148 {
 149     struct AnchorPath *ap;
 150
 151     LONG  i;                    /* Loop variable over patterns */
 152     LONG  match;                /* Loop variable over files */
 153     LONG  rc = RETURN_OK;
 154     ULONG numfiles;
 155
 156     ap = (struct AnchorPath *)AllocVec(sizeof(struct AnchorPath) +
 157                                        MAX_PATH_LEN, MEMF_CLEAR);
 158
 159     if (ap == NULL)
 160     {
 161         SetIoErr(ERROR_NO_FREE_STORE);
 162         return RETURN_FAIL;
 163     }
 164
 165     ap->ap_Strlen = MAX_PATH_LEN;
 166
 167     /* Loop over the arguments */
 168     for (i = 0; files[i] != NULL; i++)
 169     {
 170         ap->ap_BreakBits  = SIGBREAKF_CTRL_C;
 171         ap->ap_FoundBreak = 0;
 172         numfiles = 0;
 173         for (match = MatchFirst(files[i], ap); match == 0;
 174              match = MatchNext(ap))
 175         {
 176             if(append(destfile, ap->ap_Buf) != RETURN_OK )
 177             {
 178                 Printf("%s: %s", ERROR_HEADER, getstring(STR_ABORTED));
 179                 rc = RETURN_FAIL;
 180                 break;
 181             }
 182             numfiles++;
 183         }
 184
 185         MatchEnd(ap);
 186         if (ap->ap_FoundBreak & SIGBREAKF_CTRL_C)
 187         {
 188             SetIoErr(ERROR_BREAK);
 189             numfiles = 0;
 190         }
 191         if (!numfiles)
 192         {
 193             PrintFault(IoErr(), NULL);
 194             rc = RETURN_FAIL;
 195             break;
 196         }
 197     }
 198
 199     FreeVec(ap);
 200
 201     return rc;
 202 }
 203
 204
 205 LONG append(BPTR destfile, STRPTR srcfilename)
 206 {
 207     BYTE  *buffer       = NULL;
 208     LONG   actualLength = 0;
 209     BPTR   srcfile      = BNULL;
 210
 211     BOOL   rc           = RETURN_OK;
 212
 213     if ( (buffer = AllocMem( BUFFERSIZE , MEMF_ANY )) )
 214     {
 215         if ( (srcfile = Open( srcfilename , MODE_OLDFILE )) )
 216         {
 217             ULONG brk;
 218             while(!(brk = SetSignal(0,0) & SIGBREAKF_CTRL_C) && (actualLength = Read(srcfile, buffer, BUFFERSIZE)) != -1 )
 219             {
 220                 if (Write(destfile, buffer, actualLength) != actualLength )
 221                 {
 222                     Printf("%s: %s.\n", ERROR_HEADER, getstring(STR_ERR_WRITING));
 223                     rc = RETURN_FAIL;
 224
 225                     break;
 226                 }
 227
 228                 if (actualLength < BUFFERSIZE)
 229                 {
 230                     break;
 231                 }
 232             }
 233             if (actualLength == -1)
 234             {
 235                 PrintFault(IoErr(), NULL);
 236                 Printf( "%s: %s.\n", (IPTR)ERROR_HEADER,
 237                        (IPTR)getstring(STR_ERR_READING));
 238                 rc = RETURN_FAIL;
 239             }
 240
 241             if (brk)
 242             {
 243                 PrintFault(ERROR_BREAK, NULL);
 244                 SetIoErr(ERROR_BREAK);
 245                 rc = RETURN_FAIL;
 246             }
 247
 248             Close(srcfile);
 249         }
 250         else
 251         {
 252             PrintFault(IoErr(), NULL);
 253             Printf("%s: %s: '%s'\n",
 254                 ERROR_HEADER,
 255                 getstring(STR_ERR_OPENREAD),
 256                 srcfilename);
 257
 258             rc = RETURN_FAIL;
 259         }
 260
 261         FreeMem(buffer, BUFFERSIZE);
 262     }
 263     else
 264     {
 265         Printf("%s: %s.\n", ERROR_HEADER, getstring(STR_ERR_NOMEM));
 266         rc = RETURN_FAIL;
 267     }
 268
 269     return rc;
 270 }
 271
 272
 273 STRPTR getstring(LONG stringid)
 274 {
 275     switch(stringid)
 276     {
 277     case STR_ABORTED:
 278         return "Aborted";
 279
 280     case STR_REMOVINGDEST:
 281         return "removed incomplete destination-file";
 282
 283     case STR_ERR_OPENREAD:
 284         return "Could not open file for reading";
 285
 286     case STR_ERR_NOMEM:
 287         return "Could not allocate memory";
 288
 289     case STR_ERR_WRITING:
 290         return "Error while writing";
 291
 292     case STR_ERR_OPENWRITE:
 293         return "Could not open file for writing";
 294
 295     case STR_ERR_READING:
 296         return "Error while writing";
 297
 298     default:
 299         return "[Error: Unknown StringID]";
 300     }
 301 }