Jump to content

Search the Community

Showing results for tags 'compiler'.

More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


  • Atari Systems
    • Atari General
    • Atari 2600
    • Atari 5200
    • Atari 7800
    • Atari Lynx
    • Atari Jaguar
    • Atari VCS
    • Dedicated Systems
    • Atari 8-Bit Computers
    • Atari ST/TT/Falcon Computers
  • Classic Consoles
  • Classic Computing
  • Modern Consoles
  • Gaming General
  • Marketplace
  • Community
  • Community
  • Game Programming
  • Site
  • PC Gaming
  • The Club of Clubs's Discussion
  • I Hate Sauron's Topics
  • 1088 XEL/XLD Owners and Builders's Topics
  • Atari BBS Gurus's Community Chat
  • Atari BBS Gurus's BBS Callers
  • Atari BBS Gurus's BBS SysOps
  • Atari BBS Gurus's Resources
  • Atari Lynx Programmer Club's CC65
  • Atari Lynx Programmer Club's ASM
  • Atari Lynx Programmer Club's Lynx Programming
  • Atari Lynx Programmer Club's Music/Sound
  • Atari Lynx Programmer Club's Graphics
  • The Official AtariAge Shitpost Club's Shitty meme repository
  • The Official AtariAge Shitpost Club's Read this before you enter too deep
  • Arcade Gaming's Discussion
  • Tesla's Vehicles
  • Tesla's Solar
  • Tesla's PowerWall
  • Tesla's General
  • Harmony/Melody's CDFJ
  • Harmony/Melody's DPC+
  • Harmony/Melody's BUS
  • Harmony/Melody's CDFJ+
  • Harmony/Melody's General
  • ZeroPage Homebrew's Discussion
  • Furry Club's Chat/RP
  • PSPMinis.com's General PSP Minis Discussion and Questions
  • PSPMinis.com's Reviews
  • Atari Lynx 30th Birthday's 30th Birthday Programming Competition Games
  • 3D Printing Club's Chat
  • Drivers' Club's Members' Vehicles
  • Drivers' Club's Drives & Events
  • Drivers' Club's Wrenching
  • Drivers' Club's Found in the Wild
  • Drivers' Club's General Discussion
  • Dirtarians's General Discussion
  • Dirtarians's Members' Rigs
  • Dirtarians's Trail Runs & Reports
  • Dirtarians's Wrenching
  • The Green Herb's Discussions
  • Robin Gravel's new blog's My blog
  • Robin Gravel's new blog's Games released
  • Robin Gravel's new blog's The Flintstones Comic Strip
  • Atari Video Club's Harmony Games
  • Atari Video Club's The Atari Gamer
  • Atari Video Club's Video Game Summit
  • Atari Video Club's Discsuuions
  • Star Wars - The Original Trilogy's Star Wars Talk
  • PlusCart User's Bug reports
  • PlusCart User's Discussion
  • DMGD Club's Incoming!
  • DASM's General
  • AtariVox's Topics
  • Gran Turismo's Gran Turismo
  • Gran Turismo's Misc.
  • Gran Turismo's Announcements
  • The Food Club's Food
  • The Food Club's Drinks
  • The Food Club's Read me first!
  • The (Not So) Official Arcade Archives Club's Rules (READ FIRST)
  • The (Not So) Official Arcade Archives Club's Feedback
  • The (Not So) Official Arcade Archives Club's Rumor Mill
  • The (Not So) Official Arcade Archives Club's Coming Soon
  • The (Not So) Official Arcade Archives Club's General Talk
  • The (Not So) Official Arcade Archives Club's High Score Arena
  • Adelaide South Australia Atari Chat's General Chat & Welcome
  • Adelaide South Australia Atari Chat's Meets
  • Adelaide South Australia Atari Chat's Trades & Swaps
  • KC-ACE Reboot's KC-ACE Reboot Forum
  • The Official Lost Gaming Club's Lost Gaming
  • The Official Lost Gaming Club's Undumped Games
  • The Official Lost Gaming Club's Tip Of My Tounge
  • The Official Lost Gaming Club's Lost Gaming Vault
  • The Official Lost Gaming Club's Club Info
  • GIMP Users's Discussion
  • The Homebrew Discussion's Topics
  • Hair Club for Men's Bald? BEGONE!


There are no results to display.

There are no results to display.


  • AtariAge Calendar
  • The Club of Clubs's Events
  • Atari BBS Gurus's Calendar

Find results in...

Find results that contain...

Date Created

  • Start


Last Updated

  • Start


Filter by number of...


  • Start










Custom Status



Currently Playing

