The NewtonScript Programming Language (Alpha Draft 1.0)

7/27/2019 The NewtonScript Programming Language (Alpha Draft 1.0)

1/59

The NewtonScript ProgrammingLanguage

Alpha Draft 1.0

July 17, 1993PIE Technical Publications Apple Computer, Inc. 1993


2/59

Draft. Preliminary, Confidential. 1993 Apple Computer, Inc. 6/18/93

Apple Computer, Inc. 1993, Apple Computer, Inc.All rights reserved.No part of this publication or thesoftware described in it may bereproduced, stored in a retrievalsystem, or transmitted, in any form or

by any means, mechanical, electronic,photocopying, recording, or otherwise,without prior written permission ofApple Computer, Inc., except in thenormal use of the software or to make a

backup copy of the software. The sameproprietary and copyright notices must

be affixed to any permitted copies aswere affixed to the original. Thisexception does not allow copies to bemade for others, whether or not sold,

but all of the material purchased (withall backup copies) may be sold, given,or loaned to another person. Under thelaw, copying includes translating intoanother language or format. You mayuse the software on any computerowned by you, but extra copies cannot

be made for this purpose.Printed in the United States of America.The Apple logo is a registeredtrademark of Apple Computer, Inc.Use of the keyboard Apple logo(Option-Shift-K) for commercialpurposes without the prior writtenconsent of Apple may constitutetrademark infringement and unfaircompetition in violation of federal andstate laws.No licenses, express or implied, aregranted with respect to any of thetechnology described in this book.

Apple retains all intellectual propertyrights associated with the technologydescribed in this book. This book isintended to assist applicationdevelopers to develop applications onlyfor Apple Newton computers.

Apple Computer, Inc.20525 Mariani AvenueCupertino, CA 95014408-996-1010

Apple, the Apple logo, APDA,LaserWriter, the light bulb logo,Macintosh, and Newton are trademarksof Apple Computer, Inc., registered inthe United States and other countries.Newton ToolKit and QuickDraw are

trademarks of Apple Computer, Inc.Simultaneously published in the UnitedStates and Canada.

LIMITED WARRANTY ON MEDIA AND

REPLACEMENT

If you discover physical defects in the

manual or in the media on which a software

product is distributed, APDA will replace

the media or manual at no charge to you

provided you return the item to be replacedwith proof of purchase to APDA.

ALL IMPLIED WARRANTIES ON THIS

MANUAL, INCLUDING IMPLIED

WARRANTIES OF MERCHANTABILITY

AND FITNESS FOR A PARTICULAR

PURPOSE, ARE LIMITED IN DURATION

TO NINETY (90) DAYS FROM THE DATE

OF THE ORIGINAL RETAIL PURCHASE

OF THIS PRODUCT.

Even though Apple has reviewed this

manual, APPLE MAKES NO WARRANTY

OR REPRESENTATION, EITHER EXPRESS

OR IMPLIED, WITH RESPECT TO THIS

MANUAL, ITS QUALITY, ACCURACY,

MERCHANTABILITY, OR FITNESS FOR A

PARTICULAR PURPOSE. AS A RESULT,THIS MANUAL IS SOLD AS IS, AND

YOU, THE PURCHASER, ARE ASSUMING

THE ENTIRE RISK AS TO ITS QUALITY

AND ACCURACY.

IN NO EVENT WILL APPLE BE LIABLE

FOR DIRECT, INDIRECT, SPECIAL,

INCIDENTAL, OR CONSEQUENTIAL

DAMAGES RESULTING FROM ANY

DEFECT OR INACCURACY IN THIS

MANUAL, even if advised of the possibility

of such damages.

THE WARRANTY AND REMEDIES SET

FORTH ABOVE ARE EXCLUSIVE AND IN

LIEU OF ALL OTHERS, ORAL OR

WRITTEN, EXPRESS OR IMPLIED. No

Apple dealer, agent, or employee isauthorized to make any modification,

extension, or addition to this warranty.

Some states do not allow the exclusion or

limitation of implied warranties or liability

for incidental or consequential damages, so

the above limitation or exclusion may not

apply to you. This warranty gives you

specific legal rights, and you may also have

other rights which vary from state to state.


3/59

iii

Alpha Draft. Preliminary. 1993 Apple Computer, Inc. 7/17/93

Contents

Related Publications vii

Chapter 1 Data Types, Operators, and Expressions 1-1

Data Types 1-1Immediate References 1-1Integers 1-1Characters 1-2Booleans 1-2

Pointer References 1-2Symbols 1-3Strings 1-3Real numbers 1-4Arrays 1-4Frames 1-4

Operators and Expressions 1-5Assignments 1-5

Copying NewtonScript values 1-6Creating Frame Slots 1-7

Arithemetic operators 1-8Relational operators 1-8

Logical operators 1-9String Concatenators 1-9Exists 1-9

Accessing Frame Slots 1-10Path Expressions 1-10Accessing Array Elements 1-11

Precedence and evaluation order 1-11

Chapter 2 Flow of Control 2-1

Compound statements 2-1Conditional statements 2-1Iterators 2-2

Break 2-2For 2-3

Foreach 2-4Loop 2-6

While 2-6


4/59

iv


Repeat 2-6

Chapter 3 Functions 3-1

Defining Functions 3-1Return statement 3-1Local statement 3-2Constant statement 3-2

Parameter Passing 3-2Scope 3-3

Local variables 3-3Extent of Local Variables 3-4Application-Wide Variables 3-5

Chapter 4 Object-Oriented NewtonScript Programming 4-1

Inheritance 4-1Prototype Inheritance 4-1

Creating prototypes 4-2Prototype inheritance rules 4-2

Parent Inheritance 4-3Creating parent-child relationships 4-3Parent inheritance rules 4-4

Combining prototype and parent inheritance 4-4Inheritance rules for setting slot values 4-6

Interactions between functions and inheritance 4-6An object-oriented example 4-7Methods and messages 4-9Self 4-10Calling a function 4-10

Appendix A Reserved Words A-1

Appendix B Special Character Codes B-1

Appendix C NewtonScript Quick Reference Card C-1


5/59

v


Figures and Tables

Chapter 1 Data Types, Operators, and Expressions 1-1

Table 1-1 Characters with special meanings 1-2

Table 1-2 Special characters allowed within strings 1-3

Figure 1-1 Contrasting Assignment Statements in C and NewtonScript 1-6

Figure 1-2 How NewtonScript Handles Variable Assignments 1-7

Table 1-3 Operator precedence and evaluation order 1-12

Chapter 4 Object-Oriented NewtonScript Programming 4-1

Figure 4-1 Prototype frame 4-2

Figure 4-2 A prototype chain 4-3

Figure 4-3 Parent-child relationship 4-4

Figure 4-4 Prototype and parent inheritance interaction order 4-5

Figure 4-6 An inheritance structure 4-8

AAppendix B Special Character Codes B-1

Table A-1 Character codes sorted by Macintosh character code B-2

Table A-2 Character codes sorted by Unicode B-5


6/59

vi



7/59

