Agner`s CPU blog

I think it is convenient to have preprocessing directives like #include and #if resolved before the assembler begins to interpret anything else because programmers are used to this concept and it is completely transparent what happens. If we would use some kind of metaprogramming for the same purpose then it becomes less obvious at what stage in the process these directives are executed.

This is a valid point, I still have to think about that.

My idea was to use metaprogramming as an extension to the preprocessor. For example, variables defined on meta-level could be treated as preprocessor-macros by the actual assembler. This policy also solves the ambiguity problem:
Agner wrote:

I have encountered a problem with this strategy, though. Consider the following code, where % means define an assemble-time variable:

%A = R1
%B = R2
A = B
This is ambiguous. It could generate the runtime instruction R1 = R2, or it could change the assemble-time variable A to R2.

Agner wrote:

A possible solution to this dilemma is to define a symbol for alias names. For example:
& parameter1 = R0
could define parameter1 as an alias for register R0. This would be useful for function parameters and local variables, but it would generate further confusion with three different prefixes: #, %, &

<%inherit file="base.html"/>

<%

    rows = [[v for v in range(0,10)] for row in range(0,10)]

%>

<table>

    % for row in rows:

        ${makerow(row)}

    % endfor

</table>
<%def name="makerow(row)">

    <tr>

    % for name in row:

        <td>${name}</td>\

    % endfor

    </tr>

</%def>