thoughts

docs/source/todo.rst

@@ -3,6 +3,11 @@ TODO
 
 For next release
 ^^^^^^^^^^^^^^^^
+- cx16 diskio: use cx16 MACPTR() in f_read() to load stuff faster? (see its use in X16edit to fast load blocks)
+  note that it might fail on non sdcard files so have to make graceful degradation
+- pipe operator: (targets other than 'Virtual'): allow non-unary function calls in the pipe that specify the other argument(s) in the calls.  Already working for VM target.
+- add McCarthy evaluation to shortcircuit and/or expressions. First do ifs by splitting them up? Then do expressions that compute a value?
+- Inliner: also inline function call expressions, and remove it from the StatementOptimizer
 ...
 
 
@@ -17,8 +22,6 @@ Future Things and Ideas
 ^^^^^^^^^^^^^^^^^^^^^^^
 Compiler:
 
-- add McCarthy evaluation to shortcircuit and/or expressions. First do ifs by splitting them up? Then do expressions that compute a value?
-- Inliner: also inline function call expressions, and remove it from the StatementOptimizer
 - vm: implement remaining sin/cos functions in math.p8
 - vm: somehow deal with asmsubs otherwise the vm IR can't fully encode all of prog8
 - vm: don't store symbol names in instructions to make optimizing the IR easier? but what about jumps to labels. And it's no longer readable by humans.
@@ -38,7 +41,13 @@ Compiler:
   (but we lose the optimizing aspect of the assembler where it strips out unused code.
   There's not really a dynamic switch possible as all assembly lib code is static and uses one or the other)
 - Zig-like try-based error handling where the V flag could indicate error condition? and/or BRK to jump into monitor on failure? (has to set BRK vector for that)
-- add special (u)word array type (or modifier?) that puts the array into memory as 2 separate byte-arrays 1 for LSB 1 for MSB -> allows for word arrays of length 256
+- add special (u)word array type (or modifier?) that puts the array into memory as 2 separate byte-arrays 1 for LSB 1 for MSB -> allows for word arrays of length 256 and faster indexing
+- ast: don't rewrite by-reference parameter type to uword, but keep the original type (str, array)
+  BUT that makes the handling of these types different between the scope they are defined in, and the
+  scope they get passed in by reference...  unless we make str and array types by-reference ALWAYS? BUT that
+  makes simple code accessing them in the declared scope very slow because that then has to always go through
+  the pointer rather than directly referencing the variable symbol in the generated asm....
+
 
 Libraries:
 
@@ -48,20 +57,19 @@ Libraries:
 - optimize several inner loops in gfx2 even further?
 - add modes 2 and 3 to gfx2 (lowres 4 color and 16 color)?
 - add a flood fill routine to gfx2?
-- diskio: use cx16 MACPTR() in f_read() to load stuff faster? (see its use in X16edit to fast load blocks)
-  note that it might fail on non sdcard files so have to make graceful degradation
+
 
 Expressions:
 
-- pipe operator: (targets other than 'Virtual'): allow non-unary function calls in the pipe that specify the other argument(s) in the calls.
 - rethink the whole "isAugmentable" business.  Because the way this is determined, should always also be exactly mirrorred in the AugmentableAssignmentAsmGen or you'll get a crash at code gen time.
-  note: new ast PtAssignment already has no knowledge about this anymore.
+  note: the new Ast doesn't need this any more so maybe we can get rid of it altogether in the old AST - but it's still used for something in the UnusedCodeRemover.
 - can we get rid of pieces of asmgen.AssignmentAsmGen by just reusing the AugmentableAssignment ? generated code should not suffer
-- rewrite expression tree evaluation suchthat it doesn't use an eval stack but flatten the tree into linear code that uses a fixed number of predetermined value 'variables'?
+- rewrite expression tree evaluation such that it doesn't use an eval stack but flatten the tree into linear code that uses a fixed number of predetermined value 'variables'?
   "Three address code" was mentioned.  https://en.wikipedia.org/wiki/Three-address_code
   these variables have to be unique for each subroutine because they could otherwise be interfered with from irq routines etc.
+  The VM IL solves this already (by using unlimited registers) but still lacks a translation to 6502.
 - this removes the need for the BinExprSplitter? (which is problematic and very limited now)
-  and perhaps as well the assignment splitting in  BeforeAsmAstChanger too
+  and perhaps the assignment splitting in  BeforeAsmAstChanger  too
 
 Optimizations:
 
@@ -71,7 +79,27 @@ Optimizations:
 - translateUnaryFunctioncall() in BuiltinFunctionsAsmGen: should be able to assign parameters to a builtin function directly from register(s), this will make the use of a builtin function in a pipe expression more efficient without using a temporary variable
    compare ``aa = startvalue(1) |> sin8u() |> cos8u() |> sin8u() |> cos8u()``
    versus: ``aa = cos8u(sin8u(cos8u(sin8u(startvalue(1)))))``  the second one contains no sta cx16.r9L in between.
-- AssignmentAsmGen.assignExpression() -> better code gen for assigning boolean comparison expressions
+- AssignmentAsmGen.assignExpression() -> improve code gen for assigning boolean comparison expressions
+  Check what the vm target does here, maybe just do this as part of the vm -> 6502 codegen.
 - when a for loop's loopvariable isn't referenced in the body, and the iterations are known, replace the loop by a repeatloop
   but we have no efficient way right now to see if the body references a variable.
-- introduce byte-index operator to avoid index multiplications in loops over arrays? see github issue #4
+
+
+STRUCTS again?
+--------------
+
+What if we were to re-introduce Structs in prog8? Some thoughts:
+
+- can contain only numeric types (byte,word,float) - no nested structs, no reference types (strings, arrays) inside structs
+- is just some syntactic sugar for a scoped set of variables -> ast transform to do exactly this before codegen
+- no arrays of struct -- because too slow on 6502 to access those, rather use struct of arrays instead.
+  can we make this a compiler/codegen only issue? i.e. syntax is just as if it was an array of structs?
+  or make it explicit in the syntax so that it is clear what the memory layout of it is.
+- ability to assign struct variable to another?   this is slow but can be quite handy sometimes.
+  however how to handle this in a function that gets the struct passed as reference? Don't allow it there? (there's no pointer dereferencing concept in prog8)
+- ability to be passed as argument to a function (by reference)?
+  however there is no typed pointer in prog8 at the moment so this can't be implemented in a meaningful way yet,
+  because there is no way to reference it as the struct type again. (current ast gets the by-reference parameter
+  type replaced by uword)
+  So-- maybe don't replace the parameter type in the ast?  Should fix that for str and array types as well then
+