vii

Alpha Draft, Preliminary. 1993 Apple Computer, Inc. 7/17/93

PREFACE

About This Book

This book, Newton Programmers Guide, is the definitive guide and referencefor anyone writing software for the Newton family of personal digitalassistants.

Note

The chapters in this book are at different stages of completion. Some areless complete than others. For all chapters, even the most complete ones,keep in mind that the information is preliminary, subject to change, andmay not consistently reflect the latest technical information available,although every effort is being made to supply you with information thatis as accurate as possible. u

Related Publications

The suite of Newton technical documentation includes these other books:

n A Guide to the Newton Toolkit. This book introduces you to the Newtondevelopment environment and teaches you how to develop Newtonapplications. You should read this book first if you are a new Newtonapplication developer.

n The NewtonScript Programming Language.. This book describes theNewtonScript programming language. If you are new to Newtondevelopment, you should read this book before the Newton ProgrammersGuide so that you are familiar with the language.


8/59

viii


PREFACE


9/59

CHAPTER 1

Data Types 1-1


Data Types, Operators, andExpressions

In NewtonScript, every statement in a script evaluates to a value. Therefore, everythingin NewtonScript programming is an expression.

This chapter discusses the basic components of the language, its data types, its operators,and some of the expressions you can make by combining the two. Many of the conceptshere are common to other programming languages.

Data Types

NewtonScript uses 32-bit references for data representation. There are two kinds ofreferences: immediate references, in which the reference contains the data, and pointerreferences, in which the reference contains a pointer to a heap object

Immediate References

An immediate reference can represent one of three types of data:

n integers

n characters

n Booleans, TRUE and NIL

The data is stored in 30 bits; the remaining two bits are flag bits.

Integers

Integers have no decimal place. They can be either signed or unsigned and areinterpreted as decimal numbers unless prefixed with 0x (zero and the letter x) to signifya hexadecimal value. Here are some examples of integers:


10/59

CHAPTER 1

Data Types, Operators, and Expressions

1-2 Data Types


13475 -86 0x56a

Note that there is a 30 bit limit on the size of integers. Behaviour when that limit isexceeded is undefined.

Characters

The character set in Newton is stored as Unicode, in two bytes, to facilitate internationalconversions. By design, the first 128 characters match the first 128 characters of theMacintosh standard character set. You must use Unicode character codes to specifycharacters higher than the first 128 in the character set (that is, special characters.)

Characters in the standard character set are specified in your code by the dollar sign. Forexample, $a or $7 represent the characters "a" and "7", respectively.

Special characters like "" must be specified as Unicode (16-bit) characters by using thefour-digit hex character code preceded by $\u. The Unicode equivalent of "" is:$\uF7FF

See Appendix C, "Special Character Codes" for a list of the special characters and theirUnicode equivalents. In addition to special printed characters there are other charactersthat have special meanings. They are shown in Table 1-1.

Table 1-1 Characters with special meanings

Booleans

Newton defines only two Boolean constants, TRUE and NIL. In conditional statements,anything that is not NIL is considered to be TRUE.

Pointer References

A pointer reference represents one of several kinds of heap objects,including:

n Symbolstags used to identify any kind of value

n Stringsquoted constants

n Real numbersimmutable floating point numbers

n Arraysa numbered collection of references

Character code Meaning

$x the character x$\n newline$\t

tab$\\ backslash$\xx hexadecimal$\uxxxx Unicode; see Appendix C, "Special Character Codes"


11/59

CHAPTER1


Data Types 1-3


n Framesa collection of named references

Symbols

NewtonScript symbols are like identifiers in other computer languages. A symbol is asequence of as many as 254 characters, including letters, trailing numbers, and theunderscore character '_'. A symbol

n cannot begin with a number

n can include capital and lower-case letters; (NewtonScript is case insensitive, though itpreserves case)

n can break the above rules (except the 254 character limit) if the symbol is enclosed invertical bars (|). For instance, |Walter Smith!| is a valid symbol, even though itcontains spaces and special characters

