From a5bf818ebb55e4e27eb0f067664fd4db70284267 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Fri, 8 May 2020 06:34:13 +0200
Subject: Initial support for parsing and dumping recipes

---
 libbuild2/parser.hxx | 35 ++++++++++++++++++++++++++++-------
 1 file changed, 28 insertions(+), 7 deletions(-)

(limited to 'libbuild2/parser.hxx')

diff --git a/libbuild2/parser.hxx b/libbuild2/parser.hxx
index c55e14f..5b930c5 100644
--- a/libbuild2/parser.hxx
+++ b/libbuild2/parser.hxx
@@ -26,7 +26,9 @@ namespace build2
 
     explicit
     parser (context& c, stage s = stage::rest)
-      : fail ("error", &path_), ctx (c), stage_ (s) {}
+      : fail ("error", &path_), info ("info", &path_),
+        ctx (c),
+        stage_ (s) {}
 
     // Issue diagnostics and throw failed in case of an error.
     //
@@ -109,6 +111,9 @@ namespace build2
                           const target_type* = nullptr,
                           string = string ());
 
+    void
+    parse_recipe (token&, token_type&, const token&);
+
     // Ad hoc target names inside < ... >.
     //
     struct adhoc_names_loc
@@ -246,6 +251,9 @@ namespace build2
       build2::value value;
     };
 
+    friend ostream&
+    operator<< (ostream&, const attribute&);
+
     struct attributes: small_vector<attribute, 1>
     {
       location loc; // Start location.
@@ -525,8 +533,14 @@ namespace build2
 
     // If the current token is newline, then get the next token. Otherwise,
     // fail unless the current token is eos (i.e., optional newline at the end
-    // of stream). If the after argument is not \0, use it in diagnostics as
-    // the token after which the newline was expectd.
+    // of stream). Use the after token in diagnostics as the token after which
+    // the newline was expected.
+    //
+    token_type
+    next_after_newline (token&, token_type&, const token& after);
+
+    // As above but the after argument is a single-character token. If it is
+    // \0, then it is ignored.
     //
     token_type
     next_after_newline (token&, token_type&, char after = '\0');
@@ -568,10 +582,10 @@ namespace build2
     }
 
     void
-    mode (lexer_mode m, char ps = '\0')
+    mode (lexer_mode m, char ps = '\0', uintptr_t d = 0)
     {
       if (replay_ != replay::play)
-        lexer_->mode (m, ps);
+        lexer_->mode (m, ps, nullopt, d);
       else
         // As a sanity check, make sure the mode matches the next token. Note
         // that we don't check the attributes flags or the pair separator
@@ -612,8 +626,10 @@ namespace build2
     // with the lexer directly (e.g., the keyword() test). Replays also cannot
     // nest. For now we don't enforce any of this.
     //
-    // Note also that the peeked token is not part of the replay, until it
-    // is "got".
+    // Note also that the peeked token is not part of the replay until it is
+    // "got". In particular, this means that we cannot peek past the replay
+    // sequence (since we will get the peeked token as the first token of
+    // the replay).
     //
     void
     replay_save ()
@@ -628,6 +644,8 @@ namespace build2
       assert ((replay_ == replay::save && !replay_data_.empty ()) ||
               (replay_ == replay::play && replay_i_ == replay_data_.size ()));
 
+      assert (!peeked_);
+
       if (replay_ == replay::save)
         replay_path_ = path_; // Save old path.
 
@@ -638,6 +656,8 @@ namespace build2
     void
     replay_stop ()
     {
+      assert (!peeked_);
+
       if (replay_ == replay::play)
         path_ = replay_path_; // Restore old path.
 
@@ -726,6 +746,7 @@ namespace build2
     //
   protected:
     const fail_mark fail;
+    const basic_mark info;
 
     // Parser state.
     //
-- 
cgit v1.1