The Script Programming Language

The Original SCI Documentation

The Script Programming Language

Author: Jeff Stephenson

Date: 4 April 1988

 

Introduction

The Script adventure game language is an object-oriented language with a Lisp-like syntax. It is compiled by the sc compiler into the pseudo-code which is used by the interpreter, sci.

We will begin our discussion of the language with its basic Lisp-like characteristics, then go on to the object-oriented parts of the language.

As is Lisp, Script is based on parenthesized expressions which return values. An expression is of the form

Code:

(procedure [parameter parameter ...]).

The parameters to a procedure may themselves be expressions to be evaluated, and may be nested until you lose track of the parentheses.

Unlike Lisp, the procedure itself may NOT be the result of an evaluation. An example of an expression is

Code:

(+ (- y 2) (/ x 3))

which would be written in infix notation as

Code:

      (y - 2) + (x / 3).

All expressions are guaranteed to be evaluated from left to right. Thus,

Code:

(= x 4)
(= y (/ (+= x 4) (/= x 2)))

will result in y = 2 and x = 4.

Comments in Script begin with a semi-colon, ';', and continue to the end of the line.

Files

Source files for the script compiler have the extension .sc, header (include) files have the extension .sh. Source files may have any filename -- banner.sc and castle.sc are two examples. The output file from the compilation will have the name script.nnn where nnn is determined from the script# command (covered below) which is present in the file.

There are six files besides the source file and any user-defined header files which are involved in a compilation.

classdef

This file contains the information about the structure of the classes which have been defined in the application. It is read automatically by the compiler and is rewritten by the compiler after a successful compilation in order to keep it up to date. The user need not be concerned with it.

selector

This contains definitions of selectors which are used in object-oriented programming. It is automatically included in a compile and, like classdef, is rewritten after a successful compile. Any symbol in a properties or methods statement or in the selector position in a send to an object is assumed to be a selector and is assigned a selector number in included in selector.

kernel.sh

This contains the definitions for interfacing with the kernel (the machine language interpreter). It is maintained by the kernel programmers and is automatically included in system.sh.

system.sh

This contains the definitions for interfacing with the various system classes. It is initially provided by the kernel programmers. If you wish to tweak the system scripts yourself, you will also be responsible for maintaining your copy of system.sh. It should be included in all compiles.

vocab.000

This is the compiled output of vocab.txt, generated by the vocabulary compiler vc. It is automatically included in a compile.

classtbl

This is an output file of the compiler which is used by the kernel to determine which script a given class is defined in. You needn't do anything to it other than not delete it.

There are two sc commands for dealing with source code organization:

script#:

The script# command sets the script number of the output file:

Code:

(script# 4)

sets the output file name to script.004, regardless of the actual name of the source file.

include:

This includes a header file in the current source file at the current position.

Code:

(include "/sc/foo.sh")

or

Code:

(include /sc/foo.sh)

include the file /sc/foo.sh. Include files may be nested as deeply as desired.

When including a file, the compiler first looks for the file in the current directory. If it fails to find it there, it then looks for it in the directories specified in the environment variable SINCLUDE. This variable is just like the DOS PATH variable -- the directories to search are separated by semi-colons. Thus, if you want the compiler to look for include files in f:/games/sci/system and c:/include if it doesn't find them in the current directory, you put the line

Code:

set sinclude=f:/games/sci/system;c:/include

in your autoexec.bat file.

Definitions

define:

The define statement allows you to define a symbol which will stand for a string of text:

Code:

(define symbol lots of text)

will replace symbol, wherever it is encountered as a token, with lots of text and then continue scanning at the beginning of the replacement text. Thus, if we write

Code:

(define symbol some text) 
(define some even more)

then

Code:

(symbol)

will become

Code:

(some text)

which then becomes

Code:

(even more text)

enum:

A construct for easing the definition of various states of a state-variable is enum. Say you want to walk an actor from the door of a room across the floor, up the stairs, and through another door. You have a state-variable called actor-pos which will take on a number of values, which could be defined with defines:

Code:

(local    actor-pos 
     (define at-front-door    0) 
     (define in-room          1) 
     (define on-stairs        2) 
     (define top-of-stairs    3) 
     (define upper-door       4) 
)

or you could get the same result with enum:

Code:

(local    actor-pos 
     (enum 
          at-front-door 
          in-room 
          on-stairs 
          top-of-stairs 
          upper-door 
     ) 
)

Enum defaults its first symbol to 0. If you want a different starting value, put it right after the word enum:

Code:

(enum 7 
     at-front-door 
     in-room 
     on-stairs 
     top-of-stairs 
     upper-door 
)

sets at-front-door to 7, in-room to 8, etc.

synonyms:

The synonyms statement defines synonyms of words. All words must have been defined in the vocabulary file (see separate Vocabulary documentation). The statement

Code:

(synonyms 
     (main-word  synonym1 synonym2 ...) 
     ... 
)

defines the words synonym1, synonym2, etc. to be synonyms of main-word. In input being interpreted by the script in which the synonym statement is defined, user input of synonym1 will be interpreted as if the user had typed main-word.

Data Types and Variables

Numbers:

All numbers in Script are 16 bit integers, giving a range of -32768 to +32767. Numbers may be written as decimal (1024), hex ($400), or binary (%10000000000).

Variables:

Variables hold numbers. Variables can be either global, local, or temporary, depending on when they are created and destroyed:

Global variables are created when the program starts and destroyed when it ends, and are thus accessible to all scripts at all times.

Local variables are created when a logic script is loaded and destroyed when it is purged. They are thus only available when the logic script is loaded and will not retain a value through a purge-reload cycle. You will find that, as your programming takes on a more object-oriented flavor, you will use fewer and fewer local variables.

Temporary variables are created when a procedure or method is entered and destroyed when it is left. They are thus only available to the declaring procedure and do not retain a value between calls to the procedure.

In order to throw the 'link' out of the traditional 'edit-compile- link-test' cycle of software development, YOU, rather than the linker, must define the address (i.e. variable number) of global variables. This is done with the global definition:

Code:

(global 
     var-name var-number 
     var-name var-number 
     ... 
)

This defines var-name to be global variable number var-number.

Local variables, not being accessible outside of the scripts in which they are declared and thus not requiring linking, can have their addresses set by the Script compiler. There are two ways of defining locals:

Code:

(local 
     var-name 
     var-name 
     ... 
)

defines a single variables with the names var-name.

Code:

(local [array-name n])

defines an array of n elements with the name array-name (the brackets in this do NOT mean 'optional' -- they are required).

Multiple local variable definitions may be combined in one statement:

Code:

(local 
     var1 
     [array1 10] 
     [array2 5] 
     var2 
          . 
          . 
          . 
)

Temporary variables will be discussed in the section on user-defined procedures.

Define and enum statements may be included within both global and local variable definitions.