DPGraph documentation. More DPGraph documentation is available by clicking on Help inside DPGraph. When we finish incorporating DPGraph's dynamic 3D functionality into Flaming Thunder, we'll also incorporate the documentation into Flaming Thunder's documentation.

Examples:

Language Reference Index:

Command Line Parameters

The syntax to invoke Flaming Thunder from the command line is:

FT FILE inputfilename OUTPUT outputfilename TARGET targetname

The case of the letters doesn't matter to Flaming Thunder, although if you are working on a system with case-sensitive file names then the case of inputfilename and outputfilename should correspond to the file names in the file system.

The inputfilename must end in .ft so that Flaming Thunder doesn't accidentally overwrite the input file when it generates one or more of the output files.

The valid values for targetname are All, FreeBSD32, FreeBSD64, Linux32, Linux64, MacOSX32, MacOSX64, Windows32 and Windows64.

The output outputfilename and target targetname pairs are optional. If the target isn't specified, then Flaming Thunder generates the executable for your current machine and operating system. If output is specified, then you cannot use target all.

Examples:

ft file helloworld.ft

ft file IPAddress.ft output IPAddress.cgi target linux32

ft file classnotes.ft target all

File Format

A Flaming Thunder program is a sequence of 8-bit bytes. These 8-bit bytes are interpreted as characters. These characters are in turn grouped together to form the words, numbers, strings and symbols that comprise a Flaming Thunder program.

Examples:

# Here is a small Flaming Thunder program.
Write "Hello world!".

# Here is another small program.
Write 1_000!.

Lines

For readability, Flaming Thunder programs are usually broken into lines. This is not necessary, though. An entire program can be contained on a single line.

There is no arbitrary limit on the length of lines. A line can be as long as the maximum file size allowed by the operating system.

The end of a line is marked by a linefeed character, 0x0A. The linefeed character may be preceeded by a carriage return character, 0x0D. A carriage return character that isn't followed by a linefeed will be flagged as an error.

Flaming Thunder doesn't care whether or not the last line in the file has end of line characters after it.

Examples:

# Here is an entire program on one line.
Set x to 10.  Write x^x.

# Here is one statement split across lines.
Write "Four score and seven years ago ",
      "our fathers brought forth ",
      "on this continent a new nation ...".

Comments

Flaming Thunder uses # as a comment character. Flaming Thunder ignores all the 8-bit bytes on a line from the comment character through the end of the line.

Comments may contain any characters other than linefeeds because linefeeds mark the end of the comment.

Some programming languages, such as C, have multiline comments. Flaming Thunder does not have multiline comments. Multiline comments are bad programming practice because someone reading your program can't tell if a section of code is executed or not because it may be included in a large block of code that has been commented out.

Examples:

Set x to 10. # Set the variable x to 10.
Set y to 20. # Set the variable y to 20.

Symbols

The symbols recognized by the Flaming Thunder compiler are:

Some of the symbols have two characters, but they are treated as one symbol. The two-character symbols can't have any other characters, including space or underscores, between the two characters.

The # character is used to start comments, but it is ignored along with the rest of the comment and isn't treated as a symbol.

The _ character can be used to create visual breaks in words and numbers, but it is ignored by Flaming Thunder.

The word pairs and triplets IS A, IS AN, IS NOT A and IS NOT AN are treated somewhat like symbols in that together they describe a single operation, but arbitrary amounts of white space (spaces, tabs, comments, end of lines) can appear between them.

Examples:

Set x to y = 1 + 2*x^7!.

If x is an error
  then set x to -(15+x)*2.

Words

A word is a letter followed by zero or more letters, digits, or underscores. White space (spaces, comments, ends of lines) can occur between a pair of underscores in a word; this allows extremely long words to be split across lines, which is the same method used to split extremely long numbers across lines.

There is no maximum limit on the number of letters and digits in a word. Uppercase and lower case words are considered to be identical and underscores are ignored.

Computer programmers often call words "identifiers".

Examples:

Write This_  # Start of write procedure.
_is_
_an_
_extremely_
_long_
_word. # Writes thisisanextremelylongword.

W_R_I_T_E 10_000. # Flaming Thunder treats
WrItE 10000.      # these identically.

Reserved Words

