Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-01 22:28:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge remote-tracking branch 'origin/topic/timw/tools-clang-tidy'

Browse source 
* origin/topic/timw/tools-clang-tidy:
  gen-zam: Move source files up a directory
  bifcl: Fix clang-tidy warnings
  bifcl: Run clang-format on c++ code embedded in builtin-func.{l,y}
  binpac: Fix a large number of clang-tidy warnings
  binpac: Replace delete_list macro uses
  binpac: Run clang-format on c++ code embedded in pac_parse.{ll,yy}
This commit is contained in:
Tim Wojtulewicz 2025-08-28 15:19:59 -07:00
commit 273abf3d08
64 changed files with 809 additions and 823 deletions
Download patch file Download diff file Expand all files Collapse all files

14
CHANGES
View file

@ -1,3 +1,17 @@
8.1.0-dev.475 | 2025-08-28 15:19:59 -0700
* gen-zam: Move source files up a directory (Tim Wojtulewicz, Corelight)
* bifcl: Fix clang-tidy warnings (Tim Wojtulewicz, Corelight)
* bifcl: Run clang-format on c++ code embedded in builtin-func.{l,y} (Tim Wojtulewicz, Corelight)
* binpac: Fix a large number of clang-tidy warnings (Tim Wojtulewicz, Corelight)
* binpac: Replace delete_list macro uses (Tim Wojtulewicz, Corelight)
* binpac: Run clang-format on c++ code embedded in pac_parse.{ll,yy} (Tim Wojtulewicz, Corelight)
8.1.0-dev.468 | 2025-08-28 13:06:25 -0700
* Link Prometheus symbols via Broker instead of directly (Tim Wojtulewicz, Corelight)

2
VERSION
View file

@ -1 +1 @@
8.1.0-dev.468
8.1.0-dev.475

7
tools/bifcl/CMakeLists.txt
View file

@ -12,8 +12,15 @@ add_flex_bison_dependency(BIFScanner BIFParser)
set(bifcl_SRCS ${BISON_BIFParser_INPUT} ${FLEX_BIFScanner_INPUT} ${BISON_BIFParser_OUTPUTS}
${FLEX_BIFScanner_OUTPUTS} bif_arg.cc module_util.cc)
set(bifcl_bison_generated_files
${CMAKE_CURRENT_BINARY_DIR}/bif_parse.cc ${CMAKE_CURRENT_BINARY_DIR}/bif_parse.h
${CMAKE_CURRENT_BINARY_DIR}/bif_lex.cc)
set_source_files_properties(${bifcl_bison_generated_files} PROPERTIES SKIP_LINTING ON)
add_executable(bifcl ${bifcl_SRCS})
target_include_directories(bifcl BEFORE PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
zeek_target_add_linters(bifcl)
if (MSVC)
target_compile_options(bifcl PUBLIC "/J") # Similar to -funsigned-char on other platforms

3
tools/bifcl/bif_arg.cc
View file

@ -1,6 +1,6 @@
// See the file "COPYING" in the main distribution directory for copyright.
#include "bif_arg.h"
#include "include/bif_arg.h"
#include <cstring>
@ -16,6 +16,7 @@ static struct {
const char* constructor;
const char* ctor_smart;
} builtin_func_arg_type[] = {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define DEFINE_BIF_TYPE(id, bif_type, zeek_type, c_type, c_type_smart, accessor, accessor_smart, cast_smart, \
constructor, ctor_smart) \
{#id, bif_type, zeek_type, c_type, c_type_smart, accessor, accessor_smart, cast_smart, constructor, ctor_smart},

460
tools/bifcl/builtin-func.l
View file

@ -143,11 +143,10 @@ HEX [0-9a-fA-F]+
}
%%
int yywrap()
{
yy_delete_buffer(YY_CURRENT_BUFFER);
return 1;
}
int yywrap() {
yy_delete_buffer(YY_CURRENT_BUFFER);
return 1;
}
extern int yyparse();
char* input_filename = nullptr;
@ -171,297 +170,272 @@ void close_if_open(FILE **fpp);
void close_all_output_files(void);
FILE* open_output_file(const char* surfix)
{
char fn[1024];
FILE* fp;
FILE* open_output_file(const char* surfix) {
char fn[1024];
FILE* fp;
snprintf(fn, sizeof(fn), "%s.%s", input_filename, surfix);
if ( (fp = fopen(fn, "w")) == NULL )
{
fprintf(stderr, "Error: cannot open file: %s\n", fn);
err_exit();
}
snprintf(fn, sizeof(fn), "%s.%s", input_filename, surfix);
if ( fp = fopen(fn, "w"); fp == nullptr ) {
fprintf(stderr, "Error: cannot open file: %s\n", fn);
err_exit();
}
return fp;
}
return fp;
}
void usage()
{
fprintf(stderr, "usage: bifcl [-p <plugin> | -s] *.bif\n");
exit(1);
}
void usage() {
fprintf(stderr, "usage: bifcl [-p <plugin> | -s] *.bif\n");
exit(1);
}
void init_alternative_mode()
{
fp_zeek_init = open_output_file("zeek");
fp_func_h = open_output_file("h");
fp_func_def = open_output_file("cc");
fp_func_init = open_output_file("init.cc");
fp_func_register = plugin ? open_output_file("register.cc") : nullptr;
void init_alternative_mode() {
fp_zeek_init = open_output_file("zeek");
fp_func_h = open_output_file("h");
fp_func_def = open_output_file("cc");
fp_func_init = open_output_file("init.cc");
fp_func_register = plugin ? open_output_file("register.cc") : nullptr;
fp_netvar_h = fp_func_h;
fp_netvar_def = fp_func_def;
fp_netvar_init = fp_func_init;
fp_netvar_h = fp_func_h;
fp_netvar_def = fp_func_def;
fp_netvar_init = fp_func_init;
int n = 1024 + strlen(input_filename);
auto auto_gen_comment_buf = std::make_unique<char[]>(n);
auto auto_gen_comment = auto_gen_comment_buf.get();
int n = 1024 + strlen(input_filename);
auto auto_gen_comment_buf = std::make_unique<char[]>(n);
auto auto_gen_comment = auto_gen_comment_buf.get();
snprintf(auto_gen_comment, n,
"This file was automatically generated by bifcl from %s (%s mode).",
input_filename_with_path, plugin ? "plugin" : "alternative");
snprintf(auto_gen_comment, n, "This file was automatically generated by bifcl from %s (%s mode).",
input_filename_with_path, plugin ? "plugin" : "alternative");
fprintf(fp_zeek_init, "# %s\n\n", auto_gen_comment);
fprintf(fp_func_def, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "#pragma once\n\n");
fprintf(fp_func_init, "// %s\n\n", auto_gen_comment);
fprintf(fp_zeek_init, "# %s\n\n", auto_gen_comment);
fprintf(fp_func_def, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "#pragma once\n\n");
fprintf(fp_func_init, "// %s\n\n", auto_gen_comment);
if ( fp_func_register )
fprintf(fp_func_register, "// %s\n\n", auto_gen_comment);
if ( fp_func_register )
fprintf(fp_func_register, "// %s\n\n", auto_gen_comment);
static char guard[1024];
if ( getcwd(guard, sizeof(guard)) == NULL )
{
fprintf(stderr, "Error: cannot get current working directory\n");
err_exit();
}
strncat(guard, "/", sizeof(guard) - strlen(guard) - 1);
strncat(guard, input_filename, sizeof(guard) - strlen(guard) - 1);
static char guard[1024];
if ( getcwd(guard, sizeof(guard)) == nullptr ) {
fprintf(stderr, "Error: cannot get current working directory\n");
err_exit();
}
strncat(guard, "/", sizeof(guard) - strlen(guard) - 1);
strncat(guard, input_filename, sizeof(guard) - strlen(guard) - 1);
for ( char* p = guard; *p; p++ )
{
if ( ! isalnum(*p) )
*p = '_';
}
for ( char* p = guard; *p; p++ ) {
if ( ! isalnum(*p) )
*p = '_';
}
fprintf(fp_func_h, "#if defined(ZEEK_IN_NETVAR) || ! defined(%s)\n", guard);
fprintf(fp_func_h, "#if defined(ZEEK_IN_NETVAR) || ! defined(%s)\n", guard);
fprintf(fp_func_h, "#ifndef ZEEK_IN_NETVAR\n");
fprintf(fp_func_h, "#ifndef %s\n", guard);
fprintf(fp_func_h, "#define %s\n", guard);
fprintf(fp_func_h, "#include \"zeek/zeek-bif.h\"\n");
fprintf(fp_func_h, "#endif\n");
fprintf(fp_func_h, "#endif\n");
fprintf(fp_func_h, "\n");
fprintf(fp_func_h, "#ifndef ZEEK_IN_NETVAR\n");
fprintf(fp_func_h, "#ifndef %s\n", guard);
fprintf(fp_func_h, "#define %s\n", guard);
fprintf(fp_func_h, "#include \"zeek/zeek-bif.h\"\n");
fprintf(fp_func_h, "#endif\n");
fprintf(fp_func_h, "#endif\n");
fprintf(fp_func_h, "\n");
fprintf(fp_func_def, "\n");
fprintf(fp_func_def, "#include \"%s.h\"\n", input_filename);
fprintf(fp_func_def, "#include \"zeek/Func.h\"\n");
fprintf(fp_func_def, "\n");
fprintf(fp_func_def, "\n");
fprintf(fp_func_def, "#include \"%s.h\"\n", input_filename);
fprintf(fp_func_def, "#include \"zeek/Func.h\"\n");
fprintf(fp_func_def, "\n");
static char name[1024];
strncpy(name, input_filename, sizeof(name) - 1);
name[sizeof(name) - 1] = '\0';
char* dot = strchr(name, '.');
if ( dot )
*dot = '\0';
static char name[1024];
strncpy(name, input_filename, sizeof(name) - 1);
name[sizeof(name) - 1] = '\0';
char* dot = strchr(name, '.');
if ( dot )
*dot = '\0';
if ( plugin )
{
static char plugin_canon[1024];
strncpy(plugin_canon, plugin, sizeof(plugin_canon) - 1);
plugin_canon[sizeof(plugin_canon) - 1] = '\0';
char* colon = strstr(plugin_canon, "::");
if ( plugin ) {
static char plugin_canon[1024];
strncpy(plugin_canon, plugin, sizeof(plugin_canon) - 1);
plugin_canon[sizeof(plugin_canon) - 1] = '\0';
char* colon = strstr(plugin_canon, "::");
if ( colon ) {
*colon = '_';
memmove(colon + 1, colon + 2, plugin_canon + strlen(plugin_canon) - colon);
}
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "#include <list>\n");
fprintf(fp_func_init, "#include <string>\n");
fprintf(fp_func_init, "#include \"zeek/plugin/Plugin.h\"\n");
fprintf(fp_func_init, "#include \"zeek/Func.h\"\n");
fprintf(fp_func_init, "#include \"%s.h\"\n", input_filename);
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "namespace plugin::%s {\n", plugin_canon);
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "void __bif_%s_init(zeek::plugin::Plugin* plugin)\n", name);
fprintf(fp_func_init, "\t{\n");
fprintf(fp_func_register, "#include \"zeek/plugin/Manager.h\"\n");
fprintf(fp_func_register, "\n");
fprintf(fp_func_register, "namespace plugin::%s {\n", plugin_canon);
fprintf(fp_func_register, "void __bif_%s_init(zeek::plugin::Plugin* plugin);\n", name);
fprintf(fp_func_register, "zeek::plugin::detail::__RegisterBif __register_bifs_%s_%s(\"%s\", __bif_%s_init);\n", plugin_canon, name, plugin, name);
fprintf(fp_func_register, "}\n");
if ( colon ) {
*colon = '_';
memmove(colon + 1, colon + 2, plugin_canon + strlen(plugin_canon) - colon);
}
}
void finish_alternative_mode()
{
fprintf(fp_func_h, "\n");
fprintf(fp_func_h, "#endif\n");
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "#include <list>\n");
fprintf(fp_func_init, "#include <string>\n");
fprintf(fp_func_init, "#include \"zeek/plugin/Plugin.h\"\n");
fprintf(fp_func_init, "#include \"zeek/Func.h\"\n");
fprintf(fp_func_init, "#include \"%s.h\"\n", input_filename);
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "namespace plugin::%s {\n", plugin_canon);
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "void __bif_%s_init(zeek::plugin::Plugin* plugin)\n", name);
fprintf(fp_func_init, "\t{\n");
if ( plugin )
{
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "\t}\n");
fprintf(fp_func_init, "}\n");
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "\n");
}
}
fprintf(fp_func_register, "#include \"zeek/plugin/Manager.h\"\n");
fprintf(fp_func_register, "\n");
fprintf(fp_func_register, "namespace plugin::%s {\n", plugin_canon);
fprintf(fp_func_register, "void __bif_%s_init(zeek::plugin::Plugin* plugin);\n", name);
fprintf(fp_func_register, "zeek::plugin::detail::__RegisterBif __register_bifs_%s_%s(\"%s\", __bif_%s_init);\n",
plugin_canon, name, plugin, name);
fprintf(fp_func_register, "}\n");
}
}
void finish_alternative_mode() {
fprintf(fp_func_h, "\n");
fprintf(fp_func_h, "#endif\n");
if ( plugin ) {
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "\t}\n");
fprintf(fp_func_init, "}\n");
fprintf(fp_func_init, "\n");
fprintf(fp_func_init, "\n");
}
}
// GCC uses __SANITIZE_ADDRESS__, Clang uses __has_feature
#if defined(__SANITIZE_ADDRESS__)
#define USING_ASAN
#define USING_ASAN
#endif
#if defined(__has_feature)
#if __has_feature(address_sanitizer)
#define USING_ASAN
#endif
#if __has_feature(address_sanitizer)
#define USING_ASAN
#endif
#endif
// FreeBSD doesn't support LeakSanitizer
#if defined(USING_ASAN) && !defined(__FreeBSD__)
#include <sanitizer/lsan_interface.h>
#define BIFCL_LSAN_DISABLE() __lsan_disable()
#if defined(USING_ASAN) && ! defined(__FreeBSD__)
#include <sanitizer/lsan_interface.h>
#define BIFCL_LSAN_DISABLE() __lsan_disable()
#else
#define BIFCL_LSAN_DISABLE()
#define BIFCL_LSAN_DISABLE()
#endif
int main(int argc, char* argv[])
{
// We generally do not care at all if bifcl is leaking and the default
// behavior of LSAN to treat leaks as errors only trips up Zeek's build.
BIFCL_LSAN_DISABLE();
int main(int argc, char* argv[]) {
// We generally do not care at all if bifcl is leaking and the default
// behavior of LSAN to treat leaks as errors only trips up Zeek's build.
BIFCL_LSAN_DISABLE();
int opt;
int opt;
while ( (opt = getopt(argc, argv, "p:s")) != -1 )
{
switch ( opt ) {
case 'p':
alternative_mode = true;
plugin = (char*) optarg;
break;
while ( (opt = getopt(argc, argv, "p:s")) != -1 ) {
switch ( opt ) {
case 'p':
alternative_mode = true;
plugin = (char*)optarg;
break;
case 's':
alternative_mode = true;
break;
case 's': alternative_mode = true; break;
default:
usage();
}
}
default: usage();
}
}
for ( int i = optind; i < argc; i++ )
{
FILE* fp_input;
for ( int i = optind; i < argc; i++ ) {
FILE* fp_input;
input_filename = input_filename_with_path = argv[i];
char* slash = strrchr(input_filename, '/');
input_filename = input_filename_with_path = argv[i];
char* slash = strrchr(input_filename, '/');
if ( (fp_input = fopen(input_filename, "r")) == NULL )
{
fprintf(stderr, "Error: cannot open file: %s\n", input_filename);
/* no output files open. can simply exit */
exit(1);
}
if ( fp_input = fopen(input_filename, "r"); fp_input == nullptr ) {
fprintf(stderr, "Error: cannot open file: %s\n", input_filename);
/* no output files open. can simply exit */
exit(1);
}
if ( slash )
input_filename = slash + 1;
if ( slash )
input_filename = slash + 1;
if ( ! alternative_mode )
{
fp_zeek_init = open_output_file("zeek");
fp_func_h = open_output_file("func_h");
fp_func_def = open_output_file("func_def");
fp_func_init = open_output_file("func_init");
fp_netvar_h = open_output_file("netvar_h");
fp_netvar_def = open_output_file("netvar_def");
fp_netvar_init = open_output_file("netvar_init");
if ( ! alternative_mode ) {
fp_zeek_init = open_output_file("zeek");
fp_func_h = open_output_file("func_h");
fp_func_def = open_output_file("func_def");
fp_func_init = open_output_file("func_init");
fp_netvar_h = open_output_file("netvar_h");
fp_netvar_def = open_output_file("netvar_def");
fp_netvar_init = open_output_file("netvar_init");
int n = 1024 + strlen(input_filename);
auto auto_gen_comment_buf = std::make_unique<char[]>(n);
auto auto_gen_comment = auto_gen_comment_buf.get();
int n = 1024 + strlen(input_filename);
auto auto_gen_comment_buf = std::make_unique<char[]>(n);
auto auto_gen_comment = auto_gen_comment_buf.get();
snprintf(auto_gen_comment, n,
"This file was automatically generated by bifcl from %s.",
input_filename);
snprintf(auto_gen_comment, n, "This file was automatically generated by bifcl from %s.", input_filename);
fprintf(fp_zeek_init, "# %s\n\n", auto_gen_comment);
fprintf(fp_func_def, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "#pragma once\n\n");
fprintf(fp_func_init, "// %s\n\n", auto_gen_comment);
fprintf(fp_netvar_def, "// %s\n\n", auto_gen_comment);
fprintf(fp_netvar_h, "// %s\n\n", auto_gen_comment);
fprintf(fp_netvar_h, "#pragma once\n\n");
fprintf(fp_netvar_init, "// %s\n\n", auto_gen_comment);
}
fprintf(fp_zeek_init, "# %s\n\n", auto_gen_comment);
fprintf(fp_func_def, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "// %s\n\n", auto_gen_comment);
fprintf(fp_func_h, "#pragma once\n\n");
fprintf(fp_func_init, "// %s\n\n", auto_gen_comment);
fprintf(fp_netvar_def, "// %s\n\n", auto_gen_comment);
fprintf(fp_netvar_h, "// %s\n\n", auto_gen_comment);
fprintf(fp_netvar_h, "#pragma once\n\n");
fprintf(fp_netvar_init, "// %s\n\n", auto_gen_comment);
}
else
init_alternative_mode();
else
init_alternative_mode();
fprintf(fp_netvar_init, "#ifdef __GNUC__\n");
fprintf(fp_netvar_init, "#pragma GCC diagnostic push\n");
fprintf(fp_netvar_init, "#pragma GCC diagnostic ignored \"-Wdeprecated-declarations\"\n\n");
fprintf(fp_netvar_init, "#endif\n");
fprintf(fp_netvar_init, "#ifdef __GNUC__\n");
fprintf(fp_netvar_init, "#pragma GCC diagnostic push\n");
fprintf(fp_netvar_init, "#pragma GCC diagnostic ignored \"-Wdeprecated-declarations\"\n\n");
fprintf(fp_netvar_init, "#endif\n");
yy_switch_to_buffer(yy_create_buffer(fp_input, YY_BUF_SIZE));
yyparse();
yy_switch_to_buffer(yy_create_buffer(fp_input, YY_BUF_SIZE));
yyparse();
fprintf(fp_netvar_init, "#ifdef __GNUC__\n");
fprintf(fp_netvar_init, "\n\n#pragma GCC diagnostic pop\n");
fprintf(fp_netvar_init, "#endif\n");
fprintf(fp_netvar_init, "#ifdef __GNUC__\n");
fprintf(fp_netvar_init, "\n\n#pragma GCC diagnostic pop\n");
fprintf(fp_netvar_init, "#endif\n");
if ( alternative_mode )
finish_alternative_mode();
if ( alternative_mode )
finish_alternative_mode();
fclose(fp_input);
close_all_output_files();
fclose(fp_input);
close_all_output_files();
}
}
}
}
void close_if_open(FILE** fpp) {
if ( *fpp )
fclose(*fpp);
*fpp = nullptr;
}
void close_if_open(FILE **fpp)
{
if (*fpp)
fclose(*fpp);
*fpp = nullptr;
}
void close_all_output_files(void) {
close_if_open(&fp_zeek_init);
close_if_open(&fp_func_h);
close_if_open(&fp_func_def);
close_if_open(&fp_func_init);
close_if_open(&fp_func_register);
void close_all_output_files(void)
{
close_if_open(&fp_zeek_init);
close_if_open(&fp_func_h);
close_if_open(&fp_func_def);
close_if_open(&fp_func_init);
close_if_open(&fp_func_register);
if ( ! alternative_mode ) {
close_if_open(&fp_netvar_h);
close_if_open(&fp_netvar_def);
close_if_open(&fp_netvar_init);
}
}
if ( ! alternative_mode )
{
close_if_open(&fp_netvar_h);
close_if_open(&fp_netvar_def);
close_if_open(&fp_netvar_init);
}
}
void remove_file(const char* surfix) {
char fn[1024];
void remove_file(const char *surfix)
{
char fn[1024];
snprintf(fn, sizeof(fn), "%s.%s", input_filename, surfix);
unlink(fn);
}
snprintf(fn, sizeof(fn), "%s.%s", input_filename, surfix);
unlink(fn);
}
void err_exit(void)
{
close_all_output_files();
/* clean up. remove all output files we've generated so far */
remove_file("zeek");
remove_file("func_h");
remove_file("func_def");
remove_file("func_init");
remove_file("func_register");
remove_file("netvar_h");
remove_file("netvar_def");
remove_file("netvar_init");
exit(1);
}
void err_exit(void) {
close_all_output_files();
/* clean up. remove all output files we've generated so far */
remove_file("zeek");
remove_file("func_h");
remove_file("func_def");
remove_file("func_init");
remove_file("func_register");
remove_file("netvar_h");
remove_file("netvar_def");
remove_file("netvar_init");
exit(1);
}

