JString.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
#include "JString.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <math.h>

#if defined(WIN32)
//   #define _CRTDBG_MAP_ALLOC 
//   #include <stdlib.h>
//   #include <crtdbg.h>
#endif

#include "Collections.h"
#include "Dictionary.h"
#include "DotString.h"
#include "JTime.h"

namespace cmlabs {

JString::JString( const char *str )
{
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
   if ( str == NULL )
      str = "";
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
//   adjustBuffer( Length = (unsigned int)strlen( str ) );
   setBufferSizeInline(Length = (unsigned int)strlen(str));
   strcpy( Buffer, str );
}

JString::JString(char ch)
{
        Buffer = NULL;
        Length = BufferLen = 0;
   isCRTerminated = false;
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
//   adjustBuffer( Length = 1 );
   setBufferSizeInline(Length = 1);
   Buffer[0] = ch;
   Buffer[1] = 0;
}

JString::JString(void* pointer) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        #ifdef WIN32
                lpwBuffer = NULL;
        #endif

        setBufferSizeInline(Length = 20);
        sprintf(Buffer, "%p", pointer);

//      char* str = (char*)malloc(20);
//      sprintf(str, "%p", pointer);
//      setBufferSizeInline(Length = strlen(str));
//      strcpy(Buffer, str);
}

JString::JString( const bool val )
{
        Buffer = NULL;
        Length = BufferLen = 0;
   isCRTerminated = false;
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
//   adjustBuffer( Length = 6 );
        setBufferSizeInline(Length = 4);
   if (val)
           strcpy( Buffer, "Yes" );
   else
           strcpy( Buffer, "No" );
}

JString::JString( const JString &str )
{
        Buffer = NULL;
        Length = BufferLen = 0;
        #ifdef WIN32
        if (str.lpwBuffer != NULL) {
                lpwBuffer = (WCHAR*)malloc((wcslen(str.lpwBuffer)+1)*sizeof(WCHAR));
                wcscpy(lpwBuffer, str.lpwBuffer);
        }
        else
                lpwBuffer = NULL;
        #endif
        isCRTerminated = str.isCRTerminated;
        //adjustBuffer( Length = (unsigned int)str.Length );
        setBufferSizeInline(Length = str.Length);
        strcpy( Buffer, str.Buffer );
}


JString JString::format( char *formatstring, ... ) {

    va_list args;
    va_start(args, formatstring);
/*
        int l = strlen(formatstring) + 10000;
        char* str = (char*)malloc(l);
        #ifdef WIN32
                #ifdef CYGWIN
                        vsnprintf(str, l, formatstring, args);
                #else
                        _vsnprintf(str, l, formatstring, args);
                #endif
        #else
                vsnprintf(str, l, formatstring, args);
        #endif // WIN32
        va_end(args);

        JString res = JString(str);
        free((char*)str);
*/

        char* str;
        JString res;

        #ifdef HAVE_VASPRINTF
                int len = vasprintf(&str, formatstring, args);
                if(len<0) {
                }
                else {
                        free(res.Buffer);
                        res.Buffer=str;
                        res.Length=len;
                        res.BufferLen=len;
                }
                va_end(args);
//              res = JString(str);
//              free(str);
        #else //HAVE_VASPRINTF

                int size = -1;
                #ifdef WIN32
                        #ifdef WIN32_VS
                                #ifndef WIN32_VS6
                                        size = _vscprintf(formatstring, args);
                                #endif
                        #endif // WIN32_VSN
                #else // WIN32
                        size = vsnprintf(NULL, 0, formatstring, args);
                        // args is now invalid, so we need to end and start them again...
                        va_end(args);
                        va_start(args, formatstring);
                #endif // WIN32

                int vsnprintf_result = -1;
                if (size >= 0) {
                        size += 10;
                        str = (char*)malloc(size+1);
                        #ifdef WIN32
                                #ifdef CYGWIN
                                        vsnprintf_result = vsnprintf(str, size, formatstring, args);
                                #else
                                        vsnprintf_result = _vsnprintf(str, size, formatstring, args);
                                #endif
                        #else
                                vsnprintf_result = vsnprintf(str, size, formatstring, args);
                        #endif // WIN32
                }
                else {
                        int max = 1024*1024*10; // 10 MB max
                        size = 1024*10; // Initial buffer

                        int count = 0;
                        while (size <= max) {
                                count++;
                                str = (char*)malloc(size);
                                #ifdef WIN32
                                        #ifdef CYGWIN
                                                vsnprintf_result = vsnprintf(str, size, formatstring, args);
                                        #else
                                                vsnprintf_result = _vsnprintf(str, size, formatstring, args);
                                        #endif
                                #else
                                        vsnprintf_result = vsnprintf(str, size, formatstring, args);
                                #endif // WIN32

                                // Win32 returns -1, Unix returns the size needed
                                if ( (vsnprintf_result >= 0) && (vsnprintf_result < size) ) {
                                        break;
                                }
                                else if (vsnprintf_result >= size) {
                                        va_end(args);
                                        free((char*)str);
                                        str = NULL;
                                        size = vsnprintf_result + 10;
                                        va_start(args, formatstring);
                                }
                                else {
                                        va_end(args);
                                        free((char*)str);
                                        str = NULL;
                                        size *= 2;
                                        va_start(args, formatstring);
                                }
                        }
                }

                va_end(args);
                if ((vsnprintf_result >= 0) && (str != NULL))
                        res = JString(str);
                else {
                        // 10 MB buffer not big enough, giving up...
                        res = "";
                }
                free((char*)str);

        #endif //HAVE_VASPRINTF

        return res;
}


JString::JString( const JString &s, unsigned int width, int justification ) {

        Buffer = NULL;
        Length = BufferLen = 0;
   isCRTerminated = s.isCRTerminated;
   JString str;
   unsigned int l = s.Length;
   unsigned int n = 0;

   if (justification == 0) { // left
      if (l > width)
         str = s.substring(0, width);
      else if (l == width)
         str = s;
      else {
         str = s;
         for (n=0; n<(width - l); n++)
            str += " ";
      }
   }
   else if (justification == 1) { // right
      if (l > width)
         str = s.substring(l - width);
      else if (s.Length == width)
         str = s;
      else {
         str = s;
         for (n=0; n<(width - l); n++)
            str = JString(" ") + str;
      }
   }
   else { // center
      if (l > width)
         str = s.substring((int) ((l - width)/2));
      else if (s.Length == width)
         str = s;
      else {
         str = s;
         for (n=0; n<(int) ((width - l)/2); n++)
            str = JString(" ") + str + JString(" ");
      }
          while (str.Length < width)
                str = str + JString(" ");
   }
   
//   adjustBuffer( Length = (unsigned int)str.Length );
        setBufferSizeInline(Length = str.Length);
   strcpy( Buffer, str.Buffer );

   #ifdef WIN32
      lpwBuffer = NULL;
   #endif

}

JString::JString( unsigned int intValue, int padding) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        char* str = (char*)malloc(100);
        sprintf(str, "%u", intValue);
        int len = (int)strlen(str);
        int n;

        if (len >= padding) {
        }
        else {
                for (n=len; n>=0; n--)
                        str[n+padding-len] = str[n];
                for (n=0; n<padding-len; n++)
                        str[n] = '0';
        }

//      adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
        strcpy( Buffer, str );
        free((char*)str);

        #ifdef WIN32
                lpwBuffer = NULL;
        #endif
}

JString::JString( int intValue, int padding) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        char* str = (char*)malloc(100);
        sprintf(str, "%d", intValue);
        int len = (int)strlen(str);
        int n;

        if (len >= padding) {
        }
        else {
                for (n=len; n>=0; n--)
                        str[n+padding-len] = str[n];
                for (n=0; n<padding-len; n++)
                        str[n] = '0';
        }

//      adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
        strcpy( Buffer, str );
        free((char*)str);

        #ifdef WIN32
                lpwBuffer = NULL;
        #endif
}

JString::JString( long longValue, int padding ) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        char* str = (char*)malloc(100);
        sprintf(str, "%ld", longValue);
        int len = (int)strlen(str);
        int n;

        if (len >= padding) {
        }
        else {
                for (n=len; n>=0; n--)
                        str[n+padding-len] = str[n];
                for (n=0; n<padding-len; n++)
                        str[n] = '0';
        }

        
//   adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
   strcpy( Buffer, str );
   free((char*)str);
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
}

JString::JString(unsigned long longValue, int padding) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        char* str = (char*)malloc(100);
        sprintf(str, "%llu", longValue);
        int len = (int)strlen(str);
        int n;

        if (len >= padding) {
        }
        else {
                for (n=len; n>=0; n--)
                        str[n+padding-len] = str[n];
                for (n=0; n<padding-len; n++)
                        str[n] = '0';
        }

        
//   adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
   strcpy( Buffer, str );
   free((char*)str);
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
}

JString::JString(long long longValue, int padding) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        char* str = (char*)malloc(100);
        sprintf(str, "%lld", longValue);
        int len = (int)strlen(str);
        int n;

        if (len >= padding) {
        }
        else {
                for (n=len; n>=0; n--)
                        str[n+padding-len] = str[n];
                for (n=0; n<padding-len; n++)
                        str[n] = '0';
        }

        
//   adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
   strcpy( Buffer, str );
   free((char*)str);
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
}

JString::JString(unsigned long long longValue, int padding) {
        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
        char* str = (char*)malloc(100);
        sprintf(str, "%llu", longValue);
        int len = (int)strlen(str);
        int n;

        if (len >= padding) {
        }
        else {
                for (n=len; n>=0; n--)
                        str[n+padding-len] = str[n];
                for (n=0; n<padding-len; n++)
                        str[n] = '0';
        }

        
//   adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
   strcpy( Buffer, str );
   free((char*)str);
   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
}

JString::JString( double doubleValue, int afterdec, int beforedec) {
        Buffer = NULL;
        Length = BufferLen = 0;
   isCRTerminated = false;
   int zeros;

//      longlong testval;
//      double val;

        // If autodetect length
        if (afterdec < 0) {
                afterdec = 20;
        /*      int n;
                for (n=0; n<100; n++) {
                        testval = (longlong) (doubleValue*pow((double)10, n));
                        val = doubleValue*pow((double)10, n);
                        if (val == (double) testval)
                                break;
                }
                afterdec = n;*/
        }

   char* decpoint;
   char* formatstr = (char*)malloc(20);
   char* str = (char*)malloc(afterdec + beforedec + 100);

   if (afterdec >= 0) {
      sprintf(formatstr, "%%.%df", afterdec);
      sprintf(str, formatstr, doubleValue);
   }
   else {
      strcpy(str, "0");
   }

   if (beforedec > 0) {
      decpoint = strstr(str, ".");
      if (decpoint == NULL) {
         zeros = beforedec - (int)strlen(str);
      }
      else {
         zeros = beforedec - (int)(decpoint - str);
      }

      if (zeros > 0) {
         int n;
         char* charzero = (char*)malloc(zeros+50);
         for (n=0; n<zeros; n++)
            charzero[n] = '0';
         for (n=0; n < (int) strlen(str) + 1; n++)
            charzero[n+zeros] = str[n];
         strcpy(str, charzero);
         free((char*)charzero);
      }
   }

   for (int n=(int)strlen(str)-1; n>0; n--) {
           if (str[n] == '0')
                   str[n] = 0;
           else if (str[n] == '.') {
                   str[n] = 0;
                   break;
           }
           else
                   break;
   }
   if (strlen(str) == 0)
           str[0] = '0';

//   adjustBuffer( Length = (unsigned int)strlen( str ) );
        setBufferSizeInline(Length = (unsigned int) strlen(str));
   strcpy( Buffer, str );

   free((char*)formatstr);
   free((char*)str);

   #ifdef WIN32
      lpwBuffer = NULL;
   #endif
}

JString::~JString() {
        free((char*)Buffer);
        #ifdef WIN32
                free((char*)lpwBuffer);
        #endif
}


//! Get total size of payload
unsigned long JString::getPayloadSize() const {
        return Length;
}

Object* JString::clone() const {
   JString* str = new JString(*this);
   return (Object*) str;
}

JString JString::print() {
        return *this;
}


JString::operator char *() const {
   char* str = Buffer;
   return str;
}

JString::operator const char *() const {
   const char* str = Buffer;
   return str;
}

JString::operator void *() {
   void* str = (void*) Buffer;
   return str;
}

JString::operator const void *() {
   const void* str = (void*) Buffer;
   return str;
}

const char* JString::charpoint() const {
   const char* str = Buffer;
   return str;
}

char* JString::getCharCopy(int &len) const {
        len = (int) Length;
        if (len <= 0) {
                len = 0;
                return NULL;
        }
        //this MUST be new'd because it's being passed externally
        char* data = new char [len+1]; 
        memcpy(data, charpoint(), len);
        data[len] = 0;
        return data;
}

DotString JString::toDotString() const {
   return DotString(*this);
//   DotString ds = DotString(*this);
//   return ds;
}

JTime JString::toTime() {
   JTime t = JTime(*this);
   return t;
}

JString JString::getFirst(int len) {
   if ((int)Length <= len)
      return *this;
   else
      return substring(0, len);
}

JString JString::getLast(int len) {
   if ((int)Length <= len)
      return *this;
   else
      return substring(Length-len);
}


char JString::charAt( unsigned int loc ) const {
   return operator[]( loc );
}

char JString::getCharAt( unsigned int loc ) const {
   return operator[]( loc );
}

bool JString::setCharAt( unsigned int i, char ch ) {
        if ( (i >= 0) && (i < Length) ) {
                Buffer[i] = ch;
                return true;
        }
        else
                return false;
}


int JString::compare(const Object* o2) const {
        if ((o2 == NULL) || (!isSameClass(o2)))
                return 0;
        return compareTo(*(JString*) o2);
}

