Make it compile on Ubuntu, with some pain

Author: zwoop

plugins/header_rewrite/header_rewrite.cc

@@ -70,67 +70,20 @@ initHRWLibraries(const std::string &dbPath)
 // Forward declaration for the main continuation.
 static int cont_rewrite_headers(TSCont, TSEvent, void *);
 
-// Simple wrapper around a configuration file / set. This is useful such that
-// we can reuse most of the code for both global and per-remap rule sets.
-class RulesConfig
-{
-public:
-  RulesConfig(int timezone, int inboundIpSource) : _timezone(timezone), _inboundIpSource(inboundIpSource)
-  {
-    Dbg(dbg_ctl, "RulesConfig CTOR");
-    _cont = TSContCreate(cont_rewrite_headers, nullptr);
-    TSContDataSet(_cont, static_cast<void *>(this));
-  }
-
-  ~RulesConfig()
-  {
-    Dbg(dbg_ctl, "RulesConfig DTOR");
-    TSContDestroy(_cont);
-  }
-
-  [[nodiscard]] TSCont
-  continuation() const
-  {
-    return _cont;
-  }
+#include "rules_config.h"
 
-  [[nodiscard]] ResourceIDs
-  resid(int hook) const
-  {
-    return _resids[hook];
-  }
-
-  [[nodiscard]] RuleSet *
-  rule(int hook) const
-  {
-    return _rules[hook].get();
-  }
-
-  [[nodiscard]] int
-  timezone() const
-  {
-    return _timezone;
-  }
-
-  [[nodiscard]] int
-  inboundIpSource() const
-  {
-    return _inboundIpSource;
-  }
-
-  bool parse_config(const std::string &fname, TSHttpHookID default_hook, char *from_url = nullptr, char *to_url = nullptr,
-                    bool force_hrw4u = false);
-
-private:
-  void add_rule(std::unique_ptr<RuleSet> rule);
-
-  TSCont                                                      _cont;
-  std::array<std::unique_ptr<RuleSet>, TS_HTTP_LAST_HOOK + 1> _rules{};
-  std::array<ResourceIDs, TS_HTTP_LAST_HOOK + 1>              _resids{};
+RulesConfig::RulesConfig(int timezone, int inboundIpSource) : _timezone(timezone), _inboundIpSource(inboundIpSource)
+{
+  Dbg(dbg_ctl, "RulesConfig CTOR");
+  _cont = TSContCreate(cont_rewrite_headers, nullptr);
+  TSContDataSet(_cont, static_cast<void *>(this));
+}
 
-  int _timezone        = 0;
-  int _inboundIpSource = 0;
-};
+RulesConfig::~RulesConfig()
+{
+  Dbg(dbg_ctl, "RulesConfig DTOR");
+  TSContDestroy(_cont);
+}
 
 void
 RulesConfig::add_rule(std::unique_ptr<RuleSet> rule)

plugins/header_rewrite/rules_config.h