Symbols normally evaluate to the value of their contents. You can prevent this bypreceding the symbol name with a single quote ('). In this case the symbol evaluates tothe symbol itself.

Strings

A string constant is zero or more characters enclosed in double-quotation marks.Examples include

"pqr" "Now is the time" ""

You can include characters that are not in the standard character set in strings byinserting the escape code, \u, to toggle on the Unicode hex mode. Follow the \u with thefour-number code specifying the special character. If you need to return to the regular

character set, add another \u to toggle the Unicode hex mode off; however, you are notrequired to turn toggle the hex mode off. (See Appendix C, "Special Character Codes" fora list of the special characters.)

For example, you could specify the French phrase, "Garon, le billet, sil vous plat!", byembedding Unicode in the string to specify the special characters. You accomplish this asfollows:"Gar\u00e7\uon, le billet, sil vous pla\u00ee\ut!"

Other characters you can include in strings are summarized in Table 1-2.

Table 1-2 Special characters allowed within strings

Character Meaning

\n new line\t tab\u toggles Unicode on and off\\ backslash


12/59

CHAPTER 1


1-4 Data Types


Real numbers

Real numbers must contain a decimal point, which can appear any place within thenumber. Hence they are known as "floating point" real numbers. They are represented

internally in double precision, that is, in 64 bits. They have 15 digits of precision. Someexamples of real numbers include:-0.587 123.9 3.141592653589

You can also use exponential notation to represent real numbers. Simply follow the realnumber with an "e" and a signed integer exponent, in the range of -308...+308, as shownin these examples:763.112e4 87.3789e-45 -34.2e6 69.e-5

Real numbers are stored as binary objects and have the implicit class Real.

Arrays

Arrays are numbered lists of zero or more references, called array elements that areseperated by commas, and enclosed in brackets. The syntax of an array is:

[className1: element1 ,element2 ,elementn, ]

Here is a simple example of an array:[1,2,3]

Because this array does not include an explicit class name, NewtonScript assigns it theimplicit class Array. The Array designation simply gives the array a type; it does not giveit any special properties. You can specify a class name for your array by preceding thefirst array element with a class identifier and a trailing colon, as shown here:

[RandomData: [1,2,3], {check:"121", amount:9.00}, "Last element"]

Array elements may consist of any mixture of the data types that NewtonScriptsupports. Note that the RandomData array in this example contains another array as itsfirst element, a frame as the second element (this data type is discussed in the sectionFrames,) and a string as the third element.

NewtonScript numbers the elements in an array by beginning with zero for the firstelement. Therefore, element 0 in the RandomData array is the array [1,2,3].

Frames

A frame is the basic data object in a NewtonScript program. A frame, like an array, is alist of references separated by commas. However, the references in frames are namedrather than numbered.

A frame is enclosed in curly braces and is composed of zero or more slots, which arename: value pairs. The syntax of a frame is:


13/59

CHAPTER1


Operators and Expressions 1-5


{slotName1:value1 , slotName2:value2 , slotNameN:valueN, }

The slot name can consist of any valid symbol that refers to any valid NewtonScipt datatype. A frame can consist of any number of slots. Here is a simple example of a frame:{name:"Joe Bob", phone:"4-5678", employee:12345}

Slots can contain references to objects, including other frames and functions. Here is anexample of a frame containing another frame and a function:{ Jupiter:{size:491, distance:8110,speed:34},

position: func(foo) speed*foo/3.1416

}

You may specify an optional class for a frame. This is stored in a slot that you give thename class. Just as for array classes, the class of a frame gives it a type, not specialproperties.

You can also specify references to other frames by using the slot names _proto and_parent. These set up hierarchical and prototypical behaviors which you can use to

construct object-oriented programs. Chapter 3, "Inheritance," describes these conceptsand behaviors.

Operators and Expressions

NewtonScript operators include assignment operators, arithmetic operators, logical andrelational operators, messaging operators, array and frame element accessors, andbitwise operators.

Assignments

Data type declarations are unnecessary in NewtonScript; assignment statements servethe purpose of initializing variables. A simple assignment statement takes the forma := b;

The trailing semicolon is an optional statement separator. Essentially, an assignmentstatement looks like this:lvalue := expression

where lvalue is a variable, array or frame access expression.

Since all statements have a value, you could also construct the following assignmentstatement:x := if a > b then a else b;

Here is an example of the assignment of a frame reference to a symbol:myFrame := {name: "", phone: "123-4567"}

Once the frame has been created you can assign values to slots like this:myFrame.name := "Julia"

If the frame slot does not already exist it will be created.


14/59

CHAPTER 1


1-6 Operators and Expressions


You can construct arrays and assign values to them in a similar manner. The second lineof this code fragment changes the value 789 to 987.

myArray := [123, 456, 789, "a string"]

myArray [2] := 987

s Note

If you accidentally write an assignment statement as = rather than :=,your statement becomes a simple relational expression. For example, thestatementx = 5

returns TRUE or NIL and leaves the value of x unchanged. s

Copying NewtonScript values

NewtonScript, unlike C, does not copy the contents of a memory location when it makesan assignment. Instead, since most NewtonScript values are pointer references rather

than immediate references, NewtonScript merely reuses the reference rather thancopying the actual object. Figure 1-1 shows this difference graphically.

Figure 1-1 Contrasting Assignment Statements in C and NewtonScript

You can see how these differences manifest when you compare these code snippetexamples from the C programming language and NewtonScript. In the C example wehave the struct named foo that contains an integer member x. You then make twoinstances of the foo struct named a and b. You assign the integer 1 to the member x in thea structure. You then save the value of the a struct to the b struct and change the value of

the variable a.x to 2. As you expect, the value of the member b.x is 1 at this point in theexecution of the C code.C:

struct foo {

int x;

};

Cx=foo;

NewtonScriptx:=foo;

foomemory addresscontents2E

18E3

contents2Ex

foomemory addresscontents2E

18E3

contents18E3x


15/59

CHAPTER1




foo a;

foo b;

a.x = 1;

b = a;

a.x = 2;

// at this point b.x = 1

The equivalent code in NewtonScriptlocal a := {x: 1};

local b := a;

a.x := 2;

// at this point b.x = 2

gives a different outcome. The first assignment statement essentially creates the slot a.xand stores the integer 1 in it. In memory, NewtonScript creates an address for the slot a.xthat points to a memory location where the integer 1 is stored.

When the frame a is assigned to the local variable b, NewtonScript copies the addressreferring to the location of frame a, so that they share the identical contents. Both of thevariables, a and b, refer to the same memory location.

When that memory location is changed for one variable it is automatically changed forboth. See Figure 1-2 for a picture of the process.

Since the two variables share the same memory reference, the slot b.x is assigned thevalue of 2, by default, when the slot a.x is assigned the value of 2.

Figure 1-2 How NewtonScript Handles Variable Assignments

Creating Frame Slots

To create a new slot in a frame, simply assign a value to it. If the slot does not exist, it iscreated. As shown in the discussion above, the statement

aFrame:= {x: 1};

dynamically creates the frame, aFrame, with the slot, aFrame.x, and puts the value 1 intoit.

a:= {x: 1}; a.x memorycontents

18E318E3 address1

b:= a; b.x 18E3

a.x:= 2; a.x memory

contents

18E318E3 address2

b.x 18E3


16/59

CHAPTER 1




Note

The NewtonScript inheritance rules affect the ultimate behavior ofassignment statements in frames. For more information aboutinheritance and setting slot values see "Inheritance rules for setting slotvalues,"in Chapter 4.

Arithemetic operators

NewtonScript provides the standard set of binary arithmetic operators. They include, inorder of precedence:* / div mod + -

See Table 1-3 for a summary of operator precedence.

Relational operators

The relational operators are less than (=).

The equality operators are equal (=) and not equal ().

The relational and equality operators work the way you would expect them to work onimmediate reference data types. For referenced values, strings, arrays, and frames, thecontents are compared only with the relational operators, =. However, theequality operators actually compares pointers, not contents. For instance, if you type[1,2] = [1,2]

into the Newton ToolKit listener and press Return, it evaluates to NIL because the twoarrays are not the same object.

However, if you use the statement,x := [1,2]

to assign a reference to an array to the symbol x, then assign the same reference to thevariable y, and finally compare their equality using the statements,y := x

x = y

NewtonScript returns TRUE. You can see that the assignment statement copied thepointer values rather than the evaluating the pointers and copying the values stored atthe pointer address.

If you try the same exercise when an immediate value is stored in a variable, the result iswhat you would expect using a language like Pascal. NewtonScript returns the value

TRUE in response to the following lines of code:a := 1

b := a

a = b


17/59

CHAPTER1




Logical operators

The logical operators include the three reserved words:not and or

Like their counterparts, || and &&, in the C programming language, expressionsinvolving the logical operators

and or

stop evaluation as soon as the conclusion of the verity of the expression has beendetermined. For instance, if the value of the first half of the AND conditional expressionin the if statement

if x < length(someArray) AND someArray[x] = 42 then doSomething;

is NIL, then NewtonScript does not process the second part of the AND conditionalstatement.

Similarly, the OR statement stops executing as soon as one non-NIL value is determinedsince an OR logical operation only requires one TRUE value to make the wholestatement TRUE.

String Concatenators

The two string concatenators, && and &, concatenate strings by creating a new stringfrom the two strings you specify. You can also use these operators to concatenate objectsthat are not strings. For instance, the statement

"foo" & 17

returns the string

"foo17"

The single & operator also creates copies of two strings you specify and concatenatesthem by tacking one onto the end of the other with no space in between. In contrast, the&& operator concatenates the two strings you specify, by placing a space at the end ofthe copy of the first string and then placing a copy of the second string after the space.

Exists

Exists is a special postfix operator that is used to check for the existence of variables orslots. When you apply the exists operator to an identifier, such as a variable, it returnsTRUE if the variable is defined in the current context and NIL otherwise. (See"Scope" inChapter 2 for more informtion about the scope of variables.)

Here is an example of a simple IfThen structure that uses the exists operator:


18/59

CHAPTER 1




if myVar exists then myVar else 0

When you apply exists to a frame slot access expression (see the following section), existsreturns TRUE if the slot exists in the frame or any of its prototype frames, and NILotherwise. For more information about frames and inheritance, see Chapter 3

"Inheritance."Here are some examples (IfThen expressions are described below in the sectionCondition Expressions):

if myFrame.aSlot exists then

if not hasSlot(myFrame, 'aSlot) then

print("'aSlot slot is in a prototype of myFrame")

The built-in function hasSlot provides similar functionality to the exists operator. Thesefunctions differ in the type of inheritance that is used to search for slots. Refer to Chapter4, "Functions," to find out more about built-in NewtonScript functions.

Accessing Frame Slots

Slots in a particular frame can be accessed by using a frame identifier followed by a dot.For example, the expression myFrame.name returns the contents of the name slot fromthe frame named myFrame. If the slot does not exist, NewtonScript returns NIL.

If the slot is not found in the specified frame when you use the dot operator to access aframe slot, prototype inheritance is used to search prototype frames. However, thesearch does NOT continue up to the parent frame and its prototypes. The search usesonly prototype inheritance, not parent inheritance.

Three built-in functions, GetVar, GetVariable, and GetSlot, provide similar kinds of slotaccess, but with different inheritance behavior. Refer to the Newton Programmers Guidefor details.

Path Expressions

Alternatively, you can access frame data by using a path expression, like this:

myFrame.(expression)

where the path expression is enclosed in parentheses within a slot access expression.Here, the value of expression is used as the slot name. For example:

myFrame := {Name: "Joe", Title: "Cat"}

slotPath := 'TitlemyFrame.(slotPath)

The value of myFrame.(slotPath) is "Cat".

In this script, myFrame.(slotPath) evaluates to the Title slot, and the value Cat isreturned. The symbol 'Title represents the path to the slot named Title, of the framemyFrame. Longer path expressions are also allowed:


19/59

CHAPTER1


Precedence and evaluation order 1-11


> myFrame:={Kind:"Cat",Type:{Hair:"long",Color:"black"}}

> slotPath := 'Type.color

> myFrame.(slotPath)

The value of myFrame.(slotPath) is "black".

A path expression can also be expressed as an array with the class "pathExpr", whereeach array element is a slot in the path. For example, here is the previous example usingarray syntax for the path expression:

myFrame:={Kind:"Cat",Type:{Hair:"long",Color:"black"}}

slotPath := '[pathExpr: Type, color]

myFrame.(slotPath)

The value of myFrame.(slotPath) is "black".

Note this syntax: [pathExpr: Type, color]. This creates an array with the class "pathExpr".

Accessing Array Elements

Array elements are accessed with square brackets, for example:

myArray := [123, 456, "Alice's Restaurant"]

myArray[2]

The value of myArray[2] is "Alice's Restaurant".

This expression returns the contents of the third element in the array myArray. Notethat array indexes begin at zero.

Like frame slots, array elements can also be accessed using path expressions. The path to

an array element is simply the array index of the element. Here is an example:

aframe:={name:"Matt",info:{grade:"B",tests:[87,96,73]}}

mypath:='[pathExpr: info,tests,1]

myframe.(mypath)

The value of myFrame.(mypath) is 96.

Precedence and evaluation order

The precedence of operators is a set of ratings that tells the compiler which operator toevaluate first, in case it is not inherently apparent in the ststement. Table 1-3 lists theorder of precedence of all the NewtonScript operators in order from top to bottom. Notethat operators grouped together in the table are of equal precedence.

Evaluation order is simply the order in which the symbols in a line of code areprocessed. Most operators in NewtonScript are processed and evaluated from left to


20/59

CHAPTER 1


1-12 Precedence and evaluation order


right. The one notable exception is the assignment statement, which is evaluated fromright to left.

Table 1-3 Operator precedence and evaluation order

Operator Action Evaluation Order

. slot access left-to-right

::?

message sendconditional message send

left-to-right

[] array dereferencer left-to-right

- unary minus left-to-right

>

left shiftright shift

left-to-right

*

/divmod

multiply

float divisioninteger divisionremainder

left-to-right

+-

addsubtract

left-to-right

&

&&

concatenate (stringreplicant of exprs)concatenate with 1 spacebetween

left-to-right

exists variable & slot existence none

==

less thanless than or equal

greater thangreater than or equalequalnot equal

left-to-right

not logical not left-to-right

andor

logical andlogical or

left-to-right

:= assignment right-to-left


21/59

CHAPTER 2

2-1


Flow of Control

Flow of control in a NewtonScript program is determined by

n Compound statementsn Conditional statements

n Iterators

This chapter discusses the syntax and function of these constructs.

Compound statements

The BeginEnd construct is used to group statements. You can use these groupsanywhere the syntax calls for a single expression or statement. For example, you maywant to execute more than one action or expression in the then part of a conditional

statement. In that case you simply use the Begin and End statements to group thestatements as shown here:

if x=length(myArray) then

begin

result := :read(x);

print(result)

end

The return value of a BeginEnd block is the value of either the last expression in theblock or the value of an executed Return statement. Note that the optional trailingsemi-colon doesnt affect the return value of the last statement.

Conditional statements

Conditional expressions have the following syntax:if testExpression then firstStatement

else alternateStatement


22/59

CHAPTER2

Flow of Control

2-2


If testExpression evaluates to anything other than NIL, it is considered TRUE.

As is standard in other programming languages, the statement following thetestExpression is executed if testExpression is not NIL (true) and its value is returned.Note that not all statements return a value. For instance,

if x > 12 then Print(x);

returns NIL.

If you have a test expression that evaluates to NIL, the optional alternate statement ofthe else clause is evaluated. If there is no else statement, NewtonScript returns NIL.

Iterators

Like all other NewtonScript expressions, iterative statements also return a value. Theiterators normally return a NIL value unless a Break statement, which can be used to

stop execution of a loop, is executed. As in other programming languages, loops can benested.

NewtonScript includes these iterators:

n For

n Foreach

n Loop

n While

n Repeat

s Warning

Loops are not valid at the top level, that is, outside of a function. Thisshouldt be a problem in actual coding because you wouldnt put a loopat the top level, except when testing or debugging. For more informationabout function specifications see s

Break

While not an iterator itself, the Break statement interrupts the execution of any of theiterative structures. You must use the Break statement to stop the simple Loop structure,which has no built-in constructs to stop it. See the section Loop in this chapter to findout more about that structure. The syntax of the Break statement is:

break expression;

The Break statement optionally takes an argument that is an expression, which isevaluated and returned as the value of the loop. If you use the Break statement with noexpression, the loop returns the value NIL.


23/59

CHAPTER2

Flow of Control

2-3


For

You use a For loop to perform an action repeatedly, until a loop counter variable reachesa certain value or a break statement is reached.

The syntax of a For loop is:

for counter:= initialExpression to limitExpression

by incrExpression do statement;

When a For loop starts, the counter variable is set to the value of the initial expressionvariable. The values of the initial expression and the limit expression variables are setjust once. If you do not specify a value for the incremental expression, NewtonScriptuses a default value of 1. The incremental expression must be an integer. A value of zerois an error.

After each repetition of the loop, the counter is incremented by the value of theincremental expression.

If the incrExpression variable is positive, the loop test is

counter = limitExpression

If the value of the intial expression is less than the value of the limit expression then thestatement in the loop is executed and the counter variable is incremented by either thedefault value of 1 (if no incremental expression is specified) or by the value of theincremental expression.

After each repetition of the loop, the counter is incremented by the value of theincremental expression, which of course can be negative, or by the default value of 1.Again, if the incremental expression is zero, an error is generated at runtime.

Here is an example:

for x:=1 to 10 by 2 do

print(x);

1

3

5

7

9

The value of counter is undefined on loop exit. It is an error to change the value ofcounter from within the loop body. If you do so, the loop behavior is undefined.

As usual, you can use a group of statements enclosed in a BeginEnd block, instead of asingle statement, inside a For loop.


24/59

CHAPTER2

Flow of Control

2-4


Foreach

Looping with Foreach allows you to iterate an action over each element of an array orframe. The syntax of the Foreach loop is as follows:

foreach slot, element in frameOrArraydo|collect statement;

This loop executes once for each element in an array or frame. On each iteration, the slotvariable takes the value of the next array index or frame slot name, and the elementvariable takes the value of the next array element or frame slot, beginning with the firstelement in the array or frame. Using both slot and element variables is optional, andwhen you specify just one variable, it is assigned the element value.

Note that the values of slot and element are undefined on loop exit.

Here is an example using the Foreach loop to print slot names and values for a frame:

myFrame := {name:"Carol", office:"San Diego", phone:"123-4567"};

foreach slot, value in myFrame dobegin

print(slot);

print(value)

end

The output it returns is:

name

"Carol"

office

"San Diego"

phone

"123-4567"

Here is an example for an array:

myArray := ["John", "Mary", "Christine", "Mark"];

foreach index, value in myArray do

begin

print(index);

print(value)

end

0

"John"

1

"Mary"

2

"Christine"

3


25/59

CHAPTER2

Flow of Control

2-5


"Mark"

The alternative form of the Foreach loop uses the keyword "collect". In this variation, theresults of the iteration are collected into an array which is returned. For example, thecode snippet

myFrame := {name:"Carol", office:"San Diego",phone:"123-4567"};

results := foreach value in myFrame collect value;

print(results);

gives you an easy way to collect data and print it out, producing the output:["Carol", "San Diego", "123-4567"]

Heres an example of some code that collects and prints both the slot names and values:

results := foreach slot,value in myFrame collect

[slot,value];

print(results);

This example produces this output:

[[name, "Carol"], [office, "San Diego"], [phone, "123-4567"]]

s Warning

Do not add or remove slots to a frame when youre within a loop thatiterates over that frame; the results may be unpredictable! (Though it isnot recommended, you can remove the current slot in an array.) s

Setting values from within a loop

If you are setting the value of several slots to a constant string by using a single

statement in a loop to iterate over the slots, all the slots will contain the same pointer. (SeeCopying NewtonScript values, in Chapter 1 for a discussion of this behavior.) Whenthe value of one slot is changed, all the slots in the group receive the same value.Consider this example:

a := [f1, f2]

local f;

foreach f in a do begin

SetValue(f, 'text, "")

end

The text slot in both frames f1 and f2 will contain a pointer to the same string value,

which is probably not what you want. If you want to initialize empty strings like this, itsbest to set the value to NIL, not to the empty string. Another solution is to use the Clonefunction to clone the empty string as in the statementSetValue(f, 'text, Clone(""))

See the NewtonScript Programmers Guide for details.


26/59

CHAPTER2

Flow of Control

2-6


Loop

The syntax of the Loop statement is as follows:

loop statement;

This is a simple looping mechanism that simply repeats the statements within the loopuntil a Break statement is encountered. This example prints the value of the variable xuntil it reaches the value of 0 and the break statement is executed.

x:=4

loop if x = 0 then break

else

begin

print(x);

x:=x-1

end

4

3

2

1

While

The syntax of the While loop is as follows:

while expression do statement;

The While loop works by evaluating the test expression first. If the test evaluates tonon-NIL, then the statement after the keyword do executes. This sequence repeats untilthe test expression evaluates to NIL and the loop ends.

Repeat

The syntax of the Repeat loop is as follows:

repeat

action

until expression;

The Repeat loop executes the action specified by the statements inside the loop first andthen evaluates the test expression. If the expression at the end of the loop evaluates toNIL, the statement actions repeat and the test expression is evaluated again, and so onuntil the expression evaluates to non-NIL. At this point the loop ends.


27/59

CHAPTER 2

Defining Functions 3-1


Functions

This chapter describes NewtonScript functions.

Defining Functions

The general syntax of a NewtonScript function is:

functionName: func(param1,param2,paramN) statements

You may specify zero or more parameters in the parameter list of your function. Theparentheses must appear. The body of the function is typically a group of statementsenclosed by the Begin and End keywords, although it could be a single statement.

A function returns a value, typically the value of the last statement enclosed in aBeginEnd block. This sample function diff returns the value of the difference betweenits two parameters:

diff: func(n1, n2)

begin

if n1 > n2 then return n1 - n2

else return n2 - n1;

end

Return statement

The Return statement sets a functions return value. The syntax of the return statement is

return expression;

The expression is optional. If it appears, the value of the expression is returned as thevalue of the function. If no expression follows the keyword Return, NewtonScriptreturns NIL as the function value.


28/59

CHAPTER2

Functions

3-2 Parameter Passing


Local statement

You define variables that are local to a function by using the Local statement, which hasthe syntax:

local var1, var2, varN, varName := value;

If you dont assign an initial value for a local variable, its assigned the default valueNIL. For example, the statement

local x, y:= 2, z;

creates three local variables, x, y, and z, and initalizes them to the values of NIL , 2, andNIL, respecitvely.

Constant statement

You define constants by using the Constant statement. Like local variables, constantsmay be defined and initialized in one statement. The syntax for a constant is:

constant name1 ,name2, nameN, constantName := value;

These sample Constant statements define and initialize constants of various data types.

constant thisConstant := 32;

constant thatConstant := "Mike";

constant anotherOne := _symbol ;

Parameter Passing

NewtonScript functions pass parameters using the call-by-value mechanism. If you alterthe value of a parameter, as in the function

func foo(x) x := 1;

the change is not permanent and is not detected outside the function. In other words,when an argument is an immediate reference data type, as in this example, the functioncannot affect the argument passed to it.

If the argument is a pointer reference to a structured data typefor example, if its anarray, frame, or stringthen any changes your function makes to the internal values of

that argument are persistent.Consider the following code fragments that make persistant changes:

func foo(x) x[0] := 1; // sets 1st element of array arguments

func foo(x) x.slot1 := 1; // sets slot1 of frame


29/59

CHAPTER2

Functions

Scope 3-3


Scope

The part of a program within which a variable can be used is called the scope of thevariable. Normally a variable is available within the function or frame where it isdefined, although a frame variable (slot) can also be inherited from prototype and parentframes. (See Chapter 3, "Object-Oriented NewtonScript Programming," for moreinformation about inheritance.) Variables that are accessible only in a certain parts of aprogram are called local variables.

Local variables

You can ensure that a variable is local to a function, and not inherited from the caller orother context (due to dynamic scoping), by using the Local statement to declare it beforeinitializing it. For example:

myFunc: func (x)

begin

local myVar, counter;

...

end

This example declares the variables myVar and counter as local variables. Each time thefunction is executed, they are created as separate variables, unique to the functionmyFunc.

Local variables can also be initialized when they are declared, like this:local x:=3, y:=2+2;

The declaration of the local variable is processed at compile time; the values are assignedat runtime, when the statement is encountered. For example, the statements

x := 10;

local x, y := 20;

result in a value of 10 for x and a value of 20 for y. This works because y has beendeclared as a local variable and initialized to the value NIL at compile time.

By contrast, the statements

x := y + 10;

local x, y := 20;

result in a runtime error. Because local variables are not initialized until runtime, the firststatement is an attempt to add NIL to 10, which produces an error.


30/59

CHAPTER2

Functions

3-4 Scope


Attempting to access the value of an undefined variable results in a runtime error.Attempting to assign a value to an undefined variable creates a local variable of thespecified name.

When looking up a variable, NewtonScript first searches the local variables, then the

global variables, and then the inherited variables (through the proto and parent chains,as described in the previous chapter).

For purposes of scope, BeginEnd blocks do not isolate local variables. For example:

f := {foo: 10,

bar: func(x)

begin

if foo then Print ("hello") ;

if x > 0 then

begin

local foo;

foo := 42;

end;

return foo;

end;

}

For any value of x, nothing is printed. The variable foo has an initial value of NIL.Although the compiler has created a local variable foo, the variable is not initialized untilthe If statement that assigns it the value 42 executes.

The return value of

f:bar( 10 )

is 42. The return value of

f:bar( -5 )

is undefined.

Extent of Local Variables

NewtonScript doesnt necessarily free up the storage associated with a data structurewhen control exits the function block. Instead, it waits until a data structure is no longerreferenced anywhere in executing code. Therefore, storage allocated for data structures is

available until all references to the structures are deleted. Consider this example:


31/59

CHAPTER2

Functions

Scope 3-5


func () begin

local myArray := [1,2,3,4];

return myArray;

end

The storage asscociated with myArray isnt freed up when control exits the functionblock. Therefore, if youre allocating large data structures you should make sure not toleave any references to them after youre done using them. If you do, NewtonScript willnot reclaim the associated memory.

By contrast, consider this buggy C code:

int* fn (void) {int myArray[] = {1,2,3,4};

return myArray;

}

The problem is that when control exits the function block, the storage for myArray isdeallocated, and pointer returned by the function merely points to some location in thestack.

Application-Wide Variables

Unlike local variables, slots that are created in the top-level (highest parent) frame ofyour application are available throughout. (For information on parent inheritance inNewtonScript, see Chapter 3, "Object-Oriented NewtonScript Programming."

For example:

myApp := {// Here are the globals

myErrorBase: 5000,

appName: "SampleApp"

player: nil,

. . .

}

Because these slots are defined and initialized at the top level, they are inherited by allchild views of the application.


32/59

CHAPTER2

Functions

3-6 Scope



33/59

CHAPTER4

Inheritance 4-1


Object-Oriented NewtonScriptProgramming

NewtonScript supports several object-oriented features and concepts through itsinheritance system. NewtonScript uses frames as the basic data structure and inheritanceis set up through the _parent and _proto slots in a frame. Methods are implemented asslots containing functions, and messages can be set using a special message sendingsyntax. This chapter describes parent and prototype inheritance as well as

n how to set up frames with these relationships

n the rules associated with parent and prototype inheritance

n how inheritance affects setting slot values

n the uses of parent and prototype inheritance

Inheritance

There are two kinds of inheritance in NewtonScript: prototype inheritance and parentinheritance.

Prototype Inheritance

A frame can have a prototype, which is simply another frame it references in a special

way. A frame inherits slots from its prototype if it does not contain them in itself. If aframe contains a slot with the same name as a slot in the prototype, it overrides theprototype slot.

You use inheritance from prototype frames (abbreviated as protos) for

n object refinementin the Newton system there are many system prototypes you canuse whenever you need them


34/59

CHAPTER 4

Object-Oriented NewtonScript Programming

4-2 Inheritance


n persistent storage of data this must be something that does not change

Creating prototypes

You create a prototype relationship between frames by using a special slot named: _protowhose value references the frame you want to use as your prototype frame. For example,to use a frame called pageTemplate as a prototype for a frame called myPage, youinclude a _proto slot whose value is a pointer to the pageTemplate frame. This isillustrated in Figure 4-1.

Figure 4-1 Prototype frame

Prototype inheritance rules

If during runtime a function in the frame myPage references the slot named topMargin,as shown in Figure 4-1, the interpreter looks first at the frame myPage. It doesnt find theslot named topMargin so it follows the _proto reference to its prototype frame,pageTemplate, where it finds the slot and gets the value 1. In this case, the frame myPageinherits that slot. However, if a function in the frame myPage, references the slot namedleftMargin, that slot is found in the current frame and evaluates to the value 0.75. In thiscase, the current frame overrides the value of the prototype.

Note that since frame slots can contain functions as well as simple expressions, functionscan also be inherited and overridden.

The system obtains values during runtime by following the prototype inheritance rulesfor looking up slot references. NewtonScript looks first in the current frame for a slotname. If the slot is not found, it looks at the prototype frame, and if the slot is still notfound, it looks at that frames prototype frame, and so on, through all the prototypes inthe chain.

myPage

{_proto: pageTemplate

leftMargin: 0.75}

pageTemplate

This frame serves as

a prototype

{topMargin: 1bottomMargin: 2

leftMargin: 1.5rightMargin: 1.5}


35/59

CHAPTER 4


Inheritance 4-3


An example of a prototype chain is shown in Figure 2-2. In this figure, the inheritancechain starts with the current frame, myPage, and follows the arrows to its prototypesframes on the right.

Figure 4-2 A prototype chain

Parent InheritanceBesides prototypical relationships between frames, you can set up hierarchicalparent-child relationships.

Inheritance from parent frames is used for

n sharing information between objects behavior and data objects, for example

n creating hierarchies, like the view hierarchy of Newton

Creating parent-child relationships

The parent-child link between frames exists by way of a slot named _parent, which exists

in the child frame. You can set this slot directly in your code or you can use the drawingtools in the Newton Toolkit to create view hierarchies. See Getting Started with theNewton Toolkit for more information about how to do this. Figure 4-3 shows anexample of a parent-child relationship between two frames.

my age

_proto :

.

.

}

page emplate some rame some ther rame

_proto :

.

.

}

_proto:

.

.

}

_proto :

.

.

}


36/59

CHAPTER 4


4-4 Inheritance


Figure 4-3 Parent-child relationship

Frames that serve as parents can themselves be children of other frames, thereby formingan inheritance chain extending upwards.

Parent inheritance rules

When you create parent-child hierarchies between frames, NewtonScript uses aninheritance mechanism that works similarly to prototype inheritance.

As in prototype inheritance a child frame inherits slots from its parent that it does notitself contain. However, if a child frame contains a slot name that is the same as one in aparent frame, the child slot overrides the parent.

Combining prototype and parent inheritance

In practice, most frames have prototypes and parents. When a slot is referenced duringruntime, the parent inheritance mechanism interacts with the prototype inheritancemechanism.

The rules for inheritance order are really very simple:

1. NewtonScript looks first in the current frame for a referenced slot. (Unless youspecifically reference a different frame with a dot operator expression likemyDoc.header. In that case, the search begins in the referenced frame, myDoc, and

myPage

{_parent: myDoc.

.}

myDoc

{...

}Parent

Child


37/59

CHAPTER 4


Inheritance 4-5


moves forward to include only prototype frames of myDocparent inheritance doesnot apply. For details on using the dot operator to access frame slots see the sectionAccessing Frame Slots.)

2. If the slot is not found, the prototype chain of the current frame is searched.

3. If the slot is still not found, the search moves up one level to the parent frame. Theparent and its prototype chain are searched in order. The search then moves upanother level (to the parents parent) and continues in the same way until the slot isfound.

The numbers in Figure 4-4 indicate the order that frames are searched for a slot referencethat is made from a function in the current frame.

Figure 4-4 Prototype and parent inheritance interaction order

Basically, prototype inheritance takes precedence over parent inheritance; all prototypeframes on one level are searched before moving up to search a parent frame and itsprototypes on another level.

myPage

_parent: my hap

_proto : pageTemplate

leftMargin: 0.75

}

