- Generalized the AsmLibrary procedures to symbols, to also allow exporting variables.
- Removed the initialization part of .asm library header generation for global exported variables.
- The directive __asm_export can now also be used to indicate global variables exporting within C libraries (for potential .asm library generation).
- Converted the usage of typedef to struct for __conio global variable in cx16_conio.c
- Updated example code.
- Fixed a bug where for exported structs and imported structs, the variables were defined as volatile to non-volatile.
- VariableBuilder constructor now also received the program variable to refer to program level configurations defined.
- Remove to declare string constants as .asm library exported global variables.
- Removed the optimization PassNAsmLibraryGlobalVarsExport. It is not needed. Each global variable export must be explicitly declared using asm_export or __asm_export.
- Improved naming of variables and procedures to retrieve and manage import and export libraries within the program.
- Treat global variables of libraries, as part of the .asm library .namespace.
- Fix bugs.
- Assign meaningful struct names to .asm internal variables and labels. (Remove the $x notation).
- Create the possibility of forward declaration of structs as part of the language.
- Generation of forward declarations in the .asm header files.
- Treat global variables as part of global memory, even in libraries. Ensure that globals are not overwritten when importing.
- Ensure that the various compilation models (stack, var, phi) in combination with the memory models (zp, mem) result in proper execution of code and proper memory allocation etc, etc.
- Added the lru-cache logic to properly test the compilation and memory model combinations. (A lot of bugfixes as a result!)
- Fixed a couple of issues with AsmIdentifier.
- Global variables exported are volatile.
- Created proper generation of the protypes for exported global variables in _asm.h.
- Created new test cases.
- Struggled with the proper export of global struct variables, first version of it implemented but this will require rework ...
- There are issues with "types" of structures, will need more work in the future and a strategy for it...
- Made AsmLibrary functions as AsmExportLibrary to make the code more clear.
- Created isAsmExportLibraryGlobal and isAsmImportLibrary global functions.
- New AsmIdentifier class that replaces unallowed kickasm characters to an _.
- New AsmIgnoredImportInlinedKickAsm class, for creating the construct to ignore the body lines when the library is imported (used), and removed the #else clause (was confusing).
- Export of global variable in .asm Libraries (first version).
- Removal of constructor_for in .asm libraries.
- Reworked the way in assembler generation how link files are treated.
- Reworked all `replace("-","_")` areas using AsmIdentifier properly.
- Proper import mechanisms and naming.
- Ensure that .asm library files are imported only once!
- Added a new asm directory in kc folder, that contains library stub C files for .asm library generation.
- Fixed library startup initialization. .asm libraries are now also calling correctly the library init routines etc.
- Added new test cases.
- #820/29 - ensure that during pass4, namespaces are correctly labelled for variables.
- #820/30 - added option to only having to specify #pragma asm_library and the source file name will be used as the library name.
- #820/31 - remove the need for link files for libraries.
- #820/1 - Lots of optimizations
- Added lru-cache as a library in the library tests. It works!
- Added many tests
- Added conio example
- Added eightqueens example.
- Renamed #pragma asm_library(...)
- Automated *.asm inclusion when generating assembler.
- Supports kickc source code libraries too.
Procedures declared in the asm_import are considered to be
part of an external library, so any definition of that procedure
is ignored, and changed as an external __stackcall __library(...) declaration!
Also considered inline procedures following this behaviour.
This allows printf functions to call conio pre-compiled routines
to be called in the assembler.
- Internals for Libraries working for conio.asm.
- Added a demo program demonstrating the asm_import.
- Lot's of minor fixes and additions, added a new AsmLibrary class
and the handling of it in program.
- Added an AsmLibraries object
- Recompile the whole test cases and updated references for a good comparison. Changes should be cosmetic.
- Added at specific locations different compilation logic when a library is created.
- Added a .namespace library { } which encapsulates the whole library asm output.
- Added 2 new classes for .namespace creation in the Asm generation logic.
- Added as part of the program the asmLibrary, which contains the library name set through the #pragma.
- implementation of near, close, far through AsmFragmentSignature
- fragment consolidation (removal of prepare, execute, finalize)
- stackcall banked throws error + test cases
- overall test cases for phi
- implementation of fragments
- Mem[x] return value(s) in banked functions are always allocated in main memory.
- Mem[x] intermediate value(s) in banked functions are always placed in the designated data segment.
This to accommodate better banking logic for far function calls. (There might be more complexity for other type of variables, but for equinoxe it's working!).
(cherry picked from commit 649a187d7e9290b630a951d8968ce5ece6ba2216)
- Renamed #pragma far() to #pragma bank() upon design recommendations of @jesper.
- renamed #pragma near to #pragma nobank, to avoid using bank(-1).
- renamed __far directive to __bank directive.
- introduced bank area upon design recommendation of jesper, and replaced this with the already present code segment linkage to banking. So the structured stayed the same, only the naming changed! This unlink from segment indeed makes things easier when no segments are in scope of the program.
- added bank area as part of the fragment signature, so now call_far_[platform]_[bankarea]_prepare.asm, call_far_[platform]_[bankarea]_execute.asm, call_far_[platform]_[bankarea]_finalize.asm are expected to be present in the compiler.
- removed the c code prepare, execute, finalize idea. The fragments seem to be enough for the moment.
- added ram and rom fragments for far calls for the cx16.
- Cleaned banking logic from Statement level.
- Refactored pragmaCodeSegs HashMap, which has been removed from Pass0GenerateStatementSequence and moved to Program. It controls which code segment have been defined, and a validation is implemented in the far_seg pragmas.
- Refactored __far() to use the code segments, in analogy to far_seg pragmas.
- Refactored Procedure, which implements functions to use the FarSegment to decide on far declaration and far bank retrieval.
- refactored CallingConvention. Removed earlier quick implementation of bankFar variable as a local property, and declaredFar in the Procedure class. Now everyting is controlled through the farSegment.
- Refactored Procedure, the removal of FAR_CALL calling convention. It is wrong to implement FAR_CALL calling convention, because far and near calls can be stack calls, phi calls and even a varcall can be near of far.
- Removed the Pass1ProcedureFar because far and near implementation is not defined in statement level, it is defined on procedure level. But I've kept Pass1ProcedureFar to suppor the logic for inline prepare, execute, finalize routines during further implementation.
- Refactored directive FAR to match the directive far_seg() structure.
- Refactored complete logic during Pass4CodeGeneration to process statement call fragment generation to decide on near or far calls within the logic, taking into account the calling convention used.
- Added new fragments call_far[platform]_prepare.asm, call_far[platform]_execute.asm, call_far[platform]_finalize.asm and deleted call_far[platform]_entry.asm, call_far[platform]_exit.asm
- Renamed pragmas far_seg and near_seg to simply far and near respectively. Updated test cases with this change.
- Added test cases.
TODO: The actual inline implementation of prepare, execute, finalize functions when platform .asm fragments are not used.
TODO: Implementation of the near directive.
- far calls are now ALL iterated and flagged with a bank!
- procedure objects are taken as the base for far call asm generation, not the call objects anymore (too tricky). But i have kept the call objects to be also updated with the bank for any reference later!