int JString::compareTo( const JString &s2 ) const {
   return strcmp( Buffer, s2.Buffer );
}

const JString& JString::concat( const JString &s2 ) {
   return (*this) += s2;
}

const JString& JString::operator=( const JString &str ) {
   if ( this == &str )
      return *this;

   if ( str.Length > Length ) {
      //free((char*)Buffer);
      //adjustBuffer( str.Length );
        setBufferSizeInline(Length = (unsigned int) str.Length);
   }

        Length = str.Length;
        if ( (Length > 0) && (str.Buffer != NULL) )
                strcpy( Buffer, str.Buffer );
        else
                strcpy(Buffer, "");

   isCRTerminated = str.isCRTerminated;

   return *this;
}

const JString& JString::operator+=( const char aChar ) {
        setBufferSizeInline(Length+1);
   //if ( Length == BufferLen )
   //   doubleBuffer();

   Buffer[ Length++ ] = aChar;
   Buffer[ Length ] = '\0';

   return *this;
}

const JString& JString::operator+=( const unsigned char aChar ) {
        setBufferSizeInline(Length+1);
   //if ( Length == BufferLen )
   //   doubleBuffer();

   Buffer[ Length++ ] = aChar;
   Buffer[ Length ] = '\0';

   return *this;
}

const JString& JString::operator+=( const JString &other ) {
        setBufferSizeInline(Length + other.Length);
        memcpy(Buffer+Length, other.Buffer, other.Length);
        Length += other.Length;
        Buffer[Length] = 0;
        return *this;
}

const JString& JString::operator+=(const char* str) {
        if (str != NULL) {
                int len = (int)strlen(str);
                setBufferSizeInline(Length + len);
                memcpy(Buffer+Length, str, len);
                Length += len;
                Buffer[Length] = 0;
        }
        return *this;
}

int JString::operator ==(const char* chr) const {
   return strcmp( Buffer, chr ) == 0;
}

int JString::operator !=(const char* chr) const {
   return strcmp( Buffer, chr ) != 0;
}


int JString::operator==( const JString &str ) const {
   return this->equals(str);
}

int JString::operator!=( const JString &str ) const {
   return (!this->equals(str));
}

int JString::operator<( const JString &str ) const {
   return strcmp( Buffer, str.Buffer ) < 0;
}

int JString::operator>( const JString &str ) const {
   return strcmp( Buffer, str.Buffer ) > 0;
}

int JString::operator<=( const JString &str ) const {
   return strcmp( Buffer, str.Buffer ) <= 0;
}

int JString::operator>=( const JString & str ) const {
   return strcmp( Buffer, str.Buffer ) >= 0;
}


char& JString::operator[]( unsigned int i ) {
   if (i >= Length)
           return Buffer[ Length ];
   else
           return Buffer[ i ];
}

char JString::operator[]( unsigned int i ) const {
   if (i >= Length)
           return 0;
   else
           return Buffer[ i ];
}


char& JString::operator[]( int i ) {
   return operator[]((unsigned) i);
}

char JString::operator[]( int i ) const {
   return operator[]((unsigned) i);
}


bool JString::endsWith( const JString &s2 ) const {
   if ( Length < s2.Length )
      return 0;

   return strcmp( &Buffer[ Length - s2.Length], s2.cstr() ) == 0;
}

bool JString::equals(const Object* o2) const {
        if (o2 == NULL) return false;
        if (!this->isSameClass(o2)) {
                printf("O2[%s]: %s != %s\n", (char*) o2->getClass(), (char*) *this, (char*) (*(JString*)o2));
                return false;
        }
        return this->equals(*(JString*)o2);
}


bool JString::equals( const JString &s2 ) const {
   return ( strcmp( Buffer,s2.Buffer ) == 0 );
}


bool JString::equalsIgnoreCase( const JString &s2 ) const {
   if ( this == &s2 )
      return 1;
   else if ( Length != s2.Length )
      return 0;

        #ifdef WIN32
                return stricmp(Buffer, s2.Buffer) == 0;
        #else // WIN32
                return strcasecmp(Buffer, s2.Buffer) == 0;
        #endif // WIN32
}

int JString::indexOfCount(const JString& match) const {
        int count = 0;
        int loc = 0;

        if (match.length() == 1) {
                char ch = match.charAt(0);
                while ( (loc = indexOf( ch, loc)) != -1 ) {
                        loc += match.Length;
                        count++;
                }
        }
        else {
                while ( (loc = indexOf( match, loc)) != -1 ) {
                        loc += match.Length;
                        count++;
                }
        }
        return count;
}

int JString::indexOfCountIgnoreCase(const JString& match) const {
        JString str = this->toLowerCase();
        JString lmatch = match.toLowerCase();
        return str.indexOfCount(lmatch);
}


void JString::replace( char findChar, char replaceChar) {
   char* temp = strchr( Buffer, findChar );
   if ( temp != NULL )
      *temp = replaceChar;
}
   
int JString::replace(const JString& match, const JString& replacement, bool all, bool recursive) {
        int crCount = indexOfCount(match);
        if (crCount == 0)
                return 0;

        JString result;
        result.setBufferSizeInline(Length + (crCount * replacement.Length + 10));
        char* src = (char*) Buffer;
        char* dst = (char*) result;

        unsigned int dstpos = 0;
        unsigned int srcpos = 0;

        int matchLen = match.Length;
        int replLen = replacement.Length;
        int pos = 0;
        int len;

        int count = 0;
        while ( (pos = indexOf(match, pos)) >= 0) {
                len = pos - srcpos;
                memcpy(dst+dstpos, src+srcpos, len);
                dstpos += len;
                memcpy(dst+dstpos, replacement.Buffer, replLen);
                dstpos += replLen;
                srcpos = pos + matchLen;
                pos = srcpos;
                count++;
                if (!all) break;
        }
        len = Length - srcpos;
        memcpy(dst+dstpos, src+srcpos, len);
        dstpos += len;
        dst[dstpos] = 0;
        result.Length = dstpos;

        if ( recursive && (result.indexOf(match) >= 0) )
                result.replace(match, replacement, all, recursive);
        *this = result;
        return count;
}

int JString::replaceIgnoreCase(const JString& match, const JString& replacement, bool all, bool recursive) {

        int crCount = indexOfCountIgnoreCase(match);
        if (crCount == 0)
                return 0;

        JString result;
        result.setBufferSizeInline(Length + (crCount * replacement.Length + 10));
        char* src = (char*) Buffer;
        char* dst = (char*) result;

        unsigned int dstpos = 0;
        unsigned int srcpos = 0;

        int matchLen = match.Length;
        int replLen = replacement.Length;
        int pos = -1;
        int len;

        int count = 0;
        while ( (pos = indexOfIgnoreCase(match, pos+1)) >= 0) {
                len = pos - srcpos;
                memcpy(dst+dstpos, src+srcpos, len);
                dstpos += len;
                memcpy(dst+dstpos, replacement.Buffer, replLen);
                dstpos += replLen;
                srcpos = pos + matchLen;
                count++;
                if (!all) break;
        }
        len = Length - srcpos;
        memcpy(dst+dstpos, src+srcpos, len);
        dstpos += len;
        dst[dstpos] = 0;
        result.Length = dstpos;

        if ( recursive && (result.indexOfIgnoreCase(match) >= 0) )
                result.replace(match, replacement, all, recursive);
        *this = result;
        return count;
}



void JString::replace( int fromPos, int toPos, const JString& replacement ) {
        // Move rest of string accordingly
        int reloc = replacement.Length - (toPos - fromPos);
        setBufferSizeInline(Length + reloc);
        memmove(Buffer+toPos+reloc, Buffer+toPos, Length-toPos+1); // incl. \0
        Length += reloc;
        memcpy(Buffer+fromPos, replacement.charpoint(), replacement.length());
}


bool JString::contains(const JString& str) const {
   return (indexOf(str) >= 0);
}

bool JString::looksLikeXML() const {
   JString str = this->trim();
   return (str.startsWith("<") && str.endsWith(">"));
}

bool JString::isUTF() const {
        return (
                (((unsigned char)Buffer[0]) == 239) &&
                (((unsigned char)Buffer[1]) == 187) &&
                (((unsigned char)Buffer[2]) == 191)
        );
}

JString JString::addUTFHeader() const {
        JString str = JString::format("xxx%s", (char*) *this);
        *((unsigned char*)(str.Buffer)) = 239;
        *((unsigned char*)(str.Buffer+1)) = 187;
        *((unsigned char*)(str.Buffer+2)) = 191;
        return str;
}

bool JString::addCRLF() {

        setBufferSizeInline(Length+2);
//   if ( Length == BufferLen )
//      doubleBuffer();

   Buffer[ Length++ ] = (char) 13;
   Buffer[ Length++ ] = (char) 10;
   Buffer[ Length ] = '\0';

   return true;
}

JString JString::indentHTML(int numTabs) const {
        JString html = indentXML();
        html.replace("\t", "&nbsp;&nbsp;&nbsp;");
        return html;
}

JString JString::indentXML(int numTabs) const {
        
        if (Length <= 0)
                return "";
//      JString str = *this;
//      str.replace("\r\n", "\n");
//      str.replace("\r", "\n");

        int n;
        int crCount = indexOfCount("\n") + indexOfCount("\r");
        JString result;
        result.setBufferSizeInline(Length + ((crCount+1) * 2 * numTabs));
        char* src = (char*) Buffer;
        char* dst = (char*) result;

        unsigned int dstpos = 0;
        unsigned int srcpos = 0;
        for (n=0; n<numTabs;n++)
                dst[dstpos++] = '\t';
        while (srcpos < Length-1) {
                switch (src[srcpos]) {
                        case '\n':
                                dst[dstpos++] = '\n';
                                for (n=0; n<numTabs;n++)
                                        dst[dstpos++] = '\t';
                                if (src[srcpos+1] == '\r')
                                        srcpos++;
                                srcpos++;
                                break;
                        case '\r':
                                dst[dstpos++] = '\n';
                                for (n=0; n<numTabs;n++)
                                        dst[dstpos++] = '\t';
                                if (src[srcpos+1] == '\n')
                                        srcpos++;
                                srcpos++;
                                break;
                        default:
                                dst[dstpos++] = src[srcpos++];
                }
        }
        dst[dstpos++] = src[srcpos++];
        if ( (src[srcpos] != '\n') && (src[srcpos] != '\r') && (src[srcpos-1] != '\n') )
                dst[dstpos++] = '\n';
        dst[dstpos] = 0;
        result.Length = dstpos;

//      printf("\n%s\n", (char*) result);
        return result;

/*      str.setBufferSizeInline(str.Length + 2*crCount);

        bool endCR = false;
        if (str.charAt(str.Length-1) == '\n') {
                endCR = true;
                str.setCharAt(str.Length-1, 0);
        }
        str.replace("\n", "\n\t");

        return JString::format("\t%s\n", (char*) str);
*/
/*      if (endCR)
                return JString::format("\t%s\n", (char*) str);
        else
                return JString::format("\t%s", (char*) str);
*/
/*      JString str;
        Collection lines = splitIntoLines();
        for (int n=0; n<lines.getCount(); n++) {
                str += JString::format("\t%s\n", (char*) lines.get(n));
        }
        return str;*/
}

JString JString::indent(int numSpaces) const {
        
        if (Length <= 0)
                return "";

        int n;
        int crCount = indexOfCount("\n") + indexOfCount("\r");
        JString result;
        result.setBufferSizeInline(Length + ((crCount+1) * 2 * numSpaces));
        char* src = (char*) Buffer;
        char* dst = (char*) result;

        unsigned int dstpos = 0;
        unsigned int srcpos = 0;
        for (n=0; n<numSpaces;n++)
                dst[dstpos++] = ' ';
        while (srcpos < Length-1) {
                switch (src[srcpos]) {
                        case '\n':
                                dst[dstpos++] = '\n';
                                for (n=0; n<numSpaces;n++)
                                        dst[dstpos++] = ' ';
                                if (src[srcpos+1] == '\r')
                                        srcpos++;
                                srcpos++;
                                break;
                        case '\r':
                                dst[dstpos++] = '\n';
                                for (n=0; n<numSpaces;n++)
                                        dst[dstpos++] = ' ';
                                if (src[srcpos+1] == '\n')
                                        srcpos++;
                                srcpos++;
                                break;
                        default:
                                dst[dstpos++] = src[srcpos++];
                }
        }
        dst[dstpos++] = src[srcpos++];
        if ( (src[srcpos] != '\n') && (src[srcpos] != '\r') && (src[srcpos-1] != '\n') )
                dst[dstpos++] = '\n';
        dst[dstpos] = 0;
        result.Length = dstpos;

//      printf("\n%s\n", (char*) result);
        return result;
}

JString JString::toXML() {
        return JString::format("<string>%s</string>", (char*) this->xmlStringEncode());
}

bool JString::fromXML(const JString& xml) {

        char *first, *last;

        first = strstr((char*)xml, "<string>");
        if (first != NULL) {
                last = strstr((char*)xml, "</string>");
                if (last != NULL) {
                        int n;
                        char* newchar = (char*)malloc(xml.Length);
                        for (n=0; n<(last-first-8); n++)
                        newchar[n] = first[n+8];
                        newchar[n] = 0;
                        *this = newchar;
                        // adjustBuffer( Length = strlen(newchar) );
                        // strcpy( Buffer, newchar );
                        free((char*)newchar);
                        return true;
                }
        }
   
/*   if (( != NULL) &&
      (strstr(str, "</string>") != NULL))

//   if (str.charAt(0) == '<')
   if (fromXML(str))
      return;
*/
   return false;
}



int JString::indexOf(char c) const {
   return indexOf(c, 0);
}

int JString::indexOf(char ch, unsigned int fromIndex) const
{
   if ( fromIndex >= Length )
      return -1;

   const char* temp = strchr( &Buffer[fromIndex], ch );
   if ( temp == NULL )
      return -1;

   return (int)(temp - Buffer);
}

