% Remember to use the lgrind style

\File{buffer.cc},{12:08},{Oct 24 1996}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Copyright (C) 1993}}
\L{\LB{_\*}}
\L{\LB{_\* Department of Computing Science,}}
\L{\LB{_\* The University,}}
\L{\LB{_\* Newcastle upon Tyne,}}
\L{\LB{_\* UK.}}
\L{\LB{_\*}}
\L{\LB{_\* \$Id: Buffer.cc,v 1.21 1995\106\128 08:17:16 ngdp Exp \$}}
\L{\LB{_\*}}
\L{\LB{_\* Permission granted to Dean Thompson to use this code for his honours}}
\L{\LB{_\*  thesis titled \"Object Request Broker Data Marshalling Performance\" by}}
\L{\LB{_\*  Professor Santosh Shrivastava on the 15 August 1996.}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\*}}
\L{\LB{_\* Class that implements the marshalling operations for the primitive C types}}
\L{\LB{_\* supported by C++ (with certain obvious exceptions).}}
\L{\LB{_\* The internal char \* buffer is managed internally and will be freed}}
\L{\LB{_\* when the Buffer instance is destroyed REGARDLESS of where it was created.}}
\L{\LB{_\*}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{MEMORY\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{memory}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{STRING\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{string}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{NETINET\_IN\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{netinet}\1\V{in}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{VALUES\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{values}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{LIMITS\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{limits}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{PROTOS\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{protos}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{CTYPE\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{ctype}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{STDLIB\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{stdlib}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{IOSTREAM\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{System}\1\V{iostream}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{ERROR\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{Common}\1\V{Error}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{BUFFER\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\S{}\"Buffer.h\"\SE{}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{UTILITY\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{Common}\1\V{Utility}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{\#ifndef}_\V{RPCBUFFER\_H\_}}}
\L{\LB{\K{\#}__\K{include}_\<\V{StubGen}\1\V{RpcBuffer}.\V{h}\>}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\K{static}_\V{const}_\K{int}_\V{ALIGNMENT}_=_4;}}
\L{\LB{\C{}\1\*}}
\L{\LB{static const char RCSid[\,] = \"\$Id: Buffer.cc,v 1.21 1995\106\128 08:17:16 ngdp Exp \$\";}}
\L{\LB{\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\K{static}_\V{const}_\K{char}_\V{VERSION}[4]_=_\{_\S{}\'\#\'\SE{},_\S{}\'B\'\SE{},_\S{}\'E\'\SE{},_0x1_\};}}
\L{\LB{}}
\L{\LB{\V{const}_\K{unsigned}_\K{short}_\V{TRUE}_=_1;}}
\L{\LB{\V{const}_\K{unsigned}_\K{short}_\V{FALSE}_=_0;}}
\L{\LB{}}
\L{\LB{\C{}\1\* }}
\L{\LB{_\* Public constructors and destructors}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* The following constructor is provided for creating an empty Buffer.}}
\L{\LB{_\* The argument may be used to define the amount of memory allocated}}
\L{\LB{_\* each time extra memory is required - it defaults to the value}}
\L{\LB{_\* in Buffer.h }}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Buffer}::\V{Buffer}_(_\V{size\_t}_\V{buffSize}_)}}
\L{\LB{}\Tab{8}{_______:_\V{shortSize}(\K{sizeof}(\K{unsigned}_\K{short})),}}
\L{\LB{}\Tab{16}{_\V{intSize}(\K{sizeof}(\K{unsigned}_\K{int})),}}
\L{\LB{}\Tab{16}{_\V{longSize}(\K{sizeof}(\K{unsigned}_\K{long})),}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{}\Tab{16}{_\V{longlongSize}(\K{sizeof}(\K{unsigned}_\K{long}_\K{long})),}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{16}{_\V{longlongSize}(0),}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{16}{_\V{buffState}(\V{BUFFER\_GOOD}),}}
\L{\LB{}\Tab{16}{_\V{bufferEnd}(0),}}
\L{\LB{}\Tab{16}{_\V{bufferStart}(0),}}
\L{\LB{}\Tab{16}{_\V{rereadOffset}(0),}}
\L{\LB{}\Tab{16}{_\V{chunkSize}(\V{buffSize}),}}
\L{\LB{}\Tab{16}{_\V{packPoint}(0),}}
\L{\LB{}\Tab{16}{_\V{unpackPoint}(0),}}
\L{\LB{}\Tab{16}{_\V{shouldDelete}(\V{TRUE}),}}
\L{\LB{\Proc{readOnly}}\Tab{16}{_\V{readOnly}(\V{FALSE})}}
\L{\LB{\{}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* The following constructor is provided for creating a Buffer to manage}}
\L{\LB{_\* an existing block of memory, or for creating a Buffer when the size of}}
\L{\LB{_\* the Buffer is known beforehand. If the boolean argument is TRUE then}}
\L{\LB{_\* the char\* buffer is assumed to already contain data. If FALSE then}}
\L{\LB{_\* the size\_t argument defines the size of the EMPTY char\* buffer.}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Buffer}::\V{Buffer}_(_\V{size\_t}_\V{buffSize},_\K{char}_\*\V{buffer},_\V{Boolean}_\V{full},}}
\L{\LB{}\Tab{16}{_\V{Boolean}_\V{shouldDel}_)_}}
\L{\LB{_______________:_\V{shortSize}(\K{sizeof}(\K{unsigned}_\K{short})),}}
\L{\LB{}\Tab{16}{_\V{intSize}(\K{sizeof}(\K{unsigned}_\K{int})),}}
\L{\LB{}\Tab{16}{_\V{longSize}(\K{sizeof}(\K{unsigned}_\K{long})),}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{}\Tab{16}{_\V{longlongSize}(\K{sizeof}(\K{unsigned}_\K{long}_\K{long})),}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{16}{_\V{longlongSize}(0),}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{16}{_\V{buffState}(\V{BUFFER\_GOOD}),}}
\L{\LB{}\Tab{16}{_\V{bufferEnd}(0),}}
\L{\LB{}\Tab{16}{_\V{bufferStart}(0),}}
\L{\LB{}\Tab{16}{_\V{rereadOffset}(0),}}
\L{\LB{}\Tab{16}{_\V{chunkSize}(\V{DEFAULT\_CHUNK\_SIZE}),}}
\L{\LB{}\Tab{16}{_\V{packPoint}(0),}}
\L{\LB{}\Tab{16}{_\V{unpackPoint}(0),}}
\L{\LB{}\Tab{16}{_\V{shouldDelete}(\V{shouldDel}),}}
\L{\LB{\Proc{readOnly}}\Tab{16}{_\V{readOnly}(\V{FALSE})}}
\L{\LB{\{}}
\L{\LB{____\V{setBuffer}(\V{buffSize},_\V{buffer},_\V{full},_\V{shouldDel});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Initialise one buffer from another}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Buffer}::\V{Buffer}_(_\V{const}_\V{Buffer}\&_\V{copyFrom}_)_________________}}
\L{\LB{_______________:_\V{shortSize}(\K{sizeof}(\K{unsigned}_\K{short})),}}
\L{\LB{}\Tab{16}{_\V{intSize}(\K{sizeof}(\K{unsigned}_\K{int})),}}
\L{\LB{}\Tab{16}{_\V{longSize}(\K{sizeof}(\K{unsigned}_\K{long})),}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{}\Tab{16}{_\V{longlongSize}(\K{sizeof}(\K{unsigned}_\K{long}_\K{long})),}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{16}{_\V{longlongSize}(0),}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{16}{_\V{buffState}(\V{BUFFER\_GOOD}),}}
\L{\LB{}\Tab{16}{_\V{bufferEnd}(0),}}
\L{\LB{}\Tab{16}{_\V{bufferStart}(0),}}
\L{\LB{}\Tab{16}{_\V{rereadOffset}(0),}}
\L{\LB{}\Tab{16}{_\V{chunkSize}(0),}}
\L{\LB{}\Tab{16}{_\V{packPoint}(0),}}
\L{\LB{}\Tab{16}{_\V{unpackPoint}(0),}}
\L{\LB{}\Tab{16}{_\V{shouldDelete}(\V{TRUE}),}}
\L{\LB{\Proc{readOnly}}\Tab{16}{_\V{readOnly}(\V{FALSE})}}
\L{\LB{\{}}
\L{\LB{____\V{copybuff}(\V{copyFrom});}}
\L{\LB{\}}}
\L{\LB{_____}}
\L{\LB{\V{Buffer}::\~\V{Buffer}_()}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{shouldDelete}_\&\&_(\V{bufferStart}_!=_0))}}
\L{\LB{____\{}}
\L{\LB{\K{\#ifndef}_\V{GCC\_ARRAY\_DELETE\_BUG}}}
\L{\LB{}\Tab{8}{\V{delete}_[\,]_\V{bufferStart};}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{8}{\V{delete}_\V{bufferStart};}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{8}{\V{bufferStart}_=_0;}}
\L{\LB{}\Tab{8}{\V{rereadOffset}_=_0;}}
\L{\LB{____\}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\* }}
\L{\LB{_\* Public non-virtual member functions and operators}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* These routines try to handle pointer aliasing in an attempt to avoid}}
\L{\LB{_\* sending pointed to objects more than once in a buffer. As pointers to}}
\L{\LB{_\* objects are added to the buffer they are looked up in a table and if}}
\L{\LB{_\* not found a TRUE value is returned indicating that the object should be }}
\L{\LB{_\* packed. }}
\L{\LB{_\* General comments on pointer packing.}}
\L{\LB{_\* Pointers are preceded in the buffer by a flag encoded as follows:}}
\L{\LB{_\* If the pointer is NULL then a value of 0 is packed}}
\L{\LB{_\* If the pointer is non-NULL and the pointer has not been seen before}}
\L{\LB{_\* a negative index is packed followed by the pointed to object otherwise the index}}
\L{\LB{_\* from the table is packed.}}
\L{\LB{_\* The unmarshalling code forces replacement of entries in the mapping table}}
\L{\LB{_\* as pointers are unpacked}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{shouldPack}_(_\V{const}_\K{void}_\*\V{ptr},_\V{Boolean}_\V{supressMapCheck},}}
\L{\LB{}\Tab{24}{_____\V{Uint32}_\V{hashval}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Boolean}_\V{doPack}_=_\V{FALSE};}}
\L{\LB{____\V{Int32}_\V{index}_=_0;}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{packPointers}.\V{addPtr}(\V{ptr},_\V{index},_\V{supressMapCheck},_\V{hashval}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{pack}(\-\V{index});}\Tab{40}{\C{}\1\* indicate new pointer \*\1\CE{}}}
\L{\LB{}\Tab{8}{\V{doPack}_=_\V{TRUE};}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{index}_\<_0)}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{____\V{pack}(\V{index});}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\K{return}_\V{doPack};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{saveUnpackedPtr}_(_\V{const}_\K{void}_\*\V{ptr},_\V{Int32}\&_\V{index}_)}}
\L{\LB{\{}}
\L{\LB{____\K{return}_\V{unpackPointers}.\V{addPtr}(\V{ptr},_\V{index});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpackPtr}_(_\V{const}_\K{void}\*\&_\V{ptr},_\V{Int32}\&_\V{index}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Boolean}_\V{unpackMe}_=_\V{FALSE};}}
\L{\LB{}}
\L{\LB{____\V{unpack}(\V{index});}}
\L{\LB{____\K{if}_(\V{index}_\>=_0)}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{ptr}_=_\V{unpackPointers}[\V{index}];}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{unpackMe}_=_\V{TRUE};}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\K{return}_\V{unpackMe};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{pack}_(_\K{unsigned}_\K{long}_\V{l}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\K{sizeof}(\K{unsigned}_\K{long})_\<=_\K{sizeof}(\V{Uint32}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{Uint32}_\V{u32}_=_\V{l};}}
\L{\LB{}\Tab{8}{\K{return}_\V{pack32bits}(\V{u32});}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{}\Tab{8}{\K{if}_(\K{sizeof}(\K{unsigned}_\K{long})_\<=_\K{sizeof}(\V{Uint64}))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\C{}\1\*}}
\L{\LB{}\Tab{8}{_____\* To get here we MUST have 64 bit longs so LONG\_IS\_64BITS}}
\L{\LB{}\Tab{8}{_____\* should be defined and Uint64 will be a long. However, we}}
\L{\LB{}\Tab{8}{_____\* have to keep all compilers happy so for machines with}}
\L{\LB{}\Tab{8}{_____\* 32 bit longs we supress this code}}
\L{\LB{}\Tab{8}{_____\*\1\CE{}}}
\L{\LB{\K{\#ifdef}_\V{LONG\_IS\_64BITS}}}
\L{\LB{}\Tab{8}{____\V{Uint64}_\V{u64}_=_\V{l};}}
\L{\LB{}\Tab{8}{____\K{return}_\V{pack64bits}(\V{u64});}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{____}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{pack}_(_\K{unsigned}_\K{long}_\K{long}_\V{ll}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\K{sizeof}(\K{unsigned}_\K{long}_\K{long})_\<=_\K{sizeof}(\V{Uint64}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{Uint64}_\V{u64}_=_\V{ll};}}
\L{\LB{}\Tab{8}{\K{return}_\V{pack64bits}(\V{u64});}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{pack}_(_\K{float}_\V{d}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{\K{\#if}_\V{defined}(\V{mc68000})_\|\,\|_\V{defined}(\V{sparc})_\|\,\|_\V{defined}(\V{\_IEEE})_\|\,\|_\V{defined}(\V{\_AIX})}}
\L{\LB{}}
\L{\LB{____\C{}\1\*}}
\L{\LB{_____\* Beware some compilers pass floats as doubles. So using \&d}}
\L{\LB{_____\* below would fail. Use temp var instead}}
\L{\LB{_____\*\1\CE{}}}
\L{\LB{____}}
\L{\LB{____\K{float}_\V{f}_=_\V{d};}}
\L{\LB{____\V{const}_\V{Uint32}_\*\V{uint32\_p}_=_(\V{const}_\V{Uint32}_\*)_\&\V{f};}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{pack32bits}(\*\V{uint32\_p}));}}
\L{\LB{\K{\#else}}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\K{\#endif}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{pack}_(_\K{double}_\V{d}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{\K{\#if}_\V{defined}(\V{mc68000})_\|\,\|_\V{defined}(\V{sparc})_\|\,\|_\V{defined}(\V{\_IEEE})_\|\,\|_\V{defined}(\V{\_AIX})}}
\L{\LB{____\V{const}_\V{Uint64}_\*\V{uint64\_p}_=_(\V{const}_\V{Uint64}_\*)_\&\V{d};}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{pack64bits}(\*\V{uint64\_p}));}}
\L{\LB{\K{\#else}}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\K{\#endif}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\* a null terminated string \*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{packMappedString}_(_\V{const}_\K{char}_\*\V{string}_)}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{strSize}_=_0;}}
\L{\LB{____}}
\L{\LB{____\K{if}_(\V{string})}}
\L{\LB{}\Tab{8}{\V{strSize}_=_::\V{strlen}(\V{string})_+_1;}}
\L{\LB{____}}
\L{\LB{____\K{return}_\V{packBlock}(\V{string},_\V{strSize},_\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{packNonMappedString}_(_\V{const}_\K{char}_\*\V{string}_)}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{strSize}_=_0;}}
\L{\LB{____}}
\L{\LB{____\K{if}_(\V{string})}}
\L{\LB{}\Tab{8}{\V{strSize}_=_::\V{strlen}(\V{string})_+_1;}}
\L{\LB{____}}
\L{\LB{____\K{return}_\V{packBlock}(\V{string},_\V{strSize},_\V{TRUE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{packMappedBlock}_(_\V{const}_\K{void}_\*\V{memory},_\V{const}_\V{size\_t}_\V{amount}_)}}
\L{\LB{\{__}}
\L{\LB{____\K{return}_\V{packBlock}(\V{memory},_\V{amount},_\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{packNonMappedBlock}_(_\V{const}_\K{void}_\*\V{memory},_\V{const}_\V{size\_t}_\V{amount}_)}}
\L{\LB{\{__}}
\L{\LB{____\K{return}_\V{packBlock}(\V{memory},_\V{amount},_\V{TRUE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_BOOLEAN\_TYPE}}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\V{bool}\&_\V{b}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Uint32}_\V{l};}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{unpack}(\V{l});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\V{b}_=_(\V{bool})\V{l};}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{\}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{unsigned}_\K{char}\&_\V{c}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Uint32}_\V{l};}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{unpack}(\V{l});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\V{c}_=_(\K{unsigned}_\K{char})\V{l};}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{unsigned}_\K{short}\&_\V{s}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Uint32}_\V{l};}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{unpack}(\V{l});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\V{s}_=_(\K{unsigned}_\K{short})\V{l};}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{unsigned}_\K{int}\&_\V{i}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Uint32}_\V{l};}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{unpack32bits}(\V{l});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\V{i}_=_(\K{unsigned}_\K{int})\V{l};}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Unpack integral quantity - assume unpackPoint is aligned (ala pack)}}
\L{\LB{_\* and let realign maintain that}}
\L{\LB{_\* Assume longs are at least 32 bits}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{long}\&_\V{l}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{longSize}_==_\K{sizeof}(\V{Uint32}))}\Tab{40}{\C{}\1\* buffers longs are 32 bits \*\1\CE{}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{Uint32}_\V{temp};}}
\L{\LB{}\Tab{8}{\V{Boolean}_\V{res}_=_\V{unpack32bits}(\V{temp});}}
\L{\LB{}\Tab{8}{}}
\L{\LB{}\Tab{8}{\V{l}_=_\V{temp};}}
\L{\LB{}\Tab{8}{\K{return}_\V{res};}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{}\Tab{8}{\K{if}_(\V{longSize}_==_\K{sizeof}(\V{Uint64}))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\C{}\1\*}}
\L{\LB{}\Tab{8}{_____\* Buffer longs are 64 bits. Whether I can unpack them}}
\L{\LB{}\Tab{8}{_____\* depends on whether I have 64 bit longs or if the}}
\L{\LB{}\Tab{8}{_____\* value will fit in 32 bits}}
\L{\LB{}\Tab{8}{_____\*\1\CE{}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{Uint64}_\V{temp};}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{Boolean}_\V{res}_=_\V{unpack64bits}(\V{temp});}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{\K{\#ifdef}_\V{LONG\_IS\_64BITS}_}}
\L{\LB{}\Tab{16}{\V{l}_=_\V{temp};}\Tab{40}{\C{}\1\* true 64 bit result \*\1\CE{}}}
\L{\LB{\K{\#else}}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{}}
\L{\LB{}\Tab{16}{\C{}\1\* Check if value will fit \*\1\CE{}}}
\L{\LB{}\Tab{16}{}}
\L{\LB{}\Tab{16}{\K{if}_((\V{temp}_\>=_\V{LONG\_MIN})_\&\&_(\V{temp}_\<=_\V{LONG\_MAX}))}}
\L{\LB{}\Tab{16}{____\V{l}_=_\V{temp};}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{16}{\C{}\1\*}}
\L{\LB{}\Tab{16}{_\* We do not have true compiler supported 64 bit ints}}
\L{\LB{}\Tab{16}{_\* use the fakes and make sure the (signed) number will fit}}
\L{\LB{}\Tab{16}{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{}\Tab{16}{\K{if}_(((\V{temp}.\V{hi}_==_0)_\&\&_((\V{temp}.\V{lo}_\&_\V{LONG\_MIN})_==_0))_\|\,\|}}
\L{\LB{}\Tab{16}{____((\V{temp}.\V{hi}_==_\~0)_\&\&_((\V{temp}.\V{lo}_\&_\V{LONG\_MIN})_!=_0)))}}
\L{\LB{}\Tab{16}{\{}}
\L{\LB{}\Tab{16}{____\V{l}_=_\V{temp}.\V{lo};}}
\L{\LB{}\Tab{16}{\}}}
\L{\LB{}\Tab{16}{\K{else}}}
\L{\LB{}\Tab{16}{____\V{res}_=_\V{FALSE};}}
\L{\LB{\K{\#endif}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\K{return}_\V{res};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{____}}
\L{\LB{____\C{}\1\* buffer longs are too big for me \*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{unsigned}_\K{long}\&_\V{l}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{longSize}_==_\K{sizeof}(\V{Uint32}))}\Tab{40}{\C{}\1\* buffers longs are 32 bits \*\1\CE{}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{Uint32}_\V{temp};}}
\L{\LB{}\Tab{8}{\V{Boolean}_\V{res}_=_\V{unpack32bits}(\V{temp});}}
\L{\LB{}\Tab{8}{}}
\L{\LB{}\Tab{8}{\V{l}_=_\V{temp};}}
\L{\LB{}\Tab{8}{\K{return}_\V{res};}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{}\Tab{8}{\K{if}_(\V{longSize}_==_\K{sizeof}(\V{Uint64}))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\C{}\1\*}}
\L{\LB{}\Tab{8}{_____\* Buffer longs are 64 bits. Whether I can unpack them}}
\L{\LB{}\Tab{8}{_____\* depends on whether I have 64 bit longs or if the}}
\L{\LB{}\Tab{8}{_____\* value will fit in 32 bits}}
\L{\LB{}\Tab{8}{_____\*\1\CE{}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{Uint64}_\V{temp};}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{Boolean}_\V{res}_=_\V{unpack64bits}(\V{temp});}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{\K{\#ifdef}_\V{LONG\_IS\_64BITS}_}}
\L{\LB{}\Tab{16}{\V{l}_=_\V{temp};}\Tab{40}{\C{}\1\* true 64 bit result \*\1\CE{}}}
\L{\LB{\K{\#else}}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{}}
\L{\LB{}\Tab{16}{\C{}\1\* Check if value will fit \*\1\CE{}}}
\L{\LB{}\Tab{16}{}}
\L{\LB{}\Tab{16}{\K{if}_((\V{temp}_\>=_\V{LONG\_MIN})_\&\&_(\V{temp}_\<=_\V{LONG\_MAX}))}}
\L{\LB{}\Tab{16}{____\V{l}_=_\V{temp};}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{16}{\C{}\1\*}}
\L{\LB{}\Tab{16}{_\* We do not have true compiler supported 64 bit ints}}
\L{\LB{}\Tab{16}{_\* use the fakes and make sure the number will fit}}
\L{\LB{}\Tab{16}{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{}\Tab{16}{\K{if}_(\V{temp}.\V{hi}_==_0)}}
\L{\LB{}\Tab{16}{\{}}
\L{\LB{}\Tab{16}{____\V{l}_=_\V{temp}.\V{lo};}}
\L{\LB{}\Tab{16}{\}}}
\L{\LB{}\Tab{16}{\K{else}}}
\L{\LB{}\Tab{16}{____\V{res}_=_\V{FALSE};}}
\L{\LB{\K{\#endif}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\K{return}_\V{res};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{____}}
\L{\LB{____\C{}\1\* buffer longs are too big for me \*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{unsigned}_\K{long}_\K{long}\&_\V{ll}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Uint64}_\V{l};}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{unpack64bits}(\V{l});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\V{ll}_=_(\K{unsigned}_\K{long}_\K{long})\V{l};}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{}}
\L{\LB{\}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{float}\&_\V{f}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{\K{\#if}_\V{defined}(\V{mc68000})_\|\,\|_\V{defined}(\V{sparc})_\|\,\|_\V{defined}(\V{\_IEEE})_\|\,\|_\V{defined}(\V{\_AIX})}}
\L{\LB{____\V{Uint32}_\*\V{uint32\_p}_=_(\V{Uint32}_\*)_\&\V{f};}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{unpack32bits}(\*\V{uint32\_p}));}}
\L{\LB{\K{\#else}}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\K{\#endif}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{double}\&_\V{d}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{\K{\#if}_\V{defined}(\V{mc68000})_\|\,\|_\V{defined}(\V{sparc})_\|\,\|_\V{defined}(\V{\_IEEE})_\|\,\|_\V{defined}(\V{\_AIX})}}
\L{\LB{____\V{Uint64}_\*\V{uint64\_p}_=_(\V{Uint64}_\*)_\&\V{d};}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{unpack64bits}(\*\V{uint64\_p}));}}
\L{\LB{\K{\#else}}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\K{\#endif}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\* }}
\L{\LB{_\* Unpack a null terminated string. }}
\L{\LB{_\* Always Unpacks into a new area of memory}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(_\K{char}_\*\&_\V{string}_)}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{slength}_=_0;}}
\L{\LB{____\K{void}_\*\V{p}_=_0;}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{unpackBlock}(\V{p},_\V{slength}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{string}_=_(\K{char}_\*)\V{p};}}
\L{\LB{}\Tab{8}{}}
\L{\LB{}\Tab{8}{\K{return}_\V{TRUE};}}
\L{\LB{____\}}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Operation to unpack a contiguous block of memory.}}
\L{\LB{_\* The long argument is set to the size unpacked.}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack}_(\K{void}_\*\&_\V{memory},_\V{size\_t}\&_\V{amount}_)}}
\L{\LB{\{}}
\L{\LB{____\K{return}_\V{unpackBlock}(\V{memory},_\V{amount});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Pack this buffer into another. Note that we don\'t call this simply}}
\L{\LB{_\* pack because it is the INVERSE of the normal pack. That is \'this\' is}}
\L{\LB{_\* packed into the argument buffer, whereas normally (for standard types)}}
\L{\LB{_\* the argument is packed into \'this\'}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{packInto}_(_\V{Buffer}\&_\V{buff}_)_\V{const}}}
\L{\LB{\{}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{FALSE};}}
\L{\LB{____\V{size\_t}_\V{len}_=_\V{length}();}}
\L{\LB{____}}
\L{\LB{____\K{if}_(\V{buff}.\V{pack}(\V{readOnly})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{pack}((\V{Uint32})(\V{packPoint}_\-_\V{bufferStart}))_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{pack}((\V{Uint32})(\V{unpackPoint}_\-_\V{bufferStart}))_\&\&}}
\L{\LB{}\Tab{8}{(\V{buff}.\V{pack}(\V{len})))}}
\L{\LB{}\Tab{8}{\K{if}_(\V{len}_!=_0)}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{buff}.\V{packMappedBlock}(\V{bufferStart},_\V{len})_\&\&}}
\L{\LB{}\Tab{16}{\V{packPointers}.\V{pack}(\V{buff}))}}
\L{\LB{}\Tab{16}{\V{res}_=_\V{unpackPointers}.\V{pack}(\V{buff});}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{____\V{res}_=_\V{TRUE};}}
\L{\LB{____}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Unpack this from the arg buffer. Obeys same rules as packInto above}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpackFrom}_(_\V{Buffer}\&_\V{buff}_)}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{buffSize};}}
\L{\LB{____\K{void}_\*\V{tempBuffer}_=_0;}}
\L{\LB{____\V{Boolean}_\V{res}_=_\V{FALSE};}}
\L{\LB{____\V{Uint32}_\V{packOffset}_=_0;}}
\L{\LB{____\V{Uint32}_\V{unpackOffset}_=_0;}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{buff}.\V{unpack}(\V{readOnly})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{unpack}(\V{packOffset})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{unpack}(\V{unpackOffset})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{unpack}(\V{buffSize}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{if}_((\V{buffSize}_!=_0)_\&\&}}
\L{\LB{}\Tab{8}{____(\V{res}_=_\V{buff}.\V{unpack}(\V{tempBuffer},_\V{buffSize})))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{setBuffer}(\V{buffSize},_\V{tempBuffer})_\&\&}}
\L{\LB{}\Tab{16}{(\V{packPointers}.\V{unpack}(\V{buff})))}}
\L{\LB{}\Tab{16}{\V{res}_=_\V{unpackPointers}.\V{unpack}(\V{buff});}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{packPoint}_=_\V{bufferStart}_+_\V{packOffset};}}
\L{\LB{}\Tab{8}{____\V{unpackPoint}_=_\V{bufferStart}_+_\V{unpackOffset};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{}}
\L{\LB{____\}}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{res};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Concatenate the unread portion of the arg buffer into this buffer}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{appendUnused}_(_\V{const}_\V{Buffer}\&_\V{from}_)}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{lenToPack}_=_\V{from}.\V{bufferEnd}_\-_\V{from}.\V{unpackPoint};}}
\L{\LB{____}}
\L{\LB{____\K{return}_\V{packMappedBlock}(\V{from}.\V{unpackPoint},_\V{lenToPack});}}
\L{\LB{____}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Pack this buffer into an RpcBuffer. Note this is almost the same as}}
\L{\LB{_\* packInto EXCEPT that it does not send the pointer alias info as that}}
\L{\LB{_\* would almost certainly be wrong in another address space.}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\K{void}_\V{Buffer}::\V{marshall}_(_\V{RpcBuffer}\&_\V{buff}_)_\V{const}}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{len}_=_\V{length}();}}
\L{\LB{____}}
\L{\LB{____\K{if}_(\V{buff}.\V{pack}(\V{readOnly})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{pack}((\V{Uint32})(\V{packPoint}_\-_\V{bufferStart}))_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{pack}((\V{Uint32})(\V{unpackPoint}_\-_\V{bufferStart}))_\&\&}}
\L{\LB{}\Tab{8}{(\V{buff}.\V{pack}(\V{len})))}}
\L{\LB{}\Tab{8}{\K{if}_(\V{len}_!=_0)}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{buff}.\V{packMappedBlock}(\V{bufferStart},_\V{len});}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Unpack this from the arg buffer.}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\K{void}_\V{Buffer}::\V{unmarshall}_(_\V{RpcBuffer}\&_\V{buff}_)}}
\L{\LB{\{}}
\L{\LB{____\V{size\_t}_\V{buffSize};}}
\L{\LB{____\K{void}_\*\V{tempBuffer}_=_0;}}
\L{\LB{____\V{Uint32}_\V{packOffset}_=_0;}}
\L{\LB{____\V{Uint32}_\V{unpackOffset}_=_0;}}
\L{\LB{____}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{buff}.\V{unpack}(\V{readOnly})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{unpack}(\V{packOffset})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{unpack}(\V{unpackOffset})_\&\&}}
\L{\LB{}\Tab{8}{\V{buff}.\V{unpack}(\V{buffSize}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{if}_((\V{buffSize}_!=_0)_\&\&}}
\L{\LB{}\Tab{8}{____(\V{buff}.\V{unpack}(\V{tempBuffer},_\V{buffSize})))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{tempBuffer}_!=_0)}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\V{setBuffer}(\V{buffSize},_\V{tempBuffer});}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\V{packPoint}_=_\V{bufferStart}_+_\V{packOffset};}}
\L{\LB{}\Tab{8}{\V{unpackPoint}_=_\V{bufferStart}_+_\V{unpackOffset};}}
\L{\LB{____\}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Buffer}\&_\V{Buffer}::\V{operator}=_(_\V{const}_\V{Buffer}\&_\V{buff}_)}}
\L{\LB{\{}}
\L{\LB{____\V{copybuff}(\V{buff});}}
\L{\LB{____\K{return}_\*\V{this};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Buffer}\&_\V{Buffer}::\V{operator}+=_(_\V{const}_\V{Buffer}\&_\V{buff}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD}_\|\,\|}}
\L{\LB{}\Tab{8}{\V{readOnly}_\|\,\|}}
\L{\LB{}\Tab{8}{\V{buff}.\V{readState}()_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\*\V{this});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{buff}.\V{length}()_\>_0)}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{sizeup}(\V{buff}.\V{length}()))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{memcpy}(\V{packPoint},_\V{buff}.\V{bufferStart},_(\K{int})_\V{buff}.\V{length}());}}
\L{\LB{}\Tab{8}{____\V{packPoint}_+=_\V{buff}.\V{length}();}}
\L{\LB{}\Tab{8}{____\V{realign}(\V{packPoint});}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\}}}
\L{\LB{____\K{return}_\*\V{this};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{operator}==_(\V{const}_\V{Buffer}\&_\V{buff})_\V{const}}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{length}()_==_\V{buff}.\V{length}())}}
\L{\LB{}\Tab{8}{\K{return}_(\V{Boolean})_(\V{memcmp}(\V{buffer}(),_\V{buff}.\V{buffer}(),_\V{length}())_==_0);}}
\L{\LB{____\K{else}}}
\L{\LB{}\Tab{8}{\K{return}_\V{FALSE};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Public virtual functions}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{ostream}\&_\V{Buffer}::\V{print}_(_\V{ostream}\&_\V{strm}_)_\V{const}}}
\L{\LB{\{}}
\L{\LB{____\V{strm}_\<\<_\S{}\"\<\"\SE{}_\<\<_\V{buffState};}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{readOnly})}}
\L{\LB{}\Tab{8}{\V{strm}_\<\<_\S{}\"(R)\"\SE{};}}
\L{\LB{____}}
\L{\LB{____\V{strm}_\<\<_\S{}\"\>\<\"\SE{};}}
\L{\LB{____\V{strm}_\<\<_(\K{void}_\*)_\V{bufferStart}_\<\<_\S{}\"\-\!\>\"\SE{}_\<\<_(\K{void}_\*)_\V{bufferEnd}}}
\L{\LB{}\Tab{8}{_\<\<_\S{}\"\>\<\"\SE{}}}
\L{\LB{}\Tab{8}{_\<\<_(\K{void}_\*)_\V{packPoint}_\<\<_\S{}\",\"\SE{}_\<\<_(\K{void}_\*)_\V{unpackPoint}_\<\<_\S{}\"\>(\"\SE{};}}
\L{\LB{____}}
\L{\LB{____\K{if}_((\V{bufferStart}_!=_0)_\&\&_(\V{packPoint}_!=_0))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{for}_(\K{char}_\*\V{i}_=_\V{bufferStart};_\V{i}_\<_\V{packPoint};_\V{i}++)}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{strm}_\<\<_(\K{int})_\*\V{i};}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{isprint}(\*\V{i}))}}
\L{\LB{}\Tab{16}{\V{strm}_\<\<_\S{}\"_[\"\SE{}_\<\<_\*\V{i}_\<\<_\S{}\"]_\"\SE{};}}
\L{\LB{}\Tab{8}{____\K{else}}}
\L{\LB{}\Tab{16}{\V{strm}_\<\<_\S{}\"_\{?\}_\"\SE{}_;}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{____\}}}
\L{\LB{____\V{strm}_\<\<_\S{}\")\"\SE{};}}
\L{\LB{}}
\L{\LB{____\K{return}_\V{strm};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Change the underlying buffer. Since this contains flags they}}
\L{\LB{_\* need to be reset as well}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{setBuffer}_(_\V{size\_t}_\V{buffSize},_\K{void}_\*\V{buffer},_}}
\L{\LB{}\Tab{24}{____\V{Boolean}_\V{full},}}
\L{\LB{}\Tab{24}{____\V{Boolean}_\V{shouldDel}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{bufferStart}_!=_\V{NULL})_\&\&_\V{shouldDelete})}}
\L{\LB{}\Tab{8}{\V{delete}_\V{bufferStart};}}
\L{\LB{____}}
\L{\LB{____\V{shouldDelete}_=_\V{shouldDel};}}
\L{\LB{____\V{bufferStart}__=_(\K{char}_\*)\V{buffer};}}
\L{\LB{____\V{bufferEnd}____=_\V{bufferStart}+\V{buffSize};}}
\L{\LB{____\V{packPoint}____=_(\V{full}_?_\V{bufferEnd}_:_\V{bufferStart});}}
\L{\LB{____\V{unpackPoint}__=_\V{bufferStart};}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{bufferStart}_==_0)}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{}\Tab{8}{\K{return}_\V{FALSE};}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\C{}\1\*}}
\L{\LB{_____\* If the pack point is at Buffer start put in the sizes and flag}}
\L{\LB{_____\* otherwise assume they are there already and extract them}}
\L{\LB{_____\*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{packPoint}_==_\V{bufferStart})}}
\L{\LB{____\{____}}
\L{\LB{}\Tab{8}{\V{initBuffer}();}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\C{}\1\*}}
\L{\LB{}\Tab{8}{_\* Buffer contains data:}}
\L{\LB{}\Tab{8}{_\* Extract flag and if ok extract sizes too}}
\L{\LB{}\Tab{8}{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{if}_((::\V{memcmp}(\V{bufferStart},_\V{VERSION},_\K{sizeof}(\V{VERSION}))_==_0))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\C{}\1\* Magic number matches - get sizes \*\1\CE{}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{Uint32}_\V{ui};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\V{unpackPoint}_+=_\K{sizeof}(\V{VERSION});}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{unpack}(\V{ui});}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{rereadOffset}_=_\V{unpackPoint}_\-_\V{bufferStart};}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{longlongSize}_=_\V{ui}_\&_0xff;}}
\L{\LB{}\Tab{8}{____\V{longSize}_=_(\V{ui}_\&0xff00)_\>\>_8;}}
\L{\LB{}\Tab{8}{____\V{intSize}_=_(\V{ui}_\&0xff0000)_\>\>_16;}}
\L{\LB{}\Tab{8}{____\V{shortSize}_=_(\V{ui}_\&_0xff000000)_\>\>_24;}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\C{}\1\* Check sizes are compatable \*\1\CE{}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\K{if}_((\V{shortSize}_!=_\K{sizeof}(\K{unsigned}_\K{short}))_\|\,\|}}
\L{\LB{}\Tab{16}{_(\V{intSize}_!=_\K{sizeof}(\K{unsigned}_\K{int}))_\|\,\|}}
\L{\LB{}\Tab{16}{_(\V{longSize}_!=_\K{sizeof}(\K{unsigned}_\K{long}))}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{}\Tab{16}{_\|\,\|_(\V{longlongSize}_!=_\K{sizeof}(\K{unsigned}_\K{long}_\K{long}))}}
\L{\LB{\K{\#endif}}}
\L{\LB{}\Tab{16}{)}}
\L{\LB{}\Tab{16}{\V{readOnly}_=_\V{TRUE};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\C{}\1\* Probably an old format buffer - mark as read-only just in case \*\1\CE{}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{readOnly}_=_\V{TRUE};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\C{}\1\* Old format buffers only had longs of 32 bits \*\1\CE{}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\V{longSize}_=_4;}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{unpackPoint}_=_\V{bufferStart};}}
\L{\LB{}\Tab{8}{____\V{rereadOffset}_=_0;}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_GOOD};____}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}}
\L{\LB{____\}}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{buffState}_==_\V{BUFFER\_GOOD}_?_\V{TRUE}_:_\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Private non-virtual functions}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Make a copy of the argument buffer in the current one}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\K{void}_\V{Buffer}::\V{copybuff}_(_\V{const}_\V{Buffer}\&_\V{buff}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD}_\|\,\|_\V{buff}.\V{readState}()_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return};}}
\L{\LB{}}
\L{\LB{____\C{}\1\*}}
\L{\LB{_____\* copy over parameters first}}
\L{\LB{_____\*\1\CE{}}}
\L{\LB{____}}
\L{\LB{____\V{shortSize}_=_\V{buff}.\V{shortSize};}}
\L{\LB{____\V{intSize}_=_\V{buff}.\V{intSize};}}
\L{\LB{____\V{longSize}_=_\V{buff}.\V{longSize};}}
\L{\LB{____\V{longlongSize}_=_\V{buff}.\V{longlongSize};}}
\L{\LB{____}}
\L{\LB{____\V{chunkSize}_=_\V{buff}.\V{chunkSize};}}
\L{\LB{}}
\L{\LB{____\V{packPointers}_=_\V{buff}.\V{packPointers};}}
\L{\LB{____\V{unpackPointers}_=_\V{buff}.\V{unpackPointers};}}
\L{\LB{____\V{readOnly}_=_\V{buff}.\V{readOnly};}}
\L{\LB{____}}
\L{\LB{____\C{}\1\*}}
\L{\LB{_____\* Only copy buffer if actually necessary}}
\L{\LB{_____\*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{buff}.\V{length}()_\>_0)}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{sizeup}(\V{buff}.\V{length}()))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{memcpy}(\V{bufferStart},_\V{buff}.\V{bufferStart},_(\K{unsigned}_\K{int})_\V{buff}.\V{length}());}}
\L{\LB{}\Tab{8}{____\V{packPoint}_=_\V{bufferStart}_+_\V{buff}.\V{length}();}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{buff}.\V{unpackPoint}_\>_\V{buff}.\V{bufferStart})}}
\L{\LB{}\Tab{16}{\V{unpackPoint}_=_\V{bufferStart}_+}}
\L{\LB{}\Tab{16}{____(\V{buff}.\V{unpackPoint}_\-_\V{buff}.\V{bufferStart});}}
\L{\LB{}\Tab{8}{____\K{else}}}
\L{\LB{}\Tab{16}{\V{unpackPoint}_=_\V{bufferStart};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{}\Tab{8}{\V{bufferStart}_=_\V{bufferEnd}_=_\V{packPoint}_=_\V{unpackPoint}_=_(\K{char}_\*)_0;}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Init a NEW Buffer. Places flag and sizes in first parts of buffer}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{initBuffer}_()}}
\L{\LB{\{}}
\L{\LB{____\V{shortSize}_=_\K{sizeof}(\K{unsigned}_\K{short});}}
\L{\LB{____\V{intSize}_=_\K{sizeof}(\K{unsigned}_\K{int});}}
\L{\LB{____\V{longSize}_=_\K{sizeof}(\K{unsigned}_\K{long});}}
\L{\LB{\K{\#ifdef}_\V{HAVE\_LONG\_LONG}}}
\L{\LB{____\V{longlongSize}_=_\K{sizeof}(\K{unsigned}_\K{long}_\K{long});}}
\L{\LB{\K{\#else}}}
\L{\LB{____\V{longlongSize}_=_0;}}
\L{\LB{\K{\#endif}}}
\L{\LB{____}}
\L{\LB{____\K{if}_(\V{bufferStart}_!=_0)}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{Uint32}_\V{ui}_=_\V{shortSize};}}
\L{\LB{____}}
\L{\LB{}\Tab{8}{\C{}\1\*}}
\L{\LB{}\Tab{8}{_\* The first entries are always the magic flag and the sizes of the basic types.}}
\L{\LB{}\Tab{8}{_\* Do not use pack individually as it would use 32 bits for each!}}
\L{\LB{}\Tab{8}{_\*\1\CE{}}}
\L{\LB{}\Tab{8}{}}
\L{\LB{}\Tab{8}{\V{ui}_=_(\V{ui}_\<\<_8)_\|_\V{intSize};}}
\L{\LB{}\Tab{8}{\V{ui}_=_(\V{ui}_\<\<_8)_\|_\V{longSize};}}
\L{\LB{}\Tab{8}{\V{ui}_=_(\V{ui}_\<\<_8)_\|_\V{longlongSize};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{sizeup}(\K{sizeof}(\V{VERSION})_+_\K{sizeof}(\V{Uint32})))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____::\V{memcpy}(\V{bufferStart},_\V{VERSION},_\K{sizeof}(\V{VERSION}));}}
\L{\LB{}\Tab{8}{____\V{packPoint}_+=_\K{sizeof}(\V{VERSION});}}
\L{\LB{}\Tab{8}{____\V{realign}(\V{packPoint});}}
\L{\LB{}\Tab{8}{____\V{pack}(\V{ui});}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\C{}\1\* Force unpack point on so we do not mistake sizes as user data \*\1\CE{}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\V{unpackPoint}_=_\V{packPoint};}}
\L{\LB{}\Tab{8}{____\V{rereadOffset}_=_\V{packPoint}_\-_\V{bufferStart};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\K{return}_(\V{buffState}_==_\V{BUFFER\_BAD}_?_\V{FALSE}_:_\V{TRUE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{pack32bits}_(_\V{Uint32}_\V{ui}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\C{}\1\* Ensure room exists \*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{sizeup}(\K{sizeof}(\V{Uint32}))_==_\V{FALSE})}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{____\}}}
\L{\LB{}}
\L{\LB{____\C{}\1\* and then pack \*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\*((\V{Uint32}_\*)_\V{packPoint})_=_\V{htonl}(\V{ui});}}
\L{\LB{____\V{packPoint}_+=_\K{sizeof}(\V{Uint32});}}
\L{\LB{____}}
\L{\LB{____\K{return}_(\V{realign}(\V{packPoint}));}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{pack64bits}_(_\V{Uint64}_\V{ui}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\C{}\1\* Ensure room exists \*\1\CE{}}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{sizeup}(\K{sizeof}(\V{Uint64}))_==_\V{FALSE})}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{____\}}}
\L{\LB{}}
\L{\LB{____\C{}\1\* and then pack \*\1\CE{}}}
\L{\LB{\K{\#if}_\V{defined}(\V{HAVE\_LONG\_LONG})_\|\,\|_\V{defined}(\V{LONG\_IS\_64BITS})}}
\L{\LB{____\K{return}_(\V{pack32bits}(\V{ui}_\>\>_32)_\&\&_\V{pack32bits}(\V{ui}_\&_0xffffffff));}}
\L{\LB{\K{\#else}}}
\L{\LB{____\K{return}_(\V{pack32bits}(\V{ui}.\V{hi})_\&\&_\V{pack32bits}(\V{ui}.\V{lo}));}}
\L{\LB{\K{\#endif}}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{packBlock}_(_\V{const}_\K{void}_\*\V{memory},_\V{size\_t}_\V{amount},}}
\L{\LB{}\Tab{24}{____\V{Boolean}_\V{supressMapCheck}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Uint32}_\V{hashval}_=_0;}}
\L{\LB{____}}
\L{\LB{_____\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{memory}_\&\&_(\V{amount}_\>_0))}}
\L{\LB{}\Tab{8}{\V{hashval}_=_\V{checkSum}(\V{memory},_\V{amount});}}
\L{\LB{____}}
\L{\LB{____\K{if}_(\V{shouldPack}(\V{memory},\V{supressMapCheck},_\V{hashval}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\C{}\1\* shouldPack has handled the possible null pointer \*\1\CE{}}}
\L{\LB{}\Tab{8}{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{pack}(\V{amount})_\&\&_\V{sizeup}(\V{amount}))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{amount}_\>_0)}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\V{memcpy}(\V{packPoint},_\V{memory},_(\K{int})_\V{amount});}}
\L{\LB{}\Tab{16}{\V{packPoint}_+=_\V{amount};}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{____\K{return}_\V{FALSE};}\Tab{40}{\C{}\1\* buffer already bad \*\1\CE{}}\Tab{72}{____}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\C{}\1\*}}
\L{\LB{}\Tab{8}{_\* We have packed this block before. shouldPack will}}
\L{\LB{}\Tab{8}{_\* have saved the index just add the amount here for}}
\L{\LB{}\Tab{8}{_\* unpack purposes}}
\L{\LB{}\Tab{8}{_\*\1\CE{}}}
\L{\LB{}\Tab{8}{}}
\L{\LB{}\Tab{8}{\K{if}_(!\V{pack}(\V{amount}))}}
\L{\LB{}\Tab{8}{____\K{return}_\V{FALSE};}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\K{return}_(\V{realign}(\V{packPoint}));}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Unpack integral quantities - assume unpackPoint is aligned (ala pack)}}
\L{\LB{_\* and let realign maintain that}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack32bits}_(_\V{Uint32}\&_\V{l}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_((\V{unpackPoint}_+_\K{sizeof}(\V{Uint32}))_\<=_\V{packPoint})}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{l}_=_\V{ntohl}(\*((\V{Uint32}_\*)_\V{unpackPoint}));}}
\L{\LB{}\Tab{8}{\V{unpackPoint}_+=_\K{sizeof}(\V{Uint32});}}
\L{\LB{}\Tab{8}{\K{return}_(\V{realign}(\V{unpackPoint}));}}
\L{\LB{____\}}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_\V{FALSE};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpack64bits}_(_\V{Uint64}\&_\V{l}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_((\V{unpackPoint}_+_\K{sizeof}(\V{Uint64}))_\<=_\V{packPoint})}}
\L{\LB{____\{}}
\L{\LB{\K{\#if}_\V{defined}_(\V{LONG\_IS\_64BITS})_\|\,\|_\V{defined}(\V{HAVE\_LONG\_LONG})}}
\L{\LB{}\Tab{8}{\V{Uint32}_\V{temp};}}
\L{\LB{}\Tab{8}{\V{Boolean}_\V{res}_=_\V{unpack32bits}(\V{temp});}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{res})}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{l}_=_\V{temp};}}
\L{\LB{}\Tab{8}{____\V{res}_=_\V{unpack32bits}(\V{temp});}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{res})}}
\L{\LB{}\Tab{16}{\V{l}_=_(\V{l}_\<\<_32)_\|_\V{temp};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{return}_\V{res};}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{8}{\K{return}_(\V{unpack32bits}(\V{l}.\V{hi})_\&\&_\V{unpack32bits}(\V{l}.\V{lo}));}}
\L{\LB{\K{\#endif}}}
\L{\LB{____\}}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_\V{FALSE};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Operation to unpack a contiguous block of memory.}}
\L{\LB{_\* The long argument is set to the size unpacked.}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{unpackBlock}_(\K{void}_\*\&_\V{memory},_\V{size\_t}\&_\V{amount}_)}}
\L{\LB{\{}}
\L{\LB{____\V{Int32}_\V{index}__=_0;}}
\L{\LB{____\V{const}_\K{void}_\*\V{p}_=_0;}}
\L{\LB{____\V{size\_t}_\V{memSize};}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_(\V{unpackPtr}(\V{p},\V{index}))}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{unpack}(\V{memSize}))}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{memory}_==_0)}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\V{memory}_=_\V{new}_\K{char}[\V{memSize}];}}
\L{\LB{}\Tab{16}{\V{amount}_=_\V{memSize};}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{____\K{else}}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\C{}\1\* alocated memory large enough? \*\1\CE{}}}
\L{\LB{}\Tab{16}{\K{if}_(\V{memSize}_\>_\V{amount})}}
\L{\LB{}\Tab{16}{\{}}
\L{\LB{}\Tab{16}{____\V{amount}_=_\V{memSize};}}
\L{\LB{}\Tab{16}{____}}
\L{\LB{}\Tab{16}{____\C{}\1\* always (un)pack ints etc as unsigned longs \*\1\CE{}}}
\L{\LB{}\Tab{16}{____}}
\L{\LB{}\Tab{16}{____\V{unpackPoint}_\-=_\K{sizeof}(\K{unsigned}_\K{long});}}
\L{\LB{}\Tab{16}{____\K{return}_(\V{FALSE});}}
\L{\LB{}\Tab{16}{\}}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{memory})}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\V{memcpy}(\V{memory},_\V{unpackPoint},_(\K{int})_\V{amount});}}
\L{\LB{}\Tab{16}{\V{saveUnpackedPtr}(\V{memory},_\V{index});}}
\L{\LB{}\Tab{16}{\V{unpackPoint}_+=_\V{amount};}}
\L{\LB{}\Tab{16}{\K{return}_(\V{realign}(\V{unpackPoint}));}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{memory}_=_(\K{char}_\*)\V{p};}}
\L{\LB{}\Tab{8}{\K{if}_(\V{unpack}(\V{amount}))}}
\L{\LB{}\Tab{8}{____\K{return}_\V{TRUE};}}
\L{\LB{____\}}}
\L{\LB{____}}
\L{\LB{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{____\K{return}_(\V{FALSE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\C{}\1\*}}
\L{\LB{_\* Realign the pack or unpack points }}
\L{\LB{_\* to the alignment boundary dictated by ALIGNMENT}}
\L{\LB{_\*\1\CE{}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{realign}_(_\K{char}_\*\&_\V{memPtr}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(((\V{ptrdiff\_t})_\V{memPtr})_\%_\V{ALIGNMENT})}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{size\_t}_\V{pad}_=_(\V{ALIGNMENT}_\-_(((\V{ptrdiff\_t})_\V{memPtr})_\%_\V{ALIGNMENT}));}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{sizeup}(\V{pad})_==_\V{FALSE})}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{}\Tab{8}{____\K{return}_\V{FALSE};}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\C{}\1\* sizeup has already zeroed the buffer if needed \*\1\CE{}}}
\L{\LB{}\Tab{8}{\V{memPtr}_+=_\V{pad};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{return}_(\V{TRUE});}}
\L{\LB{____\}}}
\L{\LB{____\K{else}}}
\L{\LB{}\Tab{8}{\K{return}_(\V{TRUE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{sizeup}_(_\V{size\_t}_\V{extra}_)}}
\L{\LB{\{}}
\L{\LB{____\K{if}_(\V{buffState}_!=_\V{BUFFER\_GOOD})}}
\L{\LB{}\Tab{8}{\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{____\K{if}_((\V{packPoint}_+_\V{extra})_\>_\V{bufferEnd})}}
\L{\LB{____\{}}
\L{\LB{}\Tab{8}{\V{size\_t}_\V{newSize};}}
\L{\LB{}\Tab{8}{\V{size\_t}_\V{oldSize}_=_\V{length}();}}
\L{\LB{}\Tab{8}{\K{char}_\*\V{oldStart}_=_\V{bufferStart};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\C{}\1\* set new size \*\1\CE{}}}
\L{\LB{}\Tab{8}{\V{newSize}_=_\V{oldSize}_+_\V{extra};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\C{}\1\* round up to nearest multiple of chunkSize \*\1\CE{}}}
\L{\LB{}\Tab{8}{\K{if}_(\V{newSize}_\%_\V{chunkSize})}}
\L{\LB{}\Tab{8}{____\V{newSize}_+=_\V{chunkSize}_\-_(\V{newSize}_\%_\V{chunkSize});}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{bufferStart}_==_0)}}
\L{\LB{}\Tab{8}{____\V{bufferStart}_=_\V{packPoint}_=_\V{unpackPoint}_=_\V{new}_\K{char}[\V{newSize}];}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\C{}\1\* realloc \*\1\CE{}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\V{bufferStart}_=_\V{new}_\K{char}[\V{newSize}];}}
\L{\LB{}\Tab{8}{____\K{if}_(\V{bufferStart})}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\V{memcpy}(\V{bufferStart},_\V{oldStart},_\V{oldSize});}}
\L{\LB{}\Tab{16}{\K{if}_(\V{shouldDelete})}}
\L{\LB{\K{\#ifndef}_\V{GCC\_ARRAY\_DELETE\_BUG}}}
\L{\LB{}\Tab{16}{____\V{delete}_[\,]_\V{oldStart};}}
\L{\LB{\K{\#else}}}
\L{\LB{}\Tab{16}{____\V{delete}_\V{oldStart};}}
\L{\LB{\K{\#endif}}\Tab{16}{}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\V{shouldDelete}_=_\V{TRUE};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{\K{if}_(\V{bufferStart}_==_0)}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{bufferStart}_=_\V{oldStart};}}
\L{\LB{}}
\L{\LB{}\Tab{8}{____\V{error\_stream}_\<\<_\V{WARNING}_\<\<_\S{}\"Buffer::sizeup_malloc\1realloc_failure\2n\"\SE{};}}
\L{\LB{}\Tab{8}{____\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{}\Tab{8}{____\K{return}_(\V{FALSE});}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{}\Tab{8}{\K{else}}}
\L{\LB{}\Tab{8}{\{}}
\L{\LB{}\Tab{8}{____\V{bufferEnd}_=_\V{bufferStart}_+_\V{newSize};}}
\L{\LB{}}
\L{\LB{_}\Tab{8}{____\K{if}_(\V{oldStart})}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\C{}\1\* buffer start MUST have changed by this point. So.\,. \*\1\CE{}}}
\L{\LB{}\Tab{16}{\V{packPoint}_=_\V{bufferStart}_+_(\V{packPoint}_\-_\V{oldStart});}}
\L{\LB{}\Tab{16}{\V{unpackPoint}_=_\V{bufferStart}_+_(\V{unpackPoint}_\-_\V{oldStart});}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{____\K{else}}}
\L{\LB{}\Tab{8}{____\{}}
\L{\LB{}\Tab{16}{\C{}\1\* Preload initial buffer contents \*\1\CE{}}}
\L{\LB{}\Tab{16}{\V{initBuffer}();}}
\L{\LB{}\Tab{8}{____\}}}
\L{\LB{}\Tab{8}{____}}
\L{\LB{}\Tab{8}{____\V{memset}(\V{packPoint},_\S{}\'\20\'\SE{},_\V{bufferEnd}_\-_\V{packPoint});}}
\L{\LB{}\Tab{8}{\}}}
\L{\LB{____\}}}
\L{\LB{}}
\L{\LB{____\K{return}_(\V{TRUE});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{}}
\L{\LB{\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1}}
\L{\LB{\1\1\V{Function}:_\V{constructBuffer}}}
\L{\LB{\1\1\V{Author}:_\V{Dean}_\V{Thompson}}}
\L{\LB{\1\1\V{Created}:_15th_\V{August}_1996}}
\L{\LB{\1\1\V{Last}_\V{Modified}:_4th_\V{October}_1996}}
\L{\LB{\1\1\V{Description}:__\V{This}_\V{function}_\V{is}_}}
\L{\LB{\1\1__\V{responsible}_\K{for}_\V{taking}_\V{in}_\V{a}_}}
\L{\LB{\1\1__\V{character}_\V{pointer}_\V{and}_\V{converting}}}
\L{\LB{\1\1__\V{the}_\V{buffer}_\V{class}_\V{into}_\V{a}_\V{character}}}
\L{\LB{\1\1__\V{representation}_\V{through}_\V{the}_\V{aid}_\V{of}}}
\L{\LB{\1\1__\V{explicit}_\V{type}_\V{conversion}}}
\L{\LB{\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1}}
\L{\LB{}}
\L{\LB{\K{int}_\V{Buffer}::\V{constructBuffer}_(\K{char}_\*\V{bufferPassedIn})}}
\L{\LB{\{}}
\L{\LB{_\K{int}_\V{counter}=0;}}
\L{\LB{}}
\L{\LB{_\V{bufferPassedIn}[\V{counter}++]_=_\V{calculateSize}();}}
\L{\LB{}}
\L{\LB{_\K{for}_(\K{char}_\*\V{startPoint}_=_\V{bufferStart};_\V{startPoint}_\<_\V{packPoint};_\V{startPoint}++)}}
\L{\LB{_\{}}
\L{\LB{____\K{if}_(\*\V{startPoint}_\<_0)}}
\L{\LB{_____\V{bufferPassedIn}[\V{counter}++]_=_((\K{int})_\*\V{startPoint})_+_256;}}
\L{\LB{____________\1\1_\V{Make}_\V{this}_\V{a}_\V{non}\-\V{negative}_\V{number}}}
\L{\LB{____\K{else}}}
\L{\LB{_____\V{bufferPassedIn}[\V{counter}++]_=_(\K{int})_\*\V{startPoint};}}
\L{\LB{____________\1\1_\V{Take}_\V{the}_\V{number}_\V{as}_\V{it}_\V{is}}}
\L{\LB{_\}}}
\L{\LB{_\V{bufferPassedIn}[\V{counter}]_=_\-1001;__\1\1_\V{Signify}_\V{that}_\V{we}_\V{are}_\V{at}_\V{the}_\V{end}_\V{of}}}
\L{\LB{___________________________________\1\1__\V{the}_\V{buffer}}}
\L{\LB{_\K{return}_\V{counter};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1}}
\L{\LB{\1\1\V{Function}:_\V{reconstructBuffer}}}
\L{\LB{\1\1\V{Author}:_\V{Dean}_\V{Thompson}}}
\L{\LB{\1\1\V{Created}:_15th_\V{August}_1996}}
\L{\LB{\1\1\V{Last}_\V{Modified}:_4th_\V{October}_1996}}
\L{\LB{\1\1\V{Description}:__\V{This}_\V{function}_\V{is}}}
\L{\LB{\1\1__\V{responsible}_\K{for}_\V{a}_\V{character}_\V{pointer}}}
\L{\LB{\1\1__\V{and}_\V{reconstructing}_\V{the}_\V{class}_\V{from}}}
\L{\LB{\1\1__\V{it}.__\V{This}_\V{is}_\V{achieved}_\V{through}_\V{the}}}
\L{\LB{\1\1__\V{use}_\V{of}_\V{explicit}_\V{type}_\V{conversion}}}
\L{\LB{\1\1__\V{in}_\V{order}_\V{to}_\V{extract}_\V{the}_\V{data}_\V{types}}}
\L{\LB{\1\1__\V{from}_\V{the}_\V{string}.}}
\L{\LB{\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1}}
\L{\LB{}}
\L{\LB{\V{Boolean}_\V{Buffer}::\V{reconstructBuffer}_(\K{char}_\*\V{bufferInString})}}
\L{\LB{\{}}
\L{\LB{_\K{unsigned}_\K{int}_\V{bufferSize};}}
\L{\LB{}}
\L{\LB{_\V{bufferSize}_=_\V{bufferInString}[0];___\1\1_\V{The}_\V{first}_\V{position}_\V{in}_\V{the}_\V{buffer}_\V{holds}}}
\L{\LB{___________________________________\1\1__\V{its}_\V{size}.}}
\L{\LB{}}
\L{\LB{_\K{if}_((\V{buffState}_!=_\V{BUFFER\_GOOD})_\|\,\|_\V{readOnly})}}
\L{\LB{__\K{return}_(\V{FALSE});}}
\L{\LB{}}
\L{\LB{_\K{if}_(\V{sizeup}(\V{bufferSize})_==_\V{FALSE})}}
\L{\LB{_\{}}
\L{\LB{__\V{buffState}_=_\V{BUFFER\_BAD};}}
\L{\LB{__\K{return}_(\V{FALSE});}}
\L{\LB{_\}}}
\L{\LB{}}
\L{\LB{_\K{for}_(\K{int}_\V{counter}=1;\V{counter}\<\V{bufferSize};\V{counter}++)__\1\1_\V{Skip}_\V{the}_\V{first}_\V{value}}}
\L{\LB{___________________________________________________\1\1__\V{because}_\V{it}_\V{represents}}}
\L{\LB{___________________________________________________\1\1__\V{the}_\V{size}_\V{of}_\V{the}_\V{buffer}.}}
\L{\LB{____\V{bufferStart}[\V{counter}\-1]_=_\V{bufferInString}[\V{counter}];}}
\L{\LB{}}
\L{\LB{_\V{packPoint}_=_\V{bufferStart}+(\K{sizeof}(\K{char})_\*_\V{counter});__\1\1_\V{Once}_\V{extracted}_\V{the}}}
\L{\LB{____________________________________________________\1\1___\V{pointer}_\V{moves}_\V{on}}}
\L{\LB{_\V{realign}(\V{packPoint});__\1\1_\V{Fix}_\V{up}_\V{the}_\V{packPoint}_\V{and}_\V{other}_\V{associated}_\V{pointers}}}
\L{\LB{}}
\L{\LB{_\1\1_\V{bufferEnd}_\V{has}_\V{been}_\V{set}_\V{by}_\V{the}_\V{member}_\V{function}_\V{sizeup}_\1\1}}
\L{\LB{_\K{return}_\V{TRUE};}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1}}
\L{\LB{\1\1\V{Function}:_\V{calculateSize}}}
\L{\LB{\1\1\V{Author}:_\V{Dean}_\V{Thompson}}}
\L{\LB{\1\1\V{Created}:_15th_\V{August}_1996}}
\L{\LB{\1\1\V{Last}_\V{Modified}:_4th_\V{October}_1996}}
\L{\LB{\1\1\V{Description}:__\V{This}_\V{function}_\V{is}}}
\L{\LB{\1\1__\V{responsible}_\K{for}_\V{counting}_\V{the}_\V{number}}}
\L{\LB{\1\1__\V{of}_\V{elements}_\V{that}_\V{are}_\V{located}_\V{within}}}
\L{\LB{\1\1__\V{the}_\V{buffer}_\V{and}_\V{returning}_\V{that}_}}
\L{\LB{\1\1__\V{number}_\V{back}_\V{so}_\V{that}_\V{a}_\V{decision}_\V{about}}}
\L{\LB{\1\1__\V{dynamic}_\V{memory}_\V{allocation}_\V{can}_\V{be}_}}
\L{\LB{\1\1__\V{made}}}
\L{\LB{\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1}}
\L{\LB{}}
\L{\LB{\K{int}_\V{Buffer}::\V{calculateSize}_()}}
\L{\LB{\{}}
\L{\LB{_\K{int}_\V{counter}=0;}}
\L{\LB{_\K{return}_(\V{packPoint}\-\V{bufferStart});}}
\L{\LB{\}}}
\L{\LB{}}
\L{\LB{\K{\#ifdef}_\V{NO\_INLINES}}}
\L{\LB{\K{\#}__\K{define}_\V{BUFFER\_CC\_}}}
\L{\LB{\K{\#}__\K{include}_\S{}\"Common\1Buffer.n\"\SE{}}}
\L{\LB{\K{\#}__\K{undef}_\V{BUFFER\_CC\_}}}
\L{\LB{\K{\#endif}}}
\L{\LB{}}