@@ -0,0 +1,77 @@
+/*
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <string>
+
+#include "ts/ts.h"
+#include "ruleset.h"
+#include "resources.h"
+
+class RulesConfig
+{
+public:
+  RulesConfig(int timezone, int inboundIpSource);
+  ~RulesConfig();
+
+  bool parse_config(const std::string &fname, TSHttpHookID default_hook, char *from_url = nullptr, char *to_url = nullptr,
+                    bool force_hrw4u = false);
+
+  [[nodiscard]] TSCont
+  continuation() const
+  {
+    return _cont;
+  }
+
+  [[nodiscard]] ResourceIDs
+  resid(int hook) const
+  {
+    return _resids[hook];
+  }
+
+  [[nodiscard]] RuleSet *
+  rule(int hook) const
+  {
+    return _rules[hook].get();
+  }
+
+  [[nodiscard]] int
+  timezone() const
+  {
+    return _timezone;
+  }
+
+  [[nodiscard]] int
+  inboundIpSource() const
+  {
+    return _inboundIpSource;
+  }
+
+private:
+  void add_rule(std::unique_ptr<RuleSet> rule);
+
+  TSCont                                                      _cont;
+  std::array<std::unique_ptr<RuleSet>, TS_HTTP_LAST_HOOK + 1> _rules{};
+  std::array<ResourceIDs, TS_HTTP_LAST_HOOK + 1>              _resids{};
+
+  int _timezone        = 0;
+  int _inboundIpSource = 0;
+};

src/hrw4u/CMakeLists.txt

@@ -15,7 +15,6 @@
 #
 #######################
 
-# Find ANTLR4 runtime
 find_package(antlr4-runtime QUIET)
 
 if(NOT antlr4-runtime_FOUND)
@@ -27,7 +26,6 @@ if(NOT antlr4-runtime_FOUND)
   return()
 endif()
 
-# Find ANTLR4 generator tool
 find_program(ANTLR4_EXECUTABLE antlr4 NAMES antlr4 antlr)
 
 if(NOT ANTLR4_EXECUTABLE)
@@ -39,22 +37,55 @@ if(NOT ANTLR4_EXECUTABLE)
   return()
 endif()
 
-# ANTLR4 available - hrw4u will be built
+# Verify tool version matches runtime (ANTLR4 C++ API breaks between minor versions).
+if(ANTLR_VERSION)
+  execute_process(
+    COMMAND ${ANTLR4_EXECUTABLE}
+    OUTPUT_VARIABLE _antlr4_tool_stdout
+    ERROR_VARIABLE _antlr4_tool_stderr
+    OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE
+    TIMEOUT 10
+  )
+  set(_antlr4_tool_output "${_antlr4_tool_stdout} ${_antlr4_tool_stderr}")
+  string(REGEX MATCH "[Vv]ersion[ \t]+([0-9]+\\.[0-9]+\\.?[0-9]*)" _antlr4_version_match "${_antlr4_tool_output}")
+  set(_antlr4_tool_version "${CMAKE_MATCH_1}")
+  unset(_antlr4_tool_stdout)
+  unset(_antlr4_tool_stderr)
+  unset(_antlr4_tool_output)
+  unset(_antlr4_version_match)
+
+  if(_antlr4_tool_version)
+    string(REGEX MATCH "^([0-9]+\\.[0-9]+)" _tool_major_minor "${_antlr4_tool_version}")
+    string(REGEX MATCH "^([0-9]+\\.[0-9]+)" _runtime_major_minor "${ANTLR_VERSION}")
+    if(NOT _tool_major_minor STREQUAL _runtime_major_minor)
+      message(WARNING "ANTLR4 version mismatch: tool is ${_antlr4_tool_version}, runtime is ${ANTLR_VERSION}. "
+                      "hrw4u will not be built. Install matching versions to enable hrw4u."
+      )
+      set(TS_HAS_CPP_HRW4U
+          FALSE
+          PARENT_SCOPE
+      )
+      return()
+    endif()
+    message(STATUS "ANTLR4 tool version ${_antlr4_tool_version} matches runtime ${ANTLR_VERSION}")
+    unset(_tool_major_minor)
+    unset(_runtime_major_minor)
+  else()
+    message(STATUS "Could not determine ANTLR4 tool version, proceeding with runtime ${ANTLR_VERSION}")
+  endif()
+  unset(_antlr4_tool_version)
+endif()
+
 set(TS_HAS_CPP_HRW4U
     TRUE
     PARENT_SCOPE
 )
-
 message(STATUS "Building hrw4u library with ANTLR4 support")
 
-# Grammar file location
 set(HRW4U_GRAMMAR_FILE "${PROJECT_SOURCE_DIR}/tools/hrw4u/grammar/hrw4u.g4")
-
-# Generated parser output directory
 set(HRW4U_GENERATED_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
 file(MAKE_DIRECTORY ${HRW4U_GENERATED_DIR})
 
-# Generate C++ parser from grammar
 set(HRW4U_GENERATED_SOURCES ${HRW4U_GENERATED_DIR}/hrw4uLexer.cpp ${HRW4U_GENERATED_DIR}/hrw4uParser.cpp
                             ${HRW4U_GENERATED_DIR}/hrw4uBaseVisitor.cpp ${HRW4U_GENERATED_DIR}/hrw4uVisitor.cpp
 )
@@ -73,19 +104,14 @@ add_custom_command(
 
 add_custom_target(hrw4u_generated DEPENDS ${HRW4U_GENERATED_SOURCES})
 
-# Suppress warnings for generated ANTLR4 code
 set_source_files_properties(${HRW4U_GENERATED_SOURCES} PROPERTIES COMPILE_FLAGS "-Wno-unused-parameter")
 
-# Library sources
 set(HRW4U_SOURCES Error.cc Types.cc Tables.cc Visitor.cc HRW4UVisitorImpl.cc)
 
-# Create static library
 add_library(hrw4u STATIC ${HRW4U_SOURCES} ${HRW4U_GENERATED_SOURCES})
 add_library(ts::hrw4u ALIAS hrw4u)
 
-# GCC treats out-of-order and missing designated initializers as errors under
-# -Werror. The hrw4u tables use Clang-style designated initializers that rely
-# on default member values, which is safe but upsets GCC.
+# GCC errors on Clang-style designated initializers under -Werror.
 target_compile_options(hrw4u PRIVATE -Wno-missing-field-initializers)
 set_target_properties(hrw4u PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
@@ -97,12 +123,16 @@ target_include_directories(
   PRIVATE ${HRW4U_GENERATED_DIR} ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-# Prefer static ANTLR4, fall back to shared if unavailable.
-if(TARGET antlr4_static)
-  target_link_libraries(hrw4u PUBLIC antlr4_static)
-else()
+# Prefer shared ANTLR4 runtime (distro static libs may lack -fPIC).
+if(TARGET antlr4_shared)
   target_link_libraries(hrw4u PUBLIC antlr4_shared)
-  target_include_directories(hrw4u PRIVATE ${ANTLR4_INCLUDE_DIR})
+elseif(TARGET antlr4_static)
+  target_link_libraries(hrw4u PUBLIC antlr4_static)
+endif()
+
+# Fallback for distro packages that don't set INTERFACE_INCLUDE_DIRECTORIES.
+if(ANTLR4_INCLUDE_DIR)
+  target_include_directories(hrw4u PUBLIC ${ANTLR4_INCLUDE_DIR})
 endif()
 
 set(HRW4U_PUBLIC_HEADERS

tools/hrw4u/README.md

@@ -21,10 +21,73 @@ Decompiles existing `header_rewrite` rules back into HRW4U source code.
 
 ## Requirements
 
+### Python Tools (hrw4u, u4wrh)
 - **Python 3.11+** (uses modern type annotations and performance features)
 - **ANTLR4** for grammar parsing
 - **uv** (for Python environment management)
 
+### C++ Native Parser (src/hrw4u)
+
+ATS includes a C++ ANTLR4-based parser that lets the `header_rewrite` plugin
+load `.hrw4u` files directly. Building it requires:
+
+- **ANTLR4 C++ runtime** (headers and shared library)
+- **ANTLR4 tool** (`antlr4` command, same major.minor version as the runtime)
+
+#### macOS (Homebrew)
+```bash
+brew install antlr4-cpp-runtime antlr4
+```
+
+#### Fedora/RHEL
+```bash
+dnf install antlr4-cpp-runtime-devel antlr4
+```
+
+#### Ubuntu/Debian (from source recommended)
+
+The distro packages often have version mismatches between the tool and runtime,
+and the shared library may be built with a different C++ ABI. Building from
+source is recommended:
+
+```bash
+# Download ANTLR4 C++ runtime source (match JAR version)
+# https://github.com/antlr/antlr4/releases
+
+cd antlr4-cpp-runtime-<version>
+cmake -B build \
+  -DCMAKE_INSTALL_PREFIX=/opt/antlr4 \
+  -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+  -DANTLR4_INSTALL=ON
+cmake --build build -j$(nproc)
+cmake --install build
+```
+
+If you are building ATS with a non-default compiler toolchain, build the
+ANTLR4 runtime with the same compilers to avoid ABI mismatches:
+
+```bash
+cmake -B build \
+  -DCMAKE_C_COMPILER=/opt/llvm/bin/clang \
+  -DCMAKE_CXX_COMPILER=/opt/llvm/bin/clang++ \
+  -DCMAKE_CXX_FLAGS="-stdlib=libc++" \
+  -DCMAKE_INSTALL_PREFIX=/opt/antlr4 \
+  -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+  -DANTLR4_INSTALL=ON
+cmake --build build -j$(nproc)
+cmake --install build
+```
+
+Then pass the install prefix when configuring ATS:
+```bash
+cmake -B build -DCMAKE_PREFIX_PATH=/opt/antlr4 ...
+```
+
+If the `antlr4` tool is not on `PATH`, set it explicitly:
+```bash
+cmake -B build -DANTLR4_EXECUTABLE=/opt/antlr4/bin/antlr4 ...
+```
+
 ## Development Setup
 
 ### 1. Clone and Setup Environment