int JString::indexOf( const JString &s2 ) const {
   return indexOf( s2, 0 );
}


int JString::indexOf( const JString &s2, unsigned int fromIndex ) const {
   if ( fromIndex > Length )
      return -1;
        
   if (s2.Length == 0)
           return -1;
   else if (s2.Length == 1)
           return indexOf(s2.charAt(0), fromIndex);

   const char *theFind = strstr( &Buffer[ fromIndex ], s2.cstr() );

   if ( theFind == NULL )
      return -1;

   return (int)(theFind - Buffer);
}



int JString::lastIndexOf( char theChar ) const {
   return lastIndexOf( theChar, Length);
}

int JString::lastIndexOf( char ch, unsigned int fromIndex ) const {
        if ( fromIndex > Length )
                return -1;

        JString str = this->invertString();
        int pos = str.indexOf(ch, Length - fromIndex);
        if (pos < 0)
                return -1;
        return Length - 1 - pos;
}

int JString::lastIndexOf( const JString &s2 ) const {
        return lastIndexOf( s2, Length);
}

int JString::lastIndexOf( const JString &s2, unsigned int fromIndex ) const {
        if ( fromIndex > Length )
                return -1;

        JString str = this->invertString();
        JString str2 = s2.invertString();
        int pos = str.indexOf(str2, Length - fromIndex);
        if (pos < 0)
                return -1;
        return Length - pos - s2.length();
}

JString JString::invertString() const {
        char* buf = (char*)malloc(Length + 1);
        for (int n=0; n<(int)Length; n++) {
                buf[n] = Buffer[Length-n-1];
        }
        buf[Length] = 0;
        JString str = JString(buf);
        free((char*)buf);
        return str;
}

bool JString::startsOrEndsWithWhiteSpace() const {
    return ( (Length > 0) && ( ((unsigned char)Buffer[0] < 33) || ((unsigned char)Buffer[Length-1] < 33) ) );
}

bool JString::startsWithWhiteSpace() const {
    return ( (Length > 0) && ((unsigned char)Buffer[0] < 33) );
}

bool JString::endsWithWhiteSpace() const {
    return ( (Length > 0) && ((unsigned char)Buffer[Length-1] < 33) );
}


bool JString::startsWith( const JString &s2 ) const {
   if ( Length < s2.Length )
      return 0;
   return startsWith( s2, 0 );
}

bool JString::startsWith( const JString &s2, unsigned int offset ) const {
   if ( offset > Length - s2.Length )
      return 0;
   return strncmp( &Buffer[offset], s2.cstr(), s2.Length ) == 0;
}

JString JString::substring( unsigned int left ) const {
   return substring( left, Length );
}

JString JString::substring( unsigned int left, unsigned int right ) const {
   if ( left > right )
   {
      int temp = right;
      right = left;
      left = temp;
   }

   if ( right > Length )
   {
      if (DEBUGLEVEL(KITCHENSINK)) {
         printf("Index Out Of Bounds Exception in JString\n");
      }
          right = Length;
   }

   char temp = Buffer[ right ];
   Buffer[ right ] = '\0';

   JString outPut = ( Buffer + left );

   Buffer[ right ] = temp;

   return outPut;
}

JString JString::toLowerCase( ) const {
        JString temp = Buffer;
        for ( unsigned int i = 0; i < Length; i++ )
                temp.Buffer[ i ] = tolower( temp.Buffer[ i ] );
        return temp;
}

JString JString::toUpperCase() const {
   JString temp = Buffer;

   for ( unsigned int i = 0; i < Length; i++ )
      temp.Buffer[ i ] = toupper( temp.Buffer[ i ] );

   return temp;
}

JString JString::trimLines() const {
        Collection lines = splitIntoLines();
        JString str = lines.get(0).trim();
        for (int n=1; n<lines.getCount(); n++)
                str += JString::format("\n%s", (char*) lines.get(n).trim());
        if (lines.getCount() > 1)
                str += "\n";
        return str;
}

JString JString::trimLinesRemoveEmpty() const {
        Collection lines = splitIntoLines();
        JString str;
        int first = 0;
        int c = 0;
        while ( (first < lines.getCount()) && ( (str = lines.get(first).trim()).length() == 0) )
                first++;
        first++;
        JString s;
        for (int n=first; n<lines.getCount(); n++) {
                if ( (s = lines.get(n).trim()).length() > 0) {
                        str += JString::format("\n%s", (char*) s);
                        c++;
                }
        }
        if (c > 0)
                str += "\n";
        return str;
}

JString JString::concatLines() const {
        Collection lines = splitIntoLines();
        JString str = lines.getFirst().trim();
        JString s;
        for (int n=1; n<lines.getCount(); n++) {
                if ( (s = lines.get(n).trim()).length() > 0)
                        str += JString::format(" %s", (char*) s);
        }
        return str;
}

JString JString::trimLeading() const {
   if (Length == 0)
      return *this;

   unsigned int i;

   for ( i = 0; i < Length; i++ )
   {
      if ( (unsigned char)Buffer[i] > 32 )
         break;
   }

   return substring( i);
}

JString JString::trimTrailing() const {
   if (Length == 0)
      return *this;

   unsigned int j;

   for ( j = Length - 1; j > 0; j-- )
   {
      if ( (unsigned char)Buffer[j] > 32 )
         break;
   }

   return substring( 0, j + 1);
}

JString JString::trim() const {
   if (Length == 0)
      return *this;

   unsigned int i,j;

   for ( i = 0; i < Length; i++ )
   {
      if ( (unsigned char)Buffer[i] > 32 )
         break;
   }

   for ( j = Length - 1; j > i; j-- )
   {
      if ( (unsigned char)Buffer[j] > 32 )
         break;
   }

   return substring( i, j + 1);
}

JString JString::trimCTRL() const {
        if (Length == 0)
                return *this;

        JString result = *this;
        unsigned int dstPos = 0;
        char* dst = result.Buffer; // new char[Length+1];
        for (unsigned int n=0; n<Length; n++) {
                if ((unsigned char)Buffer[n] > 31)
                        dst[dstPos++] = Buffer[n];
        }
        dst[dstPos] = 0;
        result.Length = dstPos;
        return result;
}


//! Splits a string on another string into an Collection
// Collection JString::split(char* str) { JString s = str; return split(s); }
Collection JString::split(const JString& splitstr) const {
   Collection oc;
   int n, last;

   if (Length == 0)
           return oc;

   int len = splitstr.Length;
   if (len == 0) {
           oc.add(*this);
           return oc;
   }

   n = 0;
   last = 0;
   while ((n = this->indexOf(splitstr, last)) >= 0) {
      oc.add(this->substring(last, n));
      last = n+len;
   }
   // If none is found add rest of line, even if empty
   oc.add(this->substring(last));

   return oc;
}

//! Splits a string on another string, then split each into two, into a Dictionary
// Dictionary JString::split(char* splitstr, char* equalstr) { JString s1 = splitstr; JString s2 = equalstr; return split(s1, s2); }
//! Splits a string on another string, then split each into two, into a Dictionary
Dictionary JString::split(const JString& splitstr, const JString& equalstr) const {
        Dictionary dict;
        Collection oc;
        int n, last;

        int len = splitstr.Length;
        if (len == 0) {
                oc = this->split(equalstr);
                if (oc.getCount() == 2) {
                        dict.put(oc.get(0), oc.get(1));
                }
                return dict;
        }

        n = 0;
        last = 0;
        while ((n = this->indexOf(splitstr, last)) >= 0) {
                oc = this->substring(last, n).split(equalstr);
                if (oc.getCount() == 2) {
                        dict.put(oc.get(0), oc.get(1));
                }
                last = n+len;
        }
        // If none is found add rest of line, even if empty
        oc = this->substring(last).split(equalstr);
        if (oc.getCount() == 2) {
                dict.put(oc.get(0), oc.get(1));
        }

        return dict;
}

Collection JString::splitIntoLines() const {

        JString str = *this;
        str.replace("\r", "");
        Collection oc = str.split("\n");
        // If last char is a <CR>, do not add an extra line to the mix
//      if (oc.getLast().Length == 0)
//              oc.removeLast();
        return oc;
}

//! Splits a text into lines of max width
Collection JString::splitLinesOnWidth(int maxWidth) const {
        // First split into lines based on line breaks
        Collection rawlines = this->splitIntoLines();
        
        // Then check each of these lines for maxWidth
        Collection lines;
        for (int n=0; n<rawlines.getCount(); n++) {
                lines.addAll(rawlines.get(n).splitSingleLineOnWidth(maxWidth));
        }
        return lines;
}

//! Splits a single line string into lines of max width
Collection JString::splitSingleLineOnWidth(int maxWidth) const {
        
        int len = Length;

        Collection lines;
        if (len < maxWidth) {
                lines.add(*this);
                return lines;
        }

        int start = 0;
        int p;
        int width;

        while (true) {
                if (len > (start+maxWidth))
                        width = maxWidth;
                else
                        width = len - start - 1;
                p = start + width;
                while ( (p > start) && (this->charAt(p) != 32) )
                        p--;
                if (p <= start) {
                        // do a hard cut
                        lines.add(this->substring(start, start+width));
                        start += width;
                }
                else {
                        lines.add(this->substring(start, p).trim());
                        start = p+1;
                }
                if (len - start < maxWidth) {
                        lines.add(this->substring(start).trim());
                        break;
                }
        }
        return lines;
}

Collection JString::splitOnWhiteSpaces() const {

        Collection oc;
        int n, last;
        bool insideQuotes = false;
        unsigned char ch = 0, lastch;

        last = 0;
        JString str;
        for (n=0; n<(int)Length; n++) {
                lastch = ch;
                ch = this->charAt(n);
                if ((ch < 33) &&  (!insideQuotes) && (lastch != '\\')) {
                        if (last < n)
                                oc.add(this->substring(last, n));
                        last = n+1;
                }
                else if (ch == '"') {
                        insideQuotes = !insideQuotes;
                }
        }

        if (last < n)
                oc.add(this->substring(last));

        return oc;
}

Dictionary JString::splitCommandLine() const {

        bool insideQuotes = false;
        bool lastWasWhiteSpace = false;
        Dictionary dict = Dictionary();
        JString arg, val, str;
        unsigned char ch;

        Collection oc;

        for (unsigned int n=0; n<Length; n++) {
                
                ch = this->charAt(n);

                if (ch <= 32) {
                        if (!insideQuotes) {
                                if (!lastWasWhiteSpace) {
                                        // An arg is ended, parse it...
                                        oc = str.split("=");
                                        arg = oc.get(0);
                                        val = oc.get(1);
                                        if ( ( (val.startsWith("\"")) && (val.endsWith("\"")) ) ||
                                                ( (val.startsWith("'")) && (val.endsWith("'")) ) ) {
                                                val = val.substring(1, val.Length-1);
                                        }
                                        dict.put(arg, val);
                                        str = "";
                                }
                                else {
                                        // Ignore this whitespace then...
                                }
                                lastWasWhiteSpace = true;
                        }
                        else {
                                str += ch;
                        }
                }
                else if (ch == '"') {
                        insideQuotes = !insideQuotes;
                        str += ch;
                        lastWasWhiteSpace = false;
                }
                else {
                        str += ch;
                        lastWasWhiteSpace = false;
                }
        }

        if (str.length() > 0) {
                oc = str.split("=");
                arg = oc.get(0);
                val = oc.get(1);
                if ( ( (val.startsWith("\"")) && (val.endsWith("\"")) ) ||
                        ( (val.startsWith("'")) && (val.endsWith("'")) ) ) {
                        val = val.substring(1, val.Length-1);
                }
                dict.put(arg, val);
                str = "";
        }

        return dict;
}


bool JString::centerLines(unsigned int width) {
        if (Length == 0) return true;

        Collection lines = this->splitIntoLines();
        int count = lines.getCount();
        int n;
        JString line;

        // Autodetect width
        for(n=0; n<count; n++) {
                line = lines.get(n);
                if (line.length() > width)
                        width = line.length();
        }

        JString result;
        JString formatstring = JString::format("%%%ds", width);
        // Center each line
        for(n=0; n<count; n++)
                result += JString(lines.get(n), width, 2) + "\n";
        *this = result;
        return true;
}

JString JString::repeat(const JString& str, int count) {
        unsigned int len = str.length();
        unsigned int maxlen = len*count;
        char* newstr = new char[maxlen + 1];
        unsigned int pos = 0;
        for (pos=0; pos < maxlen; pos += len)
                memcpy(newstr+pos, (char*)str, len);
        newstr[maxlen] = 0;
        JString result = newstr;
        delete [] newstr;
        return result;
}

JString JString::fill(const JString& str, int width) {
        unsigned int len = str.length();
        unsigned int count = (unsigned int)(width/len);
        unsigned int leftover = width - (len*count);

        char* newstr = new char[width + 1];
        unsigned int pos = 0;
        for (unsigned int n=0; n < count; n++) {
                memcpy(newstr+pos, (char*)str, len);
                pos += len;
        }
        memcpy(newstr+pos, (char*)str, leftover);
        newstr[width] = 0;
        JString result = newstr;
        delete [] newstr;
        return result;
}

JString JString::asciiMessage(const JString& title, const JString& content, unsigned int width, const JString& borderchar) {

        unsigned int borderwidth = 2*borderchar.length()+2;
        Collection lines = content.splitIntoLines();
        // Autodetect width
        unsigned int contentwidth = 0;
        for(int n=0; n<lines.getCount(); n++) {
                contentwidth = lines.get(n).length() + borderwidth;
                if (contentwidth > width)
                        width = contentwidth;
        }
        contentwidth = title.length() + borderwidth;
        if (contentwidth > width)
                width = contentwidth;

        contentwidth = width - borderwidth + 2;

        JString borderline = JString::fill(borderchar, width);

        JString result = borderline + "\n";
        result += borderchar + JString(title, contentwidth, 2) + borderchar + "\n";
        result += borderline + "\n";

        for (int n = 0; n < lines.getCount(); n++) {
                result += borderchar + JString(lines.get(n), contentwidth, 2) + borderchar + "\n";
        }
        result += borderline + "\n";

        return result;
}


