72 lines
2.6 KiB
Plaintext
72 lines
2.6 KiB
Plaintext
|
|
# ------------------------------------------------------------------------- #
|
|
# --- Introduction -------------------------------------------------------- #
|
|
#
|
|
# This language was written as a personal study of how interpreters
|
|
# and compilers work. For this reason, the language is very basic and
|
|
# not innovative.
|
|
# One of the main inspirations was the CPython's source code since
|
|
# it's extremely readable and has a very simple clean architecture.
|
|
#
|
|
# This file was intended for people who already program in other
|
|
# high level languages (such as Python, Javascript, Ruby) and don't
|
|
# need to be introduced to basic programming concepts (variables,
|
|
# expressions and branches). This way, there is more space for the
|
|
# comparison of the language's features with the mainstream languages.
|
|
#
|
|
# ------------------------------------------------------------------------- #
|
|
# --- Implementation ------------------------------------------------------ #
|
|
#
|
|
# The interpreter works by compiling the provided source to a bytecode
|
|
# format and executing it. The bytecode is very high level since it
|
|
# does things like:
|
|
#
|
|
# - explicitly referring to variables by name.
|
|
#
|
|
# - treating values as atomic things: from the perspective of the
|
|
# bytecode, a list and an integer occupy the same space on the
|
|
# stack, which is 1.
|
|
#
|
|
# - referring to instructions by their index.
|
|
#
|
|
# For example, by compiling the following snippet
|
|
|
|
define = true;
|
|
|
|
if define:
|
|
a = 33;
|
|
|
|
print(a, '\n');
|
|
|
|
# one would obtain the following bytecode:
|
|
#
|
|
# 0: PUSHTRU
|
|
# 1: ASS [define]
|
|
# 2: POP 1
|
|
# 3: PUSHVAR [define]
|
|
# 4: JUMPIFNOTANDPOP 8
|
|
# 5: PUSHINT 33
|
|
# 6: ASS [a]
|
|
# 7: POP 1
|
|
# 8: PUSHSTR [\n]
|
|
# 9: PUSHVAR [a]
|
|
# 10: PUSHVAR [print]
|
|
# 11: CALL 2
|
|
# 12: POP 1
|
|
# 13: RETURN
|
|
#
|
|
# as you can see, there are instructions like ASS and PUSHVAR that
|
|
# assign to and read from variables by specifying names, and jumps
|
|
# that refer to other points of the "executable" by specifying indices
|
|
# (like JUMPIFNOTANDPOP) instead of raw addresses.
|
|
#
|
|
# All values (objects) are allocated on a garbage-collected heap.
|
|
# For this reason all variables are simply references to these objects.
|
|
# The garbage collection algorithm is a copy-and-compact one. It
|
|
# behaves as a bump-pointer allocator until there is space left,
|
|
# and when space runs out, it creates a new heap, copies all of the
|
|
# alive object into it, calls the destructors of the dead objects
|
|
# and frees the old one.
|
|
#
|
|
# ------------------------------------------------------------------------- #
|
|
# ------------------------------------------------------------------------- # |