CTCL

Turn statement

The turn statement is the natural verb to describe the changing of light patterns. Patterns, groups, blocks and outlets may be turned on, off, etc.

Usage

Here are some samples, assuming that the colors red, blue and green have been declared, and that we have structures (patterns or groups) called "row" and "column":

turn block 1 green           -- green lights in block 1 turned on, nothing off.
turn block 1 green off       -- green lights in block 1 turned on, all others off.
turn block 1 green blue off  -- green and blue lights in block 1 on, all others off.
turn block 1 off             -- turn all lights off in block 1.
turn block 1 off green       -- turn green lights off in block 1, leave others alone.
turn block 1 green off red   -- turn green lights on, red lights off in block 1.
turn block 1                 -- turn all lights on in block 1.
turn block 1 green off red blue -- turn green on, red and blue off in block 1.
turn block i red -- variable counters don't seem to work for blocks. Sorry.
turn row 2 blue              -- turn blue on in every block of group "row 2".
turn column i red            -- turn column i red, i = valid column number.
turn row (5 - j) color_a     -- calculate (5-j), turn that row color_a.
-- and for individual outlets,
turn outlet 5 on             -- kind of obvious, right?
turn outlet 5 off            -- ditto
turn outlet i on             -- where i = valid outlet number Oops! This may not work either
turn bush 3 on               -- where bush 3 is plugged into an outlet
turn bush i on               -- where i = valid bush number
turn bushes off              -- turn off bushes 1, 2, 3, ... in group "bushes"

The general syntax is:
turn structure_or_group [number] color_or_condition
where

• structure_or_group is a structure, group, block or outlet defined at the beginning of the program,
• [number] is used for numbered items, e.g. row 2, bush j, block 5. It may be a constant or an expression. Constants such as 5 and integer variables such as i may stand by themselves; however, more complex expressions such as (5-i) must be enclosed in parentheses.
• color_or_condition has two possible forms.
  1. For light structures on the tree (that have colors), we may turn color(s) on and color(s) off. Colors on are listed first, then the keyword "off", then color(s) turned off at the same time; for example to change the color of a row from red to green,
     turn row 2 green off red
     More than one color may be listed in each category. If the statement is terminated by off, all colors not turned on are turned off.
  2. For peripheral items such as bushes and the star controlled by single outlets, the only options are on and off.
  Note: Seems that the keywords block and outlet don't take kindly to being addressed with variables such as i. To get around this problem (yes, it's a stupid workaround!), define a structure such as

  2 blocks
    3 blk 1
      8 block 1
    3 blk 2
      8 block 2

  and so on. Stupid but it works.

How It Works

The structures are placed into a logical tree structure. The tree is housed in an array of integer pairs. The compiler's symbol table maps each name to an array subscript.

There are three types of records in the array. Interior nodes represent structures, patterns or groups. The first integer is the beginning subscript of the structure and the second integer is the ending subscript. The turn statement traverses the tree recursively until it gets to leaf nodes, which can be either blocks or outlets. Blocks and outlets are distinguished by having zero as the second integer. Blocks require further processing to determine which outlet corresponds to the color given, whereas outlets are either "off" or "on". Within the array, blocks are denoted by positive integers, outlets by negative.