This page documents the extra commands from Small Calculator. These were taken from source code, pretty much as is, but styled to suite the web, and any spelling mistakes fixed. These were retrievable from the application itself by typing “help” follow by the command.

Available Commands

The list of available commands are as follows

BLOCK <statements>    Executes a block of statements
HELP [topic]          Display help on topic
DEFFNC <function>     Defines a new function
ECHO <text>           Displays text on the line
ECHOEXPR <cmd>        Executes a command and displays the result
EXEC <file>           Executes a file of commands
FUNCTIONS             Displays all predefined functions
IF <pred>             Does a command on condition
RETURN <val>          Sets the return value
RETURNEXPR <cmd>      Sets the return value to the result of <cmd>

Type "HELP <command>" to see infomation on a command

BLOCK

BLOCK {<cmd1>} {<cmd2>} ...

Executes a block of commands.  The commands can be any statement including other block statements.

DEFFNC

DEFFNC <fnname>(<parameters>) = <command>

Defines a new function.  The function name can only consist of letters and numbers.  Only a maximum of 4 parameters can be used in the parameter list.  Parameters are required to be referred to using $ in the function due to the interpretation of parameters.

Example:

deffnc test(x) = $x + 2
      -- Adds two to any number
      
deffnc sign(k) = if ($k < 0} {-1} {if {$k > 0} {1} {0}}
      -- Returns -1 if k is negative, 1 if k is positive and
         0 if k is 0.

Functions can be recursive if using the “if” command.

ECHO

ECHO <string>

Displays a string on the console.

ECHOEXPR

ECHOEXPR <command>

Executes a command and displays the result on the console.

EXEC

EXEC <filename>

Executes a file of commands.  Lines starting with “;” are considered comments.  Lines ending with "" are considered incomplete and the next line is appended (after trimming) to the end of that line.

FUNCTIONS

functions

Displays all predefined functions.  No user functions are included.

IF

IF {<cond>} {<truepart>} {<falsepart>}

If the result of is not zero, executes which could be any statement, otherwise executes .  If statements can be nested.

HELP

HELP [topic]

Displays a help topic on the console window.  Use “HELP ” to find help on a particular command.

RETURN

RETURN <val>

Sets the return value to .

RETURNEXPR

RETURNEXPR <cmd>

Sets the return value to the return value of .

Date: Unknown, but probably around 2005

Status: Retired

Give me Delphi 7, a terminal control, and an expression parser, and of course I’m going to build a silly little REPL program.

I can’t really remember why I though this was worth spending time on, but I was always interested in little languages (still am), and I guess I though having a desk calculator that used one was worth having. I was using a parser library I found on Torry’s Delphi Pages (the best site at the time to get free controls for Delphi) for something else, and after getting a control which simulated a terminal, I wrote a very simple REPL loop which used the two.

And credit to the expression parser developer: it was pretty decent. It supported assignments and quite a number of functions. Very capable for powering a desk calculator.

For a while the app was simply that. But, as with most things like this, I got the itch to extend it a little. I started by added a few extra commands. Simple things, like one that would echo something to the screen. All quite innocent, if a little unnecessary. But it soon grew to things like if statements, blocks using curly brackets, and function definitions.

It even extended to small batch scripts, like the one below.  The full set of commands is listed here.

x := 2
y := 3

if {x = y} {echo 5} \
  {echo 232}

return 

These never went anywhere beyond a few tests. The extra commands was not really enough to be useful, and they were all pretty awful. I was already using a parser library so I didn’t want to spend any time extending it. As a result, many of these extensions were little more than things that scanned and spliced strings together. It was more of a macro language rather than anything else.

Even with the expression parser the program didn’t see a great deal of use. I was working on the replacement at the time which would eventually be much more capable, and as soon as that was ready, this program fell out of use.

Even so, it was still quite a quirky little program to make a bit of an impression.