379
tools/bifcl/builtin-func.y
View file

@ -65,92 +65,88 @@ struct decl_struct {
string enqueue_c_fullname;
} decl;
void set_definition_type(int type, const char *arg_type_name)
{
definition_type = type;
if ( type == TYPE_DEF && arg_type_name )
type_name = string(arg_type_name);
else
type_name = "";
}
void set_definition_type(int type, const char* arg_type_name) {
definition_type = type;
if ( type == TYPE_DEF && arg_type_name )
type_name = string(arg_type_name);
else
type_name = "";
}
void set_decl_name(const char *name)
{
decl.bare_name = extract_var_name(name);
void set_decl_name(const char* name) {
decl.bare_name = extract_var_name(name);
// make_full_var_name prepends the correct module, if any
// then we can extract the module name again.
string varname = make_full_var_name(current_module.c_str(), name);
decl.module_name = extract_module_name(varname.c_str());
// make_full_var_name prepends the correct module, if any
// then we can extract the module name again.
string varname = make_full_var_name(current_module.c_str(), name);
decl.module_name = extract_module_name(varname.c_str());
decl.c_namespace_start = "";
decl.c_namespace_end = "";
decl.c_fullname = "";
decl.zeek_fullname = "";
decl.zeek_name = "";
decl.c_namespace_start = "";
decl.c_namespace_end = "";
decl.c_fullname = "";
decl.zeek_fullname = "";
decl.zeek_name = "";
decl.enqueue_c_fullname = "";
decl.enqueue_c_barename = string("enqueue_") + decl.bare_name;
decl.enqueue_c_namespace_start = "";
decl.enqueue_c_namespace_end = "";
decl.enqueue_c_fullname = "";
decl.enqueue_c_barename = string("enqueue_") + decl.bare_name;
decl.enqueue_c_namespace_start = "";
decl.enqueue_c_namespace_end = "";
switch ( definition_type ) {
case TYPE_DEF:
decl.c_namespace_start = "BifType::" + type_name + "";
decl.c_fullname = "BifType::" + type_name + "::";
break;
switch ( definition_type ) {
case TYPE_DEF:
decl.c_namespace_start = "BifType::" + type_name + "";
decl.c_fullname = "BifType::" + type_name + "::";
break;
case CONST_DEF:
decl.c_namespace_start = "BifConst";
decl.c_fullname = "BifConst::";
break;
case CONST_DEF:
decl.c_namespace_start = "BifConst";
decl.c_fullname = "BifConst::";
break;
case FUNC_DEF:
decl.c_namespace_start = "BifFunc";
decl.c_fullname = "BifFunc::";
break;
case FUNC_DEF:
decl.c_namespace_start = "BifFunc";
decl.c_fullname = "BifFunc::";
break;
case EVENT_DEF:
decl.c_namespace_start = "";
decl.c_namespace_end = "";
decl.c_fullname = "::"; // need this for namespace qualified events due do event_c_body
decl.enqueue_c_namespace_start = "BifEvent";
decl.enqueue_c_fullname = "zeek::BifEvent::";
break;
case EVENT_DEF:
decl.c_namespace_start = "";
decl.c_namespace_end = "";
decl.c_fullname = "::"; // need this for namespace qualified events due do event_c_body
decl.enqueue_c_namespace_start = "BifEvent";
decl.enqueue_c_fullname = "zeek::BifEvent::";
break;
default:
break;
}
default: break;
}
if ( decl.module_name != GLOBAL_MODULE_NAME )
{
if ( decl.c_namespace_start.empty() ) {
decl.c_namespace_start += "namespace " + decl.module_name + " { ";
decl.c_namespace_end += " }";
}
else {
decl.c_namespace_start += "::" + decl.module_name;
decl.c_namespace_end = "";
}
decl.c_fullname += decl.module_name + "::";
decl.zeek_fullname += decl.module_name + "::";
if ( decl.module_name != GLOBAL_MODULE_NAME ) {
if ( decl.c_namespace_start.empty() ) {
decl.c_namespace_start += "namespace " + decl.module_name + " { ";
decl.c_namespace_end += " }";
}
else {
decl.c_namespace_start += "::" + decl.module_name;
decl.c_namespace_end = "";
}
decl.c_fullname += decl.module_name + "::";
decl.zeek_fullname += decl.module_name + "::";
if ( decl.enqueue_c_namespace_start.empty() ) {
decl.enqueue_c_namespace_start += "namespace " + decl.module_name + " { ";
decl.enqueue_c_namespace_end += " } ";
}
else {
decl.enqueue_c_namespace_start += "::" + decl.module_name;
decl.enqueue_c_namespace_end = "";
}
decl.enqueue_c_fullname += decl.module_name + "::";
}
if ( decl.enqueue_c_namespace_start.empty() ) {
decl.enqueue_c_namespace_start += "namespace " + decl.module_name + " { ";
decl.enqueue_c_namespace_end += " } ";
}
else {
decl.enqueue_c_namespace_start += "::" + decl.module_name;
decl.enqueue_c_namespace_end = "";
}
decl.enqueue_c_fullname += decl.module_name + "::";
}
decl.zeek_fullname += decl.bare_name;
decl.c_fullname += decl.bare_name;
decl.zeek_name += name;
decl.enqueue_c_fullname += decl.enqueue_c_barename;
}
decl.zeek_fullname += decl.bare_name;
decl.c_fullname += decl.bare_name;
decl.zeek_name += name;
decl.enqueue_c_fullname += decl.enqueue_c_barename;
}
const char* arg_list_name = "BiF_ARGS";
@ -168,22 +164,20 @@ static struct {
const char* constructor;
const char* ctor_smatr;
} builtin_types[] = {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define DEFINE_BIF_TYPE(id, bif_type, zeek_type, c_type, c_type_smart, accessor, accessor_smart, cast_smart, constructor, ctor_smart) \
{bif_type, zeek_type, c_type, c_type_smart, accessor, accessor_smart, cast_smart, constructor, ctor_smart},
#include "bif_type.def"
#undef DEFINE_BIF_TYPE
};
int get_type_index(const char *type_name)
{
for ( int i = 0; builtin_types[i].bif_type[0] != '\0'; ++i )
{
if ( strcmp(builtin_types[i].bif_type, type_name) == 0 )
return i;
}
return TYPE_OTHER;
}
int get_type_index(const char* type_name) {
for ( int i = 0; builtin_types[i].bif_type[0] != '\0'; ++i ) {
if ( strcmp(builtin_types[i].bif_type, type_name) == 0 )
return i;
}
return TYPE_OTHER;
}
int var_arg; // whether the number of arguments is variable
std::vector<BuiltinFuncArg*> args;
@ -192,108 +186,94 @@ extern int yyerror(const char[]);
extern int yywarn(const char msg[]);
extern int yylex();
char* concat(const char* str1, const char* str2)
{
int len1 = strlen(str1);
int len2 = strlen(str2);
char* concat(const char* str1, const char* str2) {
int len1 = strlen(str1);
int len2 = strlen(str2);
char* s = new char[len1 + len2 +1];
char* s = new char[len1 + len2 + 1];
memcpy(s, str1, len1);
memcpy(s + len1, str2, len2);
memcpy(s, str1, len1);
memcpy(s + len1, str2, len2);
s[len1+len2] = '\0';
s[len1 + len2] = '\0';
return s;
}
return s;
}
static void print_event_c_prototype_args(FILE* fp)
{
for ( auto i = 0u; i < args.size(); ++i )
{
if ( i > 0 )
fprintf(fp, ", ");
static void print_event_c_prototype_args(FILE * fp) {
for ( auto i = 0u; i < args.size(); ++i ) {
if ( i > 0 )
fprintf(fp, ", ");
args[i]->PrintCArg(fp, i);
}
}
args[i]->PrintCArg(fp, i);
}
}
static void print_event_c_prototype_header(FILE* fp)
{
fprintf(fp, "namespace zeek::%s { void %s(zeek::analyzer::Analyzer* analyzer%s",
decl.enqueue_c_namespace_start.c_str(),
decl.enqueue_c_barename.c_str(),
args.size() ? ", " : "" );
static void print_event_c_prototype_header(FILE * fp) {
fprintf(fp, "namespace zeek::%s { void %s(zeek::analyzer::Analyzer* analyzer%s",
decl.enqueue_c_namespace_start.c_str(), decl.enqueue_c_barename.c_str(), args.size() ? ", " : "");
print_event_c_prototype_args(fp);
fprintf(fp, ")");
fprintf(fp, "; %s }\n", decl.enqueue_c_namespace_end.c_str());
}
print_event_c_prototype_args(fp);
fprintf(fp, ")");
fprintf(fp, "; %s }\n", decl.enqueue_c_namespace_end.c_str());
}
static void print_event_c_prototype_impl(FILE* fp)
{
fprintf(fp, "void %s(zeek::analyzer::Analyzer* analyzer%s",
decl.enqueue_c_fullname.c_str(),
args.size() ? ", " : "" );
static void print_event_c_prototype_impl(FILE * fp) {
fprintf(fp, "void %s(zeek::analyzer::Analyzer* analyzer%s", decl.enqueue_c_fullname.c_str(),
args.size() ? ", " : "");
print_event_c_prototype_args(fp);
fprintf(fp, ")");
fprintf(fp, "\n");
}
print_event_c_prototype_args(fp);
fprintf(fp, ")");
fprintf(fp, "\n");
}
static void print_event_c_body(FILE* fp)
{
fprintf(fp, "\t{\n");
fprintf(fp, "\t// Note that it is intentional that here we do not\n");
fprintf(fp, "\t// check if %s is NULL, which should happen *before*\n",
decl.c_fullname.c_str());
fprintf(fp, "\t// %s is called to avoid unnecessary Val\n",
decl.enqueue_c_fullname.c_str());
fprintf(fp, "\t// allocation.\n");
fprintf(fp, "\n");
static void print_event_c_body(FILE * fp) {
fprintf(fp, "\t{\n");
fprintf(fp, "\t// Note that it is intentional that here we do not\n");
fprintf(fp, "\t// check if %s is NULL, which should happen *before*\n", decl.c_fullname.c_str());
fprintf(fp, "\t// %s is called to avoid unnecessary Val\n", decl.enqueue_c_fullname.c_str());
fprintf(fp, "\t// allocation.\n");
fprintf(fp, "\n");
BuiltinFuncArg* connection_arg = nullptr;
BuiltinFuncArg* connection_arg = nullptr;
fprintf(fp, "\tzeek::event_mgr.Enqueue(%s, zeek::Args{\n", decl.c_fullname.c_str());
fprintf(fp, "\tzeek::event_mgr.Enqueue(%s, zeek::Args{\n", decl.c_fullname.c_str());
for ( int i = 0; i < (int) args.size(); ++i )
{
fprintf(fp, "\t ");
args[i]->PrintValConstructor(fp);
fprintf(fp, ",\n");
for ( const auto& arg : args ) {
fprintf(fp, "\t ");
arg->PrintValConstructor(fp);
fprintf(fp, ",\n");
if ( args[i]->Type() == TYPE_CONNECTION )
{
if ( connection_arg == nullptr )
connection_arg = args[i];
else
{
// We are seeing two connection type arguments.
yywarn("Warning: with more than connection-type "
"event arguments, bifcl only passes "
"the first one to EventMgr as cookie.");
}
}
}
if ( arg->Type() == TYPE_CONNECTION ) {
if ( connection_arg == nullptr )
connection_arg = arg;
else {
// We are seeing two connection type arguments.
yywarn(
"Warning: with more than connection-type "
"event arguments, bifcl only passes "
"the first one to EventMgr as cookie.");
}
}
}
fprintf(fp, "\t },\n\t zeek::util::detail::SOURCE_LOCAL, analyzer ? analyzer->GetID() : 0");
fprintf(fp, "\t },\n\t zeek::util::detail::SOURCE_LOCAL, analyzer ? analyzer->GetID() : 0");
if ( connection_arg )
// Pass the connection to the EventMgr as the "cookie"
fprintf(fp, ", %s", connection_arg->Name());
if ( connection_arg )
// Pass the connection to the EventMgr as the "cookie"
fprintf(fp, ", %s", connection_arg->Name());
fprintf(fp, ");\n");
fprintf(fp, "\t}\n\n");
//fprintf(fp, "%s // end namespace\n", decl.enqueue_c_namespace_end.c_str());
}
fprintf(fp, ");\n");
fprintf(fp, "\t}\n\n");
// fprintf(fp, "%s // end namespace\n", decl.enqueue_c_namespace_end.c_str());
}
void record_bif_item(const char* id, const char* type)
{
if ( ! plugin )
return;
void record_bif_item(const char* id, const char* type) {
if ( ! plugin )
return;
fprintf(fp_func_init, "\tplugin->AddBifItem(\"%s\", zeek::plugin::BifItem::%s);\n", id, type);
}
fprintf(fp_func_init, "\tplugin->AddBifItem(\"%s\", zeek::plugin::BifItem::%s);\n", id, type);
}
%}
@ -474,7 +454,7 @@ enum_list: enum_list TOK_ID opt_ws ',' opt_ws
const_def: TOK_CONST opt_ws TOK_ID opt_ws ':' opt_ws TOK_ID opt_ws ';'
{
set_definition_type(CONST_DEF, 0);
set_definition_type(CONST_DEF, nullptr);
set_decl_name($3);
int typeidx = get_type_index($7);
char accessor[1024];
@ -525,11 +505,11 @@ opt_attr_list:
;
func_prefix: TOK_FUNCTION
{ set_definition_type(FUNC_DEF, 0); }
{ set_definition_type(FUNC_DEF, nullptr); }
;
event_prefix: TOK_EVENT
{ set_definition_type(EVENT_DEF, 0); }
{ set_definition_type(EVENT_DEF, nullptr); }
;
end_of_head: /* nothing */
@ -792,44 +772,41 @@ extern char* input_filename;
extern int line_number;
void err_exit(void);
void print_msg(const char msg[])
{
int msg_len = strlen(msg) + strlen(yytext) + 64;
char* msgbuf = new char[msg_len];
void print_msg(const char msg[]) {
int msg_len = strlen(msg) + strlen(yytext) + 64;
char* msgbuf = new char[msg_len];
if ( yytext[0] == '\n' )
snprintf(msgbuf, msg_len, "%s, on previous line", msg);
if ( yytext[0] == '\n' )
snprintf(msgbuf, msg_len, "%s, on previous line", msg);
else if ( yytext[0] == '\0' )
snprintf(msgbuf, msg_len, "%s, at end of file", msg);
else if ( yytext[0] == '\0' )
snprintf(msgbuf, msg_len, "%s, at end of file", msg);
else
snprintf(msgbuf, msg_len, "%s, at or near \"%s\"", msg, yytext);
else
snprintf(msgbuf, msg_len, "%s, at or near \"%s\"", msg, yytext);
/*
extern int column;
sprintf(msgbuf, "%*s\n%*s\n", column, "^", column, msg);
*/
/*
extern int column;
sprintf(msgbuf, "%*s\n%*s\n", column, "^", column, msg);
*/
if ( input_filename )
fprintf(stderr, "%s:%d: ", input_filename, line_number);
else
fprintf(stderr, "line %d: ", line_number);
fprintf(stderr, "%s\n", msgbuf);
if ( input_filename )
fprintf(stderr, "%s:%d: ", input_filename, line_number);
else
fprintf(stderr, "line %d: ", line_number);
fprintf(stderr, "%s\n", msgbuf);
delete [] msgbuf;
}
delete[] msgbuf;
}
int yywarn(const char msg[])
{
print_msg(msg);
return 0;
}
int yywarn(const char msg[]) {
print_msg(msg);
return 0;
}
int yyerror(const char msg[])
{
print_msg(msg);
int yyerror(const char msg[]) {
print_msg(msg);
err_exit();
return 0;
}
err_exit();
return 0;
}

1
tools/bifcl/include/bif_arg.h
View file

@ -6,6 +6,7 @@
#include <cstdio>
enum builtin_func_arg_type : uint8_t {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define DEFINE_BIF_TYPE(id, bif_type, bro_type, c_type, c_type_smart, accessor, accessor_smart, cast_smart, \
constructor, ctor_smart) \
id,

2
tools/binpac/lib/CMakeLists.txt
View file

@ -21,6 +21,7 @@ if (BUILD_STATIC_BINPAC)
target_compile_options(binpac_static PRIVATE "/J")
endif ()
set(BinPAC_LIBRARY binpac_static CACHE STRING "BinPAC library" FORCE)
zeek_target_add_linters(binpac_static)
else ()
add_library(binpac_lib SHARED)
target_sources(binpac_lib PRIVATE ${binpac_lib_SRCS})
@ -31,6 +32,7 @@ else ()
endif ()
install(TARGETS binpac_lib DESTINATION ${CMAKE_INSTALL_LIBDIR})
set(BinPAC_LIBRARY binpac_lib CACHE STRING "BinPAC library" FORCE)
zeek_target_add_linters(binpac_lib)
endif ()
if (ZEEK_ROOT_DIR)

10
tools/binpac/lib/binpac_buffer.cc
View file

@ -1,8 +1,8 @@
// See the file "COPYING" in the main distribution directory for copyright.
#include <stdio.h>
#include <stdlib.h>
#include <string.h> // for memcpy
#include <cstdio>
#include <cstdlib>
#include <cstring> // for memcpy
#define binpac_regex_h
@ -82,7 +82,7 @@ void FlowBuffer::ResetLineState() {
case CR_OR_LF: state_ = CR_OR_LF_0; break;
case STRICT_CRLF: state_ = STRICT_CRLF_0; break;
case LINE_BREAKER: break; // Nothing to reset
default: BINPAC_ASSERT(0); break;
default: BINPAC_ASSERT(false); break;
}
}
@ -248,7 +248,7 @@ void FlowBuffer::MarkOrCopyLine() {
case CR_OR_LF: MarkOrCopyLine_CR_OR_LF(); break;
case STRICT_CRLF: MarkOrCopyLine_STRICT_CRLF(); break;
case LINE_BREAKER: MarkOrCopyLine_LINEBREAK(); break;
default: BINPAC_ASSERT(0); break;
default: BINPAC_ASSERT(false); break;
}
}

