StdCompiler.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	StdCompiler
struct	StdCompiler::Exception
class	StdCompiler::NotFoundException
class	StdCompiler::EOFException
class	StdCompiler::CorruptException
class	StdCompilerNull
class	StdCompilerBinWrite
class	StdCompilerBinRead
class	StdCompilerINIWrite
struct	StdCompilerINIWrite::Naming
class	StdCompilerINIRead
struct	StdCompilerINIRead::NameNode

Functions
template<class T >
void	CompileFunc (T &rStruct, StdCompiler *pComp)
void	CompileFunc (std::string &s, StdCompiler *comp)
template<class T >
void	CompileNewFunc (T *&pStruct, StdCompiler *pComp)
template<class T , typename ... P>
void	CompileNewFunc (T *&pStruct, StdCompiler *pComp, P &&... pars)
template<class T , class ContextT >
void	CompileNewFuncCtx (T *&pStruct, StdCompiler *pComp, const ContextT &rCtx)
template<class T , class ContextT , class P >
void	CompileNewFuncCtx (T *&pStruct, StdCompiler *pComp, const ContextT &rCtx, const P &rPar)
template<class CompT , class StructT >
void	CompileFromBuf (StructT &&TargetStruct, const typename CompT::InT &SrcBuf)
template<class CompT , class StructT >
StructT *	CompileFromBufToNew (const typename CompT::InT &SrcBuf)
template<class CompT , class StructT >
StructT *	CompileFromBufToNewNamed (const typename CompT::InT &SrcBuf, const char *szName)
template<class CompT , class StructT >
CompT::OutT	DecompileToBuf (const StructT &SrcStruct)
void	StdCompilerWarnCallback (void *pData, const char *szPosition, const char *szError)
template<class CompT , class StructT >
bool	CompileFromBuf_Log (StructT &&TargetStruct, const typename CompT::InT &SrcBuf, const char *szName)
template<class CompT , class StructT >
bool	CompileFromBuf_LogWarn (StructT &&TargetStruct, const typename CompT::InT &SrcBuf, const char *szName)
template<class CompT , class StructT >
bool	DecompileToBuf_Log (StructT &&TargetStruct, typename CompT::OutT *pOut, const char *szName)

---

Class Documentation

StdCompilerINIWrite::Naming

struct StdCompilerINIWrite::Naming

Definition at line 600 of file StdCompiler.h.

Collaboration diagram for StdCompilerINIWrite::Naming:

Class Members
StdStrBuf	Name
Naming *	Parent

Function Documentation

CompileFromBuf()

template<class CompT , class StructT >

void CompileFromBuf	(	StructT &&	TargetStruct,
		const typename CompT::InT &	SrcBuf
	)

Definition at line 379 of file StdCompiler.h.

{
    CompT Compiler;
    Compiler.setInput(SrcBuf.getRef());
    Compiler.Compile(TargetStruct);
}

CompileFromBuf_Log()

template<class CompT , class StructT >

bool CompileFromBuf_Log	(	StructT &&	TargetStruct,
		const typename CompT::InT &	SrcBuf,
		const char *	szName
	)

Definition at line 737 of file StdCompiler.h.

{
    try
    {
        CompileFromBuf<CompT>(TargetStruct, SrcBuf);
        return true;
    }
    catch (StdCompiler::Exception *pExc)
    {
        if (!pExc->Pos.getLength())
            LogF("ERROR: %s (in %s)", pExc->Msg.getData(), szName);
        else
            LogF("ERROR: %s (in %s, %s)", pExc->Msg.getData(), pExc->Pos.getData(), szName);
        delete pExc;
        return false;
    }
}

References StdStrBuf::getData(), StdStrBuf::getLength(), LogF(), StdCompiler::Exception::Msg, and StdCompiler::Exception::Pos.

Here is the call graph for this function:

CompileFromBuf_LogWarn()

template<class CompT , class StructT >

bool CompileFromBuf_LogWarn	(	StructT &&	TargetStruct,
		const typename CompT::InT &	SrcBuf,
		const char *	szName
	)

Definition at line 755 of file StdCompiler.h.

{
    try
    {
        CompT Compiler;
        Compiler.setInput(SrcBuf.getRef());
        Compiler.setWarnCallback(StdCompilerWarnCallback, reinterpret_cast<void *>(const_cast<char *>(szName)));
        Compiler.Compile(TargetStruct);
        return true;
    }
    catch (StdCompiler::Exception *pExc)
    {
        if (!pExc->Pos.getLength())
            LogF("ERROR: %s (in %s)", pExc->Msg.getData(), szName);
        else
            LogF("ERROR: %s (in %s, %s)", pExc->Msg.getData(), pExc->Pos.getData(), szName);
        delete pExc;
        return false;
    }
}

References StdStrBuf::getData(), StdStrBuf::getLength(), LogF(), StdCompiler::Exception::Msg, StdCompiler::Exception::Pos, and StdCompilerWarnCallback().

Here is the call graph for this function:

CompileFromBufToNew()

template<class CompT , class StructT >

StructT* CompileFromBufToNew

(

const typename CompT::InT &

SrcBuf

)

Definition at line 386 of file StdCompiler.h.

{
    StructT *pStruct = nullptr;
    CompileFromBuf<CompT>(mkPtrAdaptNoNull(pStruct), SrcBuf);
    return pStruct;
}

References mkPtrAdaptNoNull().

Here is the call graph for this function:

CompileFromBufToNewNamed()

template<class CompT , class StructT >

StructT* CompileFromBufToNewNamed	(	const typename CompT::InT &	SrcBuf,
		const char *	szName
	)

Definition at line 393 of file StdCompiler.h.

