workbench/c/Filenote.c

   1 /*
   2     Copyright © 1995-2011 The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Filenote CLI command
   6     Lang: english
   7 */
   8
   9 /*****************************************************************************
  10
  11     NAME
  12
  13         Filenote
  14
  15     SYNOPSIS
  16
  17         FILE/A,COMMENT,ALL/S,QUIET/S
  18
  19     LOCATION
  20
  21         C:
  22
  23     FUNCTION
  24
  25         Add a comment to a file or directory.
  26
  27         Filenote allows a recursive scan of all directories adding comments
  28         to each file/directory it finds that matches the file pattern
  29         specified.
  30
  31     INPUTS
  32
  33         FILE    - Always has to be specified. Can be either a filename with
  34                   a full path or a file pattern that is to be matched.
  35
  36         COMMENT - The string that is to be added as a comment to the
  37                   file(s)/dir(s) specified. If no comment is specified, any
  38                   existing comment is deleted.
  39
  40                   To provide a comment that has embedded quotation marks,
  41                   precede each quote with an asterisk.
  42
  43                     i.e. Filenote FILE=RAM:test.txt COMMENT=*"hello*"
  44
  45         ALL     - Boolean switch. If specified, Filenote scans the directories
  46                   that match the pattern specified, recursively.
  47
  48         QUIET   - Boolean switch. If specified, no diagnostic text will be
  49                   displayed to stdout.
  50
  51     RESULT
  52
  53         Standard DOS return codes.
  54
  55     NOTES
  56
  57         Output from AROS' Filenote is more neat and structured than the
  58         standard Filenote command.
  59
  60         Does not yet support multi-assigns.
  61
  62     EXAMPLE
  63
  64         Filenote ram: hello all
  65
  66             Recurses through each directory in RAM: adding "hello" as a
  67             filenote to each file/directory.
  68
  69     BUGS
  70
  71     SEE ALSO
  72
  73         dos.library/SetComment()
  74
  75     INTERNALS
  76
  77 ******************************************************************************/
  78
  79 #ifdef __AROS__
  80 #include <proto/arossupport.h>
  81 #endif
  82 #include <proto/dos.h>
  83 #include <proto/exec.h>
  84
  85 #include <dos/dos.h>
  86 #include <dos/dosasl.h>
  87 #include <dos/dosextens.h>
  88 #include <dos/rdargs.h>
  89 #include <exec/memory.h>
  90 #include <utility/utility.h>
  91
  92 #include <ctype.h>
  93 #include <string.h>
  94
  95 #ifdef __AROS__
  96 #include <aros/rt.h>
  97 #else
  98 #define RT_Init()
  99 #define RT_Exit()
 100 #define IsDosEntryA(file, flags) 0
 101 #endif
 102
 103 #define ERROR_HEADER "Filenote"
 104
 105 #define ARG_TEMPLATE    "FILE/A,COMMENT,ALL/S,QUIET/S"
 106 #define ARG_FILE        0
 107 #define ARG_COMMENT     1
 108 #define ARG_ALL         2
 109 #define ARG_QUIET       3
 110 #define TOTAL_ARGS      4
 111
 112 /* To define whether a command line switch was set or not.
 113  */
 114 #define NOT_SET         0
 115
 116 #define MAX_PATH_LEN    512
 117
 118 const TEXT version[] = "$VER: Filenote 41.3 (7.5.2015)\n";
 119
 120 int Do_Filenote(struct AnchorPath *, STRPTR, STRPTR, LONG, LONG);
 121
 122 int __nocommandline;
 123
 124 int main(void)
 125 {
 126     struct RDArgs     * rda;
 127     struct AnchorPath * apath;
 128     IPTR                args[TOTAL_ARGS] = { 0, (IPTR)"", 0, 0};
 129     int                 Return_Value;
 130
 131     RT_Init();
 132
 133     Return_Value = RETURN_OK;
 134
 135     apath = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN,
 136                      MEMF_ANY | MEMF_CLEAR);
 137     if (apath)
 138     {
 139         /* Make sure DOS knows the buffer size.
 140          */
 141         apath->ap_Flags = APF_DOWILD | APF_FollowHLinks;
 142         apath->ap_Strlen = MAX_PATH_LEN;
 143         apath->ap_BreakBits = 0;
 144         apath->ap_FoundBreak = 0;
 145
 146         rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 147         if (rda)
 148         {
 149             Return_Value = Do_Filenote(apath,
 150                                        (STRPTR)args[ARG_FILE],
 151                                        (STRPTR)args[ARG_COMMENT],
 152                                        (LONG)args[ARG_ALL],
 153                                        (LONG)args[ARG_QUIET]
 154             );
 155             FreeArgs(rda);
 156         }
 157         else
 158         {
 159             PrintFault(IoErr(), ERROR_HEADER);
 160
 161             Return_Value = RETURN_ERROR;
 162         }
 163     }
 164     else
 165     {
 166         Return_Value = RETURN_FAIL;
 167     }
 168
 169     FreeVec(apath);
 170
 171     RT_Exit();
 172
 173     return Return_Value;
 174
 175 } /* main */
 176
 177
 178 /* Defines whether MatchFirst(), etc has matched a file.
 179  */
 180 #define MATCHED_FILE    0
 181
 182 void PrintFileName(struct AnchorPath *, LONG);
 183 int SafeSetFileComment(struct AnchorPath *, char *);
 184
 185 int Do_Filenote(struct AnchorPath *a,
 186                 STRPTR File,
 187                 STRPTR Comment,
 188                 LONG All,
 189                 LONG Quiet)
 190 {
 191     LONG  Result,
 192           TabValue;
 193     int   Return_Value;
 194
 195     Return_Value = RETURN_OK;
 196     TabValue     = 0L;
 197
 198     /* Looks to see if the user has given a volume name as a pattern
 199      * without the all switch set. If so, we fail.
 200      */
 201
 202     if
 203     (
 204         IsDosEntryA((char *)File, LDF_VOLUMES | LDF_DEVICES) == TRUE
 205     &&
 206         All == NOT_SET
 207     )
 208     {
 209         PrintFault(ERROR_OBJECT_WRONG_TYPE, ERROR_HEADER);
 210         Return_Value = RETURN_FAIL;
 211     }
 212     else
 213     {
 214         if (Return_Value != RETURN_FAIL)
 215         {
 216             Result = MatchFirst(File, a);
 217
 218             if (Result == MATCHED_FILE)
 219             {
 220                 do
 221                 {
 222                     if (All == NOT_SET)
 223                     {
 224                         Return_Value = SafeSetFileComment(a, Comment);
 225                         if ((Quiet == NOT_SET) && (Return_Value == RETURN_OK))
 226                         {
 227                             PrintFileName(a, TabValue);
 228                         }
 229                     }
 230                     else
 231                     {
 232                         /* Allow a recursive scan.
 233                          */
 234
 235                         if (a->ap_Info.fib_DirEntryType > 0)
 236                         {
 237                             /* Enter directory.
 238                              */
 239                             if (!(a->ap_Flags & APF_DIDDIR))
 240                             {
 241                                 a->ap_Flags |= APF_DODIR;
 242
 243                                 Return_Value = SafeSetFileComment(a, Comment);
 244
 245                                 if ((Quiet == NOT_SET) && (Return_Value == RETURN_OK))
 246                                 {
 247                                     PrintFileName(a, TabValue);
 248                                 }
 249                                 TabValue++;
 250                             }
 251                             else
 252                             {
 253                                 /* Leave directory.
 254                                  */
 255                                 a->ap_Flags &= ~APF_DIDDIR;
 256                                 TabValue--;
 257                             }
 258                         }
 259                         else
 260                         {
 261                             Return_Value = SafeSetFileComment(a, Comment);
 262
 263                             if ((Quiet == NOT_SET) && (Return_Value == RETURN_OK))
 264                             {
 265                                 PrintFileName(a, TabValue);
 266                             }
 267                         }
 268                     }
 269                 }
 270                 while
 271                 (
 272                     ((Result = MatchNext(a)) == MATCHED_FILE)
 273                 &&
 274                     Return_Value != RETURN_FAIL
 275                 );
 276             }
 277             else
 278             {
 279                 PrintFault(IoErr(), ERROR_HEADER);
 280                 Return_Value = RETURN_FAIL;
 281             }
 282
 283             MatchEnd(a);
 284         }
 285     }
 286
 287     return Return_Value;
 288
 289 } /* Do_Filenote */
 290
 291
 292 void PrintFileName(struct AnchorPath *a, LONG t)
 293 {
 294     int i;
 295
 296     Printf("   ");
 297
 298     for (i = 0; i != t; i++)
 299     {
 300         Printf("  ");
 301     }
 302
 303     Printf("%s", FilePart(&a->ap_Buf[0]));
 304
 305     if (a->ap_Info.fib_DirEntryType > 0)
 306     {
 307         Printf(" (dir)");
 308     }
 309
 310     Printf("...Done\n");
 311
 312 } /* PrintFileName */
 313
 314
 315 int SafeSetFileComment(struct AnchorPath *a, char *c)
 316 {
 317     int Return_Value;
 318
 319     Return_Value = RETURN_OK;
 320
 321     if (!SetComment(a->ap_Buf, c))
 322     {
 323         PrintFault(IoErr(), ERROR_HEADER);
 324         Return_Value = RETURN_ERROR;
 325     }
 326     else
 327     if (strlen(c) > 79)
 328     {
 329         VPrintf("Note truncated to 79 characters\n", NULL);
 330         Return_Value = RETURN_WARN;
 331     }
 332
 333     return Return_Value;
 334
 335 } /* SafeSetFileComment */