mirror of
https://github.com/zeek/zeek.git
synced 2025-10-02 06:38:20 +00:00
21cf20fc6f
The type used to store the index for a case-type now tracks the type of the index expression rather than always using an "int". The case fields also now have some checking done at code-gen-time to ensure the constants used for cases does not exceed the numeric limit of the type used in the case's index expression. Then, assuming, it looks safe, the C++ case labels are generated with casts to the type of the Binpac case's index expression to ensure compilers accept it (since all Binpac numbers use "int" for storage/printing internally).
133 lines
2.6 KiB
C++
133 lines
2.6 KiB
C++
#ifndef binpac_exception_h
|
|
#define binpac_exception_h
|
|
|
|
#include <stdint.h>
|
|
#include <inttypes.h>
|
|
|
|
namespace binpac {
|
|
|
|
class Exception
|
|
{
|
|
public:
|
|
Exception(const char* m = 0)
|
|
: msg_("binpac exception: ")
|
|
{
|
|
if ( m )
|
|
append(m);
|
|
// abort();
|
|
}
|
|
|
|
void append(string m) { msg_ += m; }
|
|
string msg() const { return msg_; }
|
|
const char* c_msg() const { return msg_.c_str(); }
|
|
|
|
protected:
|
|
string msg_;
|
|
};
|
|
|
|
class ExceptionEnforceViolation : public Exception
|
|
{
|
|
public:
|
|
ExceptionEnforceViolation(const char* where)
|
|
{
|
|
append(binpac_fmt("&enforce violation : %s", where));
|
|
}
|
|
};
|
|
|
|
class ExceptionOutOfBound : public Exception
|
|
{
|
|
public:
|
|
ExceptionOutOfBound(const char* where, int len_needed, int len_given)
|
|
{
|
|
append(binpac_fmt("out_of_bound: %s: %d > %d",
|
|
where, len_needed, len_given));
|
|
}
|
|
};
|
|
|
|
class ExceptionInvalidCase : public Exception
|
|
{
|
|
public:
|
|
ExceptionInvalidCase(const char* location,
|
|
int64_t index,
|
|
const char *expected)
|
|
: location_(location),
|
|
index_(index),
|
|
expected_(expected)
|
|
{
|
|
append(binpac_fmt("invalid case: %s: %" PRIi64 " (%s)",
|
|
location, index, expected));
|
|
}
|
|
|
|
protected:
|
|
const char* location_;
|
|
int64_t index_;
|
|
string expected_;
|
|
};
|
|
|
|
class ExceptionInvalidCaseIndex : public Exception
|
|
{
|
|
public:
|
|
ExceptionInvalidCaseIndex(const char* location,
|
|
int64_t index)
|
|
: location_(location),
|
|
index_(index)
|
|
{
|
|
append(binpac_fmt("invalid index for case: %s: %" PRIi64,
|
|
location, index));
|
|
}
|
|
|
|
protected:
|
|
const char* location_;
|
|
int64_t index_;
|
|
};
|
|
|
|
class ExceptionInvalidOffset : public Exception
|
|
{
|
|
public:
|
|
ExceptionInvalidOffset(const char* location,
|
|
int min_offset, int offset)
|
|
: location_(location),
|
|
min_offset_(min_offset), offset_(offset)
|
|
{
|
|
append(binpac_fmt("invalid offset: %s: min_offset = %d, offset = %d",
|
|
location, min_offset, offset));
|
|
}
|
|
|
|
protected:
|
|
const char* location_;
|
|
int min_offset_, offset_;
|
|
};
|
|
|
|
class ExceptionStringMismatch : public Exception
|
|
{
|
|
public:
|
|
ExceptionStringMismatch(const char* location,
|
|
const char *expected, const char *actual_data)
|
|
{
|
|
append(binpac_fmt("string mismatch at %s: \nexpected pattern: \"%s\"\nactual data: \"%s\"",
|
|
location, expected, actual_data));
|
|
}
|
|
};
|
|
|
|
class ExceptionInvalidStringLength : public Exception
|
|
{
|
|
public:
|
|
ExceptionInvalidStringLength(const char* location, int len)
|
|
{
|
|
append(binpac_fmt("invalid length string: %s: %d",
|
|
location, len));
|
|
}
|
|
};
|
|
|
|
class ExceptionFlowBufferAlloc : public Exception
|
|
{
|
|
public:
|
|
ExceptionFlowBufferAlloc(const char* reason)
|
|
{
|
|
append(binpac_fmt("flowbuffer allocation failed: %s", reason));
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif // binpac_exception_h
|