Source

Maentwrog /

Filename Size Date modified Message
eg
src
118 B
4.1 KB
1.2 KB

The Maentwrog Programming Language

This is a rudimentary specification for the Maentwrog programming language.

This information, and the example programs in this distribution, were taken from the esolangs.org wiki page for Maentwrog, written by User:Marinus and (like all esowiki articles) placed in the public domain. Thanks Marinus!

Syntax

A Maentwrog program consists of a series of words, separated by whitespace. Words can contain any character except whitespace. The way these words are executed depends on the character they begin with.

  • A word that consists of digits is taken as an integer and pushed. A minus sign may be used to make negative numbers, so 25 and -14 are words that push 25 and -14 onto the stack. Extra characters at the end of the word are allowed, so 25abc and 25.14 both also push 25.
  • A word that isn't a number is treated as either a function or a variable. If the word is defined as a function, it is executed; if it's a variable, its current value is pushed to the stack. Using an undefined word results in an error, though this doesn't stop further execution of the program.
  • To define a word as a function, use the syntax : new-word words to execute ; (as in Forth). Redefining a word is not allowed, and neither are nested function definitions.
  • To define a word as a variable, use the syntax *varname. This must be done before using a variable.

Additionally, words (except number words) can take one of a list of prefixes, changing how the word is executed.

**Prefix**   **Action**           **Example**   **Result**
`=`          Assign to variable   `=foo`        A value popped from the stack is assigned to the variable *foo*.
`@`          If                   `@bye`        Pop value, stop the program (see predefined words) if it isn't 0.
`[`          While                `[xyz`        Pop value, if it's not 0 execute word *xyz*, then pop another value and do it again; continue until a 0 is popped.
`$`          Repeat               `$.`          Pop value, then output that many values from the stack.

Predefined words

**Word**             **Stack effect**   **Description**
`bye`                                   Stop program immediately.
`rem` ... `;`                           Comment. (Ignore all words between `rem` and `;`.)
`:` *word* ... `;`                      Define a new word.
`debug`                                 Turn on debugging (outputs all words executed).
`vars`                                  Output a list of currently defined variables and their values.
`words`                                 Output a list of currently defined words.
`alloc`              `n` | `ptr`        Allocate memory for *n* C *long*s, returns a pointer.
`free`               `ptr` | `-`        Free memory at pointer.
`size`               `-` | `n`          Push stack size.
`dup`                `a` | `a a`        Duplicate top of stack.
`swap`               `a b` | `b a`      Swap the two topmost stack values.
`pop`                `a` | `-`          Remove top value from stack.
`get`                `ptr` | `value`    Push value at pointer to stack (C `*ptr`).
`put`                `ptr val` | `-`    Store value at pointer (C `*ptr = val`).
`rnd`                `-` | `n`          Push random value.
`>`                  `a b` | `(a>b)`    Push 1 if a is greater than b, else 0.
`<`                  `a b` | `(a<b)`    Push 1 if a is less than b, else 0.
`==`                 undefined          Undefined.
`.`                  `n` | `-`          Pop a value, output as integer, adding a newline.
`..`                 `n` | `-`          Pop a value, output as an ASCII character.
`mod`                `a b` | `(a%b)`    Modulo.
`+`                  `a b` | `(a+b)`    Addition.
`-`                  `a b` | `(a-b)`    Subtraction.
`*`                  `a b` | `(a*b)`    Multiplication.
`/`                  `a b` | `(a/b)`    Division, result is rounded towards 0.