GenericException.cc

Go to the documentation of this file.

/*
 * GenericException.cc
 *
 * Smalltalk like class library for C++
 * Abstract exception.
 *
 * Copyright (c) 2003-05 Milan Cermak
 */
/*
 * 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 <stdio.h>
#include <stdlib.h>
#include <execinfo.h>

#include <stlib/GenericException.h>
#include <stlib/Array.h>
#include <stlib/String.h>
#include <stlib/Stream.h>
#include <stlib/Visitor.h>

//void *GenericException::method_stack[];
//int GenericException::stack_size = 0;
GenericException *GenericException::last_exception = nil;

GenericException::GenericException(String *message, String *selector,
                                   Object *param)
{
    messageText = message;
    _selector   = selector;
    _parameter  = param;
    _originator = nil;
    stack_size = 0;
}

GenericException::~GenericException(void)
{
}

/* Class-accessing protocol */
String *GenericException::className(void) const
{
    return new String("GenericException");
}

GenericException *GenericException::lastException(void)
{
    return last_exception;
}

/* Accessing protocol */
String *GenericException::description(void)
{
    if (messageText == NULL)
        return notifierString();
    return messageText;
}

const Object *GenericException::originator(void)
{
    if (_originator == nil) return this;
                       else return _originator;
}

void GenericException::originator(const Object *object)
{
    _originator = object;
}

Object *GenericException::parameter(void)
{
    return _parameter;
}

void GenericException::selector(String *sel)
{
    _selector = sel;
}

void GenericException::selector(const char *sel)
{
    _selector = new String(sel);
}

String *GenericException::selector(void)
{
    return _selector;
}

/* Printing protocol */
void GenericException::printStackOn(Stream *stream)
{
    if (method_stack == NULL || stack_size <= 1) {
        stream->nextPutAll("No stack.");
        return;
    }

    char **names;
    String *line, *module, *mangledName;
    int startMark, endMark;

    names = backtrace_symbols(method_stack, stack_size);
    for (int i = 1; i < stack_size; i++) {
        line = new String(names[i]);
        startMark = line->indexOf('(');
        if (startMark < 0) startMark = line->indexOf(' ');
        endMark = line->nextIndexOf('+', startMark, line->size());
        module = dynamic_cast<String *>(line->copy(0, startMark));
        mangledName = dynamic_cast<String *>(line->copy(startMark+1, endMark));

        stream->nextPutAll("    ");
        try {
            stream->nextPutAll(mangledName->demangleMethodName());
        }
        catch (GenericException *ex) {
            stream->nextPutAll(mangledName);
        }
        stream->nextPutAll(" in ");
        stream->nextPutAll(module);
        stream->lf();
    }
    free((void *) names);
}

/* Raising protocol */
void GenericException::pass(void)
{
    privRaise();
}

void GenericException::raiseFrom(const Object *origin)
{
    originator(origin);
    raise();
}

void GenericException::raise(void)
{
    getExecutionStack();
    privRaise();
}

/* Visiting protocol */
void GenericException::visitBy(Visitor *visitor)
{
    visitor->visitException(this);
}

/* Private protocol */
void GenericException::getExecutionStack(void)
{
//    if (last_exception == nil)
//      GC_exclude_static_roots(method_stack, method_stack + MAXSTACKSIZE);
    last_exception = this;
    stack_size = backtrace(method_stack, MAXSTACKSIZE);
}

---