colin
/
tripwire-open-source
mirror of https://github.com/Tripwire/tripwire-open-source.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
tripwire-open-source/src/core/displayencoder.cpp

823 lines
25 KiB
C++
Raw Blame History

//
// The developer of the original code and/or files is Tripwire, Inc.
// Portions created by Tripwire, Inc. are copyright (C) 2000-2018 Tripwire,
// Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights
// reserved.
//
// This program is free software. The contents of this file are subject
// to the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your
// option) any later version. You may redistribute it and/or modify it
// only in compliance with the GNU General Public License.
//
// This program is distributed in the hope that it will be useful.
// However, this program is distributed AS-IS WITHOUT ANY
// WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS
// FOR A PARTICULAR PURPOSE. Please see the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
//
// Nothing in the GNU General Public License or any other license to use
// the code or files shall permit you to use Tripwire's trademarks,
// service marks, or other intellectual property without Tripwire's
// prior written consent.
//
// If you have any questions, please contact Tripwire, Inc. at either
// info@tripwire.org or www.tripwire.org.
//
///////////////////////////////////////////////////////////////////////////////
// displayencoder.cpp
//
//=========================================================================
// INCLUDES
//=========================================================================
#include "stdcore.h"
#include "displayencoder.h"
#include "charutil.h"
#include "debug.h"
#include "twlocale.h"
#include "stringutil.h"
#include "errorutil.h"
#include "ntmbs.h"
#include "codeconvert.h"
//=========================================================================
// STANDARD LIBRARY INCLUDES
//=========================================================================
#include <iomanip>
#include <iterator>
//=========================================================================
// DEFINES AND MACROS
//=========================================================================
// uncomment this to test schema
// #define TSS_DO_SCHEMA_VALIDATION
//////////////////////////////////////////////////////////////////////////////
// ENCODER UTILITIES
//////////////////////////////////////////////////////////////////////////////
inline bool IsSingleTCHAR(TSTRING::const_iterator first, TSTRING::const_iterator last)
{
return (first + 1 == last);
}
//////////////////////////////////////////////////////////////////////////////
// CHAR ENCODER INTERFACE
//////////////////////////////////////////////////////////////////////////////
// all derived classes should encode a char to "EscapeChar() + Identifier() + Encode( char ) [ + Identifier() ]"
class iCharEncoder
{
public:
virtual ~iCharEncoder(){};
virtual bool NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const = 0;
// Determines if character identified by [first,last) needs encoding.
// Returns true if it does.
virtual TSTRING EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const = 0;
// Encodes character identified by [first,last) in such a way that it
// can be decoded by Decode(). Returns encoded character sequence.
virtual TSTRING EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const = 0;
// Encodes character identified by [first,last) in a manner that is not roundtrip,
// but looks good. Returns encoded character sequence.
virtual TSTRING Decode(TSTRING::const_iterator* pcur, const TSTRING::const_iterator end) const = 0;
// Decodes character sequence beginning with '*pcur' and ending before 'end'.
// Returns decoded character or sequence of characters. Advances *pcur beyond
// the last character decoded.
virtual TCHAR Identifier() const = 0;
static TCHAR EscapeChar()
{
return char_escape;
}
protected:
static TCHAR char_escape;
};
class cNonNarrowableCharEncoder : public iCharEncoder
{
public:
virtual ~cNonNarrowableCharEncoder()
{
}
virtual bool NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING Decode(TSTRING::const_iterator* cur, const TSTRING::const_iterator end) const;
virtual TCHAR Identifier() const;
private:
static TCHAR char_identifier;
static TCHAR char_replace;
};
class cNonPrintableCharEncoder : public iCharEncoder
{
public:
cNonPrintableCharEncoder(bool f_allowWS) : m_allowWS(f_allowWS){};
virtual ~cNonPrintableCharEncoder()
{
}
virtual bool NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING Decode(TSTRING::const_iterator* cur, const TSTRING::const_iterator end) const;
virtual TCHAR Identifier() const;
private:
static TCHAR char_identifier;
static TCHAR char_replace;
bool m_allowWS;
};
class cQuoteCharEncoder : public iCharEncoder
{
public:
virtual ~cQuoteCharEncoder()
{
}
virtual bool NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING Decode(TSTRING::const_iterator* cur, const TSTRING::const_iterator end) const;
virtual TCHAR Identifier() const;
private:
static TCHAR char_test;
static TCHAR char_identifier;
static TCHAR char_replace;
};
class cBackslashCharEncoder : public iCharEncoder
{
public:
virtual ~cBackslashCharEncoder()
{
}
virtual bool NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const;
virtual TSTRING Decode(TSTRING::const_iterator* cur, const TSTRING::const_iterator end) const;
virtual TCHAR Identifier() const;
private:
static TCHAR char_test;
static TCHAR char_identifier;
static TCHAR char_replace;
};
//////////////////////////////////////////////////////////////////////////////
// CHARACTER SPECIALIZATIONS
//////////////////////////////////////////////////////////////////////////////
TCHAR iCharEncoder::char_escape = _T('\\');
TCHAR cNonNarrowableCharEncoder::char_identifier = _T('x');
TCHAR cNonPrintableCharEncoder::char_identifier = _T('x');
TCHAR cQuoteCharEncoder::char_identifier = _T('\"');
TCHAR cBackslashCharEncoder::char_identifier = _T('\\');
TCHAR cBackslashCharEncoder::char_test = cBackslashCharEncoder::char_identifier;
TCHAR cQuoteCharEncoder::char_test = cQuoteCharEncoder::char_identifier;
TCHAR cBackslashCharEncoder::char_replace = cBackslashCharEncoder::char_identifier;
TCHAR cQuoteCharEncoder::char_replace = cQuoteCharEncoder::char_identifier;
TCHAR cNonNarrowableCharEncoder::char_replace = _T('?');
TCHAR cNonPrintableCharEncoder::char_replace = _T('?');
//////////////////////////////////////////////////////////////////////////////
// TESTS
//////////////////////////////////////////////////////////////////////////////
bool cNonNarrowableCharEncoder::NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
return false; // all chars are narrow
}
bool cNonPrintableCharEncoder::NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
// TODO:BAM -- handle this with mb chars
// std::isprint<wchar_t> does a wctob() on the wchar!!?!?!
// what's up with that? Maybe ignore this all together and
// just do a isprint like KAI does?
// HYPOTHESIS: all mb characters are printable. only sb ASCII
// chars that would have C isprint() return false actually aren't printable
// So escape chars, and tabs and such are only in sb chars that C isprint() would check.
// HMMMM: true in all locales, though? (LC_CTYPE is checked for C isprint(), though...)
// Sooooo... it should be something like
//
// #ifdef _UNICODE
// char nch = wctob( ch );
// return( nch != EOF && ! isprint( nch ) );
// #else
// return( ! isprint( ch ) );
// #endif
//
// assuming all unprintable chars are one TCHAR long
if (!IsSingleTCHAR(first, last))
return false;
if (m_allowWS && cCharEncoderUtil::IsWhiteSpace(*first))
return false;
return cCharEncoderUtil::IsPrintable(*first);
}
bool cQuoteCharEncoder::NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
return (IsSingleTCHAR(first, last) && (*first == char_test));
}
bool cBackslashCharEncoder::NeedsEncoding(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
return (IsSingleTCHAR(first, last) && (*first == char_test));
}
//////////////////////////////////////////////////////////////////////////////
// ROUNDTRIP ENCODINGS
//////////////////////////////////////////////////////////////////////////////
TSTRING cNonNarrowableCharEncoder::EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
TSTRING str;
str += char_escape;
str += char_identifier;
str += cCharEncoderUtil::CharStringToHexValue(TSTRING(first, last));
return str;
}
TSTRING cNonPrintableCharEncoder::EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
ASSERT(IsSingleTCHAR(first, last)); // non-prints are single char (see NOTE above)
TSTRING str;
str += char_escape;
str += char_identifier;
str += cCharEncoderUtil::CharStringToHexValue(TSTRING(first, last));
return str;
}
TSTRING cQuoteCharEncoder::EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
// should just be a quote
ASSERT(IsSingleTCHAR(first, last));
ASSERT(*first == char_test);
TSTRING str;
str += char_escape;
str += char_identifier;
return str;
}
TSTRING cBackslashCharEncoder::EncodeRoundtrip(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
// should just be a backslash
ASSERT(IsSingleTCHAR(first, last));
ASSERT(*first == char_test);
TSTRING str;
str += char_escape;
str += char_identifier;
return str;
}
//////////////////////////////////////////////////////////////////////////////
// NON-ROUNDTRIP ENCODINGS
//////////////////////////////////////////////////////////////////////////////
TSTRING cNonNarrowableCharEncoder::EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
return EncodeRoundtrip(first, last);
}
TSTRING cNonPrintableCharEncoder::EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
return EncodeRoundtrip(first, last);
}
TSTRING cQuoteCharEncoder::EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
// should just be a quote
ASSERT(IsSingleTCHAR(first, last));
ASSERT(*first == char_test);
return TSTRING(1, char_replace);
}
TSTRING cBackslashCharEncoder::EncodePretty(TSTRING::const_iterator first, TSTRING::const_iterator last) const
{
// should just be a backslash
ASSERT(IsSingleTCHAR(first, last));
ASSERT(*first == char_test);
return TSTRING(1, char_replace);
}
//////////////////////////////////////////////////////////////////////////////
// DECODINGS
//////////////////////////////////////////////////////////////////////////////
TSTRING cNonNarrowableCharEncoder::Decode(TSTRING::const_iterator* pcur, const TSTRING::const_iterator end) const
{
// check preconditions
if ((*pcur) >= end || *(*pcur) != Identifier())
ThrowAndAssert(eBadDecoderInput());
return (cCharEncoderUtil::DecodeHexToChar(pcur, end));
}
TSTRING cNonPrintableCharEncoder::Decode(TSTRING::const_iterator* pcur, const TSTRING::const_iterator end) const
{
// check preconditions
if ((*pcur) >= end || *(*pcur) != Identifier())
ThrowAndAssert(eBadDecoderInput());
return (cCharEncoderUtil::DecodeHexToChar(pcur, end));
}
TSTRING cQuoteCharEncoder::Decode(TSTRING::const_iterator* pcur, const TSTRING::const_iterator end) const
{
if ((*pcur) >= end || *(*pcur) != Identifier())
ThrowAndAssert(eBadDecoderInput());
(*pcur)++; // advance past part decoded
return TSTRING(1, Identifier());
}
TSTRING cBackslashCharEncoder::Decode(TSTRING::const_iterator* pcur, const TSTRING::const_iterator end) const
{
if ((*pcur) >= end || *(*pcur) != Identifier())
ThrowAndAssert(eBadDecoderInput());
(*pcur)++; // advance past part decoded
return TSTRING(1, Identifier());
}
//////////////////////////////////////////////////////////////////////////////
// IDENTIFIERS
//////////////////////////////////////////////////////////////////////////////
TCHAR cNonNarrowableCharEncoder::Identifier() const
{
return char_identifier;
}
TCHAR cNonPrintableCharEncoder::Identifier() const
{
return char_identifier;
}
TCHAR cQuoteCharEncoder::Identifier() const
{
return char_identifier;
}
TCHAR cBackslashCharEncoder::Identifier() const
{
return char_identifier;
}
//////////////////////////////////////////////////////////////////////////////
// UTILITIES
//////////////////////////////////////////////////////////////////////////////
bool cCharEncoderUtil::IsWhiteSpace(TCHAR ch)
{
return (ch == '\r' || ch == '\n' || ch == '\t' || ch == '\v' || ch == ' ');
}
bool cCharEncoderUtil::IsPrintable(TCHAR ch)
{
#if USE_CLIB_LOCALE && !defined(__APPLE__)
return (!isprint(ch)); // kludge for KAI
#else // USE_CLIB_LOCALE
return (!std::isprint<TCHAR>(ch, std::locale()));
#endif // USE_CLIB_LOCALE
}
TSTRING cCharEncoderUtil::CharStringToHexValue(const TSTRING& str)
{
TSTRING strOut;
TSTRING::const_iterator at;
for (at = str.begin(); at < str.end(); at++)
{
strOut += char_to_hex(*at);
}
return strOut;
}
TSTRING cCharEncoderUtil::HexValueToCharString(const TSTRING& str)
{
TSTRING strOut;
TSTRING::const_iterator at;
for (at = str.begin(); at < str.end(); at += TCHAR_AS_HEX__IN_TCHARS)
{
strOut += hex_to_char(at, at + TCHAR_AS_HEX__IN_TCHARS);
}
return strOut;
}
TCHAR cCharEncoderUtil::hex_to_char(TSTRING::const_iterator first, TSTRING::const_iterator last)
{
static const TCHAR max_char = std::numeric_limits<TCHAR>::max();
static const TCHAR min_char = std::numeric_limits<TCHAR>::min();
if (first + TCHAR_AS_HEX__IN_TCHARS != last)
ThrowAndAssert(eBadHexConversion());
TISTRINGSTREAM ss(TSTRING(first, last));
ss.imbue(std::locale::classic());
ss.fill(_T('0'));
ss.setf(std::ios_base::hex, std::ios_base::basefield);
unsigned long ch;
ss >> ch;
if (ss.bad() || ss.fail())
ThrowAndAssert(eBadHexConversion(TSTRING(first, last)));
if ((TCHAR)ch > max_char || (TCHAR)ch < min_char)
ThrowAndAssert(eBadHexConversion(TSTRING(first, last)));
return (TCHAR)ch;
}
TSTRING cCharEncoderUtil::char_to_hex(TCHAR ch)
{
TOSTRINGSTREAM ss;
ss.imbue(std::locale::classic());
ss.fill(_T('0'));
ss.width(TCHAR_AS_HEX__IN_TCHARS);
ss.setf(std::ios_base::hex, std::ios_base::basefield);
ss << tss::util::char_to_size(ch);
if (ss.bad() || ss.fail() || ss.str().length() != TCHAR_AS_HEX__IN_TCHARS)
ThrowAndAssert(eBadHexConversion(TSTRING(1, ch)));
return ss.str();
}
TSTRING cCharEncoderUtil::DecodeHexToChar(TSTRING::const_iterator* pcur, const TSTRING::const_iterator end)
{
// get hex numbers -- 2 chars
TSTRING str;
size_t n = 0;
for ((*pcur)++; n < TCHAR_AS_HEX__IN_TCHARS && (*pcur) != end; n++, (*pcur)++)
{
str += *(*pcur);
}
if (n != TCHAR_AS_HEX__IN_TCHARS)
ThrowAndAssert(eBadDecoderInput());
// convert hex numbers
return HexValueToCharString(str);
}
//////////////////////////////////////////////////////////////////////////////
// ENCODER MEMBERS
//////////////////////////////////////////////////////////////////////////////
cEncoder::cEncoder(int e, int f) : m_fFlags(f)
{
// add encodings
if (e & NON_NARROWABLE)
m_encodings.push_back(new cNonNarrowableCharEncoder);
if (e & NON_PRINTABLE)
m_encodings.push_back(new cNonPrintableCharEncoder(AllowWhiteSpace()));
if (e & BACKSLASH)
m_encodings.push_back(new cBackslashCharEncoder);
if (e & DBL_QUOTE)
m_encodings.push_back(new cQuoteCharEncoder);
// assert that we weren't passed anything freaky
ASSERT(0 == (e & ~(NON_NARROWABLE | NON_PRINTABLE | BACKSLASH | DBL_QUOTE)));
// add flags
ASSERT(!((m_fFlags & ROUNDTRIP) && (m_fFlags & NON_ROUNDTRIP)));
#ifdef TSS_DO_SCHEMA_VALIDATION
// check assumptions about encodings
ValidateSchema();
#endif
}
cEncoder::~cEncoder()
{
sack_type::iterator itr;
for (itr = m_encodings.begin(); itr != m_encodings.end(); ++itr)
delete *itr;
}
bool cEncoder::RoundTrip() const
{
return (0 != (m_fFlags & ROUNDTRIP));
}
bool cEncoder::AllowWhiteSpace() const
{
return (0 != (m_fFlags & ALLOW_WHITESPACE));
}
//////////////////////////////////////////////////////////////////////////////
// ENCODER BASIC FUNCTIONALITY
//////////////////////////////////////////////////////////////////////////////
void cEncoder::Encode(TSTRING& strIn) const
{
// TODO:BAM -- reserve space for strOut as an optimization?
TSTRING strOut; // encoded string we will build up
TSTRING::const_iterator cur = strIn.begin(); // pointer to working position in strIn
const TSTRING::const_iterator end = strIn.end(); // end of strIn
TSTRING::const_iterator first = end; // identifies beginning of current character
TSTRING::const_iterator last = end; // identifies end of current character
// while get next char (updates cur)
while (cCharUtil::PopNextChar(cur, end, first, last))
{
bool fCharEncoded = false; // answers: did char need encoding?
sack_type::const_iterator atE;
// for all encoders
for (atE = m_encodings.begin(); atE != m_encodings.end(); atE++)
{
// does char need encoding?
if ((*atE)->NeedsEncoding(first, last))
{
strOut += Encode(first, last, atE);
fCharEncoded = true;
break; // each char should only fail at most one
// encoding test, so it should be cool to quit
}
}
if (!fCharEncoded)
{
strOut.append(first, last); // simply add current char to output since it needed no encoding
}
}
// pass back encoded string
strIn = strOut;
}
TSTRING
cEncoder::Encode(TSTRING::const_iterator first, TSTRING::const_iterator last, sack_type::const_iterator encoding) const
{
// encode it
if (RoundTrip())
return (*encoding)->EncodeRoundtrip(first, last);
else
return (*encoding)->EncodePretty(first, last);
}
void cEncoder::Decode(TSTRING& strIn) const
{
// TODO:BAM -- reserve space for strOut as an optimization?
TSTRING strOut; // decoded string we will build up
TSTRING::const_iterator cur = strIn.begin(); // pointer to working position in strIn
const TSTRING::const_iterator end = strIn.end(); // end of strIn
TSTRING::const_iterator first = end; // identifies beginning of current character
TSTRING::const_iterator last = end; // identifies end of current character
// while get next char (updates cur)
while (cCharUtil::PopNextChar(cur, end, first, last))
{
// is this char the escape character?
if (IsSingleTCHAR(first, last) && *first == iCharEncoder::EscapeChar())
{
// get to identifier
if (!cCharUtil::PopNextChar(cur, end, first, last))
ThrowAndAssert(eBadDecoderInput());
// this algorithm assumes that all identifiers are single char
// so anything following the escape char should be a
// single-char identifier
if (!IsSingleTCHAR(first, last))
THROW_INTERNAL("displayencoder.cpp");
// determine to which encoding the identifier belongs
bool fFoundEncoding = false;
sack_type::const_iterator atE;
for (atE = m_encodings.begin(); atE != m_encodings.end(); atE++)
{
// is this the right encoding?
if (*first == (*atE)->Identifier())
{
// this is the correct encoding....
fFoundEncoding = true;
// ...so decode char
strOut += (*atE)->Decode(&first, end); // should modify cur
cur = first; // advance current char pointer
break; // no need to run other tests after
// this because all identifiers should be unique
}
}
if (!fFoundEncoding)
ThrowAndAssert(eUnknownEscapeEncoding(TSTRING(1, *first)));
}
else
{
strOut.append(first, last);
}
}
strIn = strOut;
}
//////////////////////////////////////////////////////////////////////////////
// ENCODER SCHEMA VALIDATION
//////////////////////////////////////////////////////////////////////////////
void cEncoder::ValidateSchema() const
{
ASSERT(OnlyOneCatagoryPerChar());
ASSERT(AllIdentifiersUnique());
}
// only tests single TCHAR characters (but of those, tests all of them)
bool cEncoder::OnlyOneCatagoryPerChar() const
{
// TODO:BAM - man, is there a better way to do this?
TCHAR ch = std::numeric_limits<TCHAR>::min();
TSTRING ach(1, ch);
if (ch != std::numeric_limits<TCHAR>::max())
{
do
{
bool fFailedATest = false;
ach[0] = ch;
for (sack_type::const_iterator atE = m_encodings.begin(); atE != m_encodings.end(); atE++)
{
if ((*atE)->NeedsEncoding(ach.begin(), ach.end()))
{
if (fFailedATest)
return false; // each char can only fail one test
else
fFailedATest = true;
}
}
ch++;
} while (ch != std::numeric_limits<TCHAR>::max());
}
return true;
}
bool cEncoder::AllIdentifiersUnique() const
{
TSTRING chars;
for (sack_type::const_iterator atE = m_encodings.begin(); atE != m_encodings.end(); atE++)
{
TCHAR chID = (*atE)->Identifier();
if (chars.find(chID) == TSTRING::npos)
chars += chID;
else
return false;
}
return true;
}
bool cEncoder::AllTestsRunOnEncodedString(const TSTRING& s) const
{
TSTRING::const_iterator cur = s.begin(); // pointer to working position in s
const TSTRING::const_iterator end = s.end(); // end of s
TSTRING::const_iterator first = end; // identifies beginning of current character
TSTRING::const_iterator last = end; // identifies end of current character
// while get next char (updates cur)
while (cCharUtil::PopNextChar(cur, end, first, last))
{
sack_type::const_iterator atE;
for (atE = m_encodings.begin(); atE != m_encodings.end(); atE++)
{
if ((*atE)->NeedsEncoding(first, last))
{
return false;
}
}
}
return true;
}
//////////////////////////////////////////////////////////////////////////////
// cDisplayEncoder MEMBERS
//////////////////////////////////////////////////////////////////////////////
cDisplayEncoder::cDisplayEncoder(Flags f) : cEncoder(NON_NARROWABLE | NON_PRINTABLE | BACKSLASH | DBL_QUOTE, f)
{
}
void cDisplayEncoder::Encode(TSTRING& str) const
{
cEncoder::Encode(str);
}
bool cDisplayEncoder::Decode(TSTRING& str) const
{
cEncoder::Decode(str);
return true; // TODO:BAM -- throw error!
}
Reference in New Issue View Git Blame Copy Permalink