bool JString::insert(JString str, int pos) {
        if (pos < 0)
                replace(0, 0, str);
        else if (pos > (int)Length)
                replace(Length, Length, str);
        else
                replace(pos, pos, str);
        return true;
}

bool JString::removeChars(int count, int pos) {
        if (count < 0)
                return true;
        if ((pos < 0) || (pos > (int)Length-1))
                return false;
        if (count > (int)Length-pos)
                count = Length-pos;
        memmove(Buffer+pos, Buffer+pos+count, Length+1-pos-count); // incl. \0
        Length -= count;
        return true;
}




bool JString::matchesWithRegExp(const JString& regExp) const {
        RegExpParser parser(regExp);
        return (parser.is_reg_exp_present((char*)*this) == 1);
}

bool JString::matchMyRegExpWith(const JString& text) const {
        RegExpParser parser((char*)*this);
        return (parser.is_reg_exp_present(text) == 1);
}

bool JString::matchesIgnoreCase(const JString& match) const {
        JString str = this->toLowerCase();
        JString lmatch = match.toLowerCase();
        return str.matches(lmatch);
}

bool JString::matches(const JString& ds) const {

        if ( (!this->contains("*")) && (!ds.contains("*")) ) {
                return this->equals(ds);
        }

        int n;
        Collection col1 = this->split("*");
        Collection col2 = ds.split("*");

        if (this->startsWith("*")) {
                col1.removeFirst();
                col1.replace(0, JString::format("*%s", (char*) col1.getFirst()));
        }
        if (ds.startsWith("*")) {
                col2.removeFirst();
                col2.replace(0, JString::format("*%s", (char*) col2.getFirst()));
        }
        if (this->endsWith("*")) {
                col1.removeLast();
//              if (col1.getCount() > 1)
//                      col1.replace(col1.getCount()-1, JString::format("*%s*", (char*) col1.getLast()));
//              else
                        col1.replace(col1.getCount()-1, JString::format("%s*", (char*) col1.getLast()));
        }
        if (ds.endsWith("*")) {
                col2.removeLast();
//              if (col2.getCount() > 1)
//                      col2.replace(col2.getCount()-1, JString::format("*%s*", (char*) col2.getLast()));
//              else
                        col2.replace(col2.getCount()-1, JString::format("%s*", (char*) col2.getLast()));
        }

        for (n=0; n<col1.getCount(); n++) {
                if (col1.getCount() > n+1) {
                        if (n>0)
                                col1.replace(n, JString::format("*%s*", (char*) col1.get(n)));
                        else
                                col1.replace(n, JString::format("%s*", (char*) col1.get(n)));
                }
                else if (col1.getCount() > 1) {
                        col1.replace(n, JString::format("*%s", (char*) col1.get(n)));
                }
        }

        for (n=0; n<col2.getCount(); n++) {
                if (col2.getCount() > n+1) {
                        if (n>0)
                                col2.replace(n, JString::format("*%s*", (char*) col2.get(n)));
                        else
                                col2.replace(n, JString::format("%s*", (char*) col2.get(n)));
                }
                else if (col2.getCount() > 1) {
                        col2.replace(n, JString::format("*%s", (char*) col2.get(n)));
                }
        }

//      printf("Col1: %s\n", (char*) col1.printListLine("|"));
//      printf("Col2: %s\n", (char*) col2.printListLine("|"));

        JString str, str2;
        int pos1, pos2;
        while ( (str = col1.getFirst()).Length > 0) {
                str.replace("*", "");
                while ( (str2 = col2.getFirst()).Length > 0) {
                        str2.replace("*", "");
                        pos1 = str2.indexOf(str);
                        pos2 = str.indexOf(str2);
                        if (str.equals(str2)) {
                                col1.removeFirst();
                                col2.removeFirst();
                                break;
                        }
                        else if ( (col1.getFirst().startsWith("*")) && (col1.getFirst().endsWith("*")) && (col2.getCount() > 1)) {
                                col2.removeFirst();
                                col1.removeFirst();
                                if ( (str = col1.getFirst()).Length == 0)
                                        return true;
                                str.replace("*", "");
                                break;
                        }
                        else if ( (col2.getFirst().startsWith("*")) && (col2.getFirst().endsWith("*")) && (col1.getCount() > 1)) {
                                col2.removeFirst();
                                col1.removeFirst();
                                if ( (str = col1.getFirst()).Length == 0)
                                        return true;
                                str.replace("*", "");
                                break;
                        }
                        else if ( (col1.getFirst().endsWith("*")) && (((pos1 == 0) || ( (pos1 > 0) && (col1.getFirst().startsWith("*")) ) ))) {
                                col1.removeFirst();
                                if ( (str = col1.getFirst()).Length == 0)
                                        return true;
                                str.replace("*", "");
                                break;
                        }
                        else if ((pos1 >= 0) &&
                                     (!col1.getFirst().endsWith("*")) &&
                                         (((pos1 == 0) || ( (pos1 == ((int)str2.Length-(int)str.Length)) && (col1.getFirst().startsWith("*")) ) ))) {
                                col1.removeFirst();
                                if ( (str = col1.getFirst()).Length == 0)
                                        return true;
                                str.replace("*", "");
                                break;
                        }
                        else if ( (col2.getFirst().endsWith("*")) && (((pos2 == 0) || ( (pos2 > 0) && (col2.getFirst().startsWith("*")) ) ))) {
                                col2.removeFirst();
                                break;
                        }
                        else if ((pos2 >= 0) &&
                                     (!col2.getFirst().endsWith("*")) &&
                                         (((pos2 == 0) || ( (pos2 == ((int)str.Length-(int)str2.Length)) && (col2.getFirst().startsWith("*")) ) ))) {
                                col2.removeFirst();
                                break;
                        }
                        else if ( (col1.getFirst().startsWith("*")) && (col2.getFirst().startsWith("*"))  )     {
                                if ( (col1.getCount() == 1) && (col2.getCount() == 1) &&
                                     (col1.getFirst().endsWith("*")) && (col2.getFirst().endsWith("*"))  )      {
                                        return true;
                                }
                                else
                                        return false;
                        }
                        else if (col1.getFirst().startsWith("*")) {
                                if ((pos1 >= 0) &&
                                        ((pos1 == ((int)str2.Length-(int)str.Length)) ||
                                        ( (pos1 < ((int)str2.Length-(int)str.Length)) && (col1.getFirst().endsWith("*")) ) )) {
                                        col1.removeFirst();
                                        if ( (str = col1.getFirst()).Length == 0)
                                                return true;
                                        str.replace("*", "");
                                        break;
                                }
                                else if (col2.getCount() > 1) {
                                        col2.removeFirst();
                                        break;
                                }
                                else
                                        return false;
                        }
                        else if (col2.getFirst().startsWith("*")) {
                                if ((pos2 >= 0) &&
                                        ((pos2 == ((int)str.Length-(int)str2.Length)) ||
                                        ( (pos2 < ((int)str.Length-(int)str2.Length)) && (col2.getFirst().endsWith("*")) ) )) {
                                        col2.removeFirst();
                                        break;
                                }
                                else if (col1.getCount() > 1) {
                                        if ( (str = col1.getFirst()).Length == 0)
                                                return true;
                                        str.replace("*", "");
                                        break;
                                }
                                else
                                        return false;
                        }
                        else {
                                return false;
                        }
                }

//              printf("Col1: %s\n", (char*) col1.printListLine("|"));
//              printf("Col2: %s\n", (char*) col2.printListLine("|"));

                if (col2.getCount() == 0)
                        return true;
        }

        return true;
}





/*
Collection& JString::split(JString splitstr) {
   Collection* oc = new Collection(split2(splitstr));
   return *oc;
}
*/
int JString::toInt() const {
   return atoi(charpoint());
}

bool JString::toBool() const {
        if ((equalsIgnoreCase("true")) ||
                (equalsIgnoreCase("yes")) )
                return true;
        else
                return false;
}

void* JString::toPointer() const {
        void* ptr = NULL;
        if (sscanf(this->charpoint(), "%p", &ptr) != 1)
                return NULL;
        return ptr;
}

long JString::toLong() const {
   return atol(charpoint());
}

double JString::toDouble() const {
   char *stopstring;
   return (strtod( charpoint(), &stopstring));
}

long long JString::toLongLong() const {
        #if defined(WIN32)
                #if defined(CYGWIN)
                        return atoll( charpoint() );
                #else
                        return _atoi64( charpoint() );
                #endif
        #else
                return atoll( charpoint() );
        #endif
}

unsigned int JString::toUnsignedInt() const {
        return (unsigned int) strtoul(charpoint(),NULL,0);
}

unsigned long JString::toUnsignedLong() const {
        return strtoul(charpoint(),NULL,0);
}

unsigned long long JString::toUnsignedLongLong() const {
        #if defined(WIN32)
                #if defined(CYGWIN)
                        return strtoull(charpoint(),NULL,0);
                #else
                        return _strtoui64(charpoint(), NULL, 0);
                #endif
        #else
                return strtoull(charpoint(),NULL,0);
        #endif
}


















JString JString::operator+( char* aChar )
{
   JString str = *this;
   str += aChar;
   return str;
}

JString JString::operator+(const JString& other ) {
   JString str = *this;
   str += other;
   return str;
}

JString JString::operator+( char* aChar ) const
{
   JString str = *this;
   str += aChar;
   return str;
}

JString JString::operator+(const JString& other ) const {
   JString str = *this;
   str += other;
   return str;
}

JString JString::removeCRs() {
   JString str = *this;
   
   str.replace("\n", "");
   str.replace("\r", "");

   return str;
}

JString JString::removeCRTabs() {
   JString str = *this;
   
   str.replace("\n", "");
   str.replace("\r", "");
   str.replace("\t", "");

   return str;
}

JString JString::replaceCRs() {
   JString str = *this;
   
   str.replace("\n", "*CR*");
   str.replace("\r", "*LF*");

   return str;
}

JString JString::restoreCRs() {
   JString str = *this;
   
   str.replace("*CR*", "\n");
   str.replace("*LF*", "\r");

   return str;
}

#define CHARREPLACE(var,ch,str) case ch: strcat(var, str); break;

JString JString::toHTML() {

        if (Length == 0)
                return "";

        char c;

        const char* input = this->Buffer;
//      char* dest = (char*)malloc(Length*100);
//      dest[0] = 0;
        char* tmp = (char*)malloc(20);
        JString str;
        str.setBufferSizeInline(Length*2);

        while ((c = *input++)) {
                if (c == '\n') {
                        str += "<br>\n";
                }
                else if (c == '\r') {
                }
                else if (c == '\t') {
                        str += "&nbsp;&nbsp;&nbsp;\n";
                }
                else if ( (c < 32) || (c > 122) ||
                        ( (c > 90) && (c < 97) ) ||
                        ( (c > 57) && (c < 65) ) ||
                        ( (c > 33) && (c < 48) ) ) {
                        sprintf(tmp, "&#x%x;", (int) c & 0xFF);
                        str += tmp;
                //      strcat(dest, tmp);
                }
                else {
                        str += c;
                        // dest[strlen(dest)+1] = 0;
                        // dest[strlen(dest)] = c;
                }
        }

//      JString str = dest;
//      free((char*)dest);
        free((char*)tmp);
        
        return str;
}

                                
#define ADDCHAR(var,ch) var[strlen(var)+1] = 0; var[strlen(var)] = ch;

char HTML2Char(char* s) {
        JString str = s;
        if (strcmp(str, "&amp") == 0)
                return '&';
        else if (strcmp(str, "&lt") == 0)
                return '<';
        else if (strcmp(str, "&gt") == 0)
                return '>';
        else if (strcmp(str, "&quot") == 0)
                return '"';
        else if (strcmp(str, "&apos") == 0)
                return '\'';
        else if (strcmp(str, "&lsquo") == 0)
                return '‘';
        else if (strcmp(str, "&rsquo") == 0)
                return '’';
        else if (strcmp(str, "&sbquo") == 0)
                return '‚';
        else if (strcmp(str, "&ldquo") == 0)
                return '“';
        else if (strcmp(str, "&rdquo") == 0)
                return '”';
        else if (strcmp(str, "&bdquo") == 0)
                return '„';
        else if (strcmp(str, "&dagger") == 0)
                return '†';
        else if (strcmp(str, "&Dagger") == 0)
                return '‡';
        else if (strcmp(str, "&permil") == 0)
                return '‰';
        else if (strcmp(str, "&lsaquo") == 0)
                return '‹';
        else if (strcmp(str, "&rsaquo") == 0)
                return '›';
        else if (strcmp(str, "&trade") == 0)
                return '™';
        else
                return 0;
}

char Dec2Char(char* str) {
        return atoi(str);
}

char Hex2Char(char* str) {
        char c1 = toupper(str[0]);
        char c2 = toupper(str[1]);
        unsigned short i1 = 0;
        if (c1 < 48) {
                return 0;
        }
        else {
                i1 = c1-48;
                if (i1 > 9)
                        i1 = c1-55;
        }
        unsigned short i2 = 0;
        if (c2 < 48) {
                return (char)i1;
        }
        else {
                i2 = c2-48;
                if (i2 > 9)
                        i2 = c2-55;
                return (char)(i1*16 + i2);
        }
}

