macro class Xml
{
  macro tagOpen(lt, _, id, attrs, gt, _) : XmlAst.TagOpen
  syntax: '<' s identifier attr* '>' s
  {
    TagOpen(lt.StartPos, gt.EndPos, id.Value, attrs.Map(x => x.Value :> Attr))
  }

  macro attr(id, _, _, value) : XmlAst
  syntax: identifier '=' s attrValue;
  {
    Attr(id.StartPos, value.EndPos, id, value)
  }
}

  macro tagOpen(lt, _, id, attrs, gt, _) : XmlAst.TagOpen
  syntax: '<' s identifier attr* '>' s

Имя    Подправило
lt     '<'
_      s
id     identifier 
attrs  attr*
gt     '>'
_      s

  macro tagOpen : XmlAst.TagOpen
  syntax: '<' as lt s identifier as id attr* as attrs '>' as gt s

VD>  macro tagOpen : XmlAst.TagOpen
VD>  syntax: '<' as lt s identifier as id attr* as attrs '>' as gt s

1. varname должно быть опциональным, по умолчанию в макре доступна переменная с соответствующим именем, если имя допустимо спецификацией.
   
2. синтаксис задания переменной через as слабочитабелен (непонятно кстати как задать грамматику с as)

  macro tagOpen : XmlAst.TagOpen
  syntax '<':gt s identifier attr* '>':lt s
  {
    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attr.Map(x => x.Value :> Attr))
  }

  macro tagOpen : XmlAst.TagOpen
  syntax lt:'<' _:s id:identifier attrs:attr* _:s gt:'>'
  {
    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attr.Map(x => x.Value :> Attr))
  }

  macro tagOpen : XmlAst.TagOpen
  syntax: lt : '<' s id : identifier attrs : attr* gt : '>' s

  macro tagOpen : XmlAst.TagOpen
  syntax: lt : '<' id : identifier attrs : attr* gt : '>'

  macro tagOpen : XmlAst.TagOpen
  rawsyntax: lt : '<' s id : identifier attrs : attr* gt : '>' s

S>  macro tagOpen : XmlAst.TagOpen
S>  syntax lt:'<' _:s id:identifier attrs:attr* _:s gt:'>'
S>  {
S>    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attr.Map(x => x.Value :> Attr))
S>  }
S>

  macro tagOpen : XmlAst.TagOpen
  syntax lt:'<' s identifier attrs:attr* s gt:'>'
  {
    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attrs.Map(x => x.Value :> Attr))
  }

VD>>  macro tagOpen : XmlAst.TagOpen
VD>>  syntax: '<' as lt s identifier as id attr* as attrs '>' as gt s
Z>

syntax: expr "as" expr

Z>  macro tagOpen : XmlAst.TagOpen
Z>  syntax '<':gt s identifier attr* '>':lt s
Z>  {
Z>    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attr.Map(x => x.Value :> Attr))
Z>  }
Z>

syntax("x", "y", Optional("z"))

Z>>  macro tagOpen : XmlAst.TagOpen
Z>>  syntax lt:'<' s identifier attrs:attr* s gt:'>'
Z>>  {
Z>>    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attrs.Map(x => x.Value :> Attr))
Z>>  }
Z>>

macro TagOpen:XmlAst.TagOpen = '<' Identifier:id Attr*:attrs '>' => {TagOpen(Macro.StartPos, Macro.EndPos, identifier.Value, attrs.Map(x => x.Value :> Attr))}

[Keyword]
macro Keyword = "keyword"
macro Z = Keyword Identifier => { Console.WriteLine(Macro.Tokens[1].Value) }

macro TagOpen:XmlAst.TagOpen = '<' Identifier@id Attr*@attrs '>' => {TagOpen(Macro.StartPos, Macro.EndPos, identifier.Value, attrs.Map(x => x.Value :> Attr))}

WH>>  macro tagOpen : XmlAst.TagOpen
WH>>  syntax: lt : '<' s id : identifier attrs : attr* gt : '>' s
WH>>

macro attrList(attrs : params array[XmlAst.Attr]) // эквивалентно syntax attrList "(" attrs : attr* ")"
{}

  macro tagOpen : XmlAst.TagOpen
  syntax: lt:'<' s id:identifier attrs:attr* gt:'>' s

Z>macro attrList(attrs : params array[XmlAst.Attr]) // эквивалентно syntax attrList "(" attrs : attr* ")"
Z>{}
Z>

macro class Xml
{
  macro tagOpen : XmlAst.TagOpen
  syntax: '<' identifier attrs '>'
  where 
    attrs: attr*
  {
    TagOpen(identifier.Value, attrs.Map(x => x.Value :> Attr))
  }

  macro attr : XmlAst
  syntax: identifier '=' attrValue
  {
    Attr(identifier, attrValue)
  }
}

  macro tagOpen : XmlAst.TagOpen
  syntax: '<' identifier {attrs attr*} '>'
  {
    TagOpen(identifier.Value, attrs.Map(x => x.Value :> Attr))
  }

  macro tagOpen : XmlAst.TagOpen
  syntax: {lt '<'} identifier attrs {gt '>'}
  where 
    attrs: attr*
  {
    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attributes.Map(x => x.Value :> Attr))
  }

 '<' nospace identifier nospace '>'.

lt:'<'

macro MyMacro...
priority: SomeMacro > this > OtherMacro // т.е. текущий макрос мене приоритетный нежели SomeMacro но более приоритетный нежели OtherMacro

Z>Это пока на уровне интуиции Видится что-то типа http://rsdn.ru/forum/dotnet/3851708.1.aspx

Автор: nikov
Дата: 22.06.10

