home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / DOS / Arguments / Arguments.c
Encoding:
C/C++ Source or Header  |  1995-02-12  |  3.5 KB  |  234 lines
  1. #include <classes/DOS/Arguments.h>
  2.  
  3. #include <exec/memory.h>
  4.  
  5. #pragma -
  6. #include <pragma/exec_lib.h>
  7. #include <pragma/dos_lib.h>
  8. #pragma +
  9.  
  10. ArgsC::ArgsC(STRPTR argTemplate, struct RDArgs *rdargs)
  11. {
  12.     args = NULL;
  13.     argarray = NULL;
  14.     templ = NULL;
  15.     read(argTemplate, rdargs);
  16. }
  17.  
  18. ArgsC::ArgsC(STRPTR argTemplate, RDArgsC &rdargs)
  19. {
  20.     args = NULL;
  21.     argarray = NULL;
  22.     templ = NULL;
  23.     read(argTemplate, rdargs.object());
  24. }
  25.  
  26. ArgsC::ArgsC(const ArgsC &s)
  27. {
  28.     args = NULL;
  29.     argarray = NULL;
  30.     templ = NULL;
  31.     read(s.templ, s.args);
  32. }
  33.  
  34. ArgsC::~ArgsC()
  35. {
  36.     free();
  37. }
  38.  
  39. ArgsC &ArgsC::operator= (const ArgsC &s)
  40. {
  41.     if (this != &s)
  42.     {
  43.         free();
  44.         args = NULL;
  45.         argarray = NULL;
  46.         templ = NULL;
  47.         read(s.templ, s.args);
  48.     };
  49.     return *this;
  50. }
  51.  
  52. VOID ArgsC::read(STRPTR argTemplate, struct RDArgs *rdargs)
  53. {
  54.     free();
  55.     templ = argTemplate;
  56.     if (argTemplate)
  57.     {
  58.         STRPTR t = argTemplate;
  59.         argcount = 1;
  60.         while (*t != '\0')
  61.         {
  62.             if (*t == ',')
  63.                 argcount++;
  64.             t++;
  65.         };
  66.         if (argarray = (ULONG *) AllocMem(argcount*4,MEMF_CLEAR))
  67.         {
  68.             args = ReadArgs(argTemplate,(LONG *) argarray,rdargs);
  69.             if (!args)
  70.                 throw RDArgsX();
  71.         }
  72.         else
  73.             throw MemoryX(argcount*4);
  74.     };
  75. }
  76.  
  77. VOID ArgsC::free()
  78. {
  79.     if (args)
  80.     {
  81.         FreeArgs(args);
  82.         args = NULL;
  83.     };
  84.     if (argarray)
  85.     {
  86.         FreeMem(argarray,argcount*4);
  87.         argarray = NULL;
  88.     };
  89. }
  90.  
  91. STRPTR ArgsC::getStr(LONG i, STRPTR dfault) const
  92. {
  93.     if (((ULONG) i) < argcount && argarray)
  94.     {
  95.         if ((STRPTR) argarray[i])
  96.             return (STRPTR) argarray[i];
  97.     };
  98.     return dfault;
  99. }
  100.  
  101. STRPTR ArgsC::getStr(STRPTR keyword, STRPTR dfault) const
  102. {
  103.     if (keyword && templ && argarray)
  104.     {
  105.         LONG i = FindArg(templ,keyword);
  106.         if (i >= 0 && (STRPTR) argarray[i])
  107.             return (STRPTR) argarray[i];
  108.     };
  109.     return dfault;
  110. }
  111.  
  112. LONG ArgsC::getNumber(LONG i, LONG dfault) const
  113. {
  114.     if (((ULONG) i) < argcount && argarray)
  115.     {
  116.         if ((LONG *) argarray[i])
  117.             return *((LONG *) argarray[i]);
  118.     };
  119.     return dfault;
  120. }
  121.  
  122. LONG ArgsC::getNumber(STRPTR keyword, LONG dfault) const
  123. {
  124.     if (keyword && templ && argarray)
  125.     {
  126.         LONG i = FindArg(templ,keyword);
  127.         if (i >= 0 && (LONG *) argarray[i])
  128.             return *((LONG *) argarray[i]);
  129.     };
  130.     return dfault;
  131. }
  132.  
  133. BOOL ArgsC::getSwitch(LONG i) const
  134. {
  135.     if (((ULONG) i) < argcount && argarray)
  136.     {
  137.         return (BOOL) argarray[i];
  138.     };
  139.     return FALSE;
  140. }
  141.  
  142. BOOL ArgsC::getSwitch(STRPTR keyword) const
  143. {
  144.     if (keyword && templ && argarray)
  145.     {
  146.         LONG i = FindArg(templ,keyword);
  147.         if (i >= 0)
  148.             return (BOOL) argarray[i];
  149.     };
  150.     return FALSE;
  151. }
  152.  
  153. // *************************************************************
  154.  
  155. ArgsMCursorC::ArgsMCursorC(ArgsC &args, LONG i)
  156. {
  157.     marg = NULL;
  158.     if (((ULONG) i) < args.argcount && args.argarray)
  159.     {
  160.         marg = (ULONG *) args.argarray[i];
  161.     };
  162.     first();
  163. }
  164.  
  165. ArgsMCursorC::ArgsMCursorC(ArgsC &args, STRPTR keyword)
  166. {
  167.     marg = NULL;
  168.     if (keyword && args.templ && args.argarray)
  169.     {
  170.         LONG i = FindArg(args.templ,keyword);
  171.         if (i >= 0)
  172.         {
  173.             marg = (ULONG *) args.argarray[i];
  174.         };
  175.     };
  176.     first();
  177. }
  178.  
  179. ArgsMCursorC::ArgsMCursorC(const ArgsMCursorC &s)
  180. {
  181.     marg = s.marg;
  182.     first();
  183. }
  184.  
  185. ArgsMCursorC &ArgsMCursorC::operator= (const ArgsMCursorC &s)
  186. {
  187.     if (this != &s)
  188.     {
  189.         marg = s.marg;
  190.         first();
  191.     };
  192.     return *this;
  193. }
  194.  
  195. ULONG ArgsMCursorC::count() const
  196. {
  197.     ULONG *a = marg;
  198.     ULONG c = 0;
  199.     if (!a)
  200.         return 0;
  201.     while (*a) {
  202.         a++;
  203.         c++;
  204.     };
  205.     return c;
  206. }
  207.  
  208. VOID ArgsMCursorC::first()
  209. {
  210.     arg = marg;
  211. };
  212.  
  213. BOOL ArgsMCursorC::isDone() const
  214. {
  215.     return arg ? *arg == 0 : TRUE;
  216. }
  217.  
  218. VOID ArgsMCursorC::next()
  219. {
  220.     if (!isDone())
  221.         arg++;
  222. }
  223.  
  224. STRPTR ArgsMCursorC::itemStr() const
  225. {
  226.     return isDone() ? NULL : (STRPTR) *arg;
  227. }
  228.  
  229. LONG ArgsMCursorC::itemNumber() const
  230. {
  231.     return isDone() ? 0 : *((LONG *) *arg);
  232. }
  233.  
  234.