---

mobject.cc

/***************************************************************************
 *   This file is part of the MagiC++ library.                             *
 *                                                                         *
 *   Copyright (C) 1998-2001 Marko Grönroos <magi@iki.fi>                  *
 *                                                                         *
 ***************************************************************************
 *                                                                         *
 *  This library is free software; you can redistribute it and/or          *
 *  modify it under the terms of the GNU Library General Public            *
 *  License as published by the Free Software Foundation; either           *
 *  version 2 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      *
 *  Library General Public License for more details.                       *
 *                                                                         *
 *  You should have received a copy of the GNU Library General Public      *
 *  License along with this library; see the file COPYING.LIB.  If         *
 *  not, write to the Free Software Foundation, Inc., 59 Temple Place      *
 *  - Suite 330, Boston, MA 02111-1307, USA.                               *
 *                                                                         *
 ***************************************************************************/

#include <iostream.h>
#include <malloc.h>
#include <stdlib.h>

#include "magic/mobject.h"
#include "magic/mclass.h"
#include "magic/mmath.h"
#include "magic/mmagisupp.h"

decl_module (object);

//- Standard object.hierarchy<BR>
//- Käytetty seuraavissa käyttöympäristöissä, vaikkakaan yhteensopivuus
//- ei välttämättä ole täysin ajan tasalla:
//-      MSDOS Borland C++ 3.0
//-      Unix gcc 2.7.0 C++ (Solaris, Linux)
//-      Unix egcs C++ (Solaris, Linux)


const char nullchar = '\x00';
FILE* dbgout = stderr;

impl_abstract (Object, {})
impl_abstract (Comparable, {Object});
impl_dynamic (Int, {Comparable})

ostream& operator<< (ostream& out, const Object& obj) {
    obj >> out;
    return out;
}

istream& operator>> (istream& in, Object& obj) {
    obj << in;
    return in;
}

OStream& operator<< (OStream& out, const Object& obj) {
    obj >> out;
    return out;
}

CArchive& operator<< (CArchive& out, const Object& obj) {
    if (out.mode & DUMP_TEXT)
        out.printComma ();
    out.depth++;
    if (out.mode & DUMP_RECORD) {
        if (out.depth==1)
            obj >> out;
        else
            out.attribs->add (new String (out.nextname));
    } else {
        if (out.mode & DUMP_TEXT) {
            if ((out.mode & DUMP_CLASSNAMES) && !isnull (obj.getclass().getname()))
                out.print (obj.getclass().getname());
            //      , out.print ("::");
            if (!out.nextname.isEmpty()) {
                out.print (out.nextname);
                out.print ("=");
                out.nextname="";  // NULL originally, but causes ambiquity with some compilers
            }
            out.print ("{");
        }

        obj >> out;

        if (out.mode & DUMP_TEXT)
            out.print ("}");
    }
    out.depth--;
    return out;
}

IStream& operator>> (IStream& in, Object& obj) {
    // in.depth++;
    obj << in;
    // in.depth--;
    return in;
}

//                       ___          o                                      //
//                      |   | |          ___   ___   |                       //
//                      |   | |---    | /   ) |   \ -+-                      //
//                      |   | |   )   | |---  |      |                       //
//                      `___´ |__/  \_|  \__   \__/   \                      //

Object::~Object () {
}

ostream& Object::operator>> (ostream& out) const {return out;}

istream& Object::operator<< (istream& in) {return in;}

CArchive& Object::operator>> (CArchive& out) const {return out;}

void Object::operator>> (OStream& out) const {;}

IStream& Object::operator<< (IStream& in) {return in;}

Object* Object::clone () const {
    MUST_OVERLOAD;
    return NULL;
}

bool Object::isOK () const {
    try {
        check ();
    } catch (...) {
        return false;
    }
    return true;
}

const String& Object::getclassname () const {
    return getclass().getname ();
}

int Object::is_a (const String& classname) const {
    return getclass().getname () == classname;
}

bool nextNewIsObject = false;

#ifdef DEBUG_OBJECT_NEW
#ifdef new
#undef new
void* Object::operator new[] (size_t size, const char* filen, int lineno, const char* funcn) {
    nextNewIsObject = true;
    return ::operator new[] (size, filen, lineno, funcn);
}

void* Object::operator new (size_t size, const char* filen, int lineno, const char* funcn) {
    nextNewIsObject = true;
    return ::operator new[] (size, filen, lineno, funcn);
}