.

  macro tagOpen : XmlAst.TagOpen
  syntax: lt identifier attrs gt;
  where 
    attrs = attr*;
    lt    = '<';
    gt    = '>';
  {
    ...
  }

ТЗИ>  macro tagOpen : XmlAst.TagOpen
ТЗИ>  syntax: '<' identifier {attrs attr*} '>'
ТЗИ>  {
ТЗИ>    TagOpen(identifier.Value, attrs.Map(x => x.Value :> Attr))
ТЗИ>  }
ТЗИ>

ТЗИ>  macro tagOpen : XmlAst.TagOpen
ТЗИ>  syntax: {lt '<'} identifier attrs {gt '>'}
ТЗИ>  where 
ТЗИ>    attrs: attr*
ТЗИ>  {
ТЗИ>    TagOpen(lt.StartPos, gt.EndPos, identifier.Value, attributes.Map(x => x.Value :> Attr))
ТЗИ>  }
ТЗИ>

  macro tagOpen : XmlAst.TagOpen
  syntax: lt:'<' identifier attrs gt:'>';
  where 
    attrs = attr* // "Равно" здесь более уместно. Как вариант, можно использовать "<-" раз уж мы используем PEG
  {
    ...
  }

ТЗИ> '<' nospace identifier nospace '>'.
ТЗИ>

 '<'identifier'>'.

macro FooMacro
{
    dependencies // отдельно описать зависимости
    {
        BarMacro, 
        BazMacro
    }

    parameters // отдельно — параметры и их типы
    {
        First  : BarMacro
        Second : BazMacro
        Third  : PExpr
        Fourth : int
    }

    syntax // отдельно — синтаксис (почему бы его не описывать PEG-грамматикой, если он все равно к ней сводится)
    {
        FooMacro = ShortMode | LongMode
        ShortMode = First * 
        LongMode = Third *
    }
 
    beforeTypedMembers // отдельно — реализацию для каждой фазы компиляции
    {
         // blah blah
    }

}

language Xml
{
    macro XmlAttr: Xml.Attr
    syntax name '=' value
    where name : PExpr.Ref, value : PExpr.Expr
    {
       Xml.Attr(name.Name, value);
    }

    macro XmlNodeStart: Xml.NodeStart
    syntax '<' name attrs:attr* '>' 
    where name : PExpr.Ref, attr : Xml.Attr
    {
       Xml.NodeStart(name.Name, attrs)
    }

    macro XmlNodeEnd: Xml.NodeEnd
    syntax '</' name  '>'
    where name : PExpr.Ref
    {
       Xml.NodeEnd(name)
    }

    macro XmlNode: Xml.Node
    syntax start nodes:node* end
    where start : Xml.NodeStart, 
          node  : Xml.Node, 
          end   : Xml.NodeEnd
    {
      assert(start.Name == end.Name);
      Xml.Node(start.Name, start.Attrs, nodes)
    }
}
// program
using language Xml
{
  def x = <foo x="1">; // def x = Xml.NodeStart("foo", [Xml.Attr("x", "1")])

  def str = "1";
  def x = <foo x="1">; // def x = Xml.NodeStart("foo", [Xml.Attr("x", str)])

  def attr = Xml.Attr("x", "1");
  def x = <foo <( [attr : Xml.Attr] )> ></foo>; // def x = Xml.Node(foo, [attr], [])
}

language Xml
{
    macro XmlAttr: (Xml.Attr | PExpr)
    syntax name '=' value
    where name : PExpr.Ref, value : PExpr.Expr
    {
       | Xml.Attr => Xml.Attr(name.Name, value);
       | PExpr    => <[ Xml.Attr( $(name.Name : string), $value); ]>
    }
}

macro class Xml
{
  macro tagOpen(lt, _, id, attrs, gt, _) : XmlAst.TagOpen
  syntax: '<' s identifier attr* '>' s
  {
    TagOpen(lt.StartPos, gt.EndPos, id.Value, attrs.Map(x => x.Value :> Attr))
  }

  macro attr(id, _, _, value) : XmlAst
  syntax: identifier '=' s attrValue;
  {
    Attr(id.StartPos, value.EndPos, id, value)
  }
}

language Xml
{
  TagOpen = '<' id:Identifier attrs:Attr* '>';
  Attr = id:Identifier '=' value:AttrValue;
}

macro XmlElement : Xml.Element
syntax start children:subNode* end // children это алиас для списка вложенных тегов
where start : XmlStartTag, subNode : XmlElement, end : XmlEndTag // уточняем парсеру типы элементов грамматики, XmlStartTag, XmlElement, XmlEndTag
{
  Xml.XmlElement(start.Name, start.Attrs, children)
}

macro XmlElement : Xml.Element
syntax start children:subNode* end 
where start : XmlStartTag, subNode is Xml.Element, end : XmlEndTag // теперь subNode может быть любым макросом возвращающим Xml.Element
{
  Xml.XmlElement(start.Name, start.Attrs, children)
}

// то сможем расширить синтаксис примерно так
macro XmlEmptyElement : Xml.Element
syntax '<' name attrs:attr* '/>'
where name : XmlName, attr is Xml.Attr
{
  Xml.XmlElement(name.Name, attrs, [])
}

VD>Бррр. Не странно но что мы не можем с тобой ни о чем договориться. Казалось бы в этой теме я должен понимать все, но я опять не понимаю твоих слов.

VD>Я не телепат.

def attrs = [Xml.Attr("a", "1"), Xml.Attr("b", "2")];

def xml = <foo $(attrs : list[Xml.Attr]) />; // сахар для Xml.XmlElement("foo", attrs, []), уточнение типа понадобится парсеру

rule = extPoint1 / ruleImpl / extPoint2;