===== Intrinsic Statements =====
10LC includes some new //intrinsic//, or built-in, statements.  Currently three of them are defined:

  * ''%%__%%Delay'' - standard delay routine, causes a real-time delay in the execution of a program
  * ''%%__%%Fill'' - fill a range of memory with a specific byte
  * ''%%__%%FillRamp'' - fill a range of memory with a byte whose value keeps increasing (and resets to ''0x00'' after ''0xFF'')


==== __Delay ====
The ''%%__%%Delay'' statement causes statement execution to pause for a specified amount of time.  Internally, a special program is called and a counter value is decremented and tested against zero.  If the value is greater than zero, the value is decremented and tested again, etc. until the value reaches zero and processing resumes.

The syntax of the statement is: ''%%__%%Delay <count>;''

The counter value is a 32-bit value and a value of 25 is about 1 second.

<code c>
__Delay 50;    // Delay For About 2 Seconds
__Delay Reg2;  // Delay For Whatever Value Is In REG2
</code>


==== __Fill ====
The ''%%__%%Fill'' statement fills a range of memory with a specific byte.  During the fill operation, the byte value remains static.

The syntax of the statement is: ''%%__%%Fill From <address> To <address> With <byte>;''

<code c>
__Fill From Reg1 To Reg2 With 0xAA;
</code>


==== __FillRamp ====
The ''%%__%%FillRamp'' statement fills a range of memory with a byte value, and increments the byte value during the fill operation.  After the byte reaches 0xFF (255) it is reset back to zero.

The syntax of the statement is: ''%%__%%FillRamp From <address> To <address> With <byte>;''

<code c>
__FillRamp From Reg1 To Reg2 With 0x42;
</code>


==== Implementation ====
The intrinsic statements are implemented via a custom program (Program #99, ''%%__%%IP%%__%%P99'') that is added internally and compiled near the end of the compilation phase.  Its implementation is as follows:

<code c>
Program __IP__P99;
    Alias Command=RegF;                     // First Parameter  - Intrinsic Command
    Alias FromOrDelay=RegE;                 // Second Parameter - Start Of Fill Range or Delay Counter/Value
    Alias To=RegD;                          // Third Parameter  - End Of Fill Range
    Alias FillChar=RegC;                    // Fourth Parameter - Character to use for Fill/FillRamp      

    If Command == 1 Goto Delay;             // RegF == 1 - Delay
    If Command >= 2 Goto Fill;              // RegF == 2 - Fill, RegF == 3 - FillRamp
    Goto End;

    :Delay                                  // Delay Routine
        --FromOrDelay;
        If FromOrDelay > 0 Goto Delay;
        Goto End;

    :Fill                                   // Fill/FillRamp Routine
        Write @ FromOrDelay = FillChar;     // Write Fill Character Into Address
        ++FromOrDelay;                      // Increment Address
        If Command == 3 Goto RampInc;       // If RampFill, Goto RampInc
    
    :FillReturn                         
        If To >= FromOrDelay Goto Fill;     // If Not At End OF Fill Range, Goto Fill
        Goto End;

    :RampInc
        ++FillChar;                         // Increment Fill Character
        If FillChar > 0xFF Goto WrapChar;   // If Character Greater Than 0xFF, Goto WrapChar
        Goto FillReturn;                    // Go Back To Fill Routine

    :WrapChar
        FillChar = 0;                       // Reset Fill Character To Zero
        Goto FillReturn;                    // Go Back To Fill Routine

    :End                                        
EndProgram;                                 // End Of Program 99
</code>

When a intrinsic statement is encountered, the statement is replaced with code to populate the necessary registers with the necessary parameters and a call to Program 99 is made.  For example, the following call to the ''%%__%%Delay'' intrinsic:

<code c>
__Delay 50;
</code>

-Is replaced with the equivalent of the following code:

<code c>
RegF = 1;
RegE = 50;
Execute 99;
</code>