Add Span representation in libproc_macro cpp part of the library.
Integrate spans to existing types.
gcc/rust/ChangeLog:
* util/rust-token-converter.cc (convert): Update call to
constructors with location information.
(handle_suffix): Convert token locus to a Span and use it in the
literal.
libgrust/ChangeLog:
* libproc_macro/Makefile.am: Add span.cc
* libproc_macro/Makefile.in: Regenerate.
* libproc_macro/span.cc: New file.
* libproc_macro/span.h: New file.
* libproc_macro/group.cc (Group::make_group): Add span
argument.
* libproc_macro/group.h (GROUP_H): Add include
directive for spans.
* libproc_macro/ident.cc (Ident__new): Add span
argument.
(Ident__new_raw): Likewise.
(Ident::make_ident): Likewise.
* libproc_macro/ident.h (Ident__new): Likewise.
(Ident__new_raw): Likewise.
* libproc_macro/literal.cc (Literal::clone): Clone the
span.
(Literal::make_literal): Add span argument.
(Literal::make_u8): Likewise.
(Literal::make_u16): Likewise.
(Literal::make_u32): Likewise.
(Literal::make_u64): Likewise.
(Literal::make_i8): Likewise.
(Literal::make_i16): Likewise.
(Literal::make_i32): Likewise.
(Literal::make_i64): Likewise.
(Literal::make_string): Likewise.
(Literal::make_byte_string): Likewise.
(Literal::make_f32): Likewise.
(Literal::make_f64): Likewise.
(Literal::make_char): Likewise.
(Literal::make_usize): Likewise.
(Literal::make_isize): Likewise.
* libproc_macro/literal.h (struct Literal): Add span to
Literal structure.
* libproc_macro/punct.cc (Punct::make_punct): Add span
argument to punct constructor.
* libproc_macro/punct.h (struct Punct): Add span to
Punct structure.
Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
streams.back ().push (tt);
}
+static ProcMacro::Span
+convert (Location location)
+{
+ return ProcMacro::Span::make_unknown ();
+}
+
static void
handle_suffix (ProcMacro::TokenStream &ts, const const_TokenPtr &token,
ProcMacro::LitKind kind)
auto lookup = suffixes.lookup (token->get_type_hint ());
auto suffix = suffixes.is_iter_ok (lookup) ? lookup->second : "";
ts.push (ProcMacro::TokenTree::make_tokentree (
- ProcMacro::Literal::make_literal (kind, str, suffix)));
+ ProcMacro::Literal::make_literal (kind, convert (token->get_locus ()), str,
+ suffix)));
}
ProcMacro::TokenStream
case CHAR_LITERAL:
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
ProcMacro::Literal::make_literal (ProcMacro::LitKind::make_char (),
+ convert (token->get_locus ()),
token->as_string ())));
break;
case STRING_LITERAL:
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
ProcMacro::Literal::make_literal (ProcMacro::LitKind::make_str (),
+ convert (token->get_locus ()),
token->as_string ())));
break;
case BYTE_CHAR_LITERAL:
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
ProcMacro::Literal::make_literal (ProcMacro::LitKind::make_byte (),
+ convert (token->get_locus ()),
token->as_string ())));
break;
case BYTE_STRING_LITERAL:
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
ProcMacro::Literal::make_literal (
- ProcMacro::LitKind::make_byte_str (), token->as_string ())));
+ ProcMacro::LitKind::make_byte_str (),
+ convert (token->get_locus ()), token->as_string ())));
break;
// Ident
case IDENTIFIER:
case FALSE_LITERAL:
case TRUE_LITERAL:
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
- ProcMacro::Ident::make_ident (token->as_string ())));
+ ProcMacro::Ident::make_ident (token->as_string (),
+ convert (token->get_locus ()))));
break;
// Joint punct
case OR:
auto it = str.cbegin ();
for (; it != str.cend () - 1; it++)
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
- ProcMacro::Punct::make_punct (*it, ProcMacro::JOINT)));
+ ProcMacro::Punct::make_punct (*it,
+ convert (token->get_locus ()),
+ ProcMacro::JOINT)));
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
- ProcMacro::Punct::make_punct (*it, ProcMacro::ALONE)));
+ ProcMacro::Punct::make_punct (*it, convert (token->get_locus ()),
+ ProcMacro::ALONE)));
}
break;
// Alone punct tokens
case SINGLE_QUOTE:
trees.back ().push (ProcMacro::TokenTree::make_tokentree (
ProcMacro::Punct::make_punct (token->as_string ()[0],
+ convert (token->get_locus ()),
ProcMacro::ALONE)));
break;
case RIGHT_PAREN:
REQUIRED_OFILES = \
./proc_macro.$(objext) \
+ ./span.$(objext) \
./literal.$(objext) \
./group.$(objext) \
./ident.$(objext) \
objext = @OBJEXT@
REQUIRED_OFILES = \
./proc_macro.$(objext) \
+ ./span.$(objext) \
./literal.$(objext) \
./group.$(objext) \
./ident.$(objext) \
namespace ProcMacro {
Group
-Group::make_group (TokenStream stream, Delimiter delim)
+Group::make_group (TokenStream stream, Delimiter delim, Span span)
{
- return {delim, stream};
+ return {delim, stream, span};
}
void
#ifndef GROUP_H
#define GROUP_H
+#include "span.h"
#include "tokenstream.h"
namespace ProcMacro {
{
Delimiter delimiter;
TokenStream stream;
+ Span span;
public:
- static Group make_group (TokenStream stream, Delimiter delim);
+ static Group make_group (TokenStream stream, Delimiter delim,
+ Span span = Span::make_unknown ());
static void drop (Group *g);
};
extern "C" {
Ident
-Ident__new (unsigned char *str, std::uint64_t len)
+Ident__new (unsigned char *str, std::uint64_t len, Span span)
{
- return Ident::make_ident (str, len);
+ return Ident::make_ident (str, len, span);
}
Ident
-Ident__new_raw (unsigned char *str, std::uint64_t len)
+Ident__new_raw (unsigned char *str, std::uint64_t len, Span span)
{
- return Ident::make_ident (str, len, true);
+ return Ident::make_ident (str, len, span, true);
}
void
{
unsigned char *val = new unsigned char[this->len];
std::memcpy (val, this->val, this->len);
- return {this->is_raw, val, this->len};
+ return {this->is_raw, val, this->len, this->span};
}
Ident
-Ident::make_ident (std::string str, bool raw)
+Ident::make_ident (std::string str, Span span, bool raw)
{
return Ident::make_ident (reinterpret_cast<const unsigned char *> (
str.c_str ()),
- str.length (), raw);
+ str.length (), span, raw);
}
Ident
-Ident::make_ident (const unsigned char *str, std::uint64_t len, bool raw)
+Ident::make_ident (const unsigned char *str, std::uint64_t len, Span span,
+ bool raw)
{
unsigned char *val = new unsigned char[len];
std::memcpy (val, str, len);
- return {raw, val, len};
+ return {raw, val, len, span};
}
void
#include <cstdint>
#include <string>
+#include "span.h"
+
namespace ProcMacro {
struct Ident
unsigned char *val;
// Length in bytes
std::uint64_t len;
+ Span span;
public:
Ident clone () const;
- static Ident make_ident (std::string str, bool raw = false);
+ static Ident make_ident (std::string str, Span span, bool raw = false);
static Ident make_ident (const unsigned char *str, std::uint64_t len,
- bool raw = false);
+ Span span, bool raw = false);
static void drop (Ident *ident);
};
extern "C" {
Ident
-Ident__new (unsigned char *str, std::uint64_t len);
+Ident__new (unsigned char *str, std::uint64_t len, Span span);
Ident
-Ident__new_raw (unsigned char *str, std::uint64_t len);
+Ident__new_raw (unsigned char *str, std::uint64_t len, Span span);
void
Ident__drop (Ident *ident);
Literal
Literal::clone () const
{
- return {this->kind, this->text.clone (), this->suffix.clone ()};
+ return {this->kind, this->text.clone (), this->suffix.clone (), this->span};
}
Literal
-Literal::make_literal (LitKind kind, const std::string &text,
+Literal::make_literal (LitKind kind, Span span, const std::string &text,
const std::string &suffix)
{
auto ffi_text = FFIString::make_ffistring (text);
auto ffi_suffix = FFIString::make_ffistring (suffix);
- return {kind, ffi_text, ffi_suffix};
+ return {kind, ffi_text, ffi_suffix, span};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "u8" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "u16" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "u32" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "u64" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "i8" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "i16" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "i32" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "i64" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (str);
auto suffix = FFIString::make_ffistring ("");
- return {LitKind::make_str (), text, suffix};
+ return {LitKind::make_str (), text, suffix, Span::make_unknown ()};
}
Literal
auto text
= FFIString::make_ffistring (std::string (vec.cbegin (), vec.cend ()));
auto suffix = FFIString::make_ffistring ("");
- return {LitKind::make_byte_str (), text, suffix};
+ return {LitKind::make_byte_str (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "f32" : "");
- return {LitKind::make_float (), text, suffix};
+ return {LitKind::make_float (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "f64" : "");
- return {LitKind::make_float (), text, suffix};
+ return {LitKind::make_float (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string ((char) ch));
auto suffix = FFIString::make_ffistring ("");
- return {LitKind::make_char (), text, suffix};
+ return {LitKind::make_char (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "usize" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
Literal
{
auto text = FFIString::make_ffistring (std::to_string (value));
auto suffix = FFIString::make_ffistring (suffixed ? "isize" : "");
- return {LitKind::make_integer (), text, suffix};
+ return {LitKind::make_integer (), text, suffix, Span::make_unknown ()};
}
LitKind
#include <cstdint>
#include <string>
#include <vector>
+#include "span.h"
#include "ffistring.h"
namespace ProcMacro {
LitKind kind;
FFIString text;
FFIString suffix;
- // TODO: Add span once done in rust interface
+ Span span;
public:
Literal clone () const;
bool has_suffix () const { return suffix.len != 0; };
- static Literal make_literal (const LitKind kind, const std::string &text,
+ static Literal make_literal (const LitKind kind, Span span,
+ const std::string &text,
const std::string &suffix = "");
static Literal make_u8 (std::uint8_t value, bool suffixed = true);
static Literal make_u16 (std::uint16_t value, bool suffixed = true);
namespace ProcMacro {
Punct
-Punct::make_punct (std::uint32_t ch, Spacing spacing)
+Punct::make_punct (std::uint32_t ch, Span span, Spacing spacing)
{
- return {ch, spacing};
+ return {ch, spacing, span};
}
} // namespace ProcMacro
#define PUNCT_H
#include <cstdint>
+#include "span.h"
namespace ProcMacro {
{
std::uint32_t ch;
Spacing spacing;
+ Span span;
public:
- static Punct make_punct (std::uint32_t ch, Spacing spacing = Spacing::ALONE);
+ static Punct make_punct (std::uint32_t ch, Span span,
+ Spacing spacing = Spacing::ALONE);
};
} // namespace ProcMacro
--- /dev/null
+// Copyright (C) 2023 Free Software Foundation, Inc.
+//
+// This file is part of the GNU Proc Macro Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+#include "span.h"
+
+namespace ProcMacro {
+
+Span
+Span::make_span (std::uint32_t start, std::uint32_t end)
+{
+ return {start, end};
+}
+
+Span
+Span::make_unknown ()
+{
+ // TODO: Change this value to UNKNOWN_LOCATION from gcc/input.h
+ return {0, 0};
+}
+
+} // namespace ProcMacro
--- /dev/null
+// Copyright (C) 2023 Free Software Foundation, Inc.
+//
+// This file is part of the GNU Proc Macro Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef SPAN_H
+#define SPAN_H
+
+#include <cstdint>
+
+namespace ProcMacro {
+struct Span
+{
+ std::uint32_t start;
+ std::uint32_t end;
+
+public:
+ static Span make_span (std::uint32_t start, std::uint32_t end);
+
+ static Span make_unknown ();
+};
+} // namespace ProcMacro
+
+#endif /* SPAN_H */
projects / thirdparty / gcc.git / commitdiff