JString JString::fromHTML() {

        if (Length == 0)
                return "";

        char c, ch;

        char* semi;
//      char* src = (char*)malloc(Length+10);
//      strcpy(src, this->charpoint());
        char* input = Buffer;
        //char* dest = (char*)malloc(Length*10);
        //dest[0] = 0;
        JString str;
        str.setBufferSizeInline(Length);

        while ((c = *input++)) {
                switch (c) {
                        case '&':
                                semi = strchr(input, ';');
                                if ( (semi == NULL) || (semi - input > 10) ) {
                                        // printf("### Error in HTML string - not encoded ### \n");
                                        return *this;
                                }
                                semi[0] = 0;
                                if (*input == '#') {
                                        // ch = Dec2Char(input+1);
                                        if (*(input+1) == 'x')
                                                ch = Hex2Char(input+2);
                                        else
                                                ch = Dec2Char(input+1);
                                }
                                else {
                                        ch = HTML2Char(input-1);
                                }
                                // ADDCHAR(dest, ch);
                                str += ch;
                                input = semi+1;
                                semi[0] = ';';
                                break;
                        case '%':
                                ch = Hex2Char(input);
                                // ADDCHAR(dest, ch);
                                str += ch;
                                input+=2;
                                break;
                        case '+':
                                // ADDCHAR(dest, ' ');
                                str += ' ';
                                break;
                        default:
                                // ADDCHAR(dest, c);
                                str += c;
                }
        }

//      JString str = dest;
//      free((char*)dest);
//      free((char*)src);
        str.replace("<br>", "\n");

        return str;
}

JString JString::xmlStringEncode() const {
        if (Length == 0)
                return "";

/*      if (!((strchr(Buffer, '&') != NULL) ||
                (strchr(Buffer, '<') != NULL) ||
                (strchr(Buffer, '>') != NULL) ||
                (strchr(Buffer, '"') != NULL) ||
                (strchr(Buffer, '\'') != NULL) ||
                (strchr(Buffer, '\t') != NULL) ||
                (strchr(Buffer, '\r') != NULL) ||
                (strchr(Buffer, '\n') != NULL) ) )
                return *this;*/

        char c;
        char* input = this->Buffer;
        JString str;
        str.setBufferSizeInline(Length*2);
        char* tmp = NULL;

        while ((c = *input++)) {
                switch(c) {
                        case '&':
                                str += "&amp;";
                                break;
                        case '<':
                                str += "&lt;";
                                break;
                        case '>':
                                str += "&gt;";
                                break;
                        case '"':
                                str += "&quot;";
                                break;
                        case '\'':
                                str += "&apos;";
                                break;
                        default:
                                if ((c < 32) || (c > 126)) {
                                        if (tmp == NULL)
                                                tmp = (char*)malloc(20);
                                        sprintf(tmp, "&#x%x;", (int) c & 0xFF);
                                        str += tmp;
                                }
                                else
                                        str += c;
                                break;
                }
        }
        free((char*)tmp);
        return str;
}

JString JString::xmlStringDecode() const {
        if (Length == 0)
                return "";
        if (strchr(Buffer, '&') == NULL)
                return *this;

        char c, ch;
        char* input = this->Buffer;
        char* semi;
        JString str;
        str.setBufferSizeInline(Length);

        while ((c = *input++)) {
                switch (c) {
                        case '&':
                                semi = strchr(input, ';');
                                if ( (semi == NULL) || (semi - input > 10) ) {
                                        // printf("### Error in HTML string - not encoded ### \n");
                                        return *this;
                                }
                                semi[0] = 0;
                                if (*input == '#') {
                                        if (*(input+1) == 'x')
                                                ch = Hex2Char(input+2);
                                        else
                                                ch = Dec2Char(input+1);
                                }
                                else {
                                        ch = HTML2Char(input-1);
                                }
                                str += ch;
                                input = semi+1;
                                semi[0] = ';';
                                break;
                /*      case '%':
                                ch = Hex2Char(input);
                                str += ch
                                input+=2;
                                break;
                        case '+':
                                ADDCHAR(dest, ' ');
                                break;*/
                        default:
                                str += c;
                }
        }
        return str;
}



int JString::indexOfIgnoreCase( const JString &str ) const {
        return indexOfIgnoreCase(str, 0);
}

int JString::indexOfIgnoreCase( const JString &str, unsigned int fromIndex ) const {
        return (this->toLowerCase().indexOf(str.toLowerCase(), fromIndex));
}

int JString::lastIndexOfIgnoreCase( const JString &str ) const {
        return lastIndexOfIgnoreCase(str, 0);
}

int JString::lastIndexOfIgnoreCase( const JString &str, unsigned int fromIndex ) const {
        return (this->toLowerCase().lastIndexOf(str.toLowerCase(), fromIndex));
}

bool JString::startsWithIgnoreCase( const JString &prefix ) const {
        return startsWithIgnoreCase(prefix.toLowerCase(), 0);
}

bool JString::startsWithIgnoreCase( const JString &prefix, unsigned int toffset ) const {
        return (this->toLowerCase().startsWith(prefix.toLowerCase(), toffset));
}

bool JString::containsIgnoreCase( const JString& str) const {
        return this->toLowerCase().contains(str.toLowerCase());
}

bool JString::endsWithIgnoreCase( const JString &suffix ) const {
        return (this->toLowerCase().endsWith(suffix.toLowerCase()));
}








// Windows Specific Methods
#ifdef WIN32

// #ifdef UNICODE


JString::JString(wchar_t wch) {

        Buffer = NULL;
        Length = BufferLen = 0;
        isCRTerminated = false;
//      adjustBuffer( Length = 0);
        setBufferSizeInline(Length = 1);
        strcpy(Buffer, "");
        #ifdef WIN32
                lpwBuffer = NULL;
        #endif

        wchar_t str[2];
        str[0] = wch;
        str[1] = 0;
        this->operator+=((LPWSTR)str);
}

JString::JString(LPWSTR lstr) {

        Buffer = NULL;
        Length = BufferLen = 0;
        char* buffer = NULL;
        isCRTerminated = false;
        int res = WideCharToMultiByte(CP_ACP, 0, lstr, -1, NULL, 0, NULL, NULL);

        if (res > 0) {
                buffer = (char*)malloc(res+10);
                res = WideCharToMultiByte(CP_ACP, 0, lstr, -1, buffer, res+10, NULL, NULL);
        }

        if ((res > 0) && (buffer != NULL)) {
        //      adjustBuffer( Length = (unsigned int)strlen(buffer));
                setBufferSizeInline(Length = (unsigned int) strlen(buffer));
                strcpy(Buffer, buffer);
        }
        else {
        //      adjustBuffer( Length = 1);
                setBufferSizeInline(Length = 1);
                strcpy(Buffer, "");
        }

        free((char*)buffer);
        #ifdef WIN32
          lpwBuffer = NULL;
        #endif
}

bool JString::toUnicode() {
        if (lpwBuffer != NULL)
                free((char*)lpwBuffer);
        lpwBuffer = (WCHAR*)malloc((Length+1)*sizeof(WCHAR));
        return (MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, Buffer, -1, lpwBuffer, Length+1) != 0);
}

JString::operator LPWSTR() {
        if (lpwBuffer == NULL)
                toUnicode();
        return lpwBuffer;
}

JString JString::operator+(LPWSTR wstr) {
        JString str = JString(wstr);
        return (*this) + str;
}

const JString& JString::operator+=(LPWSTR wstr) {
        JString other = JString(wstr);
        setBufferSizeInline(Length + other.Length);
        memcpy(Buffer+Length, other.Buffer, other.Length);
        Length += other.Length;
        Buffer[Length] = 0;
        return *this;
}

JString JString::operator+(wchar_t wch) {
   JString str = *this;
   str += wch;
   return str;
}

const JString& JString::operator+=(wchar_t wch) {
        wchar_t str[2];
        str[0] = wch;
        str[1] = 0;
        return this->operator+=((LPWSTR)str);
}


// #endif // UNICODE






JString::operator const unsigned short*() {
   toUnicode();
   return (const unsigned short *) lpwBuffer;
}

/*
LPTSTR JString::lptstr() {
   toUnicode();
   return lpwBuffer;
}
*/


bool JString::utf2unicode() {
        // Buffer contains UTF-8, needs to be converted to WCHAR

        if (lpwBuffer != NULL)
                free((char*)lpwBuffer);
        int len = MultiByteToWideChar(CP_UTF8, 0, Buffer, -1, NULL, 0);

        lpwBuffer = (WCHAR*)malloc((len+1)*sizeof(WCHAR));
        int res = MultiByteToWideChar(CP_UTF8, 0, Buffer, -1, lpwBuffer, len+1);
/*      if (res == 0) {
                int err = GetLastError();
                if (err == ERROR_INSUFFICIENT_BUFFER) {
                        err = err;
                }
                else if (err == ERROR_INVALID_FLAGS) {
                        err = err;
                }
                else if (err == ERROR_INVALID_PARAMETER) {
                        err = err;
                }
                else if (err == ERROR_NO_UNICODE_TRANSLATION) {
                        err = err;
                }
        }*/
        return (res != 0);

/*      int outputlen=0;
        for (int i=0 ; i < Length; ) {
                // if overflow detected
                if (outputlen >= Length)
                        break;

                if ( 0xc0 <= Src[i] ) {
                        lpwBuffer[outputlen++] = (WCHAR) ((Src[i] & ~0xc0) << 6 | (Src[i+1] & ~0x80));
                        i+=2;
                }
                else if ( 0xe0 <= Src[i] ) {
                        lpwBuffer[outputlen++] =(WCHAR) (Src[i] << 12 | (Src[i+1] & 0x3f) << 6 | Src[i+2] & 0x3f);
                        i+=3;
                }
                else {
                        lpwBuffer[outputlen++] = (WCHAR) Src[i];
                        ++i;
                }
        }

        lpwBuffer[outputlen] = '\0';
        return true;*/
}

bool JString::unicode2utf() {
        char* buffer = NULL;
        isCRTerminated = false;
        int res = WideCharToMultiByte(CP_UTF8, 0, lpwBuffer, -1, NULL, 0, NULL, NULL);

        if (res > 0) {
                buffer = (char*)malloc(res+10);
                res = WideCharToMultiByte(CP_UTF8, 0, lpwBuffer, -1, buffer, res+10, NULL, NULL);
        }

        if ((res > 0) && (buffer != NULL)) {
        //      adjustBuffer( Length = (unsigned int)strlen(buffer));
                setBufferSizeInline(Length = (unsigned int) strlen(buffer));
                strcpy(Buffer, buffer);
                free((char*)buffer);
        }
        else {
        //      adjustBuffer( Length = 1);
                setBufferSizeInline(Length = 1);
                strcpy(Buffer, "");
                free((char*)buffer);
                return false;
        }
        return true;
}
/*
int UTF8ToUnicode(const unsigned char *Src, int SrcLen, WCHAR *Dest, int DestLen) {
        int i=0;
        int outputlen=0;

        for (i=0 ; i < SrcLen; ) {
                if (outputlen >= DestLen) {
                        //overflow detected
                        break;
                }

                if ( 0xc0 <= Src[i] ) {
                        Dest[outputlen++] = (WCHAR) ((Src[i] & ~0xc0) << 6 | (Src[i+1] & ~0x80));
                        i+=2;
                }
                else if ( 0xe0 <= Src[i] ) {
                        Dest[outputlen++] =(WCHAR) (Src[i] << 12 | (Src[i+1] & 0x3f) << 6 | Src[i+2] & 0x3f);
                        i+=3;
                }
                else {
                        Dest[outputlen++] = (WCHAR) Src[i];
                        ++i;
                }
        }

        Dest[outputlen] = '\0';
        return outputlen;
}
*/

#endif // WIN32







JString JString::scriptGetSection(const JString& tagname) {
        JString startTag = JString::format("<!-- start:%s ", (char*) tagname.trim());
        JString endTag = JString::format("<!-- end:%s ", (char*) tagname.trim());

        int startPos = indexOf(startTag);
        if (startPos < 0) return "";
        int startEndPos = indexOf("-->", startPos);
        if (startEndPos < 0) return "";

        int endPos = indexOf(endTag, startEndPos);
        if (endPos < 0) return "";
        int endEndPos = indexOf("-->", endPos);
        if (endEndPos < 0) return "";

        return substring(startEndPos + 3, endPos);
}

Dictionary JString::scriptGetSectionParameters(const JString& tagname) {
        Dictionary ownParams;
        JString startTag = JString::format("<!-- start:%s ", (char*) tagname.trim());
        JString endTag = JString::format("<!-- end:%s ", (char*) tagname.trim());

        int startPos = indexOf(startTag);
        if (startPos < 0) return ownParams;
        int startEndPos = indexOf("-->", startPos);
        if (startEndPos < 0) return ownParams;

        int endPos = indexOf(endTag, startEndPos);
        if (endPos < 0) return ownParams;
        int endEndPos = indexOf("-->", endPos);
        if (endEndPos < 0) return ownParams;

        JString paramString = substring(startPos + startTag.Length, startEndPos).trim();
        JString param;
        Collection col = paramString.splitOnWhiteSpaces();
        Collection pcol;
        for (int n=0; n<col.getCount(); n++) {
                param = col.get(n);
                if ( param.contains("=") ) {
                        pcol = param.split("=");
                        param = pcol.get(1).trim();
                        param.replace("\"", "");
                        ownParams.put(pcol.get(0).trim(), param);
                }
        }
        return ownParams;
}

bool JString::scriptReplaceSection(const JString& tagname, const JString& text) {
        JString startTag = JString::format("<!-- start:%s ", (char*) tagname.trim());
        JString endTag = JString::format("<!-- end:%s ", (char*) tagname.trim());

        int startPos = indexOf(startTag);
        if (startPos < 0) return false;
        int startEndPos = indexOf("-->", startPos);
        if (startEndPos < 0) return false;

        int endPos = indexOf(endTag, startEndPos);
        if (endPos < 0) return false;
        int endEndPos = indexOf("-->", endPos);
        if (endEndPos < 0) return false;

        replace(startPos, endEndPos+3, text);
        return true;
}


