8 Internal functioning of m0

8.1 Introduction

In most cases the exact internal execution of the m0 program is not relevant. However, in case of complicated macro systems or emulations it is necessary to know how the detection and execution of the several stages are internally performed.

The source code is the ultimate guide, but in this part an overview is given for a quick understanding.

8.2 The execution loop

The main execution loop that is performed is the loop of the bitap and possible macro execution at every input character. The bitap algorithm works per byte. There are thus no word boundaries that determine the execution loop.

The steps of the main execution loop consist of:

• Read input (a byte) and copy to output.
• If macros are active (normal case and when recursive argument collection is active):
  • Perform bitap algorithm for normal macros.
  • Detect possible macro execution.
  • Perform bitap algorithm for vlm macros.
  • Detect possible macro execution.
• If argument collection or argument substitution is active:
  • Perform bitap algorithm for patterns.
  • Run all programs that are activated by pattern.
• Execute possible macro

It can be seen that at a position multiple macros for execution can be detected. Therefore in Priority the execution priority of macros is explained. It can also be seen that a macro for execution can be detected while at the same time also programs of the pattern are executed. The priority setting in the pattern part determines if a program is then executed or not.

8.3 The execution of a macro

A macro will normally change the output by removal and insertion. What is removed and what is inserted is completely determined by the macro in its definition and settings.

In The complete working of macros already an overview of this proces is given. In this part only the steps involved when a macro is executed are explained. When a macro is executed the steps are:

• If argument pattern exists, run argument collection by calling the main execution loop with setting for argument pattern and recursive macro setting. The output of the execution loop is into a temporary buffer.
• If exists, execute program of macro.
• Execute function call or perform macro call (mcall).
• When performing an mcall:
  • Change to macro set of mcall.
  • Either execute the call to a macro by:
    • If exists, execute program of macro.
    • Execute function call.
    • Perform argument substitution, using the temporary buffer from the argument collection. The output is stored in a temporary output buffer.
    • Output the output of the call recursive by main execution loop or copy when not recursive.
  • Or execute the call to an mcall
  • return to the previous macro set.
• When executing a normal macro: Perform argument substitution, using the temporary buffer from the argument collection. The output is stored in a temporary output buffer.
• If the output of a macro is set to recursive, use the temporary output buffer as input to the main execution loop. The output will replace the macro name part.
• If the output of a macro is set to not recursive, copy the temporary output buffer to the output of the macro. The output will replace the macro name part.

This overview might seem a bit confusing because of its recursive nature of calling macros, but it will just execute:

• A normal macro.
• An mcall to a normal macro.
• An mcall to an mcall to a normal macro.
• An mcall to an mcall to an mcall to a normal macro.
• etc.

The function calls are explained in Builtin functions and the programming and instructions are explained in Programs for patterns and macros.