Playing Next

Found 28 results

  1. Hi all, I think that the Atari 5200 is under-represented in the BASIC 10-liners competition, so here is a new easy way to write games for the console: Just released a new beta version of FastBasic, with one big addition: With the help of @vitoco, the PC compiler now supports the Atari 5200! You can read the details in the manual at https://github.com/dmsc/fastbasic/blob/master/a5200.md , and the compiler usage in https://github.com/dmsc/fastbasic/blob/master/compiler/USAGE.md Basically, the Atari 5200 target supports: - All the integer and string functions, including compatible STICK() and STRIG(). - Graphic modes 0, 1, 2, 7 to 13 and 15, with PLOT and DRAWTO support. - DLI and P/M. - PRINT to screen and GET for reading the Atari 5200 keypads. To implement the Atari 5200 support, there are a lot of changes to the compiler under the hood, now the compiler supports multiple targets, and the old "integer only" and "floating-point" compilers are simply different targets now, the targets currently implemented are: Atari 8-bit computers binary loadable files (XEX, with and without floating point), Atari 8-bit computers Cartridge images (CAR, with and without floating point) and the new Atari 5200 Cartridge images (BIN). Also, for advanced users, now the language can be extended without modifying the compiler sources, by writing new target files, there is an example in the compiler manual for writing a new statement and a new function, see https://github.com/dmsc/fastbasic/blob/master/compiler/USAGE.md#extending-the-language There is a few new language extensions: - TAB() function inside PRINT, moves to a column multiple of a number. - DIM can be used to declare normal variables (like "DIM X$, Z"), the variables are automatically initialized to 0 or empty strings. - The comma in prints now uses the TAB function internally, so it behaves more consistently in screen output (but in a different way that Atari BASIC). Well, you can download all the usual files from Github: https://github.com/dmsc/fastbasic/releases/tag/v4.6-beta Attached is a test program, the "joyas" game ported to the Atari 5200 Have Fun! joyas.bas joyas.bin
  2. Hi all! Finally I published the new FastBasic 4.5 release!! From the 4.5 beta, I added: - The "ADR()" function and the "&" operator now allow taking the address of a variable, so this code will print 123: " A = 1 : DPOKE &A, 123 : ? A ". - The "EXEC" statement can be abbreviated to a "@", this makes calling procedures more natural, this will also print 123: " PROC Test A : ? A : ENDPROC : @Test 123 " This in addition to the added features of the 4.5 beta: - Parameters for the PROC/EXEC, see the test-release docs, - Arbitrary characters in string constants by using the hex value, like: PRINT "Hello"$9B"World", - Added PAUSE without a parameter, this is the same as PAUSE 0, "wait for vsync", - PROC has a shorter abbreviation: PR., - The parser is more robust to syntax errors, I discovered some erroneous inputs that could slow down the parser a lot. Many improvements to the editor: - Much faster COPY/PASTE operations, - Restores left-margin value on exit to DOS, - Remove P/M graphics when returning to the editor from user programs. And improvements to the cross-compiler: - Better error messages from some syntax errors, and fixes in parsing of big numbers. - Check for PROC and EXEC parameters mismatch. - An option to write an expanded and indented listing from an abbreviated listing, "-l" After a lot of optimizations, I managed to keep the integer IDE at 8192 bytes and the floating-point IDE at 9457 bytes. EDIT: Current release is 4.5.2, adds a few bugfixes and minor optimizations, now the integer IDE is 8166 bytes. As always, you can download the ATR, the manual and the cross-compiler from github: https://github.com/dmsc/fastbasic/releases/ Have Fun!
  3. ********** 3 May 2022 UPDATE: MegaPack V5.0.0 now available for download. ---> Download on Post #671 ---> Official Labels for SSS compilations on Post #279 ********** 13 NOVEMBER 2021 UPDATE: MegaPack V4.0.0 now available for download. ---> Download on Post #544 ********** 22 MAY 2021 UPDATE: MegaPack V3.0.0 now available for download. ---> Download on Post #392 ************************************************************************************************************************************** There are some games that have the gameplay ruined by the slowness of TI BASIC/TI EXTENDED BASIC. Some of them are worth to be compiled to try to see if the gameplay is improved by speed! Of course, it's not enough to just compile them, since you need to adjust the speed for input, etc. The XB256 by Harry Wilhelm is very useful in this case. I attachment ten or so games to try. Hope to see more games from other members of this TI99 forum. 🙂 Have fun! [GAME] Dadalus (2010)(Walid Maalouli)[Compiled by TMOP].zip [GAME] Daddie's Hot Rod (1983)(Lantern Software)[Compiled by TMOP].zip [GAME] DarkMaze (2010)(Adam Haase)[Compiled by TMOP].zip [GAME] Grog Maze (ENG-ITA)(1984)(Tesio Riccardo)[Compiled by TMOP].zip [GAME] Manic Miner II (19xx)(Wegasoft)[Compiled by TMOP].zip [GAME] Nerm of Bemer (1984)(Compute)[Compiled by TMOP].zip [GAME] Nibbler (1985)(by MMG - TI99 NewSoft)(Compiled by TMOP).zip [GAME] Nibbler II (1984)(by MMG - TI99 NewSoft)(Compiled by TMOP).zip [GAME] Turtle Hop (1985)(HC)[Compiled by TMOP].zip
  4. Hi All! As @777ismyname said, I just published a test version for the new FastBasic release. Please, help me testing it so I can make a new release in time for the BASIC 10 liner contest There is a big new feature: parameters for the PROC/EXEC, like this example: exec Test 1, 2 for i=1 to 4 exec Test 5 - i, i next proc Test a b ? "Testing: "; a, b endproc Notice that in the EXEC the parameters are separated with commas, but in the PROC the corresponding variables are separated with spaces. Also, the variables in the proc are not "local" like most languages, as all variables in FastBasic are global and the parameters are simply variables, the above code is basically equivalent to: a=1 : b=2 : exec Test for i=1 to 4 a=5-1 : b=i : exec Test next proc Test ? "Testing: "; a, b endproc Also, in the Atari IDE the parser does not verify that the number of arguments passed to the EXEC is the same as received by the PROC, I plan to add a check to the floating-point version in a future version. In addition to the above, there are other changes to the language: - You can include arbitrary characters in string constants by using the hex value, like: PRINT "Hello"$9B"World" . So, now you can easily include he EOL character in strings directly, and in the cross compiler you can write Atari characters in strings simply by the ATASCII code. - Added PAUSE without a parameter, this is the same as PAUSE 0, "wait for vsync". - PROC has a shorter abbreviation: PR., - The parser is more robust to syntax errors, I discovered some erroneous inputs that could slow down the parser a lot. Many improvements to the editor: - Much faster COPY/PASTE operations, - Restores left-margin value on exit to DOS, - Remove P/M graphics when returning to the editor from user programs. And improvements to the cross-compiler: - Better error messages from some syntax errors, and fixes in parsing of big numbers. - Check for PROC and EXEC parameters mismatch. - An option to write an expanded and indented listing from an abbreviated listing, "-l" Adding the support for PROC parameters while keeping the integer IDE under 8kb was a lot harder than expected, but I finally managed to squeeze a few bytes from the editor and made it fit, currently the "FBI.XEX" file is 8189 bytes! As always, you can download the ATR, the manual and the cross-compiler from github: https://github.com/dmsc/fastbasic/releases/tag/v4.5-rc I plan to do a few extra commits before the release, but nothing big. Have Fun!
  5. Introduction thread here: Meta is a new, human-friendly programming language that supports and started on Atari: https://language.metaproject.frl The old links from the early development period in the introduction thread are gone, and a few of the method names in the program examples have changed. I will post progress here now, so that the website is on top, and examples on the website, where they can be updated. Release thread here:
  6. I finally managed to finish the DLI work, so here is the new FastBasic version, ready for the 2020 tenliners! You can now create a DLI with a simple syntax, capable of changing registers at multiple locations in the screen. The full documentation is in the manual at https://github.com/dmsc/fastbasic/blob/master/manual.md#display-list-interrupts , but here is a little sample of the DLI support, showing how to multiplex two P/M to create 4 moving two-color sprites: ' Player shapes DATA p1() BYTE = $E7,$81,$81,$E7 DATA p2() BYTE = $18,$3C,$3C,$18 ' Players horizontal positions DATA pos() BYTE = $40,$60,$80,$A0 ' Players colors DATA c1() BYTE = $28,$88,$C8,$08 DATA c2() BYTE = $2E,$80,$CE,$06 ' Our DLI writes the position and ' colors to Player 1 and Player 2 DLI SET d3 = pos INTO $D000, pos INTO $D001, DLI = c1 INTO $D012, c2 INTO $D013 ' Setup screen GRAPHICS 0 : PMGRAPHICS 2 ' Setup our 4 DLI and Players FOR I = 8 TO 20 STEP 4 POKE DPEEK(560) + I, 130 MOVE ADR(p1), PMADR(0)+I*4+5,4 MOVE ADR(p2), PMADR(1)+I*4+5,4 NEXT ' Activate DLI DLI d3 ? "Press a Key" ' Move objects! REPEAT PAUSE 0 pos(0) = pos(0) + 2 pos(1) = pos(1) + 1 pos(2) = pos(2) - 1 pos(3) = pos(3) - 2 UNTIL KEY() ' Disable DLI and ends DLI Attached is the resulting XEX, this is the resulting screen: The new release is over github, download at: https://github.com/dmsc/fastbasic/releases/tag/v4.3 Have Fun! dlitest.xex
  7. Introduction thread here: I am starting a new thread, because Meta has a new website: https://language.metaproject.frl The old links from the early development period are gone, and a few of the method names in the program examples have changed. I will post progress here now, so that the website is on top, and examples on the website, where they can be updated.
  8. Note: a new version is available over this post. Hi all As a new-year present, I released a new version of FastBasic. It's only a minor bugfix release from last one: - Fixes a bug with floating-point comparisons - Adds more usage information to the cross-compiler. - Fixes display corruption in the editor. - Allows comments after any statement. As always, the full source is over github, and you can download the release at https://github.com/dmsc/fastbasic/releases/full manual at https://github.com/dmsc/fastbasic/blob/master/manual.md and sample programs are included in the ATR or in the source at https://github.com/dmsc/fastbasic/tree/master/samples/int and https://github.com/dmsc/fastbasic/tree/master/samples/fp Over github I included the cross-compiler for Linux, Windows and macOS, but I only tested the Linux and Windows ones. For usage instructions of the cross-compiler, see at https://github.com/dmsc/fastbasic/blob/master/compiler/USAGE.md fastbasic-r2.atr
  9. since almost a year, i got really excited with a cross-compiler coded in Python that allows to make z80 binaries (z80 asm were used temporarily there in cross-compiling process) from an ansi-basic syntax very closed to zx-spectrum basic - http://www.boriel.com/software/the-zx-basic-compiler/?lang=en - http://www.boriel.com/forum - http://www.boriel.com/files/zxb/ - http://www.boriel.com/wiki/en/index.php/ZXBasic at the Boriel's wiki page, i started to add some information about Mattel Aquarius (if people know more links with very useful information, please add there too) : http://www.boriel.com/wiki/en/index.php/ZX_BASIC:Aquarius for having a version of it cross-compiling to Mattel Aquarius, we may need help from people skilled enough about how to adapt this Python code for the same purpose, and is comfortable enough to use Aquarius technical information there. what do you all think about this?
  10. here is my first attempt on creating Aquarius .rom files from Boriel's ZX-Basic Compiler - i think i'm struggling on the "scramble code" ( http://www.vdsteenov...s/romcheck.html ) or something else? the resulting .rom, the ZX-Basic sources i used, the .asm temporary file (for helping the debug process) and the .sh (bash script on Linux) for the compiling process are all there! the idea was, for now, to do a "cls" with the character 0x41 ("A") and the colour attribute 0x35 (i can't remember now which colours are), and the resulting behaviour looks weird... :S aquarius_borielszxbasiccompiler_experimentalsnippets_201306291704.zip
  11. Started using Harry Wilhelm's XB compiler (which is a great compiler) but came across a bug that most people may never come across but took me a while to figure out what was wrong. In XB you can assign a value to two or more variables with a comma. a.k.a. x=0::y=0 can be x,y=0 when i was compiling and old program the compiler kept locking up on this one line. after a while of trying everything I changed x,y=0 to x=0::y=0 on the line. turned out to be the problem and the compiler continued on. i.e. don't use commas for multiple variable definition. Just an FYI if ever you come across the same problem.
  12. probably some people here know about this: recently i started to target arcade machines using Boriel's ZX-Basic Compiler - http://www.boriel.com/wiki/en/index.php/ZX_BASIC:Released_Programs#Arcade_Systems - for now, there are only tests there - 10 machines supported up to now, and the idea is to support more 75 - this is part of an experimental research to find out which machines are better appropriate for coding games, experimental stuff, "interactive poetry", etc.
  13. Hi! There is a new version of my FastBasic interpreter available, now with optional *floating point* support. Also, I have written a full language manual, you can browse it at: https://github.com/dmsc/fastbasic/blob/fastbasic-fp/manual.md Note that the manual is also included in the disk image. The two files contain the two versions: - Integer only, currently 8633 bytes, a "?FRE()" minimal program reports 30458 bytes. - Integer and floating point, currently 9431 bytes, a "?FRE()" minimal program reports 29642 bytes. Note that FP variables end with a "%" sign, and use the OS mathpack, so FP calculations are slow. Also, you can't have two variables of different type and same name (so "var%" and "var$" are not allowed). As always, full sources are at github, see https://github.com/dmsc/fastbasic/tree/fastbasic-fpfor the floating point version and https://github.com/dmsc/fastbasic/tree/master for the integer only version. And you can compile the sources to get the cross-compiler, build from the same sources as the atari compiler. Enjoy, and report any problem! fastbasic-int-20170719.atr fastbasic-fp-20170719.atr
  14. I would like to serve this topic as a discussion on the BASIC Ten-Liners Contest, especially the two areas: 1. Removal of the FREI category this year, which I believe is unreasonable and doesn't help the contest in any way. - Because the FREI category was established the previous year, this year I have been experimenting a lot with what kind of functionality I can fit into 10 lines of hexa code (about 2.2 KB of assembler code) - I just checked my source code, and I wrote over 5,000 lines (yes, five thousand) of assembler code, figuring out the best compromise between performance&size of the code for each component of the game - It was very exciting finding out what kind of functionality (some quite surprising and unexpected) can be fit within that limit - Hence, it was quite frustrating to see the category removed - For as long as there have been magazines with BASIC listings, inlined ASM code was always integral part of the charm of BASIC - since it doesn't in any way affect the other categories, I really see no reason why it should be removed - the only thing the removal achieved was two less entries for 2019 from me (and who knows how many other people were in same situation) TLDR: It can open up a new uncharted territory of games possible in 10 lines. 2. Inclusion of Compilers (as a separate category) - if my understanding of rules is correct, the only BASICs allowed are the ones that have an editor on the target platform (e.g. you must be able to type the program on an actual Atari (or other computer)) - this would rule out the compilers that exist on PC only - because of my recent work on Lynx, 2 weeks ago I have created a PC-based 6502 compiler (by modifying my Jaguar's 68000 & GPU RISC compiler) of a high-level language that resembles C, and feeds into the cc65 linker toolchain - it would be relatively easy to change the syntax of the language to be BASIC-like - there would be no Atari-based editor or compiler, as I really see no point in creating yet-another editor. - this can however bring the increased productivity of PC-based workflow (Notepad++, Photoshop, etc.) and increase the quality of the target application that is otherwise utterly impossible to achieve by purely typing program on a physical HW TLDR: It can further push the boundary of 10-liners due to much higher execution speeds of compiled code and increased work productivity on PC. It's important we know about this by the end of November, ideally. Posting a contest announcement thread on January 31 will be definitely too late for me (as I will be busy with Jaguar in Q1, especially around March) and I'm sure others would love to know too, as for us there are only 2 options: - resume/start the ASM coding for the 10-Liners Contest - ignore the Contest altogether
  15. After 30 years of wondering I finally got around to creating a Forth compiler for the TI-99 where the top of stack (TOS) is maintained in a register. The literature said this would speed it up by about 10%. I used a DOS Forth system to create the cross-compiler to the build the TI-99 compiler so it was painful debugging both ends at the same time. (old brain hurts) I cross-compiled Brad Rodriguez's Camel Forth for the high level Forth words and wrote 105 Assembler primitives with hints here and there to the hard stuff from TI MSP430 Camel Forth and I had to look at Turbo Forth to help find a couple of gotchas with the 9900 instruction set. Sincere thanks to Willsy and Brad. Anyway the answer is in.,, kind of sort of. Using Willys's excellent and highly optimized Turbo Forth as the benchmark for excellence I did a little comparison. Turboforth uses the PAD RAM at >8300 to hold many simple code routines so they run very fast in that zero wait state memory. To even begin to come close to Turbo Forth I found out I also had to put the Forth thread interpreter there along with branching and I stuck the literal run-time routine there as well. After that the only optimizing approach I used was this TOS thing The TOS caching is a mixed blessing. For routines that take one input on the stack and produce one output like 1+ 2+ 2/ 2* @ [email protected] etc... it is about 40% faster. Very cool. For operations that take two inputs and generate one output or no output on the stack, ( ! C! + - * etc.) refilling the TOS can eat up all of the benefit on the 9900. And for operators that need to make extra space on the stack for an output, the TMS9900 needs 2 instructions so they are actually slower because you have to push the TOS register onto the stack to make room for the new thing. (DUP OVER etc.) FYI: - my empty DO/LOOP structure runs the same speed as Turbo Forth so the test is truly comparing the math operations. - Tests were run on Classi99 emulator under Windows 10 64bits (my real iron is in a box with a defective 32K memory card) Test 1 tests all the routines Turbo Forth has in PAD Ram and the others as well, so it's mixed. Test 2 is head to head TOS vs PAD RAM optimization. Test 3 is TOS vs Forth operators that have no PAD RAM optimization. We can see in test 3 the we get about 8% improvement not 10%. The surprise for me was test 2 because the speedup was not suppose to be as fast as zero wait state ram but it seems the combination of everything netted out to the same result. Weird. In many other ways Turbo Forth is still faster by virtue of hand coding so much of the internals, but this demonstrates the TOS on math operations. Now I have to stop doing this for a while. (addictions are hard to kick) PS. I noticed I did not include NIP and TUCK but that's for another day. PSS This means Turbo Forth 3.0 can be 8% faster. Just one more re-write Willsy :-) theBF HEX : OPTEST \ mixed 1000 0 \ *OPTIMIZATION METHOD* DO \ CAMEL99 Turbo Forth \ ---------------------- AAAA ( lit) \ HSRAM HSRAM DUP \ TOS HSRAM SWAP \ TOS HSRAM OVER \ TOS HSRAM ROT \ TOS -- DROP \ TOS HSRAM DUP AND \ TOS -- DUP OR \ TOS -- DUP XOR \ TOS -- 1+ \ TOS HSRAM 1- \ TOS HSRAM 2+ \ TOS HSRAM 2- \ TOS HSRAM 2* \ TOS -- 2/ \ TOS -- NEGATE \ TOS -- ABS \ TOS -- + \ TOS HSRAM 2 * \ TOS HSRAM DROP LOOP ; \ CAMEL99: 4 5 secs \ TurboForth 4.7 secs \ (Empty DO/LOOP are same speed) : OPTEST2 \ only HSRAM VS TOS 2000 0 \ *OPTIMIZATION METHOD* DO \ CAMEL99 Turbo Forth \ ---------------------- AAAA ( lit) \ HSRAM HSRAM DUP \ TOS HSRAM SWAP \ TOS HSRAM OVER \ TOS HSRAM DUP AND \ TOS HSRAM DUP OR \ TOS HSRAM 1+ \ TOS HSRAM 1- \ TOS HSRAM 2+ \ TOS HSRAM 2- \ TOS HSRAM + \ TOS HSRAM 2 * \ TOS HSRAM DROP \ TOS HSRAM DROP \ TOS HSRAM LOOP ; \ CAMEL99: 6.4 secs \ TurboForth 6.4 secs HEX : OPTEST3 \ TOS versus conventional Parameter stack 3000 0 \ *OPTIMIZATION METHOD* DO \ CAMEL99 Turbo Forth \ ---------------------- AAAA \ HSRAM HSRAM BBBB \ HSRAM HSRAM CCCC \ HSRAM HSRAM ROT \ TOS -- AND \ TOS -- OR \ TOS -- DUP XOR \ TOS -- 2* \ TOS -- 2/ \ TOS -- NEGATE \ TOS -- ABS \ TOS -- DROP \ TOS -- LOOP ; \ CAMEL99: 7.5 secs \ TurboForth 8.13 secs
  16. Hi all! A new release of FastBasic is available, this is Release 3. This release has with many enhancements, mayor ones: - Added string comparison operators, - Interpreter is about 3% faster in FOR loops and other simple operations. SIEVE benchmark now takes 17 seconds. - The integer-only IDE is now less than 8KB, the floating point IDE is 9.2kB, and there are 200 bytes more available for the programs. - Cross compiler produces smaller executables by only including used parts of the runtime, a simple '? "Hello"' compiles to 453 bytes, including the interpreter and runtime. Minor improvements to the IDE and language: - The IDE now can edit files with lines of up to 255 bytes. - The IDE is a little faster to parse large files. - More abbreviations to the statements, The list of abbreviations is in the manual. Mayor improvements to the cross-compiler and optimizer: - New scripts for the cross-compilers allows passing options to the compiler and linker, also writes label files for debugging. - Cross compiler gives better errors in many cases. - Optimizer for NEG/MUL/DIV/MOD and all bitwise operations. - Optimizer ignores comments and can span multiple lines. - Adds tail-call optimizations (replaces CALL/RET with JUMP and JUMP to RET with RET) And many fixes: - Optimizer no longer ignores negative numbers, - Correct corner cases with MOVE / -MOVE, updates docs. - Cleanup all variables and arrays on run, fixes on memory-clearing function. - Fixes some cases of integer to floating point comparisons. - Fixes parsing of NOT with parenthesis and NOT/NOT. - Fixes errors on line numbers > 255 in the IDE. - Fixes some corner cases in the IDE editor with lines at top/bottom of screen. - Parsing of statements after a ':' ignored errors. As always, full sources and binaries for Atari, Linux, Windows and MacOS are available over Github: https://github.com/dmsc/fastbasic/releases Have fun! Edit: current version is v4, announcement at https://atariage.com/forums/topic/288617-fastbasic-40-tenliners19-release/
  17. I had a question from a work colleague that I couldn't answer, he wanted to know how the BASIC interpreter compiles and executes the code, ie is it just in time or compiles it then executes. As theres no perceivable delay on RUN, I wasnt sure, i thought it tokenized it as you entered each line. Given memory and CPU limitations compiling separate code on RUN seemed wrong, but i have no idea.
  18. I have given the compiler the name AtaC(Atari C, Pronounced Attack). Any other suggestions? I'm making a new Atari 2600 compiler for a custom C-like language(in C89). It is being created to be efficient but also to hide multi-frame calculations from the programmer(it will notify the programmer, however, if multi-frame calculation is needed), as well as be more readable than assembler. I am currently developing the assembler, and development on AtaC has been paused until it is finished. Here's the GitHub page if you want to watch me develop that mess All examples and syntax specifications have been removed(on accident, to an extent). I will come up with those tomorrow.
  19. UPDATE: There is now a new version at: Hi all! To start the new year, and to provide a better Basic for all the new ten-liners, I'm releasing version 4.0 of FastBasic. The major changes in this version are under the hood: The interpreter has been changed from a stack-base virtual machine to a register plus stack, this makes the interpreter from 10% to 20% faster depending in the program. In the SIEVE.BAS benchmark, the Atari version is 13% faster and in the cross-compiler is 19% faster, but programs depending on fast PEEK and POKE should be much faster. There is now a full test-suite to automatically catch regressions in the parser and interpreter, ensuring that bugs don't re-appear. Also, there are some user visible changes: There is now a command-line compiler "FBC.COM", this allows compiling large programs that don't fit in the full editor. Currently, "FBC" accepts the full floating-point syntax. Added minimal support for Player/Missile graphics: PMGRAPHICS (abbreviated PM.) statements setups P/M, PMHMOVE (abbreviated PMH.) horizontal moving a a player/missile, PMADR() returns the address of the given player/missile data. Many small bugs fixed. In this version the integer IDE is 8188 bytes in size (we still have 4 bytes less than 8K), and the floating-point IDE is 9405 bytes. As always, full sources and binaries for Atari, Linux, Windows and MacOS are available over Github: https://github.com/dmsc/fastbasic/releases
  20. Hello, This project is a visual tool for making visual novels for the Sega 32X. It uses Blockly as a visual editor; the design is then used to generate a C file, which is then compiled into a playable Sega 32X ROM. https://www.youtube.com/watch?v=dh5M_RHXBfg The current release is version 0.4.0 GitHub page: https://github.com/haroldo-ok/BlocklyVN32X Topic on SpritesMind: http://gendev.spritesmind.net/forum/viewtopic.php?f=4&t=2409
  21. Hello, I am happy to annouce this new release of MLC that was harder to develop as there is no F18A emulator... So I had to run between the living room and the old-compurter room with my CF card to test the software. Thanks a lot to Matthew for his patience and fast replies. Now MLC gives access to the GPU (TMS990 coprocessor) with intructions: $GPU section to define the assembly code GPURUN adr GPUWAKE GPUSLEEP GPUSTATE Access to the BitMap layer with instructions: BMLSET m adr BMLPLOT x y c BMLDRAWTO x y c BMLFILLRECT w h Access to the timer with instruction TIMER options options can be: CLEAR, READ, SUM, TOFLOAT RESET, RUN, LOAD, INC MLC with DSK images and full PDF english manual, (some videos too) can be downloaded here: (english) http://gtello.pagesp...ge.fr/mlc_e.htm (français) http://gtello.pagesp...ge.fr/mlc_f.htm Some pictures for the F18A installation here: (english) http://gtello.pagesp...e.fr/ti99_e.htm (français) http://gtello.pagesp...e.fr/ti99_f.htm Guillaume. :
  22. Hi everyone. After a slight pause finally I was able to implement the SCROLL and BORDER statements in IntyBASIC , also path selection for libraries using a command-line argument. Documentation was added to manual and also SCROLL.BAS to show how to use it. The libraries are slightly accelerated with DZ-Jay contributions and some parts of scrolling code were contributed by intvnut. Myself I've a hard time getting scroll upwards to work without flicker, but it now is fine. Looking forward to a test in real hardware of scroll routines. For the newcomers, IntyBASIC is an integer BASIC language cross-compiler for Intellivision that helps greatly to ease game writing. The original IntyBASIC thread is here http://atariage.com/forums/topic/221362-intybasic-compiler/ but I had to start a new one because I cannot edit further the original. Platforms supported: Wind*ws, Mac OS X (32/64 bits) and Linux. Edit: Mar/03/2014. Now added IntyBASIC v0.6 with CONST statement, also corrects a bug in FOR STEP, and added sample for MOB use in SCROLL.BAS intybasic_compiler_v0.5.zip intybasic_compiler_v0.6.zip
  23. Not sure if it is a present but here's gcc for your Ataris - happy coding! http://d-bug.mooo.com/beyondbrown/post/gcc-6/
  24. Hi all! I have a new beta (test) version of the next FastBasic release (4.4), I need your help testing the IDE - specially the editor, as it has many changes under the hood to make it smaller. The changes in this version are: - Adds BREAK key handling to the IDE - this was long overdue, now you can press BREAK key to return to the IDE from your program. - Adds COPY/PASTE to the editor, you need to press CONTROL-M to "mark" a line in the editor, then when you press CONTROL-C that line is copied after the current one. Pressing CONTROL-C multiple times copies multiple lines. Changes to the language: - Adds "CLR" statement, that un-dimension arrays and sets all variables to 0. Changes to the cross-compiler: - Allows to compile to code that can be put in a cartridge - by removing all uses of self-modifying-code and adding a stub to copy the zeropage interpreter from ROM to RAM at startup. - Allows accessing to DATA's from external assembly files. - The CC65 tools are included in the distribution, you don't need to install CC65 to use the cross-compiler anymore. Have Fun! EDIT: See newer beta version at: fastbasic-v4.4-beta-macosx.zip fastbasic-v4.4-beta-win32.zip fastbasic-v4.4-beta.atr fastbasic-v4.4-beta-linux64.zip
  25. Hi! Over the last months I have been writing a new Basic interpreter for the Atari 8-bit computers. My goals are: - Integer variables - Small size (currently less than 6k) - Fast execution (currently, about 15% faster than compiled TurboBasicXL in the "sieve.bas" benchmark) - Modern (no line numbers, many control structures) - "alike" TruboBasicXL. Attached is my current "beta" release. What is missing is an editor, currently it only runs text programs from disk, and possibly more commands. Also, parsing speed is slow, main reason is that the file is read a line at a time, if the file were read from memory the parser would be a lot faster. I ported one of my ten-liners to the interpreter, and included some demonstration programs. Well, bug reports and new ideas are welcomed ----- cheat sheet ----- All statements and variable names can be lower or uppercase, the parser is case insensitive. No line numbers are allowed. Supported integer operators, in order of precedence: + - : addition, subtraction * / MOD : multiplication, division, modulus & ! EXOR : binary AND, OR and EXOR + - : unary "+" and "-" Supported functions: TIME : time in jiffies ABS(N) SGN(N) PEEK(N) PADDLE(N) PTRIG(N) STICK(N) STRIG(N) RAND(N) : random from 0 to N DPEEK(N) FRE() : free memory ERR() : last I/O error ADR(array) : address of array in memory ADR(string) LEN(string) VAL(string) ASC(string) Supported boolean operators, in order of precedence: OR : Logical OR AND : Logical AND NOT : Logical NOT <= >= <> < > = : Integer comparison Strings: String variables don't need DIM, are of max 255 bytes length. String constants can have embedded " by duplicating (" my string ""hello"" ") Arrays: Arrays must be DIM before use. After array name, you can specify "WORD" or "BYTE" to give a type. DIM Array1(10) Word, SmallArray(32) Byte Variables: Variables are always INT (from -32768 to 32767), must be assigned before use. Statements: ' : Comment (REM) . : Comment (REM) ? : PRINT BGET # BPUT # CLOSE # COLOR DIM DO / LOOP DPOKE DRAWTO END : Terminates parsing, go to command mode EXEC EXIT : Exits from DO, REPEAT, WHILE or FOR FILLTO FOR / TO / NEXT FOR / TO / STEP / NEXT GET : Get from Keyboard GET # GRAPHICS IF / ELSE / ENDIF IF / THEN INC INPUT MOVE / -MOVE OPEN # PAUSE PLOT POKE POSITION PRINT PROC / ENDPROC PUT : Put to E: PUT # REPEAT / UNTIL SETCOLOR SOUND : With no parameters silences all sounds. WHILE / WEND XIO # fastbas.atr
  • Create New...