These words are reserved; they can't be redefined because Flaming Thunder then wouldn't understand the structure of your program:

and, divides, do, doing, down, else, error, false, for, forever, function, go, if, integer, interval, is, local, mod, not, of, or, real, return, set, string, then, times, to, true, unset, until, variable. while.

There are two words that Flaming Thunder uses to understand the structure of your program, but that you can also use as variables because Flaming Thunder can disambiguate your meaning based on the context:

a, an.

Reserved words are also often called keywords.

Examples:

# A and AN can be used as variables because they
# always follow IS or IS NOT when used to
# structure your program.
Set an to GetParameter(1).
If an is an error then go to ErrorHandler.

Strings

Strings are quoted text that your program can manipulate.

Strings start with a double-quote character (") and end with a double-quote character. If you want to include a double-quote character in a string, put two double-quote characters together.

Strings may include any bytes with hexadecimal codes from 0x20 (" ") through 0xFF.

Spaces are allowed in strings, but tabs characters (0x09) are not. Tabs in strings are ambiguous because the compiler can't tell if you wanted the tab expanded to spaces, or if you wanted the actual tab character in the string. If you want a string with a tab in it, use the Tab predefined string constant.

You can concatenate strings using the + sign.

Examples:

Write "This is a string.". # Writes: This is a string.

Write """Yes,"" he said." # Writes: "Yes," he said.

Write "Before tab" + Tab + "after tab".

Integers

Integers are numbers with no decimal point. Integers can contain any number of digits. Integers can also contain underscores, which are ignored. Integers can be broken across lines by ending one section with an underscore, and resuming the next section with an underscore.

Examples:

# Long integers are easier to read
# with underscores.
Write 10_000_000_000.

# Integers can be broken across lines.
Write 10_000_000_000_
        _000_000_000_
        _000_000_000.

Reals

Reals are numbers with a decimal point (floating point notation). Reals must have at least one digit before the decimal point and at least one digit after the decimal point so that Flaming Thunder can distinguish a real from an integer with a period after it at the end of a statement. Reals can contain any number of digits. Reals can also contain underscores, which are ignored. Reals can be broken across lines by ending one section with an underscore, and resuming the next section with an underscore.

Reals "poison" a calculation. Anytime a calculation involves a real and an integer, the result will be a real. That's because reals are often approximations, so the appearance of a decimal point in your result will alert you that your result might be approximate.

Examples:

Set x to 123.4*10^3.

Set y to 123.456_789.

Intervals

INTERVAL ( minimum, maximum )

Intervals allow you to do arithmetic with imprecise data and keep track of how imprecise it is.

Intervals "poison" a calculation. Anytime a calculation involves an interval and a real or integer, the result will be an interval. If an interval appears as the result of a calculation, it tells you the bounds that your result is guaranteed to lie within.

The bounds maintained by intervals can be greater than the actual maximum bounds because Flaming Thunder doesn't currently keep track of the correlations between different parts of the calculation. For example, the following program:

Set x to interval(1.1, 1.2).
Set y to interval(1.1, 1.2).
Writeline x-y.
Writeline x-x.

interval(-0.1,0.1)
interval(-0.1,0.1)

The 1st interval is correct because x and y are different variables, but the 2nd interval is too large because x-x is always exactly 0.

Examples:

Set x to interval(10.1-0.001, 10.1+0.001).

Set y to 5*interval(-0.1, 0.1).

Order of Operations

The order of operations in Flaming Thunder is the same as in standard mathematics. For example, in the expression 4+5*6*7 the multiplications are performed before the addition, and the multiplications are performed left-to-right.

All operations of the same priority are performed left-to-right except for ^ (raising to a power), which is performed right-to-left. That conforms to standard mathematical useage, where 2³² is interpreted as 2^(3^2) = 2^9 = 512, instead of (2^3)^2 = 2^(3*2) = 2^6 = 64.

Examples:

If 11 divides x then write "divisible by 11".

If x mod 7 = 5 then write "x = 7*y + 5".

Write 2^3^2. # Writes 512.

Set x to -10^2. # -10^2 = -(10^2) = 100.

Set x to 10^-2. # 10^-2 = 10^(-2) = 1/100.

Statements and Labels

A Flaming Thunder program is a list of statements and labels in a file. The statements are usually executed one-by-one starting with the first statement in the file. Statements end with periods.

A label is a word followed by a colon. Labels are used to mark locations in a statement list. More than one statement or label can be placed on each line and statements can be split across lines.

Examples:

  If x<10 then go to ErrorLabel.
  Write "Success".
  Go to endlabel.
ErrorLabel:
  Write "Error".
End_Label:

Compound Statement

( listofstatementsandlabels )

A compound statement a list of statements and labels inside parentheses. Compound statements can occur anywhere a statement is called for. An empty compound statement -- () -- can serve as a "do nothing" statement.

Examples:

(If x<10 then go to end. Write 2*x. Read x. End:)

# A single statement in a compound statement.
(for y from 1 to 20 do set sum to sum+y.)

If x=0 then         # If x is zero, get a new x and y.
 (
 Write "Enter x: ".
 ReadLine x.        # Get x.
 Write "Enter y: ".
 ReadLine y.        # Get y.
 ).
Write x.
Write y.

# An empty compound statement.
if x<10 then () else set x to 5.

For Statement

FOR variable FROM expression1 TO expression2 DO statement
FOR variable FROM expression1 DOWN TO expression2 DO statement
FOR expression TIMES DO statement
FOR FOREVER DO statement

A for statement executes a loop a specific number of times.

A for-to statement is exactly equivalent to:

    Set variable to expression1.
    Set temporaryvariable to expression2.
TemporaryLabel1:
    If (variable <= temporaryvariable) <> true go to TemporaryLabel2.
    Statement.
    Set variable to variable+1.
    Go to TemporaryLabel1.
TemporaryLabel2:

A for-down-to statement is exactly equivalent to:

    Set variable to expression1.
    Set temporaryvariable to expression2.
TemporaryLabel1:
    If (variable >= temporaryvariable) <> true go to TemporaryLabel2.
    Statement.
    Set variable to variable-1.
    Go to TemporaryLabel1.
TemporaryLabel2:

A for-times statement is exactly equivalent to:

    Set temporaryvariable to expression.
TemporaryLabel1:
    If (temporaryvariable <> 0) <> true go to TemporaryLabel2.
    Statement.
    Set temporaryvariable to temporaryvariable-1.
    Go to TemporaryLabel1.
TemporaryLabel2:

A for-forever statement is exactly equivalent to:

TemporaryLabel:
    Statement.
    Go to TemporaryLabel.

Examples:

Set sum to 0.
For i from 0 to 255 do set sum to sum + 2^i.

Set x to interval( 1.1, 1.2).
Set z to interval( 1.01, 1.02).
For i from 0 to 3 do
  (
  Set x to x^2.
  Set z to z+x.
  ).
Write z.

For 80 times do write "*".

For forever do
  (
  Write "Do you know the definition of insanity? ".
  Read response.
  ).

Function Statement

functionname IS A FUNCTION( listofparameters ) DOING statement

A function statement defines a function. The first return statement that gets executed in the function determines the value that the function returns.

Functions can be recursive. That is, a function can call itself.

Functions can be nested. You can define functions within functions.

Functions do not have to be declared before they are used. You can put all of your function statements in alphabetical order at the end of your program, glossary style.

If you want your function to execute multiple statements, put them in parentheses to form a compound statement.

When a function is called, the parameters are always evaluated in left-to-right order.

Examples:

# A simple function.
Radius is a function(x,y) doing return squareroot(x^2+y^2).

# A recursive function.
Factorial is a function(n) doing
  if n = 0 then return 1 else return n*factorial(n-1).

# Nested functions in a compound statement.
Distance is a function(x1,x2,x3,y1,y2,y3) doing
  (
  Return squareroot( square(y1-x1)+square(y2-x2)+square(y3-x3) ).
  Square is a function(w) doing return w*w.
  ).

Go To Statement

GO TO label

A go-to statement tells the compiler that instead of performing the next statement, it should continue processing statements at the label.

Examples:

if x<10
  then go to XAlreadySmall
  else set x to x-1.
XAlreadySmall:

Set x to GetParameter(2).
If x is an error then go to ErrorMessage.
Go to x_is_not_an_error.
ErrorMessage: Write "Error".
XIsNotAnError:

If Statement

IF expression THEN statement
IF expression THEN statement1 ELSE statement2

An if-then-else statement can be ambiguous if it has another if statement nested inside of it. Flaming Thunder resolves the ambiguity the same way that most other programming languages do — by pairing each else with the most recent unpaired then.

For example, Flaming Thunder interprets

If expression1
then
if expression2
then statement1
else statement2.

as

If expression1
then
(if expression2
then statement1
else statement2.).

and not as:

Examples:

If x<10 then go to AllDone.

If x<5 then
  if x<2
  then write "x<2"
  else write "x>=2 and x<5"
else write "x>=5".

Procedure Call Statement

procedurename parameter1, parameter2, ..., parametern

A procedure call passes 0 or more parameters to a procedure, which performs some action on the parameters. Unlike functions, procedures typically don't return a value; the procedure is called because of the actions it performs and not because of any value it returns.

The number of parameters for a procedure depends on the procedure. The WriteLine procedure can take any number of parameters; the Read procedure must have one and only one parameter, and it must be a variable.

Examples:

# Writeline called with 0 parameters
# writes a blank line.
Writeline.

# ReadLine reads a line of input from
# standard input (usually the command
# line prompt) and saves it in a
# variable.
ReadLine user_input.

Repeat Statement

REPEAT statement UNTIL expression

A repeat statement repeatedly executes a statement until the expression doesn't evaluate to true.

The difference between a repeat statement and a while statement is that a repeat statement always executes statement at least once because the repeat statement evaluates expression at the end of the loop.

A repeat statement is exactly equivalent to:

TemporaryLabel:
    Statement.
    If expression = true go to TemporaryLabel.

Examples:

Set x to 3.
Repeat set x to x+x^2 until x>1_000_000.
Write x.

Repeat
  (
  Write "I'm not going to stop ",
        "until you type quit.".
  Read UserInput.
  )
Until UserInput = "quit".

Return Statement

RETURN expression

A return statement determines the value returned by a function.

Examples:

Double is a function(n) doing return n+n.

GetMagnitudeName is a function(n) doing
  (
  Set AbsN to AbsoluteValue(n).
  If AbsN < 10 then return "ones".
  If AbsN < 100 then return "tens".
  If AbsN < 1000 then return "hundreds".
  If AbsN < 10000 then return "thousands".
  Return "gazillions".
  ).

Set Statement

SET variable TO expression

Sets a variable to the value of the expression. To unset a variable, use an unset statement.

Examples:

Set i to 123*234.

Set x to interval(1.2, 1.3).

Unset Statement

UNSET variable

Undoes any previous set statements for the variable. After a variable is unset it will be treated symbolically.

Examples:

Set i to 10.
WriteLine i^3. # Will write 1000.
Unset i.
WriteLine i^3. # Will write i^3.

Unset x. # Unsetting an already unset variable
         # has no effect.

Variable Declaration Statement

identifier IS A VARIABLE

Explicity declares that the identifier is a variable. Explicity declaring a variable makes it local to the context (program or function) that it is declared it, and makes it global to contexts that are nested in the variable's context.

Variables do not have to be explicity declared. If a variable is used without being declared, Flaming Thunder internally creates a variable declaration for it in the highest context that the variable appears in.

Examples:

f is a function(x) doing (
  a is a variable.  # a is local to this function.
  set a to 3.
  return a*x.
).

f is a function(x) doing (
  set a to 3.  # if a is used in a higher level,
  return a*x.  # then a refers to the higher level a.
).

While Statement

WHILE expression DO statement

A while statement repeatedly evaluates an expression, and as long as the expression is true, it executes the statement.

The difference between a while statement and a repeat statement is that a while statement might not execute statement because it evaluates the expression before looping.

A while statement is exactly equivalent to:

TemporaryLabel1:
    If expression <> true go to TemporaryLabel2.
    Statement.
    Go to TemporaryLabel1.
TemporaryLabel2:

Examples:

While True Do (Read x. Write x.). # Infinite loop.

# Find the highest 4th power that's
# less than or equal to a million.
Set i to 1.
While i^4 <= 1_000_000 do set i to i+1.
Set i to i-1. # Decrement to cancel last increment.
WriteLine "i = ", i, " and i^4 = ", i^4.

Built-in Functions, Constants and Procedures

Most of the built-in functions, constants and procedures are self-explanatory.