trying to port clonk rage. need help with compiler error


___

Advanced Member
Joined
Jan 31, 2006
Messages
3,376
Hi guys. I am trying to build clonk rage from source and it configures okay but when I run make, I get an error during linking and I am too much of a noob to figure it out. I will upload the output of make later today, as I am on the way to work right now. Freaking sunday shift...


tell me what you would need to help me please. I will upload a log of make and my configure options. this is the first big program I am trying to build from source and I don't know what to look for.


I am trying this natively on the pandora from the codeblocks cli with the built in maketools and g++.


the source is availabe on this page: http://www.clonk.de/source.php?lng=en
 
Hi guys. I am trying to build clonk rage from source and it configures okay but when I run make, I get an error during linking and I am too much of a noob to figure it out. I will upload the output of make later today, as I am on the way to work right now. Freaking sunday shift...


tell me what you would need to help me please. I will upload a log of make and my configure options. this is the first big program I am trying to build from source and I don't know what to look for.


I am trying this natively on the pandora from the codeblocks cli with the built in maketools and g++.


the source is availabe on this page: http://www.clonk.de/source.php?lng=en
Error durring linking, it happens sometimes (there are still some error in codeblocks that I try to fix).. I need the error. You'll need to copy/paste the printout of the make in here.
 
Last edited by a moderator:
ono-sendai-op:/media/pandora/builds/code/clrsrc$ make
depbase=`echo C4Include.h.gch | sed 's|[^/]*$|.deps/&|;s|\.h.gch$||'`;\
g++ -DHAVE_CONFIG_H -I./standard/lpng121 -I. -I./standard -I./standard/zlib -I./standard/inc -I./engine -I./engine/inc -I./engine/sec -DC4ENGINE -DGLEW_STATIC -I/mnt/utmp/codeblocks/usr/include/freetype2 -I/mnt/utmp/codeblocks/usr/include -I/mnt/utmp/codeblocks/usr/include/SDL -D_GNU_SOURCE=1 -D_REENTRANT -pthread -Wall -Wextra -Wno-invalid-offsetof -Wredundant-decls -Wendif-labels -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -Winit-self -Wsign-promo -Wunsafe-loop-optimizations -Wsign-promo -Wno-parentheses -Wno-unused-parameter -Wno-inline -Wno-reorder -Wno-float-equal -Wno-switch -Winvalid-pch -fpch-deps -Ofast -pipe -mcpu=cortex-a8 -mfpu=neon -ftree-vectorize -mfloat-abi=softfp -march=armv7-a -fsingle-precision-constant -mno-unaligned-access -fpermissive -x c++-header -MT C4Include.h.gch -MD -MP -MF $depbase.Tpo -c -o C4Include.h.gch engine/inc/C4Include.h &&\
mv -f $depbase.Tpo $depbase.Po
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function 'StdBuf StdBuf::getPart(size_t, size_t) const':
./standard/inc/StdBuf.h:87:41: error: no matching function for call to 'StdBuf::StdBuf(StdBuf)'
return StdBuf(getPtr(iStart), inSize);
^
./standard/inc/StdBuf.h:87:41: note: candidates are:
./standard/inc/StdBuf.h:43:3: note: StdBuf::StdBuf(const void*, size_t, bool)
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
^
./standard/inc/StdBuf.h:43:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:31:3: note: StdBuf::StdBuf(StdBuf&, bool)
StdBuf(StdBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:31:3: note: no known conversion for argument 1 from 'StdBuf' to 'StdBuf&'
./standard/inc/StdBuf.h:26:3: note: StdBuf::StdBuf()
StdBuf() : fRef(true), pData(NULL), iSize(0) { }
^
./standard/inc/StdBuf.h:26:3: note: candidate expects 0 arguments, 1 provided
./standard/inc/StdBuf.h: In member function 'StdBuf StdBuf::getRef() const':
./standard/inc/StdBuf.h:250:37: error: no matching function for call to 'StdBuf::StdBuf(StdBuf)'
return StdBuf(getData(), getSize());
^
./standard/inc/StdBuf.h:250:37: note: candidates are:
./standard/inc/StdBuf.h:43:3: note: StdBuf::StdBuf(const void*, size_t, bool)
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
^
./standard/inc/StdBuf.h:43:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:31:3: note: StdBuf::StdBuf(StdBuf&, bool)
StdBuf(StdBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:31:3: note: no known conversion for argument 1 from 'StdBuf' to 'StdBuf&'
./standard/inc/StdBuf.h:26:3: note: StdBuf::StdBuf()
StdBuf() : fRef(true), pData(NULL), iSize(0) { }
^
./standard/inc/StdBuf.h:26:3: note: candidate expects 0 arguments, 1 provided
./standard/inc/StdBuf.h: In member function 'StdBuf StdBuf::eek:perator+(const StdBuf&) const':
./standard/inc/StdBuf.h:274:24: error: no matching function for call to 'StdBuf::StdBuf(StdBuf)'
StdBuf Buf(getRef());
^
./standard/inc/StdBuf.h:274:24: note: candidates are:
./standard/inc/StdBuf.h:43:3: note: StdBuf::StdBuf(const void*, size_t, bool)
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
^
./standard/inc/StdBuf.h:43:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:31:3: note: StdBuf::StdBuf(StdBuf&, bool)
StdBuf(StdBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:31:3: note: no known conversion for argument 1 from 'StdBuf' to 'StdBuf&'
./standard/inc/StdBuf.h:26:3: note: StdBuf::StdBuf()
StdBuf() : fRef(true), pData(NULL), iSize(0) { }
^
./standard/inc/StdBuf.h:26:3: note: candidate expects 0 arguments, 1 provided
./standard/inc/StdBuf.h: In constructor 'StdCopyBuf::StdCopyBuf(const StdBuf&, bool)':
./standard/inc/StdBuf.h:332:34: error: no matching function for call to 'StdBuf::StdBuf(StdBuf, bool&)'
: StdBuf(Buf2.getRef(), fCopy)
^
./standard/inc/StdBuf.h:332:34: note: candidates are:
./standard/inc/StdBuf.h:43:3: note: StdBuf::StdBuf(const void*, size_t, bool)
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
^
./standard/inc/StdBuf.h:43:3: note: no known conversion for argument 1 from 'StdBuf' to 'const void*'
./standard/inc/StdBuf.h:31:3: note: StdBuf::StdBuf(StdBuf&, bool)
StdBuf(StdBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:31:3: note: no known conversion for argument 1 from 'StdBuf' to 'StdBuf&'
./standard/inc/StdBuf.h:26:3: note: StdBuf::StdBuf()
StdBuf() : fRef(true), pData(NULL), iSize(0) { }
^
./standard/inc/StdBuf.h:26:3: note: candidate expects 0 arguments, 2 provided
./standard/inc/StdBuf.h: In copy constructor 'StdCopyBuf::StdCopyBuf(const StdCopyBuf&, bool)':
./standard/inc/StdBuf.h:337:34: error: no matching function for call to 'StdBuf::StdBuf(StdBuf, bool&)'
: StdBuf(Buf2.getRef(), fCopy)
^
./standard/inc/StdBuf.h:337:34: note: candidates are:
./standard/inc/StdBuf.h:43:3: note: StdBuf::StdBuf(const void*, size_t, bool)
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
^
./standard/inc/StdBuf.h:43:3: note: no known conversion for argument 1 from 'StdBuf' to 'const void*'
./standard/inc/StdBuf.h:31:3: note: StdBuf::StdBuf(StdBuf&, bool)
StdBuf(StdBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:31:3: note: no known conversion for argument 1 from 'StdBuf' to 'StdBuf&'
./standard/inc/StdBuf.h:26:3: note: StdBuf::StdBuf()
StdBuf() : fRef(true), pData(NULL), iSize(0) { }
^
./standard/inc/StdBuf.h:26:3: note: candidate expects 0 arguments, 2 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function 'StdStrBuf StdStrBuf::getRef() const':
./standard/inc/StdBuf.h:403:68: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
StdStrBuf getRef() const { return StdStrBuf(getData(), getLength()); }
^
./standard/inc/StdBuf.h:403:68: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function 'StdStrBuf StdStrBuf::eek:perator+(const StdStrBuf&) const':
./standard/inc/StdBuf.h:480:79: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
StdStrBuf operator + (const StdStrBuf &Buf2) const { StdStrBuf Buf = getRef(); Buf.Append(Buf2); return Buf; }
^
./standard/inc/StdBuf.h:480:79: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function 'StdStrBuf StdStrBuf::eek:perator+(const char*) const':
./standard/inc/StdBuf.h:481:78: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
StdStrBuf operator + (const char *szString) const { StdStrBuf Buf = getRef(); Buf.Append(szString); return Buf; }
^
./standard/inc/StdBuf.h:481:78: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function 'bool StdStrBuf::SplitAtChar(char, StdStrBuf*)':
./standard/inc/StdBuf.h:552:72: warning: invalid user-defined conversion from 'StdStrBuf' to 'char*' [-fpermissive]
if (psSplit) psSplit->Take(copyPart(iPos + 1, getLength() - iPos - 1));
^
./standard/inc/StdBuf.h:497:3: note: candidate is: StdStrBuf::eek:perator const void*() const <near match>
operator const void *() const { return getData(); }
^
./standard/inc/StdBuf.h:497:3: note: no known conversion for implicit 'this' parameter from 'const void*' to 'char*'
./standard/inc/StdBuf.h: In member function 'StdStrBuf StdStrBuf::copyPart(size_t, size_t) const':
./standard/inc/StdBuf.h:565:33: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
if (!inSize) return StdStrBuf();
^
./standard/inc/StdBuf.h:565:33: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In constructor 'StdCopyStrBuf::StdCopyStrBuf(const StdStrBuf&, bool)':
./standard/inc/StdBuf.h:619:55: error: invalid static_cast from type 'StdStrBuf' to type 'StdStrBuf&'
: StdStrBuf(static_cast<StdStrBuf &>(Buf2.getRef()), fCopy)
^
./standard/inc/StdBuf.h: In copy constructor 'StdCopyStrBuf::StdCopyStrBuf(const StdCopyStrBuf&, bool)':
./standard/inc/StdBuf.h:623:55: error: invalid static_cast from type 'StdStrBuf' to type 'StdStrBuf&'
: StdStrBuf(static_cast<StdStrBuf &>(Buf2.getRef()), fCopy)
^
In file included from ./standard/inc/Fixed.h:22:0,
from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h: In member function 'virtual StdStrBuf StdCompiler::getPosition() const':
./standard/inc/StdCompiler.h:139:63: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
virtual StdStrBuf getPosition() const { return StdStrBuf(); }
^
./standard/inc/StdCompiler.h:139:63: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h: In member function 'void StdCompiler::excNotFound(const char*, ...)':
./standard/inc/StdCompiler.h:229:76: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
throw new NotFoundException(getPosition(), FormatStringV(szMessage, args));
^
./standard/inc/StdCompiler.h:229:76: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h:207:3: error: initializing argument 1 of 'StdCompiler::NotFoundException::NotFoundException(StdStrBuf, StdStrBuf)'
NotFoundException(StdStrBuf Pos, StdStrBuf Msg) : Exception(Pos, Msg) { }
^
./standard/inc/StdCompiler.h: In member function 'void StdCompiler::excEOF(const char*, ...)':
./standard/inc/StdCompiler.h:235:71: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
throw new EOFException(getPosition(), FormatStringV(szMessage, args));
^
./standard/inc/StdCompiler.h:235:71: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h:212:3: error: initializing argument 1 of 'StdCompiler::EOFException::EOFException(StdStrBuf, StdStrBuf)'
EOFException(StdStrBuf Pos, StdStrBuf Msg) : Exception(Pos, Msg) { }
^
./standard/inc/StdCompiler.h: In member function 'void StdCompiler::excCorrupt(const char*, ...)':
./standard/inc/StdCompiler.h:241:75: error: no matching function for call to 'StdStrBuf::StdStrBuf(StdStrBuf)'
throw new CorruptException(getPosition(), FormatStringV(szMessage, args));
^
./standard/inc/StdCompiler.h:241:75: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:372:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
^
./standard/inc/StdBuf.h:372:3: note: candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:362:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
^
./standard/inc/StdBuf.h:362:3: note: no known conversion for argument 1 from 'StdStrBuf' to 'StdStrBuf&'
./standard/inc/StdBuf.h:357:2: note: StdStrBuf::StdStrBuf()
StdStrBuf()
^
./standard/inc/StdBuf.h:357:2: note: candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h:217:3: error: initializing argument 1 of 'StdCompiler::CorruptException::CorruptException(StdStrBuf, StdStrBuf)'
CorruptException(StdStrBuf Pos, StdStrBuf Msg) : Exception(Pos, Msg) { }
^
In file included from ./standard/inc/StdDDraw2.h:9:0,
from engine/inc/C4Include.h:77:
./standard/inc/StdSurface2.h: In member function 'void CTexRef::SetPix2(int, int, WORD)':
./standard/inc/StdSurface2.h:309:105: warning: cast from 'BYTE* {aka unsigned char*}' to 'WORD* {aka short unsigned int*}' increases required alignment of target type [-Wcast-align]
*((WORD *) (((BYTE *) texLock.pBits) + (iY - LockSize.top) * texLock.Pitch + (iX - LockSize.left) * 2)) = v;
^
./standard/inc/StdSurface2.h: In member function 'void CTexRef::SetPix4(int, int, DWORD)':
./standard/inc/StdSurface2.h:313:106: warning: cast from 'BYTE* {aka unsigned char*}' to 'DWORD* {aka unsigned int*}' increases required alignment of target type [-Wcast-align]
*((DWORD *) (((BYTE *) texLock.pBits) + (iY - LockSize.top) * texLock.Pitch + (iX - LockSize.left) * 4)) = v;
^
In file included from engine/inc/C4Include.h:82:0:
./standard/inc/StdPNG.h: In member function 'const uint32_t* CPNGFile::GetRow(int)':
./standard/inc/StdPNG.h:47:62: warning: cast from 'BYTE* {aka unsigned char*}' to 'uint32_t* {aka unsigned int*}' increases required alignment of target type [-Wcast-align]
return reinterpret_cast<uint32_t *>(pImageData+iY*iRowSize);
^
make: *** [C4Include.h.gch] Error 1
this is the output of make and here is how I ran configure:

Code:
./configure 'CXX=g++' '--with-internal-libpng' --prefix=/mnt/utmp/codeblocks/usr LIBS="-lGL -lGLU"
CXXFLAGS="-O3 -g -finline-functions -mcpu=cortex-a8 -mfpu=neon -mfloat-abi=softfp 
-ffast-math -DBIG_C4INCLUDE"
thanks a lot for trying to help ptitSeb! and thanks for all those great ports and releases!
 
Last edited by a moderator:
Yep, use spoilers.

About the error: it's not link error, it's C++ error.

Either try to add some c++ standard (like -std=c++99) or add the missing constructor yourself (should be mostly copy/paste).
 
Last edited by a moderator:
Okay this is beyond my skills. I tried passing -std=c++98 and different dialect options via configure as CXXFLAGS and it still gives the same error. The readme in the source code recommends g++-4.1...

If someone could explain to me where I need to add to/change the code to make it compilable that would be awesome. I spent a couple of hours looking a different options that I can pass as CXXFLAGS, then I tried to figure out what could be wrong about the construction of these classes but I am too much of a noob.

// Standard buffer classes

#ifndef STDBUF_H
#define STDBUF_H

#include <zlib.h>
#include "Standard.h"

#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>

// debug memory management
#if defined(_DEBUG) && defined(_MSC_VER)
#include <crtdbg.h>
#endif

// Base buffer class. Either references or holds data.
class StdBuf
{
public:

// *** Construction
// Standard constructor
StdBuf() : fRef(true), pData(NULL), iSize(0) { }


// Constructor from other buffer (copy construction):
// Will take over buffer ownership. Copies data if specified.
// Note: Construct with Buf2.getRef() to construct a reference (This will work for a constant Buf2, too)
StdBuf(StdBuf &Buf2, bool fCopy = false)
: fRef(true), pData(NULL), iSize(0)
{
if(fCopy)
Copy(Buf2);
else if(!Buf2.isRef())
Take(Buf2);
else
Ref(Buf2);
}

// Set by constant data. Copies data if desired.
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
: fRef(true), pData(pData), iSize(iSize)
{
if(fCopy) Copy();
}

~StdBuf()
{
Clear();
}

ALLOW_TEMP_TO_REF(StdBuf)

protected:

// Reference? Otherwise, this object holds the data.
bool fRef;
// Data
union
{
const void *pData;
void *pMData;
#if defined(_DEBUG)
char *szString; // for debugger preview
#endif
};
size_t iSize;

public:

// *** Getters

bool isNull() const { return ! getData(); }
const void *getData() const { return fRef ? pData : pMData; }
void *getMData() { assert(!fRef); return pMData; }
size_t getSize() const { return iSize; }
bool isRef() const { return fRef; }

const void *getPtr(size_t i) const { return reinterpret_cast<const char*>(getData()) + i; }
void *getMPtr(size_t i) { return reinterpret_cast<char*>(getMData()) + i; }

StdBuf getPart(size_t iStart, size_t inSize) const
{
assert(iStart + inSize <= iSize);
return StdBuf(getPtr(iStart), inSize);
}

// *** Setters

// * Direct setters

// Reference given data
void Ref(const void *pnData, size_t inSize)
{
Clear();
fRef = true; pData = pnData; iSize = inSize;
}
// Take over data (hold it)
void Take(void *pnData, size_t inSize)
{
Clear();
if(pnData)
{
fRef = false; pMData = pnData; iSize = inSize;
}
}
// Transfer puffer ownership to the caller
void *GrabPointer()
{
if(isNull()) return NULL;
// Do not give out a buffer which someone else will free
if (fRef) Copy();
void *pMData = getMData();
pData = pMData; fRef = true;
return pMData;
}

// * Buffer data operations

// Create new buffer with given size
void New(size_t inSize)
{
Clear();
pMData = malloc(iSize = inSize);
fRef = false;
}
// Write data into the buffer
void Write(const void *pnData, size_t inSize, size_t iAt = 0)
{
assert(iAt + inSize <= iSize);
if(pnData && inSize) memcpy(getMPtr(iAt), pnData, inSize);
}
// Move data around inside the buffer (checks overlap)
void Move(size_t iFrom, size_t inSize, size_t iTo = 0)
{
assert(iFrom + inSize <= iSize); assert(iTo + inSize <= iSize);
memmove(getMPtr(iTo), getPtr(iFrom), inSize);
}
// Compare to memory
int Compare(const void *pCData, size_t iCSize, size_t iAt = 0) const
{
assert(iAt + iCSize <= getSize());
return memcmp(getPtr(iAt), pCData, iCSize);
}
// Grow the buffer
void Grow(size_t iGrow)
{
// Grow dereferences
if(fRef) { Copy(iSize + iGrow); return; }
if(!iGrow) return;
// Realloc
pMData = realloc(pMData, iSize += iGrow);
}
// Shrink the buffer
void Shrink(size_t iShrink)
{
assert(iSize >= iShrink);
// Shrink dereferences
if(fRef) { Copy(iSize - iShrink); return; }
if(!iShrink) return;
// Realloc
pMData = realloc(pMData, iSize -= iShrink);
}
// Clear buffer
void Clear()
{
if(!fRef) free(pMData);
pMData = NULL; fRef = true; iSize = 0;
}
// Free buffer that had been grabbed
static void DeletePointer(void *data)
{
free(data);
}

// * Composed actions

// Set buffer size (dereferences)
void SetSize(size_t inSize)
{
if(inSize > iSize)
Grow(inSize - iSize);
else
Shrink(iSize - inSize);
}

// Write buffer contents into the buffer
void Write(const StdBuf &Buf2, size_t iAt = 0)
{
Write(Buf2.getData(), Buf2.getSize(), iAt);
}

// Compare (a part of) this buffer's contents to another's
int Compare(const StdBuf &Buf2, size_t iAt = 0) const
{
return Compare(Buf2.getData(), Buf2.getSize(), iAt);
}

// Create a copy of the data (dereferences, obviously)
void Copy(size_t inSize)
{
if(isNull() && !inSize) return;
const void *pOldData = getData();
size_t iOldSize = iSize;
New(inSize);
Write(pOldData, Min(iOldSize, inSize));
}
void Copy()
{
Copy(iSize);
}
// Copy data from address
void Copy(const void *pnData, size_t inSize)
{
Ref(pnData, inSize); Copy();
}
// Copy from another buffer
void Copy(const StdBuf &Buf2)
{
Copy(Buf2.getData(), Buf2.getSize());
}
// Create a copy and return it
StdBuf Duplicate() const
{
StdBuf Buf; Buf.Copy(*this); return Buf;
}

// Append data from address
void Append(const void *pnData, int inSize)
{
Grow(inSize);
Write(pnData, inSize, iSize - inSize);
}
// Append data from another buffer
void Append(const StdBuf &Buf2)
{
Append(Buf2.getData(), Buf2.getSize());
}

// Reference another buffer's contents
void Ref(const StdBuf &Buf2)
{
Ref(Buf2.getData(), Buf2.getSize());
}
// Create a reference to this buffer's contents
StdBuf getRef() const
{
return StdBuf(getData(), getSize());
}
// take over another buffer's contents
void Take(StdBuf &Buf2)
{
Take(Buf2.GrabPointer(), Buf2.getSize());
}

// * File support
bool LoadFromFile(const char *szFile);
bool SaveToFile(const char *szFile) const;

// *** Operators

// Null check
bool operator ! () const { return isNull(); }

// Appending
StdBuf operator += (const StdBuf &Buf2) {
Append(Buf2);
return *this;
}
StdBuf operator + (const StdBuf &Buf2) const
{
StdBuf Buf(getRef());
Buf.Append(Buf2);
return Buf;
}

// Compare
bool operator == (const StdBuf &Buf2) const
{
return getSize() == Buf2.getSize() && !Compare(Buf2);
}
bool operator != (const StdBuf &Buf2) const { return ! operator == (Buf2); }

// Set (as constructor: take if possible)
StdBuf &operator = (StdBuf &Buf2)
{
if(Buf2.isRef()) Ref(Buf2); else Take(Buf2);
return *this;
}

// build a simple hash
int GetHash() const
{
if(isNull()) return 0;
return crc32(0, reinterpret_cast<const Bytef *>(getData()), getSize());
}

// *** Compiling

void CompileFunc(class StdCompiler *pComp, int iType = 0);

};

// Cast Hide Helpers - MSVC doesn't allow this as member template
template <class elem_t>
const elem_t *getBufPtr(const StdBuf &Buf, size_t iPos = 0)
{
// assert(iPos + sizeof(elem_t) <= Buf.getSize());
const void *pPos = reinterpret_cast<const char *>(Buf.getData()) + iPos;
return reinterpret_cast<const elem_t *>(pPos);
}
template <class elem_t>
elem_t *getMBufPtr(StdBuf &Buf, size_t iPos = 0)
{
// assert(iPos + sizeof(elem_t) <= Buf.getSize());
void *pPos = reinterpret_cast<char *>(Buf.getMData()) + iPos;
return reinterpret_cast<elem_t *>(pPos);
}

// Copy-Buffer - Just copies data in the copy constructor.
class StdCopyBuf : public StdBuf
{
public:

StdCopyBuf()
{ }

// Set by buffer. Copies data by default.
StdCopyBuf(const StdBuf &Buf2, bool fCopy = true)
: StdBuf(Buf2.getRef(), fCopy)
{ }

// Set by buffer. Copies data by default.
StdCopyBuf(const StdCopyBuf &Buf2, bool fCopy = true)
: StdBuf(Buf2.getRef(), fCopy)
{ }

// Set by constant data. Copies data by default.
StdCopyBuf(const void *pData, size_t iSize, bool fCopy = true)
: StdBuf(pData, iSize, fCopy)
{ }

StdCopyBuf &operator = (const StdBuf &Buf2) { Copy(Buf2); return *this; }
StdCopyBuf &operator = (const StdCopyBuf &Buf2) { Copy(Buf2); return *this; }

};

// Stringbuffer (operates on null-terminated character buffers)
class StdStrBuf : protected StdBuf
{
public:

// *** Construction

StdStrBuf()
: StdBuf()
{ }

// See StdBuf::StdBuf. Will take data if possible.
StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
: StdBuf(Buf2, fCopy)
{ }

// Set by constant data. References data by default, copies if specified.
explicit StdStrBuf(const char *pData, bool fCopy = false)
: StdBuf(pData, pData ? strlen(pData) + 1 : 0, fCopy)
{ }

// As previous constructor, but set length manually.
StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
: StdBuf(pData, pData ? iLength + 1 : 0, fCopy)
{ }

ALLOW_TEMP_TO_REF(StdStrBuf)

public:

// *** Getters

bool isNull() const { return StdBuf::isNull(); }
const char *getData() const { return getBufPtr<char>(*this); }
char *getMData() { return getMBufPtr<char>(*this); }
size_t getSize() const { return StdBuf::getSize(); }
size_t getLength() const { return getSize() ? getSize() - 1 : 0; }
bool isRef() const { return StdBuf::isRef(); }

const char *getPtr(size_t i) const { return getBufPtr<char>(*this, i); }
char *getMPtr(size_t i) { return getMBufPtr<char>(*this, i); }

// For convenience. Note that writing can't be allowed.
char operator [] (size_t i) const { return *getPtr(i); }

// Analogous to StdBuf
void Ref(const char *pnData) { StdBuf::Ref(pnData, pnData ? strlen(pnData) + 1 : 0); }
void Ref(const char *pnData, size_t iLength) { assert((!pnData && !iLength) || strlen(pnData) == iLength); StdBuf::Ref(pnData, iLength + 1); }
void Take(char *pnData) { StdBuf::Take(pnData, pnData ? strlen(pnData) + 1 : 0); }
void Take(char *pnData, size_t iLength) { assert((!pnData && !iLength) || strlen(pnData) == iLength); StdBuf::Take(pnData, iLength + 1); }
char *GrabPointer() { return reinterpret_cast<char *>(StdBuf::GrabPointer()); }

void Ref(const StdStrBuf &Buf2) { StdBuf::Ref(Buf2.getData(), Buf2.getSize()); }
StdStrBuf getRef() const { return StdStrBuf(getData(), getLength()); }
void Take(StdStrBuf &Buf2) { StdBuf::Take(Buf2); }

void Clear() { StdBuf::Clear(); }
void Copy() { StdBuf::Copy(); }
void Copy(const char *pnData) { StdBuf::Copy(pnData, pnData ? strlen(pnData) + 1 : 0); }
void Copy(const StdStrBuf &Buf2) { StdBuf::Copy(Buf2); }
StdStrBuf Duplicate() const { StdStrBuf Buf; Buf.Copy(*this); return Buf; }
void Move(size_t iFrom, size_t inSize, size_t iTo = 0) { StdBuf::Move(iFrom, inSize, iTo); }

// Byte-wise compare (will compare characters up to the length of the second string)
int Compare(const StdStrBuf &Buf2, size_t iAt = 0) const
{
assert(iAt <= getLength());
return StdBuf::Compare(Buf2.getData(), Buf2.getLength(), iAt);
}
int Compare_(const char *pCData, size_t iAt = 0) const
{
StdStrBuf str(pCData); // GCC needs this, for some obscure reason
return Compare(str, iAt);
}

// Grows the string to contain the specified number more/less characters.
// Note: Will set the terminator, but won't initialize - use Append* instead.
void Grow(size_t iGrow)
{
StdBuf::Grow(getSize() ? iGrow : iGrow + 1);
*getMPtr(getLength()) = '\0';
}
void Shrink(size_t iShrink)
{
assert(iShrink <= getLength());
StdBuf::Shrink(iShrink);
*getMPtr(getLength()) = '\0';
}
void SetLength(size_t iLength)
{
if(iLength == getLength() && !isNull()) return;
if(iLength >= getLength())
Grow(iLength - getLength());
else
Shrink(getLength() - iLength);
}

// Append string
void Append(const char *pnData, size_t iChars)
{
//assert(iChars <= strlen(pnData));
Grow(iChars);
Write(pnData, iChars, iSize - iChars - 1);
}
void Append(const char *pnData)
{
Append(pnData, strlen(pnData));
}
void Append(const StdStrBuf &Buf2)
{
Append(Buf2.getData(), Buf2.getLength());
}

// Copy string
void Copy(const char *pnData, size_t iChars)
{
Clear();
Append(pnData, iChars);
}

// * File support
bool LoadFromFile(const char *szFile);
bool SaveToFile(const char *szFile) const;

// * Operators

bool operator ! () const { return isNull(); }

StdStrBuf &operator += (const StdStrBuf &Buf2) { Append(Buf2); return *this; }
StdStrBuf &operator += (const char *szString) { Append(szString); return *this; }
StdStrBuf operator + (const StdStrBuf &Buf2) const { StdStrBuf Buf = getRef(); Buf.Append(Buf2); return Buf; }
StdStrBuf operator + (const char *szString) const { StdStrBuf Buf = getRef(); Buf.Append(szString); return Buf; }

bool operator == (const StdStrBuf &Buf2) const
{
return getLength() == Buf2.getLength() && !Compare(Buf2);
}
bool operator != (const StdStrBuf &Buf2) const { return !operator == (Buf2); }

bool operator == (const char *szString) const { return StdStrBuf(szString) == *this; }
bool operator != (const char *szString) const { return ! operator == (szString); }

// Note this references the data.
StdStrBuf &operator = (const StdStrBuf &Buf2) { Ref(Buf2); return *this; }
StdStrBuf &operator = (const char *szString) { Ref(szString); return *this; }

// conversion to "bool"
operator const void *() const { return getData(); }

// less-than operation for map
inline bool operator <(const StdStrBuf &v2)
{
int iLen = getLength(), iLen2 = v2.getLength();
if (iLen == iLen2)
return iLen ? (strcmp(getData(), v2.getData())<0) : false;
else
return iLen < iLen2;
}

// * String specific

void AppendChars(char cChar, size_t iCnt)
{
Grow(iCnt);
for(size_t i = getLength() - iCnt; i < getLength(); i++)
*getMPtr(i) = cChar;
}
void AppendChar(char cChar)
{
AppendChars(cChar, 1);
}
void InsertChar(char cChar, size_t insert_before)
{
assert(insert_before <= getLength());
Grow(1);
for(size_t i = getLength()-1; i > insert_before; --i)
*getMPtr(i) = *getPtr(i-1);
*getMPtr(insert_before) = cChar;
}

// Append data until given character (or string end) occurs.
void AppendUntil(const char *szString, char cUntil)
{
const char *pPos = strchr(szString, cUntil);
if(pPos)
Append(szString, pPos - szString);
else
Append(szString);
}
// See above
void CopyUntil(const char *szString, char cUntil)
{
Clear();
AppendUntil(szString, cUntil);
}
// cut end after given char into another string. Return whether char was found at all
bool SplitAtChar(char cSplit, StdStrBuf *psSplit)
{
if (!getData()) return false;
const char *pPos = strchr(getData(), cSplit);
if (!pPos) return false;
size_t iPos = pPos - getData();
if (psSplit) psSplit->Take(copyPart(iPos + 1, getLength() - iPos - 1));
Shrink(getLength() - iPos);
return true;
}

void Format(const char *szFmt, ...) GNUC_FORMAT_ATTRIBUTE_O;
void FormatV(const char *szFmt, va_list args);
void AppendFormat(const char *szFmt, ...) GNUC_FORMAT_ATTRIBUTE_O;
void AppendFormatV(const char *szFmt, va_list args);

StdStrBuf copyPart(size_t iStart, size_t inSize) const
{
assert(iStart + inSize <= iSize);
if (!inSize) return StdStrBuf();
StdStrBuf sResult;
sResult.Copy(getPtr(iStart), inSize);
return sResult;
}

// replace all occurences of one string with another. Return number of replacements.
int Replace(const char *szOld, const char *szNew, size_t iStartSearch=0);
int ReplaceChar(char cOld, char cNew, size_t iStartSearch=0);

// replace the trailing part of a string with something else
void ReplaceEnd(size_t iPos, const char *szNewEnd);

// get an indexed section from the string like Section1;Section2;Section3
bool GetSection(size_t idx, StdStrBuf *psOutSection, char cSeparator=';') const;

// Checks wether the contents are valid UTF-8, and if not, convert them from windows-1252 to UTF-8.
void EnsureUnicode();

// convert to lower case
void ToLowerCase();

// check if a string consists only of the given chars
bool ValidateChars(const char *szInitialChars, const char *szMidChars);

// build a simple hash
int GetHash() const
{
return StdBuf::GetHash();
}

void EscapeString()
{
Replace("\\", "\\\\");
Replace("\"", "\\\"");
}

bool TrimSpaces(); // kill spaces at beginning and end. Return if changed.

// * Compiling

void CompileFunc(class StdCompiler *pComp, int iRawType = 0);

};

// Copy-Stringbuffer - Just copies data in the copy constructor.
class StdCopyStrBuf : public StdStrBuf
{
public:

StdCopyStrBuf()
{ }

explicit StdCopyStrBuf(const StdStrBuf &Buf2, bool fCopy = true)
: StdStrBuf(static_cast<StdStrBuf &>(Buf2.getRef()), fCopy)
{ }

StdCopyStrBuf(const StdCopyStrBuf &Buf2, bool fCopy = true)
: StdStrBuf(static_cast<StdStrBuf &>(Buf2.getRef()), fCopy)
{ }

// Set by constant data. Copies data if desired.
explicit StdCopyStrBuf(const char *pData, bool fCopy = true)
: StdStrBuf(pData, fCopy)
{ }

StdCopyStrBuf &operator = (const StdStrBuf &Buf2) { Copy(Buf2); return *this; }
StdCopyStrBuf &operator = (const StdCopyStrBuf &Buf2) { Copy(Buf2); return *this; }
StdCopyStrBuf &operator = (const char *szString) { Copy(szString); return *this; }

};

// Wrappers
extern StdStrBuf FormatString(const char *szFmt, ...) GNUC_FORMAT_ATTRIBUTE;
extern StdStrBuf FormatStringV(const char *szFmt, va_list args);

#endif
I am just a little worried that there will be more similar problems with this.

Thanks for having a look! Also: Thanks for adding the spoiler tags TrashyMG!
 
Last edited by a moderator:
lol oh yeah... it says right there in the ammended post ^^ thanks

EDIT: Okay I am reading this http://www.cplusplus.com/doc/tutorial/classes/

and I am beginning to understand what the problem is here. So there needs to be a contructor added to the classes in question that initializes the variables. I will hack away and see if I can figure this out. I suck at programming, never got further than a couple of pages in most tutorials. Maybe it's time to learn some cpp finally.
 
Last edited by a moderator:
Okay I need some help. I do not know how to proceed correctly. I just do not understand what exactly is needed. I am guessing it has something to do with uninitialized variables or something similar, but since I do not understand what the heck is going on in the stdbuf.h file and how to correctly add the needed constructor/init list, there isn't much I can do.

BTW: i tried compiling this on my debain machine at home and it fails with the same message. the source package provides makefiles and vc6/vc7 project files which I was able to import into codeblocks. But building it gives me more errors about some PNG functions. Also it's set up to produce win32 executables and I probably haven't got the correct setup for that target. Maybe I can get somewhere by changing the build target to linux and getting rid of the directx etc flags. If I get the same errors as with make, I am hoping it will be easier to hunt down what's missing using codeblocks IDE. If I can get it to compile on my x86, I will try to cross compile it for pandora.

Please help me and point me in the right direction guys. I picked a project too big for my first port attempt. But I am trying to do it myself. I wish pickle could give me a hint. He already pmd me back but seems to be busy with other stuff and apparently he didn't get very far with his build.
 
Okay I need some help. I do not know how to proceed correctly. I just do not understand what exactly is needed. I am guessing it has something to do with uninitialized variables or something similar, but since I do not understand what the heck is going on in the stdbuf.h file and how to correctly add the needed constructor/init list, there isn't much I can do.

BTW: i tried compiling this on my debain machine at home and it fails with the same message. the source package provides makefiles and vc6/vc7 project files which I was able to import into codeblocks. But building it gives me more errors about some PNG functions. Also it's set up to produce win32 executables and I probably haven't got the correct setup for that target. Maybe I can get somewhere by changing the build target to linux and getting rid of the directx etc flags. If I get the same errors as with make, I am hoping it will be easier to hunt down what's missing using codeblocks IDE. If I can get it to compile on my x86, I will try to cross compile it for pandora.

Please help me and point me in the right direction guys. I picked a project too big for my first port attempt. But I am trying to do it myself. I wish pickle could give me a hint. He already pmd me back but seems to be busy with other stuff and apparently he didn't get very far with his build.
Try to add this constructor (I dodn't tested, so it may fail, or compile but fail later)

Code:
 StdBuf(StdBuf Buf2, bool fCopy = false)
    : fRef(true), pData(NULL), iSize(0)
  {
    if(fCopy)
      Copy(&Buf2);
    else if(!Buf2.isRef()) 
      Take(&Buf2);
    else
      Ref(&Buf2);
  }
 
Last edited by a moderator:
Doesn't do anything. Still fails with same messages but preceded by this new error:

./standard/inc/StdBuf.h:30:40: error: invalid constructor; you probably meant ‘StdBuf (const StdBuf&)’
  StdBuf(StdBuf Buf2, bool fCopy = false) I added your constructor to line 28 of stdbuf.h. Maybe that was wrong? I have no idea what I am doing here...

Complete output of make:

username:~/code/clonkrage$ make
depbase=`echo C4Include.h.gch | sed 's|[^/]*$|.deps/&|;s|\.h.gch$||'`;\
    g++ -DHAVE_CONFIG_H  -I./standard/lpng121 -I. -I./standard -I./standard/zlib -I./standard/inc -I./engine -I./engine/inc -I./engine/sec -DC4ENGINE -DGLEW_STATIC  -I/usr/include/freetype2 -I/usr/include/SDL -D_GNU_SOURCE=1 -D_REENTRANT   -pthread  -Wall -Wextra -Wno-invalid-offsetof -Wredundant-decls -Wendif-labels -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -Winit-self -Wsign-promo -Wunsafe-loop-optimizations -Wsign-promo -Wno-parentheses -Wno-unused-parameter -Wno-inline -Wno-reorder -Wno-float-equal -Wno-switch -Winvalid-pch -fpch-deps  -O3 -finline-functions -ffast-math -DBIG_C4INCLUDE -fdeduce-init-list -std=c++98 -x c++-header -MT C4Include.h.gch -MD -MP -MF $depbase.Tpo -c -o C4Include.h.gch engine/inc/C4Include.h &&\
    mv -f $depbase.Tpo $depbase.Po
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:30:40: error: invalid constructor; you probably meant ‘StdBuf (const StdBuf&)’
  StdBuf(StdBuf Buf2, bool fCopy = false)
                                        ^
./standard/inc/StdBuf.h: In member function ‘StdBuf StdBuf::getPart(size_t, size_t) const’:
./standard/inc/StdBuf.h:100:41: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf)’
     return StdBuf(getPtr(iStart), inSize);
                                         ^
./standard/inc/StdBuf.h:100:41: note: candidates are:
./standard/inc/StdBuf.h:56:3: note: StdBuf::StdBuf(const void*, size_t, bool)
   StdBuf(const void *pData, size_t iSize, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:56:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:44:3: note: StdBuf::StdBuf(StdBuf&, bool)
   StdBuf(StdBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:44:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h:27:2: note: StdBuf::StdBuf()
  StdBuf() : fRef(true), pData(NULL), iSize(0) { }
  ^
./standard/inc/StdBuf.h:27:2: note:   candidate expects 0 arguments, 1 provided
./standard/inc/StdBuf.h: In member function ‘StdBuf StdBuf::getRef() const’:
./standard/inc/StdBuf.h:263:37: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf)’
   return StdBuf(getData(), getSize());
                                     ^
./standard/inc/StdBuf.h:263:37: note: candidates are:
./standard/inc/StdBuf.h:56:3: note: StdBuf::StdBuf(const void*, size_t, bool)
   StdBuf(const void *pData, size_t iSize, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:56:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:44:3: note: StdBuf::StdBuf(StdBuf&, bool)
   StdBuf(StdBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:44:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h:27:2: note: StdBuf::StdBuf()
  StdBuf() : fRef(true), pData(NULL), iSize(0) { }
  ^
./standard/inc/StdBuf.h:27:2: note:   candidate expects 0 arguments, 1 provided
./standard/inc/StdBuf.h: In member function ‘StdBuf StdBuf::eek:perator+(const StdBuf&) const’:
./standard/inc/StdBuf.h:287:24: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf)’
     StdBuf Buf(getRef());
                        ^
./standard/inc/StdBuf.h:287:24: note: candidates are:
./standard/inc/StdBuf.h:56:3: note: StdBuf::StdBuf(const void*, size_t, bool)
   StdBuf(const void *pData, size_t iSize, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:56:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:44:3: note: StdBuf::StdBuf(StdBuf&, bool)
   StdBuf(StdBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:44:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h:27:2: note: StdBuf::StdBuf()
  StdBuf() : fRef(true), pData(NULL), iSize(0) { }
  ^
./standard/inc/StdBuf.h:27:2: note:   candidate expects 0 arguments, 1 provided
./standard/inc/StdBuf.h: In constructor ‘StdCopyBuf::StdCopyBuf(const StdBuf&, bool)’:
./standard/inc/StdBuf.h:345:34: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf, bool&)’
     : StdBuf(Buf2.getRef(), fCopy)
                                  ^
./standard/inc/StdBuf.h:345:34: note: candidates are:
./standard/inc/StdBuf.h:56:3: note: StdBuf::StdBuf(const void*, size_t, bool)
   StdBuf(const void *pData, size_t iSize, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:56:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘const void*’
./standard/inc/StdBuf.h:44:3: note: StdBuf::StdBuf(StdBuf&, bool)
   StdBuf(StdBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:44:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h:27:2: note: StdBuf::StdBuf()
  StdBuf() : fRef(true), pData(NULL), iSize(0) { }
  ^
./standard/inc/StdBuf.h:27:2: note:   candidate expects 0 arguments, 2 provided
./standard/inc/StdBuf.h: In copy constructor ‘StdCopyBuf::StdCopyBuf(const StdCopyBuf&, bool)’:
./standard/inc/StdBuf.h:350:34: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf, bool&)’
     : StdBuf(Buf2.getRef(), fCopy)
                                  ^
./standard/inc/StdBuf.h:350:34: note: candidates are:
./standard/inc/StdBuf.h:56:3: note: StdBuf::StdBuf(const void*, size_t, bool)
   StdBuf(const void *pData, size_t iSize, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:56:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘const void*’
./standard/inc/StdBuf.h:44:3: note: StdBuf::StdBuf(StdBuf&, bool)
   StdBuf(StdBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:44:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h:27:2: note: StdBuf::StdBuf()
  StdBuf() : fRef(true), pData(NULL), iSize(0) { }
  ^
./standard/inc/StdBuf.h:27:2: note:   candidate expects 0 arguments, 2 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function ‘StdStrBuf StdStrBuf::getRef() const’:
./standard/inc/StdBuf.h:416:68: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
  StdStrBuf getRef() const { return StdStrBuf(getData(), getLength()); }
                                                                    ^
./standard/inc/StdBuf.h:416:68: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function ‘StdStrBuf StdStrBuf::eek:perator+(const StdStrBuf&) const’:
./standard/inc/StdBuf.h:493:79: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   StdStrBuf operator + (const StdStrBuf &Buf2) const { StdStrBuf Buf = getRef(); Buf.Append(Buf2); return Buf; }
                                                                               ^
./standard/inc/StdBuf.h:493:79: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function ‘StdStrBuf StdStrBuf::eek:perator+(const char*) const’:
./standard/inc/StdBuf.h:494:78: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   StdStrBuf operator + (const char *szString) const { StdStrBuf Buf = getRef(); Buf.Append(szString); return Buf; }
                                                                              ^
./standard/inc/StdBuf.h:494:78: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In member function ‘bool StdStrBuf::SplitAtChar(char, StdStrBuf*)’:
./standard/inc/StdBuf.h:565:72: error: invalid user-defined conversion from ‘StdStrBuf’ to ‘char*’ [-fpermissive]
   if (psSplit) psSplit->Take(copyPart(iPos + 1, getLength() - iPos - 1));
                                                                        ^
./standard/inc/StdBuf.h:510:3: note: candidate is: StdStrBuf::eek:perator const void*() const <near match>
   operator const void *() const { return getData(); }
   ^
./standard/inc/StdBuf.h:510:3: note:   no known conversion for implicit ‘this’ parameter from ‘const void*’ to ‘char*’
./standard/inc/StdBuf.h: In member function ‘StdStrBuf StdStrBuf::copyPart(size_t, size_t) const’:
./standard/inc/StdBuf.h:578:33: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   if (!inSize) return StdStrBuf();
                                 ^
./standard/inc/StdBuf.h:578:33: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In constructor ‘StdCopyStrBuf::StdCopyStrBuf(const StdStrBuf&, bool)’:
./standard/inc/StdBuf.h:632:55: error: invalid static_cast from type ‘StdStrBuf’ to type ‘StdStrBuf&’
     : StdStrBuf(static_cast<StdStrBuf &>(Buf2.getRef()), fCopy)
                                                       ^
./standard/inc/StdBuf.h: In copy constructor ‘StdCopyStrBuf::StdCopyStrBuf(const StdCopyStrBuf&, bool)’:
./standard/inc/StdBuf.h:636:55: error: invalid static_cast from type ‘StdStrBuf’ to type ‘StdStrBuf&’
     : StdStrBuf(static_cast<StdStrBuf &>(Buf2.getRef()), fCopy)
                                                       ^
In file included from ./standard/inc/Fixed.h:22:0,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h: In member function ‘virtual StdStrBuf StdCompiler::getPosition() const’:
./standard/inc/StdCompiler.h:139:63: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
  virtual StdStrBuf getPosition()     const { return StdStrBuf(); }
                                                               ^
./standard/inc/StdCompiler.h:139:63: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h: In member function ‘void StdCompiler::excNotFound(const char*, ...)’:
./standard/inc/StdCompiler.h:229:76: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   throw new NotFoundException(getPosition(), FormatStringV(szMessage, args));
                                                                            ^
./standard/inc/StdCompiler.h:229:76: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h:207:3: error:   initializing argument 1 of ‘StdCompiler::NotFoundException::NotFoundException(StdStrBuf, StdStrBuf)’
   NotFoundException(StdStrBuf Pos, StdStrBuf Msg) : Exception(Pos, Msg) { }  
   ^
./standard/inc/StdCompiler.h: In member function ‘void StdCompiler::excEOF(const char*, ...)’:
./standard/inc/StdCompiler.h:235:71: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   throw new EOFException(getPosition(), FormatStringV(szMessage, args));
                                                                       ^
./standard/inc/StdCompiler.h:235:71: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h:212:3: error:   initializing argument 1 of ‘StdCompiler::EOFException::EOFException(StdStrBuf, StdStrBuf)’
   EOFException(StdStrBuf Pos, StdStrBuf Msg) : Exception(Pos, Msg)  { }  
   ^
./standard/inc/StdCompiler.h: In member function ‘void StdCompiler::excCorrupt(const char*, ...)’:
./standard/inc/StdCompiler.h:241:75: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   throw new CorruptException(getPosition(), FormatStringV(szMessage, args));
                                                                           ^
./standard/inc/StdCompiler.h:241:75: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./standard/inc/Fixed.h:22:0,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdCompiler.h:217:3: error:   initializing argument 1 of ‘StdCompiler::CorruptException::CorruptException(StdStrBuf, StdStrBuf)’
   CorruptException(StdStrBuf Pos, StdStrBuf Msg) : Exception(Pos, Msg) { }  
   ^
In file included from ./engine/inc/C4Network2IRC.h:6:0,
                 from engine/inc/C4Application.h:12,
                 from engine/inc/C4Include.h:104:
./engine/inc/C4NetIO.h: In member function ‘StdBuf C4NetIOPacket::getPBuf() const’:
./engine/inc/C4NetIO.h:149:88: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf)’
   StdBuf      getPBuf()  const { return getSize() ? getPart(1, getSize() - 1) : getRef(); }
                                                                                        ^
./engine/inc/C4NetIO.h:149:88: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:56:3: note: StdBuf::StdBuf(const void*, size_t, bool)
   StdBuf(const void *pData, size_t iSize, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:56:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:44:3: note: StdBuf::StdBuf(StdBuf&, bool)
   StdBuf(StdBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:44:3: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h:27:2: note: StdBuf::StdBuf()
  StdBuf() : fRef(true), pData(NULL), iSize(0) { }
  ^
./standard/inc/StdBuf.h:27:2: note:   candidate expects 0 arguments, 1 provided
In file included from ./engine/inc/C4Network2IRC.h:6:0,
                 from engine/inc/C4Application.h:12,
                 from engine/inc/C4Include.h:104:
./engine/inc/C4NetIO.h: In member function ‘C4NetIOPacket C4NetIOPacket::getRef() const’:
./engine/inc/C4NetIO.h:152:76: error: no matching function for call to ‘C4NetIOPacket::C4NetIOPacket(StdBuf, const addr_t&)’
  C4NetIOPacket getRef() const { return C4NetIOPacket(StdBuf::getRef(), addr); }
                                                                            ^
./engine/inc/C4NetIO.h:152:76: note: candidates are:
./engine/inc/C4NetIO.h:133:2: note: C4NetIOPacket::C4NetIOPacket(uint8_t, const char*, size_t, const addr_t&)
  C4NetIOPacket(uint8_t cStatusByte, const char *pnData, size_t inSize, const C4NetIO::addr_t &naddr = C4NetIO::addr_t());
  ^
./engine/inc/C4NetIO.h:133:2: note:   candidate expects 4 arguments, 2 provided
./engine/inc/C4NetIO.h:131:11: note: C4NetIOPacket::C4NetIOPacket(StdBuf&, const addr_t&)
  explicit C4NetIOPacket(StdBuf &Buf, const C4NetIO::addr_t &naddr = C4NetIO::addr_t());
           ^
./engine/inc/C4NetIO.h:131:11: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./engine/inc/C4NetIO.h:129:2: note: C4NetIOPacket::C4NetIOPacket(const void*, size_t, bool, const addr_t&)
  C4NetIOPacket(const void *pnData, size_t inSize, bool fCopy = false, const C4NetIO::addr_t &naddr = C4NetIO::addr_t());
  ^
./engine/inc/C4NetIO.h:129:2: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘const void*’
./engine/inc/C4NetIO.h:126:2: note: C4NetIOPacket::C4NetIOPacket()
  C4NetIOPacket();
  ^
./engine/inc/C4NetIO.h:126:2: note:   candidate expects 0 arguments, 2 provided
./engine/inc/C4NetIO.h:122:7: note: C4NetIOPacket::C4NetIOPacket(const C4NetIOPacket&)
 class C4NetIOPacket : public StdCopyBuf
       ^
./engine/inc/C4NetIO.h:122:7: note:   candidate expects 1 argument, 2 provided
./engine/inc/C4NetIO.h: In member function ‘C4NetIOPacket C4NetIOPacket::Duplicate() const’:
./engine/inc/C4NetIO.h:153:83: error: no matching function for call to ‘C4NetIOPacket::C4NetIOPacket(StdBuf, const addr_t&)’
  C4NetIOPacket Duplicate() const  { return C4NetIOPacket(StdBuf::Duplicate(), addr); }
                                                                                   ^
./engine/inc/C4NetIO.h:153:83: note: candidates are:
./engine/inc/C4NetIO.h:133:2: note: C4NetIOPacket::C4NetIOPacket(uint8_t, const char*, size_t, const addr_t&)
  C4NetIOPacket(uint8_t cStatusByte, const char *pnData, size_t inSize, const C4NetIO::addr_t &naddr = C4NetIO::addr_t());
  ^
./engine/inc/C4NetIO.h:133:2: note:   candidate expects 4 arguments, 2 provided
./engine/inc/C4NetIO.h:131:11: note: C4NetIOPacket::C4NetIOPacket(StdBuf&, const addr_t&)
  explicit C4NetIOPacket(StdBuf &Buf, const C4NetIO::addr_t &naddr = C4NetIO::addr_t());
           ^
./engine/inc/C4NetIO.h:131:11: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘StdBuf&’
./engine/inc/C4NetIO.h:129:2: note: C4NetIOPacket::C4NetIOPacket(const void*, size_t, bool, const addr_t&)
  C4NetIOPacket(const void *pnData, size_t inSize, bool fCopy = false, const C4NetIO::addr_t &naddr = C4NetIO::addr_t());
  ^
./engine/inc/C4NetIO.h:129:2: note:   no known conversion for argument 1 from ‘StdBuf’ to ‘const void*’
./engine/inc/C4NetIO.h:126:2: note: C4NetIOPacket::C4NetIOPacket()
  C4NetIOPacket();
  ^
./engine/inc/C4NetIO.h:126:2: note:   candidate expects 0 arguments, 2 provided
./engine/inc/C4NetIO.h:122:7: note: C4NetIOPacket::C4NetIOPacket(const C4NetIOPacket&)
 class C4NetIOPacket : public StdCopyBuf
       ^
./engine/inc/C4NetIO.h:122:7: note:   candidate expects 1 argument, 2 provided
In file included from engine/inc/C4Include.h:105:0:
engine/inc/C4Aul.h: At global scope:
engine/inc/C4Aul.h:239:41: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
  void dump(StdStrBuf Dump = StdStrBuf(""));
                                         ^
engine/inc/C4Aul.h:239:41: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4ChatDlg.h:7:0,
                 from engine/inc/C4Include.h:106:
engine/inc/C4Gui.h: In member function ‘virtual C4GUI::Control* C4GUI::TextWindow::IsFocusElement()’:
engine/inc/C4Gui.h:1618:47: warning: converting ‘false’ to pointer type ‘C4GUI::Control*’ [-Wconversion-null]
    virtual Control *IsFocusElement() { return false; }; // no focus element for now, because there's nothing to do (2do: scroll?)
                                               ^
In file included from engine/inc/C4ChatDlg.h:7:0,
                 from engine/inc/C4Include.h:106:
engine/inc/C4Gui.h: In member function ‘const StdStrBuf C4GUI::ComboBox::GetText()’:
engine/inc/C4Gui.h:1895:60: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
    const StdStrBuf GetText() { return StdStrBuf(Text, false); }
                                                            ^
engine/inc/C4Gui.h:1895:60: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4Network2Res.h:46:0,
                 from engine/inc/C4PlayerInfo.h:22,
                 from engine/inc/C4Control.h:10,
                 from engine/inc/C4EditCursor.h:9,
                 from engine/inc/C4Console.h:11,
                 from engine/inc/C4Include.h:112:
engine/inc/C4Network2IO.h: At global scope:
engine/inc/C4Network2IO.h:411:29: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
  const uint32_t getConnID() const { return iConnID; }
                             ^
engine/inc/C4Network2IO.h:412:34: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
  const uint32_t getPacketCount() const { return iPacketCount; }
                                  ^
In file included from ./engine/inc/C4Network2Reference.h:13:0,
                 from engine/inc/C4Game.h:43,
                 from engine/inc/C4Console.h:12,
                 from engine/inc/C4Include.h:112:
./engine/inc/C4GameVersion.h: In member function ‘StdStrBuf C4GameVersion::GetString() const’:
./engine/inc/C4GameVersion.h:20:138: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
   { return FormatString("%s %d.%d.%d.%d [%d]", sEngineName.getData(), (int)iVer[0], (int)iVer[1], (int)iVer[2], (int)iVer[3], (int)iBuild); }
                                                                                                                                          ^
./engine/inc/C4GameVersion.h:20:138: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4Console.h:12:0,
                 from engine/inc/C4Include.h:112:
engine/inc/C4Game.h: In function ‘StdStrBuf GetKeyboardInputName(const char*, bool, int32_t)’:
engine/inc/C4Game.h:362:77: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
  return Game.KeyboardInput.GetKeyCodeNameByKeyName(szKeyName, fShort, iIndex);
                                                                             ^
engine/inc/C4Game.h:362:77: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4Include.h:150:0:
engine/inc/C4Language.h: In function ‘StdStrBuf LoadResStrUtf8(const char*)’:
engine/inc/C4Language.h:82:46: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdStrBuf)’
  return Languages.IconvUtf8(LoadResStr(ident));
                                              ^
engine/inc/C4Language.h:82:46: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4Include.h:215:0:
engine/inc/C4StartupScenSelDlg.h: At global scope:
engine/inc/C4StartupScenSelDlg.h:62:28: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
     const int GetIconIndex() { return iIconIndex; }
                            ^
engine/inc/C4StartupScenSelDlg.h:63:29: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
     const int GetDifficulty() { return iDifficulty; }
                             ^
engine/inc/C4StartupScenSelDlg.h:64:30: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
     const int GetFolderIndex() { return iFolderIndex; }
                              ^
engine/inc/C4StartupScenSelDlg.h: In member function ‘virtual StdStrBuf C4ScenarioListLoader::Scenario::GetTypeName()’:
engine/inc/C4StartupScenSelDlg.h:113:97: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdCopyStrBuf)’
     virtual StdStrBuf GetTypeName() { return StdCopyStrBuf(LoadResStr("IDS_TYPE_SCENARIO"), true); }
                                                                                                 ^
engine/inc/C4StartupScenSelDlg.h:113:97: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdCopyStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4Include.h:215:0:
engine/inc/C4StartupScenSelDlg.h: In member function ‘virtual StdStrBuf C4ScenarioListLoader::SubFolder::GetTypeName()’:
engine/inc/C4StartupScenSelDlg.h:167:95: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdCopyStrBuf)’
     virtual StdStrBuf GetTypeName() { return StdCopyStrBuf(LoadResStr("IDS_TYPE_FOLDER"), true); }
                                                                                               ^
engine/inc/C4StartupScenSelDlg.h:167:95: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdCopyStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
In file included from engine/inc/C4Include.h:215:0:
engine/inc/C4StartupScenSelDlg.h: In member function ‘virtual StdStrBuf C4ScenarioListLoader::RegularFolder::GetTypeName()’:
engine/inc/C4StartupScenSelDlg.h:181:98: error: no matching function for call to ‘StdStrBuf::StdStrBuf(StdCopyStrBuf)’
     virtual StdStrBuf GetTypeName() { return StdCopyStrBuf(LoadResStr("IDS_TYPE_DIRECTORY"), true); }
                                                                                                  ^
engine/inc/C4StartupScenSelDlg.h:181:98: note: candidates are:
In file included from ./standard/inc/StdCompiler.h:5:0,
                 from ./standard/inc/Fixed.h:22,
                 from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h:385:3: note: StdStrBuf::StdStrBuf(const char*, size_t, bool)
   StdStrBuf(const char *pData, size_t iLength, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:385:3: note:   candidate expects 3 arguments, 1 provided
./standard/inc/StdBuf.h:375:3: note: StdStrBuf::StdStrBuf(StdStrBuf&, bool)
   StdStrBuf(StdStrBuf &Buf2, bool fCopy = false)
   ^
./standard/inc/StdBuf.h:375:3: note:   no known conversion for argument 1 from ‘StdCopyStrBuf’ to ‘StdStrBuf&’
./standard/inc/StdBuf.h:370:2: note: StdStrBuf::StdStrBuf()
  StdStrBuf()
  ^
./standard/inc/StdBuf.h:370:2: note:   candidate expects 0 arguments, 1 provided
make: *** [C4Include.h.gch] Fehler 1

Here is the stdbuf.h with added code:

Code:
// Standard buffer classes

#ifndef STDBUF_H
#define STDBUF_H

#include <zlib.h>
#include "Standard.h"

#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>

// debug memory management
#if defined(_DEBUG) && defined(_MSC_VER)
#include <crtdbg.h>
#endif
using namespace std;

// Base buffer class. Either references or holds data.
class StdBuf
{
public:

  // *** Construction
  // Standard constructor
 StdBuf() : fRef(true), pData(NULL), iSize(0) { }
 
 //code by ptitSeb
 StdBuf(StdBuf Buf2, bool fCopy = false)
    : fRef(true), pData(NULL), iSize(0)
  {
    if(fCopy)
      Copy(&Buf2);
    else if(!Buf2.isRef())
      Take(&Buf2);
    else
      Ref(&Buf2);
  }

  // Constructor from other buffer (copy construction):
  // Will take over buffer ownership. Copies data if specified.
  // Note: Construct with Buf2.getRef() to construct a reference (This will work for a constant Buf2, too)
  StdBuf(StdBuf &Buf2, bool fCopy = false)
------------------------------------------------------------------------
 
Last edited by a moderator:
Hum...

Placement seems ok. Try this one instead?:

Code:
 StdBuf(const StdBuf &Buf2)
    : fRef(true), pData(NULL), iSize(0)
  {
    if(!Buf2.isRef()) 
      Take(Buf2);
    else
      Ref(Buf2);
  }
 
Last edited by a moderator:
This solved the compile error but shortly after something else is awry:

Code:
In file included from ./standard/inc/StdCompiler.h:5:0,
from ./standard/inc/Fixed.h:22,
from engine/inc/C4Include.h:72:
./standard/inc/StdBuf.h: In copy constructor ‘StdBuf::StdBuf(const StdBuf&)’:
./standard/inc/StdBuf.h:34:16: error: no matching function for call to ‘StdBuf::Take(const StdBuf&)’
Take(Buf2);
^
./standard/inc/StdBuf.h:34:16: note: candidates are:
./standard/inc/StdBuf.h:112:8: note: void StdBuf::Take(void*, size_t)
void Take(void *pnData, size_t inSize)
^
./standard/inc/StdBuf.h:112:8: note: candidate expects 2 arguments, 1 provided
./standard/inc/StdBuf.h:264:8: note: void StdBuf::Take(StdBuf&)
void Take(StdBuf &Buf2)
^
./standard/inc/StdBuf.h:264:8: note: no known conversion for argument 1 from ‘const StdBuf’ to ‘StdBuf&’
./standard/inc/StdBuf.h: In constructor ‘StdCopyBuf::StdCopyBuf(const StdBuf&, bool)’:
./standard/inc/StdBuf.h:343:34: error: no matching function for call to ‘StdBuf::StdBuf(StdBuf, bool&)’
: StdBuf(Buf2.getRef(), fCopy)
^
./standard/inc/StdBuf.h:343:34: note: candidates are:
./standard/inc/StdBuf.h:54:3: note: StdBuf::StdBuf(const void*, size_t, bool)
StdBuf(const void *pData, size_t iSize, bool fCopy = false)
 
Last edited by a moderator:
Try to remove the "const" in the new constructor. If it doesn't work, you'll have to create a handfull of other "const" function, like

Code:
void Take(const StdBuf &Buf2)
  {
    Take(Buf2.GrabPointer(), Buf2.getSize());
  }
 
 void *GrabPointer() const
{
if(isNull()) return NULL;
// Do not give out a buffer which someone else will free
if (fRef) Copy();
void *pMData = getMData();
pData = pMData; fRef = true;
return pMData;
}
 
 
Last edited by a moderator:
Sorry for grave digging, but this game is just too awesome. It is now fully freeware. Everything is unlocked, not sure about online play though but I think it should work as you would host the game yourself anyway. Servers were only there for game stats IIRC.

Anyone care to try porting this? I have pretty much given up on doing this myself, but I would glady help out resizing images and whatever. It's a seriously underrated game that was big in Germany. I guess there is a small international community. If you haven't checked it out, do so on your PC. It's a huge load of fun.
 
I tried building this for the Pandora, but I gave up on both paths I tried. Both are related to the fact that the codebase requires GCC version 4.1, which is fairly old:

First I tried porting the codebase to conform to modern C++ standards so that it could be compiled with a recent GCC or Clang, but the more you fix, the more errors pop up, cascading throughout the entirety of the fairly large codebase... so I gave up on this approach.

Then I tried compiling a GCC 4.1 cross-compiler using crosstool-ng, but it's too old and no longer supported, causing all kinds of issues during the process which I don't know how to fix. Hopefully someone more knowledgeable about cross-compilers and/or GCC than me could successfully pursue this path.

I'd love to help with further development once it actually compiles, so if anyone gets that part done, please post how so we can pitch in :)
 
thanks for trying at least! I tried compiling on my PC again and had the same trouble with gcc-4.1 being required. I have no idea what I did different last time, but I remember this being no problem. Maybe because I tried building it on the pandora first.
 
Back
Top