Bbe doc downloadable

Bellbase is a programming language created by User:PixelatedStarfish in 2022 and it is designed to be a simple, practical language for learning to program. Given this, showcasing this language on the esolangs wiki is certainly ironic, but the esolangs wiki is convenient.

Bellbase was initially created as a second major version of MacroBeep, designed to support subroutines. MacroBeep v2.0 diverged to the point where it was best renamed, as a new language entirely.

The current version is version 1.2 and the language file extension is .bbe

Design Goals: Why Use Bellbase?

This language is designed to learn by tinkering. It is designed for students to practice essential programming skills, such as tracing, debugging, and memory management.

Someone can learn to code with any programming language, but few are designed for learning, and fewer still are designed for an adult learner. Why is transitioning from a graphical, block-based language, to a text-based one so hard? Well, there are constructs and conventions to memorize. There might even be three different kinds of grouping symbols: (parentheses), [brackets], {braces}. A new programmer has a lot of questions. How do I install this? Which version am I using? How do I do this or that? What is this thing again? What does this error mean? Bellbase is designed to ensure a new programmer can stop stressing, and focus on expressing their programs in code.

Bellbase has a simplified syntax, for programs that are easier to write, organize, trace, and debug.
Lexemes are descriptive, such that the tokens they represent are clearly indicated.
Memory is always bound to function calls, which eliminates confusing design patterns while maintaining usability.

Factors in Design

Always write the simplest code you can. Never implement a complicated algorithm when a simple one will do.

On Languages Designed for Pedagogy: Thoughts on Stacking Blocks

Many languages with a pedagogical design philosophy are written for children. Such languages typically employ a form of graphics based coding in specialized IDEs (Integrated Development Environments) in which programming is accomplished by clicking and dragging colorful blocks. These blocks have statements written on them and fit together like puzzle pieces. In general, I believe these languages are a success. A child can enjoy programming a video game, or an animated story without dealing with abstract data structures and advanced concepts in object oriented programming. Instinctively, one can learn how to read source code and debug it; how to use loops, variables, and conditional statements. Then it comes time to get bolder, try out some data structures. Code gets long, hundreds, or even thousands of blocks long. The IDE starts to slow and lag. The programmer hits a ceiling, and it comes time to transition to a more efficient language, one that describes source with efficient, computer-friendly text. That is the hard part.

Most high-level languages are not based on stacking colorful blocks. They have keywords instead. In a language like Scratch, blocks are commands, or arguments for commands. Even when a block is completely isolated from your program, you can click on it and watch it do something. A cat goes left. A variable is set. A list is emptied. Not all keywords have this property. Many keywords modify groups of statements (which are also called blocks and opened and closed with braces. I call them groups here to avoid confusion.) The if keyword makes this block an if statement. The fn keyword means this group is a function. The private keyword modifies the fn keyword, indicating this function cannot be accessed outside the encapsulating class. Keywords can express abstract syntax, but many do not constitute a serviceable program in isolation. They do not do anything without context. This is one of a few factors that makes transitioning from Scratch to a C-style language hard.

Bellbase commands are designed to be at a halfway point between Scratch blocks and C-style keywords. Most commands are programs that operate independent of other commands, in a manner similar to a Scratch block, or a function. However, Bellbase commands are also versatile enough to describe functions, macros, and data structures, in a manner similar to a C-style language.

Clarity: Why no Braces?

Many people like braces. from future import __braces__ is a joke among python programmers. Yes, braces are great for delineating blocks of statements, but they are easily disorganized and do not describe the blocks well. Consider this, often found at the end of a source file:

}
  }}
}

What are they enclosing? Which opening braces do they close? How does deleting one effect source? Nothing is clear about this syntax, a comment is needed for each brace. Something more descriptive is possible:

struct @foo
 #statements
_struct

Even if _struct is the only statement shown, it is still clear that it describes the end of a struct.

Influences: Shameless Theft

Structs, Macros, and Includes come from C.
The command syntax comes from assembly languages like ARM, and block-based languages like Scratch.
The call trace and data types are adapted from Java (and ultimately, C).
The format for error messages is adapted from Python.
Clojure influenced the syntax of functions, such that functions are first class, rather than second class.
BASIC, of course.

Acknowledgements

Thank you to the Skidmore College faculty, O'Connell, Dufour, Eckmann, Read, Reiley, and Prasad. I am glad to have my degree in computer science! I would also like to thank Bringas, Kravsky, and Lee for their tutelage, patience, and inspiration. Bellbase would not exist without the esolangs wiki and the work of youtuber User:Truttle1.

Thanks to User:Gapples2 for their questions, comments, and insights. This language is better for them.

Of course I should thank my loved ones for their support.

Program Examples

Hello World

Outputs “Hello World” to the console.

func @main
 out "Hello World" 
 return

Truth Machine

A problem by User:Keymaker to demonstrate usability. It takes a 0 or a 1. If it gets a 1 it outputs an endless sequence of ones. Otherwise it prints 0.

func @main
 int @c (:input "int")
 beq &c 0 Terminate
 label @Forever
  out 1
  goto Forever
 label @Terminate
  out 0
 return

Cat (Echo)

Outputs the input given.

func @main
 out "Feed the cat\n" 
 out (:input "string")
 return

FizzBuzz

include lib/Math/Ops.bbe 

func @main
 char @c
 int @i 0
 label @loop
  beq ((:mod &i 15) 0) FizzBuzz
  beq ((:mod &i 5) 0) Buzz
  beq ((:mod &i 3) 0) Fizz
 goto nonCase

 label @Fizz
  out "Fizz\n" 
 goto loopEnd 

 label @Buzz
  out "Buzz\n" 
 goto loopEnd

 label @FizzBuzz
  out "FizzBuzz\n" 
 goto loopEnd

 label @nonCase
  out &i
  out "\n"

 label @loopEnd
  give &i 1
  bleq &i 100 loop 
 return

Syntax

Statements

Statements are a single line of code that are interpreted to run a program. Each statement starts with a command, which can take arguments. The arguments for a command can be separated by tabs or spaces. A command can also have arbitrary spaces and tabs before it.

command arg1 arg2 arg3 #etc

Comments

Comments are not interpreted; they are for programmers, not computers. Comments are indicated with hashes.

#inline comment

##
Multiple
Line
Comment
##

When writing a comment, it is better to explain why the code is there, not what it is for.

Blocks

Some commands define blocks of code that group multiple statements together. Here is an example of a data structure with attributes:

struct @foo
 int @a
 string @b
_struct

Any command that defines a block has a corresponding block ender, which is the starting command preceded by an underscore. The struct block ends with _struct. macro ends with _macro and a func can end with _func although it is more common to end a function with return.

Blocks cannot nest, nesting blocks throws an error.

Argument Tokens

A command can take a few different tokens as arguments:

