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