PILS

Table of contents:

1. Introduction
2. General syntax of PILS
3. Execution environment
4. Syntax of PILS
5. The plot library
6. Accessing the Pronto database
7. Reading NMR spectra
8. Examples

Introduction

The purpose of the Pronto Interactive Language System, PILS, is to give the user the possibility of writing small pieces of code that access the Pronto database.

Figure 1: The PILS editor window.

It is an interactive, BASIC-like language. Statements are typed in a window, syntax-checked, and stored in a temporary P-code. The editor window is shown in Figure 1. When Execute is pressed, the P-code is interpreted. This will be slower than a true compiler, but easier to make crash-proof, and no time consuming compilation step is necessary.

Code can be written that reads, writes or updates the Pronto database.

The following basic data types are supported: long, float, double, and character strings. Both zero-terminated and explicitly sized strings are supported.

It is possible to define structures using the above basic types. Default structures always exist: The catalogs in the Pronto database.

Output from the program is displayed in a separate window, into an ASCII file, or to a graphics window.

It will not be possible to define new windows or menus in the first version of PILS: It is difficult to implement, and difficult to use by the user, unless he/she is willing to write hundreds of lines of code.

General Syntax of PILS

PILS is implemented Visual Basic like: It is like old BASIC, but without line numbers. Editing takes place full-screen, and each line is syntax-checked when the cursor is removed from the line.

When the Execute button is pressed, execution starts from the first line in the program. A set of statements are used to control the flow of execution (FOR-NEXT, WHILE, REPEAT-UNTIL, etc.).

Procedures can be declared and executed. Parameters are passed to the procedures either by value or by reference. By declaring the procedure closed, variables are declared locally. The storage for these is released when the procedure is left.

Structures are declared anywhere in the main program. They are global to the whole program.

The scope rules used in PILS might be a little fuzzy; structures are global to the whole program, and the scope for variables is a bit strange. If the main program contains two procedures, A and B, where B is called both from A and the main program, variables accessed in B when called from A could be different than if called from the main program: If the main program has a variable xyz, and A creates a local variable xyz before calling B, the xyz accessed in B would be different variables in these two cases.

A set of standard functions are used to access the Pronto database and to generate graphics output.

Execution environment

Editor

An extra window is implemented in Pronto. This is used to enter PILS program, in a full-screen editor. The whole program text is shown in a scrollable window. The text between FOR-NEXT, IF-ELSE-ENDIF, etc. will automatically be listed indented. Each line is syntax checked as soon as the cursor has left the line. PILS statements are always on one line, i.e. continuation lines is not possible.

Comments are preceded by the // mark, and continue to the end of the line.

Prescan

When Execute is pressed, a prescan is performed. This does several things:

Checks for structural errors. A FOR statement must have a matching NEXT statement, etc. The variable listed after NEXT is checked against the variable name in FOR; if mismatching, an error is given. If the variable name is left out of the NEXT, ENDPROC, or ENDFUNC statement, it will be provided by the prescan.

A pointer is inserted in the code for multiline statements that points to the next statement in the structure. Thus if the expression in a WHILE statement evaluates to false, the interpreter immediately knows where the corresponding ENDWHILE statement is, and performs a jump to that.

Information about variables, procedures, functions, structures, local variables in procedures, etc. is collected.

Running the program

After a program to be run has passed the prescan, the interpreter starts to execute from the first line. If a PRINT statement occurs, a separate output window is opened. The Execute button changes into a Break button. Pressing this button halts execution.

As the PILS program can modify the Pronto database, care must be taken to press backup before starting a PILS program that modifies the database.

Another way of starting a PILS program is to use the user defined menu. Pressing User PILS Programs in the System menu opens a window containing a list of files in the $PRONTO_PILS directory. Selecting a file loads the PILS program, and execution starts immediately.

Output from the running program

An input/output window is created when needed. by the PILS program interpreter. All PRINT and INPUT statements are directed into this window. This window only accepts ASCII text. Graphics will have to be done in a separate window.

Run time errors

Several possibilities exist if a run time error occurs:

The error is handled by an enclosing TRAP-HANDLER structure.

If the HANDLER code gives up and issues a REPORT statement, another enclosing TRAP-HANDLER can take over.

If the outermost TRAP-HANDLER structure gives up, or the error is so severe that a TRAP-HANDLER cannot take care of it, e.g. out of memory, the error is handled by the system.

The system error handler prints out an error message and terminates program execution. If the run time module is started from within Pronto, information is passed back to the editor, and the cursor is positioned at the point of error.

Debugging tools

In the first version, no debugging tools are provided. At a later stage, it should be possible to insert break points, stop execution temporarily, ask for values of variables, etc. However, you can insert test printing statements in the PILS code to follow the execution path.

Syntax of PILS

This chapter should give a more specific definition of the PILS syntax.

Constants and Variables

Three types of constants are used:

Integers. They are distinguished from floating point numbers by the fact that they don't contain a decimal point. They are stored as signed, 32-bit numbers.

Floating point constants. They are stored as 8-byte doubles.

Character constants. "<anything but ">"

Variable names are strings of letters, digits, or one of the characters ' or _, where the first character must be a letter. The variable type is identified as follows:

NAME Double variable.

NAME% Integer variable.

NAME$ Character variable.

NAME! Zero-terminated character variable.

NAME# Float variable.

NAME. Structure variable.

Only string and structure variables need to be declared.

Two types of string variables exist: The zero-terminated variable type is used, because this is necessary in the structures defining Pronto database catalogs, and the other form is used because it can store all 256 ASCII characters together with a length of the string.

Structures

Structure types are declared in the following way:

STRUCTURE <name>
  DIM ........
  DIM ........
  ........
ENDSTRUCTURE

A structure can contain simple variables, arrays, structure variables or arrays of structure variables.

Declarations

All declarations are performed using the DIM statement.

Simple integer, float, or double variables need not be declared.

Examples are:

STRUCTURE s1
  DIM x, y%, z#
ENDSTRUCTURE

DIM x, y%, z#
DIM s1$ OF 80
DIM s2! OF 80
DIM a(10), b(10,10), c(-4:12), d(n%*m%)
DIM p. OF s1, q.(10) OF s1, sp. OF sp_rec

x Simple double variable

y% Simple integer variable

z# Simple float variable

s1$ Simple string, maximum length 80 characters. No zero-termination is used. The string can contain 80 characters, each with an ASCII value [0; 255]

s2! Zero terminated string. The string can contain 79 characters plus the zero termination.

a Array of 10 floats, numbered from 1 to 10

b Matrix of 10-by-10 doubles

c Array of doubles, indexed -4 to 12

d Array of doubles. The expression n%*m% is evaluated during runtime to determine the number of elements

p Structured variable

q Array of structured variables

sp Structured variable, sp_rec is a predeclared structure that can hold a record from the Spectrum Catalog in the Pronto database.

The variables in a structured variable is referenced by appending the name of the variable to the name of the structured variable. p.x thus references the x variable in the p. structured variable.

Pointers is not supported. The implementation of pointers is a big job.

Expressions

Two basic types of expressions exist: Numeric or string expressions. The numeric expressions could be of type integer or double. The float type is only implemented because some of the fields in the Pronto database are of type float.

Boolean expressions are treated as numeric expressions: Zero is FALSE, everything else is TRUE.

Numerical expressions

The following operators exist:

<exp1> OR ELSE <exp2>           Boolean or; <exp2> is not evaluated if 
				<exp1> is TRUE.
<exp1> OR <exp2>                Boolean or.

<exp1> AND <exp2>               Boolean and.
<exp1> AND THEN <exp2>          Boolean and; <exp2> is not evaluated if
				<exp1> is FALSE.

<exp1> BITOR <exp2>             Bitwise or.

<exp1> BITXOR <exp2>            Bitwise xor.

<exp1> BITAND <exp2>            Bitwise and.

BITNOT <exp>                    Bitwise not.

<exp1> <= <exp2>                Less than or equal to.
<exp1> > <exp2>                 Greater than.
<exp1> <> <exp2>                Not equal to.
<exp1> = <exp2>                 Equal to.
<exp1> >= <exp2>                Greater than or equal to.
<exp1> < <exp2>                 Less than.

<exp1> + <exp2>                 Add.
<exp1> - <exp2>                 Subtract.

<exp1> DIV <exp2>               Integer divide.
<exp1> / <exp2>                 Divide.
<exp1> MOD <exp2>               Integer remainder.
<exp1> * <exp2>                 Multiply.

<exp1> ^ <exp2>                 Raised to the power of.

-<exp>                          Monadic minus.
+<exp>                          Monadic plus.

NOT <exp>                       Boolean negation.

<name><type>(<pars>)            Call function.
(<exp>)                         Evaluate expression in ( ) first.

- the operators are listed in order of priority, highest priority at the bottom.

String expressions

The following operators operate on strings:

<sexp1> + <sexp2>               Concatenation.
<sexp> * <exp>                  Repeat string. exp must be numeric.
		                If exp is zero, the expression will evaluate
				to the empty string.
<exp> * <sexp>                  Repeat.
<sexp1> IN <sexp2>              Returns the position of <sexp1>
				in <sexp2>. Returns zero if <sexp1> is not found
				in <sexp2>. If <sexp1> is the null string (""),
				zero is always returned.
<sexp>(:<exp>:)                 Substring: Return character <exp>.
				The first character in a string is always
				numbered 1.
<sexp>(<exp>:)                  Substring: Return string starting at <exp>.
<sexp>(:<exp>)                  Substring: Return string starting at 1,
				ending at <exp>.
<sexp>(<exp1>:<exp2>)           Substring: Return string starting at <exp1>,
				ending at <exp2>.

Some examples are given here:

a1$:=b1$(1:10)
a2$:=b2$(:7:)
a3$:=c$(3,4)(7:10)
a4$:="The result is "+(correct%*"right")+((NOT correct%)*"wrong")+"."

a1$ is assigned the first 10 characters of b1$. a2$ is assigned the seventh character of b2$. a3$ is assigned the characters from 7 to 10 from element 3,4 of the string array c$.

Note: If the string expression refers to non-existing element, an error occurs. If the string is declared to hold 20 characters, but only 10 characters have been assigned to it, it would be an error to ask for character number 11.

Standard functions

PILS contains the following standard functions:

int(x)          Returns the closest integer less than or equal to x.
abs(x)          Absolute value of x.
abs(x1,x2...)   sqr(x1^2+x2^2...) NOT IMPLEMENTED
rnd             Random number, 0 < rnd < 1.
rnd(x1,x2)      Random integer, x1 <= rnd(x1,x2) <= x2.
sin(x)          Sine of x, x in radians.
cos(x)          Cosine of x, x in radians.
tan(x)          Tangens of x, x in radians.
atn(x)          Arcus tangens of x, returned in radians [-pi/2; pi/2].
atn(x,y)	Arcus tangens of x/y. y=0 is handeled correctly.
acs(x)		Arcus cosine of x.
asn(x)		Arcus sine of x.
flr(x)		Floor of x.
cil(x)		Ceiling of x.
log(x)          Natural log of x.
exp(x)          Exponential of x.
sqr(x)          Square root of x.
val(x$)         Converts string of digits to number.
len(x$)         Returns the actual length of the string x$.
str$(x)         Converts value into string.
str$(x,f$)      Converts value according to the fprintf format specified in f$.
                Type of x (integer, float, or double) must
		match format specified in f$.
ord(x$)         Converts single character into ASCII value.
chr$(x)         Converts value into single ASCII character.
pi              Returns pi.
true            Returns 1.
false           Returns 0.

Standard functions will also be needed to convert to and from atom names and database index numbers.

Procedures and Functions

Procedures in PILS are declared as follows:

PROC <name> <parameters>
  ........
ENDPROC <name>

The parameters can be something like:

empty
(x)
(x,y%)
(REF i%, REF a())

Procedures can be declared without parameters.

Simple parameters, like x and y%, are by default passed by value, i.e. a local copy of the argument is created, and the argument is assigned to that variable. Statements changing the contents of x or y% does not change any variable in the main program.

Parameters preceded by REF are passed by reference. Only variables or array elements can be used as arguments. If i% is modified in the procedure, the variable passed as argument will be modified. i% is thus a nick-name for the variable in the main program.

Arrays and structure variables can only be passed by reference, else the interpreter would need to create a local copy of the whole array.

Execution of a procedure is terminated and control returned to the calling location when execution reaches the ENDPROC statement or a RETURN statement within the procedure body is executed.

Functions are declared as follows:

FUNC <name><type> <parameters>
  ........
  RETURN <expression>
ENDFUNC <name><type>

Functions can be declared of type integer, float, double, or character string. The parameters are specified as for procedures. The <type> is any of: <none>, %, #, $, or !.

The RETURN statement can appear anywhere within the function body. Reaching the ENDFUNC statement is an error, as no value would be returned.

Controlling execution flow

Execution starts at the first line of the code. PROC-ENDPROC and FUNC-ENDFUNC blocks are skipped; procedures and functions must be called explicitly.

FOR statement

Loops are created using the FOR statement:

FOR i:=1 to 10 DO
........
NEXT i

FOR j%:=10 to 1 step -1 DO
........
BREAK WHEN a(j%)<0
........
NEXT j%

FOR k#:=1 to 17.0 DO <statement>

The variable controlled by the FOR statement can be of type integer, float, or double. The value of the variable after the NEXT statement is the first value not fulfilling the termination expression. Execution of the FOR statement can be terminated by the BREAK WHEN statement; if the expression is true, control is passed to the statement after the innermost NEXT, with the current value of the controlling variable. Zero or more BREAK WHEN statements can be specified.

The statement after the DO in the one-line version can only be simple, i.e. no other conditional statement can be used here.

The WHILE statement

WHILE <expression> DO
........
ENDWHILE

WHILE <expression> DO <statement>

The statements between WHILE and ENDWHILE are repeated as long as <expression> evaluates to TRUE. If <expression> evaluates to FALSE upon the first entry, the statements will not be executed at all.

The REPEAT statement

REPEAT
  ........
UNTIL <expression>

The statements between REPEAT and UNTIL are executed until <expression> evaluates to TRUE. The statements are at least executed once.

The LOOP statement

LOOP
........
BREAK WHEN <expression>
........
ENDLOOP

The loop is continued until otherwise specified. Zero or more BREAK WHEN statements can be used.

IF statements

IF <expression> THEN <simple statement>

IF <expression> THEN
  ........
ENDIF

IF <expression> THEN
  ........
ELSE
  ........
ENDIF

IF <expression> THEN
  ........
ELIF <expression> THEN
  ........
ELIF <expression> THEN
  ........
ENDIF

IF <expression> THEN
  ........
ELIF <expression> THEN
  ........
ELSE
  ........
ENDIF

Zero or more ELIF clauses can be specified. Multiline IF statements can be nested.

TRAP-HANDLER statement

TRAP
  ........
HANDLER
  ........
  REPORT
  ........
  RETRY
  ........
ENDTRAP

The statements between TRAP and HANDLER are executed. If no error occur, execution continues after the ENDTRAP. If an error occurs, execution jumps to the first line after HANDLER. If a REPORT statement is executed in the HANDLER part, execution is transferred to the HANDLER of a surrounding TRAP-HANDLER construction; if this TRAP-HANDLER construction is the outermost, the error will be handled by the system. The RETRY statement jumps to the first statement of the TRAP construction.

It is difficult to implement a jump into the statement causing the error, and typically this statement is used very locally, i.e. around an OPEN statement to catch file not found-errors.

Label-GOTO statement

Labels are declared as a name followed by a colon. They are put a line by itself. GOTO statements cannot be used to transfer control into loops, conditional statements, procedures or functions:

l1:
........
IF <exp1> THEN
  ........
  IF <exp2> THEN GOTO l1
  ........
ENDIF

The use of labels should be avoided, as it makes programs more unreadable.

The CASE statement

CASE <expression> OF
WHEN <exp1>
  ........
WHEN <exp2>,<exp3>
  ........
........
OTHERWISE
  ........
ENDCASE

First, <expression> is evaluated. Then <exp1>, <exp2>, etc. are evaluated one by one. If the value of one of the last expressions matches <expression>, execution continues with the statements after the WHEN statement with the matching expression. If no matching expression is found, the lines between OTHERWISE and ENDCASE are executed. If no OTHERWISE is specified and no expressions match, an error occurs.

The expressions can be of type integer, float, double, or string.

Calling procedures

A procedure is called by specifying the name of the procedure, followed by a list of arguments, in parentheses. No parentheses are necessary, if the procedure does not have any parameters.

Terminating a program

Execution of a program is stopped when:

The last statement was reached.

A STOP statement is reached.

An END statement is reached.

STOP and END statements behave the same way.

Assignments

Assignment statements are written as:

<variable reference> := <expression>

The variable reference could be a simple variable, a variable in a structure variable, a substring, or an array element. The type of the expression must match the variable type. Only numeric expressions are converted.

Substring assignments are a bit special, examples:

a1$(:5:):=<sexp>        Insert the first character of <sexp> as the fifth
			character of a1$. <sexp> must contain at least one
			character, and a1$ must contain at least four characters.
a2$(4:):=<sexp>         Replace the fourth and following character in a2$
			with <sexp>. Before executing this, a2$ must contain
			at least 3 characters.
a3$(4:8):=<sexp>        Replace characters 4,5,6,7, and 8 in a3$ with
			<sexp>. If <sexp> is shorter than 5 characters,
			spaces are added, if it is longer than 5 characters, 
			only the first 5 are used. a3$ must contain
			at least 3 characters.
a4$(:4):=<sexp>         Like a4$(1:4):=...

Special statements

PRINT statement

The PRINT statement is used to print out text and variables, either on the screen or to a file.

PRINT           Print a new line.
PRINT x         Print value of x, followed by new line.
PRINT x,y       Print value of x and y, followed by new line.
PRINT x;y       Print value of x, a space, value of y, and a new line.
PRINT x;        Print value of x followed by a space. No new line is printed.
PRINT x,        Print value of x.
PRINT x$,y$,    Print the string x$ immediately followed by the string y$.
PRINT FILE 1: x Print the value of x followed by a new line to the
		file opened as number 1.

INPUT statement

The INPUT statement halts program execution and waits for the user to input a text, terminated by return.

INPUT x                 Inputs a float variable.
INPUT x,                Inputs a float variable. The cursor is left at
			the end of the line after return is pressed.
INPUT x,y               Inputs two values, separated by one or more spaces.
INPUT "Write:":x        Prints the string expression "Write:"
			and waits for the user to type the value for x.
INPUT x$                Reads the rest of the line into the character
			variable x$. If the input list contains several
			character variables, the input to each variable
			must be terminated by a return.

The INPUT statement can also be used to read in from a file:

INPUT FILE 1: a,b,c,d$

Read three numbers, separated by at least one space, into a, b, and c, and the rest of the line into the string variable d$.

OPEN statement

Opens a file for reading or writing.

OPEN 1,fn$,READ         Open the file whose name is in the string fn$ as unit
			number 1 for reading.
OPEN 2,fn$,WRITE        Create a new file named according to the string fn$ and
			prepare it for writing on unit 1.
OPEN 3,fn$,APPEND       Open an already existing file, and position the pointer
                        at the end of the file, ready for writing.

CLOSE statement

CLOSE 1                 Close file 1.
CLOSE                   Close all open files.

READ, DATA and RESTORE statements

This is good, old BASIC DATA statements. They are useful for filling arrays with initial data.

DATA 1,2,3
DATA 1,"Hello",3

READ a,b,c,d,e$,f

When execution starts, a data pointer is set to point at the first element in the first DATA statement. The pointer is incremented for each READ operation. The data pointer can be reset to the start by the RESTORE statement.

Binary Input/Output

The INPUT FILE and PRINT FILE statements read and write ASCII data. To read and write binary data, use the READ FILE and WRITE FILE statements instead:

WRITE FILE 3: a,b,c             Writes out 3 floats. The file will be
				extended with 12 bytes.
