View source for IBM System/36 BASIC

{{Unreferenced|date=December 2009}}
{{Infobox programming language
| name = IBM System/36 BASIC
| logo =               <!-- (filename) -->
| logo caption = 
| screenshot =         <!-- (filename) -->
| screenshot caption = 
| paradigm =           <!-- or: | paradigms = -->
| family =  
| designer =           <!-- or: | designers = -->
| developer =          <!-- or: | developers = -->
| released = {{start date and age|1983}}
| latest release version = 
| latest release date =     <!-- {{start date and age|YYYY|MM|DD|df=yes/no}} -->
| latest preview version = 
| latest preview date =     <!-- {{start date and age|YYYY|MM|DD|df=yes/no}} -->
| typing = 
| scope = 
| programming language = 
| discontinued =
| platform = 
| operating system = 
| license = 
| file ext = 
| file format =        <!-- or: | file formats = -->
| website =            <!-- {{url|www.example.com}} -->
| implementations = 
| dialects = 
| influenced by = 
| influenced = 
}}
'''[[IBM System/36]] [[BASIC]]''' was an [[Interpreter (computing)|interpreter]] for the [[IBM System/36]] midrange computer.

System/36 BASIC was first offered in 1983, and as such, contained many of the trappings that a BASIC program would have encountered in the time period of the [[IBM PC]], the [[Commodore 64]], the [[VIC-20]], the [[TRS-80]], or many other offerings of the Seventies and early Eighties. As such, S/36 BASIC uses conventions that are no longer standard in modern BASICs, such as line numbers, and does not support newer features such as {{mono|WHILE/WEND, DO/ENDDO, WITH/END WITH}}, procedures, properties, and so forth.  

BASIC interpreters written in the Seventies tended to "do odd things odd ways".  For example, on the [[Apple II]], a [[computer programmer|programmer]] could embed a command into a program via PRINT, when prefaced by the character string {{code|2=basic|CHR$(4)}}. {{mono|PEEK}} and {{mono|POKE}} could be used in various BASICs to examine memory content or change it, or even to create an ad hoc machine language program and then run it.  System/36 BASIC tends to stay away from these odd conventions; however, the programmer could call for the Alarm (a buzzing sound made by the terminal) via {{code|2=basic|PRINT CHR$(7)}}.

BASIC statements are expected to be entered in capital letters, and while the operator can press Cmd2 to use lowercase, the BASIC interpreter will convert non-comment keywords into uppercase.

So that BASIC could be useful in a midrange computing environment, [[IBM]] added extensions to the language that were specific to the hardware and software conventions of the IBM System/36 Family, such as the {{mono|WORKSTN}} file, support for indexed, direct, and sequential disk files, the ability to open and close multiple printer files, and LOAD/SAVE from libraries on the fixed disk.

== Statements, functions, and commands ==

These core BASIC statements, functions, and commands were used:

  DATA
  DIM
  END
  FOR...NEXT
  GOSUB...RETURN
  GOTO
  IF...THEN
  INPUT
  LET
  ON...GOTO
  PRINT
  PRINT USING
  READ
  REM
  STOP
   
  ASC()
  RND()
  SIN()
  COS()
  TAN()
  TAB()
  SQRT()
  LOG()
  
  LIST

More advanced IBM-supplied statements included:

  ON ERROR       Allows error trapping
  OPTION         Permits program-wide properties such as Base 1 or Base 0 array indexing, long or short precision, etc.
  OPEN           Allows a file or device (formatted workstation, printer) to be opened
  CLOSE          Closes a file or device
  WRITE          Outputs to a file or device
  REWRITE        Changes a record or display format
  APPEND         Adds to a file
  DELETE         Deletes a record from a file
  IMAGE          Defines the format of a record using COBOL-like syntax
  FORM           Defines the format of a record using RPG-like syntax
  DEF FN..FNEND  Defines a function
  CHAIN          Loads and passes control to another BASIC program
  
  PRINT #255:          Prints to the (default) printer file
  PRINT NEWPAGE        Clears the screen
  PRINT #255: NEWPAGE  Advances to the next page on the printer file
  
  AIDX()         Refers to the ascending index of an array, which is an array of relative sorted pointers to array elements
  DIDX()         Same as AIDX but uses a descending index
  SRCH()         Used to find a value in an array by retrieving the match pointer         
  SRCH$()        Used to find a string value in a string array by retrieving the match pointer

  RENUMBER       A command used to renumber the lines within a program
  LOAD           A command used to load a program from a library on the fixed disk
  SAVE           A command used to save a program to a library on the fixed disk
  OFF            A command used to exit the interactive BASIC session
  LISTP          A command used to list the current program to the printer

{{code|ON ERROR}} is an error-trapping statement that allows BASIC to suspend an error that might otherwise stop a BASIC program from running and perform an error-handling routine instead.  Variants include suffixing {{mono|OFLOW, ZDIV}}, and other error types to a statement and immediately trap these errors.

{{mono|OPTION}} allows the BASIC program to meet special criteria.  Sometimes BASIC did not have very much user space (since all S/36 programs are limited to 64K) and the area called "code space" which contains the current user program must reside within the user space.  Therefore, users could choose {{code|OPTION LPREC}} which causes BASIC to compute with double-precision (long) numerics, or {{code|OPTION SPREC}} which provides more space and single-precision (short) numerics.  Some programmers prefer matrix mathematics where the lowest-numbered index is 0, others prefer 1. {{code|2=basic|OPTION BASE 0}} and {{code|2=basic|OPTION BASE 1}} accomplish this.  There are other uses for {{mono|OPTION}}.

