Quote: "13th June
All existing language features have now been completed and testing with some existing projects shows very promising results. The compiler is about 40 times faster than before and the interpreter appears marginally faster although this hasn't been extensively tested yet. Byte code file sizes are now 7 times smaller when uncompressed, compressed size is about the same as before.
There are some additional languages features that the new interpreter supports but aren't yet exposed by the compiler, they are array inserting/removing/swapping elements, but first we want to make sure that existing projects are working exactly as with the old interpreter (or better).
11th June
The main Compiler work has been competed! Early tests are showing it's lightning fast compared to the older V1 Compiler. We'll bring more info to you on Friday!
6th June
The main development focus these past couple of months have been on the new Compiler and Interpreter. Here's a quick update on what's been achieved recently;
* User defined functions can now return types and arrays
* In general types and arrays can now be assigned to variables of matching types and passed to functions by value or reference.
* Parsing of IF statements is now completed
* Parsing of the 4 loop types DO, FOR, WHILE, and REPEAT is now completed
* All 4 loop types DO, FOR, WHILE, and REPEAT now have a new command CONTINUE which will skip the rest of the current iteration and move on to the next iteration.
* Parsing of SELECT statements is almost complete
After SELECT statements all the language parsing will be complete and testing on large real world projects can begin to check that there are no errors with existing tier 1 code, and give us an idea of compiling performance. Then the data (variables and instructions) will be packed into the byte code file format for the new interpreter and testing can begin to check it performs identically to the existing compiler and interpreter.
2nd June
Only a 3 day week last week due to the bank holiday and a day off on Friday so not a lot of progress, but I've nearly completed the function code for handling parameters and local variables. Functions now have the ability to return types and arrays and assign them to global variables or use them directly as parameters to other functions. This required a lot of care as temporary pointers created on the stack must be recognised when they are popped and properly freed so they don't leak memory, whilst types passed by reference must not be freed as it would destroy the original variable.
23rd May
This week Paul has finished the expression type casting work. So now it can also handle AppGameKit commands that have multiple compatible types. For example Str(int) and Str(float) would take Str(6) as an integer, where as Update(float) would take Update(6) as a float.
Paul has now moved on to function parsing which handles local variables and arrays. These are now placed on the stack instead of in global storage, and passing arrays and types by reference so that modifying their contents affects the original copy or passing by value so any changes remain inside the function” So basically variable handling is really working well.
We know the Compiler and Interpreter work has been going on for some time now but we're through the hardest part and should be looking to release a new Alpha in June for you all to start playing around with. Thanks for your patience!
19th May
Added code to validate function calls matching parameter count and types for AppGameKit commands and user functions. Added more expression rules for types and arrays so it can now parse expressions like;
"mytype.x = othertype.arrayoftypes[a].somevalue"
Arrays can be resized with "array.length = myType.num + 5".
At this point we started testing the bytecode output and realised it would also have to handle type casting so expressions like "a = 6.5" would function correctly if "a" is defined as an integer and promoting integers to floats in mixed expressions like "6.5 + 7" producing a float result. The changes to support this are nearly done. After which testing can resume to see if anything else comes up.
12th May
Implemented a new variable handler that should be able to deal with the various scopes (global, local, and function local). The parser can now recognise all the possible variable declarations, including old DIM style arrays and new array declarations of the form "myArray as integer[5]", type declarations, and default values for basic data types (integer, float, string + arrays). It can also now parse expressions like "a = 5+func()*b[5]" checking that every function, array, or variable is properly defined. Still to do is parsing conditionals and loops, and handling local variables inside functions."
Huzzah!! I haven't been following this closely but I just came back here to find all this new stuff! I haven't backed AGKv2 yet, but I plan to as soon as I have the cash for it, and it's seriously awesome to see all this compiler-level work being done. I mean, "a = 5+func()*b[5]"?? How awesome is that?! And resizable multidimensional arrays?!! Woo! Finally AppGameKit is getting a modern data-handling feature set
Excellent work Rick and Paul (and any others that may be helping that we haven't heard of)!
