Merge #983

983: Parse proper cfg values r=CohenArthur a=CohenArthur

Closes #936 

Co-authored-by: Arthur Cohen <arthur.cohen@embecosm.com>

Author: bors[bot]

gcc/rust/lex/rust-lex.cc

@@ -128,7 +128,8 @@ Lexer::Lexer (const char *filename, RAIIFile file_input, Linemap *linemap)
     token_queue (TokenSource (this))
 {
   // inform line_table that file is being entered and is in line 1
-  line_map->start_file (filename, current_line);
+  if (linemap)
+    line_map->start_file (filename, current_line);
 }
 
 Lexer::~Lexer ()
@@ -152,7 +153,11 @@ Lexer::~Lexer ()
 Location
 Lexer::get_current_location ()
 {
-  return line_map->get_location (current_column);
+  if (line_map)
+    return line_map->get_location (current_column);
+  else
+    // If we have no linemap, we're lexing something without proper locations
+    return Location ();
 }
 
 int

gcc/rust/lex/rust-lex.h

@@ -23,6 +23,7 @@
 #include "rust-buffered-queue.h"
 #include "rust-token.h"
 
+#include <cstdio>
 #include <utility>
 #include <tuple>
 
@@ -49,6 +50,13 @@ struct RAIIFile
       file = fopen (filename, "r");
   }
 
+  /**
+   * Create a RAIIFile from an existing instance of FILE*
+   */
+  RAIIFile (FILE *raw, const char *filename = nullptr)
+    : file (raw), filename (filename)
+  {}
+
   RAIIFile (const RAIIFile &other) = delete;
   RAIIFile &operator= (const RAIIFile &other) = delete;
 
@@ -57,6 +65,7 @@ struct RAIIFile
   {
     other.file = nullptr;
   }
+
   RAIIFile &operator= (RAIIFile &&other)
   {
     close ();
@@ -132,6 +141,19 @@ class Lexer
   Lexer (const char *filename, RAIIFile input, Linemap *linemap);
   ~Lexer ();
 
+  /**
+   * Lex the contents of a string instead of a file
+   */
+  static Lexer lex_string (std::string input)
+  {
+    // We can perform this ugly cast to a non-const char* since we're only
+    // *reading* the string. This would not be valid if we were doing any
+    // modification to it.
+    auto string_file = fmemopen (&input[0], input.length (), "r");
+
+    return Lexer (nullptr, RAIIFile (string_file), nullptr);
+  }
+
   // don't allow copy semantics (for now, at least)
   Lexer (const Lexer &other) = delete;
   Lexer &operator= (const Lexer &other) = delete;

gcc/rust/parse/rust-cfg-parser.cc

@@ -1,45 +1,55 @@
 #include "rust-cfg-parser.h"
+#include "rust-lex.h"
+#include "rust-parse.h"
+#include "rust-session-manager.h"
 #include "selftest.h"
 
 namespace Rust {
 bool
-parse_cfg_option (const std::string &input, std::string &key,
-		  std::string &value)
+parse_cfg_option (std::string &input, std::string &key, std::string &value)
 {
   key.clear ();
   value.clear ();
 
-  auto equal = input.find ('=');
+  auto lexer = Lexer::lex_string (input);
+  auto parser = Parser<Lexer> (std::move (lexer));
 
-  // If there is no equal sign, it means there is no value. Clean up the key
-  // and return
-  if (equal == std::string::npos)
+  auto token = parser.peek_current_token ();
+  if (token->get_id () != IDENTIFIER)
     {
-      key = input;
-
-      // FIXME: Make sure key is a proper identifier
-
-      return true;
+      return false;
     }
 
-  key = input.substr (0, equal);
-
-  auto remaining_input = input.substr (equal + 1);
-  if (remaining_input[0] != '"' || remaining_input.back () != '"')
-    return false;
-
-  // Remove the quotes around the value, by advancing one character
-  value = remaining_input.substr (1);
-  // And trimming the rightmost character. This is fine since we've already
-  // checked that both the first and last characters were quotes.
-  value.resize (value.size () - 1);
+  key = token->get_str ();
 
-  // FIXME: We need to sanitize here and make sure that both key and value
-  // are proper identifiers
+  rust_assert (parser.skip_token (IDENTIFIER));
+  token = parser.peek_current_token ();
 
-  return true;
+  switch (token->get_id ())
+    {
+    case END_OF_FILE:
+      // we're done parsing, we had a valid key, return happily
+      return true;
+    case EQUAL:
+      // We have an equal sign: Skip the token and parse an identifier
+      {
+	rust_assert (parser.skip_token (EQUAL));
+
+	auto value_expr = parser.parse_literal_expr ();
+	// We had an equal sign but no value, error out
+	if (!value_expr)
+	  return false;
+
+	if (value_expr->get_lit_type () != AST::Literal::LitType::STRING)
+	  return false;
+
+	value = value_expr->get_literal ().as_string ();
+	return true;
+      }
+    default:
+      return false;
+    }
 }
-
 } // namespace Rust
 
 #if CHECKING_P
@@ -52,23 +62,49 @@ rust_cfg_parser_test (void)
   std::string key;
   std::string value;
 
-  ASSERT_TRUE (Rust::parse_cfg_option ("key-no-value", key, value));
-  ASSERT_EQ (key, "key-no-value");
+  auto input = std::string ("key_no_value");
+
+  ASSERT_TRUE (Rust::parse_cfg_option (input, key, value));
+  ASSERT_EQ (key, "key_no_value");
   ASSERT_TRUE (value.empty ());
 
-  ASSERT_TRUE (Rust::parse_cfg_option ("k=\"v\"", key, value));
+  input = std::string ("k=\"v\"");
+
+  ASSERT_TRUE (Rust::parse_cfg_option (input, key, value));
   ASSERT_EQ (key, "k");
   ASSERT_EQ (value, "v");
 
   // values should be between double quotes
-  ASSERT_FALSE (Rust::parse_cfg_option ("k=v", key, value));
+  input = std::string ("k=v");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
 
   // No value is an error if there is an equal sign
-  ASSERT_FALSE (Rust::parse_cfg_option ("k=", key, value));
+  input = std::string ("k=");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
 
   // No key is an error
-  ASSERT_FALSE (Rust::parse_cfg_option ("=", key, value));
-  ASSERT_FALSE (Rust::parse_cfg_option ("=value", key, value));
+  input = std::string ("=");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
+
+  input = std::string ("=value");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
+
+  // values that are not string literals are an error
+  input = std::string ("key=b\"a\"");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
+
+  input = std::string ("key='v'");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
+
+  input = std::string ("key=155");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
+
+  input = std::string ("key=3.14");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
+
+  // kebab case is not valid for an identifier
+  input = std::string ("key-no-value");
+  ASSERT_FALSE (Rust::parse_cfg_option (input, key, value));
 }
 } // namespace selftest
 

gcc/rust/parse/rust-cfg-parser.h

@@ -41,8 +41,7 @@ namespace Rust {
  * @return false if the given input was invalid, true otherwise
  */
 bool
-parse_cfg_option (const std::string &input, std::string &key,
-		  std::string &value);
+parse_cfg_option (std::string &input, std::string &key, std::string &value);
 } // namespace Rust
 
 #if CHECKING_P