home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Utilities / Converters / Convert_RTF / Source / shared.subproj / RCS / TextFile.m,v < prev   
Encoding:
Text File  |  1995-06-12  |  12.5 KB  |  402 lines
  1. head     1.3;
  2. branch   ;
  3. access   ;
  4. symbols  beta10:1.2;
  5. locks    death:1.3;
  6. comment  @@;
  7.  
  8.  
  9. 1.3
  10. date     93.04.04.23.45.30;  author death;  state Exp;
  11. branches ;
  12. next     1.2;
  13.  
  14. 1.2
  15. date     93.01.10.15.08.57;  author death;  state Exp;
  16. branches ;
  17. next     1.1;
  18.  
  19. 1.1
  20. date     92.07.26.13.58.54;  author death;  state Exp;
  21. branches ;
  22. next     ;
  23.  
  24.  
  25. desc
  26. @Initial revision of an object for dealing with text files...
  27. @
  28.  
  29.  
  30. 1.3
  31. log
  32. @Sun Apr  4 23:45:30 PDT 1993
  33. @
  34. text
  35. @#import <streams/streams.h>
  36. #import <stdio.h>
  37. #import <string.h>    // for strlen
  38. #import "TextFile.h"
  39.  
  40.  
  41. //    We are assuming our superclass has already imported this.  If not, you'll get an
  42. //    error below, indicating that this wont work (see  LookAtNextCharacter
  43. //    #import <streams/streams.h>
  44.  
  45. @@implementation TextFile
  46.  
  47.  
  48. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  49. //    Method:        GetHexByte
  50. //    Parameters:    none
  51. //    Returns:     The byte corresponding to the hex values in the file
  52. //    Stores:        error info
  53. //                The byte corresponding to the hex values in the file
  54. //    Description:
  55. //        This reads in a pair of hex difits, and returns their integer form (i.e reading
  56. //        '41' will be returned as the integer 65.
  57. //    *WARNING*:
  58. //        This assumes it is working as a subclass of a File object that is going to
  59. //        have a NXstream open.
  60. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  61. - (Byte) GetHexByte
  62. {
  63.     Integer        theInt = 0;
  64.     Integer        num;
  65.     
  66.     [self ResetResults];
  67.     if (FileIsOpen == NO)
  68.         [self StoreErrorCode: ERR_FILENOTOPEN AndText: "Unable to read from a closed file"];
  69.     else
  70.     {
  71.         num = NXScanf(TheFile, "%2x", &theInt);
  72.         if (num != 1)
  73.             [self StoreErrorCode: ERR_BADREAD AndText: "Unable to read a hex value"];
  74.         else
  75.             [self StoreErrorCode: ERR_OK AndText: "Got the byte just fine"];
  76.     }
  77.     [self StoreInteger: theInt];
  78.     return theInt;
  79. }
  80.  
  81.  
  82. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  83. //    Method:        GetNumber
  84. //    Parameters:    none
  85. //    Returns:     The number read from the text file
  86. //    Stores:        error info
  87. //                The number read from the text file
  88. //    Description:
  89. //        This reads in a series of characters, and converts them to a signed integer
  90. //        value.
  91. //    *WARNING*:
  92. //        This assumes it is working as a subclass of a File object that is going to
  93. //        have a NXstream open.
  94. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  95. - (Integer) GetNumber
  96. {
  97.     Integer        theInt = 0;
  98.     Integer        num;
  99.     
  100.     [self ResetResults];
  101.     if (FileIsOpen == NO)
  102.         [self StoreErrorCode: ERR_FILENOTOPEN AndText: "Unable to read from a closed file"];
  103.     else
  104.     {
  105.         num = NXScanf(TheFile, "%d", &theInt);
  106.         if (num != 1)
  107.             [self StoreErrorCode: ERR_BADREAD AndText: "Unable to read a hex value"];
  108.         else
  109.             [self StoreErrorCode: ERR_OK AndText: "Got the byte just fine"];
  110.     }
  111.     [self StoreInteger: theInt];
  112.     return theInt;
  113. }
  114.  
  115.  
  116.  
  117. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  118. //    Method:        GetCharacter:
  119. //    Parameters:    none
  120. //    Returns:     The character found
  121. //    Stores:        error info
  122. //                The character found
  123. //    Description:
  124. //        This merely reads a character in from the file and returns it, unless an error
  125. //        occurrs.  Note that if the file is open, our error results are those which
  126. //        Read:BytesInto: generates.
  127. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  128. - (Character) GetCharacter
  129. {
  130.     Character    theBuffer = NullCharacter;
  131.     
  132.     [self ResetResults];
  133.     if (FileIsOpen == NO)
  134.         [self StoreErrorCode: ERR_FILENOTOPEN AndText: "Unable to read from a closed file"];
  135.     else
  136.     {
  137.         [self Read: 1 BytesInto: &theBuffer];
  138.         if ([self   GetErrorCode] != ERR_OK)
  139.         {
  140.             [self StoreErrorCode: ERR_BADREAD AndText: "Read error.  let's call it eof"];
  141.             FileLocation = fileAtEOF;
  142.         }
  143.         else
  144.             [self StoreErrorCode: ERR_OK AndText: "OK"];
  145.     }
  146.     
  147.     [self StoreCharacter: theBuffer];
  148.     return theBuffer;
  149. }
  150.  
  151.  
  152. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  153. //    Method:        LookAtNextCharacter
  154. //    Parameters:    none
  155. //    Returns:     The character found
  156. //    Stores:        error info
  157. //                The character found
  158. //    Description:
  159. //        This locates the next character waiting to be read, and returns it without
  160. //        moving past it.
  161. //    *WARNING*:
  162. //        This assumes it is working as a subclass of a File object that is going to
  163. //        have a NXstream open that can do ungetting!!!!!!
  164. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  165. - (Character) LookAtNextCharacter
  166. {
  167.     Character    theCharacter = NullCharacter;
  168.     
  169.     [self ResetResults];
  170.     if (FileIsOpen == NO)
  171.         [self StoreErrorCode: ERR_FILENOTOPEN AndText: "Unable to peek at a closed file"];
  172.     else
  173.     {
  174.         if (NXAtEOS(TheFile) == YES)
  175.         {
  176.             [self StoreErrorCode: ERR_BADREAD AndText: "Read error.  let's call it eof"];
  177.             FileLocation = fileAtEOF;
  178.         }
  179.         else
  180.         {
  181.             //
  182.             //    NeXT doesn't document what error codes these generate, very well..
  183.             //
  184.             theCharacter =  NXGetc(TheFile);
  185.             NXUngetc(TheFile);
  186.             [self StoreErrorCode: ERR_OK AndText: "Read the character OK"];
  187.         }
  188.     }
  189.     [self StoreCharacter: theCharacter];
  190.     return theCharacter;
  191. }
  192.  
  193.  
  194.  
  195. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  196. //    Method:        UnGetCharacter
  197. //    Parameters:    none
  198. //    Returns:     none
  199. //    Stores:        error info
  200. //    Description:
  201. //        Thgis simply ungets whatever the last character got was.
  202. //        (due to NeXT limitiations, you can't call this twice in a row to unget the last 2)
  203. //    *WARNING*:
  204. //        This assumes it is working as a subclass of a File object that is going to
  205. //        have a NXstream open that can do ungetting!!!!!!
  206. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  207. - UnGetCharacter
  208. {
  209.     [self ResetResults];
  210.     if (FileIsOpen == NO)
  211.         [self StoreErrorCode: ERR_FILENOTOPEN AndText: "Unable to peek at a closed file"];
  212.     else
  213.     {
  214.         if (NXAtEOS(TheFile) == YES)
  215.         {
  216.             [self StoreErrorCode: ERR_BADREAD AndText: "Read error.  let's call it eof"];
  217.             FileLocation = fileAtEOF;
  218.         }
  219.         else
  220.         {
  221.             //
  222.             //    NeXT doesn't document what error codes these generate, very well..
  223.             //
  224.             NXUngetc(TheFile);
  225.             [self StoreErrorCode: ERR_OK AndText: "Ungot it ok"];
  226.         }
  227.     }
  228.     return self;
  229. }
  230.  
  231.  
  232.  
  233. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  234. //    Method:        WriteText:
  235. //    Parameters:    the line of text we are to write
  236. //    Returns:     self
  237. //    Description:
  238. //        Writes the content6s of theLine out litterally, with no additional fiddling with.
  239. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  240. - WriteText: (CString) theLine
  241. {
  242.     [self Write: strlen(theLine) BytesFrom: (ByteString) theLine];
  243.     return self;
  244. }
  245.  
  246. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  247. //    Method:        WriteTextLine:
  248. //    Parameters:    the line of text we are to write
  249. //    Returns:     self
  250. //    Description:
  251. //        This writes out the speciied text, and follows it with a newline.
  252. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  253. - WriteTextLine: (CString) theLine
  254. {
  255.     [self Write: strlen(theLine) BytesFrom: (ByteString) theLine];
  256.     [self Write: 1 BytesFrom: (ByteString) "\n"];
  257.     return self;
  258. }
  259.  
  260.  
  261.  
  262. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  263. //    Method:        WriteTextUsing:WithFormat:
  264. //    Parameters:    A buffer provided by the caller, a format, and N arguments to be written
  265. //    Returns:     self
  266. //    Stores:        nothing (bug)
  267. //    Description:
  268. //        This writes out a text string given variable arguments
  269. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  270. - WriteTextUsing: (CString) buffer WithFormat: (CString) format, ...;
  271. {
  272.     va_list parameter_list;
  273.     
  274.     va_start(parameter_list, format);
  275.  
  276.     vsprintf(buffer, format, parameter_list);      // doc implies this does a va_end
  277.  
  278.     [self Write: strlen(buffer) BytesFrom: (ByteString) buffer];
  279.     return self;
  280. }
  281.  
  282.  
  283. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  284. //    Method:        AppendFrom:
  285. //    Parameters:    Another file object (opened)
  286. //    Returns:     self
  287. //    Stores:        nothing (bug)
  288. //    Description:
  289. //        This is a crude little routine that simply takes a file, assumes it is open and in
  290. //        place, reads the whole file into memory, and then writs it out into itself.
  291. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  292. - AppendFrom: sourceFile
  293. {
  294.     Integer size;
  295.     ByteString    buffer;
  296.  
  297.     size = [sourceFile FileSize];
  298.     buffer = NewByteString(size);
  299.     [sourceFile   MoveTo: 0];
  300.     [sourceFile Read: size BytesInto: buffer];
  301.     [self Write: size BytesFrom: buffer];
  302.     FreeByteString(buffer);
  303.     return self;
  304. }
  305.  
  306. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  307. //    Method:        WriteInteger:
  308. //    Parameters:
  309. //        An integer
  310. //    Returns:     self
  311. //    Stores:        none  explicitly (subcalls may)
  312. //    Description:
  313. //        This simply writes out an integer with a trailing space.  ooh ahh. 
  314. //    Bugs:
  315. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  316. - WriteInteger: (Integer) theInt
  317. {
  318.     CString    temp    = NewCString(15);
  319.     
  320.     [self   WriteTextUsing: temp WithFormat: "%d ", theInt];
  321.     
  322.     FreeCString(temp);
  323.     return self;
  324. }
  325.  
  326. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  327. //    Method:        WritePositiveInteger:
  328. //    Parameters:
  329. //        An integer
  330. //    Returns:     self
  331. //    Stores:        none  explicitly (subcalls may)
  332. //    Description:
  333. //        This simply writes out a positive integer with a trailing space.  yawn.
  334. //    Bugs:
  335. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  336. - WritePositiveInteger: (PositiveInteger) theInt
  337. {
  338.     CString    temp    = NewCString(15);
  339.     
  340.     [self   WriteTextUsing: temp WithFormat: "%u ", theInt];
  341.     
  342.     FreeCString(temp);
  343.     return self;
  344. }
  345.  
  346. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  347. //    Method:        WriteReal:
  348. //    Parameters:    A real number
  349. //    Returns:     self
  350. //    Stores:        none  explicitly (subcalls may)
  351. //    Description:
  352. //        This simply writes out a Real number with a trailing space..
  353. //    Bugs:
  354. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  355. - WriteReal: (Real) theReal
  356. {
  357.     CString    temp    = NewCString(31);
  358.     
  359.     [self   WriteTextUsing: temp WithFormat: "%.15f ", theReal];
  360.     
  361.     FreeCString(temp);
  362.     return self;
  363. }
  364.  
  365.  
  366. @@end@
  367.  
  368.  
  369. 1.2
  370. log
  371. @Sun Jan 10 15:08:57 PST 1993
  372. @
  373. text
  374. @@
  375.  
  376.  
  377. 1.1
  378. log
  379. @Initial revision
  380. @
  381. text
  382. @d8 1
  383. a8 1
  384. //    error below, indicating that this wont work (see LookAtNextCharacter
  385. d140 14
  386. a153 6
  387.         //
  388.         //    NeXT doesn't document what error codes these generate, very well..
  389.         //
  390.         theCharacter =  NXGetc(TheFile);
  391.         NXUngetc(TheFile);
  392.         [self StoreErrorCode: ERR_OK AndText: "Read the character OK"];
  393. d180 13
  394. a192 5
  395.         //
  396.         //    NeXT doesn't document what error codes these generate, very well..
  397.         //
  398.         NXUngetc(TheFile);
  399.         [self StoreErrorCode: ERR_OK AndText: "Ungot it ok"];
  400. d248 82
  401. @
  402.