home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classsource.lha / ClassSource / DOS / Files / files.c
Encoding:
C/C++ Source or Header  |  1995-02-12  |  13.3 KB  |  883 lines
  1. #include <classes/DOS/files.h>
  2.  
  3. #include <exec/memory.h>
  4. #include <string.h>
  5.  
  6. #pragma -
  7. #include <pragma/dos_lib.h>
  8. #include <pragma/exec_lib.h>
  9. #pragma +
  10.  
  11. InfoDataC::InfoDataC()
  12.     : DosObjectC(~0,AllocMem(sizeof(struct InfoData),MEMF_CLEAR))
  13. {
  14. }
  15.  
  16. InfoDataC::~InfoDataC()
  17. {
  18.     FreeMem(object(),sizeof(struct InfoData));
  19. }
  20.  
  21. InfoDataC &InfoDataC::operator= (const InfoDataC &s)
  22. {
  23.     if (this != &s)
  24.     {
  25.         if (only())
  26.         {
  27.             FreeMem(object(),sizeof(struct InfoData));
  28.         };
  29.         DosObjectC::operator=(s);
  30.     };
  31.     return *this;
  32. }
  33.  
  34. // *************************************************************
  35.  
  36.  
  37. PathStringC::PathStringC(LONG initsize)
  38.     : StringC()
  39. {
  40.     setBufferSize(initsize);
  41. }
  42.  
  43. PathStringC::PathStringC(const STRPTR s)
  44.     : StringC(s)
  45. {
  46. }
  47.  
  48. PathStringC::PathStringC(const PathStringC &s)
  49.     : StringC(s)
  50. {
  51. }
  52.  
  53. PathStringC::~PathStringC()
  54. {
  55. }
  56.  
  57. PathStringC &PathStringC::operator= (const PathStringC &s)
  58. {
  59.     if (this != &s)
  60.     {
  61.         StringC::operator= (s);
  62.     };
  63.     return *this;
  64. }
  65.  
  66. VOID PathStringC::setPath(STRPTR path)
  67. {
  68.     StringC::operator= (path);
  69. }
  70.  
  71. VOID PathStringC::addPart(STRPTR add)
  72. {
  73.     if (add)
  74.     {
  75.         for(;;) {
  76.             if ((BOOL) AddPart((STRPTR) buffer.buffer(),add,bufsize()))
  77.             {
  78.                 len = strlen((STRPTR) buffer.buffer());
  79.                 return;
  80.             };
  81.             doubleBuffer();
  82.         };
  83.     };
  84. }
  85.  
  86. VOID PathStringC::addSuffix(STRPTR suffix)
  87. {
  88.     if (suffix)
  89.     {
  90.         ULONG l = strlen(suffix) + strlen(path());
  91.         for(;;) {
  92.             if (l < bufsize())
  93.             {
  94.                 strcat(path(),suffix);
  95.                 len += strlen(suffix);
  96.                 return;
  97.             };
  98.             doubleBuffer();
  99.         };
  100.     };
  101. }
  102.  
  103. STRPTR PathStringC::filePart() const
  104. {
  105.     return (STRPTR) FilePart((STRPTR) this);
  106. }
  107.  
  108. VOID PathStringC::cutBeforeFilePart()
  109. {
  110.     STRPTR pp = FilePart((STRPTR) this);
  111.     if (pp)
  112.     {
  113.         strcpy((STRPTR) buffer.buffer(),pp);
  114.         len = strlen((STRPTR) buffer.buffer());
  115.     };
  116. }
  117.  
  118. VOID PathStringC::cutBehindPathPart()
  119. {
  120.     STRPTR pp = PathPart((STRPTR) buffer.buffer());
  121.     if (pp)
  122.     {
  123.         *pp = '\0';
  124.         len = strlen((STRPTR) buffer.buffer());
  125.     };
  126. }
  127.  
  128. VOID PathStringC::cutSuffix()
  129. {
  130.     STRPTR pp = FilePart((STRPTR) buffer.buffer());
  131.     if (pp)
  132.     {
  133.         LONG i = strlen(pp);
  134.         while (i >= 0 && pp[i] != '.')
  135.             i--;
  136.         if (i >= 0)
  137.             pp[i] = 0;
  138.         len = strlen((STRPTR) buffer.buffer());
  139.     };
  140. }
  141.  
  142. // *************************************************************
  143.  
  144. FileLockC::FileLockC()
  145. {
  146.     filelock = NULL;
  147. }
  148.  
  149. FileLockC::FileLockC(const FileLockC &s)
  150. {
  151.     if (s.filelock)
  152.     {
  153.         filelock = DupLock(s.filelock);
  154.     }
  155.     else
  156.         filelock = NULL;
  157. }
  158.  
  159. FileLockC::FileLockC(BPTR lock)
  160. {
  161.     if (lock)
  162.         filelock = DupLock(lock);
  163.     else
  164.         filelock = NULL;
  165. }
  166.  
  167. FileLockC::~FileLockC()
  168. {
  169.     unlock();
  170. }
  171.  
  172. FileLockC &FileLockC::operator= (const FileLockC &s)
  173. {
  174.     if (this != &s)
  175.     {
  176.         if (filelock)
  177.         {
  178.             UnLock(filelock);
  179.             filelock = NULL;
  180.         };
  181.         if (s.filelock)
  182.         {
  183.             filelock = DupLock(s.filelock);
  184.         };
  185.     };
  186.     return *this;
  187. }
  188.  
  189. BOOL FileLockC::lock(STRPTR name, LONG mode)
  190. {
  191.     if (!filelock)
  192.     {
  193.         filelock = Lock(name,mode);
  194.          return filelock != NULL;
  195.     };
  196.     return FALSE;
  197. }
  198.  
  199. BOOL FileLockC::duplicate(FileLockC &fromLock)
  200. {
  201.     if (!filelock && fromLock.filelock)
  202.     {
  203.         filelock = DupLock(fromLock.filelock);
  204.         return filelock != NULL;
  205.     };
  206.     return FALSE;
  207. }
  208.  
  209. BOOL FileLockC::duplicate(FileHandleC &fromHandle)
  210. {
  211.     if (!filelock && fromHandle.handle())
  212.     {
  213.         filelock = DupLockFromFH(fromHandle.handle());
  214.         return filelock != NULL;
  215.     };
  216.     return FALSE;
  217. }
  218.  
  219. VOID FileLockC::unlock()
  220. {
  221.     if (filelock)
  222.     {
  223.         UnLock(filelock);
  224.         filelock = NULL;
  225.     };
  226. }
  227.  
  228. BOOL FileLockC::changeMode(ULONG mode)
  229. {
  230.     if (filelock)
  231.     {
  232.         return ChangeMode(CHANGE_LOCK,filelock,mode);
  233.     };
  234.     return FALSE;
  235. }
  236.  
  237. BOOL FileLockC::sameDevice(FileLockC &other) const
  238. {
  239.     if (filelock && other.filelock)
  240.     {
  241.         return SameDevice(filelock,other.filelock);
  242.     };
  243.     return FALSE;
  244. }
  245.  
  246. BOOL FileLockC::sameLock(FileLockC &other) const
  247. {
  248.     if (filelock && other.filelock)
  249.     {
  250.         return SameLock(filelock,other.filelock);
  251.     };
  252.     return FALSE;
  253. }
  254.  
  255. BOOL FileLockC::nameOfLock(STRPTR buffer, LONG length) const
  256. {
  257.     if (filelock)
  258.     {
  259.         return NameFromLock(filelock,buffer,length);
  260.     };
  261.     return FALSE;
  262. }
  263.  
  264. BOOL FileLockC::nameOfLock(PathStringC &ps) const
  265. {
  266.     if (filelock)
  267.     {
  268.         for (;;) {
  269.             if (NameFromLock(filelock,ps.path(),ps.bufsize()))
  270.             {
  271.                 ps.shrinkBuffer();
  272.                 return TRUE;
  273.             };
  274.             if (IoErr() != ERROR_LINE_TOO_LONG)
  275.                 return FALSE;
  276.             ps.doubleBuffer();
  277.         };
  278.     };
  279.     return FALSE;
  280. }
  281.  
  282. BOOL FileLockC::examine(struct FileInfoBlock *fib) const
  283. {
  284.     if (filelock && fib)
  285.     {
  286.         return (BOOL) Examine(filelock,fib);
  287.     };
  288.     return FALSE;
  289. }
  290.  
  291. BOOL FileLockC::examine(class FileInfoBlockC &fib) const
  292. {
  293.     if (filelock)
  294.     {
  295.         return (BOOL) Examine(filelock,fib.object());
  296.     };
  297.     return FALSE;
  298. }
  299.  
  300. BOOL FileLockC::info(struct InfoData *id) const
  301. {
  302.     if (filelock && id)
  303.     {
  304.         return (BOOL) Info(filelock,id);
  305.     };
  306.     return FALSE;
  307. }
  308.  
  309. BOOL FileLockC::info(class InfoDataC &id) const
  310. {
  311.     if (filelock)
  312.     {
  313.         return (BOOL) Info(filelock,id.object());
  314.     };
  315.     return FALSE;
  316. }
  317.  
  318. LONG FileLockC::ioErr()
  319. {
  320.     return IoErr();
  321. }
  322.  
  323. // *************************************************************
  324.  
  325. DirLockC::DirLockC()
  326.     : FileLockC()
  327. {
  328. }
  329.  
  330. DirLockC::DirLockC(BPTR lock)
  331.     : FileLockC(lock)
  332. {
  333. }
  334.  
  335. BOOL DirLockC::create(STRPTR name)
  336. {
  337.     if (!filelock)
  338.     {
  339.         filelock = CreateDir(name);
  340.         return filelock != NULL;
  341.     };
  342.     return FALSE;
  343. }
  344.  
  345. BOOL DirLockC::parentOf(FileLockC &lock)
  346. {
  347.     if (!filelock && lock.filelock)
  348.     {
  349.         filelock = ParentDir(lock.filelock);
  350.         if (filelock)
  351.             return TRUE;
  352.         return ioErr() == 0;
  353.     };
  354.     return FALSE;
  355. }
  356.  
  357. BOOL DirLockC::parentOf(class FileHandleC &handle)
  358. {
  359.     if (!filelock && handle.handle())
  360.     {
  361.         filelock = ParentOfFH(handle.handle());
  362.         if (filelock)
  363.             return TRUE;
  364.         return ioErr() == 0;
  365.     };
  366.     return FALSE;
  367. }
  368.  
  369. BOOL DirLockC::fromCurrent()
  370. {
  371.     if (!filelock)
  372.     {
  373.         filelock = Lock("",SHARED_LOCK);
  374.         return filelock != NULL;
  375.     };
  376.     return FALSE;
  377. }
  378.  
  379. BOOL DirLockC::fromBootvolume()
  380. {
  381.     if (!filelock)
  382.     {
  383.         filelock = DupLock(NULL);
  384.         return filelock != NULL;
  385.     };
  386.     return FALSE;
  387. }
  388.  
  389. BOOL DirLockC::fromProgramDir()
  390. {
  391.     if (!filelock)
  392.     {
  393.         filelock = DupLock(GetProgramDir());
  394.         return filelock != NULL;
  395.     };
  396.     return FALSE;
  397. }
  398.  
  399. BOOL DirLockC::exAll(struct ExAllControl *eac,
  400.     APTR buffer, ULONG bufsize, ULONG type)
  401. {
  402.     if (filelock && eac)
  403.     {
  404.         return (BOOL) ExAll(filelock,(struct ExAllData *) buffer,
  405.             bufsize,type,eac);
  406.     };
  407.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  408.     return FALSE;
  409. }
  410.  
  411. BOOL DirLockC::exAll(ExAllControlC &eac,
  412.     APTR buffer, ULONG bufsize, ULONG type)
  413. {
  414.     if (filelock)
  415.     {
  416.         return (BOOL) ExAll(filelock,(struct ExAllData *) buffer,
  417.             bufsize,type,eac.object());
  418.     };
  419.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  420.     return FALSE;
  421. }
  422.  
  423. VOID DirLockC::exAllEnd(struct ExAllControl *eac,
  424.     APTR buffer, ULONG bufsize, ULONG type)
  425. {
  426.     if (filelock && eac)
  427.     {
  428.         ExAllEnd(filelock,(struct ExAllData *) buffer,
  429.             bufsize,type,eac);
  430.     };
  431.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  432. }
  433.  
  434. VOID DirLockC::exAllEnd(ExAllControlC &eac,
  435.     APTR buffer, ULONG bufsize, ULONG type)
  436. {
  437.     if (filelock)
  438.     {
  439.         ExAllEnd(filelock,(struct ExAllData *) buffer,
  440.             bufsize,type,eac.object());
  441.     };
  442.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  443. }
  444.  
  445. BOOL DirLockC::exNext(struct FileInfoBlock *fib)
  446. {
  447.     if (filelock && fib)
  448.     {
  449.         return (BOOL) ExNext(filelock,fib);
  450.     };
  451.     return FALSE;
  452. }
  453.  
  454. BOOL DirLockC::exNext(FileInfoBlockC &fib)
  455. {
  456.     if (filelock)
  457.     {
  458.         return (BOOL) ExNext(filelock,fib.object());
  459.     };
  460.     return FALSE;
  461. }
  462.  
  463. // *************************************************************
  464.  
  465. CurrentDirC::CurrentDirC()
  466. {
  467.     BPTR fl = Lock("",SHARED_LOCK);
  468.     if (fl)
  469.     {
  470.         filelock = CurrentDir(fl);
  471.     };
  472. }
  473.  
  474. CurrentDirC::CurrentDirC(STRPTR name)
  475. {
  476.     BPTR fl;
  477.     if (name)
  478.         fl = Lock(name,SHARED_LOCK)
  479.     else
  480.         fl = Lock("",SHARED_LOCK);
  481.     if (fl)
  482.     {
  483.         filelock = CurrentDir(fl);
  484.     };
  485. }
  486.  
  487. CurrentDirC::~CurrentDirC()
  488. {
  489.     if (filelock)
  490.         UnLock(CurrentDir(filelock));
  491. }
  492.  
  493. BOOL CurrentDirC::makeCurrent(DirLockC &s)
  494. {
  495.     BPTR fl;
  496.     if (s.lock() && filelock)
  497.     {
  498.         if (fl = DupLock(s.lock()))
  499.         {
  500.             UnLock(CurrentDir(fl));
  501.             return TRUE;
  502.         };
  503.     };
  504.     return FALSE;
  505. }
  506.  
  507. // *************************************************************
  508.  
  509. FileHandleC::FileHandleC()
  510. {
  511.     filehandle = NULL;
  512. }
  513.  
  514. FileHandleC::FileHandleC(const FileHandleC &s)
  515. {
  516.     BPTR fl;
  517.     filehandle = NULL;
  518.     if (s.filehandle)
  519.     {
  520.         if (fl = DupLockFromFH(s.filehandle))
  521.         {
  522.             if (!(filehandle = OpenFromLock(fl)))
  523.             {
  524.                 UnLock(fl);
  525.             };
  526.         };
  527.     };
  528. }
  529.  
  530. FileHandleC::~FileHandleC()
  531. {
  532.     close();
  533. }
  534.  
  535. FileHandleC &FileHandleC::operator= (const FileHandleC &s)
  536. {
  537.     if (this != &s)
  538.     {
  539.         BPTR fl;
  540.         close();
  541.         filehandle = NULL;
  542.         if (s.filehandle)
  543.         {
  544.             if (fl = DupLockFromFH(s.filehandle))
  545.             {
  546.                 if (!(filehandle = OpenFromLock(fl)))
  547.                 {
  548.                     UnLock(fl);
  549.                 };
  550.             };
  551.         };
  552.     };
  553.     return *this;
  554. }
  555.  
  556. BOOL FileHandleC::open(STRPTR name, LONG mode)
  557. {
  558.     if (!filehandle)
  559.     {
  560.         filehandle = Open(name,mode);
  561.         return filehandle != NULL;
  562.     };
  563.     return FALSE;
  564. }
  565.  
  566. BOOL FileHandleC::open(FileLockC &lock)
  567. {
  568.     if (!filehandle && lock.isLocked())
  569.     {
  570.         BPTR fl;
  571.         if (fl = DupLock(lock.lock()))
  572.         {
  573.             if (!(filehandle = OpenFromLock(fl)))
  574.             {
  575.                 UnLock(fl);
  576.             };
  577.             return filehandle != NULL;
  578.         };
  579.     };
  580.     return FALSE;
  581. }
  582.  
  583. BOOL FileHandleC::close()
  584. {
  585.     if (filehandle)
  586.     {
  587.         BOOL retval;
  588.         retval = Close(filehandle);
  589.         filehandle = NULL;
  590.         return retval;
  591.     };
  592.     return FALSE;
  593. }
  594.  
  595. BOOL FileHandleC::changeMode(ULONG mode)
  596. {
  597.     if (filehandle)
  598.     {
  599.         return (BOOL) ChangeMode(CHANGE_FH,filehandle,mode);
  600.     };
  601.     return FALSE;
  602. }
  603.  
  604. LONG FileHandleC::read(APTR buffer, LONG length)
  605. {
  606.     if (filehandle)
  607.     {
  608.         return Read(filehandle,buffer,length);
  609.     };
  610.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  611.     return -1;
  612. }
  613.  
  614. LONG FileHandleC::write(APTR buffer, LONG length)
  615. {
  616.     if (filehandle)
  617.     {
  618.         return Write(filehandle,buffer,length);
  619.     };
  620.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  621.     return -1;
  622. }
  623.  
  624. LONG FileHandleC::seek(LONG position, LONG mode)
  625. {
  626.     if (filehandle)
  627.     {
  628.         Seek(filehandle,position,mode);
  629.     };
  630.     SetIoErr(ERROR_SEEK_ERROR);
  631.     return -1;
  632. }
  633.  
  634. BOOL FileHandleC::eof()
  635. {
  636.     if (filehandle)
  637.     {
  638.         ULONG s = Seek(filehandle,0,OFFSET_CURRENT);
  639.         if (examine(fib))
  640.         {
  641.             if (fib.object()->fib_DirEntryType == ST_FILE ||
  642.                 fib.object()->fib_DirEntryType == ST_LINKFILE)
  643.             {
  644.                 return s == fib.object()->fib_Size;
  645.             };
  646.         };
  647.     };
  648.     return FALSE;
  649. }
  650.  
  651. LONG FileHandleC::fGetC()
  652. {
  653.     if (filehandle)
  654.     {
  655.         return FGetC(filehandle);
  656.     };
  657.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  658.     return -1;
  659. }
  660.  
  661. BOOL FileHandleC::fGets(STRPTR s, ULONG len)
  662. {
  663.     if (filehandle)
  664.     {
  665.         return FGets(filehandle,s,len) != NULL;
  666.  
  667.     };
  668.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  669.     return FALSE;
  670. }
  671.  
  672. BOOL FileHandleC::fPutC(ULONG c)
  673. {
  674.     if (filehandle)
  675.     {
  676.         return FPutC(filehandle,c) != -1;
  677.     };
  678.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  679.     return FALSE;
  680. }
  681.  
  682. BOOL FileHandleC::fPuts(STRPTR s)
  683. {
  684.     if (filehandle)
  685.     {
  686.         return (BOOL) !FPuts(filehandle,s);
  687.     };
  688.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  689.     return FALSE;
  690. }
  691.  
  692. ULONG FileHandleC::fRead(APTR buffer, ULONG len, ULONG blocks)
  693. {
  694.     if (filehandle)
  695.     {
  696.         return FRead(filehandle,buffer,len,blocks);
  697.     };
  698.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  699.     return 0;
  700. }
  701.  
  702. ULONG FileHandleC::fWrite(APTR buffer, ULONG len, ULONG blocks)
  703. {
  704.     if (filehandle)
  705.     {
  706.         return FWrite(filehandle,buffer,len,blocks);
  707.     };
  708.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  709.     return 0;
  710. }
  711.  
  712. LONG FileHandleC::fPrintF(STRPTR s, LONG *args)
  713. {
  714.     if (filehandle)
  715.     {
  716.         return VFPrintf(filehandle, s, args);
  717.     };
  718.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  719.     return -1;
  720. }
  721.  
  722. LONG FileHandleC::fPrintF(STRPTR s, ...)
  723. {
  724.     if (filehandle)
  725.     {
  726.         return VFPrintf(filehandle, s, (LONG *) (((ULONG) &s) + 4));
  727.     };
  728.     SetIoErr(ERROR_REQUIRED_ARG_MISSING);
  729.     return -1;
  730. }
  731.  
  732. VOID FileHandleC::fWriteF(STRPTR s, LONG *args)
  733. {
  734.     if (filehandle)
  735.     {
  736.         VFWritef(filehandle, s, args);
  737.     };
  738. }
  739.  
  740. VOID FileHandleC::fWriteF(STRPTR s, ...)
  741. {
  742.     if (filehandle)
  743.     {
  744.         VFWritef(filehandle, s, (LONG *) (((ULONG) &s) + 4));
  745.     };
  746. }
  747.  
  748. VOID FileHandleC::unGetC(LONG c)
  749. {
  750.     if (filehandle)
  751.     {
  752.         UnGetC(filehandle,c);
  753.     };
  754. }
  755.  
  756. BOOL FileHandleC::flush()
  757. {
  758.     if (filehandle)
  759.     {
  760.         return Flush(filehandle);
  761.     };
  762.     return FALSE;
  763. }
  764.  
  765. BOOL FileHandleC::setVBuf(APTR buffer, LONG mode, LONG bufsize)
  766. {
  767.     if (filehandle)
  768.     {
  769.         return !((BOOL) SetVBuf(filehandle,(char *) buffer, mode, bufsize));
  770.     };
  771.     return FALSE;
  772. }
  773.  
  774. BOOL FileHandleC::waitForChar(ULONG micros)
  775. {
  776.     if (filehandle)
  777.     {
  778.         return WaitForChar(filehandle,micros);
  779.     };
  780.     return FALSE;
  781. }
  782.  
  783. BOOL FileHandleC::isInteractive()
  784. {
  785.     if (filehandle)
  786.     {
  787.         return IsInteractive(filehandle);
  788.     };
  789.     return FALSE;
  790. }
  791.  
  792. BOOL FileHandleC::nameOfHandle(STRPTR buffer, LONG length) const
  793. {
  794.     if (filehandle)
  795.     {
  796.         return NameFromFH(filehandle, buffer, length);
  797.     };
  798.     return FALSE;
  799. }
  800.  
  801. BOOL FileHandleC::nameOfHandle(PathStringC &ps) const
  802. {
  803.     if (filehandle)
  804.     {
  805.         for (;;) {
  806.             if (NameFromFH(filehandle, ps.path(),ps.bufsize()))
  807.             {
  808.                 ps.shrinkBuffer();
  809.                 return TRUE;
  810.             };
  811.             if (IoErr() != ERROR_LINE_TOO_LONG)
  812.                 return FALSE;
  813.             ps.doubleBuffer();
  814.         };
  815.     };
  816.     return FALSE;
  817. }
  818.  
  819. BOOL FileHandleC::examine(struct FileInfoBlock *fib) const
  820. {
  821.     if (filehandle && fib)
  822.     {
  823.         return (BOOL) ExamineFH(filehandle,fib);
  824.     };
  825.     return FALSE;
  826. }
  827.  
  828. BOOL FileHandleC::examine(class FileInfoBlockC &fib) const
  829. {
  830.     if (filehandle)
  831.     {
  832.         return (BOOL) ExamineFH(filehandle,fib.object());
  833.     };
  834.     return FALSE;
  835. }
  836.  
  837. LONG FileHandleC::setSize(LONG offset, LONG mode)
  838. {
  839.     if (filehandle)
  840.     {
  841.         return SetFileSize(filehandle,offset,mode);
  842.     };
  843.     return -1;
  844. }
  845.  
  846. // *************************************************************
  847.  
  848. InputHandleC::InputHandleC()
  849. {
  850.     filehandle = Input();
  851. }
  852.  
  853. InputHandleC::~InputHandleC()
  854. {
  855.     close();
  856. }
  857.  
  858. BOOL InputHandleC::close()
  859. {
  860.     filehandle = NULL;
  861.     return FALSE;
  862. }
  863.  
  864. // *************************************************************
  865.  
  866. OutputHandleC::OutputHandleC()
  867. {
  868.     filehandle = Output();
  869. }
  870.  
  871. OutputHandleC::~OutputHandleC()
  872. {
  873.     close();
  874. }
  875.  
  876. BOOL OutputHandleC::close()
  877. {
  878.     filehandle = NULL;
  879.     return FALSE;
  880. };
  881.  
  882. // *************************************************************
  883.