unwiredben / my_basic

Lightweight BASIC interpreter written in standard C in dual files. Aimed to be embeddable, extendable and portable.

 _____ __ __     _____ _____ _____ _____ _____ 
|     |  |  |___| __  |  _  |   __|     |     |
| | | |_   _|___| __ -|     |__   |-   -|   --|
|_|_|_| |_|     |_____|__|__|_____|_____|_____|

Copyright (C) 2011 - 2019 Wang Renxin

Web playground

Contents

• Introduction
• Main features
• BASIC at a glance
• Installation
• Interpreter workflow diagram
• Wiki
• Donate

Introduction

MY-BASIC is a lightweight BASIC interpreter written in standard C in dual files. It's aimed to be embeddable, extendable and portable. It is a dynamic typed programming language, reserves structured syntax, supports a style of prototype-based programming (OOP), also implements a functional paradigm by lambda abstraction. The core is written in a C source file and an associated header file. It's easy to either use it as a standalone interpreter or embed it with existing projects in C, C++, Java, Objective-C, Swift, C#, etc. and totally customizable by adding your own scripting interfaces.

Main features

MY-BASIC offers a wide range of features including:

• Written in standard C, source code is portable to a dozen of platforms
• Lightweight (within less than 128KB footprint), fast, and configurable
• With both retro and modern BASIC syntax
• Case-insensitive tokenization, and many other indelible BASIC flavour
• Unicode support
• Prototype-based programming, with reflection support
• Lambda abstraction enhanced functional programming
• Customizable referenced/non-referenced usertype
• Collection construction and manipulation functions for LIST and DICT
• Automatic releasing for referenced values (prototype, lambda, referenced usertype, list, dictionary, etc.) benefited from reference counting and garbage collection
• Common numeric and string functions
• Structured sub routine definition with the DEF/ENDDEF statements
• Structured IF/THEN/ELSEIF/ELSE/ENDIF
• Structured FOR/TO/STEP/NEXT, FOR/IN/NEXT, WHILE/WEND, DO/UNTIL
• Reserved retro GOTO, GOSUB/RETURN
• Importing multiple source files with the IMPORT statement
• Debug API
• Customizable memory pool
• Easy API, for extending new BASIC functions
• Easy interacting BASIC facilities at native side, and vice versa
• More features under development

Get BASIC8 - the fantasy computer powered by MY-BASIC - on Steam for game and other program development in an integrated environment.

See awesome user creations.

BASIC at a glance

A "Hello World" convention in MY-BASIC:

input "What is your name: ", n$

def greeting(a, b)
	return a + " " + b + " by " + n$ + "."
enddef

print greeting("Hello", "world");

Read the MY-BASIC Quick Reference to get details about how to program in MY-BASIC.

Installation

Using standalone interpreter binary

This repository contains precompiled binaries for Windows and macOS, the easiest way is to download to get a direct playground. Or you can make a build by:

• Using the Visual Studio workspace my_basic.sln on Windows to build an executable
• Using the Xcode workspace my_basic_mac.xcodeproj on macOS to build an executable
• Using the makefile on *nix OS to build an executable

Follow these steps to compile an interpreter binary manually for any platform:

1. Retrieve everything under the core and shell folders for a minimum build
2. Setup your toolchain for compiling and linking
3. Compile core/my_basic.c and shell/main.c, with both including core/my_basic.h; then link up an executable

The standalone interpreter supports three running modes:

• Execute the binary without arguments to use the interactive mode
  • Type "HELP" and hint Enter to get usages of it
• Pass a file to the binary to load and run that BASIC source code
• Pass an argument -e followed with an expression to evaluate and print instantly as a simple calculator, eg. -e "2 * (3 + 4)"

Combining with existing projects

Just copy core/my_basic.c and core/my_basic.h to your project and add them to the build configuration. You can link with MY-BASIC as a lib as well.

For details about using MY-BASIC after integration, see MY-BASIC Quick Reference and read the Wiki pages.

Interpreter workflow diagram

It's recommended to know the basic principle of MY-BASIC before customizing; nothing's better than a workflow diagram to get a first image.

A simple setup as follow:

#include "my_basic.h"

int main() {
	struct mb_interpreter_t* bas = NULL;

	mb_init();
	mb_open(&bas);
	mb_load_string(bas, "print 22 / 7;", true);
	mb_run(bas, true);
	mb_close(&bas);
	mb_dispose();

	return 0;
}

Wiki

The manual explains most of the fundamental topics, however it doesn't cover everything; read the Wiki as supplement instructions, such as machinism behind MY-BASIC, efficient practice, etc:

• Principles
  • Passes
  • Interpreter workflow diagram
  • How lambda works
• Coding
  • Using Unicode
  • Importing another file
  • Module (namespace)
  • Sub routine
  • Lambda abstraction
  • Structured exception handling
  • Multiple condition
• Data types
  • Collection manipulation
  • Manipulating an array
  • Automatic memory management
  • Using usertype values
  • Using prototype-based class
  • Defining a class in C
  • Meta methods
  • Overriding operators
  • Overriding functions
  • Using iterators
• Standalone shell
  • Extra functions
• Integration
  • Linking with MY-BASIC
  • Writing a debugger
  • Callback
  • Interop with C#
• Customization
  • Customizing macros
  • Customizing a memory allocator
  • Redirecting PRINT and INPUT
  • Redefining int_t and real_t
  • Converting between string and real
  • Customizing an importer
• More scripting API
  • String matching module
  • String manipulation module
  • File module
  • Inline data sequence module
  • Bit operation module
  • Miscellaneous module
  • Stack module
• FAQ
  • Is it possible to introduce another feature

Donate

List of donors.

Consider supporting MY-BASIC development with a donation if you like this project.

One-off donation via PayPal.