pageTemplate

_proto: section emp

topMargin: 1

bottomMargin: 2

leftMargin: 1.5

rightMargin: 1.5sides: single

}

section emp

si es: nil

.

.

}

myChap

{_parent: myDoc

_proto: chapTemplate

sides: double

chapNum: 2

}

chapTemplate

{chapNum: nil

header: true.

}

my oc

{_proto: baseDoc

header: nil

footer: 2

}

docTemplate

{_proto: docTemplate

footer: 1

}

baseDoc

{paperSize: standard..

}

1

4

6

2

5

7 8

3

urrent

Frame


38/59

CHAPTER 4


4-6 Interactions between functions and inheritance


s Note

You can use the Inherited keyword when executing a function, to forcean inherited version of the function to be executed rather than theversion in the current frame. This only works with prototypeinheritance. s

Inheritance rules for setting slot values

Inheritance rules apply not only when a slot is referenced, but also when its value is set.However, the rules are different for setting a slot.

The basic difference is that slot values are only changed in parent frames during runtime.They are never changed in prototype frames during runtime. One reason for this is thatprototype frames often exist in ROM and therefore, cannot be changed. (Of course, whenyou are first creating the prototype frames their slots can be set, but not when theapplication is running.)

When setting a slot, the inheritance search is the same as for slot reference, except thatthe slot is not always set where it is found.