int
JString::scriptReplace(const JString& tagname, ObjectCollection* replacements) {

        int n;

        JString startTag = JString::format("<!-- start:%s ", (char*) tagname.trim());
        JString endTag = JString::format("<!-- end:%s ", (char*) tagname.trim());

        int startPos = indexOf(startTag);
        if (startPos < 0) return 0;
        int startEndPos = indexOf("-->", startPos);
        if (startEndPos < 0) return 0;

        int endPos = indexOf(endTag, startEndPos);
        if (endPos < 0) return 0;
        int endEndPos = indexOf("-->", endPos);
        if (endEndPos < 0) return 0;

        JString newString = "";
        if ( (replacements == NULL) || (replacements->getCount() == 0) ) {
                this->replace(startPos, endEndPos+3, newString);
                return 0;
        }

        // Dont use trim()
        // JString mainString = substring(startEndPos + 3, endPos).trim();
        JString mainString = substring(startEndPos + 3, endPos);

        Dictionary ownParams = Dictionary();
        JString paramString = substring(startPos + startTag.Length, startEndPos).trim();
        JString param;
        Collection col = paramString.splitOnWhiteSpaces();
        Collection pcol;
        for (n=0; n<col.getCount(); n++) {
                param = col.get(n);
                if ( param.contains("=") ) {
                        pcol = param.split("=");
                        param = pcol.get(1).trim();
                        param.replace("\"", "");
                        ownParams.put(pcol.get(0).trim(), param);
                }
        }

        JString debugString = ownParams.printListLine("|");

        int c, pos, count=0;
        JString mainStringCopy, replace;
        Collection* lines;
        for (n=0; n<replacements->getCount(); n++) {
                mainStringCopy = mainString;
                if ( (lines = (Collection*) replacements->get(n)) != NULL ) {
                        for (c=99; c>0; c--) {
                                replace = lines->get(c-1);
                                if (replace.equalsIgnoreCase("%default")) {
                                        replace = ownParams.get(JString(c));
                                        if (replace.contains(";")) {
                                                col = replace.split(";");
                                                pos = count%(col.getCount());
                                                replace = col.get(pos);
                                        }
                                }
                                mainStringCopy.replace(JString::format("%%%d", c), replace);
                        }
                        count++;
                        newString += mainStringCopy;
                }
        }

        this->replace(startPos, endEndPos+3, newString);
        return count;
}




int
JString::scriptReplaceDictionary(const JString& tagname, ObjectCollection* replacements) {

        int n;

        JString startTag = JString::format("<!-- start:%s ", (char*) tagname.trim());
        JString endTag = JString::format("<!-- end:%s ", (char*) tagname.trim());

        int startPos = indexOf(startTag);
        if (startPos < 0) return 0;
        int startEndPos = indexOf("-->", startPos);
        if (startEndPos < 0) return 0;

        int endPos = indexOf(endTag, startEndPos);
        if (endPos < 0) return 0;
        int endEndPos = indexOf("-->", endPos);
        if (endEndPos < 0) return 0;

        // Dont use trim()
        // JString mainString = substring(startEndPos + 3, endPos).trim();
        JString mainString = substring(startEndPos + 3, endPos);
        JString newString = "";

        Dictionary ownParams = Dictionary();
        JString paramString = substring(startPos + startTag.Length, startEndPos).trim();
        JString param;
        Collection col = paramString.splitOnWhiteSpaces();
        Collection pcol;
        for (n=0; n<col.getCount(); n++) {
                param = col.get(n);
                if ( param.contains("=") ) {
                        pcol = param.split("=");
                        param = pcol.get(1).trim();
                        param.replace("\"", "");
                        ownParams.put(pcol.get(0).trim(), param);
                }
        }

        JString debugString = ownParams.printListLine("|");

        int pos, count=0;
        JString mainStringCopy, replace;
        Dictionary* lines;
        JString key;
        for (n=0; n<replacements->getCount(); n++) {
                mainStringCopy = mainString;
                if ( (lines = (Dictionary*) replacements->get(n)) != NULL ) {
                        for (key=lines->getFirstKey(); key.length() > 0; key=lines->getNextKey()) {
                                replace = lines->get(key);
                                if (replace.equalsIgnoreCase("%default")) {
                                        replace = ownParams.get(key);
                                        if (replace.contains(";")) {
                                                col = replace.split(";");
                                                pos = count%(col.getCount());
                                                replace = col.get(pos);
                                        }
                                }
                                mainStringCopy.replace(JString::format("%%%s", (char*)key), replace);
                        }
                        count++;
                        newString += mainStringCopy;
                }
        }

        this->replace(startPos, endEndPos+3, newString);
        return count;
}




JString JString::bytifySize(long val) {
        return bytifySize((double)val);
}

JString JString::bytifySize(double val) {
        
        double kb = 1024;
        double mb = kb*1024;
        double gb = mb*1024;
        double tb = gb*1024;

        if (val < 512)
                return JString::format("%.2f B", val);
        else if (val < 512*kb) {
                val = val / kb;
                return JString::format("%.2f KB", val);
        }
        else if (val < 512*mb) {
                val = val / mb;
                return JString::format("%.2f MB", val);
        }
        else if (val < 512*gb) {
                val = val / gb;
                return JString::format("%.2f GB", val);
        }
        else {
                val = val / tb;
                return JString::format("%.2f TB", val);
        }
}

JString JString::bytifySizes(long val1, long val2) {
        return bytifySizes((double)val1, (double) val2);
}

JString JString::bytifySizes(double val1, double val2) {
        
        double kb = 1024;
        double mb = kb*1024;
        double gb = mb*1024;
        double tb = gb*1024;

        JString end;
        double val;
        double maximum = ((val1 > val2) ? val1 : val2);

        if (maximum < 512) {
                val = 1;
                end = "B";
        }
        else if (maximum < 512*kb) {
                val = kb;
                end = "KB";
        }
        else if (maximum < 512*mb) {
                val = mb;
                end = "MB";
        }
        else if (maximum < 512*gb) {
                val = gb;
                end = "GB";
        }
        else {
                val = gb;
                end = "TB";
        }
        return JString::format("%.2f / %.2f %s", ((double)val1)/val, ((double)val2)/val, (char*) end);
}

JString JString::bytifyRate(long val) {
        return bytifyRate((double)val);
}

JString JString::bytifyRate(double val) {
        return JString::format("%s/sec", (char*) bytifySize(val));
}

JString JString::bytifyRates(long val1, long val2) {
        return bytifyRates((double)val1, (double)val2);
}

JString JString::bytifyRates(double val1, double val2) {
        return JString::format("%s/sec", (char*) bytifySizes(val1, val2));
}


JString JString::xml2html() const {

        JString html;
        if (Length == 0)
                return html;

        XMLParser parser;
        parser.parseComments = true;
        if (!parser.parseXML(*this))
                return html;

        XMLNode* rootnode = parser.getRootNode();
        if (rootnode == NULL)
                return html;

        html = rootnode->toHTML();
        return html;
}



bool JString::setBufferSize(unsigned int size) {
        return setBufferSizeInline(size);
}

inline bool
JString::doubleBufferInline() {
        return setBufferSizeInline(BufferLen * 2);
}

inline bool
JString::setBufferSizeInline(unsigned int size) {
        if ((BufferLen >= size) && (Buffer != NULL) && (BufferLen > 0))
                return true;

        char* newBuffer = (char*)realloc(Buffer, size+1);
        if (newBuffer == NULL)
                return false;

//      char* oldBuffer = Buffer;
//      if (Length == 0)
//              memcpy(newBuffer, oldBuffer, Length+1);
//      free(oldBuffer);

        Buffer = newBuffer;
        BufferLen = size;

        return true;
}



/*
inline void
JString::adjustBuffer(unsigned int MaxStrLen)
{
        BufferLen = MaxStrLen;
        Buffer = (char*)malloc(BufferLen + 1); 
        if (Buffer == NULL)
                Buffer = (char*)malloc(1);
}


inline void
JString::ResizeBuffer(unsigned int MaxStrLen)
{
        if (BufferLen >= MaxStrLen)
                return;
        MaxStrLen *= 2;
        char* newBuffer = (char*)malloc(MaxStrLen+1);
        memcpy(newBuffer, Buffer, BufferLen+1);
        char* oldBuffer = Buffer;
        Buffer = newBuffer;
        BufferLen = MaxStrLen;
        free(oldBuffer);
        if (Buffer == NULL)
                Buffer = (char*)malloc(1); 
}
*/









































char *cGREP_errors[] = {
        "Invalid argument",
        "Insufficient expression",
        "Parse overload",
        "Mismatched () or []",
        "Extraneous characters",
        "Illegal use of * or +",
        "Illegal nesting",
        "Illegal [] range",
        "Illegal ?, +, or * usage",
        "Illegal backslashes",
        NULL};

// The single constructor requires a UNIX regular
// expression.  It is ok to pass a constant.
RegExpParser::RegExpParser( char *exp ) {
    Special_chars = "^$.[()|?+*\\";
    an_error_has_occured = 0;
    strcpy( error_string, "" );
    if( exp == NULL ) {
        record_error( 0 );
        return;
    }
    Input_scan_pointer = exp;
    parentheses_count = 1;
    symbol_string_size = 0L;
    code_emit_pointer = &reg_exp_shadow;
        char sigval = (char) SIGNATURE_VALUE;
        emit_next_byte(sigval);
    int flags;
    if( parse_parens( 0, &flags ) == NULL ) {
        record_error( 1 );
        return;
    }
    Input_scan_pointer = exp;
    parentheses_count = 1;
    code_emit_pointer = symbol_string;
    emit_next_byte(sigval);
    if( parse_parens( 0, &flags ) == NULL ) {
        record_error( 1 );
        return;
    }
    first_char_of_regexp = CHAR_ZERO;
    is_anchored = 0;
    required_substring = NULL;
    length_required_substring = 0;
    char *scan = symbol_string + 1;
    if( MAK_CHAR_2_OPCODE( get_next_pointer( scan ) ) == OP_END ) {
        scan = MAK_CONTROLLING_OPERAND( scan );
        if( MAK_CHAR_2_OPCODE( scan ) == OP_EXACT )
            first_char_of_regexp = *MAK_CONTROLLING_OPERAND( scan );
        else if( MAK_CHAR_2_OPCODE( scan ) == OP_BOL )
            is_anchored++;
        if( flags & BIT_OPENS_ON_STAR_OR_PLUS ) {
            char *longest = NULL;
            unsigned int len = 0;
            for( ; scan != NULL; scan = get_next_pointer( scan ) )
                    if( MAK_CHAR_2_OPCODE( scan ) == OP_EXACT && strlen( MAK_CONTROLLING_OPERAND( scan ) ) >= len ) {
                        longest = MAK_CONTROLLING_OPERAND( scan );
                        len = (unsigned int)strlen( MAK_CONTROLLING_OPERAND( scan ) );
                    }
            required_substring = longest;
            length_required_substring = len;
        }
    }
}


//  This method returns 1 if the regular expression
//  was matched.  Otherwise it returns 0.
int RegExpParser::is_reg_exp_present( char *string ) {
    char *s;
    if( string == NULL ) {
        record_error( 0 );
        return( 0 );
    }
    if( MAK_AS_UNSIGNED( symbol_string ) != SIGNATURE_VALUE ) {
        record_error( 2 );
        return( 0 );
    }
    if( required_substring != NULL ) {
        s = string;
        while( ( s = strchr( s, required_substring[ 0 ] ) ) != NULL ) {
                if( strncmp( s, required_substring, length_required_substring ) == 0 )
                    break;
                s++;
        }
        if( s == NULL )
            return( 0 );
    }
    beginning_of_input = string;
    if( is_anchored )
        return( evaluate_next( string ) );
    s = string;
    if( first_char_of_regexp != CHAR_ZERO )
        while( ( s = strchr( s, first_char_of_regexp ) ) != NULL ) {
                if( evaluate_next( s ) )
                    return( 1 );
                s++;
        }
    else do {
        if( evaluate_next( s ) )
            return( 1 );
    } while( *s++ != CHAR_ZERO );
    return( 0 );
}


void RegExpParser::record_error( int n ) {
    strcpy( error_string, cGREP_errors[ n ] );
    ++an_error_has_occured;
}


char* RegExpParser::parse_parens( int paren, int *flagp ) {
    *flagp = BIT_MORE_THAN_NULL;
    char *ret = NULL;
    int parno = 0;
    if( paren ) {
        if( parentheses_count >= MAX_SUB_EXPRESSIONS ) {
            record_error( 3 );
            return( NULL );
        }
        parno = parentheses_count;
        parentheses_count++;
        ret = emit_node( OP_OPEN + parno );
    } else
        ret = NULL;
    int flags;
    char *br = one_side_of_or_operator( &flags );
    if( br == NULL )
        return( NULL );
    if( ret != NULL )
        go_to_end_of_chain( ret, br );
    else
        ret = br;
    if( !( flags & BIT_MORE_THAN_NULL ) )
        *flagp &= ~BIT_MORE_THAN_NULL;
    *flagp |= flags & BIT_OPENS_ON_STAR_OR_PLUS;
    while( *Input_scan_pointer == CHAR_OR ) {
            Input_scan_pointer++;
            br = one_side_of_or_operator( &flags );
            if( br == NULL )
                return( NULL );
            go_to_end_of_chain( ret, br );
            if( !( flags&BIT_MORE_THAN_NULL ) )
                *flagp &= ~BIT_MORE_THAN_NULL;
                *flagp |= flags & BIT_OPENS_ON_STAR_OR_PLUS;
    }
    char *ender = emit_node( ( paren ) ? OP_CLOSE + parno : OP_END );
    go_to_end_of_chain( ret, ender );
    for( br = ret; br != NULL; br = get_next_pointer( br ) )
            go_to_end_of_chain_on_operand( br, ender );
    if( paren && *Input_scan_pointer++ != CHAR_CLOSE_PAREN ) {
        record_error( 3 );
        return( NULL );
    } else if( !paren && *Input_scan_pointer != CHAR_ZERO ) {
        if( *Input_scan_pointer == CHAR_CLOSE_PAREN ) {
            record_error( 3 );
            return( NULL );
        } else
            record_error( 4 );
            return( NULL );
    }
    return( ret );
}