An IDENTIFIER identifies something. It is used to create a variable, function, or struct.
A FUNCTION CALL is a function name preceded by a colon. This call can be passed to a function, returned by a function, or evaluated.
FUNCTIONS are data and references can be made to them.
A VAR is an argument that refers to a cell with the refer operator (&). Any sequence of refer operators followed by an integer is a VAR.
A VALUE is any token that can be stored in a variable. These can be NUMBERS (longs, ints, floats, doubles, chars); COLLECTIONS (strings lists, and words); or STRUCTS (a data type defined in source.)
A LIST is a data type that can store values of multiple types. LISTS are COMPLEX COLLECTIONS, so are STRUCTS and FUNCTIONS.
A STRING is a sequence of printable characters framed by double quotes. Each string is one argument, even if it includes spaces. A STRING is a SIMPLE COLLECTION, because it can only store data of one type, characters.
LABELS organize source code.
PATHS point to files.
WORDS are the untyped argument. Every argument is a WORD.

Token Order

In a statement, tokens take the following order from left to right:

Commands
Identifiers
Function Calls
Variables and Structs
Numbers
Strings
Lists
Labels
Paths

Parentheses and Brackets

(parentheses) and [brackets] are useful for grouping tokens together, but they serve distinct functions in code:

Parentheses group calls, and the arguments those calls take together.
Brackets group arguments into a list.

To demonstrate syntactic distinction, let :foo be an arbitrary function that does the following:

When given a number argument, add 10 to that and return the result.
Otherwise, return 0.

Compare these two lines:

(:foo 10)
[:foo 10]

The top line is a call, and it evaluates to 20. The bottom one is a list, and it evaluates to [0 10]. An argument is accepted by the function on the top line, but not the bottom one.

Useful Operators

Some operators appear in multiple tables.

Argument Specifiers
Operation	Name	Desc.
`&`	Refer	Refers to a variable.
`:`	Call Passing	Call Passing; Passes a function call as an argument.
`@`	Identifying Operator	For naming data.
`"`	Quote	Frames a String.
`(`	Open Parenthesis	Starts a parenthetical grouping, which evaluates first.
`)`	Close Parenthesis	Close Parenthesis; Closes a parenthetical grouping.
`[`	Open Bracket	Open list.
`]`	Close Bracket	Close list.
`!`	Bang	Macro operator.
`#`	Hash	Starts inline comment. Everything to the right is a comment.

Compiler Operators
Operation	Name	Desc.
`*`	Star	Gets the contents of a directory and load files into the linker.
`->`	Right Arrow	This is substituted with the path from bbe to the current file.
`/`	Subdirectory Delimiter	Extends path to a subdirectory.
`!`	Bang	Macro operator.

Lexical Operators
Operation	Name	Desc.
\n	Newline Character (ASCII)	Terminates a command or inline comment.
`;`	Semicolon	Explicit newline, equivalent to a newline.
`\`	Escape	Begins an escape sequence, which can represent newlines (\n), and tabs (\t).
`.`	Dot	Accesses library functions and structure attributes. (This is not a decimal point.)
`_`	Underscore	When a command begins with this operator, a block of statements ends.
`#`	Hash	Start inline comment. Everything to the right is a comment.
`##`	Double Hash	Frames a multiple line comment.

Grammar in EBNF

Program := Header, Body
Header := {Include}, {(Macro | Struct)}
Body := {Func}
Macro := 'macro', Sp, Word, Lt | 'macro', {Statements}, '_macro', Lt
Struct := Stead, {Stine}, '_struct', Lt
Func := Fi, {Statement}, Re
Fi := 'func', Identifier, Lt
Re := ('return' | '_func'), {Arg}, Lt
Stead := 'struct' Identifier, Lt
Stine := Command, Identifier, Lt
Statement := Command, {Arg}, Lt
Command := {Sp}, Word, Sp
Arg := {(Number | Var | String | Identifier | Call | Word), Sp}
Call := ':', Word {'.', Word}
Var := (And, Word) | (Var '(', Var, ')') | (Var '(', Integer, ')') | Var, '.', Word
Identifier := '@', Words
Number := any number
Integer := any integer
Word := any set of non-white space characters
String := ' " ', (Word | Sp | Tab), ' " '
And := '&'
Sp := ' ', {' '}, Tab
Tab := a tab character
Lt := a newline char | ';' | '#'
Comment '#', {Word, Sp} | '##', {Word | Sp | Lt}, '##'

Key:
:= assignment, equivalence
| or
(group)
{repeated zero or more times}
[optional]
'string literal'
symbol
, symbol concatenation
; symbol terminator
(*comment*)

Variables

Data Types

Bellbase stores data with variables. The following types are usable:

Types
Type	Desc.	Range
`int`	A four byte integer.	-2,147,483,648 to 2,147,483,647
`float`	A four byte value with a decimal point.	3.4E +/- 38 (7 digits)
`double`	An eight byte value with a decimal point.	1.7E +/- 308 (15 digits)
`long`	A type of eight bytes.	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
`char`	A printable character, of one byte.	0 to 255
`string`	A printable string in quotes.	none
`list`	An array or list of items in brackets. Items can be of any type.	none
`path`	A path to a file.	none
`func`	A function, passed by reference.	none

A programmer can define their own types with structures.

Declaring Variables: The Refer Operator `&`

Each type is a command. These commands can take a name and a value. The latter of which initializes the variable. All variables are referred to with ampersands. These are called refer operators, or refers.

Examples:

#use an identifier to create a var and a refer to refer to the var
int @i 20 
string @s "Hello"

# &i is 20
# &s is "Hello"

A variable's type cannot change after declaration, and two variables cannot have the same name. An uninitialized variable is 0 by default, including collections like strings, lists, and structures.

Null Data

0, the number, and null (no data here) are equivalent in this language. A variable of any type can be set to 0.

When a collection is null, it cannot have indexes; a null collection is distinct from an empty collection. When a structure is null it cannot have attributes; a null structure is distinct from a structure that has null attributes.

Assignment

Assignment, or setting a variable to a value, can be accomplished at initialization (shown above) or via the set command. Variables can be assigned values of their own type, but not values of a different type without casting.

set &i 21 
# &i is now 21

Casting

Numbers can be cast to other numbers, but collections cannot be cast to other collections.

Suppose a float is declared:

float @f 0

To cast it to an int, let the int command take the variable &f. In this example, an integer is increased by the floor of f:

int @i
give &i (:int &f)

Casting with collections gives an unexpected type error.

Constants

In this line, a variable is set to a constant.

const &i #&i is now a constant

This variable cannot be modified after this point. It will have the same value for the duration of its life, and trying to modify it throws an error. If this variable is a structure with attributes, the attributes are also constants.

Lists, Indexing, and Nesting

Lists are divided into items. Each item in a list has an index. The leftmost index is 0. Each index refers to a variable in the list.

list @b [10 "Hello" 6.28]
# &b[0] is 10, &b[1] is "Hello"

Lists can contain other lists to arbitrary depth. Indexes can also be nested to arbitrary depth.

list @b [10 [23 32] 34] # &b[1][1] is 32

Syntactically, indexes are variables and should be interpreted as such. Referring to an index that does not exist gives a bad reference error.

Strings and Escapes

Strings are interpreted literally, as text. A string is framed by quotes and can include white space. A string is always one argument, even one with spaces in it.

For example, consider this line.

out "Hello World &s"

It outputs Hello World &s to the console. The entire string, including spaces, is one argument, output by the command.

Escape Sequences

These are character codes for representing specific characters inside a string, indicated by a backslash and a letter.

Escapes
Escape	Desc.
`\n`	Newline
`\r`	Carriage return
`\t`	Tab
`\"`	Quote
`\#`	Hash
`\\`	Backslash

Example:

out "Hello\nWorld"

Output:

Hello
World

Character Access

String characters can be accessed via the indexing syntax

This example prints the first character of a string:

func @main
 string @s "dog"
 out &s[0] #outputs d
return

Identifiers: How to Use the Identifying Operator `@`

These are used when naming a construct, like a function, label, variable, or struct. This practice enforces readability and prevents abuses of syntax. In earlier versions, untyped words were used for naming, but this was problematic.

Identifying a variable:

int @i 10

Identifying a function:

func @foo (:int @a) #a is an integer.

Identifying a struct:

struct @tree

Identifying a label:

label @foo

The identifying operator (@) is not part of a name, it indicates a name.

Labels and Conditionals

Goto statements change the control flow of a program by moving the program counter from one line to another. In a program with no goto statements or calls, lines are executed from the first to the last in order, top to bottom. These programs cannot perform logic, parse input, or make decisions. The program counter needs to be able to jump in order for computation to be possible.

Goto statements make the program counter jump. Labels are locations to which the program counter jumps. In combination, they can evaluate conditions and execute loops. Finally, note that labels are stored at compile-time, so a goto can accept a label that is declared on a later line.

Conditionals and Loops

A conditional is a statement that can be true or false if a condition is met. When a conditional is true, the program counter goes to the label specified. Otherwise, the program counter increments to the next statement.

Loops begin with a label and end with a goto. They can run until a condition is met, or they can run forever. Count-controlled loops increment a number until it is of a specific value. Sentinel-controlled loops run until a condition is met.

Commands and Examples

See the "Conditionals and Loops" section of Commands for information on commands that go to labels.
For an example of conditionals with an infinite, sentinel-controlled loop, see Truth Machine in Program Examples.
For an example of conditionals with a count-controlled loop, see FizzBuzz in Program Examples.

Logic and Truth Values

Relations

A truth value can be one of two states, true or false; these are also called 1 and 0. Logical relations operate on truth values:

NOT inverts true and false.
AND takes two truth values and outputs true if both inputs are true. Otherwise, output is false.
OR takes two truth values and outputs true if either are true. Otherwise, output is false.
XOR (exclusive or) takes two truth values and outputs true if the values are opposite. Otherwise, output is false.

Standard Macros for Truth Values

!true equals 1.
!false equals 0.
!null equals 0.

These macros are part of the standard library and can be used at anytime.

Structs: Defining a Data Type

What is a Structure?

Structures are data structures defined in source.

struct @thing
 int @i
 int @j
 int @k
_struct

Variables in structures, called attributes, are not initialized. They are accessed and modified by functions, such as in the example here:

func @main
 thing @s
 set &s.k 10
 out &s.k
return
#outputs 10

Structures can have attributes of their own type. This is useful for defining data structures. This example defines a binary tree.

struct @binary_tree
 node @root
_struct
 
#node
struct @node
 int @data
 node @left   #child one
 node @right  #child two 
_struct

Initialization

An uninitialized variable of a structure type has no attributes at all, it is not a structure with null attributes, but a variable with no data at all. To initialize this variable, that is, give it data, a set block or list is used:

struct @binary_tree
 node @root
_struct
 
#node
struct @node
 int @data
 node @left   #child one
 node @right  #child two 
_struct

func @main
 set (:binary_tree @t) [0] #evaluates to &t [0] where &t is a tree with a null root
 set &t.root
  int 10
  node &left  0 
  node &right 0 
 _set
return

Notes

Note that referring to an attribute of a null structure throws a bad reference error.
Note that structures cannot be defined within a function.
Note that structure definitions cannot nest.

Functions

All memory in this language is bound to functions (or subroutines, if you prefer that term). Calls to functions are stored in the function tree. The main call is the root of this tree, and it branches each time a call is made.

The Basics: Functions and Calls

Functions let a programmer define their own commands as subprograms, and they can be called to perform a task. A function call executes the sub program defined by a function. Calls cannot run include statements, but they can take input, store information in memory, and output to calling (parent) function calls. After processing include statements, all Bellbase programs call the main function implicitly. Every function called from the main function is a child of the main function call.

The ‘func’ command starts a function definition. It takes a function name and input arguments for the function. Functions end with a ‘return’ command, which can output to the parent call.

When a function is called, execution stops for the parent call, and resumes when the child call completes execution. The program ends when the main call completes or when a halt command executes.

Specifying Function Input Types

Sometimes a programmer needs to specify what type of arguments their function can take:

Typings
Example	Desc.
`@foo`	foo is an identifier. Many commands take these.
`:foo`	foo is a call.
`(:t @foo)`	foo is a value the type specified; t is generic for an int, float, double, long, char, string, list, path, or struct.

Function Calls as Arguments: The Call Passing Operator `:`

Function calls are first class in this language. They can be assigned to a cell, passed to a function, or returned from a function.

foo :bar #passes what bar returns to foo.
foo (:bar @i 10 20) #bar can take arguments.

Overloading

A function is said to be overloaded when two function definitions share the same name.

func @foo (:string @a)
 out &a
 return

func @foo (:int @a)
 give &a 1
 out &a
 return

The function foo can output a string, or increment an integer by one and output. Overloaded functions can differ by the number of arguments they take and the types of arguments they take. However functions cannot share name, number of arguments, and types of arguments. Here is an example of what not to do.

func @foo
 out "Hi"
 return

func @foo
 out "Bye"
 return

This overloaded function is ambiguous and produces a collision. If foo were called, the output of that call is indeterminate. The two definitions of foo collide.

Returning

A return outputs from a function call to its parent. In the case where a call is an argument of a call or command, the argument is evaluated first. Let &d be 2 in this example.

bneq (:give 3 &d) 0 # -> bneq 5 0

The arrow is not an operation, it demonstrates evaluation.

Referring to Functions

Recall the table of data types. Functions and calls are data types, and they can be referenced with the refer operator. A function reference takes an identifier, and a function (header and body). It is a function definition. These are in a scope such that all functions can reference other functions.

A command called call can run a call passed by reference. (:foo 1 2) is equivalent to:

call &foo [1 2]

Functions as Attributes of Structures

A structure can reference a function as an attribute, shown here:

struct @foo
 func &bar
_struct

Such a structure can accept and run any function it references, in general this is useful for binding data to a function call.

Macros

Macros are substitutions performed by the compiler before runtime.

Use as Constants

Consider this example with no macros:

func @main
 list @b [9 8 7] 
 give &b[0] 10
 give &b[1] 10 
 give &b[2] 10 
return

To swap 10 for 11, three lines need to be changed.

Now consider this example with macros:

macro !foo 11
func @main
 list @b [9 8 7] 
 give &b[0] !foo
 give &b[1] !foo 
 give &b[2] !foo 
