bufmod.cc File Reference

#include "mbconfig.h"
#include "parser.h"
#include "bufmod.h"

Include dependency graph for bufmod.cc:

Go to the source code of this file.

Classes
struct	TypeWordSet_t

Functions
static BufCast *	ReadOneBufCast (HighParser &HP, size_t &offset, TypeMap_t &swapmap, bool bNoSkip=false)
bool	bIsLittleEndian (void)
void	SwapMapInit (TypeMap_t &swapmap)
void	ReadBufCast (HighParser &HP, std::vector< BufCast * > &data)

Function Documentation

bool bIsLittleEndian

(

void

)

Definition at line 259 of file bufmod.cc.

Referenced by buildFGBufCast(), and ReadBufCast().

{
        const int i = 1;
        return (*(char *)&i) != 0;
}

void ReadBufCast	(	HighParser &	HP,
		std::vector< BufCast * > &	data
	)

Definition at line 287 of file bufmod.cc.

References bIsLittleEndian(), BufCast::copy(), HighParser::GetYesNoOrBool(), HighParser::IsKeyWord(), HighParser::IsWord(), ReadOneBufCast(), and SwapMapInit().

Referenced by ReadStreamContentModifier(), and ReadStreamDriveModifier().

{
        TypeMap_t swapmap;
        SwapMapInit(swapmap);

        if (HP.IsKeyWord("swap")) {
                TypeWordSet_t typewordset(swapmap);
                const char *s = HP.IsWord(typewordset);
                if (s != 0) {
                        do {
                                TypeMap_t::iterator i = swapmap.find(std::string(s));
                                i->second = true;
                        } while ((s = HP.IsWord(typewordset)) != 0);

                } else {
                        bool bSwap(false);
                        if (HP.IsKeyWord("detect")) {
                                bSwap = bIsLittleEndian();

                        } else {
                                bSwap = HP.GetYesNoOrBool();
                        }

                        if (bSwap) {
                                for (TypeMap_t::iterator i = swapmap.begin(); i != swapmap.end(); ++i) {
                                        i->second = true;
                                }
                        }
                }
        }

        if (HP.IsKeyWord("all")) {
                size_t size(0), offset(0);
                BufCast *pBC = 0;
                pBC = ReadOneBufCast(HP, size, swapmap, true);

                data[0] = pBC;
                for (size_t i = 1; i < data.size(); i++) {
                        offset += size;
                        data[i] = data[i - 1]->copy(offset);
                }

        } else {
                size_t offset(0);
                for (size_t i = 0; i < data.size(); i++) {
retry:;
                        BufCast *pBC = 0;
                        pBC = ReadOneBufCast(HP, offset, swapmap);

                        if (pBC == 0) {
                                // got skip
                                goto retry;
                        }
                        data[i] = pBC;
                }
        }
}

Here is the call graph for this function:

static BufCast* ReadOneBufCast ( HighParser &  HP, size_t &  offset, TypeMap_t &  swapmap, bool  bNoSkip = false  )

static

Definition at line 146 of file bufmod.cc.

References ASSERT, HighParser::GetInt(), HighParser::GetLineData(), HighParser::IsKeyWord(), and MBDYN_EXCEPT_ARGS.

Referenced by ReadBufCast().

{
        BufCast *pBC(0);

        if (HP.IsKeyWord("int8_t")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(int8_t).name());
                if (i->second) {
                        pBC = new TBufCastHToN<int8_t>(offset);

                } else {
                        pBC = new TBufCast<int8_t>(offset);
                }
                offset += sizeof(int8_t);

        } else if (HP.IsKeyWord("uint8_t")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(uint8_t).name());
                if (i->second) {
                        pBC = new TBufCastHToN<uint8_t>(offset);

                } else {
                        pBC = new TBufCast<uint8_t>(offset);
                }
                offset += sizeof(uint8_t);

        } else if (HP.IsKeyWord("int16_t")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(int16_t).name());
                if (i->second) {
                        pBC = new TBufCastHToN<int16_t>(offset);

                } else {
                        pBC = new TBufCast<int16_t>(offset);
                }
                offset += sizeof(int16_t);

        } else if (HP.IsKeyWord("uint16_t")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(uint16_t).name());
                if (i->second) {
                        pBC = new TBufCastHToN<uint16_t>(offset);

                } else {
                        pBC = new TBufCast<uint16_t>(offset);
                }
                offset += sizeof(uint16_t);

        } else if (HP.IsKeyWord("int32_t")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(int32_t).name());
                if (i->second) {
                        pBC = new TBufCastHToN<int32_t>(offset);

                } else {
                        pBC = new TBufCast<int32_t>(offset);
                }
                offset += sizeof(int32_t);

        } else if (HP.IsKeyWord("uint32_t")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(uint32_t).name());
                if (i->second) {
                        pBC = new TBufCastHToN<uint32_t>(offset);

                } else {
                        pBC = new TBufCast<uint32_t>(offset);
                }
                offset += sizeof(uint32_t);

        } else if (HP.IsKeyWord("float")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(float).name());
                if (i->second) {
                        pBC = new TBufCastHToN<float>(offset);

                } else {
                        pBC = new TBufCast<float>(offset);
                }
                offset += sizeof(float);

        } else if (HP.IsKeyWord("double")) {
                TypeMap_t::const_iterator i = swapmap.find(typeid(double).name());
                if (i->second) {
                        pBC = new TBufCastHToN<double>(offset);

                } else {
                        pBC = new TBufCast<double>(offset);
                }
                offset += sizeof(double);

        } else if (HP.IsKeyWord("skip") && !bNoSkip) {
                integer skip = HP.GetInt();
                if (skip < 0) {
                        silent_cerr("ReadOneBufCast: invalid number of bytes " << skip
                                << " to be skipped at line " << HP.GetLineData() << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                offset += skip;

#if 0
        } else if (HP.IsKeyWord("offset")) {
                integer ioffset = HP.GetInt();
                if (ioffset < 0) {
                        silent_cerr("ReadOneBufCast: invalid number of bytes " << ioffset
                                << " as offset at line " << HP.GetLineData() << std::endl);
                        throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                }
                offset = ioffset;
#endif

        } else {
                ASSERT(0);
                throw ErrGeneric(MBDYN_EXCEPT_ARGS);
        }

        return pBC;
}

Here is the call graph for this function:

void SwapMapInit

(

TypeMap_t &

swapmap

)

Definition at line 266 of file bufmod.cc.

Referenced by buildFGBufCast(), and ReadBufCast().

{
        swapmap.insert(TypeMap_t::value_type(typeid(int8_t).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(uint8_t).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(int16_t).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(uint16_t).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(int32_t).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(uint32_t).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(float).name(), false));
        swapmap.insert(TypeMap_t::value_type(typeid(double).name(), false));
}