char* RegExpParser::one_side_of_or_operator( int *flagp ) {
    int flags = 0;
    char *ret = NULL;
    *flagp = BIT_CAN_MATCH_NOTHING;
    ret = emit_node( OP_BRANCH );
    char *chain = NULL;
    char *latest = NULL;
    while( *Input_scan_pointer != CHAR_ZERO && *Input_scan_pointer != CHAR_OR && *Input_scan_pointer != CHAR_CLOSE_PAREN ) {
            latest = trailing_wild( &flags );
            if( latest == NULL )
                return( NULL );
            *flagp |= flags & BIT_MORE_THAN_NULL;
            if( chain == NULL ) /* First piece. */
                *flagp |= flags & BIT_OPENS_ON_STAR_OR_PLUS;
            else
                go_to_end_of_chain( chain, latest );
            chain = latest;
    }
    if( chain == NULL ) /* Loop ran zero times. */
        (void) emit_node( OP_NMEMPTY );
    return( ret );
}



char* RegExpParser::trailing_wild( int *flagp ) {
    int flags = 0;
    char *ret = compress_ordinary_characters( &flags );
    char *next = NULL;
    if( ret == NULL )
        return( NULL );
    char op = *Input_scan_pointer;
    if( !MAK_IS_COMPOUND( op ) ) {
        *flagp = flags;
        return( ret );
    }
    if( !( flags & BIT_MORE_THAN_NULL ) && op != CHAR_QUESTION ) {
        record_error( 5 );
        return( NULL );
    }
    *flagp =( op != CHAR_PLUS ) ?( BIT_CAN_MATCH_NOTHING | BIT_OPENS_ON_STAR_OR_PLUS ) :
                                    ( BIT_CAN_MATCH_NOTHING | BIT_MORE_THAN_NULL );
    if( op == CHAR_STAR &&( flags & BIT_STAR_OR_PLUS_OK ) )
        insert_operator( OP_STAR, ret );
    else if( op == CHAR_STAR ) {
        insert_operator( OP_BRANCH, ret );
        go_to_end_of_chain_on_operand( ret, emit_node( OP_BACK ) );
        go_to_end_of_chain_on_operand( ret, ret );
        go_to_end_of_chain( ret, emit_node( OP_BRANCH ) );
        go_to_end_of_chain( ret, emit_node( OP_NMEMPTY ) );
    } else if( op == CHAR_PLUS &&( flags&BIT_STAR_OR_PLUS_OK ) )
        insert_operator( OP_PLUS, ret );
    else if( op == CHAR_PLUS ) {
        next = emit_node( OP_BRANCH );
        go_to_end_of_chain( ret, next );
        go_to_end_of_chain( emit_node( OP_BACK ), ret );
        go_to_end_of_chain( next, emit_node( OP_BRANCH ) );
        go_to_end_of_chain( ret, emit_node( OP_NMEMPTY ) );
    } else if( op == CHAR_QUESTION ) {
        insert_operator( OP_BRANCH, ret );
        go_to_end_of_chain( ret, emit_node( OP_BRANCH ) );
        next = emit_node( OP_NMEMPTY );
        go_to_end_of_chain( ret, next );
        go_to_end_of_chain_on_operand( ret, next );
    }
    Input_scan_pointer++;
    if( MAK_IS_COMPOUND( *Input_scan_pointer ) ) {
        record_error( 6 );
        return( NULL );
    }
    return( ret );
}


char* RegExpParser::compress_ordinary_characters( int *flagp ) {
    char *ret = NULL;
    int flags = 0;
    *flagp = BIT_CAN_MATCH_NOTHING;
    switch( *Input_scan_pointer++ ) {
            case CHAR_HOCH:
                ret = emit_node( OP_BOL );
                break;
            case CHAR_DOLLAR:
                ret = emit_node( OP_EOL );
                break;
            case CHAR_PERIOD:
                ret = emit_node( OP_ANY );
                *flagp |= BIT_MORE_THAN_NULL | BIT_STAR_OR_PLUS_OK;
                break;
            case CHAR_OPEN_BRACKET: {
                int gjv_reg_class;
                int classend;
                if( *Input_scan_pointer == CHAR_HOCH ) {
                    ret = emit_node( OP_ANYBUT );
                    Input_scan_pointer++;
                } else
                    ret = emit_node( OP_ANYOF );
                if( *Input_scan_pointer == CHAR_CLOSE_BRACKET || *Input_scan_pointer == CHAR_MINUS )
                    emit_next_byte( *Input_scan_pointer++ );
                while( *Input_scan_pointer != CHAR_ZERO && *Input_scan_pointer != CHAR_CLOSE_BRACKET ) {
                        if( *Input_scan_pointer == CHAR_MINUS ) {
                            Input_scan_pointer++;
                            if( *Input_scan_pointer == CHAR_CLOSE_BRACKET || *Input_scan_pointer == CHAR_ZERO )
                                emit_next_byte( CHAR_MINUS );
                            else {
                                gjv_reg_class = MAK_AS_UNSIGNED( Input_scan_pointer - 2 ) + 1;
                                classend = MAK_AS_UNSIGNED( Input_scan_pointer );
                                if( gjv_reg_class > classend + 1 ) {
                                    record_error( 7 );
                                    return( NULL );
                                }
                                for( ; gjv_reg_class <= classend; gjv_reg_class++ )
                                    emit_next_byte( gjv_reg_class );
                                Input_scan_pointer++;
                            }
                        } else
                            emit_next_byte( *Input_scan_pointer++ );
                }
                emit_next_byte( CHAR_ZERO );
                if( *Input_scan_pointer != CHAR_CLOSE_BRACKET ) {
                    record_error( 3 );
                    return( NULL );
                }
                Input_scan_pointer++;
                *flagp |= BIT_MORE_THAN_NULL | BIT_STAR_OR_PLUS_OK; }
                break;
            case CHAR_OPEN_PAREN:
                ret = parse_parens( 1, &flags );
                if( ret == NULL )
                    return( NULL );
                *flagp |= flags & ( BIT_MORE_THAN_NULL | BIT_OPENS_ON_STAR_OR_PLUS );
                break;
            case CHAR_ZERO:
            case CHAR_OR:
            case CHAR_CLOSE_PAREN:
                record_error( 2 );
                return( NULL );
            case CHAR_QUESTION:
            case CHAR_PLUS:
            case CHAR_STAR:
                record_error( 8 );
                return( NULL );
            case CHAR_DOUBLE_BSLASH:
                if( *Input_scan_pointer == CHAR_ZERO ) {
                    record_error( 9 );
                    return( NULL );
                }
                ret = emit_node( OP_EXACT );
                emit_next_byte( *Input_scan_pointer++ );
                emit_next_byte( CHAR_ZERO );
                *flagp |= BIT_MORE_THAN_NULL | BIT_STAR_OR_PLUS_OK;
                break;
            default: {
                int len;
                char ender;
                Input_scan_pointer--;
                len = (int)strcspn( Input_scan_pointer, Special_chars );
                if( len <= 0 ) {
                    record_error( 2 );
                    return( NULL );
                }
                ender = *( Input_scan_pointer+len );
                if( len > 1 && MAK_IS_COMPOUND( ender ) )
                    len--;
                *flagp |= BIT_MORE_THAN_NULL;
                if( len == 1 )
                    *flagp |= BIT_STAR_OR_PLUS_OK;
                ret = emit_node( OP_EXACT );
                while( len > 0 ) {
                        emit_next_byte( *Input_scan_pointer++ );
                        len--;
                }
                emit_next_byte( CHAR_ZERO ); }
                break;
    }
    return( ret );
}


char* RegExpParser::emit_node( char op ) {
    char *ret = code_emit_pointer;
    if( ret == &reg_exp_shadow ) {
        symbol_string_size += 3;
        return( ret );
    }
    char *ptr = ret;
    *ptr++ = op;
    *ptr++ = CHAR_ZERO;
    *ptr++ = CHAR_ZERO;
    code_emit_pointer = ptr;
    return( ret );
}


void RegExpParser::emit_next_byte( char b ) {
    if( code_emit_pointer != &reg_exp_shadow )
        *code_emit_pointer++ = b;
    else
        symbol_string_size++;
}


void RegExpParser::insert_operator( char op, char *opnd ) {
    if( code_emit_pointer == &reg_exp_shadow ) {
        symbol_string_size += 3;
        return;
    }
    char *src = code_emit_pointer;
    code_emit_pointer += 3;
    char *dst = code_emit_pointer;
    while( src > opnd )
            *--dst = *--src;
    char *place = opnd;
    *place++ = op;
    *place++ = CHAR_ZERO;
    *place++ = CHAR_ZERO;
}


void RegExpParser::go_to_end_of_chain( char *p, char *val ) {
    int offset = 0;
    if( p == &reg_exp_shadow )
        return;
    char *scan = p;
    for( ;; ) {
            char *temp = get_next_pointer( scan );
            if( temp == NULL )
                break;
            scan = temp;
    }
    if( MAK_CHAR_2_OPCODE( scan ) == OP_BACK )
        offset = (int)(scan - val);
    else
        offset = (int)(val - scan);
    *( scan + 1 ) = ( offset >> 8 ) & 0xFF;
    *( scan + 2 ) = offset & 0xFF;
}


void RegExpParser::go_to_end_of_chain_on_operand( char *p, char *val ) {
    if( p == NULL || p == &reg_exp_shadow || MAK_CHAR_2_OPCODE( p ) != OP_BRANCH )
        return;
    go_to_end_of_chain( MAK_CONTROLLING_OPERAND( p ), val );
}


int RegExpParser::lookup_engine( char *prog ) {
    char *scan = prog;
    char *next = NULL;
    while( scan != NULL ) {
            next = get_next_pointer( scan );
            switch( MAK_CHAR_2_OPCODE( scan ) ) {
                    case OP_BOL:
                        if( input_string_pointer != beginning_of_input )
                            return( 0 );
                        break;
                    case OP_EOL:
                        if( *input_string_pointer != CHAR_ZERO )
                            return( 0 );
                        break;
                    case OP_ANY:
                        if( *input_string_pointer == CHAR_ZERO )
                            return( 0 );
                        input_string_pointer++;
                        break;
                    case OP_EXACT: {
                        int len;
                        char *opnd;
                        opnd = MAK_CONTROLLING_OPERAND( scan );
                        if( *opnd != *input_string_pointer )
                            return( 0 );
                        len = (int)strlen( opnd );
                        if( len > 1 && strncmp( opnd, input_string_pointer, len ) != 0 )
                            return( 0 );
                        input_string_pointer += len;}
                        break;
                    case OP_ANYOF:
                        if( *input_string_pointer == CHAR_ZERO || strchr( MAK_CONTROLLING_OPERAND( scan ), *input_string_pointer ) == NULL )
                            return( 0 );
                        input_string_pointer++;
                        break;
                    case OP_ANYBUT:
                        if( *input_string_pointer == CHAR_ZERO || strchr( MAK_CONTROLLING_OPERAND( scan ), *input_string_pointer ) != NULL )
                            return( 0 );
                        input_string_pointer++;
                        break;
                    case OP_NMEMPTY:
                        break;
                    case OP_BACK:
                        break;
                    case OP_OPEN + 1:
                    case OP_OPEN + 2:
                    case OP_OPEN + 3:
                    case OP_OPEN + 4:
                    case OP_OPEN + 5:
                    case OP_OPEN + 6:
                    case OP_OPEN + 7:
                    case OP_OPEN + 8:
                    case OP_OPEN + 9: {
                        int no;
                        char *save;
                        no = MAK_CHAR_2_OPCODE( scan ) - OP_OPEN;
                        save = input_string_pointer;
                        if( lookup_engine( next ) ) {
                            if( pointer_to_rembh[ no ] == NULL )
                                pointer_to_rembh[ no ] = save;
                            return( 1 );
                        } else
                            return( 0 );}
                        break;
                    case OP_CLOSE + 1:
                    case OP_CLOSE + 2:
                    case OP_CLOSE + 3:
                    case OP_CLOSE + 4:
                    case OP_CLOSE + 5:
                    case OP_CLOSE + 6:
                    case OP_CLOSE + 7:
                    case OP_CLOSE + 8:
                    case OP_CLOSE + 9: {
                        int no;
                        char *save;
                        no = MAK_CHAR_2_OPCODE( scan ) - OP_CLOSE;
                        save = input_string_pointer;
                        if( lookup_engine( next ) ) {
                            if( pointer_to_remeh[ no ] == NULL )
                                pointer_to_remeh[ no ] = save;
                            return( 1 );
                        } else
                            return( 0 ); }
                        break;
                    case OP_BRANCH: {
                        char *save;
                        if( MAK_CHAR_2_OPCODE( next ) != OP_BRANCH )
                            next = MAK_CONTROLLING_OPERAND( scan );
                        else {
                            do {
                                save = input_string_pointer;
                                if( lookup_engine( MAK_CONTROLLING_OPERAND( scan ) ) )
                                    return( 1 );
                                input_string_pointer = save;
                                scan = get_next_pointer( scan );
                            } while( scan != NULL && MAK_CHAR_2_OPCODE( scan ) == OP_BRANCH );
                            return( 0 );
                        }}
                        break;
                    case OP_STAR:
                    case OP_PLUS: {
                        char nextch;
                        int no;
                        char *save;
                        int min;
                        nextch = CHAR_ZERO;
                        if( MAK_CHAR_2_OPCODE( next ) == OP_EXACT )
                            nextch = *MAK_CONTROLLING_OPERAND( next );
                        min = ( MAK_CHAR_2_OPCODE( scan ) == OP_STAR ) ? 0 : 1;
                        save = input_string_pointer;
                        no = wildcard_lookup( MAK_CONTROLLING_OPERAND( scan ) );
                        while( no >= min ) {
                                if( nextch == CHAR_ZERO || *input_string_pointer == nextch )
                                    if( lookup_engine( next ) )
                                        return( 1 );
                                no--;
                                input_string_pointer = save + no;
                        }
                        return( 0 );}
                        break;
                    case OP_END:
                        return( 1 );
                    default:
                        record_error( 2 );
                        return( 0 );
            }
            scan = next;
    }
    record_error( 2 );
    return( 0 );
}

        
int RegExpParser::wildcard_lookup( char *p ) {
    int count = 0;
    char *scan = input_string_pointer;
    char *opnd = MAK_CONTROLLING_OPERAND( p );
    switch( MAK_CHAR_2_OPCODE( p ) ) {
            case OP_ANY:
                    count = (int)strlen( scan );
                    scan += count;
                    break;
            case OP_EXACT:
                    while( *opnd == *scan ) {
                        count++;
                        scan++;
                    }
                    break;
            case OP_ANYOF:
                    while( *scan != CHAR_ZERO && strchr( opnd, *scan ) != NULL ) {
                        count++;
                        scan++;
                    }
                    break;
            case OP_ANYBUT:
                    while( *scan != CHAR_ZERO && strchr( opnd, *scan ) == NULL ) {
                        count++;
                        scan++;
                    }
                    break;
            default:
                    record_error( 2 );
                    count = 0;
                    return( 0 );
    }
    input_string_pointer = scan;
    return( count );
}