{
    StructT *pStruct = nullptr;
    CompileFromBuf<CompT>(mkNamingAdapt(mkPtrAdaptNoNull(pStruct), szName), SrcBuf);
    return pStruct;
}

References mkNamingAdapt(), and mkPtrAdaptNoNull().

Here is the call graph for this function:

CompileFunc() [1/2]

void CompileFunc ( std::string &  s, StdCompiler *  comp  )

inline

Definition at line 314 of file StdCompiler.h.

{
    comp->String(s);
}

References s, and StdCompiler::String().

Here is the call graph for this function:

CompileFunc() [2/2]

template<class T >

void CompileFunc ( T &  rStruct, StdCompiler *  pComp  )

inline

Definition at line 301 of file StdCompiler.h.

{
    // If the compiler doesn't like this line, you tried to compile
    // something the compiler doesn't know how to handle.
    // Possible reasons:
    // a) You are compiling a class/structure without a CompileFunc
    //    (you may add a specialization of this function, too)
    // b) You are trying to compile a pointer. Use a PtrAdapt instead.
    // c) You are trying to compile a simple value that has no
    //    fixed representation (float, int). Use safe types instead.
    rStruct.CompileFunc(pComp);
}

Referenced by StdCompiler::Value().

Here is the caller graph for this function:

CompileNewFunc() [1/2]

template<class T >

void CompileNewFunc	(	T *&	pStruct,
		StdCompiler *	pComp
	)

Definition at line 320 of file StdCompiler.h.

{
    // Create new object.
    // If this line doesn't compile, you either have to
    // a) Define a standard constructor for T
    // b) Specialize this function to do whatever the correct
    //    behaviour is to construct the object from compiler data
    std::unique_ptr<T> temp(new T); // exception-safety
    // Compile
    pComp->Value(*temp);
    pStruct = temp.release();
}

References StdCompiler::Value().

Referenced by StdPtrAdaptCompileNewFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileNewFunc() [2/2]

template<class T , typename ... P>

void CompileNewFunc	(	T *&	pStruct,
		StdCompiler *	pComp,
		P &&...	pars
	)

Definition at line 334 of file StdCompiler.h.

{
    // Create new object.
    // If this line doesn't compile, you either have to
    // a) Define a standard constructor for T
    // b) Specialize this function to do whatever the correct
    //    behaviour is to construct the object from compiler data
    std::unique_ptr<T> temp(new T); // exception-safety
    // Compile
    pComp->Value(mkParAdapt(*temp, std::forward<P>(pars)...));
    pStruct = temp.release();
}

References mkParAdapt(), and StdCompiler::Value().

Here is the call graph for this function:

CompileNewFuncCtx() [1/2]

template<class T , class ContextT >

void CompileNewFuncCtx	(	T *&	pStruct,
		StdCompiler *	pComp,
		const ContextT &	rCtx
	)

Definition at line 348 of file StdCompiler.h.

{
    // Create new object.
    // If this line doesn't compile, you either have to
    // a) Define an appropriate constructor for T
    // b) Specialize this function to do whatever the correct
    //    behaviour is to construct the object from compiler data
    //    and context
    std::unique_ptr<T> temp(new T(rCtx)); // exception-safety
    // Compile
    pComp->Value(*temp);
    pStruct = temp.release();
}

References StdCompiler::Value().

Referenced by StdPtrAdaptCompileNewFunc().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileNewFuncCtx() [2/2]

template<class T , class ContextT , class P >

void CompileNewFuncCtx	(	T *&	pStruct,
		StdCompiler *	pComp,
		const ContextT &	rCtx,
		const P &	rPar
	)

Definition at line 363 of file StdCompiler.h.

{
    // Create new object.
    // If this line doesn't compile, you either have to
    // a) Define an appropriate constructor for T
    // b) Specialize this function to do whatever the correct
    //    behaviour is to construct the object from compiler data
    //    and context
    std::unique_ptr<T> temp(new T(rCtx));  // exception-safety
    // Compile
    pComp->Value(mkParAdapt(*temp, rPar));
    pStruct = temp.release();
}

References mkParAdapt(), and StdCompiler::Value().

Here is the call graph for this function:

DecompileToBuf()

template<class CompT , class StructT >

CompT::OutT DecompileToBuf

(

const StructT &

SrcStruct

)

Definition at line 400 of file StdCompiler.h.

{
    CompT Compiler;
    Compiler.Decompile(SrcStruct);
    return Compiler.getOutput();
}

DecompileToBuf_Log()

template<class CompT , class StructT >

bool DecompileToBuf_Log	(	StructT &&	TargetStruct,
		typename CompT::OutT *	pOut,
		const char *	szName
	)

Definition at line 776 of file StdCompiler.h.

{
    if (!pOut) return false;
    try
    {
        pOut->Take(DecompileToBuf<CompT>(TargetStruct));
        return true;
    }
    catch (StdCompiler::Exception *pExc)
    {
        LogF("ERROR: %s (in %s)", pExc->Msg.getData(), szName);
        delete pExc;
        return false;
    }
}

References StdStrBuf::getData(), LogF(), and StdCompiler::Exception::Msg.

Here is the call graph for this function:

StdCompilerWarnCallback()

void StdCompilerWarnCallback	(	void *	pData,
		const char *	szPosition,
		const char *	szError
	)

Definition at line 1036 of file StdCompiler.cpp.

{
    const char *szName = reinterpret_cast<const char *>(pData);
    if (!szPosition || !*szPosition)
        DebugLogF("WARNING: %s (in %s)", szError, szName);
    else
        DebugLogF("WARNING: %s (in %s, %s)", szError, szPosition, szName);
}

References DebugLogF().

Referenced by CompileFromBuf_LogWarn().

Here is the call graph for this function:

Here is the caller graph for this function: