JSL Syntax Rules

•	Parentheses also mark the end of a function name, even when arguments are not needed. For example, the Pi function has no arguments. However, the parentheses are required so that JMP can identify Pi as a function.

Pi();

Note: Be careful that parentheses match. Every ( needs a ), or errors result.

The script editor can match fences (parentheses, brackets, and braces). Press CTRL-] (COMMAND-b on Macintosh) with your cursor in any part of a script. The editor searches for fences, highlighting the text between the first set of opening and closing fences that it finds. Repeat this process to highlight the next-higher fence. See Match Parentheses, Brackets, and Braces in Scripting Tools for an example.

Semicolons

Expressions separated by a semicolon are evaluated in succession, returning the result of the last expression. In the following code, 0 is assigned to the variable i and then 2 is assigned the variable j.

i=0;

j=2;

You can also use semicolons to join arguments that are separated by commas as shown in the following If() expression.

If(x <5, y = 3; z++; ...);

The semicolon in other languages is used as an expression terminator character. In JSL, the semicolon is a signal to continue because more commands might follow. For details about separating expressions with semicolons, see Alternatives for Gluing Expressions Together.

Semicolons at the end of a script or at the end of a line of arguments are harmless, so you can also think of semicolons as terminating characters. Trailing semicolons are allowed at the end of a script stream and after a closing parenthesis or closing curly brace. In fact, terminating each complete JSL expression with a semicolon helps avoid errors when you copy and paste small scripts into a larger one.

The semicolon is equivalent to the Glue() function. See Operators for more information about semicolons and Glue().

Double Quotes

Double quotes enclose text strings. Anything inside double quotes is taken literally, including spaces and upper- or lower-case; nothing is evaluated. If you have "Pi() ^ 2" (inside double quotes), it is just a sequence of characters, not a value close to ten.

You do have to be a careful with text strings. Extra spaces and punctuation do affect the output, because text strings inside double quotes are used literally, exactly as you enter them.

To have double quotes inside a quoted string, precede each quotation mark with the escape sequence \! (backslash-bang). For example, run the following script and look at the title of the window:

New Window( "\!"Hello\!" is a quoted string.",

Text Box( Char( Repeat( "*", 70 ) ) )

);

Escape Sequences for Quoted Strings
\!b	blank
\!t	tab
\!r	carriage return only
\!n	linefeed (newline) only
\!N	inserts line breaking characters appropriate for the host environment 1
\!f	formfeed (page break)
\!0	null character Note: The null character is dangerous to use, because it is typically treated as the end of the string. Be sure to type the number zero, not the letter O.
\!\	backslash
\!"	double quotation mark

On Macintosh, this escape sequence is CR (carriage return character, hexadecimal ‘0D’). On Windows, this sequence is CR LF (carriage return followed by a linefeed, hexadecimal ‘0D0A’).

Sometimes, long passages require a lot of escaped characters. In these cases, use the notation \[...]\ and everything between the brackets does not need or support escape sequences. Here is an example where \[...]\ is used inside a double-quoted string.

jslPhrase = "The JSL to do this is :\[

a = "hello";

b = a|| " world.";

show(b);

]\ and you use the Submit command to run it.";

Spaces

JSL allows whitespace characters inside names; spaces, tabs, returns, and blank lines inside or between JSL words are ignored. This is because most JSL words come from the user interface, and most of those commands have spaces in them. For example, the JSL expression for the Fit Model platform is Fit Model() or FitModel().

Spaces inside an operator or between digits in a single number are not allowed. In these cases, the script generates errors. For example, you cannot put spaces between the two plus signs in i++ (i+ +) or in numbers (4 3 is not the same as 43).

Note: Why does JSL allow whitespace characters inside names? For one reason, the names of commands and options match the equivalent commands in JMP menus and windows. Another reason is that data table column names often include spaces.

Numbers

Numbers can be written as integers, decimal numbers, dates, times, or datetime values. They can also be included in scientific notations with an E preceding the power of ten. For example, these are all numbers:

. 1 12 1.234 3E3 0.314159265E+1 1E-20 01JAN98

Note: A single period by itself is considered a missing numeric value (sometimes called NaN for “not a number”).

For more information about dates, times, and date-time values, see Date-Time Functions and Formats in Types of Data. See Currency in Types of Data for details about combining numbers with currency symbols.

Names

A name is simply something to call an item. When you assign the numeric value 3 to a variable in the expression a = 3, a is a name.

Commands and functions have names, too. In the expression Log( 4 ), Log is the name of the logarithmic function.

Names have a few rules:

•	Names must start with an alphabetic character or underscore and can continue with the following:

‒	alphabetic characters (a-z A-Z)

‒	numeric digits (0-9)

‒	whitespace characters (spaces, tabs, line endings, and page endings)

‒	mathematical symbols in Unicode (such as ⊆)

‒	a few punctuation marks or special characters (apostrophes (‘), percent signs (%), periods (.), backslashes (\), and underscores (_))

•	When comparing names, JMP ignores whitespace characters (such as spaces, tabs, and line endings). Upper case and lower case characters are not distinguished. For example, the names Forage and for age are equivalent, despite the differences in white space and case.

You can still have a name that is any other sequence of characters. If the name does not follow the rules above, it needs to be quoted and placed inside a special parser directive called Name(). For example, to use a global variable with the name taxable income(2011), you must use Name() every time the variable appears in a script:

Name("taxable income(2011)") = 456000;

tax = .25;

Print(tax * Name("taxable income(2011)"));

114000

Name() is harmless when it is not needed. For example, tax and Name("tax") are equivalent.

For more information about how JMP interprets names, see Rules for Name Resolution.

Comments

Comments are notes in the code that are ignored by the JSL processor (or parser). You include comments to describe sections of the script. Comments are also convenient for removing portions of a script temporarily. For example, you can insert comment symbols around code that might be causing an error and then rerun the script.

Type the comment symbols around code that you want to comment. The following example shows code commented with /* */ in the middle of a line. When the script is run, JMP considers both expressions to be identical.

tax /*percentage*/ = .25;

tax = .25;

Comment Symbols describes the comment symbols.

Comment Symbols
Symbol	Syntax	Explanation
//	// comment	Begins a comment. The comment does not have to be at the beginning of a line, but everything up to the end of the line is a comment.
/* */	/* comment */	Begins and ends a comment. This comment can appear in the middle of a line. Script text before and after the comment is parsed normally.
//!	//!	Add //! to the first line of the script, and the script runs automatically when opened in JMP. (In other words, the script editor does not open.)