void* Object::operator new[] (size_t size) {
    nextNewIsObject = true;
    return ::operator new[] (size, "unknown", -1, "unknown");
}

void* Object::operator new (size_t size) {
    nextNewIsObject = true;
    return ::operator new[] (size, "unknown", -1, "unknown");
}
#define new DEBUG_NEW
#endif
#endif





int compareComparable   (const void* a, const void* b) {
    /*
      // :WEIRDNESS: The code below crashes... What's the difference
      ASSERT (a);
      ASSERT (b);
      const Comparable& ac = *static_cast<const Comparable*> (a);
      const Comparable& bc = *static_cast<const Comparable*> (b);
      return ac.compare (bc);
      */

    return (**(const Comparable**)a).compare ((**(const Comparable**)b));
}
/*
int compareComparable   (const void* a, const void* b) {
    return (**(const Comparable**)a).compare ((**(const Comparable**)b));
}
*/


Int::Int (const String& o) {
    data = o.toInt();
}

int Int::operator == (const Comparable& o) const {
    if (o.is_a ("Int"))
        return data==((const Int&)o).data;
}



// Apufunktioita


CPPModule::CPPModule (const char* n) {
    name = strdup (n);
    #ifdef MODULEDEBUG
    printf ("Module %s loading...\n", name);
    #endif
}


//

int rnd (int range) {
    return (int) (double(range)*rand()/(RAND_MAX+1.0));
}

double frnd () {
    return rand()/(RAND_MAX+1.0);
}

double gaussrnd (double stdv) {
    if (stdv>0.0) {
        double r = rand()/(RAND_MAX+1.0)-0.5;
        return stdv * log ((r+0.5)/(0.5-r));
    }
    return 0.0;
}

// From mmagisupp.h

Exception::Exception (const String& what_arg) : mWhat (new String (what_arg)) {
}

Exception::Exception (const Exception& orig) : mWhat (new String (*orig.mWhat)) {
}

Exception::~Exception () {
    delete mWhat;
}


//                                                                          //
//              _                             o                             //
//             / \   ____  ____  ___       |           _    ____            //
//            /   \ (     (     /   ) |/\ -+- |  __  |/ \  (                //
//            |---|  \__   \__  |---  |    |  | /  \ |   |  \__             //
//            |   | ____) ____)  \__  |     \ | \__/ |   | ____)            //
//                                                                          //

int assertmode=ASSERT_THROW;

void assertwith (const char* filename, int lineno, const char* funcname,
                 const char* condition, const char* message) {
    String errormsg = format("Condition '%s' violated at %s[%d]: %s()",
                               condition, filename, lineno, funcname);
    if (message)
        errormsg += format ("\n%%ERR: %s", message);

    switch (assertmode) {
      case ASSERT_CRASH:
          fprintf (stderr, "\n%%ERR: %s\n", (CONSTR) errormsg);
          fprintf (stderr, "%%ERR: Intentional assertion crash. "
                   "I hope you are under debugger now...\n");
          *((int*)NULL) = 1; // So you're under debugger. Ok, now just backtrace
          break;
      case ASSERT_EXIT:
          fprintf (stderr, "\n%%ERR: %s\n", (CONSTR) errormsg);
          exit (1);
          break;
      case ASSERT_DONTCARE:
          fprintf (stderr, "\n%%ERR: %s\n", (CONSTR) errormsg);
          break;
      case ASSERT_THROW:
      default:
          throw assertion_failed (format ("%s", (CONSTR)errormsg));
    };
}




#ifndef DISABLE_ALL_MEMORY_DEBUGGING
#ifdef new
#undef new
#endif
#warning "Memory debugging enabled"

int dbgnewmalloced=0;
mallocinfostr* lastmalloced=NULL;
int newtrace_disabled = 1;
char* newcomment=NULL;

void newComment (const char* comment) {
    if (newcomment)
        free (newcomment);
    newcomment = strdup(comment);
}


