Reqrite project as BEd specific.

include/internal/address/address.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include "definitions.h"
+#include "internal/generic.h"
+#include "pch.h"
+
+namespace bed::internal::address {
+struct address_error : ed_error {
+  address_error(const char *msg) : ed_error(msg) {}
+};
+
+struct Address {
+  // % refers to range of whatever was resulted from the previous modification.
+  // it expands in theory to a Num,Num and so can be followed by chaining more adresses the ed way.
+  // this is handled and resolved by the handle function,
+  // the constuctor and resolve etc. are also only called in the handle function,
+  // i.e. handle is the only public facing API from this namespace & class for now.
+  //
+  // in case of any issue an instance of address_error(const char *) is thrown.
+
+  struct Result {
+    std::array<uint64_t, 2> data{};
+    uint8_t size{0};
+    std::span<const uint64_t> span(uint8_t max = UINT8_MAX) const {
+      return {data.data(), std::min(size, max)};
+    }
+  };
+
+  struct None {};
+
+  // Posix ed types of addressing.
+  struct Current {}; // .
+
+  struct Last {}; // $
+
+  struct Number { // n
+    uint64_t i;
+  };
+
+  struct Mark { // 'm
+    char m;
+  };
+
+  struct RegexLine { // /re/ or ?re?
+    internal::Direction dir;
+    std::string re;
+  };
+
+  // BEd Extended types of addressing.
+  struct Regex {             // &/re/ or &?re?
+    internal::Direction dir; // returns next/previous line containing the regex
+    std::string re;          // (not only if it matches full line)
+  };
+
+  struct Diagnostic { // #n# for diagnostic number n. (From lsp.)
+    uint16_t n;
+  };
+
+  struct DiagnosticNext { // ^ or % for previous/next diagnostic
+    internal::Direction dir;
+  };
+
+  struct SymbolDefinition { // <sym> goto symbol definition. (From lsp or using internal language parsers)
+    std::string sym;
+  };
+
+  struct SymbolReference { // <sym:n> goto nth symbol reference
+    uint16_t n;
+    std::string sym;
+  };
+
+  struct SymbolReferenceNext { // >sym> or <sym<
+    internal::Direction dir;   // goto next or previous symbol reference
+    std::string sym;
+  };
+
+  struct Block { // [ or ] goto start/end of containing block.
+    internal::Direction dir;
+  };
+
+  struct Scripted {   // (function_name:arguments)
+    std::string func; // Calls ruby mapping with name giving the argument as string.
+    std::string arg;  // resolves to line number returned by function (or throws error).
+                      // The mruby runtime also has the full context of the file and extentions etc.
+  };
+
+  std::variant<
+    std::monostate,
+    None,
+    Current,
+    Last,
+    Number,
+    Mark,
+    RegexLine,
+    Regex,
+    Diagnostic,
+    DiagnosticNext,
+    SymbolDefinition,
+    SymbolReference,
+    SymbolReferenceNext,
+    Block,
+    Scripted>
+    base{};
+
+  // they can then be followed by any number of +n or -n etc accumulating in.
+  int64_t offset = 0;
+
+  Address(std::string &cmd, uint64_t &i);
+  Address() = default;
+
+  uint64_t resolve(BEd &ctx);
+
+  static Result handle(BEd &ctx, std::string &cmd, uint64_t &i);
+};
+} // namespace bed::internal::address