return

Only one line needs to be changed. It's nicer.

Blocks

Macros can be multiple lines long, which is great for consolidating repeated code and simplifying source.

Files

Note this excerpt from Commands:

out
     This prints the value given. Standard output is default, 
     but the second argument specifies a file for writing.  
     The file content is not overwritten. Data is appended.
     Args: VALUE, [PATH]
read
    Loads file content into memory; takes a file path and returns a string.
    Args: PATH
ovwr
    Overwrite file (arg2), with content (arg1)
    Args: STRING, PATH
make
    Make a file (0) or directory (1) at the specified path.
    Args: INTEGER, PATH
del
    Delete file or directory (recursively) at path.
    Args: PATH

There actually is not much to say about files. Directories are folders, which contain files, which contain data that can be read into a program, overwritten, or given new data to add to the file somewhere.

Errors

Error Codes

Syntax Error [Command Doc] [Int Range] ::: (1)
File Not Found ::::::::::::::::::::::::::: (2)
End Of File :::::::::::::::::::::::::::::: (3)
Undefined Variable ::::::::::::::::::::::: (5)
Undefined Function ::::::::::::::::::::::: (4)
Undefined Label :::::::::::::::::::::::::: (5)
Conflicting Identifiers :::::::::::::::::: (6)
Conflicting Function Definitions ::::::::: (7)   
Conflicting Labels ::::::::::::::::::::::: (8)
Unexpected Argument Type ::::::::::::::::: (9)
More Arguments Expected ::::::::::::::::: (10)
Missing Main Function ::::::::::::::::::: (11)
Unmatched Parenthesis ::::::::::::::::::: (12)
Unmatched Bracket ::::::::::::::::::::::: (13)
Compiler Error; Check Statements :::::::: (14)
Cannot Compile in Function :::::::::::::: (15) 
Undefined Macro ::::::::::::::::::::::::: (16) 
Runtime Error ::::::::::::::::::::::::::: (17)
Stack Overflow :::::::::::::::::::::::::: (18)
Out of Memory ::::::::::::::::::::::::::: (19)
Bad Argument :::::::::::::::::::::::::::: (20)
Bad Reference ::::::::::::::::::::::::::: (21)
Cannot Modify Constant :::::::::::::::::: (22)
Cannot Nest Blocks :::::::::::::::::::::: (23)
Error ::::::::::::::::::::::::::::::::::: (24)

To clarify the use of adjectives: Undefined means that the error is thrown by an argument that requires a definition in source. Conflict occurs when the next command to execute cannot be determined because of a shared name or header. Bad means that the erroneous code is incomputable, like a negative wait time, or a reference to data that is not there.

Whenever possible, an error should describe the function and instruction at which it occurred. A trace of calls should be printed whenever an error is thrown; each call should list all of its arguments on one line if applicable.

Whenever it is applicable, a doc string should be printed describing the syntax of the erroneous command. If this command is defined by the user, the function source will be printed

Example of Call Trace

foo 213
bar
main

Example of Command Doc String