These are the rules for where a slot is set:

1. If a slot exists in the current frame, its value is set there.

2. If the slot exists the prototype chain of the current frame, it is copied into the currentframe and its value is set there.

3. If the slot exists in the parent of the current frame, its value is set in that parent frame.

4. If the slot exists in the prototype chain of the parent, it is copied into the parent frameat the same level where it was found, and its value is set in that parent frame.

Note that if you create the slot from within a function, it is created as a local variable

within the scope of the function only. If you want to make sure the slot is created as aglobal in the current frame, you must use the special frame specifier Self. Self alwaysrefers to the frame in which execution is occurring.

If you want to explicitly set the value of a slot in the parent of the current frame, you canuse the expression Self._parent.theSlot to force the slot to be created there.

Interactions between functions and inheritance

NewtonScript saves information about the context of a NewtonScript function (unlike

function pointers that are references to blocks of code in C.)In NewtonScript, a function object is created when the keyword func compiles. Considerthe simple function:


39/59

CHAPTER 4


Interactions between functions and inheritance 4-7


simpleFunction := func(x) x+y;

Along with the code, NewtonScript saves information about the frame in which it wasdefined (its lexical environment) and about what frame received the message (itsreceiver environment.) An example of the frame object is shown in Figure 4-5.

Figure 4-5 Functions in NewtonScript contain information about their lexical and receiverenvironment.

