====== Roadmap (Future Plans) ======
This page lists some of the plans for 10LC for the future, if I ever get around to them.

===== Additional Intrinsic Statements =====
By researching some more existing 9010A programs/code, I might be able to figure out some additional intrinsic statements that might be useful.  Might also consider breaking the intrinsics up into multiple smaller programs, so you do not take the hit on intrinsics that you do not use.


===== Poke (Write) Tables =====
There is a good amount of 9LC code out there that has to deal with filing a decent range of memory with different values.  This results in having to come lots of district ''Write'' statements which can get real tedious, real fast (not to mention error prone).

So I am thinking of implementing a type of table construct that can be coded easily, and processed by the compiler into the necessary ''Write'' statements.  I am feeling that implementing the feature as a list of //runs// might work.  For example, if I wanted to fill memory from 0x1000 to 0x1008 I could do something like:

<code c>
WriteTable( 0x1000, 1, 2, 3, 4, 5, 6, 7, 8 );
</code>

Which would yield:

<code c>
Write @ 0x1000 = 1;
Write @ 0x1001 = 2;
Write @ 0x1002 = 3;
Write @ 0x1003 = 4;
Write @ 0x1004 = 5;
Write @ 0x1005 = 6;
Write @ 0x1006 = 7;
Write @ 0x1007 = 8;
</code>

''Note'': this has been implemented via the ''[[documentation|WriteEx]]'' statement.

===== Additional Semantic Checks =====
It might be possible to add some more checks to 10LC to help discover possible coding errors during compilation.

===== Additional Compile Time Optimizations =====
10LC does not currently know how to separately optimize numerically-constant left hand sides or right hand sides of an ''If'' expression.  For example, look at this ''If'' expression:

<code c>
Const JoystickUp = 0x01;

If 44 ++ >> >> <= JoystickUp << << | 44 Goto FoundIt;        // If 11 <= 44
</code>

In that expression, only constant numeric values are involved - no registers.  The left hand side is ''44 ++ %%>> >>%%'' which is a constant numeric expression that can be optimized as follows:
<code c>
44 ++ >> >>
45 >> 2
11
</code>

The right hand side is ''JoystickUp %%<< <<%% | 44'' which is is also a constant numeric expression that can be optimized as follows:
<code c>
JoystickUp << << | 44
( 1 << 2 ) | 44
44
</code>

That means that the entire expression could be optimized to ''If 11 %%<=%% 44 Goto FoundIt;'' which would save 7 bytes of code over the longer version.  When you consider how limited code space is on the 9010A, optimizations like this could save a lot of space over the long run.


===== Modifying the 9010A's Firmware =====
While more on the //pipe-dream// side of things, I wonder if it might be possible to take the 9010A's firmware, decompile it, and make changes to add additional functionality.  This might include being able to support larger program memory (with or without a hardware mod)?

Or maybe making specialized firmware that removes support for things like the probe, clock module, and maybe the cassette deck, and adds additional features that can be accessed via 10LC?  Maybe move some 10LC intrinsics onto the 9010A unit itself?

Maybe one day...

===== Method Call Syntax =====
One of the things I have been kicking around is the possibility of making 10LC look more like //method calls// in a language like C/C++/C#/Java/etc. instead of just like text script.  An example of the ''Write'' statement is:
<code c>
Write @ 0x1000 = 1234;
</code>
But would it be better or more appealing if the statement was written like:
<code c>
Write( 0x1000, 1234 );
</code>
Or maybe that would only be preferable to actual software developers/programmers and not those used to just script?