bell 
     Don’t you know? A bell goes ding! 
     It makes sound!
     Args: [HERTZ, [DURATION IN MILLIS

Example of Function Print

func @cat
   out "Feed the cat\n"
   out (:input 2)
   doc "This function asks for input and prints that."
return

Writing a Doc String

The doc command can accept a string or a block of text. A one line doc string is shown above, but a block of text does not require quotes at all. All text in this block is literal. The interpreter skips this block entirely.

doc
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. 
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
_doc

func @main
 out "Hello World" 
 return

Throwing, Catching, and Handling Errors

Errors can be caught and handled inside handle blocks. A handle block catches an error and executes a goto statement. Errors can be thrown by passing an error code to the error command. Like all block statements, handles cannot nest. Here is an excerpt from the Commands section:

handle 
     Go to the label if any of the listed errors occurs in a handle block.
     Args: LABEL, LIST OF ERRCODES
_handle
     Ends the handle block above.
error 
     Throws the error given.
     Args: INTEGER.

Commands

(Note that arguments listed in [brackets] are optional)

Functions

func
     Defines a function with or without arguments
     Args: IDENTIFIER, [FUNCTION ARGUMENTS]
func
     Accepts a reference to a function, typically as a struct attribute.
     Args: FUNCTION REFERENCE (A VALUE)
return
     Ends a function and returns arguments given.
     If there is nothing to return, 0 is returned.
     Args: [VALUE]
_func
     Equivalent to a return command. 
     Args: [VALUE]
call
     Runs a call when given a function reference.
     Args: FUNCTION REFERENCE [LIST OF ARGUMENTS]
doc
    This command defines a doc string for a function.
    Doc strings explains what a function does and how 
    it should be used.
    The doc string starts on the next line and
    execution skips to the end of the doc string.
_doc
    End doc string; resume execution.

Input and Output

out
     This prints the value given. Standard output is default, 
     but the second argument specifies a file for writing.  
     The file content is not overwritten. Data is appended.
     Args: VALUE, [PATH]
input
     Takes input of the data type given 
     (with the exclusion of lists and structs).
     Args: STRING
read
    Loads file into memory; takes a file path and returns a string.
    Args: PATH
ovwr
    Overwrite file (arg2), with content (arg1)
    Args: STRING, PATH
bell 
     Don’t you know? A bell goes ding! 
     It makes sound!
     Args: [HERTZ, [DURATION IN MILLIS

Conditionals and Loops

label
     A label to go to. These are not global, 
     instead they are defined locally in a function. 
     Args: IDENTIFIER
beq
     Branch to LABEL if args are equal.
     Args: NUMBER, NUMBER, LABEL  
bneq 
     Branch to LABEL if args are not equal.
     Args: NUMBER, NUMBER, LABEL 
bgr 
     Branch to LABEL 
     if arg1 is greater than arg2.
     Args: NUMBER, NUMBER, LABEL    
bleq 
     Branch to LABEL 
     if arg1 is less than or equal to arg2.
     Args: NUMBER, NUMBER, LABEL   
goto
     Go to label specified
     Args: LABEL

Relational Operators

eq
     Return 1 if args are equal.
     Otherwise return 0.
     Args: NUMBER, NUMBER
neq 
     Return 1 if args are not equal.
     Otherwise return 0.
     Args: NUMBER, NUMBER
gr 
     Return 1 if arg1 is greater than arg2. 
     Otherwise return 0.
     Args: NUMBER, NUMBER
leq 
     Return 1 if arg1 is less than or equal to arg2. 
     Otherwise return 0.
     Args: NUMBER, NUMBER
not  
     Return 1 if given 0.
     Otherwise return 1.
     Args: NUMBER
and
     Return 1 if both args are 1. Otherwise return 0.
     Args: NUMBER, NUMBER
or
     Return 1 if either arg is 1. Otherwise return 0.
     Args: NUMBER, NUMBER
xor
     Return 1 if args are opposite each other. Otherwise return 0.
     Args: NUMBER, NUMBER

Data

var 
     Initializes a variable of the given type. 
     Note that var is a genericized placeholder for a data type.
     Pass it a value to initialize the variable.
     Args: IDENTIFIER, [VALUE]   
var
     To cast, pass a variable.
     Args: VAR
set
     Set variable to value.
     Args: VAR, VALUE
set
     Takes a variable that is a structure, 
     and sets attributes in a list.
     Args: VAR, LIST
set
     Takes a variable that is a structure, 
     and sets attributes in a block.
     Args: VAR
_set
     End set block.
const
     The specified variable is now a constant.
millis 
     Get the time since midnight of January 1, 1970, 
     in milliseconds. Returns a long.

Numeric Modifiers

give
     The first argument is set to the sum of itself and the second argument.
     Args: VAR, NUMBER
take
     The first argument is set to the difference of itself and the second argument.
     Args: VAR, NUMBER

Error Handling

handle 
     Go to the label if any of the listed errors occurs in a handle block.
     Args: LABEL, LIST OF ERRCODES
_handle
     Ends the handle block above.
error 
     Throws the error given.
     Args: INTEGER.

File Management

For File I/O see Input and Output

make
    Make a file (0) or directory (1) at the specified path.
    Args: INTEGER, PATH
del
    Delete file or directory (recursively) at path.
    Args: PATH

Program Interrupters (Excluding input)

wait
     Wait for a number of milliseconds 
     (1000 if not specified).
     Args: [TIME TO WAIT IN MILLIS]
halt   
     End program.

Compiled

struct 
     Defines a data type as a block of variables.
     Args: IDENTIFIER
_struct 
     Ends a struct.
include
     Include contents of specified file.
     or directory
     Args: PATH
macro
     These are substitutions handled by the linker.
     Argument one is the macro name
     which always start with a bang (!).
     !arg1 is replaced with arg2 at all points in source.
     Args: MACRO_NAME, REPLACEMENT
_macro
     If the second arg of a macro is a semi-colon, the macro can continue over multiple lines. 
     This command ends the macro.
impl 
     Short for implements, this is a command designed for interpreter extensibility.
     It takes a path to a .bbim file in the extensions directory. 
     This enables the interpreter to interpret commands defined in .bbim files.

Running a Bellbase Program

The interpreter runs in a shell and takes command line arguments:

bbe file_to_run.bbe inputs_for_main_func -flag

inputs_for_main_func is a set of arguments for the main function, separated by spaces.
The -flag sets the interpreter to mute, debug, or both.

Flagging

The flag can be in four states

 -m mute the bell
 -d debugger on
-dm mute the bell and debugger on
-md mute the bell and debugger on

Muting

When mute, the bell should not make sound and it should not output text. It is a no-op.

The Debugger

Every Bellbase interpreter should have a debugger that prints the following at each step:

The current function call, with arguments.
The current instruction in full.
Value stored at the last variable accessed.
Any program output at that step.

Example Debug Output:

Current Function: messages
Current Instruction: out "Here are your messages."
Last Variable Modified: &v
Variable State: 9
Output:
Here are your messages.

Inputs

When a program is waiting for user input it should output a right angle bracket and a space:

> Lorem Ipsum

The Linker: Include Commands

How to use Includes

The linker formats source code so that it can run appropriately. All leading whitespace before an instruction is removed. Additionally, all include commands are processed. The contents of each included file are compiled for use.

Note that source files are run from a run directory. Here are examples of include commands:

include run\foo\bar\hello.bbe
include ->dog\cat\*

As explained in Useful Operations, the right arrow is substituted with the path from run to the current file, and star includes the entire contents of a directory.

Using a Library

Libraries are directories that contain source files. These should be stored in a directory called lib. This directory should be stored in the same location as run.

Example:

include lib\Math.bbe

On Cyclic File References

TL;DR detecting these is an operationally expensive way to do a whole lot of nothing. If a programmer has one of these by mistake, they probably also have an infinite recursion anyway, and they will get a stack trace that alerts them to the bug.

Consider this example:

File A.bbe has the statement include B.bbe
File B.bbe has the statement include A.bbe

These are generally difficult to handle efficiently. While they can be detected by generating a graph of linked files, and checking for a Hamiltonian cycle. This would be done in polynomial time and slow the interpreter down. Even internationally recognized, professionally implemented languages, like C and Python, are often not implemented in ways that explicitly deal with cyclic references. Explicit handling of cyclic include references is, in general, too costly to bother with.

The more common, and simpler case, is infinite recursions on the call stack. These are easily demonstrated via tracing and printing the call stack in linear time. Such a case is relevant to cyclic file references because files linked in a cycle are likely to make function calls that produce an infinite recursion. Ie, file A calls a function in file B. Then file B calls a function in file A. In general, if there is an unintentional cyclic file reference, it is probably going to be discovered by means of an infinite recursion anyway, so having an explicit way to detect cycling files is not necessary.

Libraries

The following libraries are included in a Bellbase interpreter.

Standard

This is the library that is always included by default. It describes all standard commands and macros.

Math

Ops

This library has functions that operate on two numbers. Each returns an integer.

add
   adds stuff
sub
   subtracts stuff
mul
   multiplies stuff
div
   integer division
mod
   modulo 
pow
   raise arg1 to arg2
root
   takes the arg2 root of arg1
random
   returns a random value between 0 and 1
randint 
   returns a random integer between arg1 and arg2 inclusive.
floor
   returns the floor of a float or double as an int.
ceiling
   returns the ceiling of a float or double as an int.
abs
   returns the absolute value of a number.
sin
   returns the sine of a number.
cos
   returns the cosine of a number.
tan
   returns the tangent of a number.

Consts

pi 
   returns pi as a double 
e
   returns e as a double 
phi
   returns phi as a double

Data

Collect

Operations on collections.

size
   Get the number of items in a collection.
   Args: COLLECTION
   Ret:  INTEGER
count
   Counts the occurrences of a value.
   Args: COLLECTION, VALUE 
   Ret:  INTEGER
cat
   Concatenates strings into one string. 
   Args: STRING, STRING
   Ret:  STRING
cat
   Concatenates lists into one list. 
   Args: list, list
   Ret:  list
make_empty_list
   Makes an empty list (of null data) of a given size.
   Args: INTEGER
   Ret:  list
   Err: Bad Argument if Negative integer
append 
  To use with a list. 
  The list size grows by 1 and the item becomes the last index in the list.
  Args: list, VALUE
remove 
  Remove the index given from the list.
  Args: list, VAR
  Err: If the index is not found, that’s an undefined var.
insert
  Insert item at index of list.
  Args: list, INDEX, VALUE
  Err: Not a list or index

Consts

maxInt
  returns maximum integer value
minInt
  returns minimum integer value
maxLong
  returns maximum long value
minLong
  returns minimum long value
maxFloat
  returns maximum float value
minFloat
  returns minimum float value
maxDouble
  returns maximum double value
minDouble
  returns minimum double value

Compare

This is a library for comparing collections. Collections are converted to integers and evaluated.

How collections are compared:

Strings are a sum of characters.
Lists are a sum of items.
Structs are a sum of attributes.
Functions are always 0, as they are not generally comparable.

Two sums A and B, are calculated then B - A is returned. Equal values return 0. B > A returns a positive value. A < B returns a negative value.

compare
  Compares two strings.
compare
  Compare two lists recursively. 
compare
  Compare two structs by attributes recursively.

The convention for naming library files is to write the name of the library and bbe. The Collect file is Collect.bbe in the directory lib\Data

Proof of Turing Completeness

Proof by Translation to bf

It is trivial to define a function that can simulate a bf interpreter. Bf stores memory as cells on a tape. Cells are modified by a movable pointer, exactly like a Turing machine. A list of characters is sufficient to implement the tape.

func @bf
 list @tape (:make_empty_list 30000)
 int @pointer 0 #points to a char

 ##
 translated bf goes here
 ##

return

Translation Table
bf	Bellbase
`>`	`give &pointer 1;`
`<`	`take &pointer 1;`
`+`	`give &tape[&pointer] 1;`
`-`	`give &tape[&pointer] -1;`
`.`	`out &tape[&pointer];`
`,`	`input &tape[&pointer] "char";`
`[`	`beq &tape[&pointer] 0 @closeBracket; label @openBracket;`
`]`	`bneq &tape[&pointer] 0 @openBracket; label @closeBracket;`

(The semicolon is an explicit newline.)

Given bf is Turing complete, and Bellbase can simulate a bf interpreter. Bellbase must also be Turing complete. QED

Syntax Highlighting

Syntax highlighting is a practice to improve readability by coloring tokens. Keep in mind that a readable source code is best achieved in a language with appropriate syntax. Readable code does not require highlights at all.

As a general rule of thumb: tokens that require specialized parsers have hue, and tokens are otherwise black or white. The color scheme below is not a mandate, but an attempt.

Colors

ERRORS range from red to orange; if preferred, black or white is also acceptable.
IDENTIFIERS range from red to yellow
VARIABLES and NUMBERS range from yellow to blue
MACROS range from green to blue
STRINGS and DOC STRINGS range from blue to purple.
CALLS and COMMANDS range from purple to pink.
COMMENTS are gray.
PARENTHESES, BRACKETS, SEMI-COLONS, DOTS, LABELS, and PATHS are black or white.
BLACK is hex code #031930
WHITE is hex code #fce6cf

This scheme should be modified as needed for colorblindness, theme, mode, or whim. Two colorblind adapted palettes are available. Note that a dark reader may interfere with the rendering of palettes. Also note that as implied in the palettes, the operators are highlighted according to token color.

General Palettes

Lakeside palette:

error
@identifier
number
&variable
!macro
"string"
command
:call
#comment
()[];.
label
path
error

Forest palette:

error
@identifier
number
&variable
!macro
"string"
command
:call
#comment
()[];.
label
path
error

Plateau palette (This is used in documentation for light and dark reading.)

error
@identifier
number
&variable
!macro
"string"
command
:call
#comment
()[];.
label
path
error

Adapted Palettes

IBM Design Library:

error
@identifier
number
&variable
!macro
"string"
command
:call
#comment
()[];.
label
path
error

Wong, Points of View: Color Blindness. Nature Methods:

error
@identifier
number
&variable
!macro
"string"
command
:call
#comment
()[];.
label
path
error

Extensibility

The interpreter should be implemented such that it can accept command modules, such as .bbim files that can define additional commands for the interpreter. These files would be located in a directory in bbe called ext. These extended commands would be implemented in source via a compiler command. impl. These .bbim are called extensions.

Defining Commands

Files would describe commands with command blocks. The command takes an identifier as a name such as comm @foo. The body of the command would run a run command that one, takes a path to a file that is written in the same language as the Bellbase interpreter, such that it can be run via the language that implements Bellbase; and two, takes a reference (variable) that describes a function in the file described by argument one.

The file described by the run command (let's call it A) would be a file that includes necessary resources, and wraps the code that describes the extended command in a function. The .bbim file would be interpreted such that when the commands defined in the .bbim are executed by the Bellbase interpreter, the relevant function in file A is run for each command.

Here is an example:

comm @foo
 run path_to_A &function_in_A
_comm

Defining Errors

To throw an error, simply have the run command return the error code needed. 0 indicates that there is no error. Codes 1 to 24 are error codes. 25 and above are equivalent to 24. Negative values are interpreted as absolute values, such that the positive error code is returned.

Implementation

By Specification

Bellbase makes use of a compiler and an interpreter to run programs. Compiling happens at compile time. Then interpreting happens at run time. All compiled statements are processed outside of a function, like includes, structs, and macros. All interpreted statements are executed inside of a function.

The compiler does the following:

Uses a linker to read all included files into memory and concatenates them together for interpretation.
Processes all macros and performs replacements in memory.
Analyzes all structs and generates the associated data types for use in interpretation.
Analyzes all functions, storing labels, and binding calls to their respective functions.
Parses the source code with lexical and syntactic analysis.
Throws any relevant errors.

The interpreter does the following:

Executes compiled code starting at the main function.
Executes commands in order, until the program completes.
Throws an error if needed, and stops execution.
Outputs information for debugging.

By Translation

An alternative is to convert Bellbase source into source for an implemented language, such as a C style language, and then running that code. This may or may not require that a Bellbase compiler run first, depending on preference.

Minibell

This is a minimized dialect of Bellbase featuring only the essential commands, errors and operations for computation. Implementing this dialect is the first step to a successful implementation of Bellbase.

Commands:

func
return
char
give
take
beq
label
out

Operations:

Refer
Call Passing
Identifying
Parentheses (Open and Close)
Newline

Errors:

Error
Missing Main
Unmatched Parenthesis
Nested Function
Unexpected Argument

Test Cases

Parser Tests

Test each type of comment.
Test strings and docs strings.
Test for parenthesis and brackets
Test each operation.

Command Tests

Note that each command should be tested with no arguments, expected arguments, and unexpected arguments.

Error Tests

Each error should be tested.

Library Tests

Each function in the library described should be tested.

Function Tests

One (non-main) function, one call, no arguments. (Simplest Case)
One (non-main) function, one call, with value arguments.
One (non-main) function, one call, with variable arguments.
One (non-main) function, one call, with functions as arguments.
One (non-main) function, one call, with mixed type arguments.
One (non-main) function, one call, with unexpected arguments.
One overloaded (non-main) function, one call, with arguments.
One overloaded (non-main) function, multiple calls, with arguments.
One overloaded (non-main) function, multiple calls, with arguments, such that each call runs the same subroutine with different inputs.

Compiler Tests

Macro definition test.
Structure definition and use test.
Include one file in same directory.
Include one file in another directory.
Include file in subdirectory.
Include multiple files from various directories.
Include entire directory.
Include files in file to be included (accomplished via the right arrow >).
Circular include reference.

Index

Much of the stuff here is explained in the docs or rigorously defined elsewhere. This is not a textbook and the definitions here are for those interested in getting to the point.

Algorithm

A procedure to do something or make a decision.

ASCII Table

A table in which textual characters are assigned to a number. It was specifically designed for teleprinters in the 1960s. A teleprinter is essentially a typewriter that can be operated remotely. So, the ASCII table features a lot of specific control signals for operating the recipient's teleprinter. (7 rings a bell, which is fun.) The ASCII table is essentially the ancestor of all text encodings. Unless you are using some kind of esoteric keyboard, the computer you are using supports ASCII (including all of those old teleprinter signals).

Assignment

Sets a variable to a value. If x is assigned 5 , then x is now 5.

Arguments

These are not the emotional kind, or the kind of an interlocutor. They are inputs for a command or function.

Array

This is an ordered grouping of items. A list of stuff, usually contiguous in memory. lists are arrays.

Bell

This goes ding or beep. If you find yourself running a program for hours, you can use these to alert you to the program’s status while you are doing laundry.

If you prefer to run such a program while you sleep, you can mute the bell. Just know that if you ignore the computer for too long, it may crash out of spite, and you will wake up to a friendly error message, and you have to plan your evening around the needs of an old computer, and you will question your life choices.

Bf

A polite name for a language created by Urban Müller in 1993. This language is designed to be the simplest language possible, such that it has the smallest compiler possible. It runs a Turing machine on a tape of bytes and is proven to be Turing complete.

Bit

The fundamental unit of information. A bit can be in one of two states. You can think of it as a lightbulb. A bit can be on or off, 0 or 1, true or false. A contiguous set of bits is a word. A word of 2 bits has four states. 3 bits have 8 states. One more bit increases the number of states to the next power of two.

Bug

This is the chaotic code that broke your metaphoric vase. You probably wrote it to do something, but you made a mistake and now it does something else. On the origin of the term, I offer this quote from the biography of Rear Admiral Grace Murray Hopper:

"In 1946, when Hopper was released from active duty, she joined the Harvard Faculty at the Computation Laboratory where she continued her work on the Mark II and Mark III. She traced an error in the Mark II to a moth trapped in a relay, coining the term bug. This bug was carefully removed and taped to the log book. [Needless cruelty!] Stemming from the first bug, today we call errors or glitch's in a program a bug."

One day in 1946 they found a literal bug inside some very large, punch-card monstrosity of a machine. The bug crawled in looking for warmth and a cozy shelter, which is understandable. The bug was a bug, and it could not comprehend the consequences of its actions. It was making the computer do strange things. The computer needed debugging, hence the origin of a new term in the field. Hopefully, the bug was freed from its tape prison to go about its bug life uninterrupted.

Byte

8 bits. Range of 0 to 255 (unsigned).

Call

This runs a function with inputs. These can have parents and children. A parent call calls a child call.

Child

Opposite of a parent. This call finishes execution within parent scope.

Command

This is what you use to tell the computer to do a thing.

Comment

This is for people to read; it clarifies. The interpreter cannot read these. As a rule, it is better to explain why the code is written, not what it does, when writing a comment.

Compiler

In computation, a compiler is a program that reads source code and converts it into a form that can be interpreted.

Console

This runs programs, takes input, and displays output.

Constant

Data that cannot change state over time.

EBNF

This is Extended Backus-Naur Form. It is a meta-syntax that describes the syntax of programming languages.

Error

Errors are the seatbelt that keeps your computer safe. In this analogy, your program is a car and your computer is the driver. Errors protect your computer when your program does something that is unexpected. Errors are distinguished by error codes.

Esolang

An esolang is an esoteric programming language. These are usually designed by hobbyists to experiment with concepts in programming and computation. Bellbase is the least esoteric programming language in the history of the esolangs wiki, and it is documented there out of convenience. If that upsets you, perhaps you should consider if being upset over such trivial things is contributing positively to your life.

File

A happy little home for data.

First Class

Something is considered first class when it has the following properties:

It can be assigned or stored in program memory (RAM).
It can be passed to a function.
It can be returned from a function.

If these three criteria are not satisfied, the construct is second-class.

Function

A program that is run by another program. A subprogram. Takes input and returns output. The function is defined as source code.

Heap

This is a data structure that behaves like a large pile of legos. You can use the legos to build houses and spaceships and whatever else you like. (Just make sure they go back in the box when you are done.) In this language, the legos are variables, and the return command cleans everything up.

Initialization

Uninitialized variables are null. The first time a variable is assigned data, the variable undergoes initialization.

Input

Data to be processed by a program.

Interpreter

Interprets and executes source code line by line.

Library

A library is a set of files that contain useful functions for programmers.

Nesting

Putting a thing inside another thing. It has nothing to do with the 2011 movie Inception.

Null

This means "no data here". 0 is equivalent to null in ASCII.

Output

Data generated by a program.

Overloading

A function is said to be overloaded when there are two or more function definitions of the same name, but differing arguments. The number of arguments may be different, their typing may be different, or the number and typing of the arguments may vary between definitions.

Parent

Calls the current call, when the current call is finished execution returns to the parent.

Program

A to-do list for a computer. Completing the list is called running or execution.

Program Counter

This keeps track of what to do next. It will keep incrementing after each statement, until the program ends.

Source Code

This is what programs are written in.

Stack

Think of a stack of pancakes, which is what I call the yummy, pan-fried, tasties, though you might call them flapjacks or hot cakes. Pancakes get on the stack from the top, and the ones at the bottom get eaten last.

Sadly, function calls are not pancakes, the last call on the stack creates the next call to go on the stack.

Stack Overflow

Have you ever tried to make an endless stack of pancakes? You use up all the batter and the stack topples over. This error is thrown before toppling happens. It stops someone from creating a stack with an irresponsible amount of pancakes.

Syntax

This tells you how to read and write stuff in a language.

Token

A token is the shortest portion of source an interpreter can understand.

Truth Value

A value that is true or false.

Turing Complete

Something that is Turing complete is capable of doing any solvable math problem or deciding any decidable problem. It can run any algorithm that is runnable. Anything Turing complete can simulate anything else that is Turing complete.

Turing Machine

A theoretical device that can be programmed to read and write on an endless tape. The tape is divided into cells that can store one bit. The machine is capable of solving any solvable problem and is foundational in computing. It was invented by Alan Turing.

Variable

Data that can change state over time.

ASCII Table

On mobile phones, many binary values listed here will be interpreted as phone numbers. This gives them a blue, clickable link.

Binary	Decimal	Hex	Character
0000000	0	00	NULL
0000001	1	01	Start of Heading
0000010	2	02	Start of Text
0000011	3	03	End of Text
0000100	4	04	End of Transmission
0000101	5	05	Enquiry
0000110	6	06	Acknowledgement
0000111	7	07	Bell
0001000	8	08	Backspace
0001001	9	09	Horizontal Tab
0001010	10	0A	New Line
0001011	11	0B	Vertical Tab
0001100	12	0C	Form Feed
0001101	13	0D	Carriage Return
0001110	14	0E	Shift Out
0001111	15	0F	Shift In
0010000	16	10	Data Link Escape
0010001	17	11	Device Control 1
0010010	18	12	Device Control 2
0010011	19	13	Device Control 3
0010100	20	14	Device Control 4
0010101	21	15	Negative Acknowledgement
0010110	22	16	Synchronous Idle
0010111	23	17	End of Transmission Block
0011000	24	18	Cancel
0011001	25	19	End of Medium
0011010	26	1A	Substitute
0011011	27	1B	Escape
0011100	28	1C	File Separator
0011101	29	1D	Group Separator
0011110	30	1E	Record Separator
0011111	31	1F	Unit Separator
00100000	32	20	Space
00100001	33	21	!
00100010	34	22	"
00100011	35	23	#
00100100	36	24	$
00100101	37	25	%
00100110	38	26	&
00100111	39	27	'
00101000	40	28	(
00101001	41	29	)
00101010	42	2A	*
00101011	43	2B	+
00101100	44	2C	,
00101101	45	2D	-
00101110	46	2E	.
00101111	47	2F	/
00110000	48	30	0
00110001	49	31	1
00110010	50	32	2
00110011	51	33	3
00110100	52	34	4
00110101	53	35	5
00110110	54	36	6
00110111	55	37	7
00111000	56	38	8
00111001	57	39	9
00111010	58	3A	:
00111011	59	3B	;
00111100	60	3C	<
00111101	61	3D	=
00111110	62	3E	>
00111111	63	3F	?
01000000	64	40	@
01000001	65	41	A
01000010	66	42	B
01000011	67	43	C
01000100	68	44	D
01000101	69	45	E
01000110	70	46	F
01000111	71	47	G
01001000	72	48	H
01001001	73	49	I
01001010	74	4A	J
01001011	75	4B	K
01001100	76	4C	L
01001101	77	4D	M
01001110	78	4E	N
01001111	79	4F	O
01010000	80	50	P
01010001	81	51	Q
01010010	82	52	R
01010011	83	53	S
01010100	84	54	T
01010101	85	55	U
01010110	86	56	V
01010111	87	57	W
01011000	88	58	X
01011001	89	59	Y
01011010	90	5A	Z
01011011	91	5B	[
01011100	92	5C	\
01011101	93	5D	]
01011110	94	5E	^
01011111	95	5F	_
01100000	96	60	`
01100001	97	61	a
01100010	98	62	b
01100011	99	63	c
01100100	100	64	d
01100101	101	65	e
01100110	102	66	f
01100111	103	67	g
01101000	104	68	h
01101001	105	69	i
01101010	106	6A	j
01101011	107	6B	k
01101100	108	6C	l
01101101	109	6D	m
01101110	110	6E	n
01101111	111	6F	o
01110000	112	70	p
01110001	113	71	q
01110010	114	72	r
01110011	115	73	s
01110100	116	74	t
01110101	117	75	u
01110110	118	76	v
01110111	119	77	w
01111000	120	78	x
01111001	121	79	y
01111010	122	7A	z
01111011	123	7B	{
01111100	124	7C	\|
01111101	125	7D	}
01111110	126	7E	~
01111111	127	7F	Delete

Via the esolangs wiki.

Sources

@atelierbram, Syntax Highlighting Color Schemes: Atelier Schemes. (n.d.) Retrieved July 16, 2022 from 
https://atelierbram.github.io/syntax-highlighting/atelier-schemes/
-
ASCII table. ASCII Table - ASCII Character Codes, HTML, Octal, Hex,
Decimal. (n.d.). Retrieved January 16, 2022, 
from https://www.asciitable.com/
-
Bf. Esolang. (n.d.). Retrieved January 16, 2022, 
from https://esolangs.org/wiki/Bf
(Swear word removed.)
-
Bellbase. Esolang. (n.d.). Retrieved June 4, 2022, 
https://esolangs.org/wiki/Bellbase_Documentation
-
Contributor, T. T. (2020, December 16). What is Logic Gate (and, or, XOR, not, Nand, nor and xnor)? 
A definition from whatis.com. WhatIs.com. 
Retrieved September 4, 2022, from https://www.techtarget.com/whatis/definition/logic-gate-AND-OR-XOR-NOT-NAND-NOR-and-XNOR 
-
Davis, S. A. (n.d.). Rear Admiral Grace Murray Hopper.  Retrieved June 12, 2022, from 
https://ei.cs.vt.edu/~history/Hopper.Danis.html 
-
Encyclopedia Britannica, inc. (n.d.). ASCII. Encyclopedia Britannica. Retrieved June 3, 2022, from 
https://www.britannica.com/topic/ASCII
-
Java Data Types. Java data types. (n.d.). Retrieved June 3, 2022, from https://www.w3schools.com/java/java_data_types.asp
-
Nichols Davis, Coloring for Colorblindness. (n.d.) 
Retrieved July 16, 2022 from https://davidmathlogic.com/colorblind/#%23D81B60-%231E88E5-%23FFC107-%23004D40
-
Truth-machine. Esolang. (n.d.). Retrieved February 2, 2022, 
from https://esolangs.org/wiki/Truth-machine
-
Wikimedia Foundation. (2021, December 25). Extended backus-naur form. 
Wikipedia. Retrieved January 17, 2022, 
from https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form#Table_of_Symbols
-
Wikimedia Foundation. (2022, January 4). Turing completeness. Wikipedia. 
Retrieved January 16, 2022, 
from https://en.wikipedia.org/wiki/Turing_completeness
-
Wikimedia Foundation. (2022, January 14). Turing machine. Wikipedia. 
Retrieved January 16, 2022, 
from https://en.wikipedia.org/wiki/Turing_machine

Bbe doc downloadable

Design Goals: Why Use Bellbase?

Factors in Design

On Languages Designed for Pedagogy: Thoughts on Stacking Blocks

Clarity: Why no Braces?

Influences: Shameless Theft

Acknowledgements

Program Examples

Hello World

Truth Machine

Cat (Echo)

FizzBuzz

Syntax

Statements

Comments

Blocks

Argument Tokens

Token Order

Parentheses and Brackets

Useful Operators

Grammar in EBNF

Variables

Data Types

Declaring Variables: The Refer Operator &

Null Data

Assignment

Casting

Constants

Lists, Indexing, and Nesting

Strings and Escapes

Escape Sequences

Character Access

Identifiers: How to Use the Identifying Operator @

Labels and Conditionals

Conditionals and Loops

Commands and Examples

Logic and Truth Values

Relations

Standard Macros for Truth Values

Structs: Defining a Data Type

What is a Structure?

Initialization

Notes

Functions

The Basics: Functions and Calls

Specifying Function Input Types

Function Calls as Arguments: The Call Passing Operator :

Overloading

Returning

Referring to Functions

Functions as Attributes of Structures

Macros

Use as Constants

Blocks

Files

Errors

Error Codes

Example of Call Trace

Example of Command Doc String

Example of Function Print

Writing a Doc String

Throwing, Catching, and Handling Errors

Commands

Functions

Input and Output

Conditionals and Loops

Relational Operators

Data

Numeric Modifiers

Error Handling

File Management

Program Interrupters (Excluding input)

Compiled

Running a Bellbase Program

Flagging

Muting

The Debugger

Inputs

The Linker: Include Commands

How to use Includes

Declaring Variables: The Refer Operator `&`

Identifiers: How to Use the Identifying Operator `@`

Function Calls as Arguments: The Call Passing Operator `:`