READ FILE 3: a,b,c              Read the next 12 bytes into three floats.
READ FILE 3: d$                 Read a two-byte length, followed by the
				actual string.

The Plot library

Plotting in PILS is done by making calls to the cplot library. The cplot library has previously been used to make plots in the mcnt program and the Sequential Assignment Report facility in Pronto.

Initialization

The package must be initialized before used. You can only plot to one device at a time.

The PDEVICE statement

PDEVICE <sexp>

Selects the device specified by the character expression <sexp>. <sexp> could be "X11", "HP7550", "VT240", "GL", "HPLJSII", "HPLJIII", "HPLJSIV", "PS", or "WPG".

The PINIT statement

PINIT <sexp>,<var1>,<var2>,<var3>,<var4>

The string expression <sexp> is used as the filename to store the plots. Ignored for X11 and GL plots. The remaining four double variables will be set to hold the plotting area, in centimeters.

The PPAGE statement

PPAGE

Print out the current page and be ready for the next page.

The PFINISH statement

PFINISH

Finished using the cplot library.

The PCLIP statement

PCLIP <xmin>, <xmax>, <ymin>, <ymax>

Clips the following plotting commands according to the region specified.

The NOCLIP statement

PNOCLIP

Disables clipping.

Plotting commands

The following commands perform the actual plotting.

The PMOVE statement

PMOVE <x>, <y>

Move the current position to <x>, <y>. Never assume the current position to be anything, unless you've specified it yourself.

The PDRAW statement

PDRAW <x>, <y>

Draw from the current position to <x>, <y>. The new current position is set to <x>, <y>.

The PCOLOR statement

PCOLOR <number>

Select pen number <number>.

The PTHICK statement

PTHICK <width>

Set pen width to <width> pixels.

The PDENSITY statement

PDENSITY <blackness>

Set density of lines to <blackness>. Blackness is a number from 0 to 10. 10 is solid colored lines.

The PLINETYPE statement

PLINETYPE <type>

Select the pen type: 0: solid, 1...

The PTEXT statement

PTEXT <x>, <y>, <sexp>

Draw the text in <sexp> at the position <x>,<y>.

The PMARK statement

PMARK <x>, <y>

- I don't think this has been implemented...

The PMARKSTYLE statement

PMARKSTYLE <size>, <type>

- neither has this...

The PTEXTSTYLE statement

PTEXTSTYLE <size>, <align>

Defines the size and alignment of texts plotted with PTEXT.

Accessing the Pronto database

The Pronto database is accessed using more or less the same functions as used inside Pronto itself.

The structures used in the database are presented as predeclared structure types.

As an example, the layout of a cross peak record is, as if the following structure were declared:

STRUCTURE cp_rec
  DIM cp_id%
  DIM cp_phase%, cp_intensity_class%, cp_intensity_value#
  DIM cp_w1#, cp_w2#, cp_w3#, cp_w4#
  DIM cp_j_w1#, cp_j_w2#, cp_j_w3#, cp_j_w4#
  DIM cp_sc_w1#, cp_sc_w2#, cp_sc_w3#, cp_sc_w4#
  DIM cp_int_w1#, cp_int_w2#, cp_int_w3#, cp_int_w4#
  DIM cp_maker%
ENDSTRUCTURE cp_rec

or for the amino acid catalog:

STRUCTURE aa_rec
  DIM aa_id%
  DIM aa_name3! OF 4
  DIM aa_name1! OF 2
  DIM aa_name! OF 40
  DIM aa_group! OF 10
ENDSTRUCTURE aa_rec

The following piece of code read each cross peak for spectrum id sp_id%:

DIM cp. OF cp_rec

TRAP
  CAT_SP_CP_FIRST sp_id%, cp_id%
HANDLER
  IF ERR=... THEN
    PRINT "Spectrum id ",sp_id%," not found."
    END
  ENDIF
  REPORT
ENDTRAP

//
//  Read one record at a time,
//  and print out the w1 and w2
//  ppm values:
//
WHILE cp_id%<>-1 DO
  CAT_CP_GET cp_id%, cp.
  PRINT cp.cp_w1#; cp.cp_w2#
  CAT_SP_CP_NEXT sp_id%, cp_id%
ENDWHILE

Predeclared Pronto Database Structures

The following is a complete list of predeclared STRUCTUREs reflecting the Pronto database.

STRUCTURE cnt_rec
  DIM cnt_id%
  DIM cnt_name! of 40
  DIM cnt_z_xy_mode%
  DIM cnt_marker_mode%
  DIM cnt_default_x_width#
  DIM cnt_x_units%
  DIM cnt_x_active%(16)
  DIM cnt_x_sp_mask%(16)
  DIM cnt_x_center#(16)
  DIM cnt_x_width#(16)
  DIM cnt_default_y_width#
  DIM cnt_y_units%
  DIM cnt_y_active%(16)
  DIM cnt_y_sp_mask%(16)
  DIM cnt_y_center#(16)
  DIM cnt_y_width#(16)
  DIM cnt_default_z_width#
  DIM cnt_z_units%
  DIM cnt_z_active%(16)
  DIM cnt_z_sp_mask%(16)
  DIM cnt_z_center#(16)
  DIM cnt_z_width#(16)
  DIM cnt_default_w_width#
  DIM cnt_w_units%
  DIM cnt_w_active%(16)
  DIM cnt_w_sp_mask%(16)
  DIM cnt_w_center#(16)
  DIM cnt_w_width#(16)
ENDSTRUCTURE

STRUCTURE cm_rec
  DIM cm_id%
  DIM cm_ref_type%
  DIM cm_ref_id%
ENDSTRUCTURE

STRUCTURE sp_cnt_rec
  DIM sp_cnt_id%
  DIM sp_cnt_axis1%
  DIM sp_cnt_axis2%
  DIM sp_cnt_axis3%
  DIM sp_cnt_axis4%
  DIM sp_cnt_zw_merge#
  DIM sp_cnt_zw_plot#
  DIM sp_cnt_zw_marker#
  DIM sp_cnt_ww_merge#
  DIM sp_cnt_ww_plot#
  DIM sp_cnt_ww_marker#
  DIM sp_cnt_signs%
  DIM sp_cnt_low#
  DIM sp_cnt_high#
  DIM sp_cnt_levels%
  DIM sp_cnt_p_linecolor%
  DIM sp_cnt_p_linestyle%
  DIM sp_cnt_p_linewidth%
  DIM sp_cnt_n_linecolor%
  DIM sp_cnt_n_linestyle%
  DIM sp_cnt_n_linewidth%
  DIM sp_cnt_baseline%
  DIM sp_cnt_baseorder%
  DIM sp_cnt_markertype%(3)
  DIM sp_cnt_markercolor%(3)
  DIM sp_cnt_markersize%(3)
  DIM sp_cnt_linlogexp%
  DIM sp_cnt_showint%
ENDSTRUCTURE

STRUCTURE sp_rec
  DIM sp_id%
  DIM sp_file_ref_host! of 16
  DIM sp_file_ref_disk! of 16
  DIM sp_file_ref_user! of 16
  DIM sp_file_ref_name! of 16
  DIM sp_file_ref_expno%
  DIM sp_file_ref_procno%
  DIM sp_scalefactor#
  DIM sp_sample_id! of 20
  DIM sp_dim%
  DIM sp_temp#
  DIM sp_ph#
  DIM sp_type%
  DIM sp_exchange%
  DIM sp_solvent%
  DIM sp_operator%
  DIM sp_name! of 20
  DIM sp_comment! of 80
  DIM sp_axis_atom1%, sp_axis_atom2%, sp_axis_atom3%, sp_axis_atom4%
  DIM sp_axis_coord1%, sp_axis_coord2%, sp_axis_coord3%, sp_axis_coord4%
  DIM sp_axis_name1! of 11, sp_axis_name2! of 11
  DIM sp_axis_name3! of 11, sp_axis_name4! of 11
  DIM sp_wstep1#, sp_wstep2#, sp_wstep3#, sp_wstep4#
  DIM sp_woffset1#, sp_woffset2#, sp_woffset3#, sp_woffset4#
  DIM sp_freq1#, sp_freq2#, sp_freq3#, sp_freq4#
  DIM sp_points1%, sp_points2%, sp_points3%, sp_points4%
  DIM sp_fold1%, sp_fold2%, sp_fold3%, sp_fold4%
  DIM sp_fold_min1%, sp_fold_min2%, sp_fold_min3%, sp_fold_min4%
  DIM sp_fold_max1%, sp_fold_max2%, sp_fold_max3%, sp_fold_max4%
  DIM sp_sweep1#, sp_sweep2#, sp_sweep3#, sp_sweep4#
ENDSTRUCTURE

STRUCTURE cp_rec
  DIM cp_id%
  DIM cp_phase%
  DIM cp_intensity_class%
  DIM cp_intensity_value#
  DIM cp_w1#, cp_w2#, cp_w3#, cp_w4#
  DIM cp_j_w1#, cp_j_w2#, cp_j_w3#, cp_j_w4#
  DIM cp_sc_w1#, cp_sc_w2#, cp_sc_w3#, cp_sc_w4#
  DIM cp_int_w1#, cp_int_w2#, cp_int_w3#, cp_int_w4#
  DIM cp_fold1%, cp_fold2%, cp_fold3%, cp_fold4%
  DIM cp_maker%
ENDSTRUCTURE

STRUCTURE at_rec
  DIM at_id%
  DIM at_name%
  DIM at_index0%
  DIM at_ppm_n%
  DIM at_ppm_sum#
  DIM at_ppm_square#
ENDSTRUCTURE

STRUCTURE ss_rec
  DIM ss_id%
ENDSTRUCTURE

STRUCTURE aa_rec
  DIM aa_id%
  DIM aa_name3! of 4
  DIM aa_name1! of 2
  DIM aa_name! of 40
  DIM aa_group! of 10
ENDSTRUCTURE

STRUCTURE at0_rec
  DIM at0_id%
  DIM at0_name%
  DIM at0_index%
  DIM at0_sub_index%
  DIM at0_chem_shift#
ENDSTRUCTURE

STRUCTURE sa_rec
  DIM sa_id%
ENDSTRUCTURE

STRUCTURE ap_rec
  DIM ap_id%
  DIM ap_position%
  DIM ap_chainid! of 5
ENDSTRUCTURE

STRUCTURE se_rec
  DIM se_id%
  DIM se_position%
ENDSTRUCTURE

STRUCTURE sc_rec
  DIM sc_id%
  DIM sc_chainid! of 5
ENDSTRUCTURE

STRUCTURE sas_rec
  DIM sas_id%
  DIM sas_name! of 40
ENDSTRUCTURE

STRUCTURE sase_rec
  DIM sase_id%
  DIM sase_expr_no%
  DIM sase_axis%
  DIM sase_at_name%
  DIM sase_at_index%
  DIM sase_chem_shift#
  DIM sase_dev#
  DIM sase_seq_dist%
ENDSTRUCTURE

STRUCTURE stc_rec
  DIM stc_id%
  DIM stc_filename! of 80
  DIM stc_natoms%
ENDSTRUCTURE

STRUCTURE st_rec
  DIM st_id%
  DIM st_no%
  DIM st_selected%
  DIM st_etotal#
  DIM st_ebond#
  DIM st_eangl#
  DIM st_edihe#
  DIM st_eimpr#
  DIM st_evdw#
  DIM st_eelec#
  DIM st_ehbond#
  DIM st_enoe#
  DIM st_ecdih#
ENDSTRUCTURE

STRUCTURE atc_rec
  DIM atc_id%
  DIM atc_no%
  DIM atc_resno%
  DIM atc_x#
  DIM atc_y#
  DIM atc_z#
  DIM atc_r#
  DIM atc_b#
  DIM atc_segment! of 5
  DIM atc_resname! of 5
  DIM atc_aname! of 5
ENDSTRUCTURE

STRUCTURE sds_rec
  DIM sds_id%
  DIM sds_name! of 40
  DIM sds_matrix#(4,4)
ENDSTRUCTURE

STRUCTURE sdse_rec
  DIM sdse_id%
  DIM sdse_mode%
  DIM sdse_color%
  DIM sdse_linetype%
  DIM sdse_bondwidth%
ENDSTRUCTURE

STRUCTURE sdset_rec
  DIM sdset_id%
  DIM sdset_text! of 80
ENDSTRUCTURE

STRUCTURE at_cp_rec
  DIM at_cp_id%
  DIM at_cp_type%
ENDSTRUCTURE

STRUCTURE ss_at_rec
  DIM ss_at_id%
  DIM at_index%
  DIM at_sub_index%
ENDSTRUCTURE

STRUCTURE aa_ss_rec
  DIM aa_ss_id%
ENDSTRUCTURE

STRUCTURE sa_ss_rec
  DIM sa_ss_id%
ENDSTRUCTURE

CAT_AA_AT0_CHECK(aa_at0_id%,aa_id%)

CAT_AA_AT0_CONNECT(aa_id%,at0_id%)

CAT_AA_AT0_FIRST(aa_id%)

CAT_AA_AT0_LAST(aa_id%)

CAT_AA_AT0_NEXT(aa_at0_id%,aa_id%)

CAT_AA_AT0_PREV(aa_at0_id%,aa_id%)

CAT_AA_CHECK(aa_id%)

CAT_AA_CHECK_NEW_NAME3(name$)

CAT_AA_DELETE(aa_id%)

CAT_AA_FIRST

CAT_AA_GET aa_id%,aa.

CAT_AA_LAST

CAT_AA_NEW aa.

CAT_AA_NEXT(aa_id%)

CAT_AA_OF_AA_SS(aa_ss_id%)

CAT_AA_OF_AT0(at0_id%)

CAT_AA_OF_SASE(sase_id%)

CAT_AA_OF_SE(se_id%)

CAT_AA_PREV(aa_id%)

CAT_AA_UPDATE aa.

AA_SASE catalog

CAT_AA_SASE_CHECK(sase_id%,aa_id%)

CAT_AA_SASE_CONNECT aa_id%,sase_id% 

CAT_AA_SASE_FIRST(aa_id%)

CAT_AA_SASE_LAST(aa_id%)

CAT_AA_SASE_NEXT(sase_id%,aa_id%)

CAT_AA_SASE_PREV(sase_id%,aa_id%)

AA_SE catalog

CAT_AA_SE_CHECK(se_id%,aa_id%)

CAT_AA_SE_CONNECT aa_id%,se_id%

CAT_AA_SE_FIRST(aa_id%)

CAT_AA_SE_LAST(aa_id%)

CAT_AA_SE_NEXT(se_id%,aa_id%)

CAT_AA_SE_PREV(se_id%,aa_id%)

AA_SS catalog

CAT_AA_SS_CHECK(aa_ss_id%,aa_id%)

CAT_AA_SS_CONNECT(aa_ss.,aa_id%,ss_id%)

CAT_AA_SS_DELETE aa_ss_id%

CAT_AA_SS_FIRST(aa_id%)

CAT_AA_SS_GET

CAT_AA_SS_LAST(aa_id%)

CAT_AA_SS_NEXT(aa_ss_id%)

CAT_AA_SS_PREV(aa_ss_id%)

CAT_AA_SS_UPDATE aa_ss_id%,aa_ss.

AP catalog

CAT_AP_DELETE ap_id%

CAT_AP_GET ap_id%,ap.

CAT_AP_UPDATE old_ap_id%,ap.

AT0 catalog

CAT_AT0_DELETE at0_id%

CAT_AT0_GET at0_id%,at0.

CAT_AT0_NEW at0.

CAT_AT0_UPDATE old_at0_id%,at0.

AT_CP catalog

CAT_AT_CP_CHECK(at_cp_id%,at_id%)

CAT_AT_CP_CONNECT(type%,at_id%,cp_id%)

CAT_AT_CP_CONNECTED(at_cp.,at_id%,cp_id%)

CAT_AT_CP_DELETE at_cp_id%

CAT_AT_CP_FIRST(at_id%)

CAT_AT_CP_GET at_cp_id%,at_cp.

CAT_AT_CP_LAST(at_id%)

CAT_AT_CP_NEW at_cp.,at_id%,cp_id%

CAT_AT_CP_NEXT(at_cp_id%)

CAT_AT_CP_PREV(at_cp_id%)

CAT_AT_CP_UPDATE old_at_cp_id%,at_cp.

AT catalog

CAT_AT_CHECK(at_id%)

CAT_AT_DELETE at_id%

CAT_AT_FIRST

CAT_AT_GET at_id%,at.

CAT_AT_LAST

CAT_AT_NEAREST(at_id%)

CAT_AT_NEW at.

CAT_AT_NEXT(at_id%)

CAT_AT_OF_AT_CP(at_cp_id%)

CAT_AT_OF_SS_AT(ss_at_id%)

CAT_AT_OF_SASE(sase_id%)

CAT_AT_PREV(at_id%)

CAT_AT_UPDATE old_at_id%,at.

CAT_SEQ_POS_OF_AT(at_id%)

AT_SASE catalog

CAT_AT_SASE_CHECK(sase_id%,at_id%)

CAT_AT_SASE_CONNECT at_id%,sase_id%

CAT_AT_SASE_FIRST(at_id%)

CAT_AT_SASE_LAST(at_id%)

CAT_AT_SASE_NEXT(sase_id%,at_id%)

CAT_AT_SASE_PREV(sase_id%,at_id%)

AT_SS catalog

CAT_AT_SS_CHECK(ss_at_id%,at_id%)

CAT_AT_SS_FIRST(at_id%)

CAT_AT_SS_LAST(at_id%)

CAT_AT_SS_NEXT(ss_at_id%)

CAT_AT_SS_PREV(ss_at_id%)

ATC catalog

CAT_ATC_DELETE atc_id%

CAT_ATC_GET atc_id%,atc.

CAT_ATC_NEW atc.,st_id%

CAT_ATC_UPDATE old_atc_id%,atc.

CAT_ATC_FIRST

CAT_ATC_LAST

CAT_ATC_NEXT(atc_id%)

CAT_ATC_PREV(atc_id%)

CAT_ATC_CHECK(atc_id%)

CNT catalog

CAT_CNT_CHECK(cnt_id%)

CAT_CNT_DELETE cnt_id%

CAT_CNT_FIRST

CAT_CNT_GET cnt_id%,cnt.

CAT_CNT_LAST

CAT_CNT_NEW cnt.

CAT_CNT_NEXT(cnt_id%)

CAT_CNT_OF_SP_CNT(sp_cnt_id%)

CAT_CNT_PREV(cnt_id%)

CAT_N_CNT

CNT_SP catalog

CAT_CNT_SP_CHECK(sp_cnt_id%,cnt_id%)

CAT_CNT_SP_FIRST(cnt_id%)

CAT_CNT_SP_LAST(cnt_id%)

CAT_CNT_SP_NEXT(sp_cnt_id%)

CAT_CNT_SP_PREV(sp_cnt_id%)

CAT_CNT_UPDATE old_cnt_id%,cnt.

CP_AT catalog

CAT_CP_AT_CHECK(at_cp_id%,cp_id%)

CAT_CP_AT_CONS(cp_id%)

CAT_CP_AT_FIRST(cp_id%)

CAT_CP_AT_LAST(cp_id%)

CAT_CP_AT_NEXT(at_cp_id%)

CAT_CP_AT_PREV(at_cp_id%)

CP catalog

CAT_CP_CHECK(cp_id%)

CAT_CP_DEL_MAKER(cp_maker%)

CAT_CP_DELETE cp_id%

CAT_CP_FIND_ID(key_fld%,ppm,prev_id%,next_id%)

CAT_CP_FIRST

CAT_CP_GET cp_id%,cp.

CAT_CP_LAST

CAT_CP_LAST_MAKER

CAT_CP_NEAREST_ID

CAT_CP_NEAREST_PPM(key_fld%,ppm)

CAT_CP_NEW cp.,sp_id%

CAT_CP_NEW_MAKER

CAT_CP_NEXT

CAT_CP_OF_AT_CP(at_cp_id%)

CAT_CP_PREV

CAT_CP_UPDATE old_cp_id%,cp.

CAT_CP_FIRST_ID

CAT_CP_LAST_ID

CAT_CP_NEXT_ID(cp_id%)

CAT_CP_PREV_ID(cp_id%)

CAT_CP_CHECK_ID

SEL_CP_CHECK

SEL_CP_FIRST

SEL_CP_INIT_CONTEXT

SEL_CP_LAST

SEL_CP_NEAREST

SEL_CP_NEAREST_ID

SEL_CP_NEAREST_PPM

SEL_CP_NEXT

SEL_CP_PREV

SA_AP catalog

CAT_SA_AP_CHECK(ap_id%,sa_id%)

CAT_SA_AP_CONNECT sa_id%,ap.

CAT_SA_AP_FIRST(sa_id%)

CAT_SA_AP_LAST(sa_id%)

CAT_SA_AP_NEXT(ap_id%,sa_id%)

CAT_SA_AP_PREV(ap_id%,sa_id%)

CAT_N_SA_AP(sa_id%)

SA catalog

CAT_SA_CHECK(sa_id%)

CAT_SA_DELETE sa_id%

CAT_SA_FIRST

CAT_SA_GET sa_id%,sa.

CAT_SA_INDEX_OF_SS(sa_id%,ss_id%)

CAT_SA_LAST

CAT_SA_NEW sa.

CAT_SA_NEXT(sa_id%)

CAT_SA_OF_AP(ap_id%)

CAT_SA_OF_SA_SS(sa_ss_id%)

CAT_SA_PREV(sa_id%)

CAT_SA_UPDATE old_sa_id%,sa.

SA_SS catalog

CAT_SA_SS_BY_INDEX(sa_id%,index%)

CAT_SA_SS_CHECK(sa_ss_id%,sa_id%)

CAT_SA_SS_DELETE sa_ss_id%

CAT_SA_SS_FIRST(sa_id%)

CAT_SA_SS_GET sa_ss_id%,sa_ss.

CAT_SA_SS_LAST(sa_id%)

CAT_SA_SS_NEW sa_ss.,sa_id%,ss_id%,prev_sa_ss_id%

CAT_SA_SS_NEXT(sa_ss_id%)

CAT_SA_SS_PREV(sa_ss_id%)

CAT_SA_SS_UPDATE old_sa_ss_id%,sa_ss.

CAT_N_SA_SS(sa_id%)

SAS catalog

CAT_SAS_CHECK(sas_id%)

CAT_SAS_DELETE sas_id%

CAT_SAS_FIRST

CAT_SAS_GET sas_id%,sas.

CAT_SAS_LAST

CAT_SAS_NEW sas.

CAT_SAS_NEXT(sas_id%)

CAT_SAS_OF_SASE(sase_id%)

CAT_SAS_PREV(sas_id%)

CAT_SAS_UPDATE old_sas_id%,sas.

SAS_SASE catalog

CAT_SAS_SASE_CHECK(sase_id%,sas_id%)

CAT_SAS_SASE_FIRST(sas_id%)

CAT_SAS_SASE_LAST(sas_id%)

CAT_SAS_SASE_NEXT(sase_id%,sas_id%)

CAT_SAS_SASE_PREV(sase_id%,sas_id%)

SASE catalog

CAT_SASE_DELETE sase_id%

CAT_SASE_GET sase_id%,sase.

CAT_SASE_NEW sase.,sas_id%

CAT_SASE_UPDATE old_sase_id%,sase.

SC catalog

CAT_SC_CHECK(sc_id%)

CAT_SC_CHECK_CHAINID(chainid$)

CAT_SC_DELETE sc_id%

CAT_SC_FIRST

CAT_SC_GET sc_id%,sc.

CAT_SC_LAST

CAT_SC_NEW sc.

CAT_SC_NEXT(sc_id%)

CAT_SC_OF_SE(se_id%)

CAT_SC_PREV(sc_id%)

CAT_SC_UPDATE old_sc_id%,sc.

CAT_N_SC

SC_SE catalog

CAT_SC_SE_CHECK(se_id%,sc_id%)

CAT_SC_SE_FIRST(sc_id%)

CAT_SC_SE_LAST(sc_id%)

CAT_SC_SE_NEXT(se_id%,sc_id%)

CAT_SC_SE_PREV(se_id%,sc_id%)

CAT_N_SC_SE(sc_id%)

SDS catalog

CAT_SDS_CHECK(sds_id%)

CAT_SDS_DELETE sds_id%

CAT_SDS_FIRST

CAT_SDS_GET sds_id%,sds.

CAT_SDS_LAST

CAT_SDS_NEW sds.

CAT_SDS_NEXT(sds_id%)

CAT_SDS_OF_SDSE(sdse_id%)

CAT_SDS_PREV(sds_id%)

CAT_SDS_UPDATE old_sds_id%,sds.

SDS_SDSE catalog

CAT_SDS_SDSE_CHECK(sdse_id%,sds_id%)

CAT_SDS_SDSE_FIRST(sds_id%)

CAT_SDS_SDSE_LAST(sds_id%)

CAT_SDS_SDSE_NEXT(sdse_id%,sds_id%)

CAT_SDS_SDSE_PREV(sdse_id%,sds_id%)

SDSE catalog

CAT_SDSE_DELETE sdse_id%

CAT_SDSE_GET sdse_id%,sdse.

CAT_SDSE_GET_TEXT$(sdse_id%)

CAT_SDSE_NEW sdse.,sds_id%

CAT_SDSE_UPDATE old_sdse_id%,sdse.

CAT_SDSE_UPDATE_TEXT

SDSE_SDSET catalog

CAT_SDSE_OF_SDSET(sdset_id%)

CAT_SDSE_SDSET_CHECK(sdset_id%,sdse_id%)

CAT_SDSE_SDSET_FIRST(sdse_id%)

CAT_SDSE_SDSET_LAST(sdse_id%)

CAT_SDSE_SDSET_NEXT(sdset_id%,sdse_id%)

CAT_SDSE_SDSET_PREV(sdset_id%,sdse_id%)

SDSET catalog

CAT_SDSET_DELETE sdset_id%

CAT_SDSET_GET sdset_id%,sdset.

CAT_SDSET_NEW sdset.,sdse_id%

CAT_SDSET_UPDATE old_sdset_id%,sdset.

SE catalog

CAT_SE_CHECK(se_id%)

CAT_SE_DELETE se_id%

CAT_SE_GET se_id%,se.

CAT_SE_NEW sc_id%,se_id%,se.

CAT_SE_UPDATE old_se_id%,se.

SP_CNT catalog

CAT_SP_CNT0_GET sp_cnt.,sp_id%

CAT_SP_CNT0_SET sp_cnt.,sp_id%

CAT_SP_CNT_CHECK sp_cnt_id%,sp_id%

CAT_SP_CNT_DELETE sp_cnt_id%

CAT_SP_CNT_FIRST(sp_id%)

CAT_SP_CNT_GET sp_cnt_id%,sp_cnt.

CAT_SP_CNT_LAST(sp_id%)

CAT_SP_CNT_NEW sp_cnt.,sp_id%,cnt_id%

CAT_SP_CNT_NEXT(sp_cnt_id%)

CAT_SP_CNT_PREV(sp_cnt_id%)

CAT_SP_CNT_UPDATE old_sp_cnt_id%,sp_cnt.

SP_CP catalog

CAT_SP_CP_CHECK(cp_id%,sp_id%)

CAT_SP_CP_FIRST(sp_id%)

CAT_SP_CP_LAST(sp_id%)

CAT_SP_CP_NEXT(cp_id%,sp_id%)

CAT_SP_CP_PREV(cp_id%,sp_id%)

SP catalog

CAT_SP_CHECK(sp_id%)

CAT_SP_DELETE sp_id%

CAT_SP_DIM_OF_CP(cp_id%)

CAT_SP_FIRST

CAT_SP_GET sp_id%,sp.

CAT_SP_LAST

CAT_SP_MAX_DIM

CAT_SP_NEW sp.

CAT_SP_NEXT(sp_id%)

CAT_SP_OF_CP(cp_id%)

CAT_SP_OF_CP_MAKER(cp_maker%)

CAT_SP_OF_SP_CNT(sp_cnt_id%)

CAT_SP_PREV(sp_id%)

CAT_SP_UPDATE old_sp_id%,sp.

CAT_SP_AXIS_NAME_FROM_RAW_INDEX$(sp.,raw_index%)

CAT_N_SP

SS_AA catalog

CAT_SS_AA_CHECK(aa_ss_id%,ss_id%)

CAT_SS_AA_FIRST(ss_id%)

CAT_SS_AA_LAST(ss_id%)

CAT_SS_AA_NEXT(aa_ss_id%)

CAT_SS_AA_PREV(aa_ss_id%)

SS_AT catalog

CAT_SS_AT_CHECK(ss_at_id%,ss_id%)

CAT_SS_AT_CONNECT(ss_at.,ss_id%,at_id%)

CAT_SS_AT_CONNECTED(ss_at.,ss_id%,at_id%)

CAT_SS_AT_FIRST(ss_id%)

CAT_SS_AT_LAST(ss_id%)

CAT_SS_AT_NEXT(ss_at_id%)

CAT_SS_AT_PREV(ss_at_id%)

CAT_SS_AT_DELETE ss_at_id%

CAT_SS_AT_GET ss_at_id%,ss_at.

CAT_SS_AT_UPDATE old_ss_at_id%,ss_at.

SS_AT_NAME$(ss_at_id%)

CAT_N_SS_AT(ss_id%)

SS catalog

CAT_SS_CHECK(ss_id%)

CAT_SS_DELETE ss_id%

CAT_SS_FIRST

CAT_SS_GET ss_id%,ss.

CAT_SS_IN_SQ(ss_id%)

CAT_SS_LAST

CAT_SS_NEAREST(ss_id%)

CAT_SS_NEW ss.

CAT_SS_NEXT(ss_id%)

CAT_SS_OF_AA_SS(aa_ss_id%)

CAT_SS_OF_SS_AT(ss_at_id%)

CAT_SS_OF_SA_SS(sa_ss_id%)

CAT_SS_OF_SASE(sase_id%)

CAT_SS_PREV(ss_id%)

CAT_SS_UPDATE old_ss_id%,ss.

CAT_N_SS

CAT_SEQ_CHAIN_OF_SS$(ss_id%)

CAT_SEQ_POS_OF_SS(ss_id%)

SS_SA catalog

CAT_SS_SA_CHECK(sa_ss_id%,ss_id%)

CAT_SS_SA_FIRST(ss_id%)

CAT_SS_SA_LAST(ss_id%)

CAT_SS_SA_NEXT(sa_ss_id%)

CAT_SS_SA_PREV(sa_ss_id%)

SS_SASE catalog

CAT_SS_SASE_CHECK(sase_id%,ss_id%)

CAT_SS_SASE_CONNECT(ss_id%,sase_id%)

CAT_SS_SASE_FIRST(ss_id%)

CAT_SS_SASE_LAST(ss_id%)

CAT_SS_SASE_NEXT(sase_id%,ss_id%)

CAT_SS_SASE_PREV(sase_id%,ss_id%)

ST_ATC catalog

CAT_ST_ATC_CHECK(atc_id%,st_id%)

CAT_ST_ATC_FIRST(st_id%)

CAT_ST_ATC_LAST(st_id%)

CAT_ST_ATC_NEXT(atc_id%,st_id%)

CAT_ST_ATC_PREV(atc_id%,st_id%)

ST catalog

CAT_ST_DELETE st_id%

CAT_ST_GET st_id%,st.

CAT_ST_NEW st.,stc_id%

CAT_ST_OF_ATC(atc_id%)

CAT_ST_UPDATE old_st_id%,st.

CAT_ST_FIRST

CAT_ST_LAST

CAT_ST_NEXT(st_id%)

CAT_ST_PREV(st_id%)

CAT_ST_CHECK(st_id%)

STC catalog

CAT_STC_CHECK(stc_id%)

CAT_STC_DELETE stc_id%

CAT_STC_FIRST

CAT_STC_GET stc_id%,stc.

CAT_STC_LAST

CAT_STC_NEAREST(stc_id%)

CAT_STC_NEW stc.

CAT_STC_NEXT(stc_id%)

CAT_STC_OF_SDSE(sdse_id%)

CAT_STC_OF_ST(st_id%)

CAT_STC_PREV(stc_id%)

CAT_STC_UPDATE old_stc_id%,stc.

STC_SDSE catalog

CAT_STC_SDSE_CHECK(sdse_id%,stc_id%)

CAT_STC_SDSE_CONNECT stc_id%,sdse_id%

CAT_STC_SDSE_FIRST(stc_id%)

CAT_STC_SDSE_LAST(stc_id%)

CAT_STC_SDSE_NEXT(sdse_id%,stc_id%)

CAT_STC_SDSE_PREV(sdse_id%,stc_id%)

STC_ST catalog

CAT_STC_ST_CHECK(st_id%,stc_id%)

CAT_STC_ST_FIRST(stc_id%)

CAT_STC_ST_LAST(stc_id%)

CAT_STC_ST_NEXT(st_id%,stc_id%)

CAT_STC_ST_PREV(st_id%,stc_id%)

CAT_N_STC_ST(stc_id%)

Reading NMR spectra

It should be considered if it could advantageous to have access to NMRIO calls. This would make it possible to read and write NMR data and to update NMR file parameters.

Examples

Last updated: 08-MAY-2008