home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / var / part01 < prev    next >
Encoding:
Text File  |  1992-08-21  |  53.9 KB  |  2,125 lines
  1. Newsgroups: comp.sources.misc
  2. From: tlhouns@srv.pacbell.com (Lee Hounshell)
  3. Subject:  v31i091:  var - a C++ string class library, Part01/02
  4. Message-ID: <csm-v31i091=var.104945@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: c06ffbe54ada717d84c18d0bb446b631
  6. Date: Fri, 21 Aug 1992 15:50:16 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: tlhouns@srv.pacbell.com (Lee Hounshell)
  10. Posting-number: Volume 31, Issue 91
  11. Archive-name: var/part01
  12. Environment: C++
  13.  
  14. This is "var", a C++ object library that is kinda like a "super-string" class.
  15. The var class does a pretty good job of offering a data object that assumes
  16. its "type" at run time, based on context of use.  Rarely will you need to
  17. declare int's, or longs, or doubles or char[] or even string objects again!
  18. "Var" does it all (or at least tries to).
  19.  
  20.         + var will do base data types (eg: int, long, char *, float, string ...)        + var will do arithmetic
  21.         + var will do strings and operations on strings
  22.         + var will do sub-strings and operations on sub-strings
  23.         + var will intelligently "mix" operations between mixed types
  24.         + var will do formatted output using the stream library
  25.         + individual vars can be "staticly" typed, or they can assume
  26.           type at runtime, based on context.
  27.  
  28. To use this class, simply type make and a library file "libvar.a" will be
  29. created.  This class has been used extensively here at Pacific Bell as a
  30. base class in development of our own internal C++ class libraries. I've
  31. even used "var" as the YYSTYPE type inside yacc/lex programs!!
  32.  
  33. If there is sufficient interest in "var" I may post a few other "base" C++
  34. classes that I've developed.. such as an "associative array" class that uses
  35. a "var" to index another "var."
  36.  
  37. If you like (or dislike) var, please drop me a line.
  38. Mail bug reports and comments to:
  39. tlhouns@srv.pacbell.com
  40.  
  41.  -Lee
  42. -------
  43. #! /bin/sh
  44. # This is a shell archive.  Remove anything before this line, then feed it
  45. # into a shell via "sh file" or similar.  To overwrite existing files,
  46. # type "sh file -c".
  47. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  48. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  49. # Contents:  README LEGAL_NOTICE var.3++ var.C
  50. # Wrapped by kent@sparky on Fri Aug 21 10:47:44 1992
  51. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  52. echo If this archive is complete, you will see the following message:
  53. echo '          "shar: End of archive 1 (of 2)."'
  54. if test -f 'README' -a "${1}" != "-c" ; then 
  55.   echo shar: Will not clobber existing file \"'README'\"
  56. else
  57.   echo shar: Extracting \"'README'\" \(1356 characters\)
  58.   sed "s/^X//" >'README' <<'END_OF_FILE'
  59. X
  60. XThis is "var", a C++ object library that is kinda like a "super-string" class.
  61. XThe var class does a pretty good job of offering a data object that assumes
  62. Xits "type" at run time, based on context of use.  Rarely will you need to
  63. Xdeclare int's, or longs, or doubles or char[] or even string objects!
  64. X"Var" does it all (or at least tries to).
  65. X
  66. X    + var will do base data types (eg: int, long, char *, float, string ...)
  67. X    + var will do arithmetic
  68. X    + var will do strings and operations on strings
  69. X    + var will do sub-strings and operations on sub-strings
  70. X    + var will intelligently "mix" operations between mixed types
  71. X    + var will do formatted output using the stream library
  72. X    + individual vars can be "staticly" typed, or they can assume
  73. X      type at runtime, based on context.
  74. X
  75. XTo use this class, simply type make and a library file "libvar.a" will be
  76. Xcreated.  This class has been used extensively here at Pacific Bell as a
  77. Xbase class in development of our own internal C++ class libraries. I've
  78. Xeven used "var" as the YYSTYPE type inside yacc/lex programs!!
  79. X
  80. XIf there is sufficient interest in "var" I may post a few other "base" C++
  81. Xclasses that I've developed.. such as an "associative array" class that uses
  82. Xa "var" to index another "var."
  83. X
  84. XIf you like (or dislike) var, please drop me a line.
  85. XMail bug reports and comments to:
  86. Xtlhouns@srv.pacbell.com
  87. X
  88. X-Lee
  89. END_OF_FILE
  90.   if test 1356 -ne `wc -c <'README'`; then
  91.     echo shar: \"'README'\" unpacked with wrong size!
  92.   fi
  93.   # end of 'README'
  94. fi
  95. if test -f 'LEGAL_NOTICE' -a "${1}" != "-c" ; then 
  96.   echo shar: Will not clobber existing file \"'LEGAL_NOTICE'\"
  97. else
  98.   echo shar: Extracting \"'LEGAL_NOTICE'\" \(1388 characters\)
  99.   sed "s/^X//" >'LEGAL_NOTICE' <<'END_OF_FILE'
  100. X
  101. X        Any use of this source code must include, in the user documentation
  102. X        and internal comments to the code, and notices to the end user as
  103. X        follows:
  104. X
  105. X    Copyright (c) 1992 Lee Hounshell
  106. X 
  107. X    LEE HOUNSHELL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF
  108. X        THIS SOURCE CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS"
  109. X        WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.  LEE HOUNSHELL
  110. X    SEVERALLY AND INDIVIDUALLY, DISCLAIM ALL WARRANTIES WITH REGARD
  111. X    TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
  112. X    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO
  113. X    EVENT SHALL LEE HOUNSHELL BE LIABLE FOR ANY SPECIAL, INDIRECT,
  114. X    INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
  115. X    RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  116. X    OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  117. X    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE CODE.
  118. X
  119. X    Permission to use, copy, modify, and distribute this software
  120. X    and its documentation for any purpose and without fee is hereby
  121. X    granted, provided that the above copyright notice appear in all
  122. X    copies and that both that copyright notice and this permission
  123. X    notice appear in supporting documentation, and that the name of
  124. X    Lee Hounshell not be used in advertising in publicity pertaining
  125. X    to distribution of the software without specific, written prior
  126. X    permission.
  127. X
  128. END_OF_FILE
  129.   if test 1388 -ne `wc -c <'LEGAL_NOTICE'`; then
  130.     echo shar: \"'LEGAL_NOTICE'\" unpacked with wrong size!
  131.   fi
  132.   # end of 'LEGAL_NOTICE'
  133. fi
  134. if test -f 'var.3++' -a "${1}" != "-c" ; then 
  135.   echo shar: Will not clobber existing file \"'var.3++'\"
  136. else
  137.   echo shar: Extracting \"'var.3++'\" \(15188 characters\)
  138.   sed "s/^X//" >'var.3++' <<'END_OF_FILE'
  139. X.po 6
  140. X.TH VAR 3++ "1/92" "Version 1.0" "Variable Base Type String Class Library"
  141. X
  142. X.SH CLASS
  143. XVAR    \- Variable Base Type String Class Library
  144. X.SH SYNOPSIS
  145. X.B #include     <var.H>
  146. X.PP
  147. X.nf
  148. X.ta.5i 1.0i 4.0i
  149. X\fB
  150. Xclass var {
  151. X
  152. X  public:
  153. X    // Constructors & Destructors
  154. X    var(void);                    // constructor
  155. X    var(const varsize &);            // constructor
  156. X    var(const char *);                // constructor
  157. X    var(const char);                // constructor
  158. X    var(const short);                // constructor
  159. X    var(const unsigned short);            // constructor
  160. X    var(const int);                // constructor
  161. X    var(const unsigned int);            // constructor
  162. X    var(const long);                // constructor
  163. X    var(const unsigned long);            // constructor
  164. X    var(const double);                // constructor
  165. X    var(const var &);                // copy constructor
  166. X    ~var(void);                    // destructor
  167. X
  168. X    // Operators
  169. X    var & operator = (const char *);        // assignment
  170. X    var & operator = (const var &);        // assignment
  171. X    char & operator [] (const int);        // indexing
  172. X    subvar & operator () (int, int) const;    // substring
  173. X    subvar & operator () (const int) const;    // substring
  174. X    friend ostream & operator << (ostream &, const var &); // output
  175. X    friend istream & operator >> (istream &, var &); // input
  176. X    friend class subvar;            // substring
  177. X
  178. X    // More Operators (used for arithmetic type extension)
  179. X    var & operator = (const char);        // assignment
  180. X    var & operator = (const short);        // assignment
  181. X    var & operator = (const unsigned short);    // assignment
  182. X    var & operator = (const int);        // assignment
  183. X    var & operator = (const unsigned int);    // assignment
  184. X    var & operator = (const long);        // assignment
  185. X    var & operator = (const unsigned long);    // assignment
  186. X    var & operator = (const double);        // assignment
  187. X
  188. X    // Casting Operators
  189. X    operator char * (void) const;        // type conversion
  190. X    operator double (void) const;        // type conversion
  191. X
  192. X    // Assignment Operators
  193. X    var & operator ++ (void);            // increment (pre-index only)
  194. X    var & operator -- (void);            // decrement (pre-index only)
  195. X    var operator ! (void) const;        // not
  196. X
  197. X    var operator + (const var &) const;        // addition OR concatenation
  198. X    var operator - (const var &) const;        // subtraction
  199. X    var operator * (const var &) const;        // multiplication
  200. X    var operator / (const var &) const;        // division
  201. X    var operator % (const var &) const;        // remainder
  202. X
  203. X    var & operator += (const var &);        // addition OR concatenation
  204. X    var & operator -= (const var &);        // subtraction
  205. X    var & operator *= (const var &);        // multiplication
  206. X    var & operator /= (const var &);        // division
  207. X    var & operator %= (const var &);        // remainder
  208. X
  209. X    var & operator += (const char &);        // addition OR concatenation
  210. X    var & operator += (const char *);        // addition OR concatenation
  211. X    var & operator -= (const char *);        // subtraction
  212. X    var & operator *= (const char *);        // multiplication
  213. X    var & operator /= (const char *);        // division
  214. X    var & operator %= (const char *);        // remainder
  215. X
  216. X    var & operator += (const double);        // addition OR concatenation
  217. X    var & operator -= (const double);        // subtraction
  218. X    var & operator *= (const double);        // multiplication
  219. X    var & operator /= (const double);        // division
  220. X    var & operator %= (const double);        // remainder
  221. X
  222. X    friend var operator + (const char *, const var &); // addition OR concatenation
  223. X    friend var operator - (const char *, const var &); // subtraction
  224. X    friend var operator * (const char *, const var &); // multiplication
  225. X    friend var operator / (const char *, const var &); // division
  226. X    friend var operator % (const char *, const var &); // remainder
  227. X    friend var operator + (const var &, const char *); // addition OR concatenation
  228. X    friend var operator - (const var &, const char *); // subtraction
  229. X    friend var operator * (const var &, const char *); // multiplication
  230. X    friend var operator / (const var &, const char *); // division
  231. X    friend var operator % (const var &, const char *); // remainder
  232. X
  233. X    friend var operator + (const var &, const double); // addition OR concatenation
  234. X    friend var operator - (const var &, const double); // subtraction
  235. X    friend var operator * (const var &, const double); // multiplication
  236. X    friend var operator / (const var &, const double); // division
  237. X    friend var operator % (const var &, const double); // remainder
  238. X    friend var operator + (const double, const var &); // addition OR concatenation
  239. X    friend var operator - (const double, const var &); // subtraction
  240. X    friend var operator * (const double, const var &); // multiplication
  241. X    friend var operator / (const double, const var &); // division
  242. X    friend var operator % (const double, const var &); // remainder
  243. X
  244. X    // Equality Operators
  245. X    int operator == (const var &) const;    // equality
  246. X    int operator != (const var &) const;    // inequality
  247. X    int operator < (const var &) const;        // less than
  248. X    int operator > (const var &) const;        // greater than
  249. X    int operator <= (const var &) const;    // less than or equal
  250. X    int operator >= (const var &) const;    // greater than or equal
  251. X
  252. X    friend int operator == (const var &, const char *); // equality
  253. X    friend int operator != (const var &, const char *); // inequality
  254. X    friend int operator < (const var &, const char *);  // less than
  255. X    friend int operator > (const var &, const char *);  // greater than
  256. X    friend int operator <= (const var &, const char *); // less than or equal
  257. X    friend int operator >= (const var &, const char *); // greater than or equal
  258. X    friend int operator == (const char *, const var &); // equality
  259. X    friend int operator != (const char *, const var &); // inequality
  260. X    friend int operator < (const char *, const var &);  // less than
  261. X    friend int operator > (const char *, const var &);  // greater than
  262. X    friend int operator <= (const char *, const var &); // less than or equal
  263. X    friend int operator >= (const char *, const var &); // greater than or equal
  264. X
  265. X    friend int operator == (const var &, const double); // equality
  266. X    friend int operator != (const var &, const double); // inequality
  267. X    friend int operator < (const var &, const double);  // less than
  268. X    friend int operator > (const var &, const double);  // greater than
  269. X    friend int operator <= (const var &, const double); // less than or equal
  270. X    friend int operator >= (const var &, const double); // greater than or equal
  271. X    friend int operator == (const double, const var &); // equality
  272. X    friend int operator != (const double, const var &); // inequality
  273. X    friend int operator < (const double, const var &);  // less than
  274. X    friend int operator > (const double, const var &);  // greater than
  275. X    friend int operator <= (const double, const var &); // less than or equal
  276. X    friend int operator >= (const double, const var &); // greater than or equal
  277. X
  278. X    // Custom Interface
  279. X    void null(int);                // "null" out string
  280. X    void changesize(int);            // change allocated memory
  281. X    int length(void) const;            // length of string
  282. X    const char * vartype(void) const;        // name of this var type
  283. X    void change_type(const char *);        // change var type
  284. X    int is_string(void) const;            // test var type
  285. X    int is_double(void) const;            // test var type
  286. X    int is_long(void) const;            // test var type
  287. X    int strchr(const char) const;        // strchr(char) index
  288. X    int strrchr(const char) const;        // strrchr(char) index
  289. X    var & concat(const var &);            // concatenation
  290. X    var & format(const char *);            // set output format
  291. X};
  292. X.fi
  293. X\fP
  294. X
  295. X.SH DESCRIPTION
  296. XClass \fBvar\fP represents a \fBstring\fP object class that also provides all
  297. Xthe traditional functionality of the C base types: char, int, long, float, double, and char*.
  298. X\fBVar\fP, is in many ways a "super-string" class.
  299. XThe var class does a pretty good job of offering a base data "container" object that can either
  300. Xassume its "type" at run time, based on context or remain a "fixed" type, always.
  301. X
  302. X.SS var will do
  303. X.TP 2
  304. X+
  305. Xall the base data types (eg: short, int, long, char *, float, double ...)
  306. X.TP 2
  307. X+
  308. Xstring types
  309. X.TP 2
  310. X+
  311. Xarithmetic
  312. X.TP 2
  313. X+
  314. Xstrings and operations on strings
  315. X.TP 2
  316. X+
  317. Xsub-strings and operations on sub-strings
  318. X.TP 2
  319. X+
  320. Xintelligent "mixing" of operations between mixed types
  321. X.TP 2
  322. X+
  323. Xformatted output using the stream library
  324. X
  325. X.SH PUBLIC CONSTRUCTORS
  326. X.SS var(void);
  327. XThis constructor is used to declare an "untyped" var object.  Type is determined
  328. Xat run-time, based on context of use.
  329. X
  330. X.SS var(const varsize &);
  331. XThis constructor is used to declare an "string" var object, with preallocated memory.
  332. XThe object's type can change at run-time, based on context.
  333. X
  334. X.SS var(const char *);
  335. XThis constructor is used to declare a "string" object initialize from a "char *".
  336. XThe object's type can change at run-time, based on context.
  337. X
  338. X.SS var(const char);
  339. XThis constructor is used to declare an "numeric" var object, initialized from a char.
  340. XThe object's type can change at run-time, based on context.
  341. X
  342. X.SS var(const short);
  343. XThis constructor is used to declare an "numeric" var object, initialized from a short.
  344. XThe object's type is fixed and will not change at run-time.
  345. X
  346. X.SS var(const unsigned short);
  347. XThis constructor is used to declare an "numeric" var object, initialized from an unsigned short.
  348. XThe object's type is fixed and will not change at run-time.
  349. X
  350. X.SS var(const int);
  351. XThis constructor is used to declare an "numeric" var object, initialized from an int.
  352. XThe object's type is fixed and will not change at run-time.
  353. X
  354. X.SS var(const unsigned int);
  355. XThis constructor is used to declare an "numeric" var object, initialized from an unsigned int.
  356. XThe object's type is fixed and will not change at run-time.
  357. X
  358. X.SS var(const long);
  359. XThis constructor is used to declare an "numeric" var object, initialized from a long.
  360. XThe object's type is fixed and will not change at run-time.
  361. X
  362. X.SS var(const unsigned long);
  363. XThis constructor is used to declare an "numeric" var object, initialized from an unsigned long.
  364. XThe object's type is fixed and will not change at run-time.
  365. X
  366. X.SS var(const double);
  367. XThis constructor is used to declare an "numeric" var object, initialized from a double or float.
  368. XThe object's type is fixed and will not change at run-time.
  369. X
  370. X.SS var(const var &);
  371. XThis constructor is used to declare a var object, which is a copy of another var.
  372. XThe object assumes the characteristics of the initializing object.
  373. X
  374. X.SS ~var(void);
  375. XThe destructor returns all memory allocated by the object back to the OS.
  376. X
  377. X
  378. X.SH PUBLIC OPERATORS
  379. X.SS Arithmetic and Concatenation Operators
  380. XMost operators (+, -, /, *, %, +=, etc..) will operate as expected.
  381. XThe "+" and "+=" operators will either do addition or concatenation, as appropriate.
  382. Xif concatenation is required, then the \fB"var.concat(var)"\fP member function should
  383. Xbe used.
  384. X
  385. X.SS Relational Operators
  386. XThese also operate as expected.  If "string" objects are compared, the comparison
  387. Xwill be as performed by \fBstrcmp(3)\fP.
  388. X
  389. X.SS The Indexing Operator []
  390. XYou can index a character from inside a \fBvar\fP by using
  391. Xthe \fB"char & operator [] (const int);"\fP operator.
  392. XA reference to the character is returned, which can be assigned to.
  393. XDo not assign the NULL character using this operator.
  394. XInstead call the member function \fB"null(index)"\fP.
  395. X
  396. X.SS Sub-strings
  397. XTwo operators are provide for substring operation.  The
  398. Xfirst, \fB"subvar & operator () (int start, int length) const;"\fP
  399. Xwill extract a string starting at "start" for "length" characters.
  400. XThe second, \fB"subvar & operator () (const int start) const;"\fP will
  401. Xextract a string starting at "start" to the end of the string.
  402. X
  403. X.SS Type Casting
  404. XOnly two type casts are required by \fBvar\fP. The first converts
  405. Xthe object into a "char *".  The second converts the object into a
  406. Xdouble.  Implicit conversion between "char *" and "double" types
  407. Xwill be performed by your C++ compiler.
  408. X
  409. X.SS Formatted Input/Output
  410. XYou can usr \fBvar\fP with the io stream library.  Object can be
  411. Xboth output and input using the ">>" and "<<" operators.
  412. XFor formatted output, be sure to set the object's "format template"
  413. Xprior to calling the ">>" operator.  (see \fB"var & format(const char *);"\fP)
  414. X
  415. X.SH PUBLIC MEMBER FUNCTIONS
  416. X
  417. X.SS Truncating a string 
  418. XThe \fB"void null(int index);"\fP function will truncate a \fBvar\fP
  419. Xobject, starting from the specified index postion.
  420. X
  421. X.SS Memory Allocation
  422. XThe \fB"void changesize(int newsize);"\fP can be used to increase
  423. Xallocated memory for a var.  Memory can NOT be decreased.  Allocated
  424. Xmemory is returned to the heap when an object goes out of scope.
  425. X
  426. X.SS Determining Var's Length
  427. XThe \fB"int length(void) const;"\fP function returns the "size" of a \fBvar\fP.
  428. X
  429. X.SS Determining Var's Type
  430. XThe \fB"const char * vartype(void) const;"\fP function returns the "type" of a \fBvar\fP.
  431. XPossible types are: "VAR_STRING", "VAR_LONG" and "VAR_DOUBLE".
  432. X
  433. X.SS Explititly Changing a Var's Type
  434. XThe \fB"void change_type(const char *newtype);"\fP function can be used
  435. Xto set an exact type.  Valid values for "newtype" are "string", "short",
  436. X"unsigned short", "int", "unsigned int", "long", "unsigned long",
  437. X"float", and "double".
  438. X
  439. X.SS Testing a Var's Type
  440. XThree functions are provided that allow testing a \fBvar\fP type.
  441. XThey are as follows: \fB"int is_string(void) const;"\fP,
  442. X\fB"int is_double(void) const;"\fP, and \fB"int is_long(void) const;"\fP
  443. X
  444. X.SS Searching for a Character
  445. XTwo functions are provided that search a \fBvar\fP for a specified
  446. Xcharacter.  Both return an offset.  The first \fB"int strchr(const char) const;"\fP
  447. Xsearches forward.  The second, \fB"int strrchr(const char) const;"\fP
  448. Xsearches backward.
  449. X
  450. X.SS Concatenation
  451. XConcatenation can be forced, regardless of type with the \fB"var & concat(const var &);"\fP
  452. Xfunction.
  453. X
  454. X.SS Setting the Output Format
  455. XThe \fB"var & format(const char *fmt);"\fP function will allow you to specify an
  456. Xoutput format.  This format will remain in effect until changed.  Printf()
  457. Xstyle output formats can be introduced anywhere in the format statment.
  458. XMultiple formateed output directives can appear in the same "fmt".  Each
  459. Xdirective will receive a copy of the object.  Automatic type conversion will
  460. Xoccur.
  461. X
  462. X
  463. X.SH AUTHOR
  464. XLee Hounshell - 1/92
  465. X
  466. X.SH EXAMPLE
  467. X.nf
  468. X#include    <stdlib.h>
  469. X#include    <stream.h>
  470. X#include    <var.H>
  471. X
  472. Xmain ()
  473. X{
  474. X    var value;                // declare an "untyped" var
  475. X    value = "hello world";        // initialize it
  476. X    cout << value << endl;        // output "hello world"
  477. X    value = value(3, value.length() - 6); // substring example
  478. X    cout << value << endl;        // output "lo wo"
  479. X    value = 35;                // assignment of int
  480. X    value += 42.375;            // add 42.375 to present value
  481. X    cout << value << endl;        // output "77.375"
  482. X    cout << value.format("formatted output example %05d of value") << endl;
  483. X    cout << value.format("multiple outputs #1=%d, #2=%9.2f of value") << endl;
  484. X    value.null(2);            // truncate string
  485. X    value += " sunset strip";        // concatenate a string
  486. X    cout << value.format("%s") << endl;    // output "77 sunset strip"
  487. X    cout << value[3] << value[4] << value[5] << endl; // output "sun"
  488. X}
  489. X.fi
  490. X
  491. X.SH SUPERCLASSES
  492. Xnone.
  493. X
  494. X.SH SUBCLASSES
  495. Xnone
  496. X
  497. X.SH BUGS
  498. XAssignment of an array of vars to another array of vars
  499. Xmust currently be done one elemnt at a time.
  500. X
  501. END_OF_FILE
  502.   if test 15188 -ne `wc -c <'var.3++'`; then
  503.     echo shar: \"'var.3++'\" unpacked with wrong size!
  504.   fi
  505.   # end of 'var.3++'
  506. fi
  507. if test -f 'var.C' -a "${1}" != "-c" ; then 
  508.   echo shar: Will not clobber existing file \"'var.C'\"
  509. else
  510.   echo shar: Extracting \"'var.C'\" \(30983 characters\)
  511.   sed "s/^X//" >'var.C' <<'END_OF_FILE'
  512. X//
  513. X// NAME:    var.C
  514. X//
  515. X// PURPOSE:    C++ Generic "Universal Variable" library class
  516. X// AUTHOR:    Lee Hounshell
  517. X//
  518. X
  519. X#include    <stddef.h>
  520. X#include    <stream.h>
  521. X#include    <stdlib.h>
  522. X#include    <ctype.h>
  523. X#include    <string.h>
  524. X#include    "var.H"
  525. X#include    "Misc.H"
  526. X
  527. Xconst int    VAR_PAD_SIZE        = 128;
  528. Xconst int    VAR_DEF_SIZE        = 16;
  529. X
  530. Xconst short    VAR_STRING        = 0;
  531. Xconst short    VAR_LONG        = 1;
  532. Xconst short    VAR_DOUBLE        = 2;
  533. X
  534. Xchar *    DEFAULT_STRING_FORMAT        = "'%s'";
  535. Xchar *    DEFAULT_INT_FORMAT        = "%d";
  536. Xchar *    DEFAULT_UINT_FORMAT        = "%u";
  537. Xchar *    DEFAULT_LONG_FORMAT        = "%ld";
  538. Xchar *    DEFAULT_ULONG_FORMAT        = "%lu";
  539. Xchar *    DEFAULT_DOUBLE_FORMAT        = "%9.2f";
  540. X
  541. X// -----------------------------------------------------------------------------
  542. X
  543. Xconst var var::ctype    = "var";
  544. Xint var::save_me            = 1;
  545. X
  546. X
  547. Xconst var & var::type(void) const
  548. X{
  549. X    return var::ctype;
  550. X}
  551. X
  552. X
  553. Xvarsize::varsize(int sz)
  554. X{
  555. X    size = sz;
  556. X}
  557. X
  558. X
  559. Xvar::var(void)
  560. X{
  561. X    fixed = 0;
  562. X    is_numeric = VAR_STRING;
  563. X    data_str_len = VAR_DEF_SIZE;
  564. X    data_str_end = 0;
  565. X    data_str = new char[data_str_len];
  566. X    data_str[0] = 0;
  567. X    format_str = DEFAULT_STRING_FORMAT;
  568. X}
  569. X
  570. X
  571. Xvar::var(const char *str)
  572. X{
  573. X    fixed = 1;
  574. X    is_numeric = VAR_STRING;
  575. X    data_str_end = strlen(str);
  576. X    data_str_len = data_str_end + VAR_DEF_SIZE;
  577. X    data_str = new char[data_str_len];
  578. X    strcpy(data_str, str);
  579. X    format_str = DEFAULT_STRING_FORMAT;
  580. X}
  581. X
  582. X
  583. Xvar::var(const varsize &vsz)
  584. X{
  585. X    fixed = 0;
  586. X    is_numeric = VAR_STRING;
  587. X    data_str_len = vsz.size + VAR_DEF_SIZE;
  588. X    data_str_end = 0;
  589. X    data_str = new char[data_str_len];
  590. X    data_str[0] = 0;
  591. X    format_str = DEFAULT_STRING_FORMAT;
  592. X}
  593. X
  594. X
  595. Xvar::var(const char ch)
  596. X{
  597. X    fixed = 0;
  598. X    is_numeric = VAR_STRING;
  599. X    data_str_len = VAR_DEF_SIZE;
  600. X    data_str_end = 1;
  601. X    data_str = new char[data_str_len];
  602. X    data_str[0] = ch;
  603. X    data_str[1] = 0;
  604. X    format_str = DEFAULT_STRING_FORMAT;
  605. X}
  606. X
  607. X
  608. Xvar::var(const short int_num)
  609. X{
  610. X    fixed = 1;
  611. X    is_numeric = VAR_LONG;
  612. X    data_str_len = VAR_DEF_SIZE;
  613. X    data_str = new char[data_str_len];
  614. X    strcpy(data_str, itoa(int_num));
  615. X    data_str_end = strlen(data_str);
  616. X    format_str = DEFAULT_INT_FORMAT;
  617. X}
  618. X
  619. X
  620. Xvar::var(const unsigned short int_num)
  621. X{
  622. X    fixed = 1;
  623. X    is_numeric = VAR_LONG;
  624. X    data_str_len = VAR_DEF_SIZE;
  625. X    data_str = new char[data_str_len];
  626. X    strcpy(data_str, itoa(int_num));
  627. X    data_str_end = strlen(data_str);
  628. X    format_str = DEFAULT_UINT_FORMAT;
  629. X}
  630. X
  631. X
  632. Xvar::var(const int int_num)
  633. X{
  634. X    fixed = 1;
  635. X    is_numeric = VAR_LONG;
  636. X    data_str_len = VAR_DEF_SIZE;
  637. X    data_str = new char[data_str_len];
  638. X    strcpy(data_str, itoa(int_num));
  639. X    data_str_end = strlen(data_str);
  640. X    format_str = DEFAULT_INT_FORMAT;
  641. X}
  642. X
  643. X
  644. Xvar::var(const unsigned int int_num)
  645. X{
  646. X    fixed = 1;
  647. X    is_numeric = VAR_LONG;
  648. X    data_str_len = VAR_DEF_SIZE;
  649. X    data_str = new char[data_str_len];
  650. X    strcpy(data_str, itoa(int_num));
  651. X    data_str_end = strlen(data_str);
  652. X    format_str = DEFAULT_UINT_FORMAT;
  653. X}
  654. X
  655. X
  656. Xvar::var(const long long_num)
  657. X{
  658. X    fixed = 1;
  659. X    is_numeric = VAR_LONG;
  660. X    data_str_len = VAR_DEF_SIZE;
  661. X    data_str = new char[data_str_len];
  662. X    strcpy(data_str, ltoa(long_num));
  663. X    data_str_end = strlen(data_str);
  664. X    format_str = DEFAULT_LONG_FORMAT;
  665. X}
  666. X
  667. X
  668. Xvar::var(const unsigned long long_num)
  669. X{
  670. X    fixed = 1;
  671. X    is_numeric = VAR_LONG;
  672. X    data_str_len = VAR_DEF_SIZE;
  673. X    data_str = new char[data_str_len];
  674. X    strcpy(data_str, ltoa(long_num));
  675. X    data_str_end = strlen(data_str);
  676. X    format_str = DEFAULT_ULONG_FORMAT;
  677. X}
  678. X
  679. X
  680. Xvar::var(const double double_num)
  681. X{
  682. X    fixed = 1;
  683. X    is_numeric = VAR_DOUBLE;
  684. X    data_str_len = VAR_DEF_SIZE;
  685. X    data_str = new char[data_str_len];
  686. X    strcpy(data_str, dtoa(double_num));
  687. X    data_str_end = strlen(data_str);
  688. X    format_str = DEFAULT_DOUBLE_FORMAT;
  689. X}
  690. X
  691. X
  692. Xvar::var(const var &v)
  693. X{
  694. X    fixed = v.fixed;
  695. X    is_numeric = v.is_numeric;
  696. X    if (v.data_str && v.data_str_end) {
  697. X    data_str_len = v.data_str_end + VAR_DEF_SIZE;
  698. X    data_str_end = v.data_str_end;
  699. X    data_str = new char[data_str_len];
  700. X    strcpy(data_str, v.data_str);
  701. X    }
  702. X    else {
  703. X    data_str_len = VAR_DEF_SIZE;
  704. X    data_str_end = 0;
  705. X    data_str = new char[data_str_len];
  706. X    data_str[0] = 0;
  707. X    }
  708. X    format_str = DEFAULT_STRING_FORMAT;
  709. X}
  710. X
  711. X
  712. Xvar::~var(void)
  713. X{
  714. X    if (data_str) {
  715. X    delete data_str;
  716. X    }
  717. X    if (format_str
  718. X    && format_str != DEFAULT_STRING_FORMAT
  719. X    && format_str != DEFAULT_INT_FORMAT
  720. X    && format_str != DEFAULT_UINT_FORMAT
  721. X    && format_str != DEFAULT_LONG_FORMAT
  722. X    && format_str != DEFAULT_ULONG_FORMAT
  723. X    && format_str != DEFAULT_DOUBLE_FORMAT) {
  724. X        delete format_str;
  725. X    }
  726. X}
  727. X
  728. X// -----------------------------------------------------------------------------
  729. X
  730. Xvar & var::operator = (const char *str)
  731. X{
  732. X    if (fixed && is_numeric) {
  733. X    if (is_numeric == VAR_DOUBLE) {
  734. X        double d = atod((char *) str);
  735. X        *this = d;
  736. X    }
  737. X    else {
  738. X        long l = atol(str);
  739. X        *this = l;
  740. X    }
  741. X    }
  742. X    else {
  743. X    int len = strlen(str) + 1;
  744. X    if (data_str_len < len) {
  745. X        delete data_str;
  746. X        data_str_len = len;
  747. X        data_str = new char[data_str_len];
  748. X    }
  749. X    data_str_end = len - 1;
  750. X    strcpy(data_str, str);
  751. X    if (!fixed) {
  752. X        int str_is_numeric = numcheck(data_str);
  753. X        is_numeric = str_is_numeric;
  754. X    }
  755. X    }
  756. X    return *this;
  757. X}
  758. X
  759. X
  760. Xvar & var::operator = (const var &l)
  761. X{
  762. X    if (this != &l) {
  763. X    if (data_str_len <= l.data_str_end) {
  764. X        delete data_str;
  765. X        data_str_len = l.data_str_end + VAR_DEF_SIZE;
  766. X        data_str = new char[data_str_len];
  767. X    }
  768. X    data_str_end = l.data_str_end;
  769. X    strncpy(data_str, l.data_str, l.data_str_end);
  770. X    data_str[data_str_end] = 0;
  771. X    if (!fixed) {
  772. X        is_numeric = numcheck(data_str);
  773. X    }
  774. X    //
  775. X    // Note: the output "format" of a var variable is preserved
  776. X    //
  777. X    }
  778. X    return *this;
  779. X}
  780. X
  781. X
  782. Xchar & var::operator [] (const int index)
  783. X{
  784. X    static char error_ch;
  785. X    if (index < 0) {
  786. X    cerr << "ERROR: " << " - var[" << index << "] negative index used." << endl;
  787. X    error_ch = 0;
  788. X    return error_ch;
  789. X    }
  790. X    if (data_str_len <= index) {
  791. X    // this is technically a program error, but I'll be nice and extend the string's length
  792. X    data_str_len = index + VAR_PAD_SIZE;
  793. X    data_str_end = index + 1;
  794. X    char *buf = new char[data_str_len];
  795. X    sprintf(buf, "%-*.*s", data_str_end, data_str_end, data_str);
  796. X    delete data_str;
  797. X    data_str = buf;
  798. X    data_str[index] = 0;
  799. X    cerr << "WARNING: " << " - var index '" << index << "' beyond current string boundary." << endl;
  800. X    }
  801. X    while (data_str_end < index) {
  802. X    data_str[data_str_end++] = ' ';        // pad to index with spaces if necessary
  803. X    }
  804. X    if (data_str_end == index) {
  805. X    data_str[data_str_end] = 0;        // the end of a string is ALWAYS 0
  806. X    if ((data_str_end + 1) < data_str_len) {
  807. X        data_str[++data_str_end] = 0;    // the new end of string is also 0
  808. X    }
  809. X    }
  810. X    return data_str[index];
  811. X}
  812. X
  813. X
  814. X// for substrings
  815. Xsubvar & var::operator () (const int offset) const
  816. X{
  817. X    return operator () (offset, -1);
  818. X}
  819. X
  820. X
  821. X// for substrings
  822. Xsubvar & var::operator () (int offset, int length) const
  823. X{
  824. X    static subvar _esi_subvar;
  825. X    if (length < 0) {
  826. X    length = data_str_end - offset;
  827. X    }
  828. X    char *substr = new char[length + 1];
  829. X    strncpy(substr, data_str + offset, (int) length);
  830. X    substr[length] = 0;
  831. X    _esi_subvar.var::operator = (substr);
  832. X    _esi_subvar.varptr = (var *) this;
  833. X    _esi_subvar.offset = offset;
  834. X    _esi_subvar.length = length;
  835. X    delete substr;
  836. X    return _esi_subvar;
  837. X}
  838. X
  839. X
  840. X// for syntax: var(offset, length) = var
  841. Xvar & subvar::operator = (const var &substr)
  842. X{
  843. X    char *srcstr = varptr->data_str;
  844. X    char *repstr = substr.data_str;
  845. X    int replen = length;
  846. X    if (substr.data_str_end < length) {
  847. X    replen = substr.data_str_end;
  848. X    }
  849. X    int len = varptr->data_str_len;
  850. X    char *newstr = new char[len];
  851. X    strncpy(newstr, srcstr, offset);        // data from string being replaced up to "offset"
  852. X    if (replen) {
  853. X    strncpy(newstr + offset, repstr, replen);    // replacement string data
  854. X    }
  855. X    int newoffset = offset + replen;
  856. X    if (newoffset < varptr->data_str_end) {
  857. X    strcpy(newstr + newoffset, srcstr + offset + length);
  858. X    }
  859. X    else {
  860. X    newstr[newoffset] = 0;
  861. X    }
  862. X    if (varptr->data_str) {
  863. X    delete varptr->data_str;
  864. X    }
  865. X    varptr->data_str = newstr;
  866. X    varptr->data_str_len = len;
  867. X    varptr->data_str_end = strlen(newstr);
  868. X    if (!varptr->fixed) {
  869. X    varptr->is_numeric = numcheck(newstr);
  870. X    }
  871. X    return *varptr;
  872. X}
  873. X
  874. X// -----------------------------------------------------------------------------
  875. X
  876. Xvar & var::operator = (const char ch)
  877. X{
  878. X    char buf[2];
  879. X    buf[0] = ch;
  880. X    buf[1] = 0;
  881. X    *this = buf;
  882. X    return *this;
  883. X}
  884. X
  885. X
  886. Xvar & var::operator = (const short int_num)
  887. X{
  888. X    char *str = itoa(int_num);
  889. X    int len = strlen(str);
  890. X    if (data_str_len < len) {
  891. X    delete data_str;
  892. X    data_str_len = len + 1;
  893. X    data_str = new char[data_str_len];
  894. X    }
  895. X    data_str_end = len;
  896. X    strcpy(data_str, str);
  897. X    if (!fixed) {
  898. X    is_numeric = VAR_LONG;
  899. X    }
  900. X    return *this;
  901. X}
  902. X
  903. X
  904. Xvar & var::operator = (const unsigned short int_num)
  905. X{
  906. X    char *str = itoa(int_num);
  907. X    int len = strlen(str);
  908. X    if (data_str_len < len) {
  909. X    delete data_str;
  910. X    data_str_len = len + 1;
  911. X    data_str = new char[data_str_len];
  912. X    }
  913. X    data_str_end = len;
  914. X    strcpy(data_str, str);
  915. X    is_numeric = VAR_LONG;
  916. X    return *this;
  917. X}
  918. X
  919. X
  920. Xvar & var::operator = (const int int_num)
  921. X{
  922. X    char *str = itoa(int_num);
  923. X    int len = strlen(str);
  924. X    if (data_str_len < len) {
  925. X    delete data_str;
  926. X    data_str_len = len + 1;
  927. X    data_str = new char[data_str_len];
  928. X    }
  929. X    data_str_end = len;
  930. X    strcpy(data_str, str);
  931. X    if (!fixed) {
  932. X    is_numeric = VAR_LONG;
  933. X    }
  934. X    return *this;
  935. X}
  936. X
  937. X
  938. Xvar & var::operator = (const unsigned int int_num)
  939. X{
  940. X    char *str = itoa(int_num);
  941. X    int len = strlen(str);
  942. X    if (data_str_len < len) {
  943. X    delete data_str;
  944. X    data_str_len = len + 1;
  945. X    data_str = new char[data_str_len];
  946. X    }
  947. X    data_str_end = len;
  948. X    strcpy(data_str, str);
  949. X    if (!fixed) {
  950. X    is_numeric = VAR_LONG;
  951. X    }
  952. X    return *this;
  953. X}
  954. X
  955. X
  956. Xvar & var::operator = (const long long_num)
  957. X{
  958. X    char *str = ltoa(long_num);
  959. X    int len = strlen(str);
  960. X    if (data_str_len < len) {
  961. X    delete data_str;
  962. X    data_str_len = len + 1;
  963. X    data_str = new char[data_str_len];
  964. X    }
  965. X    data_str_end = len;
  966. X    strcpy(data_str, str);
  967. X    if (!fixed) {
  968. X    is_numeric = VAR_LONG;
  969. X    }
  970. X    return *this;
  971. X}
  972. X
  973. X
  974. Xvar & var::operator = (const unsigned long long_num)
  975. X{
  976. X    char *str = ltoa(long_num);
  977. X    int len = strlen(str);
  978. X    if (data_str_len < len) {
  979. X    delete data_str;
  980. X    data_str_len = len + 1;
  981. X    data_str = new char[data_str_len];
  982. X    }
  983. X    data_str_end = len;
  984. X    strcpy(data_str, str);
  985. X    if (!fixed) {
  986. X    is_numeric = VAR_LONG;
  987. X    }
  988. X    return *this;
  989. X}
  990. X
  991. X
  992. Xvar & var::operator = (const double dbl_num)
  993. X{
  994. X    char *str = dtoa(dbl_num);
  995. X    int len = strlen(str);
  996. X    if (data_str_len < len) {
  997. X    delete data_str;
  998. X    data_str_len = len + 1;
  999. X    data_str = new char[data_str_len];
  1000. X    }
  1001. X    data_str_end = len;
  1002. X    strcpy(data_str, str);
  1003. X    if (!fixed) {
  1004. X    is_numeric = VAR_DOUBLE;
  1005. X    }
  1006. X    return *this;
  1007. X}
  1008. X
  1009. X// -----------------------------------------------------------------------------
  1010. X
  1011. Xvar::operator char * (void) const
  1012. X{
  1013. X    return data_str;
  1014. X}
  1015. X
  1016. X
  1017. Xvar::operator double (void) const
  1018. X{
  1019. X    return atod(data_str);
  1020. X}
  1021. X
  1022. X// -----------------------------------------------------------------------------
  1023. X
  1024. Xvar & var::operator ++ (void)        // increment (pre-index only)
  1025. X{
  1026. X    *this += 1;
  1027. X    return *this;
  1028. X}
  1029. X
  1030. X
  1031. Xvar & var::operator -- (void)        // decrement (pre-index only)
  1032. X{
  1033. X    *this -= 1;
  1034. X    return *this;
  1035. X}
  1036. X
  1037. X
  1038. Xvar var::operator ! (void) const    // not
  1039. X{
  1040. X    var not(1);
  1041. X    if ((int) *this) {
  1042. X    not = 0;
  1043. X    }
  1044. X    return not;
  1045. X}
  1046. X
  1047. X// -----------------------------------------------------------------------------
  1048. X
  1049. Xvar var::operator + (const var & v) const    // addition OR concatenation
  1050. X{
  1051. X    var add;
  1052. X    if (is_numeric && v.is_numeric) {
  1053. X    // do math in the highest precision specified
  1054. X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
  1055. X    switch (n_type) {
  1056. X        case VAR_LONG:
  1057. X        add = (long) *this + (long) v;
  1058. X        break;
  1059. X        default:
  1060. X        // should be VAR_DOUBLE
  1061. X        add = (double) *this + (double) v;
  1062. X        break;
  1063. X    }
  1064. X    }
  1065. X    else {
  1066. X    // concatenate strings
  1067. X    delete add.data_str;
  1068. X    add.data_str_len = data_str_end + v.data_str_end + VAR_PAD_SIZE;
  1069. X    add.data_str_end = data_str_end + v.data_str_end;
  1070. X    add.data_str = new char[add.data_str_len];
  1071. X    strcpy(add.data_str, data_str);
  1072. X    strcpy((add.data_str) + data_str_end, v.data_str);
  1073. X    add.is_numeric = VAR_STRING;
  1074. X    }
  1075. X    return add;
  1076. X}
  1077. X
  1078. X
  1079. Xvar var::operator - (const var & v) const    // subtraction
  1080. X{
  1081. X    var sub;
  1082. X    // do math in the highest precision specified
  1083. X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
  1084. X    switch (n_type) {
  1085. X    case VAR_LONG:
  1086. X        sub = (long) *this - (long) v;
  1087. X        sub.is_numeric = VAR_LONG;
  1088. X        break;
  1089. X    default:
  1090. X        // should be VAR_DOUBLE
  1091. X        sub = (double) *this - (double) v;
  1092. X        break;
  1093. X    }
  1094. X    return sub;
  1095. X}
  1096. X
  1097. X
  1098. Xvar var::operator * (const var & v) const    // multiplication
  1099. X{
  1100. X    var times;
  1101. X    // do math in the highest precision specified
  1102. X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
  1103. X    switch (n_type) {
  1104. X    case VAR_LONG:
  1105. X        times = (long) *this * (long) v;
  1106. X        break;
  1107. X    default:
  1108. X        // should be VAR_DOUBLE
  1109. X        times = (double) *this * (double) v;
  1110. X        break;
  1111. X    }
  1112. X    return times;
  1113. X}
  1114. X
  1115. X
  1116. Xvar var::operator / (const var & v) const    // division
  1117. X{
  1118. X    var div;
  1119. X    // do math in the highest precision specified
  1120. X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
  1121. X    switch (n_type) {
  1122. X    case VAR_LONG:
  1123. X        div = (long) *this / (long) v;
  1124. X        break;
  1125. X    default:
  1126. X        // should be VAR_DOUBLE
  1127. X        div = (double) *this / (double) v;
  1128. X        break;
  1129. X    }
  1130. X    return div;
  1131. X}
  1132. X
  1133. X
  1134. Xvar var::operator % (const var & v) const    // remainder
  1135. X{
  1136. X    var mod;
  1137. X    // do math in the highest precision specified
  1138. X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
  1139. X    switch (n_type) {
  1140. X    case VAR_LONG:
  1141. X        mod = (long) *this % (long) v;
  1142. X        break;
  1143. X    default:
  1144. X        // should be VAR_DOUBLE
  1145. X        // really, I shouldn't allow this..
  1146. X        mod = (double) ((long) *this % (long) v);
  1147. X        break;
  1148. X    }
  1149. X    return mod;
  1150. X}
  1151. X
  1152. X// -----------------------------------------------------------------------------
  1153. X
  1154. Xvar & var::operator += (const var & v)
  1155. X{
  1156. X    if ((is_numeric == VAR_STRING) || (v.is_numeric == VAR_STRING)) {
  1157. X    concat(v);
  1158. X    }
  1159. X    else {
  1160. X    *this = (*this) + v;
  1161. X    }
  1162. X    return *this;
  1163. X}
  1164. X
  1165. X
  1166. Xvar & var::operator -= (const var & v)
  1167. X{
  1168. X    *this = (*this) - v;
  1169. X    return *this;
  1170. X}
  1171. X
  1172. X
  1173. Xvar & var::operator *= (const var & v)
  1174. X{
  1175. X    *this = (*this) * v;
  1176. X    return *this;
  1177. X}
  1178. X
  1179. X
  1180. Xvar & var::operator /= (const var & v)
  1181. X{
  1182. X    *this = (*this) / v;
  1183. X    return *this;
  1184. X}
  1185. X
  1186. X
  1187. Xvar & var::operator %= (const var & v)
  1188. X{
  1189. X    *this = (*this) % v;
  1190. X    return *this;
  1191. X}
  1192. X
  1193. X// -----------------------------------------------------------------------------
  1194. X
  1195. Xvar & var::operator += (const char & ch)
  1196. X{
  1197. X    var foo = ch;
  1198. X    *this += foo;
  1199. X    return *this;
  1200. X}
  1201. X
  1202. Xvar & var::operator += (const char * v)
  1203. X{
  1204. X    var foo = v;
  1205. X    *this += foo;
  1206. X    return *this;
  1207. X}
  1208. X
  1209. X
  1210. Xvar & var::operator -= (const char * v)
  1211. X{
  1212. X    var foo = v;
  1213. X    *this -= foo;
  1214. X    return *this;
  1215. X}
  1216. X
  1217. X
  1218. Xvar & var::operator *= (const char * v)
  1219. X{
  1220. X    var foo = v;
  1221. X    *this *= foo;
  1222. X    return *this;
  1223. X}
  1224. X
  1225. X
  1226. Xvar & var::operator /= (const char * v)
  1227. X{
  1228. X    var foo = v;
  1229. X    *this /= foo;
  1230. X    return *this;
  1231. X}
  1232. X
  1233. X
  1234. Xvar & var::operator %= (const char * v)
  1235. X{
  1236. X    var foo = v;
  1237. X    *this %= foo;
  1238. X    return *this;
  1239. X}
  1240. X
  1241. X// -----------------------------------------------------------------------------
  1242. X
  1243. Xvar & var::operator += (const double v)
  1244. X{
  1245. X    var foo = v;
  1246. X    *this += foo;
  1247. X    return *this;
  1248. X}
  1249. X
  1250. X
  1251. Xvar & var::operator -= (const double v)
  1252. X{
  1253. X    var foo = v;
  1254. X    *this -= foo;
  1255. X    return *this;
  1256. X}
  1257. X
  1258. X
  1259. Xvar & var::operator *= (const double v)
  1260. X{
  1261. X    var foo = v;
  1262. X    *this *= foo;
  1263. X    return *this;
  1264. X}
  1265. X
  1266. X
  1267. Xvar & var::operator /= (const double v)
  1268. X{
  1269. X    var foo = v;
  1270. X    *this /= foo;
  1271. X    return *this;
  1272. X}
  1273. X
  1274. X
  1275. Xvar & var::operator %= (const double v)
  1276. X{
  1277. X    var foo = v;
  1278. X    *this %= foo;
  1279. X    return *this;
  1280. X}
  1281. X
  1282. X// -----------------------------------------------------------------------------
  1283. X
  1284. Xvar operator + (const char * s, const var & v)
  1285. X{
  1286. X    var foo = s;
  1287. X    return foo + v;
  1288. X}
  1289. X
  1290. X
  1291. Xvar operator - (const char * s, const var & v)
  1292. X{
  1293. X    var foo = s;
  1294. X    return foo - v;
  1295. X}
  1296. X
  1297. X
  1298. Xvar operator * (const char * s, const var & v)
  1299. X{
  1300. X    var foo = s;
  1301. X    return foo * v;
  1302. X}
  1303. X
  1304. X
  1305. Xvar operator / (const char * s, const var & v)
  1306. X{
  1307. X    var foo = s;
  1308. X    return foo / v;
  1309. X}
  1310. X
  1311. X
  1312. Xvar operator % (const char * s, const var & v)
  1313. X{
  1314. X    var foo = s;
  1315. X    return foo % v;
  1316. X}
  1317. X
  1318. X
  1319. Xvar operator + (const var & v, const char * s)
  1320. X{
  1321. X    var foo = s;
  1322. X    return v + foo;
  1323. X}
  1324. X
  1325. X
  1326. Xvar operator - (const var & v, const char * s)
  1327. X{
  1328. X    var foo = s;
  1329. X    return v - foo;
  1330. X}
  1331. X
  1332. X
  1333. Xvar operator * (const var & v, const char * s)
  1334. X{
  1335. X    var foo = s;
  1336. X    return v * foo;
  1337. X}
  1338. X
  1339. X
  1340. Xvar operator / (const var & v, const char * s)
  1341. X{
  1342. X    var foo = s;
  1343. X    return v / foo;
  1344. X}
  1345. X
  1346. X
  1347. Xvar operator % (const var & v, const char * s)
  1348. X{
  1349. X    var foo = s;
  1350. X    return v % foo;
  1351. X}
  1352. X
  1353. X// -----------------------------------------------------------------------------
  1354. X
  1355. Xvar operator + (const var & v, const double d)
  1356. X{
  1357. X    var foo = d;
  1358. X    return v + foo;
  1359. X}
  1360. X
  1361. X
  1362. Xvar operator - (const var & v, const double d)
  1363. X{
  1364. X    var foo = d;
  1365. X    return v - foo;
  1366. X}
  1367. X
  1368. X
  1369. Xvar operator * (const var & v, const double d)
  1370. X{
  1371. X    var foo = d;
  1372. X    return v * foo;
  1373. X}
  1374. X
  1375. X
  1376. Xvar operator / (const var & v, const double d)
  1377. X{
  1378. X    var foo = d;
  1379. X    return v / foo;
  1380. X}
  1381. X
  1382. X
  1383. Xvar operator % (const var & v, const double d)
  1384. X{
  1385. X    var foo = d;
  1386. X    return v % foo;
  1387. X}
  1388. X
  1389. X
  1390. Xvar operator + (const double d, const var & v)
  1391. X{
  1392. X    var foo = d;
  1393. X    return foo + v;
  1394. X}
  1395. X
  1396. X
  1397. Xvar operator - (const double d, const var & v)
  1398. X{
  1399. X    var foo = d;
  1400. X    return foo - v;
  1401. X}
  1402. X
  1403. X
  1404. Xvar operator * (const double d, const var & v)
  1405. X{
  1406. X    var foo = d;
  1407. X    return foo * v;
  1408. X}
  1409. X
  1410. X
  1411. Xvar operator / (const double d, const var & v)
  1412. X{
  1413. X    var foo = d;
  1414. X    return foo / v;
  1415. X}
  1416. X
  1417. X
  1418. Xvar operator % (const double d, const var & v)
  1419. X{
  1420. X    var foo = d;
  1421. X    return foo % v;
  1422. X}
  1423. X
  1424. X// -----------------------------------------------------------------------------
  1425. X
  1426. Xint var::operator == (const var & t) const        // equality
  1427. X{
  1428. X    if (is_numeric && t.is_numeric) {
  1429. X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
  1430. X        return (long) (*this) == (long) t;
  1431. X    }
  1432. X    return (double) (*this) == (double) t;
  1433. X    }
  1434. X    else {
  1435. X    if (data_str_end && t.data_str_end) {
  1436. X        return !strcmp(data_str, t.data_str);
  1437. X    }
  1438. X    else {
  1439. X        return data_str_end == t.data_str_end;
  1440. X    }
  1441. X    }
  1442. X}
  1443. X
  1444. X
  1445. Xint var::operator != (const var & t) const        // inequality
  1446. X{
  1447. X    if (is_numeric && t.is_numeric) {
  1448. X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
  1449. X        return (long) (*this) != (long) t;
  1450. X    }
  1451. X    return (double) (*this) != (double) t;
  1452. X    }
  1453. X    else {
  1454. X    if (data_str_end && t.data_str_end) {
  1455. X        return strcmp(data_str, t.data_str);
  1456. X    }
  1457. X    else {
  1458. X        return data_str_end != t.data_str_end;
  1459. X    }
  1460. X    }
  1461. X}
  1462. X
  1463. X
  1464. Xint var::operator < (const var & t) const        // less than
  1465. X{
  1466. X    if (is_numeric && t.is_numeric) {
  1467. X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
  1468. X        return (long) (*this) < (long) t;
  1469. X    }
  1470. X    return (double) (*this) < (double) t;
  1471. X    }
  1472. X    else {
  1473. X    if (data_str_end && t.data_str_end) {
  1474. X        return (strcmp(data_str, t.data_str) < 0);
  1475. X    }
  1476. X    else {
  1477. X        return data_str_end < t.data_str_end;
  1478. X    }
  1479. X    }
  1480. X}
  1481. X
  1482. X
  1483. Xint var::operator > (const var & t) const        // greater than
  1484. X{
  1485. X    if (is_numeric && t.is_numeric) {
  1486. X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
  1487. X        return (long) (*this) > (long) t;
  1488. X    }
  1489. X    return (double) (*this) > (double) t;
  1490. X    }
  1491. X    else {
  1492. X    if (data_str_end && t.data_str_end) {
  1493. X        return (strcmp(data_str, t.data_str) > 0);
  1494. X    }
  1495. X    else {
  1496. X        return data_str_end > t.data_str_end;
  1497. X    }
  1498. X    }
  1499. X}
  1500. X
  1501. X
  1502. Xint var::operator <= (const var & t) const        // less than or equal
  1503. X{
  1504. X    if (is_numeric && t.is_numeric) {
  1505. X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
  1506. X        return (long) (*this) <= (long) t;
  1507. X    }
  1508. X    return (double) (*this) <= (double) t;
  1509. X    }
  1510. X    else {
  1511. X    if (data_str_end && t.data_str_end) {
  1512. X        return (strcmp(data_str, t.data_str) <= 0);
  1513. X    }
  1514. X    else {
  1515. X        return data_str_end <= t.data_str_end;
  1516. X    }
  1517. X    }
  1518. X}
  1519. X
  1520. X
  1521. Xint var::operator >= (const var & t) const        // greater than or equal
  1522. X{
  1523. X    if (is_numeric && t.is_numeric) {
  1524. X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
  1525. X        return (long) (*this) >= (long) t;
  1526. X    }
  1527. X    return (double) (*this) >= (double) t;
  1528. X    }
  1529. X    else {
  1530. X    if (data_str_end && t.data_str_end) {
  1531. X        return (strcmp(data_str, t.data_str) >= 0);
  1532. X    }
  1533. X    else {
  1534. X        return data_str_end >= t.data_str_end;
  1535. X    }
  1536. X    }
  1537. X}
  1538. X
  1539. X// -----------------------------------------------------------------------------
  1540. X
  1541. Xint operator == (const var & t, const char * s)
  1542. X{
  1543. X    var foo = s;
  1544. X    return t == foo;
  1545. X}
  1546. X
  1547. X
  1548. Xint operator != (const var & t, const char * s)
  1549. X{
  1550. X    var foo = s;
  1551. X    return t != foo;
  1552. X}
  1553. X
  1554. X
  1555. Xint operator < (const var & t, const char * s)
  1556. X{
  1557. X    var foo = s;
  1558. X    return t < foo;
  1559. X}
  1560. X
  1561. X
  1562. Xint operator > (const var & t, const char * s)
  1563. X{
  1564. X    var foo = s;
  1565. X    return t > foo;
  1566. X}
  1567. X
  1568. X
  1569. Xint operator <= (const var & t, const char * s)
  1570. X{
  1571. X    var foo = s;
  1572. X    return t <= foo;
  1573. X}
  1574. X
  1575. X
  1576. Xint operator >= (const var & t, const char * s)
  1577. X{
  1578. X    var foo = s;
  1579. X    return t >= foo;
  1580. X}
  1581. X
  1582. X
  1583. Xint operator == (const char * s, const var & t)
  1584. X{
  1585. X    var foo = s;
  1586. X    return foo == t;
  1587. X}
  1588. X
  1589. X
  1590. Xint operator != (const char * s, const var & t)
  1591. X{
  1592. X    var foo = s;
  1593. X    return foo != t;
  1594. X}
  1595. X
  1596. X
  1597. Xint operator < (const char * s, const var & t)
  1598. X{
  1599. X    var foo = s;
  1600. X    return foo < t;
  1601. X}
  1602. X
  1603. X
  1604. Xint operator > (const char * s, const var & t)
  1605. X{
  1606. X    var foo = s;
  1607. X    return foo > t;
  1608. X}
  1609. X
  1610. X
  1611. Xint operator <= (const char * s, const var & t)
  1612. X{
  1613. X    var foo = s;
  1614. X    return foo <= t;
  1615. X}
  1616. X
  1617. X
  1618. Xint operator >= (const char * s, const var & t)
  1619. X{
  1620. X    var foo = s;
  1621. X    return foo >= t;
  1622. X}
  1623. X
  1624. X// -----------------------------------------------------------------------------
  1625. X
  1626. Xint operator == (const var & t, const double d)
  1627. X{
  1628. X    return (double) t == d;
  1629. X}
  1630. X
  1631. X
  1632. Xint operator != (const var & t, const double d)
  1633. X{
  1634. X    return (double) t != d;
  1635. X}
  1636. X
  1637. X
  1638. Xint operator < (const var & t, const double d)
  1639. X{
  1640. X    return (double) t < d;
  1641. X}
  1642. X
  1643. X
  1644. Xint operator > (const var & t, const double d)
  1645. X{
  1646. X    return (double) t > d;
  1647. X}
  1648. X
  1649. X
  1650. Xint operator <= (const var & t, const double d)
  1651. X{
  1652. X    return (double) t <= d;
  1653. X}
  1654. X
  1655. X
  1656. Xint operator >= (const var & t, const double d)
  1657. X{
  1658. X    return (double) t >= d;
  1659. X}
  1660. X
  1661. X
  1662. Xint operator == (const double d, const var & t)
  1663. X{
  1664. X    return d == (double) t;
  1665. X}
  1666. X
  1667. X
  1668. Xint operator != (const double d, const var & t)
  1669. X{
  1670. X    return d != (double) t;
  1671. X}
  1672. X
  1673. X
  1674. Xint operator < (const double d, const var & t)
  1675. X{
  1676. X    return d < (double) t;
  1677. X}
  1678. X
  1679. X
  1680. Xint operator > (const double d, const var & t)
  1681. X{
  1682. X    return d > (double) t;
  1683. X}
  1684. X
  1685. X
  1686. Xint operator <= (const double d, const var & t)
  1687. X{
  1688. X    return d <= (double) t;
  1689. X}
  1690. X
  1691. X
  1692. Xint operator >= (const double d, const var & t)
  1693. X{
  1694. X    return d >= (double) t;
  1695. X}
  1696. X
  1697. X// -----------------------------------------------------------------------------
  1698. X
  1699. Xvoid var::null(int index)
  1700. X{
  1701. X    if (index >= data_str_len) {
  1702. X    cerr << "WARNING: " << " - var::null(" << index << ") - the index out of range." << endl;
  1703. X    (*this)[index] = 0;
  1704. X    data_str_end = index;
  1705. X    }
  1706. X    else {
  1707. X    data_str[index] = 0;
  1708. X    data_str_end = index;
  1709. X    }
  1710. X}
  1711. X
  1712. X
  1713. Xvoid var::changesize(int newsize)
  1714. X{
  1715. X    if (newsize > data_str_len) {
  1716. X    char *buf = new char[newsize];
  1717. X    if (data_str) {
  1718. X        strncpy(buf, data_str, data_str_end);
  1719. X        buf[data_str_end] = 0;
  1720. X        delete data_str;
  1721. X    }
  1722. X    else {
  1723. X        *buf = 0;
  1724. X        data_str_end = 0;
  1725. X    }
  1726. X    data_str_len = newsize;
  1727. X    data_str = buf;
  1728. X    }
  1729. X}
  1730. X
  1731. X
  1732. Xint var::length(void) const
  1733. X{
  1734. X    return data_str_end;
  1735. X}
  1736. X
  1737. X
  1738. Xconst char * var::vartype(void) const
  1739. X{
  1740. X    switch (is_numeric) {
  1741. X    case VAR_STRING:
  1742. X        return "VAR_STRING";
  1743. X    case VAR_LONG:
  1744. X        return "VAR_LONG";
  1745. X    case VAR_DOUBLE:
  1746. X        return "VAR_DOUBLE";
  1747. X    }
  1748. X    return "var type unknown";
  1749. X}
  1750. X
  1751. X
  1752. Xvoid var::change_type(const char *ntype)
  1753. X{
  1754. X    if (ntype == NULL) {
  1755. X    return;
  1756. X    }
  1757. X    int index = strlen(ntype);
  1758. X    if (!index) {
  1759. X    return;
  1760. X    }
  1761. X    char *new_type = new char[index + 1];
  1762. X    if (ntype[0] == '(' && ntype[index - 1] == ')') {
  1763. X    strcpy(new_type, &ntype[1]);
  1764. X    index = strlen(new_type) - 1;
  1765. X    if (index <= 0) {
  1766. X        delete new_type;
  1767. X        return;
  1768. X    }
  1769. X    new_type[index] = 0;            // drop parens
  1770. X    }
  1771. X    else {
  1772. X    strcpy(new_type, ntype);
  1773. X    }
  1774. X    if (new_type[index - 1] == ' ') {
  1775. X    new_type[index - 1] = 0;
  1776. X    }
  1777. X    fixed = 1;
  1778. X    if (!strcmp(new_type, "var")) {
  1779. X    is_numeric = numcheck((const char *) *this);
  1780. X    }
  1781. X    else if (!strcmp(new_type, "string")) {
  1782. X    is_numeric = VAR_STRING;
  1783. X    }
  1784. X    else if (!strcmp(new_type, "short")) {
  1785. X    is_numeric = VAR_LONG;
  1786. X    }
  1787. X    else if (!strcmp(new_type, "unsigned short")) {
  1788. X    is_numeric = VAR_LONG;
  1789. X    }
  1790. X    else if (!strcmp(new_type, "int")) {
  1791. X    is_numeric = VAR_LONG;
  1792. X    }
  1793. X    else if (!strcmp(new_type, "unsigned int")) {
  1794. X    is_numeric = VAR_LONG;
  1795. X    }
  1796. X    else if (!strcmp(new_type, "long")) {
  1797. X    is_numeric = VAR_LONG;
  1798. X    }
  1799. X    else if (!strcmp(new_type, "unsigned long")) {
  1800. X    is_numeric = VAR_LONG;
  1801. X    }
  1802. X    else if (!strcmp(new_type, "float")) {
  1803. X    is_numeric = VAR_DOUBLE;
  1804. X    }
  1805. X    else if (!strcmp(new_type, "double")) {
  1806. X    is_numeric = VAR_DOUBLE;
  1807. X    }
  1808. X    else {
  1809. X    cerr << "WARNING: " << " - change_type(" << new_type << ") - unrecognized type name." << endl;
  1810. X    }
  1811. X    delete new_type;
  1812. X}
  1813. X
  1814. X
  1815. Xint var::is_string(void) const
  1816. X{
  1817. X    return is_numeric == VAR_STRING;
  1818. X}
  1819. X
  1820. X
  1821. Xint var::is_double(void) const
  1822. X{
  1823. X    return is_numeric == VAR_DOUBLE;
  1824. X}
  1825. X
  1826. X
  1827. Xint var::is_long(void) const
  1828. X{
  1829. X    return is_numeric == VAR_LONG;
  1830. X}
  1831. X
  1832. X
  1833. Xint var::strchr(const char ch) const
  1834. X{
  1835. X    for (int i = 0; i < data_str_end; ++i) {
  1836. X    if (data_str[i] == ch) {
  1837. X        return i;
  1838. X    }
  1839. X    }
  1840. X    return -1;
  1841. X}
  1842. X
  1843. X
  1844. Xint var::strrchr(const char ch) const
  1845. X{
  1846. X    for (int i = data_str_end - 1; i >= 0; --i) {
  1847. X    if (data_str[i] == ch) {
  1848. X        return i;
  1849. X    }
  1850. X    }
  1851. X    return -1;
  1852. X}
  1853. X
  1854. X
  1855. Xvar & var::concat(const var & str)
  1856. X{
  1857. X    // concatenate strings
  1858. X    int new_data_str_end = data_str_end + str.data_str_end;
  1859. X    if (new_data_str_end >= data_str_len) {
  1860. X    var add;
  1861. X    add.data_str_len = data_str_len + str.data_str_len + VAR_PAD_SIZE;
  1862. X    add.data_str_end = new_data_str_end;
  1863. X    add.data_str = new char[add.data_str_len];
  1864. X    strcpy(add.data_str, data_str);
  1865. X    strcpy((add.data_str) + data_str_end, str.data_str);
  1866. X    *this = add;
  1867. X    }
  1868. X    else {
  1869. X    strcpy(data_str + data_str_end, str.data_str);
  1870. X    data_str_end += str.data_str_end;
  1871. X    }
  1872. X    return *this;
  1873. X}
  1874. X
  1875. X
  1876. Xvar & var::format(const char * fmt)
  1877. X{
  1878. X    if (format_str
  1879. X    && format_str != DEFAULT_STRING_FORMAT
  1880. X    && format_str != DEFAULT_INT_FORMAT
  1881. X    && format_str != DEFAULT_UINT_FORMAT
  1882. X    && format_str != DEFAULT_LONG_FORMAT
  1883. X    && format_str != DEFAULT_ULONG_FORMAT
  1884. X    && format_str != DEFAULT_DOUBLE_FORMAT) {
  1885. X        delete format_str;
  1886. X    }
  1887. X    if (fmt) {
  1888. X    format_str = new char[strlen(fmt) + 1];
  1889. X    strcpy(format_str, fmt);
  1890. X    }
  1891. X    else {
  1892. X    format_str = NULL;
  1893. X    }
  1894. X    return *this;
  1895. X}
  1896. X
  1897. X
  1898. Xint var::numcheck(const char * str) const
  1899. X{
  1900. X    if (!str || !*str) {
  1901. X    return VAR_STRING;        // assume a string
  1902. X    }
  1903. X    char *ptr = (char *) str;
  1904. X    int nc = VAR_LONG;            // assume a signed long
  1905. X    int decimal_yet = 0;
  1906. X    if (*ptr == '.' && *(ptr + 1)) {
  1907. X    nc = VAR_DOUBLE;        // floating point number
  1908. X    decimal_yet = 1;
  1909. X    ++ptr;
  1910. X    }
  1911. X    else if (*ptr == '-' && *(ptr + 1)) {
  1912. X    // skip optional sign char
  1913. X    ++ptr;
  1914. X    }
  1915. X    while (*ptr) {
  1916. X    if (*ptr == '.' && !decimal_yet) {
  1917. X        decimal_yet = 1;
  1918. X        nc = VAR_DOUBLE;        // assume a double
  1919. X    }
  1920. X    else if (!isdigit(*ptr)) {
  1921. X        return VAR_STRING;        // nope.. got a string
  1922. X    }
  1923. X    ++ptr;
  1924. X    }
  1925. X    return nc;
  1926. X}
  1927. X
  1928. X// -----------------------------------------------------------------------------
  1929. X
  1930. Xint var::save_it(const int save_flag)
  1931. X{
  1932. X    int s = var::save_me;
  1933. X    var::save_me = save_flag;
  1934. X    return s;
  1935. X}
  1936. X
  1937. X// -----------------------------------------------------------------------------
  1938. X
  1939. Xostream & operator << (ostream &out, const var &d)
  1940. X{
  1941. X    d.print(out);
  1942. X    return out;
  1943. X}
  1944. X
  1945. X
  1946. Xvoid var::print(ostream &out) const
  1947. X{
  1948. X    // NOTE: the "read()" function requires a newline to appear after the last quote.
  1949. X    // I assume that this newline was appropriately output by the var class user.
  1950. X    if (!format_str || (format_str && *format_str == 0)) {
  1951. X    out << "var OBJECT: {"
  1952. X        << Inc << "fixed        = " << fixed
  1953. X        << Tab << "is_numeric   = " << is_numeric
  1954. X        << Tab << "data_str_len = " << data_str_len
  1955. X        << Tab << "data_str_end = " << data_str_end
  1956. X        << Tab << "data_str     = '" << data_str << "'"
  1957. X        << Tab << "format_str   = '" << format_str << "'"
  1958. X        << Dec << "}" << endl;
  1959. X    }
  1960. X    else {
  1961. X    // we need to use the specified format string for output
  1962. X    int len = length() + 1;
  1963. X    char *outbuf = new char[2048];
  1964. X    char *fptr = format_str;
  1965. X    while (*fptr) {
  1966. X        if (*fptr != '%' && *fptr != '\\') {
  1967. X        out << *fptr;
  1968. X        ++fptr;
  1969. X        }
  1970. X        else if (*fptr == '\\') {
  1971. X        switch (*(fptr + 1)) {
  1972. X            case 'n':
  1973. X            cout << '\n';
  1974. X            break;
  1975. X            case 't':
  1976. X            cout << '\t';
  1977. X            break;
  1978. X            case 'v':
  1979. X            cout << '\v';
  1980. X            break;
  1981. X            case 'b':
  1982. X            cout << '\b';
  1983. X            break;
  1984. X            case 'r':
  1985. X            cout << '\r';
  1986. X            break;
  1987. X            case 'f':
  1988. X            cout << '\f';
  1989. X            break;
  1990. X            case 'a':
  1991. X            cout << '\007';
  1992. X            break;
  1993. X            case '\\':
  1994. X            cout << '\\';
  1995. X            break;
  1996. X            case '?':
  1997. X            cout << '\?';
  1998. X            break;
  1999. X            case '\'':
  2000. X            cout << '\'';
  2001. X            break;
  2002. X            case '\"':
  2003. X            cout << '\"';
  2004. X            break;
  2005. X            default:
  2006. X            cout << *(fptr + 1);
  2007. X        }
  2008. X        fptr += 2;
  2009. X        }
  2010. X        else {
  2011. X        // Hmmm.. we need to do some special formatting
  2012. X        // first extract this printf-style format string
  2013. X        char smallfmtstr[128];
  2014. X        char *smptr = smallfmtstr;
  2015. X        *smptr = 0;
  2016. X        if (*(fptr + 1) == '%') {
  2017. X            strcpy(outbuf, "%");
  2018. X            fptr += 2;
  2019. X        }
  2020. X        else {
  2021. X            while (*fptr) {
  2022. X            *smptr = *fptr++;
  2023. X            *(smptr + 1) = 0;
  2024. X            // integer
  2025. X            if (*smptr == 'd') {
  2026. X                sprintf(outbuf, smallfmtstr, (int) *this);
  2027. X                break;
  2028. X            }
  2029. X            // unsigned integer
  2030. X            if (*smptr == 'o' || *smptr == 'u' || *smptr == 'x' || *smptr == 'X') {
  2031. X                sprintf(outbuf, smallfmtstr, (unsigned int) *this);
  2032. X                break;
  2033. X            }
  2034. X            // float or double
  2035. X            if (*smptr == 'f' || *smptr == 'e' || *smptr == 'E' || *smptr == 'g' || *smptr == 'G') {
  2036. X                sprintf(outbuf, smallfmtstr, (double) *this);
  2037. X                break;
  2038. X            }
  2039. X            // character
  2040. X            if (*smptr == 'c') {
  2041. X                if (!strcmp(vartype(), "VAR_STRING")) {
  2042. X                const char *tmp = (const char *) (*this);
  2043. X                sprintf(outbuf, smallfmtstr, tmp[0]);
  2044. X                }
  2045. X                else {
  2046. X                sprintf(outbuf, smallfmtstr, (char) ((int) *this));
  2047. X                }
  2048. X                break;
  2049. X            }
  2050. X            // string
  2051. X            if (*smptr == 's') {
  2052. X                sprintf(outbuf, smallfmtstr, (const char *) *this);
  2053. X                break;
  2054. X            }
  2055. X            ++smptr;
  2056. X            }
  2057. X        }
  2058. X        out << outbuf;
  2059. X        }
  2060. X    }
  2061. X    out << flush;
  2062. X    delete outbuf;
  2063. X    }
  2064. X}
  2065. X
  2066. X
  2067. Xistream & operator >> (istream &in, var &d)
  2068. X{
  2069. X    d.read(in);
  2070. X    return in;
  2071. X}
  2072. X
  2073. X
  2074. Xvoid var::read(istream &in)
  2075. X{
  2076. X    // input the same format as was created by the output operator
  2077. X    char buf1[4096];
  2078. X    char buf2[4096];
  2079. X    if (!format_str || (format_str && *format_str == 0)) {
  2080. X    look_for(in, '{');
  2081. X    look_for(in, '=');
  2082. X    in >> fixed;
  2083. X    look_for(in, '=');
  2084. X    in >> is_numeric;
  2085. X    look_for(in, '=');
  2086. X    in >> data_str_len;
  2087. X    look_for(in, '=');
  2088. X    in >> data_str_end;
  2089. X    look_for(in, '=');
  2090. X    scan_string(in, buf1, sizeof(buf1));
  2091. X    look_for(in, '=');
  2092. X    scan_string(in, buf2, sizeof(buf2));
  2093. X    look_for(in, '}');
  2094. X    *this = buf1;
  2095. X    format(buf2);
  2096. X    }
  2097. X    else {
  2098. X    // LEE: need to add input/output formatting capabilities
  2099. X    }
  2100. X}
  2101. X
  2102. END_OF_FILE
  2103.   if test 30983 -ne `wc -c <'var.C'`; then
  2104.     echo shar: \"'var.C'\" unpacked with wrong size!
  2105.   fi
  2106.   # end of 'var.C'
  2107. fi
  2108. echo shar: End of archive 1 \(of 2\).
  2109. cp /dev/null ark1isdone
  2110. MISSING=""
  2111. for I in 1 2 ; do
  2112.     if test ! -f ark${I}isdone ; then
  2113.     MISSING="${MISSING} ${I}"
  2114.     fi
  2115. done
  2116. if test "${MISSING}" = "" ; then
  2117.     echo You have unpacked both archives.
  2118.     rm -f ark[1-9]isdone
  2119. else
  2120.     echo You still must unpack the following archives:
  2121.     echo "        " ${MISSING}
  2122. fi
  2123. exit 0
  2124. exit 0 # Just in case...
  2125.