void* operator new[] (size_t size, const char* filename, int lineno, const char* fname) {
    
    if (newtrace_disabled) {
        void* res = malloc(size);
        if (!res)
            *((char*)0x0)=0;
        return res;
    }

    // Reserve the memory block PLUS space for the info structure
    mallocinfostr* p = (mallocinfostr*) malloc (size+sizeof(mallocinfostr));
    if (!p)
        *((char*)0x0)=0;

    strcpy (p->startsym, "MiS_S");  // Set a recognition label
    p->size         = size;
    p->filename     = filename;
    p->lineno       = lineno;
    p->funcname     = fname;
    p->newcomment   = newcomment? newcomment : NULL;
    newcomment      = NULL;
    p->renewed      = false;
    p->isObject     = nextNewIsObject;
    nextNewIsObject = false;
    p->prev         = lastmalloced;
    p->next         = NULL;
    if (p->prev)
        p->prev->next = p;
    lastmalloced    = p;
    
    // Fill with 0x00
    memset (((char*)p)+sizeof (mallocinfostr), '\xcc', p->size);

    // Add to global counter
    dbgnewmalloced += size + sizeof(mallocinfostr);
    return ((char*)p)+sizeof (mallocinfostr);
}

void* operator new (size_t size, const char* filename, int lineno, const char* fname) {
    return operator new[] (size, filename, lineno, fname);
}

void* _renew (void* p, size_t newsize, const char* filename, int lineno, const char* fname) {
    if (memcmp (((char*)p)-sizeof(mallocinfostr), "MiS_S", 5) || newtrace_disabled) {
        void* res = realloc ((char*) p, newsize);
        // Again, should not be null
        if (!res)
            *((char*)0x0)=0;
        return res;
    } else {
        // Realloc the memory block PLUS space for the info structure
        mallocinfostr* np = (mallocinfostr*) realloc (((char*)p)-sizeof(mallocinfostr),
                                                      newsize+sizeof(mallocinfostr));
        // Again, should not be null
        if (!np)
            *((char*)0x0)=0;
        
        dbgnewmalloced -= np->size; // Substract old size from total size register
        np->size = newsize;         // Refresh
        np->filename = filename;    // Refresh
        np->lineno = lineno;        // Refresh
        np->funcname = fname;       // Refresh
        if (newcomment) {           // Refresh
            free (np->newcomment);
            np->newcomment = newcomment;
            newcomment = NULL;
        }
        np->renewed = true;         // Now we have been renewed
        if (np->prev)
            np->prev->next = np;
        if (np->next)
            np->next->prev = np;
        if ((void*) (((char*)p)-sizeof(mallocinfostr)) == (void*) lastmalloced)
            lastmalloced = np;
        dbgnewmalloced += newsize;  // Add new size to total size register
        return ((char*)np)+sizeof (mallocinfostr);
    }
}

void operator delete (void* p) {
    if (p) {
        if (memcmp (((char*)p)-sizeof(mallocinfostr), "MiS_S", 5)) {
            free (p); // Allocated with ordinary malloc or new
        } else {
            mallocinfostr* mp=(mallocinfostr*)(((char*)p)-sizeof(mallocinfostr));
            //TRACE3 ("%d, %s, %d", mp->size, mp->filename, mp->lineno);
            if (mp->next)
                mp->next->prev = mp->prev; 
            if (mp->prev)
                mp->prev->next = mp->next;
            if (mp == lastmalloced)
                if (mp->next)
                    while (lastmalloced->next)
                        lastmalloced=lastmalloced->next;
                else
                    lastmalloced = mp->prev;
            if (mp->newcomment)
                free (mp->newcomment);
            dbgnewmalloced -= mp->size + sizeof (mallocinfostr);

            // Fill the block with 0xdd
            memset (mp, '\xdd', mp->size + sizeof (mallocinfostr));

            free (mp);
        }
    }
}

// int listAllocationsLimit=100;

void list_allocations (int number, FILE* out) {
    fprintf (out, "Dumping all reserved memory blocks:\n");
    int i=0;
    for (mallocinfostr* p=lastmalloced; p && (number==0 || i<number); p=p->prev, i++) {
        fprintf (out, "%9d bytes (%8x) %s at %s#%d %s",
                 p->size, ((char*)p)+sizeof (mallocinfostr),
                 (p->renewed)? "renewed  ":"allocated", 
                 p->filename, p->lineno, p->funcname);
        if (p->isObject) {
            Object* op = (Object*)(void*)(((char*)p)+sizeof(mallocinfostr));
            fprintf (out, " (%s)", (CONSTR) op->getclassname());
        }
        if (p->newcomment)
            fprintf (out, " : \042%s\042", (CONSTR) p->newcomment);
        fprintf (out, "\n");
    }
    if (number>0 && i>=number)
        fprintf (out, "** Only %d first items listed\n", number);
    fprintf (out, "Total amount of memory allocated: %d "
             "(including the DEBUG_NEW overhead)\n", dbgnewmalloced);
}

#endif

---