[[RPG II]] programs on the [[IBM System/34|S/34]] and S/36 could not call each other, but BASIC programs could, using the {{mono|CHAIN}} statement. {{mono|CHAIN}} passes control from the current BASIC module to the named module, bearing a list of arguments which can become variables in the new module when it is loaded.

{{code|2=basic|DEF FN}} allows the definition of a user function in BASIC which can be named and referred in the program.  {{mono|FNEND}} is placed after the last statement in a function.

There are four ways to format BASIC input and output.  First, unformatted; just {{mono|PRINT}} and {{mono|INPUT}} to your heart's content.  Second, with {{code|2=basic|PRINT USING}}, which in S/36 BASIC can incorporate a constant, a string variable, a line number, or a label.  Third, with {{code|2=basic|PRINT FIELDS}} and {{code|2=basic|INPUT FIELDS}}, which place 5250-type display fields on the CRT in immediate mode.  Fourth, by using a workstation file (opened with {{code|2=basic|1=OPEN #x: "WS,NAME="}} and so forth) and performing various combinations of {{mono|WRITE}} and {{mono|READ}} to that workstation file, using SDA-generated screen formats similar to those in other S/36 applications. {{mono|WRITE}} and {{mono|READ}}, as well as {{code|2=basic|PRINT USING}} and {{code|2=basic|INPUT USING}}, can direct BASIC to a line number or a label that contains the keyword {{code|IMAGE:}}.

An IMAGE statement contains decimals, commas, dollar signs, dashes, and pound signs ("#") in representation of the substituted numeric or alphameric values.
{{sxhl|2=bbcbasic|1=
3540 IMAGE: ###-##-####  #############################  $#,###,###.##
}}
A FORM statement denotes the size of the variables to be read or written.  To save a numeric value of .00 to 99,999.99, use this notation:
{{sxhl|2=basic|1=
2959 FORM N 7.2
}}
A label is a tag on a line as follows:
{{sxhl|2=bbcbasic|1=
260 BEGIN_CALCULATIONS::
270 FOR X = 1 TO 12
280 Y = Y + X*1.08
290 NEXT X
}}
If desired, the statement {{code|GOSUB BEGIN_CALCULATIONS}} can be used instead of {{code|GOSUB 260}}.

{{mono|OPEN, CLOSE, WRITE, REWRITE, DELETE,}} and {{mono|APPEND}} are already familiar to [[COBOL]] programmers and describe the actions taken to access S/36 disk files using BASIC.  It isn't possible to access every single type of S/36 file because these include system files, libraries, and folders, but every user-created S/36 file with a fixed record length (only [[FORTRAN]] programs can use variable record lengths) will suffice.  Disk files can be opened sequentially, by index, or relatively (by record number).  If a file is delete-capable, records can be deleted using the {{mono|DELETE}} statement.  To add a record, use {{mono|WRITE}} (with {{mono|APPEND}} specified in the {{mono|OPEN}} statement) and to update use {{mono|REWRITE}}.

In S/36 BASIC, to print to the printer, a device file must be used.  A default printer file called #255 always exists when BASIC is started.  It has a printer name of BASIC255 and opens the device that is the default printer for the terminal that begins a BASIC session.  If desired, it is possible to create a different printer file numbered between 1 and 254.  Use {{code|2=basic|1=OPEN #x: PRINTER,NAME=}} and so forth to do this, specifying columns or device ID or other parameters as needed.  The {{mono|PAGEOFLOW}} keyword can be used to trap the page overflow condition for the printer.

Some versions of BASIC allow the programmer to sort an array.  S/36 BASIC doesn't provide a function for this, but it does provide an interesting remedy.  The programmer can define an array with the same number of elements as the target array and use AIDX or DIDX to create an ascending or descending index.  Each element of the new array will contain a number representing the ordinal sorted position of the target array, so if AMERICA is the sixth element of array {{mono|A$}} but first in alphabetical order, then setting {{code|1=A() = DIDX(A$)}} would cause {{code|A(6)}} to contain the value 1.

Writing a BASIC program is much more fun than rewriting the same program each time you use it, therefore the authors of BASIC allow programmers to {{mono|SAVE}} their program code to a library member and to {{mono|REPLACE}} it when changes are made.

{{code|2=basic|SAVE PROG1,PGMRLIB}} causes the current module to be saved as a subroutine member (type R) named {{mono|PROG1}} in a user library named {{mono|PGMRLIB}}.

Note that System/36 files are not part of libraries.  If a disk file is named {{mono|FNF001}}, then an {{mono|OPEN}} statement like this one can work:
{{sxhl|2=basic|1=
  OPEN #3:"NAME=FNF001,SEQUENTIAL",INPUT
}}
It doesn't matter which library is used to access file FNF001.

{{mono|RENUMBER}} is the S/36 BASIC command used to renumber statements.  All internal references to statement numbers are immediately recalculated.

System/36 BASIC has a very dangerous command called {{mono|FREE}}.  Typing {{mono|FREE}} followed by a filename deletes that file without a trace.  It will work for every user file, unless there is a conflict of security or an in-use condition that blocks it.

System/36 BASIC has another dangerous command called {{mono|LOCK}}.  The {{mono|LOCK}} command will make the current program source code inaccessible and it is not reversible.  Always save an unlocked copy before using LOCK.

==Incompatibility Between S/34 and S/36==
System/34 BASIC and System/36 BASIC are very similar; however, machine code incompatibility makes it impossible to port a subroutine member BASIC program between these systems.

See also Square Root of 2 & PI π solution for solution published on mainframes during the 1980s & 1990s. 

==References==
{{reflist}}

{{DEFAULTSORT:Ibm System 36 Basic}}
[[Category:BASIC interpreters]]
[[Category:IBM software|System 36 BASIC]]