home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Recent / comm / mail / YAM23src.lha / Source / extrasrc / NewReadArgs.c < prev    next >
C/C++ Source or Header  |  2000-12-15  |  10KB  |  422 lines
  1. /*
  2. **
  3. **    NewReadArgs() -
  4. **    a shell/workbench transparent ReadArgs() interface
  5. **
  6. **    © 1997-99 by Stephan Rupprecht
  7. **    All rights reserved.
  8. **
  9. **    FREEWARE - I am not responsible for any damage that
  10. **    is caused by the (mis)use of this program.
  11. **
  12. **    MaxonC++, OS2.04+
  13. **
  14. */
  15.  
  16. /*- INCLUDES & DEFINES -*/
  17. #include <dos/dos.h>
  18. #include <exec/memory.h>
  19. #include <workbench/startup.h>
  20. #include <workbench/workbench.h>
  21. #include <workbench/icon.h>
  22. #include <proto/intuition.h>
  23. #include <proto/icon.h>
  24. #include <proto/exec.h>
  25. #include <proto/dos.h>
  26. #include <string.h>
  27.  
  28. #ifdef DEBUG
  29. #define bug        Printf
  30. #define d(x)        (x)
  31. #else
  32. #define bug
  33. #define d(x)        ;
  34. #endif
  35.  
  36. //#define COMPILE_V39
  37.  
  38. /****************************************************************************/
  39.  
  40. /*- NEWRDARGS STRUCTURE -*/
  41. struct NewRDArgs {
  42. // initialize these fields before calling NewReadArgs() !!!
  43.     STRPTR         Template;     // ReadArgs() template
  44.     STRPTR         ExtHelp;     // ExtHelp string
  45.     STRPTR         Window;     // workbench window -> eg. "CON:////Test"
  46.     LONG        *Parameters;     // where to store the data
  47.     LONG         FileParameter;     // -1 = none, 0 = all
  48.     LONG         PrgToolTypesOnly;
  49.  
  50. // private data section
  51.     struct RDArgs    *RDArgs;    // RDArgs we give to ReadArgs()
  52.     struct RDArgs    *FreeArgs;    // RDArgs we get from ReadArgs()
  53.  
  54. #ifdef COMPILE_V39
  55.     APTR         Pool;
  56. #else
  57.     struct Remember    *Remember;    // the memory we`ve allocated
  58. #endif
  59.  
  60.     BPTR         WinFH;        // i/o window stream
  61.     BPTR         OldInput;    // old i/o streams
  62.     BPTR         OldOutput;
  63. };
  64.  
  65. /****************************************************************************/
  66.  
  67. void NewFreeArgs(struct NewRDArgs *);
  68. LONG NewReadArgs(struct WBStartup *, struct NewRDArgs *);
  69.  
  70. /****************************************************************************/
  71.  
  72. void NewFreeArgs(struct NewRDArgs *rdargs)
  73. {
  74. #ifndef COMPILE_V39
  75. static const STRPTR NRDArgsID = "NewReadArgs 37.4 © 1997-1999 by Stephan Rupprecht";
  76. #else 
  77. static const STRPTR NRDArgsID = "NewReadArgs 39.4 © 1997-1999 by Stephan Rupprecht";
  78. #endif
  79.  
  80.     d(bug("--- NewFreeArgs ---\n"));
  81.     FreeArgs(rdargs->FreeArgs);
  82.     d(bug("FreeArgs( rdargs->FreeArgs )\n"));
  83.     if(rdargs->RDArgs)
  84.     {
  85.         FreeVec( rdargs->RDArgs->RDA_Source.CS_Buffer );
  86.         FreeDosObject(DOS_RDARGS, rdargs->RDArgs);
  87.     }
  88.     d(bug("FreeDosObject( DOS_RDARGS, rdargs->RDArgs )\n"));
  89.     if(rdargs->WinFH) 
  90.     {
  91.         SelectOutput(rdargs->OldOutput);
  92.         Close(SelectInput(rdargs->OldInput));
  93.         d(bug("SelectOutput( .. )\nClose( ... )\n"));
  94.     }
  95.  
  96. #ifndef COMPILE_V39
  97.     if(rdargs->Remember)
  98.         FreeRemember(&rdargs->Remember, TRUE);
  99. #else
  100.     if(rdargs->Pool)
  101.         DeletePool(rdargs->Pool);
  102. #endif
  103.     d(bug("memory freed\n"));
  104.     d(bug("--- EXIT ---\n"));
  105. }
  106.  
  107. /****************************************************************************/
  108.  
  109. STATIC LONG IsArg( STRPTR template, STRPTR keyword)
  110. {
  111.     UBYTE    buffer[128], c;
  112.     STRPTR    ptr = buffer;
  113.  
  114.     while((c = *keyword++) && (c != '=')) *ptr++ = c;
  115.  
  116.     *ptr = 0;
  117.  
  118.     /*- checks if keyword is specified in template -*/
  119.     return(FindArg(template, buffer));
  120. }
  121.  
  122. /****************************************************************************/
  123.  
  124. LONG NewReadArgs( struct WBStartup *WBStartup, struct NewRDArgs *nrdargs)
  125. {
  126.     static const Tag icontags[] = {
  127.         ICONGETA_RemapIcon,FALSE, TAG_DONE
  128.     };
  129.  
  130.     d(bug("--- NewReadArgs ---\n"));
  131.  
  132.     nrdargs->RDArgs        =
  133.     nrdargs->FreeArgs    = NULL;
  134.     nrdargs->WinFH        = 0;
  135. #ifndef COMPILE_V39
  136.     nrdargs->Remember    = NULL;
  137. #else
  138.     nrdargs->Pool        = NULL;
  139. #endif
  140.  
  141.     if((nrdargs->RDArgs = (struct RDArgs *)AllocDosObject(DOS_RDARGS, NULL)))
  142.     {
  143. #ifndef COMPILE_V39
  144.         struct Remember    **remember = &nrdargs->Remember;
  145. #else
  146.         APTR            pool = NULL;
  147. #endif
  148.         STRPTR    ToolWindow = nrdargs->Window;
  149.  
  150.         if(WBStartup)
  151.         {
  152.             struct WBArg    *wbarg;
  153.             STRPTR            *Args, ptr;
  154.             LONG            MaxArgs = 1, *ArgLen, num = WBStartup->sm_NumArgs,
  155.                             FileArgs = nrdargs->FileParameter, FArgNum = -1L, MultiArg = -1L;
  156.  
  157.             if(!(ptr = nrdargs->Template))
  158.                 return(ERROR_BAD_TEMPLATE);
  159.  
  160.             /*- count max number of args -*/
  161.             while(*ptr)
  162.             {
  163.                 if( *ptr++ == '/' && *ptr == 'M' ) {
  164.                     MultiArg = MaxArgs-1L;
  165.                     ptr++;
  166.                 }
  167.                 else if(*(ptr-1) == ',') MaxArgs++;
  168.             }
  169.             d(bug("Args: %ld\n", MaxArgs) );
  170.             ptr = nrdargs->Template;
  171.  
  172.             /*- how many file args? -*/
  173.             FileArgs = (FileArgs > num) ? num : ((FileArgs == -1) ? 0L : num);
  174.             MaxArgs += FileArgs;
  175.  
  176. #ifndef COMPILE_V39
  177.             if(!(Args = AllocRemember(remember, MaxArgs*sizeof(STRPTR)*2, MEMF_ANY|MEMF_CLEAR)))
  178.                 return(ERROR_NO_FREE_STORE);
  179. #else
  180.             if(!(pool = nrdargs->Pool = CreatePool(MEMF_ANY, 1024, 1024)) || !(Args = AllocPooled(pool, MaxArgs*sizeof(STRPTR)*2)))
  181.                 return(ERROR_NO_FREE_STORE);
  182.  
  183.             for(num = 0L; num < (MaxArgs*2); num++)
  184.                 Args[num] = 0L;
  185. #endif
  186.  
  187.             ArgLen = (LONG *)&Args[MaxArgs];
  188.  
  189.             for(    wbarg = WBStartup->sm_ArgList, num = 0L;
  190.                     num < WBStartup->sm_NumArgs;
  191.                     num++, wbarg++    )
  192.             {
  193.                 struct DiskObject    *dobj;
  194.                 BPTR            olddir;
  195.  
  196.                 /*- get file-names if requested -*/
  197.                 if(FileArgs)
  198.                 {
  199.                     TEXT    buf[300];
  200.  
  201.                     if(FArgNum < FileArgs && FArgNum >= 0L)
  202.                     {
  203.                         d(bug("ICON: %s\n", wbarg->wa_Name));
  204.  
  205.                         if(    NameFromLock(wbarg->wa_Lock, buf, sizeof(buf)) &&
  206.                             AddPart(buf, wbarg->wa_Name, sizeof(buf))    )
  207.                         {
  208.                             STRPTR    dst;
  209.                             LONG    len = strlen(buf) + 2L;
  210. #ifndef COMPILE_V39
  211.                             if((Args[FArgNum] = dst = AllocRemember(remember, len, MEMF_ANY)))
  212. #else
  213.                             if((Args[FArgNum] = dst = AllocPooled(pool, len)))
  214. #endif
  215.                             {
  216.                                 CopyMem(buf, (dst+1), len-2L);
  217.                                 *dst = dst[len-1] = '"';
  218.  
  219.                                 ArgLen[FArgNum] = len;
  220.                             }
  221.                             else return(ERROR_NO_FREE_STORE);
  222.                         }
  223.                         else return(ERROR_LINE_TOO_LONG);
  224.                     }
  225.  
  226.                     FArgNum++;
  227.                 }
  228.  
  229.                 if(nrdargs->PrgToolTypesOnly && num)
  230.                     continue;
  231.  
  232.                 olddir = CurrentDir(wbarg->wa_Lock);
  233.  
  234.                 /*- get tooltypes from .info file -*/
  235.                 dobj = ( IconBase->lib_Version < 44L ) ?
  236.                         GetDiskObject(wbarg->wa_Name) :
  237.                         GetIconTagList(wbarg->wa_Name, (struct TagItem *)icontags);
  238.  
  239.                 if( dobj )
  240.                 {
  241.                     if(dobj->do_Type == WBTOOL || dobj->do_Type == WBPROJECT)
  242.                     {
  243.                         STRPTR    *tarray = (STRPTR *)dobj->do_ToolTypes;
  244.  
  245.                         while(*tarray)
  246.                         {
  247.                             if(**tarray != '(')
  248.                             {
  249.                                 STRPTR    src = *tarray;
  250.                                 LONG    i;
  251.  
  252.                                 d(bug("tt: %s\n", *tarray));
  253.  
  254.                                 /*- valid arg ? -*/
  255.                                 if((i = IsArg(ptr, src)) > -1)
  256.                                 {
  257.                                     STRPTR    dst;
  258.                                     LONG    len;
  259.  
  260.                                     i += FileArgs;
  261.  
  262.                                     if( ArgLen[i] == 0L || (i-FileArgs) != MultiArg )
  263.                                     {
  264. #ifndef COMPILE_V39
  265.                                         if((Args[i] = dst = AllocRemember(remember, (len = strlen(src))+2L, MEMF_ANY)))
  266. #else
  267.                                         if((Args[i] = dst = AllocPooled(pool, (len = strlen(src))+2L)))
  268. #endif
  269.                                         {
  270.                                             /*- copy arg -*/
  271.                                             while(*src)
  272.                                             {
  273.                                                 if(((*dst++ = *src++) == '=') && (*src != '"'))
  274.                                                 {
  275.                                                     *dst++ = Args[i][len+1] = '"';
  276.                                                     len+=2;
  277.                                                 }
  278.                                             }
  279.  
  280.                                             ArgLen[i] = len;
  281.                                         }
  282.                                         else return(ERROR_NO_FREE_STORE);
  283.                                     }
  284.                                     else
  285.                                     {
  286.                                         while( *src && *src++ != '=' );
  287.  
  288.                                         len = strlen( src ) + 1 + ArgLen[i];
  289. #ifndef COMPILE_V39
  290.                                         if( (dst = AllocRemember(remember, len+2, MEMF_ANY)) )
  291. #else
  292.                                         if( (dst = AllocPooled(pool, len+2)) )
  293. #endif
  294.                                         {
  295.                                             BOOL    quotes = FALSE;
  296.                                             UBYTE    c;
  297.  
  298.                                             CopyMem( Args[i], dst, len );
  299.                                             Args[i] = dst;
  300.                                             dst += ArgLen[i];
  301.                                             *dst++ = ' ';
  302.  
  303.                                             if( *src != '"' ) {
  304.                                                 quotes = TRUE;
  305.                                                 *dst++ = '"';
  306.                                                 len += 2;
  307.                                             }
  308.  
  309.                                             while( c = *src++,c )
  310.                                                 *dst++ = c;
  311.  
  312.                                             if( quotes ) *dst = '"';
  313.  
  314.                                             ArgLen[i] = len;
  315.                                         }
  316.                                     }
  317.                                 }
  318.                                 /*- arg not specified in template, check for WINDOW tooltype -*/
  319.                                 else if(!IsArg("WINDOW", src))
  320.                                 {
  321.                                     if((i = strlen(src)-6L) > 1L)
  322.                                     {
  323. #ifndef COMPILE_V39
  324.                                         if((ToolWindow = AllocRemember(remember, i, MEMF_ANY)))
  325. #else
  326.                                         if((ToolWindow = AllocPooled(pool, i)))
  327. #endif
  328.                                             CopyMem((src+7L), ToolWindow, i);
  329.                                     }
  330.                                     else ToolWindow = "CON:";
  331.                                 }
  332.                             }
  333.  
  334.                             tarray++;
  335.                         }
  336.                     }
  337.  
  338.                     FreeDiskObject(dobj);
  339.                 }
  340.  
  341.                 CurrentDir(olddir);
  342.             }
  343.  
  344.             /*- now copy all given args to a single line -*/
  345.             for(num = FileArgs = 0; FileArgs < MaxArgs; FileArgs++)
  346.                 num += ArgLen[FileArgs];
  347.  
  348.             if(num)
  349.             {
  350.                 nrdargs->RDArgs->RDA_Source.CS_Length = (num+=MaxArgs);
  351.  
  352.                 if((nrdargs->RDArgs->RDA_Source.CS_Buffer = ptr = AllocVec(num+1, MEMF_ANY)))
  353.                 {
  354.                     for(FileArgs = 0; FileArgs < MaxArgs; FileArgs++)
  355.                     {
  356.                         if((num = ArgLen[FileArgs]))
  357.                         {
  358.                             CopyMem(Args[FileArgs], ptr, num);
  359.                             ptr += num;
  360.                             *ptr++ = ' ';
  361.                         }
  362.                     }
  363.                 }
  364.                 else return(ERROR_NO_FREE_STORE);
  365.  
  366.                 *(ptr-1) = '\n';
  367.                 *ptr = '\0'; // not really needed
  368.  
  369.                 d(bug("CS_Buffer: %s", nrdargs->RDArgs->RDA_Source.CS_Buffer));
  370.             }
  371.             else
  372.             {
  373.                 nrdargs->RDArgs->RDA_Source.CS_Length = 1;
  374.                 if((nrdargs->RDArgs->RDA_Source.CS_Buffer = ptr = AllocVec(1, MEMF_ANY)))
  375.                     *ptr = '\n';
  376.             }
  377.         }
  378.  
  379.         /*- call ReadArgs() -*/
  380.         nrdargs->RDArgs->RDA_ExtHelp = nrdargs->ExtHelp;
  381.         if(!(nrdargs->FreeArgs = ReadArgs(nrdargs->Template, nrdargs->Parameters, nrdargs->RDArgs)))
  382.         {
  383.             d(bug("ReadArgs() error\n"));
  384.             return(IoErr());
  385.         }
  386.  
  387.         d(bug("ReadArgs() okay\n"));
  388.  
  389.         /*- when started from wb, open window if requested -*/
  390.         if(ToolWindow && WBStartup)
  391.         {
  392.             d(bug("WINDOW has been defined\n"));
  393.             if((nrdargs->WinFH = Open(ToolWindow, MODE_READWRITE)))
  394.             {
  395.                 d(bug("Opened WINDOW=%s\n", ToolWindow));
  396.                 nrdargs->OldInput = SelectInput(nrdargs->WinFH);
  397.                 nrdargs->OldOutput = SelectOutput(nrdargs->WinFH);
  398.             }
  399.             else return(IoErr());
  400.         }
  401.  
  402. #ifdef COMPILE_V39
  403.         if( pool ) {
  404.             DeletePool( pool );
  405.             nrdargs->Pool = NULL;
  406.         }
  407. #else
  408.         if( *remember ) {
  409.             FreeRemember( remember, TRUE );
  410.             nrdargs->Remember = NULL;
  411.         }
  412. #endif
  413.     }
  414.     else return(ERROR_NO_FREE_STORE);
  415.  
  416.     d(bug("--- EXIT ---\n"));
  417.  
  418.     return(RETURN_OK);
  419. }
  420.  
  421. /****************************************************************************/
  422.