gcc/rust/ast/rust-fmt.h

   1 // Copyright (C) 2023-2025 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #ifndef RUST_FMT_H
  20 #define RUST_FMT_H
  21
  22 #include "rust-system.h"
  23 #include <cstddef>
  24
  25 // FIXME: How to encode Option?
  26
  27 namespace Rust {
  28 namespace Fmt {
  29
  30 namespace ffi {
  31
  32 struct RustHamster
  33 {
  34   const char *ptr;
  35   size_t len;
  36
  37   std::string to_string () const;
  38 };
  39
  40 /// Enum of alignments which are supported.
  41 enum class Alignment
  42 {
  43   /// The value will be aligned to the left.
  44   AlignLeft,
  45   /// The value will be aligned to the right.
  46   AlignRight,
  47   /// The value will be aligned in the center.
  48   AlignCenter,
  49   /// The value will take on a default alignment.
  50   AlignUnknown,
  51 };
  52
  53 /// Enum for the debug hex flags.
  54 enum class DebugHex
  55 {
  56   /// The `x` flag in `{:x?}`.
  57   Lower,
  58   /// The `X` flag in `{:X?}`.
  59   Upper,
  60 };
  61
  62 /// Enum for the sign flags.
  63 enum class Sign
  64 {
  65   /// The `+` flag.
  66   Plus,
  67   /// The `-` flag.
  68   Minus,
  69 };
  70
  71 /// Enum describing where an argument for a format can be located.
  72 struct Position
  73 {
  74   enum class Tag
  75   {
  76     /// The argument is implied to be located at an index
  77     ArgumentImplicitlyIs,
  78     /// The argument is located at a specific index given in the format,
  79     ArgumentIs,
  80     /// The argument has a name.
  81     ArgumentNamed,
  82   };
  83
  84   struct ArgumentImplicitlyIs_Body
  85   {
  86     size_t _0;
  87   };
  88
  89   struct ArgumentIs_Body
  90   {
  91     size_t _0;
  92   };
  93
  94   struct ArgumentNamed_Body
  95   {
  96     RustHamster _0;
  97   };
  98
  99   Tag tag;
 100   union
 101   {
 102     ArgumentImplicitlyIs_Body argument_implicitly_is;
 103     ArgumentIs_Body argument_is;
 104     ArgumentNamed_Body argument_named;
 105   };
 106 };
 107
 108 /// Range inside of a `Span` used for diagnostics when we only have access to
 109 /// relative positions.
 110 struct InnerSpan
 111 {
 112   size_t start;
 113   size_t end;
 114 };
 115
 116 /// A count is used for the precision and width parameters of an integer, and
 117 /// can reference either an argument or a literal integer.
 118 struct Count
 119 {
 120   enum class Tag
 121   {
 122     /// The count is specified explicitly.
 123     CountIs,
 124     /// The count is specified by the argument with the given name.
 125     CountIsName,
 126     /// The count is specified by the argument at the given index.
 127     CountIsParam,
 128     /// The count is specified by a star (like in `{:.*}`) that refers to the
 129     /// argument at the given index.
 130     CountIsStar,
 131     /// The count is implied and cannot be explicitly specified.
 132     CountImplied,
 133   };
 134
 135   struct CountIs_Body
 136   {
 137     size_t _0;
 138   };
 139
 140   struct CountIsName_Body
 141   {
 142     RustHamster _0;
 143     InnerSpan _1;
 144   };
 145
 146   struct CountIsParam_Body
 147   {
 148     size_t _0;
 149   };
 150
 151   struct CountIsStar_Body
 152   {
 153     size_t _0;
 154   };
 155
 156   Tag tag;
 157   union
 158   {
 159     CountIs_Body count_is;
 160     CountIsName_Body count_is_name;
 161     CountIsParam_Body count_is_param;
 162     CountIsStar_Body count_is_star;
 163   };
 164 };
 165
 166 /// Specification for the formatting of an argument in the format string.
 167 struct FormatSpec
 168 {
 169   /// Optionally specified character to fill alignment with.
 170   const uint32_t *fill;
 171   /// Span of the optionally specified fill character.
 172   const InnerSpan *fill_span;
 173   /// Optionally specified alignment.
 174   Alignment align;
 175   /// The `+` or `-` flag.
 176   const Sign *sign;
 177   /// The `#` flag.
 178   bool alternate;
 179   /// The `0` flag.
 180   bool zero_pad;
 181   /// The `x` or `X` flag. (Only for `Debug`.)
 182   const DebugHex *debug_hex;
 183   /// The integer precision to use.
 184   Count precision;
 185   /// The span of the precision formatting flag (for diagnostics).
 186   const InnerSpan *precision_span;
 187   /// The string width requested for the resulting format.
 188   Count width;
 189   /// The span of the width formatting flag (for diagnostics).
 190   const InnerSpan *width_span;
 191   /// The descriptor string representing the name of the format desired for
 192   /// this argument, this can be empty or any number of characters, although
 193   /// it is required to be one word.
 194   RustHamster ty;
 195   /// The span of the descriptor string (for diagnostics).
 196   const InnerSpan *ty_span;
 197 };
 198
 199 /// Representation of an argument specification.
 200 struct Argument
 201 {
 202   /// Where to find this argument
 203   Position position;
 204   /// The span of the position indicator. Includes any whitespace in implicit
 205   /// positions (`{  }`).
 206   InnerSpan position_span;
 207   /// How to format the argument
 208   FormatSpec format;
 209 };
 210
 211 /// A piece is a portion of the format string which represents the next part
 212 /// to emit. These are emitted as a stream by the `Parser` class.
 213 struct Piece
 214 {
 215   enum class Tag
 216   {
 217     /// A literal string which should directly be emitted
 218     String,
 219     /// This describes that formatting should process the next argument (as
 220     /// specified inside) for emission.
 221     NextArgument,
 222   };
 223
 224   struct String_Body
 225   {
 226     RustHamster _0;
 227   };
 228
 229   struct NextArgument_Body
 230   {
 231     Argument _0;
 232   };
 233
 234   Tag tag;
 235   union
 236   {
 237     String_Body string;
 238     NextArgument_Body next_argument;
 239   };
 240 };
 241
 242 struct PieceSlice
 243 {
 244   const Piece *base_ptr;
 245   size_t len;
 246   size_t cap;
 247 };
 248
 249 struct RustString
 250 {
 251   const unsigned char *ptr;
 252   size_t len;
 253   size_t cap;
 254 };
 255
 256 struct FormatArgsHandle
 257 {
 258   PieceSlice piece_slice;
 259   RustString rust_string;
 260 };
 261
 262 extern "C" {
 263
 264 FormatArgsHandle
 265 collect_pieces (const char *input, bool append_newline);
 266
 267 FormatArgsHandle
 268 clone_pieces (const FormatArgsHandle &);
 269
 270 void destroy_pieces (FormatArgsHandle);
 271
 272 } // extern "C"
 273
 274 } // namespace ffi
 275
 276 struct Pieces
 277 {
 278   static Pieces collect (const std::string &to_parse, bool append_newline);
 279   ~Pieces ();
 280
 281   Pieces (const Pieces &other);
 282   Pieces &operator= (const Pieces &other);
 283
 284   Pieces (Pieces &&other);
 285
 286   const std::vector<ffi::Piece> &get_pieces () const { return pieces_vector; }
 287
 288   // {
 289   //   slice = clone_pieces (&other.slice);
 290   //   to_parse = other.to_parse;
 291
 292   //   return *this;
 293   // }
 294
 295 private:
 296   Pieces (ffi::FormatArgsHandle handle, std::vector<ffi::Piece> &&pieces_vector)
 297     : pieces_vector (std::move (pieces_vector)), handle (handle)
 298   {}
 299
 300   std::vector<ffi::Piece> pieces_vector;
 301
 302   // this memory is held for FFI reasons - it needs to be released and cloned
 303   // precisely, so try to not access it/modify it if possible. you should
 304   // instead work with `pieces_vector`
 305   ffi::FormatArgsHandle handle;
 306 };
 307
 308 } // namespace Fmt
 309 } // namespace Rust
 310
 311 #endif // !RUST_FMT_H