When the function is called with x as a parameter, NewtonScript looks for the freevariable y, first in the frame where the function is defined. If it doesnt find a value thereit continues looking in the inheritance chain.

An object-oriented example

The inheritance structure shown in Figure 2-6 demonstrates some of the essentials ofsending messages.

Lexicalenvironment

Receiverenvironment

Code func (x)x + y

self

Defining code block


40/59

CHAPTER 4




Figure 4-6 An inheritance structure

You construct this using the code:

frame1 := {

slot1: "slot1 from frame1",

slot6: 99; };

frame2 := {

_parent: frame1,

slot1: "slot1 from frame2"slot2: "slot2 from frame2",};

frame3 := {

slot3: "slot3 from frame3",

slot5: 42,};

frame1

{slot1: "slot1 frame1"

slot6: 99}

frame2

{_parent: frame1

slot1: "slot1 frame2"

slot2: "slot2 frame2"

}

frame3

{slot3: "slot3 frame3"

slot5: 42}

frame4

{_parent: frame2

_proto: frame3

msg1: func() }


41/59

CHAPTER 4


Interactions between functions and inheritance 4-9


frame4 := {

_parent: frame2,

_proto: frame3,

msg1: func()

begin

//show slot from parent inheritance

Print(slot1);

//show slot from proto inheritance

Print(slot3);

//show slot from parent inheritance - again -

//but doesn't work cause

// self.slot1 only searches proto chain

Print(self.slot1);

//show slot from proto inheritance - again

Print(self.slot3);

end

Methods and messages

Methods in NewtonScript are nothing more than functions defined in a frame slot. As inother object-oriented languages, you can send methods as messages to objects (frames)

that exist in your code. The syntax you use to send a message is:

frameExpression : messageName (args)

Using this syntax, you are actually sending the message, messageName along with anyarguments, to the frame (that is the value of the frame expression) on the left side of thecolon.

In the example, if you type the command line

> frame4:msg1()

you are sending msg1 to frame4. This produces the output:

"slot1 from frame2"

"slot3 from frame3"

NIL

"slot3 from frame3"

#2 NIL


42/59

CHAPTER 4




Self

As mentioned earlier, there is a special variable, named Self, that you can use in yourscript code. It always evaluates to the receiver; that is, the last frame which received a

message. This is almost always the frame in which execution is currently occurring.

Calling a function

You rarely call functions using NewtonScript. There is, however, a syntax for calling afunction. It is:

call functionExpression with (arg)

Note that another way to call a function is to use the built-in Newton function

apply(functionExpression,[args])

The second syntax may actually be preferable to the first, since it allows you todynamically set the arguments.

It is important to be aware that when you call a function, the system variable is set to theframe in which the function is called.


43/59

APPENDIX A

A-1


Reserved Words

The following words are reserved in NewtonScript. You may not use any of these wordsas symbols unless you enclose the word in vertical bars, like this: |self|.

and

begin

break

by

call

collect

do

div

else

end

exists

for

foreach

fromfunc

global

if

in

inherited

local

loop

mod

not

onexception

or

repeat

return


44/59

APPENDIX A

Reserved Words

A-2


self

send

set

thento

try

until

while

with


45/59

APPENDIX B

B-1


Special Character Codes

This appendix contains a character code table that has both Macintosh and Unicode(16-bit) character codes for the high 128 characters in the Newton character set(characters 128 through 254). When specifying character constants or strings that containcharacters from the high 128 characters, you must use unicode character codes. TheMacintosh character codes are provided for convenience if you are used to using them.


46/59

APPENDIX B


B-2


Table A-1 Character codes sorted by Macintosh character code

Mac Unicode Char

80 00C4

81 00C5

82 00C7

83 00C9

84 00D1

85 00D6

86 00DC

87 00E1

88 00E0

89 00E2

8A 00E4 8B 00E3

8C 00E5

8D 00E7

8E 00E9

8F 00E8

90 00EA

91 00EB

92 00ED

93 00EC

94 00EE 95 00EF

96 00F1

97 00F3

98 00F2

99 00F4

9A 00F6

9B 00F5

9C 00FA

9D 00F9 9E 00FB

9F 00FC

A0 2020

A1 00B0

A2 00A2


47/59

APPENDIX B


B-3

Alpha Draft. Preliminary 1993 Apple Computer, Inc. 7/17/93

A3 00A3

A4 00A7

A5 2022A6 00B6

A7 00DF

A8 00AE

A9 00A9

AA 2122

AB 00B4

AC 00A8

AD 2260

AE 00C6 AF 00D8

B0 221E

B1 00B1

B2 2264

B3 2265

B4 00A5

B5 00B5

B6 2202

B7 2211

B8 220F B9 03C0

BA 222B

BB 00AA

BC 00BA

BD 2126

BE 00E6

BF 00F8

C0 00BF

C1 00A1

C2 00AC

C3 221A

C4 0192

C5 2248

C6 2206

Mac Unicode Char


48/59

APPENDIX B


B-4


C7 00AB

C8 00BB

C9 2026 CA 00A0

CB 00C0

CC 00C3

CD 00D5

CE 0152

CF 0153

D0 2013

D1 2014

D2 201CD3 201D

D4 2018

D5 2019

D6 00F7

D7 25CA

D8 00FF

D9 0178

DA 2044

DB 00A4

DC 2039 DD 203A

DE FB01 fi

DF FB02 fl

E0 2021

E1 00B7

E2 201A

E3 201E

E4 2030

E5 00C2

E6 00CA

E7 00C1

E8 00CB

E9 00C8

EA 00CD

Mac Unicode Char


49/59

APPENDIX B


B-5


Table A-2 Character codes sorted by Unicode

EB 00CE

EC 00CF

ED 00CC EE 00D3

EF 00D4

F0 F7FF F1 00D2

F2 00DA

F3 00DB

F4 00D9

F5 0131

F6 02C6 F7 02DC

F8 00AF

F9 02D8

FA 02D9

FB 02DA

FC 00B8

FD 02DD

FE 02DB

FF 02C7

Mac Unicode Char

CA 00A0

C1 00A1

A2 00A2 A3 00A3

DB 00A4

B4 00A5

A4 00A7

AC 00A8

Mac Unicode Char


50/59

APPENDIX B


B-6


A9 00A9

BB 00AA

C7 00AB C2 00AC

A8 00AE

F8 00AF

A1 00B0

B1 00B1

AB 00B4

B5 00B5

A6 00B6

E1 00B7 FC 00B8

BC 00BA

C8 00BB

C0 00BF

CB 00C0

E7 00C1

E5 00C2

CC 00C3

80 00C4

81 00C5 AE 00C6

82 00C7

E9 00C8

83 00C9

E6 00CA

E8 00CB

ED 00CC

EA 00CD

EB 00CE

EC 00CF

84 00D1

F1 00D2

EE 00D3

EF 00D4

Mac Unicode Char


51/59

APPENDIX B


B-7


CD 00D5

85 00D6

AF 00D8 F4 00D9

F2 00DA

F3 00DB

86 00DC

A7 00DF

88 00E0

87 00E1

89 00E2

8B 00E3 8A 00E4

8C 00E5

BE 00E6

8D 00E7

8F 00E8

8E 00E9

90 00EA

91 00EB

93 00EC

92 00ED 94 00EE

95 00EF

96 00F1

98 00F2

97 00F3

99 00F4

9B 00F5

9A 00F6

D6 00F7

BF 00F8

9D 00F9

9C 00FA

9E 00FB

9F 00FC

Mac Unicode Char


52/59

APPENDIX B


B-8


D8 00FF

F5 0131

CE 0152 CF 0153

D9 0178

C4 0192

F6 02C6

FF 02C7

F9 02D8

FA 02D9

FB 02DA

FE 02DB F7 02DC

FD 02DD

B9 03C0

D0 2013

D1 2014

D4 2018

D5 2019

E2 201A

D2 201C

D3 201DE3 201E

A0 2020

E0 2021

A5 2022

C9 2026

E4 2030

DC 2039

DD 203A

DA 2044

AA 2122

BD 2126

B6 2202

C6 2206

B8 220F

Mac Unicode Char


53/59

APPENDIX B


B-9


B7 2211

C3 221A

B0 221E BA 222B

C5 2248

AD 2260

B2 2264

B3 2265

D7 25CA

F0 F7FF DE FB01 fi

DF FB02 fl

Mac Unicode Char


54/59

APPENDIX B


B-10



55/59

APPENDIX C

C-1


NewtonScript Quick Reference Card

The third and fourth pages of this appendix contains a quick reference card for theNewtonScript programming language.


56/59

APPENDIXC


C-2



57/59

APPENDIXC


C-3



58/59

APPENDIXC


C-4



59/59

Index

A

Arrays 1-4

B

BREAK statement 2-2

CCharacters 1-2

special codes 1-3

F

FOREACH loop 2-4 to 2-5FOR loop 2-3Frames 1-4

setting class 1-5Functions

defining 3-1

G

Global variables 3-5

I

Inheritance 4-1 to ??Integers 1-1

L

N

Numbers 1-1

O

Operators 1-5

RReal numbers 1-4REPEAT loop 2-6

S

Scope 3-3Strings 1-3Symbols 1-3

special characters in 1-3

U

Unicode 1-2

V

Variablesglobal 3-5local 3-3

W

WHILE loop 2 6

Documents

The NewtonScript Programming Language (Alpha Draft 1.0)