workbench/c/IconX.c

   1 /*
   2     Copyright © 2006-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: IconX WB script starter
   6     Lang: English
   7 */
   8
   9 /******************************************************************************
  10
  11
  12     NAME
  13
  14         IconX
  15
  16     SYNOPSIS
  17
  18         FILE/A
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         Starts DOS scripts from Workbench. In order to use it you need an icon for
  27         your script. Set 'IconX' as default tool.
  28
  29     INPUTS
  30
  31         FILE - The script filename to execute.
  32
  33         Tooltypes for script icon:
  34             WINDOW            -- Specification of the shell window
  35                                  default: con:0/50//80/IconX/Auto
  36             STACK=n           -- default: 40960
  37             USERSHELL=YES|NO  -- default: YES
  38             WAIT=n            -- Wait n seconds before closing window (default 2)
  39             DELAY=n           -- Wait n/50 seconds before closing window
  40
  41     RESULT
  42
  43     NOTES
  44
  45     EXAMPLE
  46
  47     BUGS
  48
  49     SEE ALSO
  50
  51         Execute
  52
  53     INTERNALS
  54
  55     HISTORY
  56
  57 ******************************************************************************/
  58
  59 //#define DEBUG 1
  60
  61 #include <aros/debug.h>
  62 #include <proto/exec.h>
  63 #include <proto/dos.h>
  64 #include <proto/intuition.h>
  65 #include <proto/icon.h>
  66 #include <proto/alib.h>
  67
  68 #include <workbench/startup.h>
  69
  70 #include <string.h>
  71 #include <stdlib.h>
  72 #include <stdio.h>
  73
  74 /* some default values */
  75 #define DEFWINDOW "con:0/50//80/IconX/Auto"
  76 #define DEFSTACK  (40960)
  77 #define DEFWAIT   (2 * 50) // two seconds
  78 #define DEFUSHELL (TRUE)
  79
  80 #define BASECOMMAND "EXECUTE "
  81
  82 const TEXT version[] = "\0$VER: IconX 41.3 (23.1.2012)";
  83 int __forceerrorrequester = 1;
  84 static TEXT errbuffer[255];
  85
  86
  87 void displayMsg(LONG code)
  88 {
  89     if (code)
  90     {
  91         Fault(code, "IconX", errbuffer, sizeof(errbuffer));
  92         struct EasyStruct es = {sizeof(struct EasyStruct), 0,
  93             "Error", errbuffer, "OK"};
  94         EasyRequest(0, &es, 0);
  95     }
  96 }
  97
  98 STRPTR AllocateNameFromLock(BPTR lock)
  99 {
 100     ULONG  length = 512;
 101     STRPTR buffer = NULL;
 102     BOOL   done   = FALSE;
 103
 104     while (!done)
 105     {
 106         if (buffer != NULL) FreeVec(buffer);
 107
 108         buffer = AllocVec(length, MEMF_ANY);
 109         if (buffer != NULL)
 110         {
 111             if (NameFromLock(lock, buffer, length))
 112             {
 113                 done = TRUE;
 114                 break;
 115             }
 116             else
 117             {
 118                 if (IoErr() == ERROR_LINE_TOO_LONG)
 119                 {
 120                     length += 512;
 121                     continue;
 122                 }
 123                 else
 124                 {
 125                     break;
 126                 }
 127             }
 128         }
 129         else
 130         {
 131             SetIoErr(ERROR_NO_FREE_STORE);
 132             break;
 133         }
 134     }
 135
 136     if (done)
 137     {
 138         return buffer;
 139     }
 140     else
 141     {
 142         if (buffer != NULL) FreeVec(buffer);
 143         return NULL;
 144     }
 145 }
 146
 147
 148
 149 STRPTR BuildCommandLine(struct WBStartup *startup)
 150 {
 151     const struct WBStartup *wbsstate = startup;
 152     STRPTR                  buffer   = NULL;
 153     ULONG                   length   = 2 /* NULL + '\n' */ + strlen(BASECOMMAND);
 154     int i;
 155
 156     /*-- Calculate length of resulting string ------------------------------*/
 157     for (i = 1 ; i < wbsstate->sm_NumArgs ; i++)
 158     {
 159         BPTR lock = Lock((STRPTR) wbsstate->sm_ArgList[i].wa_Name, ACCESS_READ);
 160         if (lock != BNULL)
 161         {
 162             BPTR cd   = CurrentDir(lock);
 163             STRPTR path = AllocateNameFromLock(lock);
 164             if (path != NULL)
 165             {
 166                 length += 3 /* space + 2 '"' */ + strlen(path);
 167                 FreeVec(path);
 168             }
 169             UnLock(lock);
 170             CurrentDir(cd);
 171         }
 172     }
 173
 174     /*-- Allocate space for command line string ----------------------------*/
 175     buffer = AllocVec(length, MEMF_ANY);
 176     D(bug("[IconX] buffer length: %d\n", length));
 177
 178     if (buffer != NULL)
 179     {
 180         /*-- Build command line --------------------------------------------*/
 181         strcpy(buffer, BASECOMMAND);
 182
 183         for (i = 1 ; i < wbsstate->sm_NumArgs ; i++)
 184         {
 185             BPTR lock = Lock((STRPTR) wbsstate->sm_ArgList[i].wa_Name, ACCESS_READ);
 186             if (lock != BNULL)
 187             {
 188                 BPTR cd   = CurrentDir(lock);
 189                 STRPTR path = AllocateNameFromLock(lock);
 190                 if (path != NULL)
 191                 {
 192                     strcat(buffer, " \"");
 193                     strcat(buffer, path);
 194                     strcat(buffer, "\"");
 195                     FreeVec(path);
 196                 }
 197                 UnLock(lock);
 198                 CurrentDir(cd);
 199             }
 200         }
 201         strcat(buffer, "\n");
 202     }
 203     else
 204     {
 205         SetIoErr(ERROR_NO_FREE_STORE);
 206     }
 207
 208     return buffer;
 209 }
 210
 211
 212 int main(int argc, char **argv)
 213 {
 214     LONG               rc            =       RETURN_FAIL;
 215     STRPTR             filename,
 216                        commandLine   =       NULL,
 217                        ixWindow      =       DEFWINDOW;
 218     LONG               ixWait        =       0,
 219                        ixStack       =       DEFSTACK;
 220     BOOL               ixUShell      =       DEFUSHELL;
 221     BPTR               oldlock       = (BPTR)-1,
 222                        dirlock       = (BPTR)-1,
 223                        window        =       BNULL;
 224     struct DiskObject *dobj          =       NULL;
 225
 226     D(bug("IconX argc %d\n", argc));
 227
 228     if (argc != 0)
 229     {
 230         displayMsg(ERROR_REQUIRED_ARG_MISSING);
 231         goto exit;
 232     }
 233
 234     struct WBStartup *startup = (struct WBStartup *) argv;
 235     if (startup->sm_NumArgs < 2)
 236     {
 237         displayMsg(ERROR_REQUIRED_ARG_MISSING);
 238         goto exit;
 239     }
 240
 241     D(bug("[IconX] startup->sm_NumArgs: %d\n", startup->sm_NumArgs));
 242
 243     dirlock  = startup->sm_ArgList[1].wa_Lock;
 244     filename = startup->sm_ArgList[1].wa_Name;
 245
 246     oldlock = CurrentDir(dirlock);
 247
 248     /* query diskobject for tooltypes */
 249     dobj = GetDiskObject(filename);
 250     if (dobj == NULL)
 251     {
 252         struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 253             "Error", "IconX\nGetDiskObject failed for:\n%s", "OK"};
 254         EasyRequest(0, &es, 0, filename);
 255         goto exit;
 256     }
 257
 258     if (dobj->do_Type == WBPROJECT)
 259     {
 260         const STRPTR *toolarray = (const STRPTR *)dobj->do_ToolTypes;
 261         STRPTR s;
 262         if ((s = FindToolType(toolarray, "WINDOW")))
 263         {
 264             ixWindow = s;
 265         }
 266         if ((s = FindToolType(toolarray, "STACK")))
 267         {
 268             ixStack = atol(s);
 269         }
 270         if ((s = FindToolType(toolarray, "USERSHELL")))
 271         {
 272             if (MatchToolValue(s, "NO"))
 273             {
 274                 ixUShell = FALSE;
 275             }
 276         }
 277         if ((s = FindToolType(toolarray, "WAIT")))
 278         {
 279             ixWait += atol(s) * 50;
 280         }
 281         if ((s = FindToolType(toolarray, "DELAY")))
 282         {
 283             ixWait += atol(s);
 284         }
 285     }
 286     else
 287     {
 288         displayMsg(ERROR_OBJECT_WRONG_TYPE);
 289         goto exit;
 290     }
 291
 292     if (ixWait <= 0)
 293         ixWait = DEFWAIT;
 294
 295     if (ixStack <= 4096)
 296         ixStack = DEFSTACK;
 297
 298     D(bug("wait %d stack %d usershell %d window %s\n", ixWait, ixStack, ixUShell, ixWindow));
 299
 300     D(bug("Building command line\n"));
 301     commandLine = BuildCommandLine(startup);
 302     if (commandLine == NULL)
 303     {
 304         displayMsg(IoErr());
 305         goto exit;
 306     }
 307     D(bug("[IconX] commandLine: '%s'\n", commandLine));
 308
 309     window  = Open(ixWindow, MODE_OLDFILE);
 310     if (window == BNULL)
 311     {
 312         /* try to open default window */
 313         window = Open(DEFWINDOW, MODE_OLDFILE);
 314     }
 315
 316     if (window)
 317     {
 318         D(bug("[IconX] window ok\n"));
 319         struct TagItem tags[] =
 320         {
 321             { SYS_Asynch,      FALSE        },
 322             { SYS_Background,  TRUE         },
 323             { SYS_Input,       (IPTR)window },
 324             { SYS_Output,      (IPTR)NULL   },
 325             { SYS_Error,       (IPTR)NULL   },
 326             { SYS_UserShell,   ixUShell     },
 327             { NP_StackSize,    ixStack      },
 328             { TAG_DONE,        0            }
 329         };
 330
 331         rc = SystemTagList(commandLine, tags);
 332         if (rc == -1)
 333         {
 334             displayMsg(IoErr());
 335             rc = RETURN_FAIL;
 336         }
 337     }
 338     else
 339     {
 340         displayMsg(IoErr());
 341         goto exit;
 342     }
 343
 344     Delay(ixWait);
 345     rc = RETURN_OK;
 346
 347 exit:
 348     Close(window);
 349     FreeDiskObject(dobj);
 350
 351     if (oldlock != (BPTR)-1)
 352         CurrentDir(oldlock);
 353
 354     return rc;
 355 }
 356