Turing (programming language)

From Wikipedia, the free encyclopedia

The logo for the turing programming language

Turing is a Pascal-like programming language developed in 1982 by Ric Holt and James Cordy, then of University of Toronto, Canada. Turing is a descendant of Euclid, Pascal and SP/k that features a clean syntax and precise machine-independent semantics.

Named after British computer scientist Alan Turing, Turing is used primarily as a teaching language at the high school and university level. Two other versions exist, Object-Oriented Turing and Turing Plus, a systems programming variant. In September 2001, "Object Oriented Turing" was renamed "Turing" and the original Turing was renamed "Classic Turing". Turing is available from Holt Software Associates in Toronto. Versions for Microsoft Windows, and Apple Macintosh are available.

1 Syntax
2 References
3 External links
4 See also

[edit] Syntax

Turing is designed to have a very lightweight, readable, intuitive syntax. Here is the entire Hello World program in Turing:

put "Hello World!"

Turing avoids semicolons, braces and other redundant syntax, using explicit end markers for most language constructs instead, and allows declarations anywhere. Here is a complete program defining and using the traditional recursive function to calculate a factorial.

 % Accepts a number and calculates its factorial
 
 function  factorial (n: int) : real
   if n = 0 then
     result 1
   else
     result n * factorial(n-1)
   end if
 end factorial
 
 var n : int
 loop
   put "Please input an integer :" ..
   get n
   exit when n >= 0
   put "Input must be a non-negative integer."
 end loop
 
 put "The factorial of ", n, " is ", factorial(n)

Turing is particularly convenient for handling text strings - for example, here is a Turing program to conjugate regular French 'er' verbs.

 % Program to conjugate regular French verbs
 
 loop
     put "Please give me a regular French 'er' verb"
     var infinitive : string
     get infinitive
 
     put "Thanks, here is the present conjugation"
 
     var root := infinitive (1 .. *-2)
     put "The root of this verb is '", root, "'"
 
     if infinitive (*-1 .. *) = "er" then
 
         if root (1) = "a" or root (1) = "e" or root (1) = "i" 
                 or root (1) = "o" or root (1) = "u" then 
             put "J'" + root + "e"
         else
             put "Je " + root + "e"
         end if
 
         put "Tu " + root + "es"
         put "Il ou elle " + root + "e"
 
         if root (*) = "g" then
             put "Nous " + root + "eons"
         else
             put "Nous " + root + "ons"
       end if
 
         put "Vous " + root + "ez"
         put "Ils ou elles " + root + "ent"
 
     elsif infinitive (*-1 .. *) = "ir" then
         put "I'm too tired to do an 'ir' verb" 
 
     else 
         put "I don't like the looks of this verb"
     end if
 
     exit when infinitive = "arreter"
 end loop

This is an example of a simple game in Turing. Use the arrows to move and the HOME and END keys to jump to the beginning and end.

setscreen ("msdos")
const WAIT := 125
const NUMBER_OF_ASTERISKS := 10
const LEFT_ARROW := chr (203)
const RIGHT_ARROW := chr (205)
const HOME := chr (199)
const END := chr (207)
const BLOCKER_ROW := 24
var Asterisk_Column, Start, Finish : int
var Asterisk_Row := 2

const BLOCKER :=
    chr (220) + chr (220) + chr (220) + chr (220) + chr (220)
const BLANK_BLOCKER := "     "
var Key : string (1)
var Key_Code : int
var Blocker_Column := 38
var Blocker_Row := 24
setscreen ("noecho, nocursor")
put "Move the blocker with the <ARROW>, <HOME>, & <END> keys."

procedure Move_Blocker
    getch (Key)
    locate (Blocker_Row, Blocker_Column)
    put BLANK_BLOCKER
    if Key = RIGHT_ARROW then
        Blocker_Column := Blocker_Column + 2
    elsif Key = LEFT_ARROW then
        Blocker_Column := Blocker_Column - 2
    elsif Key = HOME then
        Blocker_Column := 2
    elsif Key = END then
        Blocker_Column := 75
    end if
    if Blocker_Column > 75 then
        Blocker_Column := 75
    elsif Blocker_Column < 2 then
        Blocker_Column := 2
    end if
    locate (Blocker_Row, Blocker_Column)
    put BLOCKER
end Move_Blocker

locate (Blocker_Row, Blocker_Column)
put BLOCKER
randomize
clock (Start)
for Asterisk : 1 .. NUMBER_OF_ASTERISKS
    locate (1, 1)
    put "Asterisk #", Asterisk
    randint (Asterisk_Column, 2, 79)
    loop
        locate (Asterisk_Row, Asterisk_Column)
        put "*" ..
        delay (WAIT)
        if hasch then
            Move_Blocker
        end if
        locate (Asterisk_Row, Asterisk_Column)
        put " "
        Asterisk_Row := Asterisk_Row + 1
        if Asterisk_Row > 24 then
            Asterisk_Row := 2
        end if
        if Asterisk_Column >= Blocker_Column and
                Asterisk_Column <= Blocker_Column + 4 and
                Asterisk_Row = 24 then
            sound (1000, 100)
            exit
        elsif Asterisk_Row = 24 and
                (Asterisk_Column < Blocker_Column or
                Asterisk_Column > Blocker_Column + 4) then
            sound (100, 100)
        end if
    end loop
end for
clock (Finish)
cls
put "TIME: ", (Finish - Start) / 1000, " Seconds."