Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/misc/volume33/var/part01

Text File | 1992-11-28 | 54.4 KB | 2,185 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Lee Hounshell)
Subject:  v33i127:  var - C++ class library "var" (v1.1) and "VarMap" (associative arrays), Part01/02
Message-ID: <csm-v33i127=[e-mail]>
X-Md4-Signature: 1694cd4714b8b4ce309b6b33452adcd2
Date: Wed, 25 Nov 1992 21:56:33 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Lee Hounshell)
Posting-number: Volume 33, Issue 127
Archive-name: var/part01
Environment: C++, G++
Supersedes: var: Volume 31, Issue 91-92

This is the latest release of "var", and "VarMap".
This is a C++ object library that provides a "super-string" class with
"associative array" capabilities.

The var class does a pretty good job of offering a data object that assumes
its "type" at run time, based on context of use.  Rarely will you need to
declare int's, or longs, or doubles or char[] or even string objects!
"Var" does it all (or at least tries to).

    + var will do base data types (eg: int, long, char *, float, string ...)
    + var will do arithmetic
    + var will do strings and operations on strings
    + var will do sub-strings and operations on sub-strings
    + var will intelligently "mix" operations between mixed types
    + var will do formatted output using the stream library
    + individual vars can be "staticly" typed, or they can assume
      type at runtime, based on context.
    + VarMap will do associative arrays of vars indexed by vars.

To use this class, simply type make and a library file "libvar.a" will be
created.  This class has been used extensively here at Pacific Bell as a
base class in development of our own internal C++ class libraries. I've
even used "var" as the YYSTYPE type inside yacc/lex programs!!

To try out the enclosed demo programs, type "make demo".

Both var and VarMap have been tested and used on the following architectures:

    - Sun C++ versions 2.0 and 2.1
    - AT&T C++ versions 2.0 and 2.1
    - g++ (yes, I now support GNU C++!!)

If you like (or dislike) var and/or VarMap, please drop me a line.
Mail bug reports and comments to:
[e-mail]

-Lee
--------
#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# Contents:  README demo2.C var.3++ var.C
# Wrapped by kent@sparky on Tue Nov 24 09:31:37 1992
PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive 1 (of 2)."'
if test -f 'README' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'README'\"
else
  echo shar: Extracting \"'README'\" \(1566 characters\)
  sed "s/^X//" >'README' <<'END_OF_FILE'
X
XThis is the latest release of "var", and "VarMap".
XThis is a C++ object library that provides a "super-string" class with
X"associative array" capabilities.
X
XThe var class does a pretty good job of offering a data object that assumes
Xits "type" at run time, based on context of use.  Rarely will you need to
Xdeclare int's, or longs, or doubles or char[] or even string objects!
X"Var" does it all (or at least tries to).
X
X    + var will do base data types (eg: int, long, char *, float, string ...)
X    + var will do arithmetic
X    + var will do strings and operations on strings
X    + var will do sub-strings and operations on sub-strings
X    + var will intelligently "mix" operations between mixed types
X    + var will do formatted output using the stream library
X    + individual vars can be "staticly" typed, or they can assume
X      type at runtime, based on context.
X    + VarMap will do associative arrays of vars indexed by vars.
X
XTo use this class, simply type make and a library file "libvar.a" will be
Xcreated.  This class has been used extensively here at Pacific Bell as a
Xbase class in development of our own internal C++ class libraries. I've
Xeven used "var" as the YYSTYPE type inside yacc/lex programs!!
X
XTo try out the enclosed demo programs, type "make demo".
X
XBoth var and VarMap have been tested and used on the following architectures:
X
X    - Sun C++ versions 2.0 and 2.1
X    - AT&T C++ versions 2.0 and 2.1
X    - g++ (yes, I now support GNU C++!!)
X
XIf you like (or dislike) var and/or VarMap, please drop me a line.
XMail bug reports and comments to:
[e-mail]
X
X-Lee
END_OF_FILE
  if test 1566 -ne `wc -c <'README'`; then
    echo shar: \"'README'\" unpacked with wrong size!
  fi
  # end of 'README'
fi
if test -f 'demo2.C' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'demo2.C'\"
else
  echo shar: Extracting \"'demo2.C'\" \(362 characters\)
  sed "s/^X//" >'demo2.C' <<'END_OF_FILE'
X#include    <VarMap.H>
X
Xmain ()
X{
X    VarMap aa;                // declare a VarMap
X    var lee = "foobar";
X    if (!aa.element(lee)) {
X    aa[lee] = "hello world";    // create/assign using index "foobar"
X    }
X    aa[42] = "testing 123";        // create/assign using index "42"
X    aa[5] = 123.45;            // create/assign using index "5"
X    aa.display();            // display this map to stderr
X}
X
END_OF_FILE
  if test 362 -ne `wc -c <'demo2.C'`; then
    echo shar: \"'demo2.C'\" unpacked with wrong size!
  fi
  # end of 'demo2.C'
fi
if test -f 'var.3++' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'var.3++'\"
else
  echo shar: Extracting \"'var.3++'\" \(15362 characters\)
  sed "s/^X//" >'var.3++' <<'END_OF_FILE'
