AQB: A BASIC Compiler and IDE for Amiga Computers

About

• Project Scope
• Requirements
• Installation
• Benchmark Results
• Source Code
• Authors

Command Reference

• Reference: Core
• Reference: Amiga specific commands
• Reference: IFFSupport
• Reference: AnimSupport

AQB Programming Language

• Type System
• Module System and Runtime
• Code Generation and Target Systems
• Interrupting / break handling in AQB programs

Amiga OS System Programming in AQB

• Introduction
• Reference: OSUtility

IDE

• Keyboard shortcuts

Project Scope

An experiment in alternate history: what AmigaBASIC could have looked like, had it been developed further tailored to the Amiga OS.

What AQB is not: AQB does not try to be a clone of any particular BASIC dialect - neither QuickBASIC, FreeBASIC or VisualBASIC nor any particular Amiga specific BASIC implementation like AmigaBASIC, ACE, HiSoft, GFA, Blitz or AMOS. While it strives to be as compatible as possible with the Microsoft BASIC family of languages (and certainly has many QuickBASIC traits) the primary focus is on the creation of a modern, clean, Amiga OS-compliant, future-proof BASIC that is tailored towards modern Amiga application development.

To be more specific, FreeBASIC is the source of many core AQB language constructs (in many respects AQB can be considered a subset of FreeBASIC) with inspiration for Amiga specific commands mainly from AmigaBASIC, ACE and HiSoft. Main target is Amiga OS compliant application development.

Improvements over AmigaBASIC include:

• Advanced type system (including UDTs and Pointers, see below)
• Support for non-static functions and subs (enables recursion)
• Module support (similar to UNITs in TurboPascal, with full type safety and dependencies)
• Modern syntax inspired by FreeBASIC and VisualBASIC
• True native 68k compiler
• Integrated IDE besides compiler command line interface with
  • syntax highlighting
  • auto-indent
  • folding support
  • source level debugging

Requirements

• 3 MB RAM
• OS 3.1 (V39) or newer

Installation

Download a release LHA archive (https://github.com/gooofy/aqb/releases) and unpack it wherever you like, keep the directory structure intact.

AQB should run from this point on without the need for further installation, but for convenience add a "AQB:" assign to your S:user-startup file, e.g.

;BEGIN AQB
Assign AQB: "sys:Apps/AQB"
;END AQB

Type System

Basic types:

• Byte, UByte (8 bits)
• Integer, UInteger (16 bits)
• Long, ULong (32 bits)
• Single (32 Bit FFP floats)
• Boolean (8 bits)

Advanced types

• Static (C-like, fast) and dynamic (runtime bounds checking) arrays
• UDTs (structs)
• OOP (FreeBASIC like)
• Pointers (C-like, including function/sub pointers)
• Strings (0-terminated pointers to UByte, C-compatible)

Module System and Runtime

AQB tries to keep the set of commands that are built into the compiler to a minimum and relies on its quite powerful module system to provide most of the commands as part of the runtime system. This means that while the default runtime strives to implement a modern QuickBASIC like dialect tailored to the Amiga, it is quite possible to implement alternative runtime modules that could provide AQB with a different "personality", e.g. one that is closer to AmigaBASIC or GFA BASIC or even languages like BlitzBasic or AMOS.

The goal for AQB's default runtime is to provide a rich set of commands covering typical Amiga OS programming topics like GUI programming, multitasking, graphics and audio combined with resource tracking and error/exception handling. Future plans might also include an automated garbage collector to make memory allocation easier and safer.

AQB is fully link-compatible with the Amiga 68k GCC compiler which means that AQB modules can be implemented in C as well as BASIC (one could even mix these languages within one module, i.e. implement some subprograms in C while others in BASIC).

Intuition / Exec event handling

Since the default runtime wants to enable OS friendly programming no busy waiting is used. Therefore the SLEEP command is used to process pending events, i.e. you will need to call SLEEP regularly in your program, typically form a main loop that could look like this:

WHILE running
    SLEEP
WEND

For event processing you register subroutines using the ON ... CALL