4
tools/binpac/lib/binpac_bytestring.cc
View file

@ -4,11 +4,11 @@
#include "binpac_bytestring.h"
#include <stdlib.h>
#include <cstdlib>
namespace binpac {
std::string std_string(bytestring const* s) { return std::string((const char*)s->begin(), (const char*)s->end()); }
std::string std_string(bytestring const* s) { return {(const char*)s->begin(), (const char*)s->end()}; }
int bytestring_to_int(bytestring const* s) { return atoi((const char*)s->begin()); }

16
tools/binpac/src/CMakeLists.txt
View file

@ -11,6 +11,18 @@ else ()
set_property(SOURCE pac_scan.cc APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-sign-compare")
endif ()
set(binpac_bison_generated_files
${CMAKE_CURRENT_BINARY_DIR}/pac_parse.cc ${CMAKE_CURRENT_BINARY_DIR}/pac_parse.h
${CMAKE_CURRENT_BINARY_DIR}/pac_scan.cc)
set_source_files_properties(${binpac_bison_generated_files} PROPERTIES SKIP_LINTING ON)
# pac_main.cc includes up pac_parse.h, and so clang-tidy reports a bunch of warnings from
# that header as part of it. adding NOLINTBEGIN/END around the include didn't resolve it.
# I fixed the findings in pac_main.cc, but am ignoring it from here on to avoid the extra
# noise.
set_source_files_properties(pac_main.cc PROPERTIES SKIP_LINTING ON)
set(binpac_SRCS
${BISON_PACParser_INPUT}
${FLEX_PACScanner_INPUT}
@ -55,7 +67,9 @@ set(binpac_SRCS
pac_exception.cc
pac_main.cc)
add_executable(binpac ${binpac_SRCS})
add_executable(binpac)
target_sources(binpac PRIVATE ${binpac_SRCS})
zeek_target_add_linters(binpac)
target_include_directories(binpac BEFORE PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_include_directories(binpac BEFORE PUBLIC ${CMAKE_CURRENT_BINARY_DIR})

2
tools/binpac/src/pac_action.cc
View file

@ -11,7 +11,7 @@
#include "pac_utils.h"
AnalyzerAction::AnalyzerAction(ID* action_id, When when, ActionParam* param, EmbeddedCode* code)
: AnalyzerElement(ACTION), action_id_(action_id), when_(when), param_(param), code_(code), analyzer_(nullptr) {}
: AnalyzerElement(ACTION), action_id_(action_id), when_(when), param_(param), code_(code) {}
AnalyzerAction::~AnalyzerAction() {
delete action_id_;

8
tools/binpac/src/pac_action.h
View file

@ -3,6 +3,8 @@
#ifndef pac_action_h
#define pac_action_h
#include <cstdint>
// Classes representing analyzer actions.
#include "pac_analyzer.h"
@ -10,7 +12,7 @@
class AnalyzerAction : public AnalyzerElement {
public:
enum When { BEFORE, AFTER };
enum When : uint8_t { BEFORE, AFTER };
AnalyzerAction(ID* action_id, When when, ActionParam* param, EmbeddedCode* code);
@ -35,7 +37,7 @@ private:
When when_;
ActionParam* param_;
EmbeddedCode* code_;
AnalyzerDecl* analyzer_;
AnalyzerDecl* analyzer_ = nullptr;
};
class ActionParam {
@ -56,7 +58,7 @@ private:
class ActionParamType {
public:
ActionParamType(const ID* type_id, const ID* field_id = 0) : type_id_(type_id), field_id_(field_id) {}
ActionParamType(const ID* type_id, const ID* field_id = nullptr) : type_id_(type_id), field_id_(field_id) {}
const ID* type_id() const { return type_id_; }
const ID* field_id() const { return field_id_; }

16
tools/binpac/src/pac_analyzer.cc
View file

@ -34,14 +34,14 @@ AnalyzerDecl::AnalyzerDecl(ID* id, DeclType decl_type, ParamList* params) : Type
}
AnalyzerDecl::~AnalyzerDecl() {
delete_list(StateVarList, statevars_);
delete_list(AnalyzerActionList, actions_);
delete_list(AnalyzerHelperList, helpers_);
delete_list(FunctionList, functions_);
delete_list(ParamList, params_);
delete_list(AnalyzerHelperList, constructor_helpers_);
delete_list(AnalyzerHelperList, destructor_helpers_);
delete_list(AnalyzerHelperList, eof_helpers_);
delete_list(statevars_);
delete_list(actions_);
delete_list(helpers_);
delete_list(functions_);
delete_list(params_);
delete_list(constructor_helpers_);
delete_list(destructor_helpers_);
delete_list(eof_helpers_);
}
void AnalyzerDecl::AddElements(AnalyzerElementList* elemlist) {

12
tools/binpac/src/pac_analyzer.h
View file

@ -3,6 +3,8 @@
#ifndef pac_analyzer_h
#define pac_analyzer_h
#include <cstdint>
#include "pac_common.h"
#include "pac_field.h"
#include "pac_typedecl.h"
@ -16,8 +18,8 @@ class AnalyzerDataUnit;
class AnalyzerFunction;
class ConnDecl;
class FlowDecl;
typedef vector<AnalyzerHelper*> AnalyzerHelperList;
typedef vector<Function*> FunctionList;
using AnalyzerHelperList = vector<AnalyzerHelper*>;
using FunctionList = vector<Function*>;
class AnalyzerDecl : public TypeDecl {
public:
@ -84,7 +86,7 @@ protected:
class AnalyzerElement : public Object {
public:
enum ElementType { STATE, ACTION, FUNCTION, HELPER, FLOW, DATAUNIT };
enum ElementType : uint8_t { STATE, ACTION, FUNCTION, HELPER, FLOW, DATAUNIT };
AnalyzerElement(ElementType type) : type_(type) {}
virtual ~AnalyzerElement() {}
@ -109,7 +111,7 @@ private:
// A collection of embedded C++ code
class AnalyzerHelper : public AnalyzerElement {
public:
enum Type {
enum Type : uint8_t {
MEMBER_DECLS,
INIT_CODE,
CLEANUP_CODE,
@ -140,7 +142,7 @@ public:
class AnalyzerFlow : public AnalyzerElement {
public:
enum Direction { UP, DOWN };
enum Direction : uint8_t { UP, DOWN };
AnalyzerFlow(Direction dir, ID* type_id, ExprList* params);
~AnalyzerFlow() override;

4
tools/binpac/src/pac_attr.h
View file

@ -3,10 +3,12 @@
#ifndef pac_attr_h
#define pac_attr_h
#include <cstdint>
#include "pac_common.h"
#include "pac_datadep.h"
enum AttrType {
enum AttrType : uint8_t {
ATTR_BYTEORDER,
ATTR_CHECK,
ATTR_CHUNKED,

3
tools/binpac/src/pac_btype.cc
View file

@ -19,6 +19,7 @@ bool BuiltInType::CompatibleBuiltInTypes(BuiltInType* type1, BuiltInType* type2)
}
static const char* basic_pactype_name[] = {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define TYPE_DEF(name, pactype, ctype, size) pactype,
#include "pac_type.def"
#undef TYPE_DEF
@ -40,6 +41,7 @@ int BuiltInType::LookUpByName(const char* name) {
}
static const char* basic_ctype_name[] = {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define TYPE_DEF(name, pactype, ctype, size) ctype,
#include "pac_type.def"
#undef TYPE_DEF
@ -52,6 +54,7 @@ string BuiltInType::DataTypeStr() const { return basic_ctype_name[bit_type_]; }
int BuiltInType::StaticSize(Env* /* env */) const {
static const size_t basic_type_size[] = {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define TYPE_DEF(name, pactype, ctype, size) size,
#include "pac_type.def"
#undef TYPE_DEF

7
tools/binpac/src/pac_btype.h
View file

@ -3,11 +3,14 @@
#ifndef pac_btype_h
#define pac_btype_h
#include <cstdint>
#include "pac_type.h"
class BuiltInType : public Type {
public:
enum BITType {
enum BITType : uint8_t {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define TYPE_DEF(name, pactype, ctype, size) name,
#include "pac_type.def"
#undef TYPE_DEF
@ -29,7 +32,7 @@ public:
bool IsPointerType() const override { return false; }
bool ByteOrderSensitive() const override { return StaticSize(0) >= 2; }
bool ByteOrderSensitive() const override { return StaticSize(nullptr) >= 2; }
void GenInitCode(Output* out_cc, Env* env) override;

4
tools/binpac/src/pac_case.cc
View file

@ -2,7 +2,7 @@
#include "pac_case.h"
#include <stdint.h>
#include <cstdint>
#include <limits>
#include "pac_btype.h"
@ -219,7 +219,7 @@ CaseField::CaseField(ExprList* index, ID* id, Type* type)
index_var_ = nullptr;
}
CaseField::~CaseField() { delete_list(ExprList, index_); }
CaseField::~CaseField() { delete_list(index_); }
void GenCaseStr(ExprList* index_list, Output* out_cc, Env* env, Type* switch_type) {
if ( index_list ) {

2
tools/binpac/src/pac_case.h
View file

@ -49,7 +49,7 @@ protected:
ID* index_var_;
CaseFieldList* cases_;
typedef map<const ID*, CaseField*, ID_ptr_cmp> member_map_t;
using member_map_t = map<const ID*, CaseField*, ID_ptr_cmp>;
member_map_t member_map_;
};

80
tools/binpac/src/pac_common.h
View file

@ -3,9 +3,9 @@
#ifndef pac_common_h
#define pac_common_h
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <vector>
#include "pac_utils.h"
@ -87,47 +87,49 @@ class WithInputField;
// The ID of the current declaration.
extern const ID* current_decl_id;
typedef vector<ActionParam*> ActionParamList;
typedef vector<AnalyzerAction*> AnalyzerActionList;
typedef vector<AnalyzerElement*> AnalyzerElementList;
typedef vector<Attr*> AttrList;
typedef vector<CaseExpr*> CaseExprList;
typedef vector<CaseField*> CaseFieldList;
typedef vector<ContextField*> ContextFieldList;
typedef vector<Decl*> DeclList;
typedef vector<Enum*> EnumList;
typedef vector<Expr*> ExprList;
typedef vector<Field*> FieldList;
typedef vector<LetField*> LetFieldList;
typedef vector<Number*> NumList;
typedef vector<Param*> ParamList;
typedef vector<RecordField*> RecordFieldList;
typedef vector<StateVar*> StateVarList;
using ActionParamList = vector<ActionParam*>;
using AnalyzerActionList = vector<AnalyzerAction*>;
using AnalyzerElementList = vector<AnalyzerElement*>;
using AttrList = vector<Attr*>;
using CaseExprList = vector<CaseExpr*>;
using CaseFieldList = vector<CaseField*>;
using ContextFieldList = vector<ContextField*>;
using DeclList = vector<Decl*>;
using EnumList = vector<Enum*>;
using ExprList = vector<Expr*>;
using FieldList = vector<Field*>;
using LetFieldList = vector<LetField*>;
using NumList = vector<Number*>;
using ParamList = vector<Param*>;
using RecordFieldList = vector<RecordField*>;
using StateVarList = vector<StateVar*>;
// NOLINTBEGIN(cppcoreguidelines-macro-usage,modernize-loop-convert)
#define foreach(i, ct, pc) \
if ( pc ) \
for ( ct::iterator i = (pc)->begin(); i != (pc)->end(); ++i )
for ( ct::iterator i = (pc)->begin(); (i) != (pc)->end(); ++(i) )
// NOLINTEND(cppcoreguidelines-macro-usage,modernize-loop-convert)
#define delete_list(ct, pc) \
{ \
foreach (delete_list_i, ct, pc) \
delete *delete_list_i; \
delete pc; \
pc = 0; \
}
template<typename T>
constexpr void delete_list(T* container) {
for ( auto& i : *container )
delete i;
delete container;
}
// Constants
const char* const kComputeFrameLength = "compute_frame_length";
const char* const kFlowBufferClass = "FlowBuffer";
const char* const kFlowBufferVar = "flow_buffer";
const char* const kFlowEOF = "FlowEOF";
const char* const kFlowGap = "NewGap";
const char* const kInitialBufferLengthFunc = "initial_buffer_length";
const char* const kNeedMoreData = "need_more_data";
const char* const kNewData = "NewData";
const char* const kParseFuncWithBuffer = "ParseBuffer";
const char* const kParseFuncWithoutBuffer = "Parse";
const char* const kRefCountClass = "binpac::RefCount";
const char* const kTypeWithLengthClass = "binpac::TypeWithLength";
constexpr char kComputeFrameLength[] = "compute_frame_length";
constexpr char kFlowBufferClass[] = "FlowBuffer";
constexpr char kFlowBufferVar[] = "flow_buffer";
constexpr char kFlowEOF[] = "FlowEOF";
constexpr char kFlowGap[] = "NewGap";
constexpr char kInitialBufferLengthFunc[] = "initial_buffer_length";
constexpr char kNeedMoreData[] = "need_more_data";
constexpr char kNewData[] = "NewData";
constexpr char kParseFuncWithBuffer[] = "ParseBuffer";
constexpr char kParseFuncWithoutBuffer[] = "Parse";
constexpr char kRefCountClass[] = "binpac::RefCount";
constexpr char kTypeWithLengthClass[] = "binpac::TypeWithLength";
#endif // pac_common_h

2
tools/binpac/src/pac_conn.cc
View file

@ -26,7 +26,7 @@ ConnDecl::~ConnDecl() {
}
void ConnDecl::AddBaseClass(vector<string>* base_classes) const {
base_classes->push_back("binpac::ConnectionAnalyzer");
base_classes->emplace_back("binpac::ConnectionAnalyzer");
}
void ConnDecl::ProcessFlowElement(AnalyzerFlow* flow_elem) {

2
tools/binpac/src/pac_context.cc
View file

@ -53,7 +53,7 @@ AnalyzerContextDecl::AnalyzerContextDecl(ID* id, ContextFieldList* context_field
AnalyzerContextDecl::~AnalyzerContextDecl() {
delete context_name_id_;
delete param_type_;
delete_list(ContextFieldList, context_fields_);
delete_list(context_fields_);
}
void AnalyzerContextDecl::GenForwardDeclaration(Output* out_h) {

2
tools/binpac/src/pac_cstr.cc
View file

@ -77,7 +77,7 @@ int expand_escape(const char*& s) {
} // namespace
ConstString::ConstString(const string& s) : str_(s) {
ConstString::ConstString(string s) : str_(std::move(s)) {
// Copied from scan.l of Zeek
try {
const char* text = str_.c_str();

2
tools/binpac/src/pac_cstr.h
View file

@ -7,7 +7,7 @@
class ConstString : public Object {
public:
ConstString(const string& s);
ConstString(string s);
// The string in its escaped form, with surrounding '"'s
const string& str() const { return str_; }

2
tools/binpac/src/pac_datadep.cc
View file

@ -6,7 +6,7 @@
#include "pac_id.h"
#include "pac_type.h"
DataDepElement::DataDepElement(DDE_Type type) : dde_type_(type), in_traversal(false) {}
DataDepElement::DataDepElement(DDE_Type type) : dde_type_(type) {}
bool DataDepElement::Traverse(DataDepVisitor* visitor) {
// Avoid infinite loop

11
tools/binpac/src/pac_datadep.h
View file

@ -3,17 +3,18 @@
#ifndef pac_datadep_h
#define pac_datadep_h
#include <cstdint>
// To provide a way to traverse through the data dependency graph.
// That is, to evaluate X, what must be evaluated.
#include "pac_common.h"
#include "pac_dbg.h"
class DataDepVisitor;
class DataDepElement {
public:
enum DDE_Type {
enum DDE_Type : uint8_t {
ATTR,
CASEEXPR,
EXPR,
@ -38,7 +39,7 @@ public:
protected:
DDE_Type dde_type_;
bool in_traversal;
bool in_traversal = false;
};
class DataDepVisitor {
@ -51,8 +52,6 @@ public:
class RequiresAnalyzerContext : public DataDepVisitor {
public:
RequiresAnalyzerContext() : requires_analyzer_context_(false) {}
// Returns whether to continue traversal
bool PreProcess(DataDepElement* element) override;
bool PostProcess(DataDepElement* element) override;
@ -64,7 +63,7 @@ public:
protected:
void ProcessExpr(Expr* expr);
bool requires_analyzer_context_;
bool requires_analyzer_context_ = false;
};
#endif // pac_datadep_h

3
tools/binpac/src/pac_dataptr.h
View file

@ -17,6 +17,9 @@ public:
DataPtr(DataPtr const& x) { *this = x; }
DataPtr const& operator=(DataPtr const& x) {
if ( this == &x )
return *this;
id_ = x.id();
offset_ = x.offset();
ptr_expr_ = x.ptr_expr();

4
tools/binpac/src/pac_dataunit.h
View file

@ -3,6 +3,8 @@
#ifndef pac_dataunit_h
#define pac_dataunit_h
#include <cstdint>
#include "pac_analyzer.h"
// The type and parameters of input data unit of a flow. For instance, the
@ -10,7 +12,7 @@
class AnalyzerDataUnit : public AnalyzerElement {
public:
enum DataUnitType { DATAGRAM, FLOWUNIT };
enum DataUnitType : uint8_t { DATAGRAM, FLOWUNIT };
AnalyzerDataUnit(DataUnitType type, ID* id, ExprList* type_params, ExprList* context_params);
~AnalyzerDataUnit() override;

3
tools/binpac/src/pac_dbg.h
View file

@ -8,7 +8,8 @@
extern bool FLAGS_pac_debug;
#define ASSERT(x) assert(x)
constexpr void ASSERT(bool flag) { assert(flag); }
constexpr void ASSERT(int flag) { assert(flag); }
#define DEBUG_MSG(...) \
if ( FLAGS_pac_debug ) \
fprintf(stderr, __VA_ARGS__)

6
tools/binpac/src/pac_decl.cc
View file

@ -19,20 +19,18 @@
DeclList* Decl::decl_list_ = nullptr;
Decl::DeclMap Decl::decl_map_;
Decl::Decl(ID* id, DeclType decl_type) : id_(id), decl_type_(decl_type), attrlist_(nullptr) {
Decl::Decl(ID* id, DeclType decl_type) : id_(id), decl_type_(decl_type) {
decl_map_[id_] = this;
if ( ! decl_list_ )
decl_list_ = new DeclList();
decl_list_->push_back(this);
DEBUG_MSG("Finished Decl %s\n", id_->Name());
analyzer_context_ = nullptr;
}
Decl::~Decl() {
delete id_;
delete_list(AttrList, attrlist_);
delete_list(attrlist_);
}
void Decl::AddAttrs(AttrList* attrs) {

12
tools/binpac/src/pac_decl.h
View file

@ -3,6 +3,8 @@
#ifndef pac_decl_h
#define pac_decl_h
#include <cstdint>
#include "pac_common.h"
#include "pac_id.h"
@ -10,7 +12,7 @@ class Decl : public Object {
public:
// Note: ANALYZER is not for AnalyzerDecl (which is an
// abstract class) , but for AnalyzerContextDecl.
enum DeclType { ENUM, LET, TYPE, FUNC, CONN, FLOW, ANALYZER, HELPER, REGEX };
enum DeclType : uint8_t { ENUM, LET, TYPE, FUNC, CONN, FLOW, ANALYZER, HELPER, REGEX };
Decl(ID* id, DeclType decl_type);
virtual ~Decl();
@ -41,8 +43,8 @@ protected:
ID* id_;
DeclType decl_type_;
AttrList* attrlist_;
AnalyzerContextDecl* analyzer_context_;
AttrList* attrlist_ = nullptr;
AnalyzerContextDecl* analyzer_context_ = nullptr;
public:
static void ProcessDecls(Output* out_h, Output* out_cc);
@ -50,13 +52,13 @@ public:
private:
static DeclList* decl_list_;
typedef map<const ID*, Decl*, ID_ptr_cmp> DeclMap;
using DeclMap = map<const ID*, Decl*, ID_ptr_cmp>;
static DeclMap decl_map_;
};
class HelperDecl : public Decl {
public:
enum HelperType {
enum HelperType : uint8_t {
HEADER,
CODE,
EXTERN,

4
tools/binpac/src/pac_embedded.cc
View file

@ -6,7 +6,7 @@
#include "pac_output.h"
#include "pac_primitive.h"
EmbeddedCodeSegment::EmbeddedCodeSegment(const string& s) : s_(s), primitive_(nullptr) {}
EmbeddedCodeSegment::EmbeddedCodeSegment(string s) : s_(std::move(s)), primitive_(nullptr) {}
EmbeddedCodeSegment::EmbeddedCodeSegment(PacPrimitive* primitive) : s_(""), primitive_(primitive) {}
@ -20,7 +20,7 @@ string EmbeddedCodeSegment::ToCode(Env* env) {
EmbeddedCode::EmbeddedCode() { segments_ = new EmbeddedCodeSegmentList(); }
EmbeddedCode::~EmbeddedCode() { delete_list(EmbeddedCodeSegmentList, segments_); }
EmbeddedCode::~EmbeddedCode() { delete_list(segments_); }
void EmbeddedCode::Append(int atom) { current_segment_ += static_cast<char>(atom); }

4
tools/binpac/src/pac_embedded.h
View file

@ -7,7 +7,7 @@
class EmbeddedCodeSegment {
public:
explicit EmbeddedCodeSegment(const string& s);
explicit EmbeddedCodeSegment(string s);
explicit EmbeddedCodeSegment(PacPrimitive* primitive);
~EmbeddedCodeSegment();
@ -18,7 +18,7 @@ private:
PacPrimitive* primitive_;
};
typedef vector<EmbeddedCodeSegment*> EmbeddedCodeSegmentList;
using EmbeddedCodeSegmentList = vector<EmbeddedCodeSegment*>;
class EmbeddedCode : public Object {
public:

2
tools/binpac/src/pac_enum.cc
View file

@ -34,7 +34,7 @@ EnumDecl::EnumDecl(ID* id, EnumList* enumlist) : Decl(id, ENUM), enumlist_(enuml
}
EnumDecl::~EnumDecl() {
delete_list(EnumList, enumlist_);
delete_list(enumlist_);
delete extern_typedecl_;
}

2
tools/binpac/src/pac_enum.h
View file

@ -7,7 +7,7 @@
class Enum {
public:
Enum(ID* id, Expr* expr = 0);
Enum(ID* id, Expr* expr = nullptr);
~Enum();
void GenHeader(Output* out_h, int* pval);

59
tools/binpac/src/pac_expr.cc
View file

@ -45,6 +45,7 @@ string EvalExprList(ExprList* exprlist, Output* out, Env* env) {
}
static const char* expr_fmt[] = {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define EXPR_DEF(type, num_op, fmt) fmt,
#include "pac_expr.def"
#undef EXPR_DEF
@ -155,8 +156,8 @@ Expr::~Expr() {
delete operand_[0];
delete operand_[1];
delete operand_[2];
delete_list(ExprList, args_);
delete_list(CaseExprList, cases_);
delete_list(args_);
delete_list(cases_);
}
void Expr::AddCaseExpr(CaseExpr* case_expr) {
@ -311,11 +312,11 @@ void Expr::GenEval(Output* out_cc, Env* env) {
Type* ty;
try {
if ( (rf = GetRecordField(id, env)) != nullptr ) {
if ( rf = GetRecordField(id, env); rf != nullptr ) {
str_ = strfmt("%s", rf->FieldSize(out_cc, env));
}
} catch ( ExceptionIDNotFound& e ) {
if ( (ty = TypeDecl::LookUpType(id)) != nullptr ) {
if ( ty = TypeDecl::LookUpType(id); ty != nullptr ) {
int ty_size = ty->StaticSize(global_env());
if ( ty_size >= 0 )
str_ = strfmt("%d", ty_size);
@ -339,9 +340,9 @@ void Expr::GenEval(Output* out_cc, Env* env) {
default:
// Evaluate every operand by default
for ( int i = 0; i < 3; ++i )
if ( operand_[i] )
operand_[i]->GenEval(out_cc, env);
for ( auto& op : operand_ )
if ( op )
op->GenEval(out_cc, env);
GenStrFromFormat(env);
break;
}
@ -373,9 +374,9 @@ void Expr::ForceIDEval(Output* out_cc, Env* env) {
default:
// Evaluate every operand by default
for ( int i = 0; i < 3; ++i )
if ( operand_[i] )
operand_[i]->ForceIDEval(out_cc, env);
for ( auto& op : operand_ )
if ( op )
op->ForceIDEval(out_cc, env);
break;
}
}
@ -670,14 +671,14 @@ int Expr::MinimalHeaderSize(Env* env) {
RecordField* rf;
Type* ty;
if ( (rf = GetRecordField(id, env)) != nullptr ) {
if ( rf = GetRecordField(id, env); rf != nullptr ) {
if ( rf->StaticSize(env, -1) >= 0 )
mhs = 0;
else
mhs = mhs_recordfield(env, rf);
}
else if ( (ty = TypeDecl::LookUpType(id)) != nullptr ) {
else if ( ty = TypeDecl::LookUpType(id); ty != nullptr ) {
mhs = 0;
}
@ -703,25 +704,24 @@ int Expr::MinimalHeaderSize(Env* env) {
case EXPR_CALLARGS: {
mhs = 0;
if ( args_ )
for ( unsigned int i = 0; i < args_->size(); ++i )
mhs = mhs_max(mhs, (*args_)[i]->MinimalHeaderSize(env));
for ( const auto& arg : *args_ )
mhs = mhs_max(mhs, arg->MinimalHeaderSize(env));
} break;
case EXPR_CASE: {
mhs = operand_[0]->MinimalHeaderSize(env);
for ( unsigned int i = 0; i < cases_->size(); ++i ) {
CaseExpr* ce = (*cases_)[i];
for ( const auto& ce : *cases_ ) {
if ( ce->index() )
for ( unsigned int j = 0; j < ce->index()->size(); ++j )
mhs = mhs_max(mhs, (*ce->index())[j]->MinimalHeaderSize(env));
for ( const auto& idx : *(ce->index()) )
mhs = mhs_max(mhs, idx->MinimalHeaderSize(env));
mhs = mhs_max(mhs, ce->value()->MinimalHeaderSize(env));
}
} break;
default:
// Evaluate every operand by default
mhs = 0;
for ( int i = 0; i < 3; ++i )
if ( operand_[i] )
mhs = mhs_max(mhs, operand_[i]->MinimalHeaderSize(env));
for ( auto& op : operand_ )
if ( op )
mhs = mhs_max(mhs, op->MinimalHeaderSize(env));
break;
}
@ -750,8 +750,8 @@ bool Expr::HasReference(const ID* id) const {
default:
// Evaluate every operand by default
for ( int i = 0; i < 3; ++i ) {
if ( operand_[i] && operand_[i]->HasReference(id) ) {
for ( auto& op : operand_ ) {
if ( op && op->HasReference(id) ) {
return true;
}
}
@ -788,8 +788,8 @@ bool Expr::DoTraverse(DataDepVisitor* visitor) {
default:
// Evaluate every operand by default
for ( int i = 0; i < 3; ++i ) {
if ( operand_[i] && ! operand_[i]->Traverse(visitor) ) {
for ( auto& op : operand_ ) {
if ( op && ! op->Traverse(visitor) ) {
return false;
}
}
@ -828,9 +828,9 @@ bool Expr::RequiresAnalyzerContext() const {
default:
// Evaluate every operand by default
for ( int i = 0; i < 3; ++i )
if ( operand_[i] && operand_[i]->RequiresAnalyzerContext() ) {
DEBUG_MSG("'%s' requires analyzer context\n", operand_[i]->orig());
for ( auto& op : operand_ )
if ( op && op->RequiresAnalyzerContext() ) {
DEBUG_MSG("'%s' requires analyzer context\n", op->orig());
return true;
}
return false;
@ -841,7 +841,8 @@ CaseExpr::CaseExpr(ExprList* index, Expr* value)
: DataDepElement(DataDepElement::CASEEXPR), index_(index), value_(value) {}
CaseExpr::~CaseExpr() {
delete_list(ExprList, index_);
delete_list(index_);
index_ = nullptr;
delete value_;
}

1
tools/binpac/src/pac_expr.h
View file

@ -13,6 +13,7 @@ class CaseExpr;
class Expr : public Object, public DataDepElement {
public:
enum ExprType : uint8_t {
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define EXPR_DEF(type, x, y) type,
#include "pac_expr.def"
#undef EXPR_DEF

4
tools/binpac/src/pac_exttype.h
View file

@ -3,6 +3,8 @@
#ifndef pac_exttype_h
#define pac_exttype_h
#include <cstdint>
#include "pac_type.h"
// ExternType represent external C++ types that are not defined in
@ -12,7 +14,7 @@
class ExternType : public Type {
public:
enum EXTType { PLAIN, NUMBER, POINTER, BOOLEAN };
enum EXTType : uint8_t { PLAIN, NUMBER, POINTER, BOOLEAN };
ExternType(const ID* id, EXTType ext_type) : Type(EXTERN), id_(id), ext_type_(ext_type) {}
bool DefineValueVar() const override;

2
tools/binpac/src/pac_field.cc
View file

@ -18,7 +18,7 @@ Field::Field(FieldType tof, int flags, ID* id, Type* type)
Field::~Field() {
delete id_;
delete type_;
delete_list(AttrList, attrs_);
delete_list(attrs_);
}
void Field::AddAttr(AttrList* attrs) {

4
tools/binpac/src/pac_field.h
View file

@ -3,12 +3,14 @@
#ifndef pac_field_h
#define pac_field_h
#include <cstdint>
#include "pac_common.h"
#include "pac_datadep.h"
// A "field" is a member of class.
enum FieldType {
enum FieldType : uint8_t {
CASE_FIELD,
CONTEXT_FIELD,
FLOW_FIELD,

2
tools/binpac/src/pac_flow.cc
View file

@ -38,7 +38,7 @@ ParameterizedType* FlowDecl::flow_buffer_type() {
return flow_buffer_type_;
}
void FlowDecl::AddBaseClass(vector<string>* base_classes) const { base_classes->push_back("binpac::FlowAnalyzer"); }
void FlowDecl::AddBaseClass(vector<string>* base_classes) const { base_classes->emplace_back("binpac::FlowAnalyzer"); }
void FlowDecl::ProcessFlowElement(AnalyzerFlow* flow_elem) {
throw Exception(flow_elem, "flow should be defined in only a connection declaration");

8
tools/binpac/src/pac_func.cc
View file

@ -8,16 +8,12 @@
#include "pac_param.h"
#include "pac_type.h"
Function::Function(ID* id, Type* type, ParamList* params)
: id_(id), type_(type), params_(params), expr_(nullptr), code_(nullptr) {
analyzer_decl_ = nullptr;
env_ = nullptr;
}
Function::Function(ID* id, Type* type, ParamList* params) : id_(id), type_(type), params_(params) {}
Function::~Function() {
delete id_;
delete type_;
delete_list(ParamList, params_);
delete_list(params_);
delete env_;
delete expr_;
delete code_;

8
tools/binpac/src/pac_func.h
View file

@ -27,16 +27,16 @@ public:
void GenCode(Output* out_h, Output* out_cc);
private:
Env* env_;
Env* env_ = nullptr;
ID* id_;
Type* type_;
ParamList* params_;
AnalyzerDecl* analyzer_decl_;
AnalyzerDecl* analyzer_decl_ = nullptr;
Expr* expr_;
EmbeddedCode* code_;
Expr* expr_ = nullptr;
EmbeddedCode* code_ = nullptr;
};
class FuncDecl : public Decl {

10
tools/binpac/src/pac_id.cc
View file

@ -168,9 +168,9 @@ Env::Env(Env* parent_env, Object* context_object) : parent(parent_env), context_
}
Env::~Env() {
for ( id_map_t::iterator it = id_map.begin(); it != id_map.end(); ++it ) {
delete it->second;
it->second = 0;
for ( auto& id : id_map ) {
delete id.second;
id.second = nullptr;
}
}
@ -365,8 +365,8 @@ Env* global_env() {
the_global_env->AddConstID(null_id, 0, extern_type_nullptr);
#if 0
the_global_env->AddID(null_byteseg_id,
GLOBAL_VAR,
the_global_env->AddID(null_byteseg_id,
GLOBAL_VAR,
extern_type_const_byteseg);
#endif
}

13
tools/binpac/src/pac_id.h
View file

@ -3,6 +3,7 @@
#ifndef pac_id_h
#define pac_id_h
#include <cstdint>
#include <map>
#include <string>
using namespace std;
@ -24,7 +25,7 @@ using namespace std;
// Env -- a mapping from ID names to their L/R-value expressions and evaluation
// methods.
enum IDType {
enum IDType : uint8_t {
CONST,
GLOBAL_VAR,
TEMP_VAR,
@ -44,7 +45,7 @@ class Evaluatable;
class ID : public Object {
public:
ID(string arg_name) : name(arg_name), anonymous_id_(false) { locname = nfmt("%s:%s", Location(), Name()); }
ID(string arg_name) : name(std::move(arg_name)) { locname = nfmt("%s:%s", Location(), Name()); }
~ID() { delete[] locname; }
bool operator==(ID const& x) const { return name == x.Name(); }
@ -57,8 +58,8 @@ public:
protected:
string name;
bool anonymous_id_;
char* locname;
bool anonymous_id_ = false;
char* locname = nullptr;
friend class ID_ptr_cmp;
public:
@ -146,7 +147,7 @@ public:
void set_in_branch(bool x) { in_branch_ = x; }
void AddID(const ID* id, IDType id_type, Type* type);
void AddConstID(const ID* id, const int c, Type* type = 0);
void AddConstID(const ID* id, const int c, Type* type = nullptr);
void AddMacro(const ID* id, Expr* expr);
// Generate a temp ID with a unique name
@ -192,7 +193,7 @@ protected:
private:
Env* parent;
Object* context_object_;
typedef map<const ID*, IDRecord*, ID_ptr_cmp> id_map_t;
using id_map_t = map<const ID*, IDRecord*, ID_ptr_cmp>;
id_map_t id_map;
bool allow_undefined_id_;
bool in_branch_;

2
tools/binpac/src/pac_inputbuf.cc
View file

@ -31,5 +31,5 @@ DataPtr InputBuffer::GenDataBeginEnd(Output* out_cc, Env* env) {
env->SetEvaluated(begin_of_data);
env->SetEvaluated(end_of_data);
return DataPtr(env, begin_of_data, 0);
return {env, begin_of_data, 0};
}

7
tools/binpac/src/pac_main.cc
View file

@ -1,7 +1,7 @@
// See the file "COPYING" in the main distribution directory for copyright.
#include <ctype.h>
#include <unistd.h>
#include <cctype>
#include "pac_common.h"
#include "pac_decl.h"
@ -9,7 +9,9 @@
#include "pac_exttype.h"
#include "pac_id.h"
#include "pac_output.h"
// NOLINTBEGIN
#include "pac_parse.h"
// NOLINTEND
#include "pac_type.h"
#include "pac_utils.h"
@ -27,7 +29,8 @@ Output* header_output = nullptr;
Output* source_output = nullptr;
void add_to_include_directories(string dirs) {
unsigned int dir_begin = 0, dir_end;
unsigned int dir_begin = 0;
unsigned int dir_end = 0;
while ( dir_begin < dirs.length() ) {
for ( dir_end = dir_begin; dir_end < dirs.length(); ++dir_end )
if ( dirs[dir_end] == ':' )

8
tools/binpac/src/pac_output.cc
View file

@ -2,10 +2,10 @@
#include "pac_output.h"
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <cerrno>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include "pac_utils.h"

125
tools/binpac/src/pac_parse.yy
View file

@ -1,7 +1,7 @@
%token TOK_TYPE TOK_RECORD TOK_CASE TOK_ENUM TOK_LET TOK_FUNCTION
%token TOK_REFINE TOK_CASEFUNC TOK_CASETYPE TOK_TYPEATTR
%token TOK_HELPERHEADER TOK_HELPERCODE
%token TOK_RIGHTARROW TOK_DEFAULT TOK_OF
%token TOK_RIGHTARROW TOK_DEFAULT TOK_OF
%token TOK_PADDING TOK_TO TOK_ALIGN
%token TOK_WITHINPUT
%token TOK_INT8 TOK_INT16 TOK_INT32 TOK_INT64
@ -11,19 +11,19 @@
%token TOK_ATTR_ALSO
%token TOK_ATTR_BYTEORDER TOK_ATTR_CHECK TOK_ATTR_CHUNKED TOK_ATTR_ENFORCE
%token TOK_ATTR_EXPORTSOURCEDATA TOK_ATTR_IF
%token TOK_ATTR_LENGTH TOK_ATTR_LET
%token TOK_ATTR_LENGTH TOK_ATTR_LET
%token TOK_ATTR_LINEBREAKER TOK_ATTR_MULTILINE TOK_ATTR_ONELINE
%token TOK_ATTR_REFCOUNT TOK_ATTR_REQUIRES
%token TOK_ATTR_REFCOUNT TOK_ATTR_REQUIRES
%token TOK_ATTR_RESTOFDATA TOK_ATTR_RESTOFFLOW
%token TOK_ATTR_TRANSIENT TOK_ATTR_UNTIL
%token TOK_ANALYZER TOK_CONNECTION TOK_FLOW
%token TOK_STATE TOK_ACTION TOK_WHEN TOK_HELPER
%token TOK_ANALYZER TOK_CONNECTION TOK_FLOW
%token TOK_STATE TOK_ACTION TOK_WHEN TOK_HELPER
%token TOK_DATAUNIT TOK_FLOWDIR TOK_WITHCONTEXT
%token TOK_LPB_EXTERN TOK_LPB_HEADER TOK_LPB_CODE
%token TOK_LPB_EXTERN TOK_LPB_HEADER TOK_LPB_CODE
%token TOK_LPB_MEMBER TOK_LPB_INIT TOK_LPB_CLEANUP TOK_LPB_EOF
%token TOK_LPB TOK_RPB
%token TOK_LPB TOK_RPB
%token TOK_EMBEDDED_ATOM TOK_EMBEDDED_STRING
%token TOK_PAC_VAL TOK_PAC_SET TOK_PAC_TYPE TOK_PAC_TYPEOF TOK_PAC_CONST_DEF
%token TOK_PAC_VAL TOK_PAC_SET TOK_PAC_TYPE TOK_PAC_TYPEOF TOK_PAC_CONST_DEF
%token TOK_END_PAC
%token TOK_EXTERN TOK_NULLPTR
@ -35,7 +35,7 @@
%left TOK_AND
%nonassoc TOK_EQUAL TOK_NEQ TOK_LE TOK_GE '<' '>'
%left '&' '|' '^'
%left TOK_LSHIFT TOK_RSHIFT
%left TOK_LSHIFT TOK_RSHIFT
%left '+' '-'
%left '*' '/' '%'
%right '~' '!'
@ -64,14 +64,14 @@
%type <field> withinputfield letfield
%type <fieldlist> letfieldlist
%type <function> funcproto function
%type <id> TOK_ID tok_id optfieldid
%type <id> TOK_ID tok_id optfieldid
%type <input> input
%type <nullp> TOK_NULLPTR
%type <num> TOK_NUMBER
%type <pacprimitive> embedded_pac_primitive
%type <param> param
%type <paramlist> optparams paramlist
%type <recordfield> recordfield recordfield0 padding
%type <recordfield> recordfield recordfield0 padding
%type <recordfieldlist> recordfieldlist
%type <regex> regex
%type <statevar> statevar
@ -262,15 +262,15 @@ decl_with_attr : TOK_TYPE tok_id { current_decl_id = $2; } optparams '=' type
decl_without_attr: TOK_LPB_HEADER embedded_code TOK_RPB
{
$$ = new HelperDecl(HelperDecl::HEADER, 0, $2);
$$ = new HelperDecl(HelperDecl::HEADER, nullptr, $2);
}
| TOK_LPB_CODE embedded_code TOK_RPB
{
$$ = new HelperDecl(HelperDecl::CODE, 0, $2);
$$ = new HelperDecl(HelperDecl::CODE, nullptr, $2);
}
| TOK_LPB_EXTERN embedded_code TOK_RPB
{
$$ = new HelperDecl(HelperDecl::EXTERN, 0, $2);
$$ = new HelperDecl(HelperDecl::EXTERN, nullptr, $2);
}
| TOK_REFINE TOK_TYPEATTR tok_id TOK_PLUSEQ attrlist
{
@ -359,11 +359,11 @@ optparams : '(' paramlist ')'
}
| /* empty */
{
$$ = 0;
$$ = nullptr;
}
;
paramlist : paramlist ',' param
paramlist : paramlist ',' param
{
$1->push_back($3);
$$ = $1;
@ -387,7 +387,7 @@ param : tok_id ':' type2
optinit : /* nothing */
{
$$ = 0;
$$ = nullptr;
}
| '=' expr
{
@ -397,7 +397,7 @@ optinit : /* nothing */
opttype : /* nothing */
{
$$ = 0;
$$ = nullptr;
}
| ':' type2
{
@ -465,7 +465,7 @@ recordfieldlist : recordfieldlist recordfield ';'
$1->push_back($2);
$$ = $1;
}
| /* empty */
| /* empty */
{
$$ = new RecordFieldList();
}
@ -526,7 +526,7 @@ casefieldlist : casefieldlist casefield ';'
$1->push_back($2);
$$ = $1;
}
| /* empty */
| /* empty */
{
$$ = new CaseFieldList();
}
@ -534,7 +534,7 @@ casefieldlist : casefieldlist casefield ';'
casefield : casefield0 optattrs
{
$1->AddAttr($2);
$1->AddAttr($2);
$$ = $1;
}
;
@ -545,13 +545,13 @@ casefield0 : exprlist TOK_RIGHTARROW tok_id ':' type2
}
| TOK_DEFAULT TOK_RIGHTARROW tok_id ':' type2
{
$$ = new CaseField(0, $3, $5);
$$ = new CaseField(nullptr, $3, $5);
}
;
optexprlist : /* nothing */
{
$$ = 0;
$$ = nullptr;
}
| exprlist
{
@ -605,8 +605,8 @@ expr : tok_id
}
| expr '(' optexprlist ')'
{
$$ = new Expr(Expr::EXPR_CALL,
$1,
$$ = new Expr(Expr::EXPR_CALL,
$1,
new Expr($3));
}
| '-' expr
@ -697,7 +697,7 @@ expr : tok_id
{
$$ = new Expr(Expr::EXPR_COND, $1, $3, $5);
}
| TOK_CASE expr TOK_OF '{' caseexprlist '}'
| TOK_CASE expr TOK_OF '{' caseexprlist '}'
{
$$ = new Expr($2, $5);
}
@ -718,8 +718,8 @@ cstr : TOK_STRING
;
regex : TOK_BEGIN_RE TOK_REGEX TOK_END_RE
{
$$ = new RegEx($2);
{
$$ = new RegEx($2);
}
;
@ -740,7 +740,7 @@ caseexpr : exprlist TOK_RIGHTARROW expr
}
| TOK_DEFAULT TOK_RIGHTARROW expr
{
$$ = new CaseExpr(0, $3);
$$ = new CaseExpr(nullptr, $3);
}
;
@ -823,8 +823,8 @@ sah : TOK_LPB_MEMBER embedded_code TOK_RPB
| TOK_DATAUNIT '=' tok_id optargs TOK_WITHCONTEXT '(' optexprlist ')' ';'
{
$$ = new AnalyzerDataUnit(
(AnalyzerDataUnit::DataUnitType) $1,
$3,
(AnalyzerDataUnit::DataUnitType) $1,
$3,
$4,
$7);
}
@ -916,7 +916,7 @@ embedded_pac_primitive: TOK_PAC_VAL expr TOK_END_PAC
optargs : /* empty */
{
$$ = 0;
$$ = nullptr;
}
| '(' optexprlist ')'
{
@ -924,7 +924,7 @@ optargs : /* empty */
}
;
letfieldlist : letfieldlist letfield ';'
letfieldlist : letfieldlist letfield ';'
{
$1->push_back($2);
$$ = $1;
@ -961,9 +961,9 @@ input : expr
}
;
optattrs : /* empty */
optattrs : /* empty */
{
$$ = 0;
$$ = nullptr;
}
| attrlist
{
@ -993,7 +993,7 @@ attr : TOK_ATTR_BYTEORDER '=' expr
{
$$ = new Attr(ATTR_BYTEORDER, $3);
}
| TOK_ATTR_CHECK expr
| TOK_ATTR_CHECK expr
{
$$ = new Attr(ATTR_CHECK, $2);
}
@ -1009,7 +1009,7 @@ attr : TOK_ATTR_BYTEORDER '=' expr
{
$$ = new Attr(ATTR_EXPORTSOURCEDATA);
}
| TOK_ATTR_IF expr
| TOK_ATTR_IF expr
{
$$ = new Attr(ATTR_IF, $2);
}
@ -1061,7 +1061,7 @@ attr : TOK_ATTR_BYTEORDER '=' expr
optlinebreaker : /* nothing */
{
$$ = 0;
$$ = nullptr;
}
| '(' expr ')'
{
@ -1071,35 +1071,34 @@ optlinebreaker : /* nothing */
%%
const ID* current_decl_id = 0;
const ID* current_decl_id = nullptr;
int yyerror(const char msg[])
{
auto n = strlen(msg) + yyleng + 64;
char* msgbuf = new char[n];
int yyerror(const char msg[]) {
auto n = strlen(msg) + yyleng + 64;
char* msgbuf = new char[n];
if ( ! yychar || ! yytext || yytext[0] == '\0' )
snprintf(msgbuf, n, "%s, at end of file", msg);
if ( ! yychar || ! yytext || yytext[0] == '\0' )
snprintf(msgbuf, n, "%s, at end of file", msg);
else if ( yytext[0] == '\n' )
snprintf(msgbuf, n, "%s, on previous line", msg);
else if ( yytext[0] == '\n' )
snprintf(msgbuf, n, "%s, on previous line", msg);
else
snprintf(msgbuf, n, "%s, at or near \"%s\"", msg, yytext);
else
snprintf(msgbuf, n, "%s, at or near \"%s\"", msg, yytext);
/*
extern int column;
sprintf(msgbuf, "%*s\n%*s\n", column, "^", column, msg);
*/
/*
extern int column;
sprintf(msgbuf, "%*s\n%*s\n", column, "^", column, msg);
*/
if ( ! input_filename.empty() )
fprintf(stderr, "%s:%d: ", input_filename.c_str(), line_number);
else
fprintf(stderr, "line %d: ", line_number);
fprintf(stderr, "%s", msgbuf);
fprintf(stderr, " (yychar=%d)", yychar);
fprintf(stderr, "\n");
if ( ! input_filename.empty() )
fprintf(stderr, "%s:%d: ", input_filename.c_str(), line_number);
else
fprintf(stderr, "line %d: ", line_number);
fprintf(stderr, "%s", msgbuf);
fprintf(stderr, " (yychar=%d)", yychar);
fprintf(stderr, "\n");
delete[] msgbuf;
return 0;
}
delete[] msgbuf;
return 0;
}

2
tools/binpac/src/pac_primitive.cc
View file

@ -9,7 +9,7 @@
string PPVal::ToCode(Env* env) {
ASSERT(expr_);
return string(expr_->EvalExpr(nullptr, env));
return {expr_->EvalExpr(nullptr, env)};
}
string PPSet::ToCode(Env* env) {

4
tools/binpac/src/pac_primitive.h
View file

@ -3,11 +3,13 @@
#ifndef pac_primitive_h
#define pac_primitive_h
#include <cstdint>
#include "pac_common.h"
class PacPrimitive {
public:
enum PrimitiveType { VAL, SET, TYPE, CONST_DEF };
enum PrimitiveType : uint8_t { VAL, SET, TYPE, CONST_DEF };
explicit PacPrimitive(PrimitiveType type) : type_(type) {}
virtual ~PacPrimitive() {}

2
tools/binpac/src/pac_record.cc
View file

@ -29,7 +29,7 @@ RecordType::RecordType(RecordFieldList* record_fields) : Type(RECORD) {
}
RecordType::~RecordType() {
// Do not delete_list(RecordFieldList, record_fields_)
// Do not delete_list(record_fields_)
// because the fields are also in fields_.
delete record_fields_;
delete parsing_dataptr_var_field_;

2
tools/binpac/src/pac_record.h
View file

@ -135,7 +135,7 @@ protected:
bool DoTraverse(DataDepVisitor* visitor) override;
};
enum PaddingType { PAD_BY_LENGTH, PAD_TO_OFFSET, PAD_TO_NEXT_WORD };
enum PaddingType : uint8_t { PAD_BY_LENGTH, PAD_TO_OFFSET, PAD_TO_NEXT_WORD };
class RecordPaddingField : public RecordField {
public:

230
tools/binpac/src/pac_scan.ll
View file

@ -45,38 +45,36 @@ int line_number = 1;
int begin_pac_primitive(int tok);
int end_pac_primitive();
int string_token(int tok)
{
yylval.str = copy_string(yytext);
return tok;
}
int string_token(int tok) {
yylval.str = copy_string(yytext);
return tok;
}
int char_token(int tok)
{
yylval.val = yytext[0];
return tok;
}
int char_token(int tok) {
yylval.val = yytext[0];
return tok;
}
void include_file(const char *filename);
void include_file(const char* filename);
std::string do_dirname(std::string_view s)
{
std::string do_dirname(std::string_view s) {
#ifdef _MSC_VER
return std::filesystem::path(s).parent_path().string();
return std::filesystem::path(s).parent_path().string();
#else
std::unique_ptr<char[]> tmp{new char[s.size()+1]};
strncpy(tmp.get(), s.data(), s.size());
tmp[s.size()] = '\0';
std::unique_ptr<char[]> tmp{new char[s.size() + 1]};
strncpy(tmp.get(), s.data(), s.size());
tmp[s.size()] = '\0';
char* dn = dirname(tmp.get());
if ( !dn )
return "";
char* dn = dirname(tmp.get());
if ( ! dn )
return "";
std::string res{dn};
std::string res{dn};
return res;
return res;
#endif
}
}
%}
/* EC -- embedded code state */
@ -283,133 +281,109 @@ ESCSEQ (\\([^\n]|[0-7]{3}|x[[:xdigit:]]{2}))
%%
void begin_RE()
{
BEGIN(RE);
}
void begin_RE() {
BEGIN(RE);
}
void end_RE()
{
BEGIN(INITIAL);
}
void end_RE() { BEGIN(INITIAL); }
// The DECL state is deprecated
void begin_decl()
{
// BEGIN(DECL);
}
void begin_decl() {
// BEGIN(DECL);
}
void end_decl()
{
// BEGIN(INITIAL);
}
void end_decl() {
// BEGIN(INITIAL);
}
int begin_pac_primitive(int tok)
{
BEGIN(PP);
return tok;
}
int begin_pac_primitive(int tok) {
BEGIN(PP);
return tok;
}
int end_pac_primitive()
{
BEGIN(EC);
return TOK_END_PAC;
}
int end_pac_primitive() {
BEGIN(EC);
return TOK_END_PAC;
}
const int MAX_INCLUDE_DEPTH = 100;
constexpr int MAX_INCLUDE_DEPTH = 100;
struct IncludeState {
YY_BUFFER_STATE yystate;
string input_filename;
int line_number;
YY_BUFFER_STATE yystate;
string input_filename;
int line_number;
};
IncludeState include_stack[MAX_INCLUDE_DEPTH];
int include_stack_ptr = 0;
void switch_to_file(FILE *fp)
{
yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
}
void switch_to_file(FILE* fp) { yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE)); }
void switch_to_file(const char *filename)
{
if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
{
fprintf( stderr, "Includes nested too deeply" );
exit( 1 );
}
void switch_to_file(const char* filename) {
if ( include_stack_ptr >= MAX_INCLUDE_DEPTH ) {
fprintf(stderr, "Includes nested too deeply");
exit(1);
}
IncludeState state =
{ YY_CURRENT_BUFFER, input_filename, line_number };
include_stack[include_stack_ptr++] = state;
IncludeState state = {YY_CURRENT_BUFFER, input_filename, line_number};
include_stack[include_stack_ptr++] = state;
FILE *fp = fopen(filename, "r");
FILE* fp = fopen(filename, "r");
if ( ! fp )
{
fprintf(stderr, "%s:%d: error: cannot include file \"%s\"\n",
input_filename.c_str(), line_number,filename);
exit( 1 );
}
if ( ! fp ) {
fprintf(stderr, "%s:%d: error: cannot include file \"%s\"\n", input_filename.c_str(), line_number, filename);
exit(1);
}
yyin = fp;
input_filename = string(filename);
line_number = 1;
switch_to_file(yyin);
if ( !FLAGS_quiet )
fprintf(stderr, "switching to file %s\n", input_filename.c_str());
}
yyin = fp;
input_filename = string(filename);
line_number = 1;
switch_to_file(yyin);
if ( ! FLAGS_quiet )
fprintf(stderr, "switching to file %s\n", input_filename.c_str());
}
void include_file(const char *filename)
{
ASSERT(filename);
void include_file(const char* filename) {
ASSERT(filename);
string full_filename;
if ( filename[0] == '/' )
full_filename = filename;
else if ( filename[0] == '.' )
{
string dir = do_dirname(input_filename);
string full_filename;
if ( filename[0] == '/' )
full_filename = filename;
else if ( filename[0] == '.' ) {
string dir = do_dirname(input_filename);
if ( ! dir.empty() )
full_filename = dir + "/" + filename;
else
{
fprintf(stderr, "%s:%d error: cannot include file \"%s\": %s\n",
input_filename.c_str(), line_number, filename,
strerror(errno));
exit( 1 );
}
}
else
{
int i;
for ( i = 0; i < (int) FLAGS_include_directories.size(); ++i )
{
full_filename = FLAGS_include_directories[i] + filename;
DEBUG_MSG("Try include file: \"%s\"\n",
full_filename.c_str());
if ( access(full_filename.c_str(), R_OK) == 0 )
break;
}
if ( i >= (int) FLAGS_include_directories.size() )
full_filename = filename;
}
if ( ! dir.empty() )
full_filename = dir + "/" + filename;
else {
fprintf(stderr, "%s:%d error: cannot include file \"%s\": %s\n", input_filename.c_str(), line_number,
filename, strerror(errno));
exit(1);
}
}
else {
int i;
for ( i = 0; i < (int)FLAGS_include_directories.size(); ++i ) {
full_filename = FLAGS_include_directories[i] + filename;
DEBUG_MSG("Try include file: \"%s\"\n", full_filename.c_str());
if ( access(full_filename.c_str(), R_OK) == 0 )
break;
}
if ( i >= (int)FLAGS_include_directories.size() )
full_filename = filename;
}
switch_to_file(full_filename.c_str());
}
switch_to_file(full_filename.c_str());
}
int yywrap()
{
yy_delete_buffer(YY_CURRENT_BUFFER);
--include_stack_ptr;
if ( include_stack_ptr < 0 )
return 1;
int yywrap() {
yy_delete_buffer(YY_CURRENT_BUFFER);
--include_stack_ptr;
if ( include_stack_ptr < 0 )
return 1;
IncludeState state = include_stack[include_stack_ptr];
yy_switch_to_buffer(state.yystate);
input_filename = state.input_filename;
line_number = state.line_number;
return 0;
}
IncludeState state = include_stack[include_stack_ptr];
yy_switch_to_buffer(state.yystate);
input_filename = state.input_filename;
line_number = state.line_number;
return 0;
}

6
tools/binpac/src/pac_strtype.cc
View file

@ -273,11 +273,7 @@ void StringType::GenDynamicSizeRegEx(Output* out_cc, Env* env, const DataPtr& da
void StringType::GenDynamicSizeAnyStr(Output* out_cc, Env* env, const DataPtr& data) {
ASSERT(type_ == ANYSTR);
if ( attr_restofdata_ || attr_oneline_ ) {
out_cc->println("%s = (%s) - (%s);", env->LValue(string_length_var()), env->RValue(end_of_data),
data.ptr_expr());
}
else if ( attr_restofflow_ ) {
if ( attr_restofdata_ || attr_oneline_ || attr_restofflow_ ) {
out_cc->println("%s = (%s) - (%s);", env->LValue(string_length_var()), env->RValue(end_of_data),
data.ptr_expr());
}

4
tools/binpac/src/pac_strtype.h
View file

@ -3,12 +3,14 @@
#ifndef pac_strtype_h
#define pac_strtype_h
#include <cstdint>
#include "pac_type.h"
// TODO: question: shall we merge it with ArrayType?
class StringType : public Type {
public:
enum StringTypeEnum { CSTR, REGEX, ANYSTR };
enum StringTypeEnum : uint8_t { CSTR, REGEX, ANYSTR };
explicit StringType(StringTypeEnum anystr);
explicit StringType(ConstString* str);

10
tools/binpac/src/pac_type.cc
View file

@ -75,14 +75,14 @@ Type::~Type() {
delete buffering_state_var_field_;
delete has_value_field_;
delete[] size_expr_;
delete_list(FieldList, fields_);
delete_list(fields_);
delete attrs_;
delete attr_byteorder_expr_;
delete attr_if_expr_;
delete attr_length_expr_;
delete_list(ExprList, attr_checks_);
delete_list(ExprList, attr_enforces_);
delete_list(ExprList, attr_requires_);
delete_list(attr_checks_);
delete_list(attr_enforces_);
delete_list(attr_requires_);
}
Type* Type::Clone() const {
@ -696,7 +696,7 @@ string Type::DataSize(Output* out_cc, Env* env, const DataPtr& data) {
}
else {
if ( ! size_var() || ! env->Evaluated(size_var()) ) {
ASSERT(out_cc != 0);
ASSERT(out_cc != nullptr);
GenDynamicSize(out_cc, env, data);
ASSERT(size_var());
}

2
tools/binpac/src/pac_type.h
View file

@ -303,7 +303,7 @@ public:
static Type* LookUpByID(ID* id);
protected:
typedef map<string, Type*> type_map_t;
using type_map_t = map<string, Type*>;
static type_map_t type_map_;
};

10
tools/binpac/src/pac_typedecl.cc
View file

@ -27,7 +27,7 @@ TypeDecl::~TypeDecl() {
delete env_;
delete type_;
delete_list(ParamList, params_);
delete_list(params_);
}
void TypeDecl::ProcessAttr(Attr* a) { type_->ProcessAttr(a); }
@ -101,7 +101,7 @@ void TypeDecl::GenCode(Output* out_h, Output* out_cc) {
AddBaseClass(&base_classes);
if ( type_->attr_refcount() )
base_classes.push_back(kRefCountClass);
base_classes.emplace_back(kRefCountClass);
// The first line of class definition
out_h->println("");
@ -232,7 +232,8 @@ string TypeDecl::ParseFuncPrototype(Env* env) {
}
void TypeDecl::GenParsingEnd(Output* out_cc, Env* env, const DataPtr& data) {
string ret_val_0, ret_val_1;
string ret_val_0;
string ret_val_1;
if ( type_->incremental_input() ) {
ret_val_0 = type_->parsing_complete(env).c_str();
@ -259,9 +260,6 @@ void TypeDecl::GenParsingEnd(Output* out_cc, Env* env, const DataPtr& data) {
out_cc->println("BINPAC_ASSERT(!(%s));", type_->parsing_complete(env).c_str());
out_cc->println("return %s;", ret_val_1.c_str());
}
else if ( type_->incremental_input() ) {
out_cc->println("return %s;", ret_val_0.c_str());
}
else {
out_cc->println("return %s;", ret_val_0.c_str());
}

8
tools/binpac/src/pac_utils.cc
View file

@ -2,9 +2,9 @@
#include "pac_utils.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <cstdarg>
#include <cstdio>
#include <cstring>
char* copy_string(const char* s) {
char* c = new char[strlen(s) + 1];
@ -27,7 +27,7 @@ string strfmt(const char* format, ...) {
va_start(ap, format);
const char* r = do_fmt(format, ap);
va_end(ap);
return string(r);
return {r};
}
char* nfmt(const char* format, ...) {

2
tools/gen-zam/CMakeLists.txt
View file

@ -1,2 +1,2 @@
add_executable(gen-zam)
target_sources(gen-zam PRIVATE src/Gen-ZAM.cc)
target_sources(gen-zam PRIVATE Gen-ZAM.cc)

0
tools/gen-zam/src/Gen-ZAM.cc → tools/gen-zam/Gen-ZAM.cc
View file

0
tools/gen-zam/src/Gen-ZAM.h → tools/gen-zam/Gen-ZAM.h
View file