X.po 6
X.TH VAR 3++ "1/92" "Version 1.1" "Variable Base Type String Class Library"
X
X.SH CLASS
XVAR    \- Variable Base Type String Class Library
X.SH SYNOPSIS
X.B #include     <var.H>
X.PP
X.nf
X.ta.5i 1.0i 4.0i
X\fB
Xclass var {
X
X  public:
X    // Constructors & Destructors
X    var(void);                    // constructor
X    var(const varsize &);            // constructor
X    var(const char *);                // constructor
X    var(const char);                // constructor
X    var(const short);                // constructor
X    var(const unsigned short);            // constructor
X    var(const int);                // constructor
X    var(const unsigned int);            // constructor
X    var(const long);                // constructor
X    var(const unsigned long);            // constructor
X    var(const double);                // constructor
X    var(const var &);                // copy constructor
X    ~var(void);                    // destructor
X
X    // Operators
X    var & operator = (const char *);        // assignment
X    var & operator = (const var &);        // assignment
X    char & operator [] (const int);        // indexing
X    subvar & operator () (int, int) const;    // substring
X    subvar & operator () (const int) const;    // substring
X    friend ostream & operator << (ostream &, const var &); // output
X    friend class subvar;            // substring
X
X    // More Operators (used for arithmetic type extension)
X    var & operator = (const char);        // assignment
X    var & operator = (const short);        // assignment
X    var & operator = (const unsigned short);    // assignment
X    var & operator = (const int);        // assignment
X    var & operator = (const unsigned int);    // assignment
X    var & operator = (const long);        // assignment
X    var & operator = (const unsigned long);    // assignment
X    var & operator = (const double);        // assignment
X
X    // Casting Operators
X    operator char * (void) const;        // type conversion
X    operator double (void) const;        // type conversion
X
X    // Assignment Operators
X    var & operator ++ (void);            // increment (pre-index only)
X    var & operator -- (void);            // decrement (pre-index only)
X    var operator ! (void) const;        // not
X
X    var operator + (const var &) const;        // addition OR concatenation
X    var operator - (const var &) const;        // subtraction
X    var operator * (const var &) const;        // multiplication
X    var operator / (const var &) const;        // division
X    var operator % (const var &) const;        // remainder
X
X    var & operator += (const var &);        // addition OR concatenation
X    var & operator -= (const var &);        // subtraction
X    var & operator *= (const var &);        // multiplication
X    var & operator /= (const var &);        // division
X    var & operator %= (const var &);        // remainder
X
X    var & operator += (const char &);        // addition OR concatenation
X    var & operator += (const char *);        // addition OR concatenation
X    var & operator -= (const char *);        // subtraction
X    var & operator *= (const char *);        // multiplication
X    var & operator /= (const char *);        // division
X    var & operator %= (const char *);        // remainder
X
X    var & operator += (const double);        // addition OR concatenation
X    var & operator -= (const double);        // subtraction
X    var & operator *= (const double);        // multiplication
X    var & operator /= (const double);        // division
X    var & operator %= (const double);        // remainder
X
X    friend var operator + (const char *, const var &); // addition OR concatenation
X    friend var operator - (const char *, const var &); // subtraction
X    friend var operator * (const char *, const var &); // multiplication
X    friend var operator / (const char *, const var &); // division
X    friend var operator % (const char *, const var &); // remainder
X    friend var operator + (const var &, const char *); // addition OR concatenation
X    friend var operator - (const var &, const char *); // subtraction
X    friend var operator * (const var &, const char *); // multiplication
X    friend var operator / (const var &, const char *); // division
X    friend var operator % (const var &, const char *); // remainder
X
X    friend var operator + (const var &, const double); // addition OR concatenation
X    friend var operator - (const var &, const double); // subtraction
X    friend var operator * (const var &, const double); // multiplication
X    friend var operator / (const var &, const double); // division
X    friend var operator % (const var &, const double); // remainder
X    friend var operator + (const double, const var &); // addition OR concatenation
X    friend var operator - (const double, const var &); // subtraction
X    friend var operator * (const double, const var &); // multiplication
X    friend var operator / (const double, const var &); // division
X    friend var operator % (const double, const var &); // remainder
X
X    // Equality Operators
X    int operator == (const var &) const;    // equality
X    int operator != (const var &) const;    // inequality
X    int operator < (const var &) const;        // less than
X    int operator > (const var &) const;        // greater than
X    int operator <= (const var &) const;    // less than or equal
X    int operator >= (const var &) const;    // greater than or equal
X
X    friend int operator == (const var &, const char *); // equality
X    friend int operator != (const var &, const char *); // inequality
X    friend int operator < (const var &, const char *);  // less than
X    friend int operator > (const var &, const char *);  // greater than
X    friend int operator <= (const var &, const char *); // less than or equal
X    friend int operator >= (const var &, const char *); // greater than or equal
X    friend int operator == (const char *, const var &); // equality
X    friend int operator != (const char *, const var &); // inequality
X    friend int operator < (const char *, const var &);  // less than
X    friend int operator > (const char *, const var &);  // greater than
X    friend int operator <= (const char *, const var &); // less than or equal
X    friend int operator >= (const char *, const var &); // greater than or equal
X
X    friend int operator == (const var &, const double); // equality
X    friend int operator != (const var &, const double); // inequality
X    friend int operator < (const var &, const double);  // less than
X    friend int operator > (const var &, const double);  // greater than
X    friend int operator <= (const var &, const double); // less than or equal
X    friend int operator >= (const var &, const double); // greater than or equal
X    friend int operator == (const double, const var &); // equality
X    friend int operator != (const double, const var &); // inequality
X    friend int operator < (const double, const var &);  // less than
X    friend int operator > (const double, const var &);  // greater than
X    friend int operator <= (const double, const var &); // less than or equal
X    friend int operator >= (const double, const var &); // greater than or equal
X
X    // Custom Interface
X    void null(int);                // "null" out string
X    void changesize(int);            // change allocated memory
X    int length(void) const;            // length of string
X    const char * vartype(void) const;        // name of this var type
X    void change_type(const char *);        // change var type
X    int is_string(void) const;            // test var type
X    int is_double(void) const;            // test var type
X    int is_long(void) const;            // test var type
X    int strchr(const char) const;        // strchr(char) index
X    int strrchr(const char) const;        // strrchr(char) index
X    var & concat(const var &);            // concatenation
X    var & format(const char *);            // set output format
X};
X.fi
X\fP
X
X.SH DESCRIPTION
XClass \fBvar\fP represents a \fBstring\fP object class that also provides all
Xthe traditional functionality of the C base types: char, int, long, float, double, and char*.
X\fBVar\fP, is in many ways a "super-string" class.
XThe var class does a pretty good job of offering a base data "container" object that can either
Xassume its "type" at run time, based on context or remain a "fixed" type, always.
X
X.SS var will do
X.TP 2
X+
Xall the base data types (eg: short, int, long, char *, float, double ...)
X.TP 2
X+
Xstring types
X.TP 2
X+
Xarithmetic
X.TP 2
X+
Xstrings and operations on strings
X.TP 2
X+
Xsub-strings and operations on sub-strings
X.TP 2
X+
Xintelligent "mixing" of operations between mixed types
X.TP 2
X+
Xformatted output using the stream library
X
X.SH PUBLIC CONSTRUCTORS
X.SS var(void);
XThis constructor is used to declare an "untyped" var object.  Type is determined
Xat run-time, based on context of use.
X
X.SS var(const varsize &);
XThis constructor is used to declare an "string" var object, with preallocated memory.
XThe object's type can change at run-time, based on context.
X
X.SS var(const char *);
XThis constructor is used to declare a "string" object initialize from a "char *".
XThe object's type can change at run-time, based on context.
X
X.SS var(const char);
XThis constructor is used to declare an "numeric" var object, initialized from a char.
XThe object's type can change at run-time, based on context.
X
X.SS var(const short);
XThis constructor is used to declare an "numeric" var object, initialized from a short.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const unsigned short);
XThis constructor is used to declare an "numeric" var object, initialized from an unsigned short.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const int);
XThis constructor is used to declare an "numeric" var object, initialized from an int.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const unsigned int);
XThis constructor is used to declare an "numeric" var object, initialized from an unsigned int.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const long);
XThis constructor is used to declare an "numeric" var object, initialized from a long.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const unsigned long);
XThis constructor is used to declare an "numeric" var object, initialized from an unsigned long.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const double);
XThis constructor is used to declare an "numeric" var object, initialized from a double or float.
XThe object's type is fixed and will not change at run-time.
X
X.SS var(const var &);
XThis constructor is used to declare a var object, which is a copy of another var.
XThe object assumes the characteristics of the initializing object.
X
X.SS ~var(void);
XThe destructor returns all memory allocated by the object back to the OS.
X
X
X.SH PUBLIC OPERATORS
X.SS Arithmetic and Concatenation Operators
XMost operators (+, -, /, *, %, +=, etc..) will operate as expected.
XThe "+" and "+=" operators will either do addition or concatenation, as appropriate.
Xif concatenation is required, then the \fB"var.concat(var)"\fP member function should
Xbe used.
X
X.SS Relational Operators
XThese also operate as expected.  If "string" objects are compared, the comparison
Xwill be as performed by \fBstrcmp(3)\fP.
X
X.SS The Indexing Operator []
XYou can index a character from inside a \fBvar\fP by using
Xthe \fB"char & operator [] (const int);"\fP operator.
XIf you attempt to index \fBbeyond\fP a \fBvar\fP object's current end, then
Xthe referenced object will be automatically extended (padded with spaces)
Xto the desired length.
XA reference to the character is returned, which can be assigned to.
XDo not assign the NULL character using this operator.
XInstead call the member function \fB"null(index)"\fP.
X
X.SS Sub-strings
XTwo operators are provide for substring operation.  The
Xfirst, \fB"subvar & operator () (int start, int length) const;"\fP
Xwill extract a string starting at "start" for "length" characters.
XThe second, \fB"subvar & operator () (const int start) const;"\fP will
Xextract a string starting at "start" to the end of the string.
X
X.SS Type Casting
XOnly two type casts are required by \fBvar\fP. The first converts
Xthe object into a "char *".  The second converts the object into a
Xdouble.  Implicit conversion between "char *" and "double" types
Xwill be performed by your C++ compiler.
X
X.SS Formatted Output
XYou can use \fBvar\fP with the io stream library.  Objects can be
Xoutput using the ">>" operator.
XFor formatted output, be sure to set the object's "format template"
Xprior to calling the ">>" operator.  (see \fB"var & format(const char *);"\fP)
X
X.SH PUBLIC MEMBER FUNCTIONS
X
X.SS Truncating a string
XThe \fB"void null(int index);"\fP function will truncate a \fBvar\fP
Xobject, starting from the specified index postion.
X
X.SS Memory Allocation
XThe \fB"void changesize(int newsize);"\fP can be used to increase
Xallocated memory for a var.  Memory can NOT be decreased.  Allocated
Xmemory is returned to the heap when an object goes out of scope.
X
X.SS Determining Var's Length
XThe \fB"int length(void) const;"\fP function returns the "size" of a \fBvar\fP.
X
X.SS Determining Var's Type
XThe \fB"const char * vartype(void) const;"\fP function returns the "type" of a \fBvar\fP.
XPossible types are: "VAR_STRING", "VAR_LONG" and "VAR_DOUBLE".
X
X.SS Explititly Changing a Var's Type
XThe \fB"void change_type(const char *newtype);"\fP function can be used
Xto set an exact type.  Valid values for "newtype" are "string", "short",
X"unsigned short", "int", "unsigned int", "long", "unsigned long",
X"float", and "double".
X
X.SS Testing a Var's Type
XThree functions are provided that allow testing a \fBvar\fP type.
XThey are as follows: \fB"int is_string(void) const;"\fP,
X\fB"int is_double(void) const;"\fP, and \fB"int is_long(void) const;"\fP
X
X.SS Searching for a Character
XTwo functions are provided that search a \fBvar\fP for a specified
Xcharacter.  Both return an offset.  The first \fB"int strchr(const char) const;"\fP
Xsearches forward.  The second, \fB"int strrchr(const char) const;"\fP
Xsearches backward.
X
X.SS Concatenation
XConcatenation can be forced, regardless of type with the \fB"var & concat(const var &);"\fP
Xfunction.
X
X.SS Setting the Output Format
XThe \fB"var & format(const char *fmt);"\fP function will allow you to specify an
Xoutput format.  This format will remain in effect until changed.  Printf()
Xstyle output formats can be introduced anywhere in the format statment.
XMultiple formateed output directives can appear in the same "fmt".  Each
Xdirective will receive a copy of the object.  Automatic type conversion will
Xoccur.
X
X
X.SH AUTHOR
XLee Hounshell - 1/92
X
X.SH EXAMPLE
X.nf
X#include    <var.H>
X
Xmain ()
X{
X    var value;                // declare an "untyped" var
X    value = "hello world";        // initialize it
X    cout << value << "\n";        // output "hello world"
X    value = value(3, value.length() - 6); // substring example
X    cout << value << "\n";        // output "lo wo"
X    value = 34;                // assignment of int
X    value++;                // increment
X    value += 42.375;            // add 42.375 to present value
X    cout << value << "\n";        // output "77.375"
X    cout << value.format("formatted output example %05d of value\n");
X    cout << value.format("multiple outputs #1=%d, #2=%9.2f of value\n");
X    value.null(2);            // truncate string
X    value += " sunset strip";        // concatenate a string
X    cout << value.format("%s\n");    // output "77 sunset strip"
X    cout << value[3] << value[4] << value[5] << "\n"; // output "sun"
X}
X.fi
X
X.SH SUPERCLASSES
Xnone.
X
X.SH SUBCLASSES
Xnone
X
X.SH BUGS
XAssignment of an array of vars to another array of vars
Xmust currently be done one element at a time.
XVar now works with g++. (version 1.1)
XString contatenation problem fixed. (version 1.1)
XMemory leak fixed. (version 1.1)
X
END_OF_FILE
  if test 15362 -ne `wc -c <'var.3++'`; then
    echo shar: \"'var.3++'\" unpacked with wrong size!
  fi
  # end of 'var.3++'
fi
if test -f 'var.C' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'var.C'\"
else
  echo shar: Extracting \"'var.C'\" \(31997 characters\)
  sed "s/^X//" >'var.C' <<'END_OF_FILE'
X//
X// NAME:    var.C
X//
X// PURPOSE:    C++ Generic "Universal Variable" library class
X// VERSION:    1.1
X// AUTHOR:    Lee Hounshell
X// LAST MOD:    Mon Nov 23 08:56:24 PST 1992
X//
X
X#include    <stddef.h>
X#include    <stream.h>
X#include    <stdlib.h>
X#include    <ctype.h>
X#include    <string.h>
X#include    <memory.h>
X#include    "var.H"
X
Xconst int    VAR_PAD_SIZE        = 128;
Xconst int    VAR_DEF_SIZE        = 16;
X
Xconst short    VAR_STRING        = 0;
Xconst short    VAR_LONG        = 1;
Xconst short    VAR_DOUBLE        = 2;
X
Xchar *    DEFAULT_STRING_FORMAT        = "'%s'";
Xchar *    DEFAULT_INT_FORMAT        = "%d";
Xchar *    DEFAULT_UINT_FORMAT        = "%u";
Xchar *    DEFAULT_LONG_FORMAT        = "%ld";
Xchar *    DEFAULT_ULONG_FORMAT        = "%lu";
Xchar *    DEFAULT_DOUBLE_FORMAT        = "%9.2f";
X
X// -----------------------------------------------------------------------------
X
X
Xconst var & var::type(void) const
X{
X    static const var objtype = "var";
X    return objtype;
X}
X
X
Xvarsize::varsize(int sz)
X{
X    size = sz;
X}
X
X
Xvar::var(void)
X{
X    fixed = 0;
X    is_numeric = VAR_STRING;
X    data_str_len = VAR_DEF_SIZE;
X    data_str_end = 0;
X    data_str = new char[data_str_len];
X    data_str[0] = 0;
X    format_str = DEFAULT_STRING_FORMAT;
X}
X
X
Xvar::var(const char *str)
X{
X    fixed = 1;
X    is_numeric = VAR_STRING;
X    data_str_end = strlen(str);
X    data_str_len = data_str_end + VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, str);
X    format_str = DEFAULT_STRING_FORMAT;
X}
X
X
Xvar::var(const varsize &vsz)
X{
X    fixed = 0;
X    is_numeric = VAR_STRING;
X    data_str_len = vsz.size + VAR_DEF_SIZE;
X    data_str_end = 0;
X    data_str = new char[data_str_len];
X    data_str[0] = 0;
X    format_str = DEFAULT_STRING_FORMAT;
X}
X
X
Xvar::var(const char ch)
X{
X    fixed = 0;
X    is_numeric = VAR_STRING;
X    data_str_len = VAR_DEF_SIZE;
X    data_str_end = 1;
X    data_str = new char[data_str_len];
X    data_str[0] = ch;
X    data_str[1] = 0;
X    format_str = DEFAULT_STRING_FORMAT;
X}
X
X
Xvar::var(const short int_num)
X{
X    fixed = 1;
X    is_numeric = VAR_LONG;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, itoa((const int) int_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_INT_FORMAT;
X}
X
X
Xvar::var(const unsigned short int_num)
X{
X    fixed = 1;
X    is_numeric = VAR_LONG;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, itoa((const int) int_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_UINT_FORMAT;
X}
X
X
Xvar::var(const int int_num)
X{
X    fixed = 1;
X    is_numeric = VAR_LONG;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, itoa(int_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_INT_FORMAT;
X}
X
X
Xvar::var(const unsigned int int_num)
X{
X    fixed = 1;
X    is_numeric = VAR_LONG;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, itoa((const int) int_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_UINT_FORMAT;
X}
X
X
Xvar::var(const long long_num)
X{
X    fixed = 1;
X    is_numeric = VAR_LONG;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, ltoa(long_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_LONG_FORMAT;
X}
X
X
Xvar::var(const unsigned long long_num)
X{
X    fixed = 1;
X    is_numeric = VAR_LONG;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, ltoa(long_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_ULONG_FORMAT;
X}
X
X
Xvar::var(const double double_num)
X{
X    fixed = 1;
X    is_numeric = VAR_DOUBLE;
X    data_str_len = VAR_DEF_SIZE;
X    data_str = new char[data_str_len];
X    strcpy(data_str, dtoa(double_num));
X    data_str_end = strlen(data_str);
X    format_str = DEFAULT_DOUBLE_FORMAT;
X}
X
X
Xvar::var(const var &v)
X{
X    fixed = v.fixed;
X    is_numeric = v.is_numeric;
X    if (v.data_str && v.data_str_end) {
X    data_str_len = v.data_str_end + VAR_DEF_SIZE;
X    data_str_end = v.data_str_end;
X    data_str = new char[data_str_len];
X    strcpy(data_str, v.data_str);
X    }
X    else {
X    data_str_len = VAR_DEF_SIZE;
X    data_str_end = 0;
X    data_str = new char[data_str_len];
X    data_str[0] = 0;
X    }
X    format_str = DEFAULT_STRING_FORMAT;
X}
X
X
Xvar::~var(void)
X{
X    if (data_str) {
X    delete data_str;
X    }
X    if (format_str
X    && format_str != DEFAULT_STRING_FORMAT
X    && format_str != DEFAULT_INT_FORMAT
X    && format_str != DEFAULT_UINT_FORMAT
X    && format_str != DEFAULT_LONG_FORMAT
X    && format_str != DEFAULT_ULONG_FORMAT
X    && format_str != DEFAULT_DOUBLE_FORMAT) {
X        delete format_str;
X    }
X}
X
X// -----------------------------------------------------------------------------
X
Xvar & var::operator = (const char *str)
X{
X    //
X    if (fixed && is_numeric) {
X    if (is_numeric == VAR_DOUBLE) {
X        double d = atod((char *) str);
X        *this = d;
X    }
X    else {
X        long l = atol(str);
X        *this = l;
X    }
X    }
X    else {
X    int len = strlen(str) + 1;
X    if (data_str_len < len) {
X        delete data_str;
X        data_str_len = len;
X        data_str = new char[data_str_len];
X    }
X    data_str_end = len - 1;
X    strcpy(data_str, str);
X    if (!fixed) {
X        int str_is_numeric = numcheck(data_str);
X        is_numeric = str_is_numeric;
X    }
X    }
X    return *this;
X}
X
X
Xvar & var::operator = (const var &l)
X{
X    //
X    if (this != &l) {
X    if (data_str_len <= l.data_str_end) {
X        delete data_str;
X        data_str_len = l.data_str_end + VAR_DEF_SIZE;
X        data_str = new char[data_str_len];
X    }
X    data_str_end = l.data_str_end;
X    strncpy(data_str, l.data_str, l.data_str_end);
X    data_str[data_str_end] = 0;
X    if (!fixed) {
X        is_numeric = numcheck(data_str);
X    }
X    //
X    // Note: the output "format" of a var variable is preserved
X    //
X    }
X    return *this;
X}
X
X
Xchar & var::operator [] (const int index)
X{
X    static char error_ch;
X    if (index < 0) {
X    cerr << "ERROR: " << " - var[" << index << "] negative index used.\n";
X    error_ch = 0;
X    return error_ch;
X    }
X    if (data_str_len <= index) {
X    // this is technically a program error, but I'll be nice and extend the string's length
X    data_str_len = index + VAR_PAD_SIZE;
X    data_str_end = index + 1;
X    char *buf = new char[data_str_len];
X    sprintf(buf, "%-*.*s", data_str_end, data_str_end, data_str);
X    delete data_str;
X    data_str = buf;
X    data_str[index] = 0;
X    // cerr << "WARNING: " << " - var index '" << index << "' beyond current string boundary.\n";
X    }
X    while (data_str_end < index) {
X    data_str[data_str_end++] = ' ';        // pad to index with spaces if necessary
X    }
X    if (data_str_end == index) {
X    data_str[data_str_end] = 0;        // the end of a string is ALWAYS 0
X    if ((data_str_end + 1) < data_str_len) {
X        data_str[++data_str_end] = 0;    // the new end of string is also 0
X    }
X    }
X    return data_str[index];
X}
X
X
X// for substrings
Xsubvar & var::operator () (const int offset) const
X{
X    return operator () (offset, -1);
X}
X
X
X// for substrings
Xsubvar & var::operator () (int offset, int length) const
X{
X    static subvar _esi_subvar;
X    if (length < 0) {
X    length = data_str_end - offset;
X    }
X    char *substr = new char[length + 1];
X    strncpy(substr, data_str + offset, (int) length);
X    substr[length] = 0;
X    _esi_subvar.var::operator = (substr);
X    _esi_subvar.varptr = (var *) this;
X    _esi_subvar.offset = offset;
X    _esi_subvar.length = length;
X    delete substr;
X    return _esi_subvar;
X}
X
X
X// for syntax: var(offset, length) = var
Xvar & subvar::operator = (const var &substr)
X{
X    char *srcstr = varptr->data_str;
X    char *repstr = substr.data_str;
X    int replen = length;
X    if (substr.data_str_end < length) {
X    replen = substr.data_str_end;
X    }
X    int len = varptr->data_str_len;
X    char *newstr = new char[len];
X    strncpy(newstr, srcstr, offset);        // data from string being replaced up to "offset"
X    if (replen) {
X    strncpy(newstr + offset, repstr, replen);    // replacement string data
X    }
X    int newoffset = offset + replen;
X    if (newoffset < varptr->data_str_end) {
X    strcpy(newstr + newoffset, srcstr + offset + length);
X    }
X    else {
X    newstr[newoffset] = 0;
X    }
X    if (varptr->data_str) {
X    delete varptr->data_str;
X    }
X    varptr->data_str = newstr;
X    varptr->data_str_len = len;
X    varptr->data_str_end = strlen(newstr);
X    if (!varptr->fixed) {
X    varptr->is_numeric = numcheck(newstr);
X    }
X    return *varptr;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar & var::operator = (const char ch)
X{
X    char buf[2];
X    buf[0] = ch;
X    buf[1] = 0;
X    *this = buf;
X    return *this;
X}
X
X
Xvar & var::operator = (const short int_num)
X{
X    char *str = itoa((const int) int_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    if (!fixed) {
X    is_numeric = VAR_LONG;
X    }
X    return *this;
X}
X
X
Xvar & var::operator = (const unsigned short int_num)
X{
X    char *str = itoa((const int) int_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    is_numeric = VAR_LONG;
X    return *this;
X}
X
X
Xvar & var::operator = (const int int_num)
X{
X    char *str = itoa(int_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    if (!fixed) {
X    is_numeric = VAR_LONG;
X    }
X    return *this;
X}
X
X
Xvar & var::operator = (const unsigned int int_num)
X{
X    char *str = itoa((const int) int_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    if (!fixed) {
X    is_numeric = VAR_LONG;
X    }
X    return *this;
X}
X
X
Xvar & var::operator = (const long long_num)
X{
X    char *str = ltoa(long_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    if (!fixed) {
X    is_numeric = VAR_LONG;
X    }
X    return *this;
X}
X
X
Xvar & var::operator = (const unsigned long long_num)
X{
X    char *str = ltoa(long_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    if (!fixed) {
X    is_numeric = VAR_LONG;
X    }
X    return *this;
X}
X
X
Xvar & var::operator = (const double dbl_num)
X{
X    char *str = dtoa(dbl_num);
X    int len = strlen(str);
X    if (data_str_len < len) {
X    delete data_str;
X    data_str_len = len + 1;
X    data_str = new char[data_str_len];
X    }
X    data_str_end = len;
X    strcpy(data_str, str);
X    if (!fixed) {
X    is_numeric = VAR_DOUBLE;
X    }
X    return *this;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar::operator char * (void) const
X{
X    return data_str;
X}
X
X
Xvar::operator double (void) const
X{
X    return atod(data_str);
X}
X
X// -----------------------------------------------------------------------------
X
Xvar & var::operator ++ (void)        // increment (pre-index only)
X{
X    *this -= (-1);            // because of bug in g++
X    return *this;
X}
X
X
Xvar & var::operator -- (void)        // decrement (pre-index only)
X{
X    *this -= 1;
X    return *this;
X}
X
X
Xvar var::operator ! (void) const    // not
X{
X    var not(1);
X    if ((int) *this) {
X    not = 0;
X    }
X    return not;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar var::operator + (const var & v) const    // addition OR concatenation
X{
X    var add;
X    if (is_numeric && v.is_numeric) {
X    // do math in the highest precision specified
X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
X    switch (n_type) {
X        case VAR_LONG:
X        add = (long) *this + (long) v;
X        break;
X        default:
X        // should be VAR_DOUBLE
X        add = (double) *this + (double) v;
X        break;
X    }
X    }
X    else {
X    // concatenate strings
X    add = (*this);
X    add.concat(v);
X    add.is_numeric = VAR_STRING;
X    }
X    return add;
X}
X
X
Xvar var::operator - (const var & v) const    // subtraction
X{
X    var sub;
X    // do math in the highest precision specified
X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
X    switch (n_type) {
X    case VAR_LONG:
X        sub = (long) *this - (long) v;
X        sub.is_numeric = VAR_LONG;
X        break;
X    default:
X        // should be VAR_DOUBLE
X        sub = (double) *this - (double) v;
X        break;
X    }
X    return sub;
X}
X
X
Xvar var::operator * (const var & v) const    // multiplication
X{
X    var times;
X    // do math in the highest precision specified
X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
X    switch (n_type) {
X    case VAR_LONG:
X        times = (long) *this * (long) v;
X        break;
X    default:
X        // should be VAR_DOUBLE
X        times = (double) *this * (double) v;
X        break;
X    }
X    return times;
X}
X
X
Xvar var::operator / (const var & v) const    // division
X{
X    var div;
X    // do math in the highest precision specified
X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
X    switch (n_type) {
X    case VAR_LONG:
X        div = (long) *this / (long) v;
X        break;
X    default:
X        // should be VAR_DOUBLE
X        div = (double) *this / (double) v;
X        break;
X    }
X    return div;
X}
X
X
Xvar var::operator % (const var & v) const    // remainder
X{
X    var mod;
X    // do math in the highest precision specified
X    int n_type = (is_numeric > v.is_numeric) ? is_numeric : v.is_numeric;
X    switch (n_type) {
X    case VAR_LONG:
X        mod = (long) *this % (long) v;
X        break;
X    default:
X        // should be VAR_DOUBLE
X        // really, I shouldn't allow this..
X        mod = (double) ((long) *this % (long) v);
X        break;
X    }
X    return mod;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar & var::operator += (const var & v)
X{
X    if ((is_numeric == VAR_STRING) || (v.is_numeric == VAR_STRING)) {
X    concat(v);
X    }
X    else {
X    *this = (*this) + v;
X    }
X    return *this;
X}
X
X
Xvar & var::operator -= (const var & v)
X{
X    *this = (*this) - v;
X    return *this;
X}
X
X
Xvar & var::operator *= (const var & v)
X{
X    *this = (*this) * v;
X    return *this;
X}
X
X
Xvar & var::operator /= (const var & v)
X{
X    *this = (*this) / v;
X    return *this;
X}
X
X
Xvar & var::operator %= (const var & v)
X{
X    *this = (*this) % v;
X    return *this;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar & var::operator += (const char & ch)
X{
X    var foo = ch;
X    *this += foo;
X    return *this;
X}
X
Xvar & var::operator += (const char * v)
X{
X    var foo = v;
X    *this += foo;
X    return *this;
X}
X
X
Xvar & var::operator -= (const char * v)
X{
X    var foo = v;
X    *this -= foo;
X    return *this;
X}
X
X
Xvar & var::operator *= (const char * v)
X{
X    var foo = v;
X    *this *= foo;
X    return *this;
X}
X
X
Xvar & var::operator /= (const char * v)
X{
X    var foo = v;
X    *this /= foo;
X    return *this;
X}
X
X
Xvar & var::operator %= (const char * v)
X{
X    var foo = v;
X    *this %= foo;
X    return *this;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar & var::operator += (const double v)
X{
X    var foo = v;
X    *this += foo;
X    return *this;
X}
X
X
Xvar & var::operator -= (const double v)
X{
X    var foo = v;
X    *this -= foo;
X    return *this;
X}
X
X
Xvar & var::operator *= (const double v)
X{
X    var foo = v;
X    *this *= foo;
X    return *this;
X}
X
X
Xvar & var::operator /= (const double v)
X{
X    var foo = v;
X    *this /= foo;
X    return *this;
X}
X
X
Xvar & var::operator %= (const double v)
X{
X    var foo = v;
X    *this %= foo;
X    return *this;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar operator + (const char * s, const var & v)
X{
X    var foo = s;
X    return foo + v;
X}
X
X
Xvar operator - (const char * s, const var & v)
X{
X    var foo = s;
X    return foo - v;
X}
X
X
Xvar operator * (const char * s, const var & v)
X{
X    var foo = s;
X    return foo * v;
X}
X
X
Xvar operator / (const char * s, const var & v)
X{
X    var foo = s;
X    return foo / v;
X}
X
X
Xvar operator % (const char * s, const var & v)
X{
X    var foo = s;
X    return foo % v;
X}
X
X
Xvar operator + (const var & v, const char * s)
X{
X    var foo = s;
X    return v + foo;
X}
X
X
Xvar operator - (const var & v, const char * s)
X{
X    var foo = s;
X    return v - foo;
X}
X
X
Xvar operator * (const var & v, const char * s)
X{
X    var foo = s;
X    return v * foo;
X}
X
X
Xvar operator / (const var & v, const char * s)
X{
X    var foo = s;
X    return v / foo;
X}
X
X
Xvar operator % (const var & v, const char * s)
X{
X    var foo = s;
X    return v % foo;
X}
X
X// -----------------------------------------------------------------------------
X
Xvar operator + (const var & v, const double d)
X{
X    var foo = d;
X    return v + foo;
X}
X
X
Xvar operator - (const var & v, const double d)
X{
X    var foo = d;
X    return v - foo;
X}
X
X
Xvar operator * (const var & v, const double d)
X{
X    var foo = d;
X    return v * foo;
X}
X
X
Xvar operator / (const var & v, const double d)
X{
X    var foo = d;
X    return v / foo;
X}
X
X
Xvar operator % (const var & v, const double d)
X{
X    var foo = d;
X    return v % foo;
X}
X
X
Xvar operator + (const double d, const var & v)
X{
X    var foo = d;
X    return foo + v;
X}
X
X
Xvar operator - (const double d, const var & v)
X{
X    var foo = d;
X    return foo - v;
X}
X
X
Xvar operator * (const double d, const var & v)
X{
X    var foo = d;
X    return foo * v;
X}
X
X
Xvar operator / (const double d, const var & v)
X{
X    var foo = d;
X    return foo / v;
X}
X
X
Xvar operator % (const double d, const var & v)
X{
X    var foo = d;
X    return foo % v;
X}
X
X// -----------------------------------------------------------------------------
X
Xint var::operator == (const var & t) const        // equality
X{
X    if (is_numeric && t.is_numeric) {
X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
X        return (long) (*this) == (long) t;
X    }
X    return (double) (*this) == (double) t;
X    }
X    else {
X    if (data_str_end && t.data_str_end) {
X        return !strcmp(data_str, t.data_str);
X    }
X    else {
X        return data_str_end == t.data_str_end;
X    }
X    }
X}
X
X
Xint var::operator != (const var & t) const        // inequality
X{
X    if (is_numeric && t.is_numeric) {
X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
X        return (long) (*this) != (long) t;
X    }
X    return (double) (*this) != (double) t;
X    }
X    else {
X    if (data_str_end && t.data_str_end) {
X        return strcmp(data_str, t.data_str);
X    }
X    else {
X        return data_str_end != t.data_str_end;
X    }
X    }
X}
X
X
Xint var::operator < (const var & t) const        // less than
X{
X    if (is_numeric && t.is_numeric) {
X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
X        return (long) (*this) < (long) t;
X    }
X    return (double) (*this) < (double) t;
X    }
X    else {
X    if (data_str_end && t.data_str_end) {
X        return (strcmp(data_str, t.data_str) < 0);
X    }
X    else {
X        return data_str_end < t.data_str_end;
X    }
X    }
X}
X
X
Xint var::operator > (const var & t) const        // greater than
X{
X    if (is_numeric && t.is_numeric) {
X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
X        return (long) (*this) > (long) t;
X    }
X    return (double) (*this) > (double) t;
X    }
X    else {
X    if (data_str_end && t.data_str_end) {
X        return (strcmp(data_str, t.data_str) > 0);
X    }
X    else {
X        return data_str_end > t.data_str_end;
X    }
X    }
X}
X
X
Xint var::operator <= (const var & t) const        // less than or equal
X{
X    if (is_numeric && t.is_numeric) {
X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
X        return (long) (*this) <= (long) t;
X    }
X    return (double) (*this) <= (double) t;
X    }
X    else {
X    if (data_str_end && t.data_str_end) {
X        return (strcmp(data_str, t.data_str) <= 0);
X    }
X    else {
X        return data_str_end <= t.data_str_end;
X    }
X    }
X}
X
X
Xint var::operator >= (const var & t) const        // greater than or equal
X{
X    if (is_numeric && t.is_numeric) {
X    if (is_numeric == VAR_LONG && t.is_numeric == VAR_LONG) {
X        return (long) (*this) >= (long) t;
X    }
X    return (double) (*this) >= (double) t;
X    }
X    else {
X    if (data_str_end && t.data_str_end) {
X        return (strcmp(data_str, t.data_str) >= 0);
X    }
X    else {
X        return data_str_end >= t.data_str_end;
X    }
X    }
X}
X
X// -----------------------------------------------------------------------------
X
Xint operator == (const var & t, const char * s)
X{
X    var foo = s;
X    return t == foo;
X}
X
X
Xint operator != (const var & t, const char * s)
X{
X    var foo = s;
X    return t != foo;
X}
X
X
Xint operator < (const var & t, const char * s)
X{
X    var foo = s;
X    return t < foo;
X}
X
X
Xint operator > (const var & t, const char * s)
X{
X    var foo = s;
X    return t > foo;
X}
X
X
Xint operator <= (const var & t, const char * s)
X{
X    var foo = s;
X    return t <= foo;
X}
X
X
Xint operator >= (const var & t, const char * s)
X{
X    var foo = s;
X    return t >= foo;
X}
X
X
Xint operator == (const char * s, const var & t)
X{
X    var foo = s;
X    return foo == t;
X}
X
X
Xint operator != (const char * s, const var & t)
X{
X    var foo = s;
X    return foo != t;
X}
X
X
Xint operator < (const char * s, const var & t)
X{
X    var foo = s;
X    return foo < t;
X}
X
X
Xint operator > (const char * s, const var & t)
X{
X    var foo = s;
X    return foo > t;
X}
X
X
Xint operator <= (const char * s, const var & t)
X{
X    var foo = s;
X    return foo <= t;
X}
X
X
Xint operator >= (const char * s, const var & t)
X{
X    var foo = s;
X    return foo >= t;
X}
X
X// -----------------------------------------------------------------------------
X
Xint operator == (const var & t, const double d)
X{
X    return (double) t == d;
X}
X
X
Xint operator != (const var & t, const double d)
X{
X    return (double) t != d;
X}
X
X
Xint operator < (const var & t, const double d)
X{
X    return (double) t < d;
X}
X
X
Xint operator > (const var & t, const double d)
X{
X    return (double) t > d;
X}
X
X
Xint operator <= (const var & t, const double d)
X{
X    return (double) t <= d;
X}
X
X
Xint operator >= (const var & t, const double d)
X{
X    return (double) t >= d;
X}
X
X
Xint operator == (const double d, const var & t)
X{
X    return d == (double) t;
X}
X
X
Xint operator != (const double d, const var & t)
X{
X    return d != (double) t;
X}
X
X
Xint operator < (const double d, const var & t)
X{
X    return d < (double) t;
X}
X
X
Xint operator > (const double d, const var & t)
X{
X    return d > (double) t;
X}
X
X
Xint operator <= (const double d, const var & t)
X{
X    return d <= (double) t;
X}
X
X
Xint operator >= (const double d, const var & t)
X{
X    return d >= (double) t;
X}
X
X// -----------------------------------------------------------------------------
X
Xvoid var::null(int index)
X{
X    if (index >= data_str_len) {
X    cerr << "WARNING: " << " - var::null(" << index << ") - the index out of range.\n";
X    (*this)[index] = 0;
X    data_str_end = index;
X    }
X    else {
X    data_str[index] = 0;
X    data_str_end = index;
X    }
X}
X
X
Xvoid var::changesize(int newsize)
X{
X    if (newsize > data_str_len) {
X    char *buf = new char[newsize];
X    if (data_str) {
X        strncpy(buf, data_str, data_str_end);
X        buf[data_str_end] = 0;
X        delete data_str;
X    }
X    else {
X        *buf = 0;
X        data_str_end = 0;
X    }
X    data_str_len = newsize;
X    data_str = buf;
X    }
X}
X
X
Xint var::length(void) const
X{
X    return data_str_end;
X}
X
X
Xconst char * var::vartype(void) const
X{
X    switch (is_numeric) {
X    case VAR_STRING:
X        return "VAR_STRING";
X    case VAR_LONG:
X        return "VAR_LONG";
X    case VAR_DOUBLE:
X        return "VAR_DOUBLE";
X    }
X    return "var type unknown";
X}
X
X
Xvoid var::change_type(const char *ntype)
X{
X    if (ntype == NULL) {
X    return;
X    }
X    int index = strlen(ntype);
X    if (!index) {
X    return;
X    }
X    char *new_type = new char[index + 1];
X    if (ntype[0] == '(' && ntype[index - 1] == ')') {
X    strcpy(new_type, &ntype[1]);
X    index = strlen(new_type) - 1;
X    if (index <= 0) {
X        delete new_type;
X        return;
X    }
X    new_type[index] = 0;            // drop parens
X    }
X    else {
X    strcpy(new_type, ntype);
X    }
X    if (new_type[index - 1] == ' ') {
X    new_type[index - 1] = 0;
X    }
X    fixed = 1;
X    if (!strcmp(new_type, "var")) {
X    is_numeric = numcheck((const char *) *this);
X    }
X    else if (!strcmp(new_type, "string")) {
X    is_numeric = VAR_STRING;
X    }
X    else if (!strcmp(new_type, "short")) {
X    is_numeric = VAR_LONG;
X    }
X    else if (!strcmp(new_type, "unsigned short")) {
X    is_numeric = VAR_LONG;
X    }
X    else if (!strcmp(new_type, "int")) {
X    is_numeric = VAR_LONG;
X    }
X    else if (!strcmp(new_type, "unsigned int")) {
X    is_numeric = VAR_LONG;
X    }
X    else if (!strcmp(new_type, "long")) {
X    is_numeric = VAR_LONG;
X    }
X    else if (!strcmp(new_type, "unsigned long")) {
X    is_numeric = VAR_LONG;
X    }
X    else if (!strcmp(new_type, "float")) {
X    is_numeric = VAR_DOUBLE;
X    }
X    else if (!strcmp(new_type, "double")) {
X    is_numeric = VAR_DOUBLE;
X    }
X    else {
X    cerr << "WARNING: " << " - change_type(" << new_type << ") - unrecognized type name.\n";
X    }
X    delete new_type;
X}
X
X
Xint var::is_string(void) const
X{
X    return is_numeric == VAR_STRING;
X}
X
X
Xint var::is_double(void) const
X{
X    return is_numeric == VAR_DOUBLE;
X}
X
X
Xint var::is_long(void) const
X{
X    return is_numeric == VAR_LONG;
X}
X
X
Xint var::strchr(const char ch) const
X{
X    for (int i = 0; i < data_str_end; ++i) {
X    if (data_str[i] == ch) {
X        return i;
X    }
X    }
X    return -1;
X}
X
X
Xint var::strrchr(const char ch) const
X{
X    for (int i = data_str_end - 1; i >= 0; --i) {
X    if (data_str[i] == ch) {
X        return i;
X    }
X    }
X    return -1;
X}
X
X
Xvar & var::concat(const var & str)
X{
X    // concatenate strings
X    char *this_str = (char *) (*this);
X    char *strs_str = (char *) (str);
X    int this_len = strlen(this_str);
X    int strs_len = strlen(strs_str);
X    int new_data_str_end = data_str_end + str.data_str_end;
X    // will it fit in this var's memory?
X    if (new_data_str_end >= (this_len + strs_len)) {
X    var add;
X    add.data_str_len = this_len + strs_len + VAR_PAD_SIZE;
X    add.data_str_end = this_len + strs_len;
X    delete add.data_str;
X    add.data_str = new char[add.data_str_len];
X    strcpy(add.data_str, this_str);
X    strcpy((add.data_str) + this_len, strs_str);
X    *this = add;
X    }
X    else {
X    strcpy(data_str + this_len, strs_str);
X    data_str_end = this_len + strs_len;
X    }
X    return *this;
X}
X
X
Xvar & var::format(const char * fmt)
X{
X    if (format_str
X    && format_str != DEFAULT_STRING_FORMAT
X    && format_str != DEFAULT_INT_FORMAT
X    && format_str != DEFAULT_UINT_FORMAT
X    && format_str != DEFAULT_LONG_FORMAT
X    && format_str != DEFAULT_ULONG_FORMAT
X    && format_str != DEFAULT_DOUBLE_FORMAT) {
X        delete format_str;
X    }
X    if (fmt) {
X    format_str = new char[strlen(fmt) + 1];
X    strcpy(format_str, fmt);
X    }
X    else {
X    format_str = NULL;
X    }
X    return *this;
X}
X
X
Xint var::numcheck(const char * str) const
X{
X    if (!str || !*str) {
X    return VAR_STRING;        // assume a string
X    }
X    char *ptr = (char *) str;
X    int nc = VAR_LONG;            // assume a signed long
X    int decimal_yet = 0;
X    if (*ptr == '.' && *(ptr + 1)) {
X    nc = VAR_DOUBLE;        // floating point number
X    decimal_yet = 1;
X    ++ptr;
X    }
X    else if (*ptr == '-' && *(ptr + 1)) {
X    // skip optional sign char
X    ++ptr;
X    }
X    while (*ptr) {
X    if (*ptr == '.' && !decimal_yet) {
X        decimal_yet = 1;
X        nc = VAR_DOUBLE;        // assume a double
X    }
X    else if (!isdigit(*ptr)) {
X        return VAR_STRING;        // nope.. got a string
X    }
X    ++ptr;
X    }
X    return nc;
X}
X
X// -----------------------------------------------------------------------------
X
Xostream & operator << (ostream &out, const var &d)
X{
X    d.print(out);
X    return out;
X}
X
X
Xvoid var::print(ostream &out) const
X{
X    // NOTE: the "read()" function requires a newline to appear after the last quote.
X    // I assume that this newline was appropriately output by the var class user.
X    if (!format_str || (format_str && *format_str == 0)) {
X    out << "var OBJECT: {"
X        << "\n\tfixed        = " << fixed
X        << "\n\tis_numeric   = " << is_numeric
X        << "\n\tdata_str_len = " << data_str_len
X        << "\n\tdata_str_end = " << data_str_end
X        << "\n\tdata_str     = '" << data_str << "'"
X        << "\n\tformat_str   = '" << format_str << "'"
X        << "\n}\n";
X    }
X    else {
X    // we need to use the specified format string for output
X    int len = length() + 1;
X    char *outbuf = new char[2048];
X    char *fptr = format_str;
X    while (*fptr) {
X        if (*fptr != '%' && *fptr != '\\') {
X        out << *fptr;
X        ++fptr;
X        }
X        else if (*fptr == '\\') {
X        switch (*(fptr + 1)) {
X            case 'n':
X            cout << '\n';
X            break;
X            case 't':
X            cout << '\t';
X            break;
X            case 'v':
X            cout << '\v';
X            break;
X            case 'b':
X            cout << '\b';
X            break;
X            case 'r':
X            cout << '\r';
X            break;
X            case 'f':
X            cout << '\f';
X            break;
X            case 'a':
X            cout << '\007';
X            break;
X            case '\\':
X            cout << '\\';
X            break;
X            case '?':
X            cout << '\?';
X            break;
X            case '\'':
X            cout << '\'';
X            break;
X            case '\"':
X            cout << '\"';
X            break;
X            default:
X            cout << *(fptr + 1);
X        }
X        fptr += 2;
X        }
X        else {
X        // Hmmm.. we need to do some special formatting
X        // first extract this printf-style format string
X        char smallfmtstr[128];
X        char *smptr = smallfmtstr;
X        *smptr = 0;
X        if (*(fptr + 1) == '%') {
X            strcpy(outbuf, "%");
X            fptr += 2;
X        }
X        else {
X            while (*fptr) {
X            *smptr = *fptr++;
X            *(smptr + 1) = 0;
X            // integer
X            if (*smptr == 'd') {
X                sprintf(outbuf, smallfmtstr, (int) *this);
X                break;
X            }
X            // unsigned integer
X            if (*smptr == 'o' || *smptr == 'u' || *smptr == 'x' || *smptr == 'X') {
X                sprintf(outbuf, smallfmtstr, (unsigned int) *this);
X                break;
X            }
X            // float or double
X            if (*smptr == 'f' || *smptr == 'e' || *smptr == 'E' || *smptr == 'g' || *smptr == 'G') {
X                sprintf(outbuf, smallfmtstr, (double) *this);
X                break;
X            }
X            // character
X            if (*smptr == 'c') {
X                if (!strcmp(vartype(), "VAR_STRING")) {
X                const char *tmp = (const char *) (*this);
X                sprintf(outbuf, smallfmtstr, tmp[0]);
X                }
X                else {
X                sprintf(outbuf, smallfmtstr, (char) ((int) *this));
X                }
X                break;
X            }
X            // string
X            if (*smptr == 's') {
X                sprintf(outbuf, smallfmtstr, (const char *) *this);
X                break;
X            }
X            ++smptr;
X            }
X        }
X        out << outbuf;
X        }
X    }
X    //out << flush;
X    delete outbuf;
X    }
X}
X
X// -----------------------------------------------------------------------------
X
X// convert an integer into an ascii string.  return a pointer to that string.
X//
Xchar *itoa(const int foo)
X{
X    static char int_buf[28];
X    sprintf(int_buf, "%d", foo);
X    return int_buf;
X}
X
X
X// convert an unsigned integer into an ascii string.  return a pointer to that string.
X//
Xchar *uitoa(const unsigned int foo)
X{
X    static char int_buf[28];
X    sprintf(int_buf, "%u", foo);
X    return int_buf;
X}
X
X
X// convert a long into an ascii string.  return a pointer to that string.
X//
X#ifdef HP
Xchar *ltoa(long foo)
X#else
Xchar *ltoa(const long foo)
X#endif
X{
X    static char long_buf[28];
X    sprintf(long_buf, "%ld", foo);
X    return long_buf;
X}
X
X
X// convert an unsigned long into an ascii string.  return a pointer to that string.
X//
X#ifdef HP
Xchar *ultoa(unsigned long foo)
X#else
Xchar *ultoa(const unsigned long foo)
X#endif
X{
X    static char long_buf[28];
X    sprintf(long_buf, "%lu", foo);
X    return long_buf;
X}
X
X
X// convert a double into an ascii string.  return a pointer to that string.
X// truncate any extra zeros after the decimal point.
X//
Xchar *dtoa(const double foo)
X{
X    static char double_buf[28];
X    sprintf(double_buf, "%lf", foo);
X    char *ptr;
X    for (ptr = double_buf; *ptr; ++ptr) {
X    if (*ptr == '.') {
X        // we may need to truncate zeroes
X        ptr = double_buf + (strlen(double_buf) - 1);
X        while (*ptr == '0') {
X        *ptr-- = 0;
X        }
X        if (*ptr == '.') {
X        *ptr = 0;
X        }
X        break;
X    }
X    }
X    return double_buf;
X}
X
X
X// convert an ascii string to a double
X//
Xdouble atod(char * foo)
X{
X    double d = 0;
X    if (!foo || !*foo) {
X    return d;
X    }
X    if (!isdigit(*foo)) {
X    if (*foo != '-' && *foo != '+') {
X        return d;
X    }
X    if (!isdigit(*(foo + 1))) {
X        return d;
X    }
X    }
X    sscanf(foo, "%lf", &d);
X    return d;
X}
X
END_OF_FILE
  if test 31997 -ne `wc -c <'var.C'`; then
    echo shar: \"'var.C'\" unpacked with wrong size!
  fi
  # end of 'var.C'
fi
echo shar: End of archive 1 \(of 2\).
cp /dev/null ark1isdone
MISSING=""
for I in 1 2 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked both archives.
    rm -f ark[1-9]isdone
else
    echo You still must unpack the following archives:
    echo "        " ${MISSING}
fi
exit 0
exit 0 # Just in case...