macro define_keyword
{
  macro keyword Params&
  \{
    define_keyword
    match k , keyword_ctx
    \\{
      k Params
    \\}
  \}
}
define_keyword    

keyword begin
keyword end
; ...
    

macro keyword Name*
{
  local _def
  macro _def
  \{
    macro Name Params&
    \\{
      _def
      match k , Name \\# _ctx
      \\\{
        k Params
      \\\}
    \\}
  \}
  _def
}    

... begin_ctx, end_ctx and stuff like that are defined as local symbols in the outside block ...

DimonSoft wrote:

... begin_ctx, end_ctx and stuff like that are defined as local symbols in the outside block ...

I don't see that in the code you posted. Can you please post all the relevant bits so we can see what you have done.

match ,
{
  local Error,\
        uses_ctx,       uses_def,       uses_stub,      uses_program,   uses_unit,\
        begin_ctx,      begin_def,      begin_stub,     begin_program,\
        end._ctx,       end._def,       end._stub,      end._program,   end._unit

  macro Error Message*
  \{
    display Message
    err
  \}

  define uses_ctx uses_stub
  define begin_ctx begin_stub
  define end._ctx end._stub

  ; ==> I’m trying to generate these macros via another macro
  macro uses_def
  \{
    macro uses Params&
    \\{
      uses_def
      match u , uses_ctx \\\{ u Params \\\}
    \\}
  \}
  macro begin_def
  \{
    macro begin Params&
    \\{
      begin_def
      match b , begin_ctx \\\{ b Params \\\}
    \\}
  \}
  macro end._def
  \{
    macro end. Params&
    \\{
      end._def
      match e , end._ctx  \\\{ e Params \\\}
    \\}
  \}

  uses_def
  begin_def
  end._def

  ; Custom implementations of the keywords depending on the context

  macro uses_stub \{ Error "`uses` clause not allowed here" \}
  macro uses_program List& \{ ... \}
  macro uses_unit List& \{ ... \}

  macro begin_stub \{ Error "`begin` clause not allowed here" \}
  macro begin_program \{ ... \}

  macro end._stub \{ Error "`end.` clause not allowed here" \}
  macro end._program \{ ... \}
  macro end._unit \{ ... \}

  ...
}    

define uses_ctx uses_program ; May also be uses_unit, etc.    

DimonSoft
I think, you're over-engineering your macros. E.g., I don't see any need for recursive macros. And the macro-implementations of the keywords aren't gonna be equal, so it doesn't make sense to generate them all with a single macro.

Besides, it seems, you're trying to integrate contradictory ideas into your macro architecture: on one hand the keyword macro should generate a standalone independent keyword, on the other hand it should share its context with other keywords. You could try to define the _ctx suffix as a local symbol and generate keywords by concatenating the suffix to the Name, but it seems the architecture is broken anyway, and this might not help.

macro_rec mymacro params
{
  ...
}    

a short means of creating a recursive macro would be a good thing since recursive macros are not that rare

DimonSoft

Quote:

a short means of creating a recursive macro would be a good thing since recursive macros are not that rare

They are also not as common. In some cases there's a way to avoid recursion, and it should be done if possible, because recursive macros induce high memory and compile time overhead. Additionally the way a macro recurs differs for different macros, and there's no way to make a universal recursion.

I've ever seen at FASM board is the one I tried to use above (with outside "define" macro)

(b) common ways to avoid macro recursion with current preprocessor implementation

I've read somewhere on the board about FASM 2 being slowly developed.