~ubuntu-branches/ubuntu/saucy/gnash/saucy-proposed

 

// Macro to prevent repeated logging calls for the same

// event

 

# include <boost/preprocessor/arithmetic/inc.hpp>

# include <boost/preprocessor/repetition/enum_params.hpp>

# include <boost/preprocessor/repetition/repeat.hpp>

# include <boost/preprocessor/repetition/repeat_from_to.hpp>

# include <boost/preprocessor/seq/for_each.hpp>

 

namespace gnash {

 

// This is a basic file logging class

public:

 

    static LogFile& getDefaultInstance();

 

    ~LogFile();

 

    enum FileState {

        CLOSED,

        OPEN,

    void setLogFilename(const std::string& fname);

 

    // accessors for the verbose level

    }

 

        _verbose = x;

    }

 

        return _verbose;

    }

    

        _actiondump = x;

    }

 

        return _actiondump;

    }

    

    void setParserDump (int x) {

        _parserdump = x;

    }

 

        return _parserdump;

    }

    

        _stamp = b;

    }

 

        return _stamp;

    }

 

    /// Set whether to write logs to file

 

        return _write;

    }

    

    boost::mutex _ioMutex;

 

    /// Stream to write to stdout.

 

    /// How much output is required: 2 or more gives debug output.

 

    /// Whether to dump all SWF actions

 

    /// Whether to dump parser output

 

    /// The state of the log file.

    FileState _state;

 

 

    /// Whether to write the log file to disk.

 

    std::string _filespec;

 

 

};

 

/// This heap of steaming preprocessor code magically converts

/// printf-style statements into boost::format messages using templates.

//

/// This is a sequence of different log message types to be used in

/// the code. Append the name to log_ to call the function, e.g. 

/// log_error, log_unimpl.

 

/// This actually creates the template functions using the TOKENIZE

/// functions above. The templates look like this:

//

/// {

/// }

/// Only not as nicely indented.

///

#define LOG_TEMPLATES(z, n, data)\

    if (LogFile::getDefaultInstance().getVerbosity() == 0) return; \

 

/// Defines the maximum number of template arguments

//

/// The preprocessor generates templates with 1..ARG_NUMBER

/// arguments.

 

/// Calls the macro LOG_TEMPLATES an ARG_NUMBER number

/// of times, each time adding an extra typename argument to the

#undef LOG_TEMPLATES

#undef ARG_NUMBER

 

/// Convert a sequence of bytes to hex or ascii format.

//

/// @param bytes    the array of bytes to process

///                 for checking that length does not exceed the array size.

/// @param ascii    whether to return in ascii or space-separated hex format.

/// @return         a string representation of the byte sequence.

 

// Define to 0 to completely remove parse debugging at compile-time

#ifndef VERBOSE_PARSE

#define VERBOSE_MALFORMED_AMF 1

#endif

 

 

#if VERBOSE_PARSE

#define IF_VERBOSE_PARSE(x) do { if ( LogFile::getDefaultInstance().getParserDump() ) { x; } } while (0);

#define IF_VERBOSE_ACTION(x)

#endif

 

#if VERBOSE_ASCODING_ERRORS

// TODO: check if it's worth to check verbosity level too...

#define IF_VERBOSE_ASCODING_ERRORS(x) { if ( gnash::RcInitFile::getDefaultInstance().showASCodingErrors() ) { x; } }

    }

 

    ~__Host_Function_Report__(void) {

            log_debug("%s returning", func);

        }

    }