VerseGrammar.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
// Dependency-free allocation-free single-header Verse grammar library.
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
 
#pragma once
 
// The #if TIM are special cases for using the library outside of UE5 and for handling specification alignment issues
// that aren't ready for UE5 yet.
#define TIM 0
 
#if !TIM
#include <utility>
#include <stdint.h>
#endif
 
namespace Verse {
namespace Grammar {
 
#ifndef VERSE_MAX_EXPR_DEPTH
#define VERSE_MAX_EXPR_DEPTH 100
#endif
 
#ifndef VERSE_MAX_INDCMT_DEPTH
#define VERSE_MAX_INDCMT_DEPTH 3
#endif
 
// Macros.
#if /*NDEBUG*/false
#define GRAMMAR_ASSERT(c)    (void)(0)
#else
#define GRAMMAR_ASSERT(c)    ((c)? (void)0: Verse::Grammar::Err())
#endif
#define GRAMMAR_RUN(e)       {auto GrammarTemp=(e); if(!GrammarTemp) return GrammarTemp.GetError();}
#define GRAMMAR_SET(r,e)     {auto GrammarTemp=(e); if(!GrammarTemp) return GrammarTemp.GetError(); r=*GrammarTemp;}
#define GRAMMAR_LET(r,e)     auto r##Let=(e); if(!r##Let) return r##Let.GetError(); auto r=*r##Let;
 
// Natural numbers and characters.
using int64  = long long;
using nat8   = unsigned char;
using nat16  = unsigned short;
using nat32  = unsigned int;
using nat64  = unsigned long long;
using nat    = unsigned long long;
using char32 = char32_t;
 
#if defined(__cpp_char8_t)
    using char8 = char8_t;
#else
    // `char8_t` is natively defined since C++20 unless disabled.
    // If not available, use `char` as a replacement - while `char8_t` is supposed to be unsigned, `unsigned char` is not compatible with u8"" literals.
    // Though all greater / less than comparisons need to ensure that an unsigned 8-bit number is used.
    // [The alternative is to have all string literals wrapped in a cast (or macro of a cast) and use `unsigned char`.]
    // See:
    //   char8_t: A type for UTF-8 characters and strings (Revision 6) - https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0482r6.html
    //   char8_t backward compatibility remediation - https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1423r3.html
    using char8 = char;
#endif
 
// Basic functions.
template<class t,nat n> constexpr nat ArraySize(t(&)[n]) {return n;}
 
// Error.
[[noreturn]] inline void Err() //-V1082
{ 
#if defined(_MSC_VER)
    while(true) __debugbreak();
#else
    while(true) __builtin_trap();
#endif
}
 
// Trivial type.
struct nothing {};
 
// Precedence.
enum class prec: nat8 {Never,List,Commas,Expr,Fun,Def,Or,And,Not,Eq,NotEq,Less,Greater,Choose,To,Add,Mul,Prefix,Call,Base,Nothing};
 
// Associativity.
enum class assoc: nat8 {None,Postfix,InfixLeft,InfixRight};
 
// Block form.
enum class form: nat8 {List, Commas};
 
// Block punctuation.
enum class punctuation: nat8 {None,Braces,Parens,Brackets,AngleBrackets,Qualifier,Dot,Colon,Ind};
 
// Places specializing capture_t generation.
enum class place: nat16 {UTF8,Printable,BlockCmt,LineCmt,IndCmt,Space,String,Content};
 
// Modes for calling: none (error if instantiated), of (failure disallowed), at (failure allowed), with (macro).
enum class mode {None,Open,Closed,With};
 
// Sets a variable on construction, and restores its previous value on destruction.
template<typename t> struct scoped_guard {
    scoped_guard(t& _guard_variable, const t& new_value)
        : guard_variable(&_guard_variable)
        , old_value(_guard_variable)
    {
        *guard_variable = new_value;
    }
    ~scoped_guard()
    {
        if (guard_variable)
            *guard_variable = old_value;
    }
private:
    t* guard_variable;
    t old_value;
};
 
// Text spans passed around by the parser.
struct text {
    const char8 *Start, *Stop;
    constexpr text(): Start(nullptr), Stop(nullptr) {}
    constexpr text(const char8* Start0,const char8* Stop0): Start(Start0), Stop(Stop0) {GRAMMAR_ASSERT(Stop>=Start);}
    constexpr text(const char8* Start0): text(Start0,Start0) {while(*Stop) ++Stop;}
    #if defined(__cpp_char8_t)
    text(const char* Start0) : text(reinterpret_cast<const char8*>(Start0), (const char8*)Start0) { while (*Stop) ++Stop; }
    #endif
    constexpr char8 operator[](nat i) const {GRAMMAR_ASSERT(Start+i<Stop); return Start[i];}
    explicit operator bool() const {return Start!=Stop;}
};
constexpr nat Length(const text& Text) {
    return Text.Stop-Text.Start;
}
inline bool operator==(const text& as,const text& bs) {
    if(Length(as)!=Length(bs))
        return 0;
    for(nat i=0; i<Length(as); i++)
        if(as.Start[i]!=bs.Start[i])
            return 0;
    return 1;
}
inline bool operator!=(const text& as,const text& bs) {
    return !(as==bs);
}
 
// A snippet of text describing its location.
struct snippet {
    text Text;
    nat  StartLine,   StopLine;
    nat  StartColumn, StopColumn;
    snippet(): Text(nullptr,nullptr), StartLine(0), StopLine(0), StartColumn(0), StopColumn(0) {}
    explicit operator bool() const {
        return bool(Text);
    }
private:
    // Private to ensure all non-empty snippets are within the string passed to the parser.
    friend struct parser_base;
    snippet(const char8* Start0,const char8* End0,nat StartLine0,nat StopLine0,nat StartColumn0,nat StopColumn0):
        Text(Start0,End0), StartLine(StartLine0), StopLine(StopLine0), StartColumn(StartColumn0), StopColumn(StopColumn0) {}
};
 
// Verse blocks.
template<class syntaxes_t,class capture_t> struct block {
    block(const snippet& BlockSnippet0=snippet{},const syntaxes_t& Elements0=syntaxes_t(),form Form0=form::List):
        BlockSnippet(BlockSnippet0), Punctuation(punctuation::None), Form(Form0), Elements(Elements0) {}
    snippet     BlockSnippet;        // Snippet of the whole block.
    syntaxes_t  Specifiers;          // Specifiers.
    capture_t   TokenLeading;        // If Token, the Scan before it.
    text        Token;               // Token preceding opening punctuation.
    capture_t   PunctuationLeading;  // After token, before opening punctuation; present only if Punctuation.
    punctuation Punctuation;         // Punctuation wrapping the list.
    form        Form;                // Commas or List.
    syntaxes_t  Elements;            // Elements.
    capture_t   ElementsTrailing;    // Scan between elements and closing punctuation or end.
    capture_t   PunctuationTrailing; // If Punctuation, this holds Space & NewLine trailing it.
};
 
// Results consisting of either a value or an error.
template<class value_t,class error_t> struct result {
    template<class u,class=decltype(value_t(*(u*)nullptr))> result(const u& Value0): Value(Value0), Success(true) {}
#if !TIM
    template<class u, class = decltype(value_t(*(u*)nullptr))> result(u&& Value0) : Value(std::move(Value0)), Success(true) {}
#endif
    template<class t0=error_t,class=decltype(t0())> result(): Error(), Success(false) {}
    result(const error_t& Error0): Error(Error0), Success(false) {}
    result(const result& Other): Success(Other.Success) {
        if(Other.Success)
            new(&Value)value_t(Other.Value);
        else
            new(&Error)error_t(Other.Error);
    }
    ~result() {if(Success) {Value.~value_t();} else {Error.~error_t();}}
    operator bool() const {return Success;}
    result& operator=(const result& R) {if(this!=&R) {this->~result(); new(this)result(R);} return *this;}
    const value_t& operator*() const {GRAMMAR_ASSERT(Success); return Value;}
    value_t* operator->() {GRAMMAR_ASSERT(Success); return &Value;}
    const error_t& GetError() const {GRAMMAR_ASSERT(!Success); return Error;}
private:
    union {value_t Value; error_t Error;};
    bool  Success;
};
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Low-level character classification.
 
// Verse grammar character classification functions.
constexpr bool IsSpace   (char8 c) {return c==' ' || c=='\t';}
constexpr bool IsNewLine (char8 c) {return c==0x0D || c==0x0A;}
constexpr bool IsEnding  (char8 c) {return c==0 || c==0x0D || c==0x0A;}
constexpr bool IsAlpha   (char8 c) {return (c>='A'&&c<='Z') || (c>='a'&&c<='z') || c=='_';}  // Parentheses `()` required to make static analysis happy
constexpr bool IsDigit   (char8 c) {return c>='0' && c<='9';}
constexpr bool IsAlnum   (char8 c) {return IsAlpha(c) || IsDigit(c);}
constexpr bool IsHex     (char8 c) {return (c>='0'&&c<='9') || (c>='A'&&c<='F') || (c>='a'&&c<='f');}
constexpr nat8 DigitValue(char8 c) {return (c>='0'&&c<='9')? c-'0': (c>='A'&&c<='F')? c-'A'+10: (c>='a'&&c<='f')? c-'a'+10: 0;}
constexpr bool IsIdentifierQuotable(char8 c0,char8 c1) {return nat8(c0)>=0x20 && nat8(c0)<=0x7E && c0!='{' && c0!='}' && c0!='"' && c0!='\'' && c0!='\\' && (c0!='<'||c1!='#') && (c0!='#'||c1!='>');}
constexpr bool IsStringBackslashLiteral(char8 c0,char8 c1) {return c0=='r' || c0=='n' || c0=='t' || c0=='\\' || c0=='"' || c0=='\'' || (c0=='<'&&c1!='#') || c0=='>' || (c0=='#'&&c1!='>') || c0=='&' || c0=='~' || c0=='{' || c0=='}';}
 
// Convert valid UTF-8 sequence with valid length to its Unicode Code Point.
inline char32 EncodedChar32(const char8* s,nat Count) {
    switch(Count) {  // Extra `nat8` casts for when `char8` is signed in certain circumstances
    case 1: return char32(       nat8(s[0])                                                                                                            );
    case 2: return char32((nat32(nat8(s[0]))*0x40    + nat32(nat8(s[1])&0x3F)                                                              ) & 0x7FF   );
    case 3: return char32((nat32(nat8(s[0]))*0x1000  + nat32(nat8(s[1])&0x3F)*0x40   + nat32(nat8(s[2])&0x3F)                              ) & 0xFFFF  );
    case 4: return char32((nat32(nat8(s[0]))*0x40000 + nat32(nat8(s[1])&0x3F)*0x1000 + nat32(nat8(s[2])&0x3F)*0x40 + nat32(nat8(s[3])&0x3F)) & 0x1FFFFF);
    default: Err();
    }
}
 
// Get length of internal lexical unit recognized for Place.
// U8        := 0o80..0oBF
// UTF8      :=                                      0o00..0o7F
//           |                                       0oC2..0oDF U8
//           |  !(0oE0 0o80..0o9F | 0oED 0oA0..0oBF) 0oE0..0oEF U8 U8
//           |  !(0oF0 0o80..0o8F | 0oF4 0o90..0oBF) 0oF0..0oF4 U8 U8 U8
// Printable := 0o09 | !("<#" | "#>" | 0o0..0o1F | 0o7F | 0oC2 0o80..0o9F | 0oE2 0o80 0oA8..0oA9 ) UTF8 | ..
// Special   := '\'|'{'|'}'|'#'|'<'|'>'|'&'|'~'
// String    := .. !('\'|'{'|'}'|'"') Text ..
// Content   := .. !Special Text ..
template<place Place> nat EncodedLength(const char8* s) {
    switch(nat8(s[0])) {
    case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x06: case 0x07:
    case 0x08:            case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0E: case 0x0F: 
    case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: 
    case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
    case 0x7F:
        return Place==place::UTF8? 1: 0;
    case 0x09: case 0x20:
        return 1;
    case '"':
        return Place!=place::Space && Place!=place::String? 1: 0;
    case '<':
        return Place==place::UTF8 || (s[1]!='#' && Place!=place::Space && Place!=place::Content)? 1: 0;
    case '#':
        return Place==place::UTF8 || (s[1]!='>' && Place!=place::Space)? 1: 0;
    case '\\': case '{': case '}':
        return Place!=place::Space && Place!=place::String && Place!=place::Content? 1: 0;
    case '>': case '&': case '~':
        return Place!=place::Space && Place!=place::Content? 1: 0;
    case '!': case '$': case '%': case '\'':case '(': case ')': case '*': case '+': case ',': case '-': case '.': case '/':
    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
    case ':': case ';': case '=': case '?': case '@':
    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M':
    case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
    case '[': case ']': case '^': case '_': case '`':
    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm':
    case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
    case '|':
        return Place!=place::Space? 1: 0;
    case 0x80: case 0x81: case 0x82: case 0x83: case 0x84: case 0x85: case 0x86: case 0x87:
    case 0x88: case 0x89: case 0x8A: case 0x8B: case 0x8C: case 0x8D: case 0x8E: case 0x8F:
    case 0x90: case 0x91: case 0x92: case 0x93: case 0x94: case 0x95: case 0x96: case 0x97:
    case 0x98: case 0x99: case 0x9A: case 0x9B: case 0x9C: case 0x9D: case 0x9E: case 0x9F:
    case 0xA0: case 0xA1: case 0xA2: case 0xA3: case 0xA4: case 0xA5: case 0xA6: case 0xA7:
    case 0xA8: case 0xA9: case 0xAA: case 0xAB: case 0xAC: case 0xAD: case 0xAE: case 0xAF:
    case 0xB0: case 0xB1: case 0xB2: case 0xB3: case 0xB4: case 0xB5: case 0xB6: case 0xB7:
    case 0xB8: case 0xB9: case 0xBA: case 0xBB: case 0xBC: case 0xBD: case 0xBE: case 0xBF:
    case 0xC0: case 0xC1:
    case 0xF5: case 0xF6: case 0xF7:
    case 0xF8: case 0xF9: case 0xFA: case 0xFB: case 0xFC: case 0xFD: case 0xFE: case 0xFF:
        return 0;
    case 0xC2:
        return Place!=place::Space && nat8(s[1])>=0x80&&nat8(s[1])<=0xBF && (Place==place::UTF8 || nat8(s[1])>=0xA0)? 2: 0;
    case 0xC3: case 0xC4: case 0xC5: case 0xC6: case 0xC7:
    case 0xC8: case 0xC9: case 0xCA: case 0xCB: case 0xCC: case 0xCD: case 0xCE: case 0xCF:
    case 0xD0: case 0xD1: case 0xD2: case 0xD3: case 0xD4: case 0xD5: case 0xD6: case 0xD7: 
    case 0xD8: case 0xD9: case 0xDA: case 0xDB: case 0xDC: case 0xDD: case 0xDE: case 0xDF:
        return Place!=place::Space && nat8(s[1])>=0x80&&nat8(s[1])<=0xBF? 2: 0;
    case 0xE0:
        return Place!=place::Space && nat8(s[1])>=0xA0&&nat8(s[1])<=0xBF && nat8(s[2])>=0x80&&nat8(s[2])<=0xBF? 3: 0;
    case 0xE2:
        if constexpr(Place!=place::Space)
            if ((nat8(s[1])>=0x80)
                && (nat8(s[1])<=0xBF)
                && (nat8(s[2])>=0x80)
                && (nat8(s[2])<=0xBF)
                && ((nat8(s[1])!=0x80)
                    || ((nat8(s[2])!=0xA8)
                        && (nat8(s[2])!=0xA9))))
                return 3;
        return 0;
    case 0xE1: case 0xE3: case 0xE4: case 0xE5: case 0xE6: case 0xE7:
    case 0xE8: case 0xE9: case 0xEA: case 0xEB: case 0xEC:            case 0xEE: case 0xEF:
        return Place!=place::Space && nat8(s[1])>=0x80&&nat8(s[1])<=0xBF && nat8(s[2])>=0x80&&nat8(s[2])<=0xBF? 3: 0;
    case 0xED:
        return Place!=place::Space && nat8(s[1])>=0x80&&nat8(s[1])<=0x9F && nat8(s[2])>=0x80&&nat8(s[2])<=0xBF? 3: 0;
    case 0xF0:
        return Place!=place::Space && nat8(s[1])>=0x90&&nat8(s[1])<=0xBF && nat8(s[2])>=0x80&&nat8(s[2])<=0xBF && nat8(s[3])>=0x80&&nat8(s[3])<=0xBF? 4: 0;
    case 0xF1: case 0xF2: case 0xF3:
        return Place!=place::Space && nat8(s[1])>=0x80&&nat8(s[1])<=0xBF && nat8(s[2])>=0x80&&nat8(s[2])<=0xBF && nat8(s[3])>=0x80&&nat8(s[3])<=0xBF? 4: 0;
    case 0xF4:
        return Place!=place::Space && nat8(s[1])>=0x80&&nat8(s[1])<=0x8F && nat8(s[2])>=0x80&&nat8(s[2])<=0xBF && nat8(s[3])>=0x80&&nat8(s[3])<=0xBF? 4: 0;
    default:
        return 0;
    };
}
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Grammar output.
// This is not ready for use, but will later provide a Verse and VSON output library and pretty-printing API.
 
// Grammar output encoding.
struct encoding {
    prec Prec;
    bool AllowIn,FollowingIn;
    encoding(prec Prec0=prec::List,bool AllowIn0=false,bool FollowingIn0=false):
        Prec(Prec0), AllowIn(AllowIn0), FollowingIn(FollowingIn0) {}
    encoding Fresh(prec Prec1,bool AllowIn1=false,bool FollowingIn0=false) const {
        return encoding(Prec1,AllowIn1 || Prec1<=prec::Def,FollowingIn0);
    }
};
inline bool ParenthesizePrefix(const encoding& Encoding,prec StringPrec) {
    return StringPrec<Encoding.Prec;
}
inline bool ParenthesizePostfix(const encoding& Encoding,prec StringPrec) {
    return StringPrec<Encoding.Prec || ((Encoding.Prec==prec::Less)&&(StringPrec==prec::Greater));
}
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Token table.
 
// Forward declared tokens.
extern const struct token_set AllTokens,AllowLess,AllowNotEq;
 
// Token information.
struct token_info {
    const char8*     Symbol;
    prec             PrefixPrec;
    mode             PrefixMode;
    prec             PostfixTokenPrec;
    prec             PostfixPrec;
    assoc            PostfixAssoc;
    mode             PostfixMode;
    const token_set& PostfixAllowMask;
    encoding PostfixLeftEncoding(const encoding& Encoding,bool Parens) const {
        GRAMMAR_ASSERT(PostfixAssoc==assoc::Postfix || PostfixAssoc==assoc::InfixLeft || PostfixAssoc==assoc::InfixRight);
        bool AllowIn = Encoding.AllowIn || Encoding.Prec<=prec::Def || Parens;
        if(PostfixAssoc==assoc::Postfix || PostfixAssoc==assoc::InfixLeft)
            return Encoding.Fresh(PostfixPrec,AllowIn);
        else 
            return Encoding.Fresh(prec(nat(PostfixPrec)+1),AllowIn);
    }
    encoding PostfixRightEncoding(const encoding& Encoding,bool Parens) const {
        GRAMMAR_ASSERT(PostfixAssoc==assoc::InfixLeft || PostfixAssoc==assoc::InfixRight);
        if(PostfixAssoc==assoc::InfixRight)
            return Encoding.Fresh(PostfixPrec,false,Encoding.FollowingIn && !Parens);
        else
            return Encoding.Fresh(prec(nat(PostfixPrec)+1),false,Encoding.FollowingIn && !Parens);
    }
    prec PostfixRightPrec() const {
        GRAMMAR_ASSERT(PostfixAssoc==assoc::InfixLeft || PostfixAssoc==assoc::InfixRight);
        return PostfixAssoc==assoc::InfixRight? PostfixPrec: prec(nat(PostfixPrec)+1);
    }
};
constexpr token_info Tokens[]={
    {u8""        , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens }, // unknown
    {u8""        , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens }, // end
    {u8""        , prec::Never , mode::None   ,prec::Call   ,prec::Call   ,assoc::None      ,mode::None  , AllTokens }, // NewLine
    {u8""        , prec::Base  , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens }, // Alpha
    {u8""        , prec::Base  , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens }, // Digit
    {u8"alias"   , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"and"     , prec::Base  , mode::None   ,prec::And    ,prec::And    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"at"      , prec::Base  , mode::None   ,prec::Call   ,prec::Call   ,assoc::None      ,mode::Closed, AllTokens },
    {u8"break"   , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"catch"   , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"const"   , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"continue", prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"do"      , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"else"    , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"if"      , prec::Base  , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"in"      , prec::Def   , mode::With   ,prec::Def    ,prec::Choose ,assoc::None      ,mode::None  , AllTokens },
    {u8"is"      , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::None      ,mode::None  , AllTokens },
    {u8"live"    , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"mutable" , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"next"    , prec::Base  , mode::None   ,prec::Fun    ,prec::Fun    ,assoc::InfixRight,mode::None  , AllTokens },
    {u8"not"     , prec::Not   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"of"      , prec::Base  , mode::None   ,prec::Call   ,prec::Call   ,assoc::None      ,mode::Open  , AllTokens },
    {u8"or"      , prec::Base  , mode::None   ,prec::Or     ,prec::Or     ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"over"    , prec::Base  , mode::None   ,prec::Fun    ,prec::Fun    ,assoc::InfixLeft ,mode::With  , AllTokens },
    {u8"set"     , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"ref"     , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::With  , AllTokens },
    {u8"return"  , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"then"    , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"to"      , prec::Base  , mode::None   ,prec::To     ,prec::To     ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"until"   , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"when"    , prec::Base  , mode::None   ,prec::Fun    ,prec::Fun    ,assoc::InfixLeft ,mode::With  , AllTokens },
    {u8"where"   , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"while"   , prec::Base  , mode::None   ,prec::Fun    ,prec::Fun    ,assoc::InfixLeft ,mode::With  , AllTokens },
    {u8"with"    , prec::Never , mode::None   ,prec::Call   ,prec::Call   ,assoc::None      ,mode::None  , AllTokens },
    {u8"yield"   , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"var"     , prec::Def   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8","       , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8";"       , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"!"       , prec::Not   , mode::With   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"\""      , prec::Base  , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"&"       , prec::Def   , mode::None   ,prec::Mul    ,prec::Mul    ,assoc::InfixLeft ,mode::With  , AllTokens },
    {u8"'"       , prec::Base  , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"("       , prec::Base  , mode::None   ,prec::Call   ,prec::Call   ,assoc::None      ,mode::None  , AllTokens },
    {u8")"       , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"*"       , prec::Prefix, mode::Closed ,prec::Mul    ,prec::Mul    ,assoc::InfixLeft ,mode::Closed, AllTokens },
    {u8"*="      , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"+"       , prec::Prefix, mode::Closed ,prec::Add    ,prec::Add    ,assoc::InfixLeft ,mode::Closed, AllTokens },
    {u8"+="      , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"-"       , prec::Prefix, mode::Closed ,prec::Add    ,prec::Add    ,assoc::InfixLeft ,mode::Closed, AllTokens },
    {u8"-="      , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"->"      , prec::Never , mode::None   ,prec::To     ,prec::To     ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"."       , prec::Never , mode::None   ,prec::Call   ,prec::Call   ,assoc::InfixLeft ,mode::With  , AllTokens },
    {u8".."      , prec::Def   , mode::With   ,prec::To     ,prec::To     ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"/"       , prec::Base  , mode::None   ,prec::Mul    ,prec::Mul    ,assoc::InfixLeft ,mode::Closed, AllTokens },
    {u8"/="      , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8":"       , prec::Def   , mode::With   ,prec::Call   ,prec::Choose ,assoc::None      ,mode::None  , AllTokens },
    {u8":="      , prec::Never , mode::None   ,prec::Def    ,prec::Def    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8":)"      , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8":>"      , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"<"       , prec::Base  , mode::None   ,prec::Call   ,prec::Less   ,assoc::InfixRight,mode::Closed, AllowLess },
    {u8"<="      , prec::Never , mode::None   ,prec::Less   ,prec::Less   ,assoc::InfixRight,mode::Closed, AllowLess },
    {u8"<>"      , prec::Never , mode::None   ,prec::NotEq  ,prec::NotEq  ,assoc::InfixLeft ,mode::With  , AllowNotEq},
    {u8"="       , prec::Never , mode::None   ,prec::Eq     ,prec::Eq     ,assoc::InfixLeft ,mode::With  , AllTokens },
    {u8"=="      , prec::Never , mode::None   ,prec::Eq     ,prec::Never  ,assoc::None      ,mode::Closed, AllTokens },
    {u8"=>"      , prec::Never , mode::None   ,prec::Fun    ,prec::Fun    ,assoc::InfixRight,mode::With  , AllTokens },
    {u8">"       , prec::Never , mode::None   ,prec::Greater,prec::Greater,assoc::InfixRight,mode::Closed, AllTokens },
    {u8">="      , prec::Never , mode::None   ,prec::Greater,prec::Greater,assoc::InfixRight,mode::Closed, AllTokens },
    {u8"?"       , prec::Prefix, mode::Closed ,prec::Call   ,prec::Call   ,assoc::Postfix   ,mode::With  , AllTokens },
    {u8"@"       , prec::Expr  , mode::None   ,prec::Expr   ,prec::Expr   ,assoc::None      ,mode::None  , AllTokens },
    {u8"["       , prec::Prefix, mode::Closed ,prec::Call   ,prec::Prefix ,assoc::InfixRight,mode::Closed, AllTokens },
    {u8"]"       , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
    {u8"^"       , prec::Prefix, mode::Closed ,prec::Call   ,prec::Call   ,assoc::Postfix   ,mode::With  , AllTokens },
    {u8"{"       , prec::Never , mode::None   ,prec::Call   ,prec::Call   ,assoc::None      ,mode::None  , AllTokens },
    {u8"|"       , prec::Never , mode::None   ,prec::Choose ,prec::Choose ,assoc::InfixRight,mode::With  , AllTokens },
    {u8"}"       , prec::Never , mode::None   ,prec::Never  ,prec::Never  ,assoc::None      ,mode::None  , AllTokens },
};
 
// Tokens.
struct token {
    nat8 Index;
    explicit constexpr token(nat8 Index0): Index(Index0) {}
    constexpr token(const char8* Op): Index(nat8(ArraySize(Tokens)-1)) {
        for(; Index>=nat(token::FirstParse()); Index--)
            for(nat j=0;; j++)
                if(Tokens[Index].Symbol[j]!=char8(Op[j]))
                    break;
                else if(!Op[j])
                    return;
        Index=0;
    }
    constexpr operator nat8() const {return Index;}
    static constexpr token None()       {return token(nat8(0));}
    static constexpr token End()        {return token(1);}
    static constexpr token NewLine()    {return token(2);}
    static constexpr token Alpha()      {return token(3);}
    static constexpr token Digit()      {return token(4);}
    static constexpr token FirstParse() {return token(5);}
    explicit operator bool() const {
        return Index!=0;
    }
    constexpr const token_info* operator->() const {
        return &Tokens[Index];
    }
};
 
// A set of tokens.
struct token_set {
    constexpr token_set(): Bits{0,0} {}
    template<class... ts> explicit constexpr token_set(token T,ts... TS): token_set(TS...) {
        Bits[nat8(T)/64]|=1LL<<(nat8(T)&63);
    }
    template<class... ts> explicit constexpr token_set(const char8* S,ts... TS): token_set(token(S),TS...) {}
    constexpr bool Has(token T) const {
        return Bits[nat8(T)/64]&(1LL<<(nat8(T)&63));
    }
    constexpr explicit operator bool() const {
        return Bits[0] || Bits[1];
    }
    constexpr token_set operator&(const token_set& Other) const {
        return token_set(Bits[0]&Other.Bits[0],Bits[1]&Other.Bits[1]);
    }
    constexpr token_set operator|(const token_set& Other) const {
        return token_set(Bits[0]|Other.Bits[0],Bits[1]|Other.Bits[1]);
    }
    constexpr token_set operator~() const {
        return token_set(~Bits[0],~Bits[1]);
    }
private:
    constexpr token_set(nat64 Bits0,nat64 Bits1): Bits{Bits0,Bits1} {}
    nat64 Bits[2];
};
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Token sets.
 
inline const token_set AllTokens          = ~token_set{};
inline const token_set AllowLess          = ~token_set{u8">",u8">="};
inline const token_set AllowNotEq         = ~token_set{u8">",u8">=",u8"<",u8"<="};
inline const token_set InPrefixes         = token_set{u8":",u8"in"};
inline const token_set StopList           = token_set{u8":)",u8")",u8"]",u8"}",token::NewLine(),token::End()};
inline const token_set StopExpr           = StopList | token_set{u8";",u8","};
inline const token_set StopFun            = StopExpr | token_set{u8"@"};
inline const token_set StopDef            = StopFun  | token_set{u8"=>",u8"next",u8"over",u8"when",u8"while"};
inline const token_set BracePostfixes     = token_set{u8"{"};
inline const token_set BlockPostfixes     = token_set{u8"{",u8".",u8":"};
inline const token_set ParenPostfixes     = token_set{u8"("};
inline const token_set WithPostfixes      = token_set{u8"with",u8"<"};
inline const token_set InvokePostfixes    = BlockPostfixes | ParenPostfixes | WithPostfixes | token_set{u8"in",token::NewLine()};
inline const token_set MarkupPostfixes    = token_set{u8",",u8";",u8">",u8":>"};
inline const token_set DefPostfixes       = token_set{u8"=",u8":=",u8"+=",u8"-=",u8"*=",u8"/="};
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Parser.
 
// Generator-independent base class of parser.
struct parser_base {
private:
    template<class> friend struct parser;
 
    // A cursor tracks a parsing position in accordance with the Verse grammar,
    // and a snipping position that attributes NewLine to the Space preceding it.
    struct cursor {
        const char8* Pos;           // Pointer to current parse position.
        const char8* LineStart;     // Pointer to start of line.
        const char8* NextLineStart; // If >Pos, indicates we've snipped the NewLine at Pos.
        token        Token;         // Token here.
        nat          TokenSize;     // Length of token.
        nat          Line;          // Zero-based line number.
        char8 operator[](int64 Offset) const {
            return Pos[Offset];
        }
        bool SnippedNewLine() const {
            return NextLineStart>Pos;
        }
    };
 
    // A point for producing snippets.
    struct point {
        const char8* Pos;
        nat          Line,Column;
        point(const char8* Pos0,nat Line0,nat Column0): Pos(Pos0), Line(Line0), Column(Column0) {}
        point(const cursor& Cursor): 
            Pos   (Cursor.SnippedNewLine()? Cursor.NextLineStart: Cursor.Pos), 
            Line  (Cursor.SnippedNewLine()? Cursor.Line+1:        Cursor.Line), 
            Column(Cursor.SnippedNewLine()? 1:                    nat(Cursor.Pos-Cursor.LineStart+1)) {}
        static point Start(const snippet& Snippet) {return point{Snippet.Text.Start,Snippet.StartLine,Snippet.StartColumn};}
        static point Stop (const snippet& Snippet) {return point{Snippet.Text.Stop,Snippet.StopLine,Snippet.StopColumn};}
    };
 
    // Grammar context coinciding with "push" and "pop" in the specification.
    struct context {
        const char8* BlockInd;   // Start of the line that initiated our current indentation, or nullptr.
        const char8* TrimInd;    // BlockInd or a more indented block to specify further text trimming.
        bool         Nest;       // Whether we accept lines with equal indentation to BlockInd.
        bool         LinePrefix; // Whether subsequent ScanKey and Commas lines should be prefixed with '&'.
        context(): BlockInd{u8""}, TrimInd{u8""}, Nest(true), LinePrefix(true) {}
    };
 
    // Tokens.
    nat8 FirstToken [256              ]; // First candidate token per leading char8.
    nat8 NextToken  [ArraySize(Tokens)]; // Next candidate token per token.
    token ParseToken(const char8* Start,nat& Size) {
        if(Start[0]==0)
            return Size=0, token::End();
        for(nat8 i=FirstToken[nat8(Start[0])]; i; i=NextToken[i]) {
            if(i<token::FirstParse())
                return Size=0, token(i);
            auto Symbol = Tokens[i].Symbol;
            nat j;
            for(j=0; Symbol[j] && Start[j]==Symbol[j]; j++);
            if(Symbol[j] || (IsAlnum(Symbol[0])&&IsAlnum(Start[j])))
                continue;
            return Size=j, token(i);
        }
        return Size=0, token::None();
    }
 
    // State and constructor.
    cursor       Cursor;
    context      Context;
    nat32        ExprDepth{0};
    nat32        CommentDepth{0};
    const nat    InputLength;
    const char8* InputString;
    parser_base(nat InputLength0,const char8* InputString0,nat Line0=1):
        FirstToken{}, NextToken{},
        Cursor{InputString0,InputString0,InputString0,token::None(),0,Line0},
        InputLength(InputLength0), InputString(InputString0) {
        GRAMMAR_ASSERT(InputString[InputLength]==0);
        for(nat c=0u; c<128u; c++)
            FirstToken[c] = 
                IsNewLine(char8(c))? token::NewLine():
                IsEnding(char8(c))?  token::End():
                IsAlpha(char8(c))?   token::Alpha():
                IsDigit(char8(c))?   token::Digit():
                                     token::None();
        for(auto Token=nat8(token::FirstParse()); Token<ArraySize(Tokens); Token++) {
            auto& First=FirstToken[nat(Tokens[Token].Symbol[0])];
            if(First)
                NextToken[Token]=First;
            First=token(Token);
        }
    }
 
    // Consumption.
    void Next(nat n) {
        while(n--)
            GRAMMAR_ASSERT(Cursor[0]!=0), Cursor.Pos++;
    }
    bool Eat(const char8* s) {
        nat n;
        for(n=0; s[n]; n++)
            if(Cursor[n]!=s[n])
                return false;
        return Cursor.Pos+=n, true;
    }
    void EatToken() {
        Cursor.Pos += Cursor.TokenSize;
    }
 
    // Snippets.
    static snippet Snip(const point& Start,const point& Stop) {
        return snippet{
            Start.Pos,    Stop.Pos,
            Start.Line,   Stop.Line, 
            Start.Column, Stop.Column
        };
    }
    snippet Snip(const point& Start) const {
        return Snip(Start,Cursor);
    }
    snippet Snip() const {
        return Snip(Cursor,Cursor);
    }
    text CursorQuote() {
        static const text Quote[2]={u8"",u8"\""};
        const nat8 Cur0 = nat8(Cursor[0]);
        return Quote[Cur0>0x20 && Cur0!='"' && Cur0<0x7F];
    }
    text CursorText() {
        const nat8 Cur0 = nat8(Cursor[0]);
 
        // Quoted.
        if((Cur0=='#'&&Cursor[1]=='>') || (Cur0=='<'&&Cursor[1]=='#'))
            return text(Cursor.Pos,Cursor.Pos+2);
        if(IsAlpha(Cur0)) {
            nat n=1;
            while(IsAlnum(Cursor[n]))
                n++;
            return text(Cursor.Pos,Cursor.Pos+n);
        }
        if(Cur0>0x20 && Cur0<=0x7E)
            return text(Cursor.Pos,Cursor.Pos+1);
 
        // Not quoted.
        if(Cur0=='"')
            return u8"'\"'";
        else if(Cur0>=128 && EncodedLength<place::Printable>(Cursor.Pos))
            return u8"unicode character";
        else if(Cur0>=128)
            return u8"non-unicode character sequence";
        else if(Cur0=='\r' || Cur0=='\n')
            return u8"end of line";
        else if(Cur0=='\t')
            return u8"tab";
        else if(Cur0==' ')
            return u8"space";
        else if(Cur0==0)
            return u8"end of file";
        else
            return u8"ASCII control character";
    }
};
 
// Generator-dependent parser.
template<class gen_t> struct parser: parser_base {
private:
    using syntax_t                   = typename gen_t::syntax_t;
    using syntaxes_t                 = typename gen_t::syntaxes_t;
    using error_t                    = typename gen_t::error_t;
    using capture_t                  = typename gen_t::capture_t;
    template<class t> using result_t = result<t,error_t>;
 
    // Constructor.
    const gen_t& Gen;
    parser(const gen_t& Gen0,nat n,const char8* Source0,nat StartLine=1):
        // Accounts for null `Source0` which often occurs with empty files / etc.
        parser_base(n,Source0?Source0:u8"", StartLine), Gen(Gen0) {}
 
    // Tracking trailing captures across expressions and their postfixes so we can
    // assign them to the lexically outermost generator.
    struct trailing {
        result<cursor,nothing> TrailingStart;
        capture_t              TrailingCapture;
        explicit operator bool() const {
            return bool(TrailingStart);
        }
        void MoveFrom(trailing& Source) {
            GRAMMAR_ASSERT(!TrailingStart);
            TrailingStart        = Source.TrailingStart;
            TrailingCapture      = Source.TrailingCapture;
            Source.TrailingStart = nothing{};
        }
    };
 
    // Our extended internal block structure tracking block's trailing captures.
    struct block_t: public block<syntaxes_t,capture_t> {
        using block<syntaxes_t,capture_t>::block;
        trailing BlockTrailing;
    };
 
    // We track a stack of expressions and postfixes at increasing precedence so that we can
    // insert multi-precedence postfix operators like '<' and stop subsequent parsing there.
    // An expr is in one of three states (except mid-update when these invariants don't hold):
    // - Uninitialized: no ExprSyntax, no Trailing, not Finished. 
    // - Initialized:   has ExprSyntax, has Trailing, not Finished.
    // - Finished:      has ExprSyntax, no Trailing, is Finished.
    struct expr {
        cursor                   Start;
        prec                     FinishPrec;
        result<cursor,nothing>   Finished;
        expr*                    OuterExpr;
        token_set                AllowPostfixes;
        result<syntax_t,nothing> ExprSyntax;
        capture_t                ExprLeading;
        trailing                 Trailing; //-V730_NOINIT
        result<cursor,nothing>   MarkupStart;
        bool                     MarkupFinished, ExprStop;
        struct expr*             OuterMarkup;
        text                     MarkupTag;
        expr*                    QualIdentTarget;
        expr(prec FinishPrec0,const cursor& Start0,expr* OuterExpr0,token_set AllowPostfixes0=token_set{},expr* QualIdentTarget0=nullptr):
            Start(Start0), FinishPrec(FinishPrec0),
            OuterExpr(OuterExpr0), AllowPostfixes(AllowPostfixes0),
            MarkupFinished(false), ExprStop(false), OuterMarkup(nullptr),
            QualIdentTarget(QualIdentTarget0) {} //-V730
        syntax_t operator*() const {
            return *ExprSyntax;
        }
        // Needs a virtual destructor since it has virtual methods or various static analysis will complain
        virtual ~expr() {}
        virtual result_t<nothing> OnFinish(parser& /*Parser*/) {
            GRAMMAR_ASSERT(!Finished);
            GRAMMAR_ASSERT(!OuterExpr || !OuterExpr->Finished);
            GRAMMAR_ASSERT(Trailing);
            Finished = *Trailing.TrailingStart;
            return nothing{};
        }
    };
 
    // Token management.
    void UpdateToken() {
        Cursor.Token=ParseToken(Cursor.Pos,Cursor.TokenSize);
        if(IsAlpha(Cursor.Token->Symbol[0])) {
            // Key := !Alnum Space !":="
            // When a reserved word is followed by a definition symbol, we demote it to an identifier
            // so that simple object notation supports all identifiers including reserved words.
            cursor    KeyStart     = Cursor;
            EatToken();
            auto      SpaceResult  = Space();
            auto      IsIdentifier = Cursor.Token==token(u8":=");
            Cursor                 = KeyStart;//backtrack but could cache
            if(SpaceResult && IsIdentifier)
                Cursor.Token=token::Alpha();
        }
    }
    bool CheckToken() {
        auto SavedToken=Cursor.Token;
        UpdateToken();
        return Cursor.Token==SavedToken;
    }
 
    // Errors.
    result_t<nothing> Require(const char8* Value,error_t(parser::*OnError)(text What)) {
        if(!Eat(Value))
            return (this->*OnError)(Value);
        return nothing{};
    }
    result_t<nothing> RequireClose(cursor Start,const char8* Open,const char8* Close,error_t(parser::*OnError)(text)) {
        if(Eat(Close))
            return nothing{};
        else if(!Ending())
            return (this->*OnError)(Close);
        else
            return Cursor=Start, S80(Open);
    }
 
    // Snippets.
    snippet SnipFinished(const cursor& Start,const expr& End) {
        return Snip(Start,*End.Finished);
    }
    snippet SnipFinished(const cursor& Start,const block_t& End) {
        return Snip(Start,*End.BlockTrailing.TrailingStart);
    }
 
    // Trailing capture and snippet management.
    result_t<nothing> SpaceTrailing(trailing& Trailing) {
        GRAMMAR_ASSERT(!Trailing);
        Trailing.TrailingStart=Cursor;
        GRAMMAR_RUN(Space(Trailing.TrailingCapture));
        return nothing{};
    }
    result_t<nothing> UpdateFrom(expr& Target,trailing& Source,const result_t<syntax_t>& SyntaxResult) {
        GRAMMAR_ASSERT(Source);
        GRAMMAR_ASSERT(!Target.Finished && !Target.Trailing);
        Target.Trailing.MoveFrom(Source);
        GRAMMAR_SET(Target.ExprSyntax,SyntaxResult);
        return nothing{};
    }
    result_t<nothing> UpdateSpaceTrailing(expr& Target,const result_t<syntax_t>& SyntaxResult) {
        GRAMMAR_ASSERT(!Target.Finished);
        GRAMMAR_ASSERT(!Target.Trailing);
        GRAMMAR_SET(Target.ExprSyntax,SyntaxResult);
        GRAMMAR_RUN(SpaceTrailing(Target.Trailing));
        return nothing{};
    }
    syntax_t ApplyTrailing(expr& Target,bool FinishingNow=false) {
        GRAMMAR_ASSERT(!Target.Finished || FinishingNow);
        GRAMMAR_ASSERT(Target.Trailing);
        Target.ExprSyntax = Gen.Trailing(*Target,Target.Trailing.TrailingCapture);
        Target.Trailing   = trailing{};
        return *Target;
    }
    void ApplyTrailing(block_t& Block0,const point& TrailingEnd) {
        if(Block0.Punctuation!=punctuation::None)
            Gen.CaptureAppend(Block0.PunctuationTrailing,Block0.BlockTrailing.TrailingCapture);
        else
            Gen.CaptureAppend(Block0.ElementsTrailing,Block0.BlockTrailing.TrailingCapture);
        Block0.BlockSnippet  = Snip(point::Start(Block0.BlockSnippet),TrailingEnd);
        Block0.BlockTrailing = trailing{};
    }
 
    // Character set and comment and errors:
    auto S01() {return Gen.Err(Snip(),"S01","Source must be ASCII or Unicode UTF-8 format");}
    auto S02() {return Gen.Err(Snip(),"S02","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," in block comment");}
    auto S03() {return Gen.Err(Snip(),"S03","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," in line comment");}
    auto S04() {return Gen.Err(Snip(),"S04","Block comment beginning at \"<#\" never ends");}
    auto S05() {return Gen.Err(Snip(),"S05","Ending \"#>\" is outside of block comment");}
    auto S06() {return Gen.Err(Snip(),"S06","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," in indented comment");}
 
    // Numeric and numbered character constant errors.
    auto S15() {return Gen.Err(Snip(),"S15","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," following number.");}
    auto S16() {return Gen.Err(Snip(),"S15","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," following character.");}
    auto S18() {return Gen.Err(Snip(),"S18","Character code unit octet must be 1-2 digits in the range 0o0 to 0oFF");}
    auto S19() {return Gen.Err(Snip(),"S19","Unicode code point must be 1-6 digits in the range 0u0 to 0u10FFFF");}
 
    // Identifier errors.
    auto S20(text What) {return Gen.Err(Snip(),"S20","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing identifier following \"",What,"\"");}
    auto S23(text What) {return Gen.Err(Snip(),"S23","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing \"",What,"\" in qualifier");}
    auto S24(text What) {return Gen.Err(Snip(),"S24","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing \"",What,"\" in quoted identifier");}
    auto S25(text What) {return Gen.Err(Snip(),"S25","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing \"",What,"\" in path literal");}
    auto S26(text What) {return Gen.Err(Snip(),"S26","Missing label in path following \"",What,"\"");}
 
    // Text errors.
    auto S30()          {return Gen.Err(Snip(),"S30","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," in character literal");}
    auto S31(text)      {return Gen.Err(Snip(),"S31","Missing \"'\" in character literal");}
    auto S32(text)      {return Gen.Err(Snip(),"S32","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing end quote in string literal");}
    auto S34()          {return Gen.Err(Snip(),"S34","Bad character escape \"\\\" followed by ",CursorQuote(),CursorText(),CursorQuote());}
 
    // Markup errors.
    auto S40()                 {return Gen.Err(Snip(),"S40","Missing markup tag preceding ",CursorQuote(),CursorText(),CursorQuote());}
    auto S41()                 {return Gen.Err(Snip(),"S41","Bad markup expression preceding ",CursorQuote(),CursorText(),CursorQuote());}
    auto S42()                 {return Gen.Err(Snip(),"S42","Unexpected markup end tag outside of markup");}
    auto S43(text Tag,text Id) {return Gen.Err(Snip(),"S43","Markup started with \"<",Tag,">\" tag but ended in mismatched \"</",Id,">\" tag");}
    auto S44(text What)        {return Gen.Err(Snip(),"S44","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing \"",What,"\" in markup end tag");}
    auto S46()                 {return Gen.Err(Snip(),"S46","Expected indented markup following \":>\" but got ",CursorQuote(),CursorText(),CursorQuote());}
 
    // Markup content errors.
    auto S51(text What) {return Gen.Err(Snip(),"S51","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing \"",What,"\" in markup");}
    auto S52(text)      {return Gen.Err(Snip(),"S52","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing markup end tag");}
    auto S54()          {return Gen.Err(Snip(),"S54","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," in indented markup");}
    auto S57()          {return Gen.Err(Snip(),"S57","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," or missing ending \";\" or newline following \"&\" markup escape expression");}
    auto S58()          {return Gen.Err(Snip(),"S58","Markup list separator \"~\" is only allowed in markup beginning with \"~\"; elsewhere escape it using \"\\~\"");}
 
    // Precedence errors.
    auto S60(text What,text Op) {return Gen.Err(Snip(),"S60","Precedence doesn't allow \"",Op,"\" following \"",What,"\"");}
    auto S61(text Op)           {return Gen.Err(Snip(),"S61","Precedence doesn't allow \"",Op,"\" here");}
    auto S62()                  {return Gen.Err(Snip(),"S62","Verse uses 'and', 'or', 'not' instead of '&&', '||', '!'.");};
    auto S64(text,text Op)      {return Gen.Err(Snip(),"S64","Precedence doesn't allow \"",Op,"\" in markup tag expression");}
    auto S65()                  {return Gen.Err(Snip(),"S65","Use a=b for comparison, not a==b");}
    auto S66(text Op)           {return Gen.Err(Snip(),"S66","Use 'set' before \"",Op,"\" to update variables");}
    auto S67()                  {return Gen.Err(Snip(),"S67","Prefix attribute must be followed by identifier declaration");}
    auto S68()                  {return Gen.Err(Snip(),"S68","Use # for line comment, not //");}
    
    // Bad or missing expression, block, keyword errors.
    auto S70(text)      {return Gen.Err(Snip(),"S70","Expected expression, got ",CursorQuote(),CursorText(),CursorQuote()," at top level of program");}
    auto S71(text What) {return Gen.Err(Snip(),"S71","Expected expression, got ",CursorQuote(),CursorText(),CursorQuote()," following \"",What,"\"");}
    auto S74(text)      {return Gen.Err(Snip(),"S74","Expected markup tag expression, got ",CursorQuote(),CursorText(),CursorQuote());}
    auto S76(text What) {return Gen.Err(Snip(),"S76","Expected block, got ",CursorQuote(),CursorText(),CursorQuote()," following \"",What,"\"");}
    auto S77()          {return Gen.Err(Snip(),"S77","Unexpected ",CursorQuote(),CursorText(),CursorQuote()," following expression");}
    auto S78()          {return Gen.Err(Snip(),"S78","Expected <specifier> following \"with\"");}
    auto S79()          {return Gen.Err(Snip(),"S79","Unexpected ",CursorQuote(),CursorText(),CursorQuote(),"or missing \">\" following specifier");}
 
    // Expression grouping errors:
    auto S80(text What) {return Gen.Err(Snip(),"S80","Block starting in \"",What,"\" never ends");}
    auto S81(text What) {return Gen.Err(Snip(),"S81","Expected expression or \"",What,"\", got ",CursorQuote(),CursorText(),CursorQuote()," in parenthesis");}
    auto S82(text What) {return Gen.Err(Snip(),"S82","Expected expression or \"",What,"\", got ",CursorQuote(),CursorText(),CursorQuote()," in parenthesized parameter list");}
    auto S83(text What) {return Gen.Err(Snip(),"S83","Expected expression or \"",What,"\", got ",CursorQuote(),CursorText(),CursorQuote()," in bracketed parameters");}
    auto S84(text What) {return Gen.Err(Snip(),"S84","Expected expression or \"",What,"\", got ",CursorQuote(),CursorText(),CursorQuote()," in braced block");}
    auto S85(text What) {return Gen.Err(Snip(),"S85","Expected \"",What,"\", got ",CursorQuote(),CursorText(),CursorQuote()," in prefix brackets");}
    auto S86(text What) {return Gen.Err(Snip(),"S86","Expected expression or \"",What,"\", got ",CursorQuote(),CursorText(),CursorQuote()," in string interpolation");}
    auto S88(text)      {return Gen.Err(Snip(),"S88","Expected expression, got ",CursorQuote(),CursorText(),CursorQuote()," in indented block");}
    auto S88void()      {return Gen.Err(Snip(),"S88","Expected expression, got ",CursorQuote(),CursorText(),CursorQuote()," in indented block");}
    auto S89()          {return Gen.Err(Snip(),"S89","Indentation mismatch: expected ",Context.BlockInd[point(Cursor).Column]==' '? "space": "tab",", got ",CursorQuote(),CursorText(),CursorQuote());}
 
    // Parser limitations versus spec.
    auto S97()          {return Gen.Err(Snip(),"S97","Unexpected error");}
    auto S98()          {return Gen.Err(Snip(),"S98","Feature is not currently supported");}
    auto S99()          {return Gen.Err(Snip(),"S99","Exceeded maximum expression depth"); }
 
    // Blank space and indentation.
    void SnipNewLine(capture_t& Capture,place Place=place::Space) {
        // If a NewLine is ahead, incorporate it in Capture despite not consuming it per grammar spec.
        if(!Cursor.SnippedNewLine() && (Cursor[0]==0x0D || Cursor[0]==0x0A)) {
            auto Start           = Cursor;
            Cursor.NextLineStart = Cursor.Pos+1+(Cursor[0]==0x0D && Cursor[1]==0x0A);
            Gen.NewLine(Capture,Snip(Start),Place);
        }
    }
    bool NewLine(capture_t& Capture,place Place=place::Space) {
        // NewLine := 0o0D [0o0A] | 0o0A
        SnipNewLine(Capture,Place);
        if(Cursor.SnippedNewLine()) {
            Cursor.Pos       = Cursor.NextLineStart;
            Cursor.LineStart = Cursor.Pos;
            Cursor.Line++;
            return true;
        }
        return false;
    }
    bool Ending() {
        // Ending := &(NewLine | end)
        return Cursor.SnippedNewLine() || IsEnding(Cursor[0]);
    }
    result_t<nothing> Space(capture_t& Capture,place Place=place::Space,bool DoSnipNewLine=true) {
        // Space := {0o09 | 0o20 | Comment}
        GRAMMAR_RUN(Text<place::Space>(Capture,Place));
        if(DoSnipNewLine)
            SnipNewLine(Capture,Place);
        return UpdateToken(), nothing{};
    }
    result_t<capture_t> Space(place Place=place::Space) {
        capture_t Capture;
        GRAMMAR_RUN(Space(Capture,Place));
        return Capture;
    }
    result_t<context> Ind() {
        // Ind := Ending push; set Nest=false; set BlockInd=LineInd; set LinePrefix=""
        GRAMMAR_ASSERT(Ending());
        auto SavedContext   = Context;
        Context.BlockInd    = Cursor.LineStart;
        Context.TrimInd     = Cursor.LineStart;
        Context.Nest        = false;
        return SavedContext;
    }
    result_t<nothing> Ded(const context& SavedContext,error_t(parser::*OnError)()) {
        // Ded := Ending pop
        Context = SavedContext;
        if(!Ending())
            return (this->*OnError)();
        return UpdateToken(), nothing{};
    }
    result_t<bool> Line(capture_t& Capture,place Place) {
        // Line := NewLine; parse i:={0o09|0o20}; (Ending | !(0o09|0o20) Space
        //         if     (i>BlockInd | Nest and i=BlockInd) then set LineInd=ThisInd
        //         else if(not i<=BlockInd                 ) then error)
        auto SavedLineEnd = Cursor;
        if(!NewLine(Capture,Place))
            return false;
        auto SavedLineStart = Cursor;
        while(IsSpace(Cursor[0]) && Cursor[0]==Context.BlockInd[Cursor.Pos-SavedLineStart.Pos])
            Next(1);
        bool HasMoreSpace = IsSpace(Cursor[0]);
        if((HasMoreSpace || Context.Nest) && !IsSpace(Context.BlockInd[Cursor.Pos-SavedLineStart.Pos])) {
            // This line falls into current indented block, so consume any additional optional TrimIn
            // and note via Gen.Indent followed by potentially Place-significant Space.
            while(IsSpace(Cursor[0]) && Cursor[0]==Context.TrimInd[Cursor.Pos-SavedLineStart.Pos])
                Next(1);
            Gen.Indent(Capture,Snip(SavedLineStart),Place);
            GRAMMAR_RUN(Space(Capture,Place));
            return true;
        }
        else if(Ending()) {
            // Blank line whose indentation isn't related to leading.
            return Gen.BlankLine(Capture,Snip(SavedLineStart),Place), true;
        }
        else if(HasMoreSpace) {
            // Inconsistently indented nonblank line, so error at inconsistency.
            return S89();
        }
        else {
#if TIM
            return Cursor=SavedLineEnd, false; // Backtrack but could cache.
#else
            // NOTE: (yiliang.siew) For indented indcmts, such as:
            /*
             *
             * ```
             * a<#>
             *  b<#>
             * c<#>
             *  d<#>
             * <#>
             *  e<#>
             * ```
             *
             * And so on, the parser will end up treating the entirety of the contents after `a<#>` as an indcmt,
             * and recursively do so for the contents after `b<#>` and so on. This can lead to really slow parsing/stack overflow
             * should a malicious actor craft Verse syntax to take advantage of this.
             * We therefore only capture indented comments up to a certain point and give up; it's highly unlikely anyone would need
             * that amount of indentation in their comments.
             */
            const uint32_t NewCommentDepth = Place == place::IndCmt || Place == place::BlockCmt ? CommentDepth + 1 : CommentDepth;
            scoped_guard CommentDepthGuard(CommentDepth, NewCommentDepth);
            if (CommentDepth > VERSE_MAX_INDCMT_DEPTH) {
                return Cursor=SavedLineEnd, false; //backtrack but could cache
            }
            
            // Line that only contains whitespace or comments, but less indented than the current block.
            // If we have reached this point, it means that we might be at the start of a comment on the next line, but
            // the comment might not have any indentation at all.
            capture_t SpaceCapture = {};
            GRAMMAR_RUN(Space(SpaceCapture,Place));
            if(Cursor.SnippedNewLine()) {
                // We need to keep eating until we hit a token that is non-whitespace/comment and has different indentation. If so, backtrack.
                // If no backtracking, return `true` and append the capture here.
                // If this `Scan` fails to extend the current block because there is already a non-whitespace/comment token there,
                // it will already have backtracked to the previous line. But the capture would still be empty since `Scan` would
                // return a `nothing{}` value.
                capture_t ScanCapture = {};
                if (Scan(ScanCapture,Place) && Gen.CaptureLength(ScanCapture) == 0) {
                    // NOTE: (yiliang.siew) Backtrack here so that the comment can be associated with the correct capture.
                    return Cursor=SavedLineEnd, false;
                }
                else {
                    Gen.CaptureAppend(Capture, SpaceCapture);
                    return true;
                }
            }
            else {
                // Consistent nonblank line from an earlier indented block.
                return Cursor=SavedLineEnd, false;//backtrack but could cache
            }
#endif
        }
    }
    result_t<nothing> Scan(capture_t& Capture,place Place=place::Space) {
        // Scan := Space {Line}
        GRAMMAR_RUN(Space(Capture,Place,false));
        for(;;) {
            capture_t LineCapture;
            GRAMMAR_LET(GotLine,Line(LineCapture,Place));
            if(!GotLine)
                return UpdateToken(), nothing{};
 
            // In place::Content, trim trailing [NewLine Space &('~' | '</')].
            if(Place==place::Content && (Cursor[0]=='~' || (Cursor[0]=='<'&&Cursor[1]=='/')))
                Gen.MarkupTrim(LineCapture);
            Gen.CaptureAppend(Capture,LineCapture);
        }
    }
    result_t<token> ScanKey(capture_t& Capture,token_set TokenSet) {
        // This function implements the grammar for Brace and ScanKey [Token1 | Token2 | ..] &Key.
        // Brace   := Scan '{' List '}' Space
        // ScanKey := Space (&NewLine Scan LinePrefix Space | !NewLine)
        // Key     := !Alnum Space !":="
        auto ScanStart = Cursor;
        GRAMMAR_LET(More,Space());
        bool Multiline = Ending();
        GRAMMAR_RUN(Scan(More));
        if(Context.LinePrefix && Multiline && Cursor.Token!=token(u8"{")) {
            auto LinePrefixStart=Cursor;
            if(Eat(u8"&")) {
                Gen.LinePrefix(More,Snip(LinePrefixStart));
                GRAMMAR_RUN(Space(More));
                if(TokenSet.Has(Cursor.Token))
                    return Gen.CaptureAppend(Capture,More), Cursor.Token;
            }
        }
        else if(TokenSet.Has(Cursor.Token))
            return Gen.CaptureAppend(Capture,More), Cursor.Token;
        return Cursor=ScanStart, token::None(); //backtrack but could cache
    }
 
    // Constants and base expressions.
    result_t<nat> ParseHex(nat MaxDigits,nat MaxValue,error_t(parser::*OnError)()) {
        nat i=0;
        while(IsHex(Cursor[0])) {
            if(MaxDigits-->0) {
                auto i0=i;
                i=i*16+DigitValue(Cursor[0]);
                if(i<=MaxValue && i/16==i0) {
                    Next(1);
                    continue;
                }
            }
            return (this->*OnError)();
        }
        return i;
    }
    result_t<nothing> DisallowDotAlnum() {
        bool GotDot=Cursor[0]=='.';
        if(IsAlnum(Cursor[GotDot]))
            return S15();
        return nothing{};
    }
    result_t<nothing> DisallowDotNum() {
        bool GotDot=Cursor[0]=='.';
        if(IsDigit(Cursor[GotDot]))
            return S15();
        return nothing{};
    }
    result_t<syntax_t> Num() {
        // Exp    := [('e'|'E') ['+'|'-'] Digits] !(('e'|'E') ('+'|'-'|Digit))
        // Units  := [Alpha {Alpha}] !Alpha
        // Num    := !(("0b"|"0o"|"0u"|"0x") Hex) Digits ['.' Digits] Exp Units) !('.' Digits)
        //        |  ("0x" Hex {Hex} !('.' Alnum)
        auto Start=Cursor;
        GRAMMAR_ASSERT(IsDigit(Cursor[0]));
        if(Cursor[0]=='0' && Cursor[1]=='x' && IsHex(Cursor[2])) {
            GRAMMAR_ASSERT(Cursor[0]=='0'&&Cursor[1]=='x'&&IsHex(Cursor[2]));
            Next(2);
            do {Next(1);} while(IsHex(Cursor[0]));
            // Could use `DisallowDotNum()` which would then permit extension function on hex literals - `0xff.ShiftRight()`
            // Can still wrap hex literals with parentheses - `(0xff).ShiftRight()`
            GRAMMAR_RUN(DisallowDotAlnum());
            return Gen.NumHex(Snip(Start),text(Start.Pos+2,Cursor.Pos));
        }
        while(IsDigit(Cursor[0]))
            Next(1);
        text Digits(Start.Pos,Cursor.Pos),FractionalDigits(Cursor.Pos+1,Cursor.Pos+1);
        if(Cursor[0]=='.' && IsDigit(Cursor[1])) {
            Next(2);
            while(IsDigit(Cursor[0]))
                Next(1);
            FractionalDigits.Stop=Cursor.Pos;
        }
        text ExponentSign,Exponent;
        if(Cursor[0]=='e' || Cursor[0]=='E') {
            int64 HasExponentSign = int64(Cursor[1]=='+' || Cursor[1]=='-');
            if(IsDigit(Cursor[1+HasExponentSign])) {
                ExponentSign=text(Cursor.Pos+1,Cursor.Pos+1+HasExponentSign);
                Next(1+HasExponentSign);
                Exponent.Start=Cursor.Pos;
                while(IsDigit(Cursor[0]))
                    Next(1);
                Exponent.Stop=Cursor.Pos;
            }
        }
        GRAMMAR_LET(Result,Gen.Num(Snip(Start),Digits,FractionalDigits,ExponentSign,Exponent));
        if(IsAlpha(Cursor[0])) {
            auto Pos0=Cursor.Pos;
            do Next(1);
            while(IsAlnum(Cursor[0]));
            GRAMMAR_SET(Result,Gen.Units(Snip(Start),Result,text(Pos0,Cursor.Pos)));
        }
        // Disallow extra dot digit and allow dot alpha so extension functions ['.' Ident] can be called on number literals
        GRAMMAR_RUN(DisallowDotNum());
        return Result;
    }
    result_t<syntax_t> CharLit() {
        // Special := '\'|'{'|'}'|'#'|'<'|'>'|'&'|'~'
        // CharEsc := '\' ('r'|'n'|'t'|'''|'"'|Special)
        // CharLit := ''' Printable ''' !''' | ''' CharEsc '''
        GRAMMAR_ASSERT(Cursor[0]=='\'');
        auto Start=Cursor;
        Next(1);
        nat n=EncodedLength<place::Printable>(Cursor.Pos);
        if(!n)
            return S30();
        auto Char32    = EncodedChar32(Cursor.Pos,n);
        auto Backslash = Cursor[0]=='\\' && Cursor[1] && Cursor[2]=='\'';
        if(Backslash) {
            Next(1);
            if(IsStringBackslashLiteral(Cursor[0],Cursor[1])) {
                Char32=char32(Cursor[0]=='r'? '\r': Cursor[0]=='n'? '\n': Cursor[0]=='t'? '\t': Cursor[0]);
                Backslash=1;
                Next(n);
            }
            else return S34();
        }
        else Next(n);
        GRAMMAR_RUN(Require(u8"'",&parser::S31));
        return Gen.Char32(Snip(Start),Char32,false,Backslash);
    }
    result_t<char8> Char8() {
        // Char8 := "0o" (Hex) [Hex] !Alnum
        GRAMMAR_ASSERT(Cursor[0]=='0'&&Cursor[1]=='o'&&IsHex(Cursor[2]));
        Next(2);
        GRAMMAR_LET(n,ParseHex(2,0xFFULL,&parser::S18));
        if(IsAlnum(Cursor[0]))
            return S16();
        return char8(n);
    }
    result_t<char32> Char32() {
        // Char32 := "0u" ("10" | Hex) [Hex] [Hex] [Hex] [Hex]) !Alnum
        GRAMMAR_ASSERT(Cursor[0]=='0'&&Cursor[1]=='u'&&IsHex(Cursor[2]));
        Next(2);
        GRAMMAR_LET(n,ParseHex(6,0x10FFFFULL,&parser::S19));
        if(IsAlnum(Cursor[0]))
            return S16();
        return char32(n);
    }
    result_t<text> Ident() {
        // Ident := Alpha {Alnum} !Alnum ["'" {!('<#'|'#>'|'\'|'{'|'}'|'"'|''') 0o20-0o7E} "'"]
        GRAMMAR_ASSERT(IsAlpha(Cursor[0]));
        auto Pos0=Cursor.Pos;
        do Next(1);
        while(IsAlnum(Cursor[0]));
        if(!Eat(u8"'"))
            return text(Pos0,Cursor.Pos);
        // Ensure not reading past string and determine if quotable
        while((Cursor[0] != '\0') && IsIdentifierQuotable(Cursor[0], Cursor[1]))
            Next(1);
        GRAMMAR_RUN(Require(u8"'",&parser::S24));
        return text(Pos0,Cursor.Pos);
    }
    result_t<text> Path() {
        // Path := '/' Label ('@' Label | !'@')] {'/' ['(' Path ':)'] Ident} !'/'
        auto Start=Cursor;
        GRAMMAR_RUN(Require(u8"/",&parser::S25));
        if(Cursor[0]=='/' || (Cursor[0]==' ' && Cursor.Pos>InputString && Cursor[-1]=='/'))
            return S68();
        GRAMMAR_RUN(Label(u8"/"));
        if(Eat(u8"@"))
            GRAMMAR_RUN(Label(u8"@"));
        while(Eat(u8"/")) {
            text What=u8"/";
            if(Eat(u8"(")) {
                GRAMMAR_RUN(Path());
                GRAMMAR_RUN(Require(u8":)",&parser::S25));
                What=u8":)";
            }
            if(IsAlpha(Cursor[0])) {
                GRAMMAR_RUN(Ident());
                continue;
            }
            return S20(What);
        }
        if(Cursor[0]!='/')
            return text(Start.Pos,Cursor.Pos);
        return S25(u8"/");
    }
    result_t<text> Label(text What) {
        // Label := Alnum {Alnum|'-'|'.'} !(Alnum|'-'|'.')
        auto Pos0=Cursor.Pos;
        if(IsAlnum(Cursor[0])) {
            Next(1);
            while(IsAlnum(Cursor[0]) || Cursor[0]=='-' || Cursor[0]=='.')
                Next(1);
            return text(Pos0,Cursor.Pos);
        }
        return S26(What);
    }
 
    // Text processing.
    result_t<capture_t> LineCmt() {
        // LineCmt := '#' !'>' {Text} Ending
        GRAMMAR_ASSERT(Cursor[0]=='#');
        Next(1);
        capture_t Capture;
        GRAMMAR_RUN(Text<place::LineCmt>(Capture));
        if(Ending())
            return Capture;
        else
            return S03();
    }
    result_t<capture_t> BlockCmt() {
        // BlockCmt := "<#" !'>' {Text|NewLine} !'<' "#>"
        GRAMMAR_ASSERT(Cursor[0]=='<'&&Cursor[1]=='#'&&Cursor[2]!='>');
        auto Start=Cursor;
        Next(2);
        capture_t Capture;
        GRAMMAR_RUN(Text<place::BlockCmt>(Capture));
        if(Cursor[0]=='#' && Cursor[1]=='>')
            return Next(2), Capture;
        else if(Cursor[0]==0)
            return Cursor=Start, S04();
        else
            return S02();
    }
    result_t<capture_t> IndCmt() {
        // IndCmt := "<#>" {Text} Ind {Text|Line} Ded
        GRAMMAR_ASSERT(Cursor[0]=='<'&&Cursor[1]=='#'&&Cursor[2]=='>');
        Next(3);
        capture_t Capture;
        GRAMMAR_RUN(Text<place::LineCmt>(Capture));
        if(Ending()) {
            GRAMMAR_LET(SavedContext,Ind());
            GRAMMAR_RUN(Text<place::IndCmt>(Capture));
            GRAMMAR_RUN(Ded(SavedContext,&parser::S06));
            // NOTE: (yiliang.siew) We don't want to snip a newline here, because that means that an indcmt like:
            /*
             * <#>indcmt
             *     indcmt_frag
             * stub{}
             * 
             */
            // Ends up getting an extra newline snipped as part of its comment string capture, which wouldn't make sense
            // since indcmts must always have a newline after anyway.
            // GRAMMAR_RUN(Space(Capture,place::IndCmt));
            return Capture;
        }
        else return S06();
    }
    template<place ParsePlace> result_t<nothing> Text(capture_t& Capture,place GenPlace=ParsePlace) {
        // Text      := Printable | BlockCmt | "<#>"
        // LineCmt   := '#' !'>' {Text} Ending
        // BlockCmt  := "<#" !'>' {Text|NewLine} !'<' "#>"
        // IndCmt    := "<#>" {Text} Ind {Text|Line} Ded
        // Space     := {0o09 | 0o20 | Comment}
        // String    := '"' {..                  | CharEsc |      !('\'|'{'|'}'|'"') Text} '"'
        // Content   :=     {.. | Comment | Line | CharEsc | .. | !Special           Text}
        // CharEsc   := '\' ('r'|'n'|'t'|'''|'"'|Special)
        for(;;) {
            auto Start=Cursor;
            for(nat n; (n=EncodedLength<ParsePlace>(Cursor.Pos))!=0;)
                Next(n);
            if(Cursor.Pos!=Start.Pos)
                Gen.Text(Capture,Snip(Start),GenPlace);
            auto SpecialStart=Cursor;
            switch(Cursor[0]) {
            case '\r': case '\n':
                if constexpr(ParsePlace==place::Content || ParsePlace==place::IndCmt) {
                    GRAMMAR_RUN(Scan(Capture,GenPlace));
                    if(Ending())
                        return nothing{};
                    continue;
                }
                else if constexpr(ParsePlace==place::BlockCmt) {
                    NewLine(Capture,GenPlace);
                    continue;
                }
                else return nothing{};
            case '#':
                if(Cursor[1]!='>') {
                    GRAMMAR_LET(Commentary,LineCmt());
                    Gen.LineCmt(Capture,Snip(SpecialStart),GenPlace,Commentary);
                    continue;
                }
                else if constexpr(ParsePlace==place::BlockCmt)
                    return nothing{};
                else
                    return S05();
            case '<':
                if(Cursor[1]!='#') {
                    return nothing{};
                }
                else if(Cursor[2]!='>') {
                    GRAMMAR_LET(Commentary,BlockCmt());
                    Gen.BlockCmt(Capture,Snip(SpecialStart),GenPlace,Commentary);
                    continue;
                }
                else if constexpr(ParsePlace==place::Space || ParsePlace==place::Content || ParsePlace==place::IndCmt) {
                    GRAMMAR_LET(Commentary,IndCmt());
                    Gen.IndCmt(Capture,Snip(SpecialStart),GenPlace,Commentary);
                    continue;
                }
                else {
                    Next(3);
                    Gen.Text(Capture,Snip(SpecialStart),GenPlace);
                    continue;
                }
            case '\\':
                // Parse a constant escape.
                // Special  := '\'|'{'|'}'|'#'|'<'|'>'|'&'|'~'
                // CharEsc  := '\' ('r'|'n'|'t'|'''|'"'|Special)
                if constexpr(ParsePlace==place::String || ParsePlace==place::Content) {
                    Next(1);
                    if(Cursor[0] && IsStringBackslashLiteral(Cursor[0],Cursor[1])) {
                        auto Backslashed = Cursor[0];
                        Next(1);
                        Gen.StringBackslash(Capture,Snip(SpecialStart),GenPlace,Backslashed);
                        continue;
                    }
                    else return S34();
                }
            default:
                return nothing{};
            }
        }
    }
    result_t<block_t> Interp() {
        // Interp := '{' List '}'
        GRAMMAR_ASSERT(Cursor[0]=='{');
        auto Start=Cursor;
        Next(1);
        GRAMMAR_LET(Block0,List(u8"}",&parser::S86,Cursor,capture_t(),punctuation::None,Cursor));
        GRAMMAR_RUN(RequireClose(Start,u8"{",u8"}",&parser::S86));
        return Block0;
    }
    result_t<block_t> Ampersand() {
        // Ampersand := push; parse LinePrefix='&'; Space Def (';'|Ending); pop
        GRAMMAR_ASSERT(Cursor[0]=='&');
        Next(1);
        auto ExprStart          = Cursor;
        GRAMMAR_LET(Leading,Space());
        auto SavedContext       = Context;
        Context.LinePrefix      = true;
        GRAMMAR_LET(Block0,WhenExpr(u8"&",prec::Def,prec::Def,nullptr,Leading,[&](expr& Expr)->result_t<block_t> {
            ApplyTrailing(Expr,true);
            auto SemicolonStart = Cursor;
            bool Semicolon      = Eat(u8";");
            auto Block0         = SingletonBlock(ExprStart,Expr);
            if(!Ending() && !Semicolon)
                return S57();
            if(Semicolon)
                Gen.Semicolon(Block0.ElementsTrailing,Snip(SemicolonStart));
            ApplyTrailing(Block0,Cursor);
            return Block0;
        },AllTokens));
        Context                 = SavedContext;
        return Block0;
    }
    template<place Place> result_t<syntaxes_t> String(cursor TextStart,capture_t Leading=capture_t()) {
        // String  := '"' {Interp | CharEsc | !('\'|'{'|'}'|'"') Text} '"'
        // Content :=     {Interp | CharEsc | Markup | Ampersand | Comment | Line | !Special Text}
        syntaxes_t Splices;
        for(;;) {
            GRAMMAR_RUN(Text<Place>(Leading));
            if(Cursor.Pos!=TextStart.Pos) {
                GRAMMAR_LET(S,Gen.StringLiteral(Snip(TextStart),Leading));
                Gen.SyntaxesAppend(Splices,S);
            }
            auto SpecialStart=Cursor;
            switch(Cursor[0]) {
            case '{': {
                GRAMMAR_LET(Block0,Interp());
                GRAMMAR_LET(S,Gen.StringInterpolate(Snip(SpecialStart),Place,1,Block0));
                Gen.SyntaxesAppend(Splices,S);
                break;
            }
            case '&': {
                GRAMMAR_LET(Block0,Ampersand());
                GRAMMAR_LET(S,Gen.StringInterpolate(Snip(SpecialStart),Place,0,Block0));
                Gen.SyntaxesAppend(Splices,S);
                break;
            }
            case '<':
                // Markup := '<' Tags ..
                // Tags   := Space (!'/' ..) ..
                if(Cursor[1]!='/') {
                    GRAMMAR_LET(e,Markup());
                    Gen.SyntaxesAppend(Splices,e);
                    break;
                }
                [[fallthrough]];
            default:
                return Splices;
            }
            TextStart=Cursor;
            Leading=capture_t();
        }
    }
 
    // Markup content.
    result_t<syntax_t> Contents(bool TrimLeading) {
        // Contents := Scan (Content | '~' Content {'~' Content})
        auto Start=Cursor;
        GRAMMAR_LET(Leading,Space(place::Content)); // If TrimLeading, trim leading [Space NewLine].
        if(TrimLeading && Ending())
            Gen.MarkupTrim(Leading);
        GRAMMAR_RUN(Scan(Leading,place::Content));
        if(Cursor[0]!='~') {
            GRAMMAR_LET(Splices,String<place::Content>(Start,Leading));
            if(Cursor[0]=='~')
                return S58();
            return Gen.Content(Snip(Start),Splices);
        }
        else {
            Next(1);
            Gen.MarkupTrim(Leading); // Trim everything before ~.
            syntaxes_t Results;
            do {
                auto ElementStart=Cursor;
                GRAMMAR_LET(Splices,String<place::Content>(Cursor));
                GRAMMAR_LET(S,Gen.Content(Snip(ElementStart),Splices));
                Gen.SyntaxesAppend(Results,S);
            }
            while(Eat(u8"~"));
            return Gen.Contents(Snip(Start),Leading,Results);
        }
    }
    result_t<syntax_t> Trimmed(bool TrimLeading) {
        // We push and set TrimInd to LineInd so markup can precisely trim according to LineStart.
        auto SavedContext = Context;
        Context.TrimInd   = Cursor.LineStart;
        Context.Nest      = true;
        GRAMMAR_LET(Result,Contents(TrimLeading));
        Context           = SavedContext;
        return Result;
    }
 
    // Blocks.
    block_t SingletonBlock(const snippet& Snippet,const syntax_t& Syntax,const capture_t& PunctuationLeading=capture_t(),punctuation Punctuation=punctuation::None) {
        block_t Block0(Snippet);
        Block0.PunctuationLeading  = PunctuationLeading;
        Block0.Punctuation         = Punctuation;
        Gen.SyntaxesAppend(Block0.Elements,Syntax);
        return Block0;
    }
    block_t SingletonBlock(const cursor& BlockStart,expr& Expr,const capture_t& PunctuationLeading=capture_t(),punctuation Punctuation=punctuation::None) {
        auto Block0=SingletonBlock(SnipFinished(BlockStart,Expr),*Expr,PunctuationLeading,Punctuation);
        Block0.BlockTrailing.MoveFrom(Expr.Trailing);
        return Block0;
    }
    result_t<block_t> IndList(cursor Start,const capture_t& PunctuationLeading,punctuation Punctuation,cursor LeadingStart,const capture_t& Leading=capture_t()) {
        // Ind List Ded
        GRAMMAR_LET(SavedContext,Ind());
        GRAMMAR_LET(Block0,List(u8"",&parser::S88,Start,PunctuationLeading,Punctuation,LeadingStart,Leading));
        GRAMMAR_RUN(Ded(SavedContext,&parser::S88void));
        GRAMMAR_RUN(SpaceTrailing(Block0.BlockTrailing));
        return Block0;
    }
    result_t<block_t> BlockHelper(text What,prec Prec,expr& OuterExpr,cursor BlockStart,capture_t PunctuationLeading,
        bool AllowOpen,bool AllowInd,bool AllowCommas,bool* Fails=nullptr) {
        // Brace     := Scan '{' List '}' Space
        // Block     := Brace | DotSpace Space Def Space | (DotSpace | ':') Space Ind List Ded
        // BraceInd  := Brace | Ind List Ded
        // DotSpace  := '.' (0o09 | 0o20 | Ending) Space
        switch(nat8(Cursor.Token)) {
        case token::NewLine(): case token::End(): {
            GRAMMAR_LET(ScanToken,ScanKey(PunctuationLeading,BracePostfixes));
            if(!ScanToken) {
                if(AllowInd)
                    return IndList(BlockStart,PunctuationLeading,punctuation::Ind,Cursor);
                goto bad;
            }
            [[fallthrough]];
        }
        case token(u8"{"): {
            auto BraceStart=Cursor;
            EatToken();
            GRAMMAR_LET(Block0,List(u8"}",&parser::S84,Cursor,PunctuationLeading,punctuation::Braces,Cursor));
            GRAMMAR_RUN(RequireClose(BraceStart,u8"{",u8"}",&parser::S84));
            Block0.BlockSnippet=Snip(BlockStart);
            GRAMMAR_RUN(SpaceTrailing(Block0.BlockTrailing));
            return Block0;
        }
        case token(u8"."): {
            if(AllowOpen && (IsSpace(Cursor[1]) /*|| IsEnding(Cursor[1])*/)) {
                EatToken();
                //auto MiddleStart=Cursor;
                GRAMMAR_LET(Middle,Space());
                /*if(Ending())
                    return IndList(BlockStart,PunctuationLeading,punctuation::Dot,MiddleStart,Middle);*/
                return WhenExpr(What,prec::Def,prec::Def,&OuterExpr,Middle,[&](expr& Right)->result_t<block_t> {
                    return SingletonBlock(BlockStart,Right,PunctuationLeading,punctuation::Dot);
                });
            }
            goto bad;
        }
        case token(u8":"): {
            if(AllowOpen) {
                auto ColonStart=Cursor;
                EatToken();
                auto MiddleStart=Cursor;
                GRAMMAR_LET(Middle,Space());
                if(Ending())
                    return IndList(BlockStart,PunctuationLeading,punctuation::Colon,MiddleStart,Middle);
                Cursor=ColonStart; //backtrack colon and space, then fall through.
            }
            [[fallthrough]];
        }
        default:
            if(Prec!=prec::Nothing) {
                if(AllowCommas)
                    return Commas(What,Prec,BlockStart,PunctuationLeading,&parser::S71);
                else
                    return WhenExpr(What,Prec,Prec,&OuterExpr,PunctuationLeading,[&](expr& Right)->result_t<block_t> {
                        return SingletonBlock(BlockStart,Right);
                    });
            }
        bad:
            if(!Fails)
                return S71(What);
            else
                return *Fails=true, block_t{};
        }
    }
    result_t<block_t> Block(text What,expr& OuterExpr,cursor BlockStart,const capture_t& PunctuationLeading,bool& Fails) {
        // Block := Brace | DotSpace Space Def Space | (DotSpace | ':') Space Ind List Ded
        return BlockHelper(What,prec::Nothing,OuterExpr,BlockStart,PunctuationLeading,true,false,false,&Fails);
    }
    result_t<block_t> BraceInd(text What,prec Prec,expr& OuterExpr) {
        // BraceInd := Brace | Ind List Ded
        auto BlockStart=Cursor;
        GRAMMAR_LET(PunctuationLeading,Space());
        return BlockHelper(What,Prec,OuterExpr,BlockStart,PunctuationLeading,false,true,false);
    }
    result_t<block_t> KeyBlock(prec Prec,expr& OuterExpr,cursor BlockStart,const capture_t& TokenLeading,text Token,const capture_t& PunctuationLeading) {
        // KeyBlock := Block
        GRAMMAR_LET(Block0,BlockHelper(Token,Prec,OuterExpr,BlockStart,PunctuationLeading,true,false,false));
        Block0.Token        = Token;
        Block0.TokenLeading = TokenLeading;
        return Block0;
    }
    result_t<block_t> KeyBlockDefs(expr& OuterExpr,cursor BlockStart,const capture_t& TokenLeading,text Token) {
        // Defs := Def {Space ',' Scan Def}
        GRAMMAR_LET(PunctuationLeading,Space());
        GRAMMAR_LET(Block0,BlockHelper(Token,prec::Def,OuterExpr,BlockStart,PunctuationLeading,true,false,true));
        Block0.Token        = Token;
        Block0.TokenLeading = TokenLeading;
        return Block0;
    }
    template<class f> result_t<nothing> WhenBraceCall(const char8* What,prec Prec,expr& OuterExpr,const f& F) {
        // Brace  := Scan '{' List '}' Space
        // Prefix := Call | .. Space (Brace | Prefix)
        // Takes a callback because things like +a<b preemptively invoke OnFinish.
        auto BlockStart=Cursor;
        GRAMMAR_LET(PunctuationLeading,Space());
        if(Cursor.Token==token(u8"{") || Cursor.Token==token::NewLine()) {
            GRAMMAR_LET(RightBlock,BlockHelper(What,Prec,OuterExpr,BlockStart,PunctuationLeading,false,false,false));
            return F(RightBlock);
        }
        else return WhenExpr(What,Prec,Prec,&OuterExpr,PunctuationLeading,[&](expr& RightExpr)->result_t<nothing> {
            auto RightBlock=SingletonBlock(BlockStart,RightExpr);
            return F(RightBlock);
        });
    }
 
    // Qualified identifiers.
    result_t<syntax_t> QualIdentQualified(expr& Target,const cursor& Start,block_t& Block0) {
        GRAMMAR_RUN(Space(Block0.PunctuationTrailing));
        Block0.BlockSnippet = Snip(Start);
        Block0.Punctuation  = punctuation::Qualifier;
        if(IsAlpha(Cursor[0])) {
            GRAMMAR_LET(Id,Ident());
            Target.MarkupTag=Id;
            return Gen.QualIdent(Snip(Start),Block0,Id);
        }
        else return S23(u8":)");
    }
    result_t<syntax_t> QualIdent(text What,expr& Target,bool AllowParenthesis) {
        // QualIdent := ['(' List ':)' Space] Ident
        auto Start=Cursor;
        if(IsAlpha(Cursor[0])) {
            GRAMMAR_LET(Id,Ident());
            Target.MarkupTag=Id;
            return Gen.Ident(Snip(Start),Id,u8"",u8"");
        }
        else if(Cursor[0]=='(') {
            EatToken();
            GRAMMAR_LET(Block0,List(u8")",&parser::S81,Cursor,capture_t(),punctuation::Parens,Cursor));
            if(Eat(u8":)"))
                return QualIdentQualified(Target,Start,Block0);
            else if(AllowParenthesis) {
                GRAMMAR_RUN(RequireClose(Start,u8"(",u8")",&parser::S81));
                Block0.BlockSnippet = Snip(Start);
                return Gen.Parenthesis(Block0);
            }
            else return S23(u8":)");
        }
        return S20(What);
    }
 
    // Macro invocations and constructs that lead with same syntax like '(', '<', 'with'.
    struct call {
        text      CallWhat;
        cursor    CallTrailingStop;
        mode      CallMode;
        block_t&  CallParameter;
        call*     OuterCall = nullptr;  // Initialized to keep static analysis happy
    };
    struct invoke: expr {
        text            What;
        token           StartToken;
        token_set       InTokens, PostTokens;
        call            *FirstCall, *LastCall;
        call*           Of;
        block_t*        Clauses[3];
        block_t*        PriorClause;
        invoke(text What0,expr& OuterExpr0,cursor Start0,token StartToken0,token_set InTokens0,token_set PostTokens0,call* FirstCall0=nullptr,call* LastCall0=nullptr):
            expr(prec::Base,Start0,&OuterExpr0,OuterExpr0.MarkupStart? InvokePostfixes|MarkupPostfixes: InvokePostfixes),
            What(What0), StartToken(StartToken0),
            InTokens(InTokens0), PostTokens(PostTokens0),
            FirstCall(FirstCall0), LastCall(LastCall0),
            Of(nullptr), Clauses{nullptr,nullptr,nullptr}, PriorClause(nullptr) {}
        void UpdateLastCall(call* NewCall) {
            if(LastCall)
                LastCall->OuterCall = NewCall;
            else
                FirstCall           = NewCall;
            LastCall                = NewCall;
        }
        result_t<nothing> OnFinish(parser& Parser) override {
            Parser.CheckToken();
            this->Trailing = trailing{
                LastCall
                    ? *LastCall->CallParameter.BlockTrailing.TrailingStart
                    : PriorClause
                        ? *PriorClause->BlockTrailing.TrailingStart:
                        Parser.Cursor,
                capture_t()};
            GRAMMAR_RUN(expr::OnFinish(Parser));
            if(Clauses[0]) {
                GRAMMAR_ASSERT(PriorClause);
                // Generate this macro invocation.
                GRAMMAR_RUN(Parser.UpdateFrom(*this->OuterExpr,PriorClause->BlockTrailing,Parser.Gen.Invoke(
                    Parser.SnipFinished(this->Start,*PriorClause),
                    Parser.ApplyTrailing(*this->OuterExpr),
                    *Clauses[0],Clauses[1],Clauses[2])));
 
                // Handle remaining calls on the stack now with another Invoke.
                if(!FirstCall) // Disable this to check soundness of logic below.
                    return nothing{};
                invoke NewTarget{u8"nested macro invocation",*this->OuterExpr,this->Start,token::None(),
                    token_set{u8"do"},token_set{u8"until",u8"catch"},FirstCall,LastCall};
                if(!this->ExprStop)
                    return Parser.Invoke(NewTarget,Parser.Cursor,capture_t());
                else
                    return NewTarget.OnFinish(Parser);
            }
            else if(!StartToken) {
                // Not a macro, and a macro isn't required, so flush accumulated call and specifiers
                // to the nearest outer prec::Call, needed for if{a}else if{b}<c> associating as (if{a}else if{b})<c>.
                if (!this->OuterExpr) { return nothing{}; }  // This should never occur - though without it some C++ semantic analysis checkers get upset when passing to FinishExpr() below.
                GRAMMAR_LET(InsertCall,Parser.FinishExpr(token::None(),prec::Call,*this->OuterExpr));
                if(!InsertCall)
                    return Parser.S61(FirstCall? FirstCall->CallWhat: u8"macro end");
                for(auto Call=FirstCall; Call; Call=Call->OuterCall) {
                    Call->CallParameter.BlockSnippet=Snip(point::Start(Call->CallParameter.BlockSnippet),*Call->CallParameter.BlockTrailing.TrailingStart);
                    GRAMMAR_RUN(Parser.UpdateFrom(*InsertCall,Call->CallParameter.BlockTrailing,Parser.Gen.Call(
                        Snip(InsertCall->Start,point::Stop(Call->CallParameter.BlockSnippet)),Call->CallMode,
                        Parser.ApplyTrailing(*InsertCall),Call->CallParameter)));
                }
                return nothing{};
            }
            else return Parser.S76(What); // Error for reserved word not followed by macro.
        }
    };
    result_t<nothing> InvokeClause(invoke& Target,nat WhichClause,cursor BlockStart,block_t& Block0,cursor NextBlockStart,const capture_t& NextTokenLeading=capture_t()) {
        // We've committed to producing a macro invocation, so accumulate specifiers m<a> and handle any prior m(a).catch up to clauses from call m(c).
        auto           Specifiers     = syntaxes_t{};
        const snippet* FirstSpecifier = nullptr;
        while(auto Call=Target.FirstCall) {
            Target.FirstCall=Target.FirstCall->OuterCall;
            ApplyTrailing(Call->CallParameter,Call->CallTrailingStop);
            if(Call->CallMode==mode::Open) {
                GRAMMAR_ASSERT(!Target.Clauses[0] && !Target.Clauses[1] && !Target.Clauses[2]);
                if(FirstSpecifier)
                    Call->CallParameter.BlockSnippet = Snip(point::Start(*FirstSpecifier),point::Stop(Call->CallParameter.BlockSnippet));
                Call->CallParameter.Specifiers       = Specifiers;
                Target.Clauses[0]                    = &Call->CallParameter;
                Target.Of                            = nullptr;
                return InvokeClause(Target,WhichClause,BlockStart,Block0,NextBlockStart,NextTokenLeading);
            }
            else if(Call->CallMode==mode::With) {
                if(!Gen.SyntaxesLength(Specifiers))
                    FirstSpecifier = &Call->CallParameter.BlockSnippet;
                GRAMMAR_LET(E,Gen.Parenthesis(Call->CallParameter));
                Gen.SyntaxesAppend(Specifiers,E);
            }
            else Err();
        }
        if(Target.PriorClause)
            ApplyTrailing(*Target.PriorClause,FirstSpecifier? point::Start(*FirstSpecifier): BlockStart);
        if(FirstSpecifier)
            Block0.BlockSnippet     = Snip(point::Start(*FirstSpecifier),point::Stop(Block0.BlockSnippet));
        Block0.Specifiers           = Specifiers;
        Target.LastCall             = nullptr; // Catch up so subsequent accumulation works.
        Target.Clauses[WhichClause] = &Block0;
        Target.PriorClause          = Block0.BlockSnippet? &Block0: Target.PriorClause;
        if(!Target.ExprStop)
            return Invoke(Target,NextBlockStart,NextTokenLeading);
        else
            return Target.OnFinish(*this);
    };
    result_t<nothing> Invoke(invoke& Target,cursor BlockStart,capture_t TokenLeading=capture_t()) {
        // Markup  := '<' Scan Tags Scan ":>" Space Ind Contents Ded 
        //         |  '<' Scan Tags Scan ';'  Scan      Contents '>'
        //         |  '<' Scan Tags Scan '>'  Scan      Contents '</' Ident Space {'/' Ident Space} '>'
        // Tags    := Space (!'/' Call ScanKey '.' | !Reserved) QualIdent Space {Invoke} [',' Scan Tags]
        // Postfix := .. | !Invoke (Paren | Specs) | ..
        // Invoke  :=          [Specs] (Paren [Specs] (Block | Do  ) | Block [[Specs] Do  ]) (Until | !Until)
        // If      := "if" Key [Specs] (Paren         (Block | Then) | Block [        Then]) (Else  | !Else )
        GRAMMAR_ASSERT(CheckToken());
        auto PostfixStart = Cursor;
        auto PostfixToken = PostfixStart.Token;
        if(!Target.AllowPostfixes.Has(PostfixToken))
            return Target.OnFinish(*this);
 
        // Definitely starting a new potential clause.
        switch(nat8(PostfixToken)) {
        case token(u8"("): {
            // Paren := '(' List ')' Space
            EatToken();
            GRAMMAR_LET(Block0,List(u8")",&parser::S82,Cursor,capture_t(),punctuation::Parens,Cursor));
            if(Eat(u8":)")) {
                // If we're in an attribute like @a (b:)c, move the QualIdent to the Base handler for '@'.
                GRAMMAR_LET(InsertExpr,FinishExpr(token::None(),prec::Prefix,Target));
                if(!InsertExpr || !InsertExpr->QualIdentTarget)
                    return parser::S82(u8":)");
                InsertExpr->QualIdentTarget->Start=PostfixStart;
                GRAMMAR_LET(Id,QualIdentQualified(*InsertExpr,PostfixStart,Block0));
                GRAMMAR_RUN(UpdateSpaceTrailing(*InsertExpr->QualIdentTarget,Id));
                return nothing{};
            }
            GRAMMAR_RUN(RequireClose(PostfixStart,u8"(",u8")",&parser::S82));
            Block0.BlockSnippet      = Snip(BlockStart);
            auto NewCall             = call{u8"(",Cursor,mode::Open,Block0};
            GRAMMAR_RUN(SpaceTrailing(NewCall.CallParameter.BlockTrailing));
            NewCall.CallTrailingStop = Cursor;
            Target.UpdateLastCall(&NewCall);
            Target.Of                = &NewCall;
            Target.AllowPostfixes    = (Target.AllowPostfixes & ~ParenPostfixes) | Target.InTokens;
            if(Target.StartToken==token(u8"if")) // Disallow if(a)<b>{c} to enable future if(a) b.
                Target.AllowPostfixes = Target.AllowPostfixes & ~WithPostfixes;
            return Invoke(Target,Cursor);
        }
        case token(u8"<"): case token(u8"with"): {
            // Specs := [ScanKey "with" Key] '<' Scan Choose Space '>' Space (Specs | !Specs)
            text CallToken;
            capture_t PunctuationLeading;
            if(PostfixToken==token(u8"with")) {
                EatToken();
                CallToken=u8"with";
                GRAMMAR_RUN(Space(PunctuationLeading));
                if(Cursor.Token!=token(u8"<"))
                    return S78();
            }
            EatToken();
            GRAMMAR_LET(Leading,Space());
            // We parse specifier at prec::Choose, but FinishExpr at prec::Less to right-associate nested '<'.
            // LessExpr receives TrailingCapture so specifiers can handle it and less-than can propagate it.
            // If we parsed a<b<c at just prec::Choose, the inner FinishExpr forces the finishes prec::Choose,
            // whose FinishExpr forces the outer prec::Choose, so the outer Postfix incorrectly parses first.
            // This is as simple as it can be; other approaches add bloat.
            bool GotLess    = false;
            auto LessExpr   = when_expr(prec::Less,&Target,AllowLess,Cursor,Leading,[&](expr& LessExpr)->result_t<nothing> {
                // We get here only if we parse a Less expression a<b, not if we parse a specifier.
                GRAMMAR_ASSERT(GotLess);
                auto& InsertExpr = *LessExpr.OuterExpr; // Dynamic, not necessarily Target.
                return UpdateFrom(InsertExpr,LessExpr.Trailing,Gen.InfixToken(
                    SnipFinished(InsertExpr.Start,LessExpr),PostfixToken->PostfixMode,
                    ApplyTrailing(InsertExpr),PostfixToken->Symbol,*LessExpr
                ));
            });
            return WhenExpr(u8"<",prec::Choose,prec::Less,&LessExpr,capture_t(),[&](expr& RightExpr)->result_t<nothing> {
                GRAMMAR_RUN(UpdateFrom(LessExpr,RightExpr.Trailing,*RightExpr));
                if(Eat(u8">")) {
                    // Parsed a specifier. Abandon LessExpr.
                    auto RightSyntax            = Gen.Leading(Leading,ApplyTrailing(LessExpr));
                    auto SpecifierBlock         = SingletonBlock(Snip(BlockStart,Cursor),RightSyntax,PunctuationLeading,punctuation::AngleBrackets);
                    SpecifierBlock.Token        = CallToken;
                    SpecifierBlock.TokenLeading = TokenLeading;
                    auto NewCall                = call{u8"<",Cursor,mode::With,SpecifierBlock};
                    GRAMMAR_RUN(SpaceTrailing(NewCall.CallParameter.BlockTrailing));
                    NewCall.CallTrailingStop    = Cursor;
                    Target.UpdateLastCall(&NewCall);
                    return Invoke(Target,Cursor);
                }
                else if(PostfixToken!=token(u8"with")) {
                    // We parsed a Less expression a<b so figure out where it lands and finish parsing it.
                    GotLess=true;
                    GRAMMAR_SET(LessExpr.OuterExpr,FinishExpr(token(u8"<"),prec::Less,Target));
                    if(!LessExpr.OuterExpr)
                        return S61(u8"<");
                    return Postfix(u8"<",prec::Less,LessExpr); // Trigger's LessExpr's when_expr.
                }
                else return S79();
            });
        }
        case token(u8"{"): case token(u8"."): case token(u8":"): case token(u8"in"): {
            // Block := Brace | DotSpace Space Def Space | (DotSpace | ':') Space Ind List Ded
            bool Fails=false;
            GRAMMAR_LET(Block0,Block(u8"macro invocation",Target,BlockStart,TokenLeading,Fails));
            if(!Fails) {
                Target.AllowPostfixes = (Target.AllowPostfixes & ~ParenPostfixes & ~BlockPostfixes) | Target.InTokens | Target.PostTokens;
                if(Target.Of)
                    Target.AllowPostfixes = Target.AllowPostfixes & ~Target.InTokens;
                if(Target.StartToken==token(u8"if")) // Disallow if{a}<b>.. so else-if never finishes before last InvokedClause.
                    Target.AllowPostfixes = Target.AllowPostfixes & ~WithPostfixes;
                return InvokeClause(Target,Target.Of!=0,BlockStart,Block0,Cursor);
            }
            return Target.OnFinish(*this); // For In, '.' QualIdent.
        }
        case token(u8"do"): case token(u8"then"): {
            // Do   := ScanKey "do"    Key (KeyBlock | Def)
            // Then := ScanKey "then"  Key (KeyBlock | Def)
            EatToken();
            GRAMMAR_LET(PunctuationLeading,Space());
            GRAMMAR_LET(Block0,KeyBlock(prec::Def,Target,BlockStart,TokenLeading,PostfixToken->Symbol,PunctuationLeading));
            Target.AllowPostfixes = (Target.AllowPostfixes & ~Target.InTokens) | Target.PostTokens;
            return InvokeClause(Target,1,BlockStart,Block0,Cursor);
        }
        case token(u8"until"): {
            // Until := ScanKey "until" Key (KeyBlock | Def) | ..
            EatToken();
            GRAMMAR_LET(PunctuationLeading,Space());
            GRAMMAR_LET(Block0,KeyBlock(prec::Def,Target,BlockStart,TokenLeading,PostfixToken->Symbol,PunctuationLeading));
            Target.AllowPostfixes = token_set{};
            return InvokeClause(Target,2,BlockStart,Block0,Cursor);
        }
        case token(u8"catch"): {
            // Until := .. | ScanKey "catch" Key Invoke
            // Chain more catches only if !Target.FirstCall. Update AllowTokens to reenable catch.
            EatToken();
            auto CatchExpr = when_expr(prec::Base,&Target,AllTokens,BlockStart,TokenLeading,[&](expr& CatchExpr)->result_t<nothing> {
                auto Block0=SingletonBlock(BlockStart,CatchExpr);
                return InvokeClause(Target,2,BlockStart,Block0,*CatchExpr.Finished);
            });
            GRAMMAR_RUN(UpdateSpaceTrailing(CatchExpr,Gen.Native(Snip(BlockStart),u8"catch")));
            invoke CatchTarget{u8"catch",CatchExpr,BlockStart,token(u8"catch"),token_set{u8"do"},token_set{u8"until",u8"catch"}};
            GRAMMAR_RUN(Invoke(CatchTarget,Cursor));
            if(!CatchExpr.Finished)
                CatchExpr.OnFinish(*this);
            return nothing();
        }
        case token(u8"else"): {
            // Else := ScanKey "else" Key (ScanKey If | !(ScanKey If) (KeyBlock | Def))
            EatToken();
            GRAMMAR_LET(PunctuationLeading,Space());
            Target.AllowPostfixes = token_set{};
            if(Cursor.Token==token(u8"if")) {
                // Grammar makes "else if" a special case so "if(a){b}else if(c){d}+1"
                // is equivalent to "(if(a){b}else if(c){d})+1", not "if(a){b}else (if(c){d}+1)".
                return WhenExpr(u8"else if",prec::Base,prec::Base,&Target,PunctuationLeading,[&](expr& ElseExpr)->result_t<nothing> {
                    Target.ExprStop         = ElseExpr.ExprStop;
                    auto ElseBlock          = SingletonBlock(BlockStart,ElseExpr);
                    ElseBlock.Token         = PostfixToken->Symbol;
                    ElseBlock.TokenLeading  = TokenLeading;
                    return InvokeClause(Target,2,BlockStart,ElseBlock,Cursor);
                });
            }
            else {
                GRAMMAR_LET(ElseBlock,KeyBlock(prec::Def,Target,BlockStart,TokenLeading,PostfixToken->Symbol,PunctuationLeading));
                return InvokeClause(Target,2,BlockStart,ElseBlock,Cursor);
            }
        }
        case token(u8","): case token(u8";"): case token(u8">"): case token(u8":>"): {
            if(!Target.Clauses[0] || Target.FirstCall) {
                // If we have <m;c>, <m(a);c>, <m<a>;c>, <m{a}<b>;c>, introduce a new block and recurse back.
                block_t Block0{Snip()};
                return InvokeClause(Target,Target.FirstCall!=nullptr,BlockStart,Block0,BlockStart,TokenLeading);
            }
            EatToken();
            if(!Target.OuterExpr->MarkupTag)
                return S40();
            if(Target.PriorClause)
                ApplyTrailing(*Target.PriorClause,BlockStart); // TODO: Fix, as this is bad for <m(a)\n ;a>.
            Target.OuterExpr->MarkupFinished=true;
            capture_t PreContent,PostContent;
            switch(nat8(PostfixToken)) {
            case token(u8","): {
                GRAMMAR_LET(InnerContent,MarkupExpr(Target.OuterExpr,PostfixStart));
                return InvokeMarkup(Target,TokenLeading,capture_t(),InnerContent,capture_t());
            }
            case token(u8";"): {
                Gen.MarkupStart(PreContent,Snip(PostfixStart));
                GRAMMAR_LET(Content,Trimmed(false));
                cursor ContentsEnd=Cursor;
                GRAMMAR_RUN(Require(u8">",&parser::S51));
                Gen.MarkupStop(PostContent,Snip(ContentsEnd));
                return InvokeMarkup(Target,TokenLeading,PreContent,Content,PostContent);
            }
            case token(u8">"): {
                Gen.MarkupStart(PreContent,Snip(PostfixStart));
                GRAMMAR_LET(Content,Trimmed(true));
                cursor PostStart=Cursor;
                GRAMMAR_RUN(Require(u8"<",&parser::S52));
                Gen.MarkupStart(PostContent,Snip(PostStart));
                for(auto* ExpectMarkup=Target.OuterExpr; ExpectMarkup; ExpectMarkup=ExpectMarkup->OuterMarkup) {
                    GRAMMAR_RUN(Require(u8"/",&parser::S44));
                    if(!IsAlpha(Cursor[0]))
                        return S44(ExpectMarkup->MarkupTag);
                    auto TagStart=Cursor;
                    GRAMMAR_LET(EndTag,Ident());
                    if(EndTag!=ExpectMarkup->MarkupTag)
                        return S43(ExpectMarkup->MarkupTag,EndTag);
                    auto TagSnippet=Snip(TagStart);
                    Gen.MarkupTag(PostContent,TagSnippet);
                    GRAMMAR_RUN(Space(PostContent));
                }
                cursor PostEnd=Cursor;
                GRAMMAR_RUN(Require(u8">",&parser::S44));
                Gen.MarkupStop(PostContent,Snip(PostEnd));
                return InvokeMarkup(Target,TokenLeading,PreContent,Content,PostContent);
            }
            case token(u8":>"): {
                Gen.MarkupStart(PreContent,Snip(PostfixStart));
                GRAMMAR_RUN(Space(PreContent));
                if(!Ending())
                    return S46();
                GRAMMAR_LET(SavedContext,Ind());
                GRAMMAR_LET(Content,Contents(true));
                GRAMMAR_RUN(Ded(SavedContext,&parser::S54));
                GRAMMAR_RUN(Space(PostContent));
                return InvokeMarkup(Target,TokenLeading,PreContent,Content,PostContent);
            }
            default: {
                break;
            }}
            [[fallthrough]];
        }
        case token::NewLine(): {
            GRAMMAR_LET(ScanToken,ScanKey(TokenLeading,
                Target.AllowPostfixes&token_set{u8"catch",u8"do",u8"else",u8"then",u8"until",u8"with",u8"{",u8">",u8":>",u8",",u8";"}));
            if(ScanToken)
                return Invoke(Target,BlockStart,TokenLeading);
            return Target.OnFinish(*this);
        }
        default:  // Ensure static analysis happy with all permutations covered
            break;
        }
        Err(); // AllowPostfixes makes this unreachable.
    }
 
    // Markup.
    result_t<nothing> InvokeMarkup(invoke& InvokeTarget,const capture_t& TokenLeading,const capture_t& PreContent,syntax_t& Content,const capture_t& PostContent) {
        auto& MarkupExpr = *InvokeTarget.OuterExpr;
        auto  NoTrailing = trailing{Cursor, capture_t()};
        GRAMMAR_RUN(UpdateFrom(MarkupExpr,NoTrailing,Gen.InvokeMarkup(
            Snip(*MarkupExpr.MarkupStart),
            !MarkupExpr.OuterMarkup? u8"<": u8",",
            MarkupExpr.ExprLeading,
            ApplyTrailing(MarkupExpr),
            InvokeTarget.Clauses[0],InvokeTarget.Clauses[1],
            TokenLeading,
            PreContent,Content,PostContent)
        ));
        MarkupExpr.ExprLeading = capture_t();
        return MarkupExpr.OnFinish(*this);
    }
    result_t<syntax_t> Markup() {
        GRAMMAR_ASSERT(Cursor[0]=='<');
        auto Start=Cursor;
        Next(1);
        return MarkupExpr(nullptr,Start);
    }
 
    // Expressions.
    struct ins {cursor Start; token InToken; cursor NextStart; capture_t NextLeading; const ins* NextIns;};
    result_t<nothing> InChoose(expr& PostfixExpr,cursor Start,const ins* Ins=nullptr) {
        // In := ("in" Key | ':') Space (In | NotEq)
 
        scoped_guard ExprDepthGuard(ExprDepth, ExprDepth + 1);
        if (ExprDepth > VERSE_MAX_EXPR_DEPTH)
            return S99();
 
        // Here, we parse the Choose into PostfixExpr without finishing it.
        auto InToken = Cursor.Token;
        if(InPrefixes.Has(Cursor.Token)) {
            EatToken();
            auto NextStart=Cursor;
            GRAMMAR_LET(NextLeading,Space());
            auto NextIn=ins{Start,InToken,NextStart,NextLeading,Ins};
            return InChoose(PostfixExpr,Cursor,&NextIn);
        }
        GRAMMAR_RUN(WhenExpr(InToken->Symbol,prec::Choose,prec::Choose,&PostfixExpr,capture_t(),[&](expr& Right)->result_t<nothing> {
            auto NewRight=*Right;
            for(; Ins; Ins=Ins->NextIns) {
                auto RightBlock=SingletonBlock(SnipFinished(Ins->NextStart,Right),Gen.Leading(Ins->NextLeading,NewRight));
                GRAMMAR_SET(NewRight,Gen.PrefixToken(
                    SnipFinished(Ins->Start,Right),Ins->InToken->PrefixMode,Ins->InToken->Symbol,
                    RightBlock,false));
            }
            return UpdateFrom(PostfixExpr,Right.Trailing,NewRight);
        }));
        return nothing{};
    }
    result_t<nothing> DefPostfix(expr& Target) {
        // Def := (.. | .. Space (('='|':='|'+='|'*='|'/=') Space (BraceInd | Def) | !'=' !':=')) {&In Def | ..}
        auto DefineToken=Cursor.Token;
        if(DefPostfixes.Has(DefineToken)) {
            EatToken();
            GRAMMAR_LET(Right,BraceInd(DefineToken->Symbol,prec::Def,Target));
            GRAMMAR_RUN(UpdateFrom(Target,Right.BlockTrailing,Gen.InfixBlock(
                SnipFinished(Target.Start,Right),
                ApplyTrailing(Target),DefineToken->Symbol,Right)));
        }
        return nothing{};
    }
    result_t<nothing> Base(text What,prec Prec,expr& Target,error_t(parser::*OnTokenError)(text),error_t(parser::*OnPrecError)(text,text)) {
        // Base := '(' List ')' | Num | Char | Path | String | Markup | If | !Reserved QualIdent
        GRAMMAR_ASSERT(CheckToken());
        auto BaseToken = Cursor.Token;
        if(Prec<=BaseToken->PrefixPrec) {
            switch(nat8(Cursor.Token)) {
            case token::Digit(): {
                if(Cursor[0]=='0' && Cursor[1]=='o' && IsHex(Cursor[2])) {
                    GRAMMAR_LET(c,Char8());
                    return UpdateSpaceTrailing(Target,Gen.Char8(Snip(Target.Start),c));
                }
                else if(Cursor[0]=='0' && Cursor[1]=='u' && IsHex(Cursor[2])) {
                    GRAMMAR_LET(c,Char32());
                    return UpdateSpaceTrailing(Target,Gen.Char32(Snip(Target.Start),c,true,false));
                }
                else return UpdateSpaceTrailing(Target,Num());
            }
            case token(u8"\""): {
                // String := '"' {Interp | CharEsc | !('\'|'{'|'}'|'"') Text} '"'
                Next(1);
                GRAMMAR_LET(Capture,String<place::String>(Cursor));
                GRAMMAR_RUN(Require(u8"\"",&parser::S32));
                return UpdateSpaceTrailing(Target,Gen.String(Snip(Target.Start),Capture));
            }
            case token(u8"'"): {
                // CharLit := ''' Printable ''' !''' | ''' CharEsc '''
                return UpdateSpaceTrailing(Target,CharLit());
            }
            case token::Alpha():                    // Ident.
            case token(u8"("):                      // QualIdent or Paren.
            case token(u8"at"): case token(u8"of"): // Infix operator tokens that are allowed as identifiers.
            case token(u8"to"):
            case token(u8"next"): case token(u8"over"): case token(u8"when"): case token(u8"while"):
            case token(u8"and"): case token(u8"or"): {
                // Ident     := Alpha {Alnum} !Alnum ["'" {!('<#'|'#>'|'\'|'{'|'}'|'"'|''') 0o20-0o7E} "'"]
                // QualIdent := ['(' List ':)' Space] Ident
                // Base      := '(' List ')' | ..
                // Postfix-only non-ScanKey keywords are valid identifiers.
                return UpdateSpaceTrailing(Target,QualIdent(What,Target,true));
            }
            case token(u8"@"): {
                // Expr := .. | '@' Space Call Scan &('@'|QualIdent) Expr
                EatToken();
                result<syntax_t,nothing> AttrSyntax;
 
                // Set up for parsing RightExpr later. It may receive QualIdent early, e.g. in @a (b:)c...
                auto RightExpr = when_expr(prec::Expr,&Target,AllTokens,Cursor,capture_t(),[&](expr& RightExpr) {
                    return UpdateFrom(Target,RightExpr.Trailing,Gen.PrefixAttribute(
                        SnipFinished(Target.Start,RightExpr),
                        *AttrSyntax,*RightExpr));
                });
 
                // Parse attribute, with RightExpr as its QualIdent target for @a (b:)c.
                GRAMMAR_LET(AttrLeading,Space());
                GRAMMAR_RUN(WhenExpr(u8"@",prec::Call,prec::Prefix,nullptr,AttrLeading,[&](expr& AttrExpr)->result_t<nothing> {
                    ApplyTrailing(AttrExpr,true);
                    AttrSyntax=*AttrExpr;
                    return nothing{};
                },AllTokens,&parser::S71,&RightExpr));
 
                // Parse all or the remainder of RightExpr.
                if(!RightExpr.ExprSyntax) {
                    GRAMMAR_RUN(Scan(RightExpr.ExprLeading));
                    RightExpr.Start=Cursor;
                    if(Cursor[0]!='@' && Cursor[0]!='(' && !IsAlnum(Cursor[0]))
                        return S67();
                    GRAMMAR_RUN(Base(What,Prec,RightExpr,&parser::S71,&parser::S60));
                }
                GRAMMAR_RUN(Postfix(What,Prec,RightExpr,&parser::S71,&parser::S60));
                return RightExpr.Result;
            }
            case token(u8"<"): {
                // Base = .. | Markup | ..
                return UpdateSpaceTrailing(Target,Markup());
            }
            case token(u8"/"): {
                // Base = (.. | Path | ..) Space
                GRAMMAR_LET(P,Path());
                return UpdateSpaceTrailing(Target,Gen.Path(Snip(Target.Start),P));
            }
            case token(u8":"): case token(u8"in"): {
                // In  := ("in" Key | ':') Space (In | NotEq)
                // Def := (Or | (In|Var) Space (('='|':='|'+='|'*='|'/=') Space (BraceInd | Def) | !'=' !':=')) {&In Def | ..}
 
                // Postfix definition x:t leads here, so capture any :t<v, keeping x:t definition at the top.
                auto PostfixExpr = when_expr(prec::Def,&Target,AllTokens,Cursor,capture_t(),[&](expr& PostfixExpr)->result_t<nothing> {
                    // This runs when In or Postfix below finishes PostfixExpr.
                    GRAMMAR_RUN(UpdateFrom(Target,PostfixExpr.Trailing,*PostfixExpr));
                    return DefPostfix(Target);
                },nullptr);
 
                // In parses Choose into PostfixExpr, then Postfix extends to NotEq.
                GRAMMAR_RUN(InChoose(PostfixExpr,Target.Start));
                GRAMMAR_RUN(Postfix(BaseToken->Symbol,prec::NotEq,PostfixExpr));
                return nothing{};
            }
            case token(u8"var"): case token(u8"set"): case token(u8"ref"): case token(u8"alias"): case token(u8"live"): {
                // Var := (("var" [Space '<' Space Choose Space '>'] [Space "live"])|("set" [Space "live"])|"ref"|"alias"|"live") Key Space Choose
                // Def := (Or | (In|Var) Space (('='|':='|'+='|'*='|'/=') Space (BraceInd | Def) | !'=' !':=')) {&In Def | ..}
                bool bIsVar = Cursor.Token == token(u8"var");
                bool bIsSet = Cursor.Token == token(u8"set");
                bool bLive = Cursor.Token == token(u8"live");
                EatToken();
                syntaxes_t Attributes;
#if !TIM /* This syntax will evolve from var<specifier> x:t=v to x:t<specifier>=v. */
                if (bIsVar)
                {
                    while (true)
                    {
                        GRAMMAR_LET(StartingSpace,Space());
                        if (Cursor.Token != token(u8"<"))
                        {
                            break;
                        }
 
                        EatToken();
                        GRAMMAR_RUN(Space());
                        GRAMMAR_RUN(WhenExpr(u8"<",prec::Choose,prec::Less,&Target,StartingSpace,[&](expr& Expr)->result_t<nothing> {
                            ApplyTrailing(Expr,true);
                            Gen.SyntaxesAppend(Attributes,*Expr);
                            return nothing{};
                        }));
                        GRAMMAR_RUN(Space());
                        GRAMMAR_RUN(RequireClose(Cursor,u8"<",u8">",&parser::S85));
                    }
                }
#endif
                auto ChooseStart = Cursor;
                GRAMMAR_LET(Middle, Space());
                if (bIsVar || bIsSet)
                {
                    if (Cursor.Token == token(u8"live"))
                    {
                        EatToken();
                        bLive = true;
                        ChooseStart = Cursor;
                        GRAMMAR_RUN(Space());
                    }
                }
                return WhenExpr(BaseToken->Symbol,prec::Choose,prec::Choose,&Target,Middle,[&](expr& Choose)->result_t<nothing> {
                    auto ChooseBlock=SingletonBlock(ChooseStart,Choose);
                    GRAMMAR_RUN(UpdateFrom(Target,ChooseBlock.BlockTrailing,Gen.PrefixToken(
                        SnipFinished(Target.Start,Choose),
                        BaseToken->PrefixMode,BaseToken->Symbol,
                        ChooseBlock, false, Attributes, bLive)));
                    if(DefPostfixes.Has(Cursor.Token)) // Translate "set x=3" to "set{x}:=3".
                        return DefPostfix(Target);
                    return nothing{};
                });
            }
            case token(u8".."): case token(u8"not"): /*case token("!"):*/ {
                // Not  := .. | ("not" Key) Space Not
                // Def  := .. | (.. | '..') Space Def
                EatToken();
                auto RightStart=Cursor;
                GRAMMAR_LET(Middle,Space());
                return WhenExpr(BaseToken->Symbol,BaseToken->PrefixPrec,BaseToken->PrefixPrec,&Target,Middle,[&](expr& RightExpr) {
                    auto RightBlock=SingletonBlock(RightStart,RightExpr);
                    return UpdateFrom(Target,RightBlock.BlockTrailing,Gen.PrefixToken(
                        SnipFinished(Target.Start,RightExpr),
                        BaseToken->PrefixMode,BaseToken->Symbol,
                        RightBlock,false));
                });
            }
            case token(u8"&"): {
                // Def := .. | ('&' | ..) Space Def
                EatToken();
                GRAMMAR_LET(Middle,Space());
                return WhenExpr(u8"&",BaseToken->PrefixPrec,BaseToken->PrefixPrec,&Target,Middle,[&](expr& Right) {
                    return UpdateFrom(Target,Right.Trailing,Gen.Escape(
                        SnipFinished(Target.Start,Right),*Right));
                });
            }
            case token(u8"^"): case token(u8"?"): case token(u8"+"): case token(u8"-"): case token(u8"*"): {
                // Prefix := .. | ('^' | '?' | .. | '+' | '-' | '*') Space (Brace | Prefix)
                EatToken();
                return WhenBraceCall(BaseToken->Symbol,BaseToken->PrefixPrec,Target,[&](block_t& RightBlock)->result_t<nothing> {
                    return UpdateFrom(Target,RightBlock.BlockTrailing,Gen.PrefixToken(
                        SnipFinished(Target.Start,RightBlock),
                        BaseToken->PrefixMode,BaseToken->Symbol,
                        RightBlock,RightBlock.Punctuation==punctuation::Braces));
                });
            }
            case token(u8"["): {
                // Prefix := .. | (.. | '[' List ']' | ..) Space (Brace | Prefix)
                EatToken();
                GRAMMAR_LET(Left,List(u8"]",&parser::S85,Cursor,capture_t(),punctuation::None,Cursor));
                GRAMMAR_RUN(RequireClose(Target.Start,u8"[",u8"]",&parser::S85));
                return WhenBraceCall(u8"[]",BaseToken->PrefixPrec,Target,[&](block_t& Right)->result_t<nothing> {
                    return UpdateFrom(Target,Right.BlockTrailing,Gen.PrefixBrackets(
                        SnipFinished(Target.Start,Right),
                        Left,Right));
                });
            }
            case token(u8"if"): {
                // If := "if" Key [Specs] (Paren (Block | Then) | Block [Then]) (Else | !Else)
                Target.MarkupTag=u8"if"; // We propagate markup to support <if(a)>Hello</if>.
                EatToken();
                GRAMMAR_RUN(UpdateSpaceTrailing(Target,Gen.Native(Snip(Target.Start),u8"if")));
                invoke IfTarget{u8"if",Target,Target.Start,token(u8"if"),token_set{u8"then"},token_set{u8"else"}};
                return Invoke(IfTarget,Cursor);
            }
            case token(u8"return"): case token(u8"yield"): case token(u8"break"): case token(u8"continue"): {
                // Def := .. | Return [KeyBlock|Def] StopDef
                EatToken();
                block_t Right;
                Right.BlockTrailing.TrailingStart=Cursor;
                GRAMMAR_SET(Right.BlockTrailing.TrailingCapture,Space());
                if(!StopDef.Has(Cursor.Token))
                    GRAMMAR_SET(Right,KeyBlock(prec::Def,Target,*Right.BlockTrailing.TrailingStart,capture_t(),u8"",Right.BlockTrailing.TrailingCapture));
                return UpdateFrom(Target,Right.BlockTrailing,Gen.PrefixToken(
                    SnipFinished(Target.Start,Right),
                    BaseToken->PrefixMode,BaseToken->Symbol,
                    Right,false));
            }
            case token(u8"!"): 
                return S62();
            default: {  // Static analysis warnings without default
                break;
            }}
            Err(); // Should never occur due to structure of the precedence table.
        }
        if(BaseToken->PrefixPrec==prec::Never)
            return (this->*OnTokenError)(What);
        else
            return (this->*OnPrecError)(What,BaseToken->Symbol);
    }
    result_t<nothing> Postfix(text /*What*/,prec Prec,expr& Target,error_t(parser::*/*OnTokenError*/)(text)=&parser::S71,error_t(parser::*/*OnPrecError*/)(text,text)=&parser::S60) {
        while(!Target.Finished) {
            auto PostfixStart = Cursor;
            auto TokenLeading = capture_t();
            auto PostfixToken = Cursor.Token;
        token_leading_loop:
            GRAMMAR_ASSERT(CheckToken());
            if(!(Prec<=PostfixToken->PostfixTokenPrec || (Target.MarkupStart && MarkupPostfixes.Has(PostfixToken)))) {
            finished_postfix:
                Cursor=PostfixStart; //backtrack NewLine's ScanToken
                return Target.OnFinish(*this);
            }
            if(!Target.AllowPostfixes.Has(Cursor.Token)) // Immediate error disallowing e.g. a<=b>c per grammar.
                return S61(PostfixToken->Symbol);
            switch(nat8(Cursor.Token)) {
            case token(u8"&"):
                if(Cursor[1]=='&') 
                    return S62();
                goto binary_operator;
            case token(u8"|"):
                if(Cursor[1]=='|') 
                    return S62();
                goto binary_operator;
            case token(u8">"):
                if(Target.MarkupStart)
                    goto markup_postfix;
                goto binary_operator; // Else continue on as greater operator.
            binary_operator:
            case token(u8"*"):  case token(u8"/"):
            case token(u8"+"):  case token(u8"-"):  
            case token(u8"to"): case token(u8".."): case token(u8"->"):
            case token(u8">="): 
            case token(u8"<="):
            case token(u8"<>"):
            case token(u8"="):
            case token(u8"and"): /*case token(u8"&&"):*/
            case token(u8"or"):  /*case token(u8"||"):*/ {
                // Mul     := Prefix  { Space ('*' | '/' | '&'       ) Scan  Prefix  }
                // Add     := Mul     { Space ('+' | '-'             ) Scan  Mul     }
                // To      := Add     [ Space ("to" Key | ".." | "->") Scan  To      ]
                // Choose  := To      [ Space ('|'                   ) Scan  Choose  ]
                // Greater := Choose  [ Space ('>'  | ">="           ) Scan  Greater ]
                // Less    := Greater [ Space ('<'  | "<="           ) Scan  &(Choose Space !'>' !'>=') Less]
                // NotEq   := Less    { Space ('<>'                  ) Scan  Choose  }
                // Eq      := NotEq   { Space ('='                   ) Scan  NotEq   }
                // And     := Not     { Space ("and" Key             ) Scan  And     }
                // Or      := And     { Space ("or"  Key             ) Scan  Or      }
                Target.MarkupTag=u8"";
                EatToken();
                capture_t Leading;
                GRAMMAR_RUN(Scan(Leading));
                GRAMMAR_RUN(WhenExpr(PostfixToken->Symbol,PostfixToken->PostfixRightPrec(),PostfixToken->PostfixRightPrec(),&Target,Leading,[&](expr& Right)->result_t<nothing> {
                    return UpdateFrom(Target,Right.Trailing,Gen.InfixToken(
                        SnipFinished(Target.Start,Right),PostfixToken->PostfixMode,
                        ApplyTrailing(Target),PostfixToken->Symbol,*Right
                    ));
                },PostfixToken->PostfixAllowMask));
                continue;
            }
            case token(u8"^"): case token(u8"?"): case token(u8"ref"): {
                // Call    := Base {Space Postfix}
                // Postfix := .. | ('^' | '?' | "ref" | ..)
                Target.MarkupTag=u8"";
                EatToken();
                GRAMMAR_RUN(UpdateSpaceTrailing(Target,Gen.PostfixToken(
                    Snip(Target.Start),PostfixToken->PostfixMode,
                    ApplyTrailing(Target),PostfixToken->Symbol)));
                continue;
            }
            case token(u8"["): {
                // Call    := Base {Space Postfix}
                // Postfix := .. | (.. | '[' List ']' ..)
                Target.MarkupTag=u8"";
                EatToken();
                GRAMMAR_LET(Block0,List(u8"]",&parser::S83,Cursor,capture_t(),punctuation::Brackets,Cursor));
                GRAMMAR_RUN(RequireClose(Target.Start,u8"[",u8"]",&parser::S83));
                Block0.BlockSnippet=Snip(PostfixStart);
                GRAMMAR_RUN(UpdateSpaceTrailing(Target,Gen.Call(
                    Snip(Target.Start),mode::Closed,
                    ApplyTrailing(Target),Block0)));
                continue;
            }
            case token(u8"@"): {
                // Expr := Fun {'@' Space Call} StopExpr | ..
                EatToken();
                GRAMMAR_LET(Leading,Space());
                GRAMMAR_RUN(WhenExpr(PostfixToken->Symbol,prec::Call,prec::Call,&Target,Leading,[&](expr& Right)->result_t<nothing> {
                    return UpdateFrom(Target,Right.Trailing,Gen.PostfixAttribute(
                        SnipFinished(Target.Start,Right),
                        ApplyTrailing(Target),*Right));
                }));
                continue;
            }
            case token(u8"at"): case token(u8"of"): {
                // Postfix := .. | ("at"|"of") Key (KeyBlock | Fun)
                Target.MarkupTag=u8"";
                EatToken();
                GRAMMAR_LET(PunctuationLeading,Space());
                GRAMMAR_LET(Right,KeyBlock(prec::Fun,Target,PostfixStart,capture_t(),PostfixToken->Symbol,PunctuationLeading));
                GRAMMAR_RUN(UpdateFrom(Target,Right.BlockTrailing,Gen.Call(
                    SnipFinished(Target.Start,Right),PostfixToken->PostfixMode,
                    ApplyTrailing(Target),Right)));
                continue;
            }
            case token(u8"=>"): case token(u8":="): case token(u8"next"): {
                // Def  := .. { .. | Space ":=" Space (BraceInd | Def) | ..} | ..
                // Fun  := Def {Space ("=>" Space | "next" Key) (BraceInd | Fun) } StopFun
                EatToken();
                GRAMMAR_LET(Right,BraceInd(PostfixToken->Symbol,PostfixToken->PostfixRightPrec(),Target));
                GRAMMAR_RUN(UpdateFrom(Target,Right.BlockTrailing,Gen.InfixBlock(
                    SnipFinished(Target.Start,Right),
                    ApplyTrailing(Target),PostfixToken->Symbol,Right)));
                continue;
            }
            case token(u8"."): {
                // Postfix := .. | (.. | ScanKey '.' QualIdent)
                if(!IsSpace(Cursor[1]) /*&& !IsEnding(Cursor[1])*/) {
                    Target.MarkupTag=u8"";
                    EatToken();
                    Gen.CaptureAppend(Target.Trailing.TrailingCapture,TokenLeading);
                    GRAMMAR_LET(Id,QualIdent(u8".",Target,false));
                    GRAMMAR_RUN(UpdateSpaceTrailing(Target,Gen.InfixToken(
                        Snip(Target.Start),PostfixToken->PostfixMode,
                        ApplyTrailing(Target),PostfixToken->Symbol,Id)));
                    continue;
                }
                [[fallthrough]]; // Else it's a macro invocation handled below.
            }
            case token(u8"{"): case token(u8":"): case token(u8"<"): case token(u8"("):
            case token(u8"in"): case token(u8"with"): 
            case token(u8":>"): case token(u8";"): case token(u8","): markup_postfix: {
                // Invoke := [Specs] (Paren [Specs] (Block | Do) | Block [[Specs] Do]) (Until | !Until)
                // Def    := (Or | ..) {&In Def | ..}
                invoke InvokeTarget{u8"macro invocation",Target,Target.Start,token::None(),token_set{u8"do"},token_set{u8"until",u8"catch"}};
                GRAMMAR_RUN(Invoke(InvokeTarget,PostfixStart,TokenLeading));
                if(Cursor.Pos==PostfixStart.Pos && InPrefixes.Has(PostfixToken)) {
                    if(Prec>prec::Def)
                        goto finished_postfix;
                    // Parse Def and generate a tokenless definition of Target.
                    GRAMMAR_RUN(WhenExpr(PostfixToken->Symbol,prec::Def,prec::Def,&Target,capture_t(),[&](expr& InExpr) {
                        auto InBlock=SingletonBlock(InExpr.Start,InExpr);
                        return UpdateFrom(Target,InBlock.BlockTrailing,Gen.InfixBlock(
                            SnipFinished(Target.Start,InExpr),
                            ApplyTrailing(Target),u8"",InBlock));
                    }));
                }
                continue;
            }
            case token(u8"is"): {
                // Def := .. (.. | ScanKey "is" Key (KeyBlock | Def) | ..)
                EatToken();
                GRAMMAR_LET(PunctuationLeading,Space());
                GRAMMAR_LET(Right,KeyBlock(prec::Def,Target,PostfixStart,TokenLeading,u8"is",PunctuationLeading));
                GRAMMAR_RUN(UpdateFrom(Target,Right.BlockTrailing,Gen.InfixBlock(
                    SnipFinished(Target.Start,Right),
                    ApplyTrailing(Target),u8"is",Right)));
                continue;
            }
            case token(u8"over"): case token(u8"when"): case token(u8"where"): case token(u8"while"): {
                // Def := .. (.. | Space "where" Key (KeyBlock | Defs) | ..)
                // Fun := Def { Space ('over' | 'upon' | 'while') Key (KeyBlock | Defs) | ..) StopFun
                EatToken();
                GRAMMAR_LET(Right,KeyBlockDefs(Target,PostfixStart,TokenLeading,PostfixToken->Symbol));
                GRAMMAR_RUN(UpdateFrom(Target,Right.BlockTrailing,Gen.InfixBlock(
                    SnipFinished(Target.Start,Right),
                    ApplyTrailing(Target),PostfixToken->Symbol,Right)));
                continue;
            }
            case token::NewLine():
                GRAMMAR_SET(PostfixToken,ScanKey(TokenLeading,token_set{u8"is",u8"with",u8"{",u8">",u8":>",u8".",u8",",u8";"}));
                goto token_leading_loop;
            case token(u8"=="):
                return S65();
            case token(u8"+="): case token(u8"-="): case token(u8"*="): case token(u8"/="):
                return S66(PostfixToken->Symbol);
            default:
                Err(); // Should be unreachable due to precedence.
            }
        }
        return nothing{};
    }
    result_t<expr*> FinishExpr(token Token,prec FinishPrec,expr& SourceExpr) {
        // Preemptively finish and generate syntax for all expressions tighter than FinishPrec,
        // producing an error if there is no expression at or looser than FinishPrec.
        GRAMMAR_ASSERT(FinishPrec>=prec::Def); // Vital because prec.Def and looser don't handle preemptive finish.
        for(auto Expr=&SourceExpr; Expr; Expr=Expr->OuterExpr) {
            if(Expr->FinishPrec<=FinishPrec)
                if(Token==token::None() || Expr->AllowPostfixes.Has(Token))
                    return Expr;
            Expr->ExprStop=true;
            if(!Expr->Finished)
                GRAMMAR_RUN(Expr->OnFinish(*this));
        }
        return nullptr;
    }
    template<class f> struct when_expr: expr {
        using       result_type = decltype((*(f*)nullptr)(*(expr*)nullptr));
        f           F;
        result_type Result;
        when_expr(prec FinishPrec0,expr* OuterExpr0,token_set PostfixAllow0,const cursor& Start0,
            const capture_t& ExprLeading0,const f& F0,expr* QualIdentTarget0=nullptr):
            expr(FinishPrec0,Start0,OuterExpr0,PostfixAllow0,QualIdentTarget0), F(F0) {
            this->ExprLeading=ExprLeading0;
        }
        result_t<nothing> Parse(parser& Parser,text What,prec ParsePrec,error_t(parser::*OnTokenError)(text),error_t(parser::*OnPrecError)(text,text)) {
            scoped_guard ExprDepthGuard(Parser.ExprDepth, Parser.ExprDepth + 1);
            if (Parser.ExprDepth > VERSE_MAX_EXPR_DEPTH)
                return Parser.S99();
            GRAMMAR_RUN(Parser.Base(What,ParsePrec,*this,OnTokenError,OnPrecError));
            GRAMMAR_RUN(Parser.Postfix(What,ParsePrec,*this,OnTokenError,OnPrecError));
            GRAMMAR_ASSERT(this->Finished);
            return nothing{};
        }
        result_t<nothing> OnFinish(parser& Parser) override {
            GRAMMAR_RUN(expr::OnFinish(Parser));
            this->ExprSyntax = Parser.Gen.Leading(this->ExprLeading,**this);
            GRAMMAR_SET(Result,F(*this));
            GRAMMAR_ASSERT(!this->Trailing);
            return nothing{};
        }
    };
    template<class f> when_expr(prec,expr*,token_set,const cursor&,const capture_t&,const f&,expr* e=nullptr,bool b=false)->when_expr<f>;
    template<class f> typename when_expr<f>::result_type WhenExpr(text What,prec ParsePrec,prec FinishPrec,expr* OuterExpr,
        const capture_t& ExprLeading,const f& F,
        token_set AllowPostfixes=AllTokens,error_t(parser::*OnTokenError)(text)=&parser::S71,expr* QualIdentTarget0=nullptr) {
        // Start parsing an expression which may be finished preemptively by FinishExpr.
        auto Target = when_expr(FinishPrec,OuterExpr,AllowPostfixes,Cursor,ExprLeading,F,QualIdentTarget0);
        GRAMMAR_RUN(Target.Parse(*this,What,ParsePrec,OnTokenError,&parser::S60));
        return Target.Result;
    }
    result_t<syntax_t> MarkupExpr(expr* OuterMarkup,cursor MarkupStart) {
        capture_t Leading;
        GRAMMAR_RUN(Scan(Leading));
        if(Cursor[0]=='/')
            return S42();
        auto Expr = when_expr(prec::Call,nullptr,AllTokens,Cursor,Leading,[&](expr& Expr)->result_t<nothing> {
            Expr.Trailing = trailing{};
            return nothing{};
        });
        Expr.MarkupStart = MarkupStart;
        Expr.OuterMarkup = OuterMarkup;
        GRAMMAR_RUN(Expr.Parse(*this,u8"markup",prec::Call,&parser::S74,&parser::S64));
        if(!Expr.MarkupFinished)
            return S41();
        return *Expr;
    }
 
    // Separated expressions.
    result_t<block_t> Commas(text What,prec Prec,cursor Start,capture_t& Leading,error_t(parser::*OnTokenError)(text)) {
        // Commas := Expr {',' Scan Expr}
        block_t Block0;
        for(;;) {
            bool More=false;
            GRAMMAR_RUN(WhenExpr(What,Prec,Prec,nullptr,Leading,[&](expr& Expr)->result_t<nothing> {
                More=Eat(u8",");
                if(More)
                    ApplyTrailing(Expr,true);
                else
                    Block0.BlockSnippet=Snip(Start,*Expr.Trailing.TrailingStart),
                    Block0.BlockTrailing.MoveFrom(Expr.Trailing);
                Leading=capture_t();
                Gen.SyntaxesAppend(Block0.Elements,*Expr);
                return nothing{};
            },AllTokens,OnTokenError));
            if(!More)
                return Block0;
            Block0.Form=form::Commas;
            GRAMMAR_RUN(Scan(Leading));
        }
    }
    result_t<block_t> List(text What,error_t(parser::*OnTokenError)(text),cursor BlockStart,const capture_t& PunctuationLeading,punctuation Punctuation,cursor CommasStart,const capture_t& Leading=capture_t()) {
        // Separator := (';'|Ending) Scan
        // List      := push; set LinePrefix=""; Scan [Commas {Separator Commas} [Separator]]; pop
        auto SavedContext            = Context;
        bool Some                    = false;
        Context.LinePrefix           = false;
        auto ListBlock               = block_t{};
        ListBlock.Form               = form::List;
        ListBlock.PunctuationLeading = PunctuationLeading;
        ListBlock.Punctuation        = Punctuation;
        ListBlock.ElementsTrailing   = Leading;
        GRAMMAR_RUN(Scan(ListBlock.ElementsTrailing));
        if(!StopList.Has(Cursor.Token))
            for(;;) {
                GRAMMAR_LET(CommasBlock,Commas(What,prec::Expr,CommasStart,ListBlock.ElementsTrailing,OnTokenError));
                ApplyTrailing(CommasBlock,Cursor);
                CommasBlock.BlockSnippet = Snip(CommasStart);
                bool More                = false;
                if(Cursor.Token==token(u8";") || Ending()) {
 
                    // Attribute Commas-trailing [';'] Space &NewLine to CommasBlock, following Scan to ListBlock.
                    auto SemicolonStart = Cursor;
                    if(Eat(u8";"))
                        Gen.Semicolon(CommasBlock.ElementsTrailing,Snip(SemicolonStart));
                    GRAMMAR_LET(SemicolonTrailing,Space());
                    Gen.CaptureAppend(CommasBlock.ElementsTrailing,SemicolonTrailing);
 
                    // Start parsing next list element.
                    CommasBlock.BlockSnippet = Snip(CommasStart);
                    CommasStart              = Cursor;
                    GRAMMAR_RUN(Scan(ListBlock.ElementsTrailing));
                    More                     = !StopList.Has(Cursor.Token);
                }
                if(More || Some) {
                    // Multiple Semicolon or NewLine separated elements.
                    Some = true;
                    GRAMMAR_LET(CommasSyntax,Gen.Parenthesis(CommasBlock));
                    Gen.SyntaxesAppend(ListBlock.Elements,CommasSyntax);
                }
                else {
                    // Single Commas block.
                    Gen.CaptureAppend(CommasBlock.ElementsTrailing,ListBlock.ElementsTrailing);
                    ListBlock.Form             = CommasBlock.Form;
                    ListBlock.Elements         = CommasBlock.Elements;
                    ListBlock.ElementsTrailing = CommasBlock.ElementsTrailing;
                }
                if(!More)
                    break;
            }
        if(StopList.Has(Cursor.Token)) {
            Context                = SavedContext;
            ListBlock.BlockSnippet = Snip(BlockStart);
            return ListBlock;
        }
        return S77();
    }
    result_t<syntax_t> File() {
        // File := [0oEF 0oBB 0oBF] set Nest=true; set BlockInd=""; set LineInd=""; List Scan end
        if(nat8(Cursor[0])==0xEF) {
            if(nat8(Cursor[1])==0xBB && nat8(Cursor[2])==0xBF) Next(3);
            else return S01();
        }
        GRAMMAR_LET(Block0,List(u8"",&parser::S70,Cursor,capture_t(),punctuation::None,Cursor));
        return Gen.File(Block0);
    }
    result_t<syntax_t> CheckResult(const result_t<syntax_t>& Result) {
        GRAMMAR_LET(Syntax,Result);
        if(Cursor[0]!=0)
            return S70(u8"");
        if(nat(Cursor.Pos-InputString)!=InputLength)
            return S01();
        return Syntax;
    }
 
    // Friends.
    template<class t> friend result<typename t::syntax_t,typename t::error_t> File(t& Gen,nat n,const char8* s,nat Line);
};
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Default Generator Framework inheriting a user generator.
 
template<class gen_t> struct generate: gen_t {
    using syntax_t   = typename gen_t::syntax_t;
    using syntaxes_t = typename gen_t::syntaxes_t;
    using error_t    = typename gen_t::error_t;
    using capture_t  = typename gen_t::capture_t;
    using block_t    = block<syntaxes_t,capture_t>;
    template<class t> using result_t = result<t,error_t>;
 
    // Passthrough constructor.
    template<class... ts> generate(const ts&... TS): gen_t(TS...) {}
 
    // Default translators from concrete syntax callbacks to abstract syntax callbacks.
    result<syntax_t,error_t> Units(const snippet& Snippet,const syntax_t& Num,text Units) const {
        GRAMMAR_LET(UnitsIdent,this->Ident(snippet{},u8"units'",Units,u8"'"));
        syntaxes_t Parameters;
        this->SyntaxesAppend(Parameters,Num);
        return this->Call(Snippet,mode::Open,UnitsIdent,block_t{Snippet,Parameters});
    }
    result_t<syntax_t> Parenthesis(const block_t& Block) const {
        if(this->SyntaxesLength(Block.Elements)!=1) {
            GRAMMAR_LET(Macro,this->Native(snippet{},u8"array"));
            return this->Invoke(Block.BlockSnippet,Macro,Block,nullptr,nullptr);
        }
        else return this->SyntaxesElement(Block.Elements,0);
    }
    result_t<syntax_t> StringLiteral(const snippet& Snippet,const capture_t& Capture) const {
        syntaxes_t Characters;
        nat n = 0u;  // Inexplicably gives "warning C4700: uninitialized local variable 'Length' used" when not initialized separately in Visual Studio 2019 14.29.30139
        n=this->CaptureLength(Capture);
        for(nat i=0; i<n; i++) {
            GRAMMAR_LET(ch,this->Char8(snippet{},this->CaptureElement(Capture,i)));
            this->SyntaxesAppend(Characters,ch);
        }
        GRAMMAR_LET(Macro,this->Native(snippet{},u8"array"));
        return this->Invoke(Snippet,Macro,block_t{snippet{},Characters,form::Commas},nullptr,nullptr);
    }
    result_t<syntax_t> StringInterpolate(const snippet& Snippet,place Place,bool /*Brace*/,const block_t& Block) const {
        GRAMMAR_ASSERT(Place==place::String || Place==place::Content);
        GRAMMAR_LET(FunctionSyntax,this->Native(snippet{},Place==place::String? u8"ToString": u8"ToMarkup"));
        return this->Call(Snippet,mode::Open,FunctionSyntax,Block);
    }
    result_t<syntax_t> String(const snippet& Snippet,const syntaxes_t& Splices) const {
        if(this->SyntaxesLength(Splices)==1)
            return this->SyntaxesElement(Splices,0);
        if(this->SyntaxesLength(Splices)==0)
            return this->Parenthesis(block_t{});
        GRAMMAR_LET(FunctionSyntax,this->Native(snippet{},u8"Concatenate"));
        return this->Call(Snippet,mode::Open,FunctionSyntax,block_t{snippet{},Splices,form::Commas});
    }
    result_t<syntax_t> Content(const snippet& Snippet,const syntaxes_t& Splices) const {
        return String(Snippet,Splices);
    }
    result_t<syntax_t> Contents(const snippet& Snippet,const capture_t& /*Leading*/,const syntaxes_t& Splices) const {
        GRAMMAR_LET(Macro,this->Native(snippet{},u8"array"));
        return this->Invoke(Snippet,Macro,block_t{snippet{},Splices},nullptr,nullptr);
    }
    result_t<syntax_t> InvokeMarkup(const snippet& Snippet,text /*StartToken*/,const capture_t& /*Leading*/,const syntax_t& Macro,block_t* Clause,block_t* DoClause,const capture_t& /*TokenLeading*/,const capture_t& /*PreContent*/,const syntax_t& Content,const capture_t& /*PostContent*/) const {
        GRAMMAR_LET(DefineMacro, this->Native(snippet{},u8"operator':='"));
        GRAMMAR_LET(ContentIdent,this->Ident(snippet{},u8"Content",u8"",u8""));
        block_t DefineClause;    this->SyntaxesAppend(DefineClause  .Elements,ContentIdent);
        block_t DefineDoClause;  this->SyntaxesAppend(DefineDoClause.Elements,Content     );
        GRAMMAR_LET(ContentSyntax ,this->Invoke(snippet{},DefineMacro,DefineClause,&DefineDoClause,nullptr));
        auto LastClause = !Clause? block_t{}: DoClause? *DoClause: *Clause;
        this->SyntaxesAppend(LastClause.Elements,ContentSyntax);
        return this->Invoke(Snippet,Macro,!DoClause? LastClause: *Clause,DoClause? &LastClause: nullptr,nullptr);
    }
    result_t<syntax_t> PrefixToken(const snippet& Snippet,mode Mode,text Symbol,const block_t& Block,bool Lift, const syntaxes_t& /*VarAttributes*/ = {}) const {
        if(Symbol==u8"in")
            Symbol=u8":";
        if(Lift)
            return this->Err(Snippet,"S98","Feature is not currently supported");
        GRAMMAR_LET(Macro,/*IsAlnum(Symbol[0])?
            this->Ident(snippet{},Symbol,u8"",u8""):*/
            this->Ident(snippet{},u8"prefix'",Symbol,u8"'"));
        if(Mode==mode::Open || Mode==mode::Closed)
            return this->Call(Snippet,Mode,Macro,Block);
        else if(Mode==mode::With)
            return this->Invoke(Snippet,Macro,Block,nullptr,nullptr);
        else Err();
    }
    result_t<syntax_t> PrefixBrackets(const snippet& Snippet,const block_t& Left,const block_t& Right) const {
        if(Right.Punctuation==punctuation::Braces)
            return this->Err(Snippet,"S98","Feature is not currently supported");
        if(this->SyntaxesLength(Left.Elements)==0) {
            GRAMMAR_LET(Macro,this->Ident(snippet{},u8"prefix'[]'",u8"",u8""));
            return this->Call(Snippet,mode::Closed,Macro,Right);
        }
        GRAMMAR_LET(Macro,this->Ident(snippet{},u8"operator'[]'",u8"",u8""));
        block_t Parameters;
        GRAMMAR_LET(LeftSyntax ,this->Parenthesis(Left )); this->SyntaxesAppend(Parameters.Elements,LeftSyntax);
        GRAMMAR_LET(RightSyntax,this->Parenthesis(Right)); this->SyntaxesAppend(Parameters.Elements,RightSyntax);
        Parameters.Form=form::Commas;
        return this->Call(Snippet,mode::Closed,Macro,Parameters);
    }
    result_t<syntax_t> PostfixToken(const snippet& Snippet,mode Mode,const syntax_t& Left,text Symbol) const {
        GRAMMAR_LET(Macro,this->Ident(snippet{},u8"operator'",Symbol,u8"'"));
        block_t Parameters;
        this->SyntaxesAppend(Parameters.Elements,Left);
        if(Mode==mode::Open || Mode==mode::Closed)
            return this->Call(Snippet,Mode,Macro,Parameters);
        else if(Mode==mode::With)
            return this->Invoke(Snippet,Macro,Parameters,nullptr,nullptr);
        else Err();
    }
    result_t<syntax_t> InfixToken(const snippet& Snippet,mode Mode,const syntax_t& Left,text Symbol,const syntax_t& Right) const {
        if(Symbol==u8"to")
            Symbol=u8"->";
        GRAMMAR_LET(Macro,this->Ident(snippet{},u8"operator'",Symbol,u8"'"));
        block_t Parameters;
        this->SyntaxesAppend(Parameters.Elements,Left);
        this->SyntaxesAppend(Parameters.Elements,Right);
        if(Mode==mode::Closed || Mode==mode::Open)
            return Parameters.Form=form::Commas, this->Call(Snippet,Mode,Macro,Parameters);
        else if(Mode==mode::With)
            return this->Invoke(Snippet,Macro,Parameters,nullptr,nullptr);
        else Err();
    }
    result_t<syntax_t> InfixBlock(const snippet& Snippet,const syntax_t& LeftSyntax,text Symbol,const block_t& Right) const {
        if(Symbol==u8"" || Symbol==u8"is" || Symbol==u8"=")
            Symbol=u8":=";
        block_t LeftBlock;
        this->SyntaxesAppend(LeftBlock.Elements,LeftSyntax);
        GRAMMAR_LET(Macro,this->Ident(snippet{},u8"operator'",Symbol,u8"'"));
        return this->Invoke(Snippet,Macro,LeftBlock,&Right,nullptr);
    }
    syntax_t Leading(const capture_t& /*Capture*/,const syntax_t& Syntax) const {
        return Syntax;
    }
    syntax_t Trailing(const syntax_t& Syntax,const capture_t& /*Capture*/) const {
        return Syntax;
    }
    result<syntax_t,error_t> File(const block_t& Block) const {
        return Parenthesis(Block);
    }
 
    // String callbacks that can contribute to abstract syntax.
    // In all string callbacks, every non-empty Snippet's text span is guaranteed to be inside the parser's input string.
    void Text(capture_t& Capture,const snippet& Snippet,place Place) const {
        if(Place==place::Content || Place==place::String)
            this->gen_t::Text(Capture,Snippet,Place);
    }
    void NewLine(capture_t& Capture,const snippet& /*Snippet*/,place Place) const {
        if(Place==place::Content) {
            char8 Char8 = '\n'; // We normalize markup NewLine to \n.
            snippet NewSnippet = {};
            NewSnippet.Text = text{&Char8,&Char8+1};
            this->gen_t::Text(Capture,NewSnippet,Place);
        }
    }
    void StringBackslash(capture_t& Capture,const snippet& /*Snippet*/,place Place,char8 Backslashed) const {
        if(Place==place::Content || Place==place::String) {
            // We pass through backslashed control characters as-is.
            char8 Char8 = Backslashed=='n'? '\n': Backslashed=='r'? '\r': Backslashed=='t'? '\t': Backslashed;
            snippet NewSnippet = {};
            NewSnippet.Text = text{&Char8,&Char8+1};
            this->gen_t::Text(Capture,NewSnippet,Place);
        }
    }
 
    // Optional string callbacks which don't contribute to abstract syntax.
    void LineCmt(capture_t& /*Capture*/,const snippet& /*Snippet*/,place /*Place*/,const capture_t& /*Comments*/) const {}
    void BlockCmt(capture_t& /*Capture*/,const snippet& /*Snippet*/,place /*Place*/,const capture_t& /*Comments*/) const {}
    void IndCmt(capture_t& /*Capture*/,const snippet& /*Snippet*/,place /*Place*/,const capture_t& /*Comments*/) const {}
    void Indent(capture_t& /*Capture*/,const snippet& /*Snippet*/,place /*Place*/) const {}
    void BlankLine(capture_t& /*Capture*/,const snippet& /*Snippet*/,place /*Place*/) const {}
    void Semicolon(capture_t& /*Capture*/,const snippet& /*Snippet*/) const {}
    void MarkupTrim(capture_t& Capture) const {Capture=capture_t();}
    void MarkupStart(capture_t& /*Capture*/,const snippet& /*Snippet*/) const {}
    void MarkupTag(capture_t& /*Capture*/,const snippet& /*Snippet*/) const {}
    void MarkupStop(capture_t& /*Capture*/,const snippet& /*Snippet*/) const {}
    void LinePrefix(capture_t& /*Capture*/,const snippet& /*Snippet*/) const {}
};
 
//--------------------------------------------------------------------------------------------------------------------------------------------------------------
// Public parsing interface.
 
template<class gen_t> result<typename gen_t::syntax_t,typename gen_t::error_t> File(gen_t& Gen,nat n,const char8* s,nat Line=1) {
    auto Parser=parser(Gen,n,s,Line);
    return Parser.CheckResult(Parser.File());
}
 
}}