char* RegExpParser::get_next_pointer( char *p ) {
    if( p == &reg_exp_shadow )
        return( NULL );
    int offset = MAK_GET_NEXT( p );
    if( offset == 0 )
        return( NULL );
    if( MAK_CHAR_2_OPCODE( p ) == OP_BACK )
        return( p - offset );
    else
        return( p + offset );
}


int RegExpParser::evaluate_next( char *string ) {
    input_string_pointer = string;
    pointer_to_rembh = reg_exp_match_begins_here;
    pointer_to_remeh = reg_exp_match_ends_here;
    char **sp = reg_exp_match_begins_here;
    char **ep = reg_exp_match_ends_here;
    for( int i = MAX_SUB_EXPRESSIONS; i > 0; i-- ) {
            *sp++ = NULL;
            *ep++ = NULL;
    }
    if( lookup_engine( symbol_string + 1 ) ) {
        reg_exp_match_begins_here[ 0 ] = string;
        reg_exp_match_ends_here[ 0 ] = input_string_pointer;
        return( 1 );
    } else
        return( 0 );
}

unsigned long JString::getHash() const {
        char* str = Buffer;
        unsigned long hash = 0;
        int c;
        while (c = *str++)
                hash = c + (hash << 6) + (hash << 16) - hash;
        return hash;
}











bool JString::unitTest() {
        JString str, str2, strExp;
        addUnitTestLog("Starting JString UnitTest...");

        addUnitTestLog("Starting Boolex UnitTest...");
        Boolex* bx = new Boolex();

        str = "((mytext is one) and (mytext is two))";
        strExp = "((mytext is one) AND (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "(mytext is one and mytext is two)";
        strExp = "((mytext is one) AND (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "(mytext is one) and (mytext is two)";
        strExp = "((mytext is one) AND (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "mytext is one and mytext is two";
        strExp = "((mytext is one) AND (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "((mytext is one) and (mytext is two) or (mytext is three))";
        strExp = "((mytext is one) AND (mytext is two) OR (mytext is three))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "((mytext is one) and (mytext is two)) or (mytext is three)";
        strExp = "(((mytext is one) AND (mytext is two)) OR (mytext is three))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "(((mytext is one) and (mytext is two)) or (mytext is three))";
        strExp = "(((mytext is one) AND (mytext is two)) OR (mytext is three))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "((mytext is one) and not (mytext is two))";
        strExp = "((mytext is one) AND NOT (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "(not (mytext is one) and not (mytext is two))";
        strExp = "(NOT (mytext is one) AND NOT (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        str = "not ((mytext is one) and not (mytext is two))";
        strExp = "NOT ((mytext is one) AND NOT (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        bx->strAND = "&&";
        bx->strOR = "||";
        bx->strNOT = "!";
        str = "! ((mytext is one) || ! (mytext is two) && ! (mytext is two))";
        strExp = "! ((mytext is one) || ! (mytext is two) && ! (mytext is two))";
        if (bx->setExpression(str)) {
                str2 = bx->print();
                if (!str2.equalsIgnoreCase(strExp)) {
                        addUnitTestLog(JString::format("Boolex result failed:\n%s\n%s\n%s\n", (char*) str, (char*) str2, (char*) strExp));
                        return false;
                }
        }
        else {
                addUnitTestLog(JString::format("Boolex parsing failed:\n%s\n", (char*) str));
                return false;
        }

        delete(bx);
        return true;
}





Boolex::Boolex() {
        boolex = NULL;
        isNegated = false;
        operators = new Collection();
        boolexes = new ObjectCollection();
        strAND = "AND";
        strOR = "OR";
        strXOR = "XOR";
        strNOT = "NOT";
}

Boolex::Boolex(const JString& str) {
        boolex = NULL;
        isNegated = false;
        operators = new Collection();
        boolexes = new ObjectCollection();
        strAND = "AND";
        strOR = "OR";
        strXOR = "XOR";
        strNOT = "NOT";
        if (str.looksLikeXML())
                Object::fromXML(str);
        else
                setExpression(str);
}

Boolex::Boolex(XMLNode* node) {
        boolex = NULL;
        isNegated = false;
        operators = new Collection();
        boolexes = new ObjectCollection();
        strAND = "AND";
        strOR = "OR";
        strXOR = "XOR";
        strNOT = "NOT";
        fromXML(node);
}

Boolex::~Boolex() {
        delete(boolex);
        boolex = NULL;
        delete(operators);
        operators = NULL;
        delete(boolexes);
        boolexes = NULL;
}

bool Boolex::reset() {
        text = "";
        delete(boolex);
        boolex = NULL;
        isNegated = false;
        operators->removeAll();
        boolexes->removeAll();
        return true;
}


bool Boolex::fromXML(XMLNode* node) {
        if (node == NULL)
                return false;

        if (!node->getTag().equalsIgnoreCase("boolex"))
                return false;

        return setExpression(node->getText());
}



bool Boolex::equals(const Object* o2) const {
        if (o2 == NULL) return false;
        return toText().equalsIgnoreCase(((Boolex*)o2)->toText());
}

Object* Boolex::clone() const {
        Boolex* bx = new Boolex();
        bx->strAND = strAND;
        bx->strOR = strOR;
        bx->strXOR = strXOR;
        bx->strNOT = strNOT;
        bx->text = text;
        if (boolex != NULL)
                bx->boolex = (Boolex*) boolex->clone();
        if (operators->getCount() > 0) {
                bx->operators->addAll(operators);
                bx->boolexes->copyAll(boolexes);
        }
        return bx;
}

JString Boolex::toXML() {
        return JString::format("<boolex>%s</boolex>", (char*) toText().xmlStringEncode());
}

JString Boolex::print() {
        return toText();
}

JString Boolex::toText() const {
        JString str;
        if (boolex != NULL) {
                str = boolex->print();
        }
        else if (text.length() > 0) {
                if (isNegated)
                        str = JString::format("%s (%s)", (char*) strNOT, (char*) text);
                else
                        str = JString::format("(%s)", (char*) text);
        }
        else
                return "";
        if (boolexes->getCount() == 0)
                return str;

        JString opr;
        Boolex* bx;
        for (int n=0; n<boolexes->getCount(); n++) {
                if ( (bx = (Boolex*) boolexes->get(n)) != NULL) {
                        if ( (opr = operators->get(n)).length() > 0) {
                                str = JString::format("%s %s %s", (char*) str, (char*) opr.toUpperCase(), (char*) bx->print());
                        }
                }
        }
        if (isNegated)
                return JString::format("%s (%s)", (char*) strNOT, (char*) str);
        else
                return JString::format("(%s)", (char*) str);
}

bool Boolex::setExpression(const JString& str) {
        reset();
        JString fullStr = enforceParentheses(str);
        if (fullStr.length() == 0)
                return false;
        if ( (!fullStr.contains("(")) && (!fullStr.contains(")")) && (!containsReservedWords(str))) {
                text = fullStr;
                return true;
        }
        else
                return parseExpression(fullStr);
}

bool Boolex::parseExpression(const JString& str) {
        return parseParentheses(str);
}

bool Boolex::isReservedWord(const JString& word) {
        return ( word.equalsIgnoreCase(strAND) || word.equalsIgnoreCase(strOR)
                 || word.equalsIgnoreCase(strXOR) || word.equalsIgnoreCase(strNOT) );
}

bool Boolex::containsReservedWords(const JString& text) {
        return ( text.containsIgnoreCase(strAND) || text.containsIgnoreCase(strOR)
                 || text.containsIgnoreCase(strXOR) || text.containsIgnoreCase(strNOT) );
}

JString Boolex::enforceParentheses(JString str) {

        if (!containsReservedWords(str))
                return str;

        if ( str.indexOfCount("(") != str.indexOfCount(")") )
                return "";

        str.replace("( ", "(");
        str.replace(" )", ")");

        str.replaceIgnoreCase(JString::format("(%s", (char*) strNOT), JString::format("( %s ", (char*) strNOT));

//      str.replace("((", "( (", true, true);
//      str.replace("))", ") )", true, true);

        Collection words = str.splitOnWhiteSpaces();
        JString word;
        int first = -1, last = -1;
        for (int n=0; n<words.getCount(); n++) {
                word = words.get(n);
                if (!isReservedWord(word)) {
                        if ( (!word.equals("(")) && (!word.equals(")"))) {
                                if (first == -1)
                                        first = n;
                                last = n;
                        }
                }
                else if (first >= 0) {
                        if ( (!words.get(first).startsWith("(")) || (!words.get(last).endsWith(")")) ) {
                        //      if (words.get(first).startsWith("("))
                        //              words.replace(first, JString::format("( %s", (char*) words.get(first)));
                        //      else
                                        words.replace(first, JString::format("(%s", (char*) words.get(first)));
                        //      if (words.get(last).endsWith(")"))
                        //              words.replace(last, JString::format("%s )", (char*) words.get(last)));
                        //      else
                                        words.replace(last, JString::format("%s)", (char*) words.get(last)));
                        }
                        first = last = -1;
                }
        }
        if (first >= 0) {
                if ( (!words.get(first).startsWith("(")) || (!words.get(last).endsWith(")")) ) {
                //      if (words.get(first).startsWith("("))
                //              words.replace(first, JString::format("( %s", (char*) words.get(first)));
                //      else
                                words.replace(first, JString::format("(%s", (char*) words.get(first)));
                //      if (words.get(last).endsWith(")"))
                //              words.replace(last, JString::format("%s )", (char*) words.get(last)));
                //      else
                                words.replace(last, JString::format("%s)", (char*) words.get(last)));
                }
        }
        return words.printListLine(" ");
}

bool Boolex::parseParentheses(const JString& str) {

        if ( str.indexOfCount("(") != str.indexOfCount(")") )
                return false;

        int n, m;
        int pcount = 0;
        int len = str.length();
        JString lastWord, secondLastWord, opr, text;
        int lastSpace=0, secondLastSpace=0, thirdLastSpace=0;
        for (n=0; n<len; n++) {
                if (str[n] == ' ') {
                        thirdLastSpace = secondLastSpace;
                        secondLastSpace = lastSpace;
                        lastSpace = n;
                }
                else if (str[n] == '(') {
                        // Find the matching closing ')'
                        pcount = 1;
                        for (m=n+1; m<len; m++) {
                                if (str[m] == '(')
                                        pcount++;
                                else if (str[m] == ')') {
                                        pcount--;
                                        if (pcount == 0) {
                                                // We now have one () from pos n to m
                                                text = str.substring(n+1, m).trim();
                                                Boolex* bx = new Boolex();
                                                bx->strAND = strAND;
                                                bx->strOR = strOR;
                                                bx->strXOR = strXOR;
                                                bx->strNOT = strNOT;
                                                bx->setExpression(text);
                                                if (boolex == NULL) {
                                                        // Find the last word
                                                        lastWord = str.substring(secondLastSpace, lastSpace).trim();
                                                        // Find the NOT if any
                                                        if (lastWord.equalsIgnoreCase(strNOT)) {
                                                                bx->isNegated = true;
                                                        }
                                                        boolex = bx;
                                                }
                                                else {
                                                        // Find the last two words
                                                        lastWord = str.substring(secondLastSpace, lastSpace).trim();
                                                        secondLastWord = str.substring(thirdLastSpace, secondLastSpace).trim();
                                                        // Find the NOT if any
                                                        if (lastWord.equalsIgnoreCase(strNOT)) {
                                                                bx->isNegated = true;
                                                                // Find the operator
                                                                opr = secondLastWord;
                                                        }
                                                        else {
                                                                // Find the operator
                                                                opr = lastWord;
                                                        }
                                                        // Add them all
                                                        operators->add(opr);
                                                        boolexes->add(bx);
                                                }
                                                n = m;
                                                break;
                                        }
                                }
                        }
                }
        }

        return true;
}







} // namespace cmlabs

---