Xref: news2.mv.net comp.os.msdos.djgpp:4832
From: boylesgj AT lion DOT cs DOT latrobe DOT edu DOT au (Gregary J Boyles)
Newsgroups: comp.os.msdos.djgpp
Subject: Compiler error????
Date: 11 Jun 1996 07:03:32 GMT
Organization: Comp.Sci & Comp.Eng, La Trobe Uni, Australia
Lines: 2051
Distribution: world
Message-ID: <4pj5o4$pfp@lion.cs.latrobe.edu.au>
NNTP-Posting-Host: lion.cs.latrobe.edu.au
To: djgpp AT delorie DOT com
DJ-Gateway: from newsgroup comp.os.msdos.djgpp

Newsgroups: comp.os.msdos.djgpp
Subject: Compiler errors????????
Summary: 
Followup-To: 
Distribution: world
Organization: Comp.Sci & Comp.Eng, La Trobe Uni, Australia
Keywords: 

What does this crap mean???
I'm not making calls to clear!
See files included below - sorry I can't remove irrelavent code 
because I haven't clue what all this means or what might be causing it.

In file included from /usr/local/lib/g++-include/iostream.h:31,
                 from stringc.hpp:10,
                 from field.cpp:5:
/usr/local/lib/g++-include/streambuf.h:207: arguments given to macro `clear'
In file included from stringc.hpp:10,
                 from field.cpp:5:
/usr/local/lib/g++-include/iostream.h:169: arguments given to macro `clear'
/usr/local/lib/g++-include/iostream.h:172: arguments given to macro `clear'

/*

   File field.hpp

   Class specifications

*/

#ifndef __FIELD_HPP
#define __FIELD_HPP




/*
*****************************************************************************
*                                                                           *
* ENUMERATED TYPE NAME : CommandTypeE                                       *
*                                                                           *
* PURPOSE : To seperate key scan codes from invocation of system modules in *
*           order  to make changing the keys used, by the system, easier.   *
*                                                                           *
* NOTE : When a key is pressed the Read modules get the character(s) from   *
*        the key board buffer, determine whether they belong to a command   *
*        key e.g. up arrow or esc and if so return the corresponding system *
*        command.                                                           *
*        MB stands for menu bar.                                            *
*                                                                           *
*****************************************************************************
*/
typedef enum {Next,Cancel,Enter,Tag,Untag,Print,Up,Down,Left,Right,PageUp,
              PageDown,EndLine,StartLine,Insert,Delete,None,Error,Add1,Add10,
              Add100,Add1000,Subtract1,Subtract10,Subtract100,Subtract1000,
              
              SearchA,SearchB,SearchD,SearchE,SearchF,SearchG,SearchH,SearchI,
              SearchJ,SearchK,SearchL,SearchM,SearchN,SearchO,SearchP,SearchQ,
              SearchR,SearchS,SearchT,SearchU,SearchV,SearchW,SearchX,SearchY,
              SearchZ,Search0,Search1,Search2,Search3,Search4,Search5,Search6,
              Search7,Search8,Search9,

              MBFile,MBEntry,MBView,MBPrint,MBHelp,

              MBFileUsers,MBFileAnalysis,MBFileColors,MBFileLogout,MBFileQuit,

              MBEntryInvoices,MBEntryOrders,MBEntryProducts,MBEntryCustomers,

              MBViewInvoices,MBViewOrders,MBViewProducts,MBViewCustomers,MBViewSuppliers,

              MBPrintInvoices,MBPrintOrders,MBPrintProducts,MBPrintCustomers,
              MBPrintSuppliers,

              MBHelpContents,MBHelpIndex,MBHelpAbout} CommandTypeE;




/*
*****************************************************************************
*                                                                           *
* CLASS NAME : PositionC                                                    *
*                                                                           *
* PURPOSE : To store coordinates of a single position.                      *
*                                                                           *
* NOTE :                                                                    *
*                                                                           *
*****************************************************************************
*/
class PositionC
{
  private :
    // Position coordinates.
    int X,Y;

  public :
    // The constructors.
    PositionC();

    PositionC(const int X_,const int Y_);

    // The destructor.
    ~PositionC();

    // Functions for setting and getting data members.
    void SetPosition(const int X_,const int Y_);

    int GetX();
    int GetY();
};




/*
*****************************************************************************
*                                                                           *
* CLASS NAME : FieldC                                                       *
*                                                                           *
* PURPOSE : To store details of a field in a dialog box, corresponding to   *
*           field in a database record.                                     *
*                                                                           *
* NOTE :                                                                    *
*                                                                           *
*****************************************************************************
*/
class FieldC
{
  private:
    // The name of the field.
    StringC Name;

    // The position of the field in the dialog box.
    PositionC Position;

    // The length of the data field in the field.
    int FieldLength;

    // Data members to store the field's data.
    StringC String;

    int Integer;

    char Ch;

   public:
    // The constructors.
    FieldC();

    FieldC(const char *Name_,const int X_,const int Y_,const int FieldLength_,const char *String_);

    FieldC(const char *Name_,const int X_,const int Y_,const int FieldLength_,const int Integer_);

    FieldC(const char *Name_,const int X_,const int Y_,const int FieldLength_,const char Ch_);

    FieldC(const char *Name_,const int X_,const int Y_,const int FieldLength_);

    // The destructor.
    ~FieldC();

    // Functions for getting and setting individual data members.
    void SetName(const char *Name_);

    const StringC &GetName();

    void SetPosition(const int X_,const int Y_);

    void GetPosition(int &X_,int &Y_);

    void SetFieldLength(const int FieldLength_);

    int GetFieldLength();

    void SetString(const char *String_);

    const char *GetString();

    void SetInteger(const int Integer_);

    int GetInteger();

    // Display function.
    void Display(WINDOW *Win);

    // Input functions.
    CommandTypeE ReadInteger(WINDOW *Win,const int Upper,const int Lower);

    CommandTypeE ReadString(WINDOW *Win);

    CommandTypeE ReadChar(WINDOW *Win);

    CommandTypeE ChangeInteger(WINDOW *Win,const int Upper,const int Lower);

    CommandTypeE ReadCommand(WINDOW *Win);
};




#endif



/*

   File field.cpp

   Class implementations

*/
#include <curses.h>
#include <stdio.h>
#include <stdlib.h>
#include "string.hpp"
#include "display.hpp"
#include "keycodes.hpp"




/*
*****************************************************************************
*                                                                           *
* CLASS PositionC                                                           *
*                                                                           *
*****************************************************************************
*/

// The constructors.
PositionC::PositionC()
{
  X=0;
  Y=0;
}




PositionC::PositionC(const int X_,const int Y_)
{
  X=X_;
  Y=Y_;
}




// The destructor.
PositionC::~PositionC()
{
  X=0;
  Y=0;
}




// Functions for setting and getting data members.
void PositionC::SetPosition(const int X_,const int Y_)
{
  X=X_;
  Y=Y_;
}




int PositionC::GetX()
{
  return X;
}




int PositionC::GetY()
{
  return Y;
}




/*
*****************************************************************************
*                                                                           *
* CLASS NAME : FieldC                                                       *
*                                                                           *
*****************************************************************************
*/

// The constructors.
FieldC::FieldC():

Name(),Position(),String()

{
  FieldLength=0;
  Integer=0;
  Ch=Null;
}




FieldC::FieldC(const char *Name_,const int X_,const int Y_,
               const int FieldLength_,const char *String_):

Name(Name_),String(String_),Position(X_,Y_)

{
  FieldLength=FieldLength_;
  Integer=0;
  Ch=Null;
}




FieldC::FieldC(const char *Name_,const int X_,const int Y_,
               const int FieldLength_,const int Integer_):

Name(Name_),String(),Position(X_,Y_)

{
  FieldLength=FieldLength_;
  Integer=Integer_;
  Ch=Null;
}





FieldC::FieldC(const char *Name_,const int X_,const int Y_,
               const int FieldLength_,const char Ch_):

Name(Name_),Position(X_,Y_),String()

{
  FieldLength=FieldLength_;
  Integer=Integer_;
  Ch=Ch_;
}


FieldC::FieldC(const char *Name_,const int X_,const int Y_,
               const int FieldLength_):

Name(Name_),Position(X_,Y_),String()

{
  FieldLength=FieldLength_;
  Integer=Integer_;
  Ch=Null;
}




// The destructor.
FieldC::~FieldC()
{
  FieldLength=0;
  Integer=0;
  Ch=Null;
}





// Functions for getting and setting individual data members.
void FieldC::SetName(const char *Name_)
{
  Name=Name_;
}




const StringC &FieldC::GetName()
{
  return Name;
}





void FieldC::SetPosition(const int X_,const int Y_)
{
  Position.SetPosition(X_,Y_);
}




void FieldC::GetPosition(int &X_,int &Y_)
{
  X_=Position.GetX();
  Y_=Position.GetY();
}




void FieldC::SetFieldLength(const int FieldLength_)
{
  FieldLength=FieldLength_;
}




int FieldC::GetFieldLength()
{
  return FieldLength;
}




void FieldC::SetString(const char *String_)
{
  String=String_;
}




const char *FieldC::GetString()
{
  return String.GetS();
}




void FieldC::SetInteger(const int Integer_)
{
  Integer=Integer_;
}




int FieldC::GetInteger()
{
  return Integer;
}




// Display function.
void FieldC::Display(WINDOW *Win)
{
  int Index;

  Name.MvWAddStr(Win,Position.GetY(),Position.GetX(),1,Name.Length());
  waddch(Win,'[');
  String.WAddStr(Win,1,FieldLength);
  for (Index=String.Length()+1;Index<=FieldLength;Index++)
    waddch(Win,' ');
  waddch(Win,']');
}




// Input functions.
CommandTypeE FieldC::ReadCommand(WINDOW *Win)
{
  int Ch1=NULL,Ch2=Null;
  CommandTypeE Command;

  do
  {
    Ch1=wgetch(Win);
    if (Ch1==Null)
      Ch2=wgetch(Win);
    else
      Ch2=NULL;

    if (Ch1==Tab)
      Command=Next;
    else if (Ch1==Escape)
      Command=Cancel;
    else if (Ch1==CarriageReturn)
      Command=Enter;
    else if (Ch2==UpArrow)
      Command=Add1;
    else if (Ch2==DownArrow)
      Command=Subtract1;
    else if (Ch2==PgUp)
      Command=Add10;
    else if (Ch2==PgDn)
      Command=Subtract10;
    else if (Ch1==ShiftPgUp)
      Command=Add100;
    else if (Ch1==ShiftPgDn)
      Command=Subtract100;
    else if (Ch2==CtrlPgUp)
      Command=Add1000;
    else if (Ch2==CtrlPgDn)
      Command=Subtract1000;
    else
      Command=None;
  }
  while (Command!=None);

  return Command;
}




CommandTypeE FieldC::ReadChar(WINDOW *Win)
{
  char Ch1=Null,Ch2=Null;
  CommandTypeE Command;
  bool Done,CharPressed=false;

  do
  {
    Ch1=wgetch(Win);
    if (Ch1==Null)
      Ch2=wgetch(Win);
    else
      Ch2=Null;

    if ((Ch1==BackSpace) || (Ch2==Del))
    {
      Command=Delete;
      Done=true;
      CharPressed=false;
    }
    else if (Ch1==Tab)
    {
      Command=Next;
      Done=true;
    }
    else if (Ch1==Escape)
    {
      Command=Cancel;
      Done=true;
    }
    else if (Ch1==CarriageReturn)
    {
      Command=Enter;
      Done=true;
    }
    else if ((Ch1>=Space) && (Ch1<=Tilde) && (!CharPressed))
    {
      Command=None;
      Ch=Ch1;
    }
  }
  while (!Done);

  return Command;
}




CommandTypeE FieldC::ReadInteger(WINDOW *Win,const int Lower,const int Upper)
{
  int X=Position.GetX()+Name.Length()+1,Y=Position.GetY(),TempInteger,Index;
  StringC TempString;
  CommandTypeE Command;

  TempString="";
  wmove(Win,Y,X);
  do
  {
    Command=ReadChar(Win);

    // If the delete command was issued and the length of string is greater
    // than 0.
    if ((Command==Delete) && (String.Length()>0))
    {
      // Decrement the x coordinate : X.
      X--;

      // Remove the last character from TempString.
      TempString-=TempString[TempString.Length()];

      // Erase the last character from the screen.
      mvwaddch(Win,Y,X,Space);
      wmove(Win,Y,X);
      wrefresh(Win);
    }
    // If the enter command was issued.
    else if (Command==Enter)
    {
      // If TempString could not be converted to an integer or the integer is
      // out of the prescribed range then reset TempString to "" and clear the
      // field and start again.
      if (!TempString.ToInt(TempInteger) || (TempInteger<Lower) || (TempInteger>Upper))
      {
        // Change the value of command so that the loop does not terminate.
        Command=None;

        // Set X back to its original value.
        X=Position.GetX()+Name.Length()+1;

        // Empty TempString.
        TempString="";

        // Erase the field.
        wmove(Win,X,Y);
        for (Index=1;Index<=FieldLength;Index++)
          waddch(Win,Space);
        wmove(Win,X,Y);
        wrefresh(Win);
      }
      // If no errors then assign the Temp variables into the field data
      // members.
      else
      {
        String=TempString;
        Integer=TempInteger;
      }
    }
    // If a digit key was pressed and the length of TempString is less than
    // the length of the field.
    else if ((Ch>=Digit0) && (Ch<=Digit9) && (TempString.Length()<FieldLength))
    {
      // Echo the character.
      mvwaddch(Win,Y,X,Ch);
      wrefresh(Win);

      // Add it to String.
      TempString+=Ch;

      // Increment the x coordinate : X.
      X++;
    }
  }
  while ((Command!=Enter) && (Command!=Cancel) && (Command!=Next));

  return Command;
}




CommandTypeE FieldC::ReadString(WINDOW *Win)
{
  int X=Position.GetX()+Name.Length()+1,Y=Position.GetY();
  CommandTypeE Command;

  String="";
  wmove(Win,Y,X);
  do
  {
    Command=ReadChar(Win);

    // If the delete command was issued and the length of string is greater
    // than 0.
    if ((Command==Delete) && (String.Length()>0))
    {
      // Decrement the x coordinate : X.
      X--;

      // Remove the last character from String.
      String-=String[String.Length()];

      // Erase the last character from the screen.
      mvwaddch(Win,Y,X,Space);
      wmove(Win,Y,X);
      wrefresh(Win);
    }
    // If a digit, alphabetic or punctuation key was pressed and the length of
    // String is less than the length of the field.
    else if ((Ch>=Space) && (Ch<=Tilde) && (String.Length()<FieldLength))
    {
      // Echo the character.
      mvwaddch(Win,Y,X,Ch);
      wrefresh(Win);

      // Add it to String.
      String+=Ch;

      // Increment the x coordinate : X.
      X++;
    }
  }
  while ((Command!=Enter) && (Command!=Cancel) && (Command!=Next));

  return Command;
}




CommandTypeE FieldC::ChangeInteger(WINDOW *Win,const int Upper,const int Lower)
{
  CommandTypeE Command;
  int TempInt;

  do
  {
    Command=ReadCommand(Win);

    if (Command==Add1)
    {
      TempInt++;
    }
    else if (Command==Subtract1)
    {
      TempInt--;
    }
    else if (Command==Add10)
    {
      TempInt+=10;
    }
    else if (Command==Subtract10)
    {
      TempInt-=10;
    }
    else if (Command==Add100)
    {
      TempInt+=100;
    }
    else if (Command==Subtract100)
    {
      TempInt-=100;
    }
    else if (Command==Add1000)
    {
      TempInt+=1000;
    }
    else if (Command==Subtract1000)
    {
      TempInt-=1000;
    }
    // TempInt is within the specified range.
    if ((TempInt>=Lower) && (TempInt<=Upper))
    {
      // Convert Integer to a string.
      String=TempInt;

      // If the TempInt fits within the field.
      if (String.Length()<=FieldLength)
      {
        Integer=TempInt;

        // Display String.
        String.MvWAddStr(Win,Position.GetY(),Position.GetX(),1,FieldLength);
        wrefresh(Win);
      }
      // Otherwise set String to its original value.
      else
        String=Integer;
    }
  }
  while ((Command!=Enter) && (Command!=Cancel) && (Command!=Next));

  return Command;
}




/*
   File string.hpp

   StringC class specification.
*/

#ifndef __STRING_HPP
#define __STRING_HPP

#include <iostream.h>
#include <fstream.h>
#include <curses.h>

/*
*****************************************************************************
*                                                                           *
* CLASS NAME : StringC                                                      *
*                                                                           *
* PURPOSE : To provide Pascal like string manipulations.                    *
*                                                                           *
* NOTE : Statements such as String1=String2, String1="hello",               *
*        String1+="there, String1+=String2, String1-="there",               *
*        String1-=String2, String3=String1+String2, String3=String1-String2,*
*        String1[2]='c', String1=="hello", String1==String2, cout<<String1  *
*        and cin>>String1 are posible with this class.                      *
*        In addition to these there are many more useful functions and in   *
*        fact there is no need to use string.h at all.                      *
*                                                                           *
*****************************************************************************
*/
class StringC
{
  private : 
    // Data members
    int L; // AString length;
    char *S; // The string

  public : 
    // Constructors
    StringC(const char *AString);
    StringC(const StringC &AString);
    StringC();

    // Destructor
    ~StringC();

    // Friend functions
    friend ofstream &operator <<(ofstream &OFS,const StringC &AString);
    friend ifstream &operator >>(ifstream &IFS,StringC &AString);
    friend ostream &operator <<(ostream &OS,const StringC &AString);
    friend istream &operator >>(istream &IS,StringC &AString);

    // Operator function members
    void operator -=(const char *AString); // Substring deletion
    StringC &operator -(const char *AString); // Substring deletion
    void operator +=(const char *AString); // String concatenation
    StringC &operator +(const char *AString); // String concatenation
    void operator =(const char *AString); // String assignment
    bool  operator ==(const char *AString); // Case insensitive equal
    bool  operator >(const char *AString); // Case insensitive greater
    bool  operator <(const char *AString); // Case insensitive less
    bool  operator !=(const char *AString); // Case insensitive not equal
    int operator *(const char *AString); // Sub-string search

    void operator -=(const StringC &AString); // Substring deletion
    StringC &operator -(const StringC &AString); // Substring deletion
    void operator +=(const StringC &AString); //String concatenation
    StringC &operator +(const StringC &AString); // String concatenation
    void operator =(const StringC &AString); // String assignment
    bool  operator ==(const StringC &AString); // Case insensitive equal
    bool  operator >(const StringC &AString); // Case insensitive greater
    bool  operator <(const StringC &AString); // Case insensitive less
    bool  operator !=(const StringC &AString); // Case insensitive not equal
    int operator *(const StringC &AString); // Substring search

    void operator -=(const char Ch); // Character deletion
    StringC &operator -(const char Ch); // Character deletion
    void operator +=(const char Ch); // Character concatenation
    StringC &operator +(const char Ch); // Character concatenation
    int operator *(char Ch); // Character search
    char &operator [](int Pos); //String sub-scripting

    // Integer to string conversion.
    void operator =(int Integer);

    // Other function members
    int Length(); // Return the length of the string
    void Delete(int Pos,int Num); // Delete Num characters from position Pos
    void Insert(const StringC &AString,int PosToAdd); // Insert AString at position PosToAdd
    void Insert(const char *AString,int PosToAdd); // Insert AString at position PosToAdd
    bool Equal(const StringC &AString); // Case sensitive comparisons
    bool NotEqual(const StringC &AString);
    bool Greater(const StringC &AString);
    bool Less(const StringC &AString);
    bool Equal(const char *AString); // Case sensitive comparisons
    bool NotEqual(const char *AString);
    bool Greater(const char *AString);
    bool Less(const char *AString);
    void Set(const char Ch); // Set all characters to Ch
    const char *GetS(); // Returns (char *) S.
    bool ToInt(int &Integer);

    // These functions provide compatibility between StringC objects and
    // curses string input and output.
    void MvWAddStr(WINDOW *Win,const int Y,const int X,const int Position,const int Length);
    void WAddStr(WINDOW *Win,const int Position,const int Length);
};



#endif



/*

   File string.cpp

   StringC class implementation
*/
#include <string.h>
#include <iostream.h>
#include <fstream.h>
#include <stdio.h>
#include <math.h>
#include "string.hpp"




// LOCAL CONSTANTS

const char EOLN='\n';
const char EOS='\0';
const char SPACE=' ';
const int MAXSTRING=100;


/*
   Local string variable for temporarily storing strings.

   All string operations are performed using TempString1 and when they are complete
   S is deleted, an appropriate amount of memory is re-allocated and the contents
   of TempString1 are copied into S. In this way S always has the minumum amount
   of memory required.

   Before using TempString1, all its elements are set to '\0' by the call
   strset(S,EOS). This guarentees that S will contain the expected string value
stream
   when using the Borland Tubo C++ string functions. These 
functions do not always
   append a '\0' to the end of a string.
   E.G. If TempString1 contains "Hello there" and we replace it with the value
   "bye", using the various string functions, then, in some cases, TempString1
   will end up containing the value "byelo there" because a '\0' was not
   appended to "bye"
*/

char TempString1[MAXSTRING];
char TempString2[MAXSTRING];




/*
   Local StringC object for temporarily storing strings created by the
   operator functions + and -
*/

StringC TempString_;




// LOCAL UTILITY FUNCTIONS.

void strset_(char *AString,char Ch,int Length)
// Set all elements of AString to Ch.
{
  int Index;

  for(Index=0;Index<Length;Index++)
    AString[Index]=Ch;
}




char Char(int Number)
{
  typedef union{int IntValue;char CharValue;} ConverterType;
  ConverterType Converter;

  Converter.IntValue=Number;
  return Converter.CharValue;
}




// CONSTRUCTORS

StringC::StringC(const char *AString)
{
  delete S;
  L=strlen(AString);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,AString);
}




StringC::StringC(const StringC &AString)
{
  delete S;
  L=strlen(AString.S);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,AString.S);
}




StringC::StringC()
{
  L=0;
  S=new char[L+2];
  strset_(S,EOS,L+2);
}




// DESTRUCTOR

StringC::~StringC()
{
  delete S;
  S=NULL;
  L=0;
}




// FRIEND FUNCTIONS

ofstream &operator <<(ofstream &OFS,const StringC &AString)
// StringC file output
{

  OFS<<(AString.S);
  return OFS;
}



 
ifstream &operator >>(ifstream &IFS,StringC &AString)
// StringC file input
{
  strset_(TempString1,EOS,MAXSTRING);
  IFS.getline(TempString1,MAXSTRING,EOLN);

  AString.L=strlen(TempString1);
  delete AString.S;
  AString.S=new char[AString.L+1];
  strset_(AString.S,EOS,AString.L+1);
  strcpy(AString.S,TempString1);
  return IFS;
}




ostream &operator <<(ostream &OS,const StringC &AString)
// StringC output
{
  OS<<AString.S;
  return OS;
}




istream &operator >>(istream &IS,StringC &AString)
{
  strset_(TempString1,EOS,MAXSTRING);
  IS.getline(TempString1,MAXSTRING,EOLN);

  AString.L=strlen(TempString1);
  delete AString.S;
  AString.S=new char[AString.L+1];
  strset_(AString.S,EOS,AString.L+1);
  strcpy(AString.S,TempString1);
  return IS;
}




// MEMBER FUNCTIONS
void StringC::MvWAddStr(WINDOW *Win,const int Y,const int X,const int Position,const int Length)
// Curses string output.
{
  char *SubString;

  // TempString1 is filled with spaces and then Length or less characters of
  // S is copied to TempString1 (char *).
  strset_(TempString1,SPACE,MAXSTRING);
  SubString=S+Position-1;
  strncpy(TempString1,SubString,Length);
  // Add the string terminator to position Length.
  TempString1[Length]=EOS;
  mvwaddstr(Win,Y,X,TempString1);
}



void StringC::WAddStr(WINDOW *Win,const int Position,const int Length)
// Curses string output.
{
  char *SubString;

  // TempString1 is filled with spaces and then Length or less characters of
  // S is copied to TempString1 (char *).
  strset_(TempString1,SPACE,MAXSTRING);
  SubString=S+Position-1;
  strncpy(TempString1,SubString,Length);
  // Add the string terminator to position Length.
  TempString1[Length]=EOS;
  waddstr(Win,TempString1);
}



void StringC::operator -=(const char *AString)
// If S contains the sub-string AString then delete it and return the resulting
// string.
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // Search for AString in S and store the pointer in SubString
  SubString=strstr(S,AString);
  // If S does not contain AString then simply copy S to TempString1
  if (SubString==NULL)
  {
    strcpy(TempString1,S);
  }
  else
  {
    // Calculate the number of characters between the start of S and the start
    // of AString in S (SubString)
    NumToCopy=abs(S-SubString);
    // Copy NumToCopy characters from S to TempString1
    strncpy(TempString1,S,NumToCopy);
    // If AString is smaller than the remainder of S
    if (strlen(AString)<(L-NumToCopy))
    {
      // Move SubString to the end of AString in S
      SubString+=strlen(AString);
      // Concatenate the remaining characters of S to TempString1
      strcat(TempString1,SubString);
    }
  }

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




StringC &StringC::operator -(const char *AString)
// If S contains the sub-string AString then delete it and return the resulting
// string.
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // Search for AString in S and store the pointer in SubString
  SubString=strstr(S,AString);
  // If S does not contain AString.S then simply copy S to TempString_.S
  if (SubString==NULL)
  {
    strcpy(TempString1,S);
  }
  else
  {
    // Calculate the number of characters between the start of S and the start
    // of AString in S (SubString)
    NumToCopy=abs(S-SubString);
    // Copy NumToCopy characters from S to TempString1
    strncpy(TempString1,S,NumToCopy);
    // If AString is smaller than the remainder of S
    if (strlen(AString)<(L-NumToCopy))
    {
      // Move SubString to the end of AString.S in S
      SubString+=strlen(AString);
      // Concatenate the remaining characters of S to TempString_.S
      strcat(TempString1,SubString);
    }
  }
  delete TempString_.S;
  TempString_.L=strlen(TempString1);
  TempString_.S=new char[TempString_.L+1];
  strset_(TempString_.S,EOS,TempString_.L+1);
  strcpy(TempString_.S,TempString1);
  return TempString_;
}




void StringC::operator +=(const char *AString)
// Concatenate S and AString and assign the resulting string into S
{
  strset_(TempString1,EOS,MAXSTRING);
  strcpy(TempString1,S);
  strcat(TempString1,AString);

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




StringC &StringC::operator +(const char *AString)
// Concatenate S and AString and return the resulting string
{
  strset_(TempString1,EOS,MAXSTRING);
  strcpy(TempString1,S);
  strcat(TempString1,AString);
  delete TempString_.S;
  TempString_.L=strlen(TempString1);
  TempString_.S=new char[TempString_.L+1];
  strset_(TempString_.S,EOS,TempString_.L+1);
  strcpy(TempString_.S,TempString1);
  return TempString_;
}




void StringC::operator =(const char *AString)
// StringC/char * assignment
{
  delete S;
  L=strlen(AString);
  S=new char[L+1];
  strset_(S,EOS,L);
  strcpy(S,AString);
}




bool StringC::operator ==(const char *AString)
// StringC input
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString);
  if (Num==0)
    Result=true;
  else
    Result=false;
  return Result;
}




bool StringC::operator >(const char *AString)
// Case insensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString);
  if (Num>0)
    Result=true;
  else
    Result=false;
  return Result;
}




bool StringC::operator <(const char *AString)
// Case insensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString);
  if (Num<0)
    Result=true;
  else
    Result=false;
  return Result;
}




bool StringC::operator !=(const char *AString)
// Case insensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString);
  if (Num!=0)
    Result=true;
  else
    Result=false;
  return Result;
}




int StringC::operator *(const char *AString)
// If S contains the sub-string AString then return the start position or else
// return 0
{
  char *SubString;
  int Result;

  SubString=strstr(S,AString);

  if (SubString!=NULL)
    Result=abs(S-SubString)+1;
  else
    Result=NULL;

  return Result;
}




void StringC::operator -=(const StringC &AString)
// If S contains the sub-string AString.S then delete it and assign the resulting
// string into S
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // Search for AString.S in S and store the pointer in SubString
  SubString=strstr(S,AString.S);
  // If S does not contain AString.S then simply copy S to TempString1
  if (SubString==NULL)
  {
    strcpy(TempString1,S);
  }
  else
  {
    // Calculate the number of characters between the start of S and the start
    // of AString.S in S (SubString)
    NumToCopy=abs(S-SubString);
    // Copy NumToCopy characters from S to TempString1
    strncpy(TempString1,S,NumToCopy);
    // If AString.S is smaller than the remainder of S
    if (strlen(AString.S)<(L-NumToCopy))
    {
      // Move SubString to the end of AString.S in S
      SubString+=AString.L;
      // Concatenate the remaining characters of S to TempString1
      strcat(TempString1,SubString);
    }
  }

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




StringC &StringC::operator -(const StringC &AString)
// If S contains the sub-string AString.S then delete it and return the resulting
// string.
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // Search for AString.S in S and store the pointer in SubString
  SubString=strstr(S,AString.S);
  // If S does not contain AString.S then simply copy S to TempString1
  if (SubString==NULL)
  {
    strcpy(TempString1,S);
  }
  else
  {
    // Calculate the number of characters between the start of S and the start
    // of AString.S in S (SubString)
    NumToCopy=abs(S-SubString);
    // Copy NumToCopy characters from S to TempString1
    strncpy(TempString1,S,NumToCopy);
    // If AString.S is smaller than the remainder of S
    if (strlen(AString.S)<(L-NumToCopy))
    {
      // Move SubString to the end of AString.S in S
      SubString+=AString.L;
      // Concatenate the remaining characters of S to TempString1
      strcat(TempString1,SubString);
    }
  }
  delete TempString_.S;
  TempString_.L=strlen(TempString1);
  TempString_.S=new char[TempString_.L+1];
  strset_(TempString_.S,EOS,TempString_.L+1);
  strcpy(TempString_.S,TempString1);
  return TempString_;
}




void StringC::operator +=(const StringC &AString)
// Concatenate S and AString.S and assign return the resulting string.
{
  strset_(TempString1,EOS,MAXSTRING);
  strcpy(TempString1,S);
  strcat(TempString1,AString.S);

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




StringC &StringC::operator +(const StringC &AString)
// Concatenate S and AString.S and return the resulting string
{
  strset_(TempString1,EOS,MAXSTRING);
  strcpy(TempString1,S);
  strcat(TempString1,AString.S);
  delete TempString_.S;
  TempString_.L=strlen(TempString1);
  TempString_.S=new char[TempString_.L+1];
  strset_(TempString_.S,EOS,TempString_.L+1);
  strcpy(TempString_.S,TempString1);
  return TempString_;
}




void StringC::operator =(const StringC &AString)
// StringC/StringC assignment
{
  delete S;
  L=AString.L;
  S=new char[L+1];
  strset_(S,EOS,L);
  strcpy(S,AString.S);
}




int StringC::operator *(const StringC &AString)
// If S contains the sub-string AString.S then return the start position or else
// return 0
{
  char *SubString;
  int Result;

  SubString=strstr(S,AString.S);

  if (SubString!=NULL)
    Result=abs(S-SubString)+1;
  else
    Result=NULL;

  return Result;
}




bool StringC::operator ==(const StringC &AString)
// StringC input
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString.S);
  if (Num==0)
    Result=true;
  else
    Result=false;
  return Result;
}




bool StringC::operator >(const StringC &AString)
// Case insensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString.S);
  if (Num>0)
    Result=true;
  else
    Result=false;
  return Result;
}




bool StringC::operator <(const StringC &AString)
// Case insensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString.S);
  if (Num<0)
    Result=true;
  else
    Result=false;
  return Result;
}




bool StringC::operator !=(const StringC &AString)
// Case insensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcasecmp(S,AString.S);
  if (Num!=0)
    Result=true;
  else
    Result=false;
  return Result;
}




void StringC::operator -=(const char Ch)
// If S contains the character Ch then delete it and return the resulting string.
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // Convert Ch to a (char *) string.
  strset_(TempString2,EOS,MAXSTRING);
  TempString2[0]=Ch;
  // Search for TempString2 (Ch) in S and store the pointer in SubString
  SubString=strstr(S,TempString2);
  // If S does not contain AString then simply copy S to TempString1
  if (SubString==NULL)
  {
    strcpy(TempString1,S);
  }
  else
  {
    // Calculate the number of characters between the start of S and the start
    // of AString in S (SubString)
    NumToCopy=abs(S-SubString);
    // Copy NumToCopy characters from S to TempString1
    strncpy(TempString1,S,NumToCopy);
    // Move SubString on by one character.
    SubString+=1;
    // Concatenate the remaining characters of S to TempString1 if any.
    strcat(TempString1,SubString);
  }

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




StringC &StringC::operator -(const char Ch)
// If S contains the character Ch then delete it and return the resulting string.
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // Convert Ch to a string.
  strset_(TempString2,EOS,MAXSTRING);
  TempString2[0]=Ch;
  // Search for TempString2 (Ch) in S and store the pointer in SubString
  SubString=strstr(S,TempString2);
  // If S does not contain TempString1 (Ch) then simply copy S to TempString_.S
  if (SubString==NULL)
  {
    strcpy(TempString1,S);
  }
  else
  {
    // Calculate the number of characters between the start of S and the start
    // of AString in S (SubString)
    NumToCopy=abs(S-SubString);
    // Copy NumToCopy characters from S to TempString1
    strncpy(TempString1,S,NumToCopy);
    // Move SubString on one character.
    SubString+=1;
    // Concatenate the remaining characters of S to TempString_.S if any.
    strcat(TempString1,SubString);
  }
  delete TempString_.S;
  TempString_.L=strlen(TempString1);
  TempString_.S=new char[TempString_.L+1];
  strset_(TempString_.S,EOS,TempString_.L+1);
  strcpy(TempString_.S,TempString1);
  return TempString_;
}




void StringC::operator +=(const char Ch)
// Concatenate S and Ch and assign return the resulting string.
{
  strset_(TempString1,EOS,MAXSTRING);
  strcpy(TempString1,S);
  TempString1[strlen(TempString1)]=Ch;

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




StringC &StringC::operator +(const char Ch)
// Concatenate S and Ch and return the resulting string
{
  strset_(TempString1,EOS,MAXSTRING);
  strcpy(TempString1,S);
  TempString1[strlen(TempString1)]=Ch;
  delete TempString_.S;
  TempString_.L=strlen(TempString1);
  TempString_.S=new char[TempString_.L+1];
  strset_(TempString_.S,EOS,TempString_.L+1);
  strcpy(TempString_.S,TempString1);
  return TempString_;
}




int StringC::operator *(char Ch)
// If S contains the character Ch then return its position or else return 0
{
  char *SubString;
  int Result;

  SubString=strchr(S,Ch);

  if (SubString!=NULL)
    Result=abs(S-SubString)+1;
  else
    Result=NULL;

  return Result;
}




char &StringC::operator [](int Pos)
// StringC sub-scripting
{
  if (!((Pos<=L) && (Pos>0)))
  {
    cout<<"ERROR : string subscript is out of range . . ."<<EOLN<<EOLN;
    exit(1);
  }
  return S[Pos-1];
}




void StringC::operator =(int Integer)
// Converts Integer to a string.
{
  strset_(TempString1,EOS,MAXSTRING);
  sprintf(TempString1,"%d",Integer);
  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
 }



int StringC::Length()
// Return the length of S (L)
{
  return L;
}




void StringC::Delete(int PosToDeleteFrom,int NumToDelete)
// Delete NumToDelete characters from S starting at PosToDeletFrom
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  // PosToDelete is greater the the length of S then just copy S to TempString1
  if (PosToDeleteFrom>L)
  {
    strcpy(TempString1,S);
  }
  // If PosToDeleteFrom is 1 and NumToDelete is equal to or larger than the
  // length of S then simply copy a null string to TempString1
  else if ((PosToDeleteFrom==1) && (NumToDelete>=L))
  {
    strcpy(TempString1,"");
  }
  else
  {
    // If there is less than NumToDelete characters between PosToDeleteFrom
    // and the end of S then adjust the value of NumToDelete
    if ((NumToDelete+PosToDeleteFrom-1)>L)
      NumToDelete=L-PosToDeleteFrom+1;

    SubString=S+PosToDeleteFrom-1;
    NumToCopy=abs(S-SubString);
    strncpy(TempString1,S,NumToCopy);
    SubString+=NumToDelete;
    strcat(TempString1,SubString);
  }

  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L+1);
  strcpy(S,TempString1);
}




void StringC::Insert(const StringC &AString,int Pos)
// Insert AString.S into S before position Pos
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  SubString=S+Pos-1;
  NumToCopy=abs(S-SubString);
  strncpy(TempString1,S,NumToCopy);
  strcat(TempString1,AString.S);
  strcat(TempString1,SubString);
  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L);
  strcpy(S,TempString1);
}




void StringC::Insert(const char *AString,int Pos)
// Insert AString into S before position Pos
{
  char *SubString;
  int NumToCopy;

  strset_(TempString1,EOS,MAXSTRING);
  SubString=S+Pos-1;
  NumToCopy=abs(S-SubString);
  strncpy(TempString1,S,NumToCopy);
  strcat(TempString1,AString);
  strcat(TempString1,SubString);
  delete S;
  L=strlen(TempString1);
  S=new char[L+1];
  strset_(S,EOS,L);
  strcpy(S,TempString1);
}




bool StringC::Equal(const StringC &AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString.S);

  if (Num==0)
    Result=true;
  else
    Result=false;

  return Result;
}




bool StringC::NotEqual(const StringC &AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString.S);

  if (Num==0)
    Result=false;
  else
    Result=true;

  return Result;
}




bool StringC::Greater(const StringC &AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString.S);

  if (Num>0)
    Result=true;
  else
    Result=false;

  return Result;
}




bool StringC::Less(const StringC &AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString.S);

  if (Num<0)
    Result=true;
  else
    Result=false;

  return Result;
}




bool StringC::Equal(const char *AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString);

  if (Num==0)
    Result=true;
  else
    Result=false;

  return Result;
}




bool StringC::NotEqual(const char *AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString);

  if (Num==0)
    Result=false;
  else
    Result=true;

  return Result;
}




bool StringC::Greater(const char *AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString);

  if (Num>0)
    Result=true;
  else
    Result=false;

  return Result;
}




bool StringC::Less(const char *AString)
// Case sensitive StringC comparison
{
  bool Result;
  int Num;

  Num=strcmp(S,AString);

  if (Num<0)
    Result=true;
  else
    Result=false;

  return Result;
}




const char *StringC::GetS()
// Returns (char *) S.
{
  return S;
}




bool StringC::ToInt(int &Integer)
// Converts S to an integer returning true if successful and false otherwise.
{
  // We need to be able to view a variable as a long integer and an integer
  // at the same time and unions allow us to do this. In this way we can
  // convert S to a long integer and then return it as a integer if it is
  // in range.
  typedef union{int Int;long Long;} ConverterType;
  ConverterType Converter;
  const char Zero=48;
  const char Nine=57;
  const char Minus=45;
  int Index,Sign;
  bool Result;

  // If the first character is a minus sign and there are more characters
  // then set Sign to -1, which the integer is later multiplied by.
  if ((S[0]==Minus) && (L>1))
  {
    Sign=-1;
    Result=true;
    // Index starts at one since the first character has been processed.
    Index=1;
  }
  // If the first character is a digit then convert it to the integer it
  // represents.
  else if ((S[0]>=Zero) && (S[0]<=Nine))
  {
    Converter.Long=(S[0]-Zero)*10;
    Result=true;
    Sign=1;
    // Index starts at one since the first character has been processed.
    Index=1;
  }
  // Otherwise set Result to false so that no further action is taken.
  else
  {
    Integer=0;
    Result=false;
  }
  // While Result is still true continue converting S.
  while ((Index<L) && Result)
  {
    Result=((S[Index]>=Zero) && (S[Index]<=Nine));
    if (Result)
    {
      Converter.Long+=S[Index]-Zero;
      // Only want to multiply by ten if processing the last character.
      if (Index<(L-1))
        Converter.Long*=10;
      Index++;
    }
  }
  // If S was successfully converted.
  if (Result)
  {
    Converter.Long*=Sign;
    // Check if value is out of range for an integer.
    if ((Converter.Long<-32768) || (Converter.Long>32767))
    {
      Result=false;
      Integer=0;
    }
    else
    {
      Result=true;
      Integer=Converter.Int;
    }
  }
  return Result;
}




void StringC::Set(const char Ch)
{
  strset_(S,Ch,L);
  // In case Ch is EOS.
  L=strlen(S);
}

Newsgroups: comp.os.msdos.djgpp
Subject: Compiler error?????
Summary: 
Followup-To: 
Distribution: world
Organization: Comp.Sci & Comp.Eng, La Trobe Uni, Australia
Keywords: