jockm/my_basic

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

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

Copyright (C) 2011 - 2018 Wang Renxin. All rights reserved.

开发日志

Contents

• Introduction
• Main features
• BASIC at a glance
• Awesome
• Installation
• Interpreter workflow diagram
• Wiki
• References
• Donate/List of donors

Introduction

MY-BASIC is a lightweight BASIC interpreter written in standard C, with only dual files. It is a dynamic typed programming language, and aimed to be embeddable, extendable and portable. MY-BASIC supports structured syntax; implements a style of OOP called prototype-based programming paradigm; and it offers a functional programming ability with lambda abstraction. The kernel is written with a C source file and an associated header file. It's easy to either embed it or use it as a standalone interpreter. You can get how to use it and how to add new scripting interfaces in five minutes. It's possible to combine MY-BASIC with existing projects in C, C++, Java, Objective-C, Swift, C# and many other languages. Script driven can make your projects configurable, scalable and elegant. It's also possible to learn how to build an interpreter from scratch with MY-BASIC, or build your own dialect based on it.

The prefix "MY-" in the name means either literally "My" or "Make Your".

Main features

MY-BASIC is a dynamic typed programming language with BASIC syntax and has a very dynamic nature; it makes it flexible and easy to use. MY-BASIC offers a wide range of features including:

• It is totally free to use MY-BASIC for commercial or noncommercial purposes under the MIT license
• Written in clean 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 feelings
• Unicode support
• Prototype-based programming (OOP) paradigm, with reflection support
• Lambda abstraction enhanced functional programming
• Customizable referenced usertype
• Collection construction and manipulation functions for LIST and DICT
• Automatic releasing of referenced objects (prototype, lambda, referenced usertype, list, dictionary, etc.) benefited from Reference Counting and Garbage Collection
• Dynamic typed integer, real, string, boolean, usertype, and other advanced types with array support
• Standard numeric functions, and standard string functions
• Importing multiple source files with the IMPORT statement
• 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
• Debug API
• Customizable memory pool
• High expansibility, easy to use API, easy to extend new BASIC functions
• Powerful interactive ability to manipulate BASIC facilities at native side; or to use native functionalities in BASIC
• More features under development

I write some of my plans in the language design page.

Get BASIC8 on Steam; a fantasy computer for game and other program development powered by MY-BASIC!

BASIC at a glance

Come along with 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 (especially the "Programming with BASIC" section) to get more details about how to program in MY-BASIC.

Awesome

See the list for some user creations.

• Awesome projects powered by MY-BASIC

Don't forget to share with us about your creativity!

Installation

Using standalone interpreter binary

This repository contains precompiled binaries for Windows and macOS, the easiest way is to download one of them to get a playground. Or you could make a build as follow:

• Open the Visual Studio solution my_basic.sln on Windows to build an executable
• Open the Xcode solution my_basic_mac.xcodeproj on macOS to build a macOS executable
• If you are using other *nix OS, use the makefile with a "make" toolchain to build an interpreter binary according to your specific platform

To compile an interpreter binary for your own platform manually, please follow these steps:

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

The standalone interpreter supports three running modes:

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

Combining with existing projects

MY-BASIC is cleanly written in a single C source file and an associated header file. Just copy core/my_basic.c and core/my_basic.h to the folder of your project and add them to a build configuration.

You can definitely link with MY-BASIC as a lib as well.

For more details about using MY-BASIC when it has been integrated with a project, see MY-BASIC Quick Reference or read the Wiki pages.

Interpreter workflow diagram

It's necessary to know some principle of MY-BASIC before doing deep customization; nothing's better than a workflow diagram to get a first image.

A simplest setup as follow:

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 MY-BASIC Quick Reference includes most of the fundamental topics, however, it hasn't covered everything, such as the design principle, machinism behind MY-BASIC, efficient practice, etc; some of these topics are mentioned in the Wiki:

• Principles
  • Language design
  • How lambda works
  • Passes
  • Interpreter workflow diagram
• Code with MY-BASIC
  • Using Unicode
  • Importing another file
  • Module (namespace)
  • Sub routine
  • Lambda abstraction
  • Structured exception handling
  • Multiple condition
• Understanding data type system in MY-BASIC
  • 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

References

• BASIC - Wikipedia
• Prototype-based programming - Wikipedia
• Lambda abstraction - Wikipedia

Donate/List of donors

I need your supports to keep this project alive. Consider supporting MY-BASIC development with a donation.

One-off donation via PayPal.

List of donors.