Infobasic Programming

Agenda

• Introduction to Infobasic
• Arrays and types of arrays
• Introduction to subroutines and programs
• Important functions/commands in Infobasic
• Steps to create a subroutine in T24
• Compiling and cataloguing routines and programs
• T24 routines – file operations
• T24 routines – sequential file access
• T24 – Creation of functions and routines with
arguments

07 January 2005
Introduction To Infobasic

• Programming language used for T24

• Simple – English like statements
• No declaration of variables required
• No data type specification is required
• All variables by default have infinite variable length
– Multi value
– Sub Value

07 January 2005
Arrays

• Continuous allocation of bytes

• All bytes in an array have the same name as that of
the array
• Each byte is uniquely identified with the help of a
subscript.

T E M E N O S
0 1 2 3 4 5 6

07 January 2005
Arrays In Infobasic

• Dynamic Arrays
– Dynamic in nature
– Variable length
– Need not be declared
– Can hold any type of data
– Automatically increase or decrease in size depending on the
data
– All variables in Infobasic are dynamic arrays
• Dimensioned arrays
– Have a fixed number of rows and columns
– Can hold any type of data
– Needs to be declared
– Used when dimensions and extents are known and are not
likely to change

07 January 2005
Dynamic Array

CUSTOMER.NAME = ‘’
RATE = 0
DATE = “121202”

Can store any type and any amount of data.

Only initialisation is required.

07 January 2005
Arrays

• Dynamic Arrays (Cont.)

– Uses delimiters to store data of various

fields

ASCII Decimal Description

254 Field Marker
253 Value Marker
252 Sub-Value Marker
Filed1FMField2FM Value1VMValue2VMValue3VMValue4FMField4FMSubValue1SMSubValue2FMField6

07 January 2005
Sample Record From The TEMENOS.TRG

1 Name TemenosTrg
2.1 Address India
2.2 Address UK
2.3 Address Geneva
3.1 Course Category Technical
4.1.1 Course Name jBASE
4.1.2 Course Name T24
3.2 Course Category Functional
4.2.1 Course Name Lending
4.2.2 Course Name Financials
5 Free Text
6 Inputter TRAINER.1

07 January 2005
How will this record get stored in a dynamic
array?

07 January 2005
Storage In A Dynamic Array

TemenosTrgFMIndiaVMUKVMGenevaFMTechnicalVMFunctionalFM
jBASESMT24SMLendingSMFinancialsFMFMTrainer.1

07 January 2005
Dimensioned Array

DIM ARRAY1(4,3)
4 – Rows
3 – Columns

07 January 2005
Dimensioned Array (Cont.)

DIM ARRAY2(4)
4 – Rows
Unlimited columns (Each row will be a dynamic array)

07 January 2005
 Structure Of An Infobasic Program

PROGRAM – Executed from the database prompt

SUBROUTINE – Execute from within Globus

*Comments *Comments
PROGRAM <Programname> SUBROUTINE <Subroutinename>
Statement 1 Statement 1
Statement 2 Statement 2
Statement 3 Statement 3
RETURN
END END

07 January 2005
 Compiling And Cataloguing Routines

EB.COMPILE TRG.BP TRG.RTN1

COMPILE CATALOG

Check for errors Check JBCDEV_LIB

Error – Exit
No Error JBCDEV_LIB
= $HOME/lib
Produce object code
$TRG.RTN1 $HOME/lib
TRG.BP
Is there lib.so.1
place here
$TRG.RTN1
Is there lib.so.2
place here
07 January 2005
 Compiling And Cataloguing Programs

EB.COMPILE TRG.BP TRG.PRG1

COMPILE CATALOG

Check for errors Check JBCDEV_BIN

Error – Exit
No Error JBCDEV_BIN
= $HOME/bin
Produce executable
$TRG.PRG1
TRG.BP $HOME/bin
$TRG.PRG1 TRG.PRG1

07 January 2005
 Executing Routines

Login into T24

Make an entry in
the PGM.FILE

At the command line

TRG.RTN1

JBCOBJECTLIST =
$HOME/globuslib;$HOME/lib

Execute the
routine
07 January 2005
 Executing Programs

Go to the
database prompt

jsh..> TRG.PRG1

PATH =
.;$HOME/globusbin;$HOME/bin;$PATH

Execute the
program
07 January 2005
Writing A simple Infobasic Program

Program to display ‘Hello World’

JED TRG.BP HELLO

PROGRAM HELLO
CRT “Hello World”
END

07 January 2005
Compile And Execute The Program

• Compile and catalog

EB.COMPILE TRG.BP HELLO

• Execute the program

jsh..>HELLO
Hello World

07 January 2005
Workshop 1
Control Structures

• IF THEN ELSE

IF <condition> THEN
<statements>
END
ELSE
<statements>
END

07 January 2005
Control Structures

• BEGIN CASE … END CASE

BEGIN CASE
CASE <variable> = <value>
<statements>
CASE <variable> = <value>
<statements>
CASE <variable> = <value>
<statements>
CASE 1
<statements>
END CASE

07 January 2005
Control Structures

• FOR

FOR <variable> = <initialvalue> TO <maximumvalue>

<statements>
NEXT <variablename>

07 January 2005
Control Structures

• Open Loop

LOOP
CRT “Input 2 Numbers”
INPUT Y.NUM1
INPUT Y.NUM2
WHILE Y.NUM1:Y.NUM2
CRT “Total “ : Y.NUM1 + Y.NUM2
REPEAT

07 January 2005
Built In Infobasic Functions

LEN(e) Length of the text in expression

COUNT(e,d) Number of occurrences of d in e
DCOUNT(e,d) Number of occurrences of d in e, +1
UPCASE(e) Converts e to uppercase
DOWNCASE(e) Converts e to lowercase
CHANGE(e,d,c) Change occurrences of d to c in e
OCONV(e,d) Convert e into the format specified in d

07 January 2005
Structure Of A Subroutine

SUBROUTINE SubroutineName
$INSERT I_COMMON
$INSERT I_EQUATE

Actual Statements
Actual Statements

RETURN
END

07 January 2005
Insert Files

• I_COMMON
– Defines all common variables
• I_EQUATE
– Equates a number of common variables

• Insert files are available under GLOBUS.BP

• Common variables get loaded when a user signs on
• Some common variables are loaded when specific
applications are opened/specific actions are
performed
• Example : R.USER, ID.NEW

07 January 2005
Example 2

Write a subroutine that will display the details

(Id, Mnemonic and Nationality)of a customer whose id is
100069

07 January 2005
Algorithm

• Step 1. Open the Customer File

• Step 2. Read the Customer file and extract the
record with id 100069
• Step 3. From the extracted record obtain the
mnemonic and nationality
• Step 4. Display the customer id,mnemonic and
nationality.

07 January 2005
Open A File

• Use the command OPEN

OPEN FBNK.CUSTOMER…….

But…….

07 January 2005
Open A File (Cont.)

OPF – Open File

CALL OPF(FN.CUS,F.CUS)

FN.CUS = ‘F.CUSTOMER’ (File Name)

FV.CUS = ‘’ (File Path)

07 January 2005
Read A File

Use the Globus subroutine

CALL F.READ(1,2,3,4,5)
1 - File name
2 - ID of the record to be read
3 - Dynamic array that will hold the read record
4 - File Path
5 – Error Variable

CALL F.READ(FN.CUS,”100069”,R.CUSTOMER,FV.CUS,CUS.ERR1)

F.READ always checks if the record is in cache. If yes, fetches the record
from the cache, else retrieves the record from the databse.

07 January 2005
Record Returned By F.READ

Contents of R.CUSTOMER
DAOHENGBK DAO HENG BANK INC DAO HENG BANK INC 119 ASIAN MANSION 209
DELA ROSA ST LEGASPI VILLAGE MAKATI CITY MAN PH 1111
90 8100 999 PH 4 PH 20000101 20000101
1 1 18_RICKBANAT1ÿ28_ANDREABARNES1 0006121042 18_RI
CKBANAT1 US0010001 1

07 January 2005
Extract Values

R.CUSTOMER<1>
R.CUSTOMER<15>

What happens after an upgrade?

07 January 2005
I_F.CUSTOMER File

07 January 2005
Display Parts Of A Record

Y.MNEMONIC = R.CUSTOMER<EB.CUS.MNEMONIC>
Y.NATIONALITY = R.CUSTOMER<EB.CUS.NATIONALITY>

07 January 2005
Display Parts Of A Record(Cont.)

CRT “Customer Id: “:Y.CUS.ID

CRT “Customer Mnemonic: “:Y.MNEMONIC
CRT “Customer Nationality: “:Y.NATIONALITY

07 January 2005
Solution 2

*Subroutine to display the details of customer 100069

SUBROUTINE CUS.DISPLAY.DETAILS
$INSERT I_COMMON
$INSERT I_EQUATE
$INSERT I_F.CUSTOMER
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN
INIT:
FN.CUS = ‘F.CUSTOMER’
FV.CUS = ‘’
Y.CUS.ID = 100069
Y.MNEMONIC = ‘’
Y.NATIONALITY = ‘’
R.CUSTOMER = ‘’
CUS.ERR1 = ‘’
RETURN

07 January 2005
Solution 2 (Cont.)

OPENFILES:
CALL OPF(FN.CUS,FV.CUS)
RETURN
PROCESS:
CALL F.READ(FN.CUS,Y.CUS.ID,R.CUSTOMER,FV.CUS,CUS.ERR1)
Y.MNEMONIC = R.CUSTOMER<EB.CUS.MNEMONIC>
Y.NATIONALITY = R.CUSTOMER<EB.CUS.NATIONALITY>
CRT “Customer Id: “:Y.CUS.ID
CRT “Customer Mnemonic: “:Y.MNEMONIC
CRT ‘Customer Nationality: “:Y.NATIONALITY
RETURN
END

07 January 2005
Solution 2

• Compile and catalog the routine

– EB.COMPILE TRG.BP CUS.DISPLAY.DETAILS
• Make an entry in the PGM.FILE with the type set to
‘M’.

• Execute the routine from the command line.

07 January 2005
 Debugging …….

• See the execution of the routine line by line

• Insert the ‘DEBUG’ statement anywhere in the
routine
Subroutine to display the details of customer 100069
SUBROUTINE CUS.DISPLAY.DETAILS
$INSERT I_COMMON
$INSERT I_EQUATE
$INSERT I_F.CUSTOMER
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN
INIT:

DEBUG
FN.CUS = ‘F.CUSTOMER’
FV.CUS = ‘’
Y.CUS.ID = 100069

07 January 2005
Debugging……….

Source changed to BP/CUS.DISPLAY.DETAILS

0011 DEBUG
jBASE debugger->S
0012 FN.CUS = 'F.CUSTOMER'
jBASE debugger->S
0013 FV.CUS = ''
jBASE debugger->S
0014 Y.CUS.ID = 1038
jBASE debugger->S
0015 Y.MNEMONIC = ''
jBASE debugger->S
---------------------------------------
---------------------------------------
0023 PROCESS:
jBASE debugger->V FN.CUS
FN.CUS : FBNK.CUSTOMER
jBASE debugger->V FV.CUS
FV.CUS : File '../mbdemo.data/st/FBNK.CUST000'

07 January 2005
Workshop 2
Example 3

Modify example 2 to display the mnemonic and

nationality of all the customers

07 January 2005
 Algorithm

• Step 1. Open the Customer File

• Step 2. Select all the customer ids

• Step 3. Remove one customer id from the selected list

• Step 4. For the extracted customer id extract the

corresponding record from the customer file
• Step 5. From the extracted record extract the mnemonic and
nationality
• Step 6. Display the customer id, mnemonic and nationality
• Repeat Steps 3 to 6 for all customers
07 January 2005
Select

• Assign the select statement to a variable

• SEL.CMD = “SELECT “:FN.CUS

Note the space

• Use the Globus subroutine EB.READLIST to execute

the select statement
• Use SSELECT instead of SELECT if you want data in
a sorted order

07 January 2005
EB.READLIST

CALL EB.READLIST(1,2,3,4,5)

• 1 - Select Statement To Be Executed

• 2 - A dynamic array that will hold the ids of all records
selected, separated by field markers.
• 3 - File that will hold the results of the select
statement(Optional)
• 4 - Variable that will hold the number of records
selected
• 5 - Return Code

07 January 2005
EB.READLIST (Cont.)

CALL EB.READLIST(SEL.CMD,SEL.LIST,’’,NO.OF.REC,RET.CODE)

07 January 2005
Insight Into EB.READLIST – Execute Select

SEL.CMD = “SELECT “:FN.CUS:” WITH SECTOR > 1000”

CALL EB.READLIST(SEL.CMD,SEL.LIST,’’,NO.OF.REC,RET.CODE)

How does EB.READLIST execute this SELECT

statement?

• Picks up the SELECT statement

• Performs an ‘EXECUTE SEL.CMD’ and store the
output on to SEL.LIST

07 January 2005
Insight Into EB.READLIST - Internal Select

SEL.CMD = “SELECT “:FN.CUS

CALL EB.READLIST(SEL.CMD,SEL.LIST,’’,NO.OF.REC,RET.CODE)

How does EB.READLIST execute this SELECT

statement?
• Picks up the SELECT statement
• Realizes that there are no conditions and no sorted select in
SEL.CMD
• Performs an OPF for the file that you wish to select
CALL OPF(FN.CUS.F.CUS)
• Performs ‘SELECT F.CUS’
– This is faster than ‘EXECUTE SEL.CMD’ as it is not actually
selecting the file
– It is only positioning the file pointer to the start of the file and then
will extract one ID after another and store it in SEL.LIST

07 January 2005
Insight Into EB.READLIST - Internal Select

• Use the facility of internal select in EB.READLIST

when

– You wish to process most of the records of a file

– You do not want records in a sorted order

07 January 2005
Repeating A Set Of Statements

Use LOOP and REMOVE(Discussed Earlier) to repeat

Steps 3 to 6

07 January 2005
Solution 3

*Subroutine to display the mnemonic and nationality of all customers

SUBROUTINE CUS.DISPLAY.DETAILS
$INSERT I_COMMON
$INSERT I_EQUATE
$INSERT I_F.CUSTOMER
DEBUG
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN
INIT:
FN.CUS = 'F.CUSTOMER'
FV.CUS = ''
Y.CUS.ID = ''
R.CUSTOMER = '‘
CUS.ERR1 = ''
Y.MNEMONIC = ''
Y.NATIONALITY = ''
SEL.CMD = ''
SEL.LIST = ''
NO.OF.REC = 0
RET.CODE = ''
RETURN

07 January 2005
 Solution 3 (Cont.)

OPENFILES:
CALL OPF(FN.CUS,FV.CUS)
RETURN
PROCESS:

SEL.CMD = "SELECT ":FN.CUS

CALL EB.READLIST(SEL.CMD,SEL.LIST,'',NO.OF.REC,RET.CODE)
LOOP
REMOVE Y.CUS.ID FROM SEL.LIST SETTING POS
WHILE Y.CUS.ID:POS
CALL F.READ(FN.CUS,Y.CUS.ID,R.CUSTOMER,FV.CUS,CUS.ERR1)
Y.MNEMONIC = R.CUSTOMER<EB.CUS.MNEMONIC>
Y.NATIONALITY = R.CUSTOMER<EB.CUS.NATIONALITY>
CRT "Customer Id: ":Y.CUS.ID
CRT "Customer Mnemonic: ":Y.MNEMONIC
CRT "Customer Nationality: ":Y.NATIONALITY
REPEAT
RETURN

END

07 January 2005
Solution 3

• Add a DEBUG statement in the routine

• Compile and catalog the routine
• Make an entry in the PGM.FILE with the type set to
‘M’.
• Execute the routine from the command line.

07 January 2005
Workshop 3
Example 4

Amend example 3 to store the extracted all the

customer Ids, their mnemonics and nationalities in a
dynamic array in the following format
CusId*Mnemonic*NationalityFMCusId*Mnemonic*Nationality

07 January 2005
Algorithm

• Step 1. Open the Customer File

• Step 2. Select all the customer ids

• Step 3. Remove one customer id from the

selected list

• Step 4. For the extracted customer id extract the

corresponding record from the customer file

• Step 5. From the extracted record extract

the mnemonic and nationality

07 January 2005
Algorithm

• Step 6. Store the customer id, mnemonic and the

nationality in a dynamic array

• Repeat Steps 3 to 6 for all customers

07 January 2005
Append Data In An Array

ARRAY<-1> = NewValue

ARRAY<-1> = Y.CUS.ID:’*’:Y.MNEMONIC:’*’:Y.NATIONALITY

07 January 2005
Append Data In An Array (Cont.)

What if an array delimited with VMs need to formed?

ARRAY<1,-1> = Value

What if an array delimited with SMs need to be formed?

ARRAY<1,1,-1> = Value

07 January 2005
Solution 4
*Subroutine to store the id, mnemonic and nationality of all *customers in an array
SUBROUTINE CUS.DISPLAY.DETAILS
$INSERT I_COMMON
$INSERT I_EQUATE
$INSERT I_F.CUSTOMER
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN

INIT:
FN.CUS = 'F.CUSTOMER'
FV.CUS = ''
Y.CUS.ID = '‘
R.CUSTOMER = ''
CUS.ERR1 = ''
Y.MNEMONIC = ''
Y.NATIONALITY = ''
SEL.CMD = ''
SEL.LIST = ''
NO.OF.REC = 0
RET.CODE = ''
CUS.DETAILS.ARRAY = ''
RETURN

07 January 2005
Solution 4 (Cont.)

OPENFILES:
CALL OPF(FN.CUS,FV.CUS)
RETURN

PROCESS:

SEL.CMD = "SELECT ":FN.CUS

CALL EB.READLIST(SEL.CMD,SEL.LIST,'',NO.OF.REC,RET.CODE)
LOOP
REMOVE Y.CUS.ID FROM SEL.LIST SETTING POS
WHILE Y.CUS.ID:POS
CALL F.READ(FN.CUS,Y.CUS.ID,R.CUSTOMER,FV.CUS,CUS.ERR1)
Y.MNEMONIC = R.CUSTOMER<EB.CUS.MNEMONIC>
Y.NATIONALITY = R.CUSTOMER<EB.CUS.NATIONALITY>
CUS.DETAILS.ARRAY<-1> =
Y.CUS.ID:'*':Y.MNEMONIC:'*':Y.NATIONALITY
REPEAT
RETURN

END

07 January 2005
Solution 4

• Add a DEBUG statement in the routine

• Compile and catalog the routine
• Make an entry in the PGM.FILE with the type set to
‘M’.
• Execute the routine from the command line.

07 January 2005
Workshop 4
Example 5

Example 5
As a part of the COB process in T24, all savings
accounts that have balance less than 5000 need to be
charged a fee. For this purpose you are expected to
create a local reference field by name CHARGE in the
Account application and write a subroutine that will
check the working balance of all savings accounts, and
if the working balance is lesser than 5000 then set the
value in the local reference field CHARGE to ‘Y’. As a
part of the COB process in T24, one of the COB
routines will deduct a charge from all accounts which
have this field set to ‘Y’.

07 January 2005
Algorithm

• Step 1 . Create the local reference field CHARGE

using the LOCAL.TABLE application and attach it to
the ACCOUNT application using the
LOCAL.REF.TABLE application.

• Step 2. Open the ACCOUNT file

• Step 3.Select all accounts with category = 6001(this

category might differ from one Globus installation to
another).

• Step 4.For each of the accounts selected, read the

corresponding record from the ACCOUNT file

07 January 2005
Algorithm (Cont.)

• Step 4. Check the working balance of the account

and if the balance is less than 5000 then write the
entire ACCOUNT record into the ACCOUNT file with
the local reference field CHARGE set to ‘Y’

• Step 5.Update the F.JOURNAL file.

• Repeat steps 3 to 5 for all accounts using the LOOP

and REPEAT statements.

07 January 2005
Update a local reference field

R.ACCOUNT<AC.LOCAL.REF,1> = ‘Y’

07 January 2005
Write into a hashed file

CALL F.WRITE(FN.ACC,Y.AC.ID,R.ACCOUNT)

• Parameters :
– File name
– Record Id
– Record to be written

07 January 2005
Update the F.JOURNAL file

CALL JOURNAL.UPDATE(Y.AC.ID)

• Online Mode : F.WRITE to be followed by

JOURNAL.UPDATE
• Batch Mode : F.WRITE should not be followed by
JOURNAL.UPDATE as the F.JOURNAL file is not
available during EOD.

07 January 2005
Solution 5

*Subroutine to check if the balance in all savings accounts are less than 5000 and if so,
*update a local reference field in the ACCOUNT file called CHARGE to ‘Y’.

SUBROUTINE ACC.BAL.CHECK
$INSERT I_COMMON
$INSERT I_EQUATE
$INSERT I_F.ACCOUNT
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS

INIT:
FN.ACC = ‘F.ACCOUNT’
FV.ACC = ‘’
Y.AC.ID = ‘’
R.ACCOUNT = ‘’
Y.ACC.ERR = ‘’
RETURN

07 January 2005
Solution 5
OPENFILES:
CALL OPF(FN.ACC,FV.ACC)
RETURN

PROCESS:
SEL.CMD = “SELECT “:FN.ACC:” WITH CATEGORY = 6001”
CALL EB.READLIST(SEL.CMD,SEL.LIST,’’,NO.OF.REC,RET,CODE)
LOOP
REMOVE Y.ACC.ID FROM SEL.LIST SETTING POS
WHILE Y.ACC.ID:POS
CALL F.READ(FN.ACC,Y.AC.ID,R.ACCOUNT,FV.ACC,Y.ACC.ERR)
IF R.ACCOUNT<AC.WORKING.BALANCE> < 5000 THEN
R.ACCOUNT<AC.LOCAL.REF,1> = ‘Y’
CALL F.WRITE(FN.ACC,Y.ACC.ID,R.ACCOUNT)
CALL JOURNAL.UPDATE(Y.ACC.ID)
END
Y.AC.ID = ‘’
R.ACCOUNT = ‘’
REPEAT
RETURN

END

07 January 2005
What if another user updates the same Account record
while you are trying to update?

07 January 2005
Always read and lock a record if you wish to update it.

Can F.READ, read and lock a record?

No. It can only read.

07 January 2005
F.READU

Use F.READU
• Similar to F.READ
• Read and lock a record
• The lock will be released when
– The record is written back to the file
– There is an explicit RELEASE statement after obtaining the
lock
– The routine terminates

07 January 2005
F.READU

CALL F.READU(1,2,3,4,5,6)
1 – File Name
2 – ID
3 – Record
4 – File variable
5 – Error variable
6 – Retry Option
– P msg - prompt user with msg to retry if record locked
– R nn xx - retry xx times with a nn seconds sleep interval
– I - ignore the lock and return
– E - return immediately with an error message
– ‘’ – Retry continuously

07 January 2005
Code With F.READU

PROCESS:
SEL.CMD = “SELECT “:FN.ACC:” WITH CATEGORY = 6001”
CALL EB.READLIST(SEL.CMD,SEL.LIST,’’,NO.OF.REC,RET,CODE)
LOOP
REMOVE Y.ACC.ID FROM SEL.LIST SETTING POS
WHILE Y.ACC.ID:POS
CALL F.READU(FN.ACC,Y.AC.ID,R.ACCOUNT,FV.ACC,Y.ACC.ERR,’’)
IF R.ACCOUNT<AC.WORKING.BALANCE> < 5000 THEN
R.ACCOUNT<AC.LOCAL.REF,1> = ‘Y’
CALL F.WRITE(FN.ACC,Y.ACC.ID,R.ACCOUNT)
JOURNAL.UPDATE(Y.ACC.ID)
END
Y.AC.ID = ‘’
R.ACCOUNT = ‘’
REPEAT
RETURN

END

07 January 2005
Solution 5

• Add a DEBUG statement in the routine

• Compile and catalog the routine
• Make an entry in the PGM.FILE with the type set to
‘M’.
• Execute the routine from the command line.

07 January 2005
Are there better ways to read data from a file?

07 January 2005
CACHE.READ

• Used to read data from the cache.

– It checks if the record is in cache
– If yes, retrieves it from the cache
– Else, does a OPF and F.READ to fetch the record and loads
it in the cache
– Will not pick up records from cache if they are more than
<SPF->CACHE.EXPIRY> seconds old.

07 January 2005
CACHE.READ (Cont.)

• Doesn’t F.READ also perform a similar operation?

• When should I use CACHE.READ ?

Use CACHE.READ when

– The record that you retrieve will not be frequently updated
– Best used for retrieving parameter records
– It is faster than F.READ as it does not require a call to OPF.
Only when the record is not available in cache, it will perform
an OPF

07 January 2005
CACHE.READ (Cont.)

CACHE.READ(FileName,ID,Record,Error)

FILENAME = Name of file - without the mnemonic

(Example : F.CUSTOMER)
ID = Valid values are
ID of a record
‘SelectIDs‘ (List of Ids from the ‘FileName’)
‘SSelectIDs’ (List of sorted Ids)
‘SSelectARs’ (List of sorted Ids in ascending order right justified)
Record = Data returned
Error = RECORD NOT FOUND for example

07 January 2005
CACHE.READ (Cont.)

When
• ID is passed to CACHE.READ
– Check if it exists in cache else will read from disk and load it
to cache
• If ‘SelectIDs’ is passed to CACHE.READ
– Peform a call to EB.READLIST. Since there are no
conditions and it is not a sorted select, an internal selected
will be executed
• If ‘SSelectedID’ or ‘SSelectARs’ is passed
– Perform a call to EB.READLIST. Since it is sorted select, will
actually select the file

07 January 2005
Insight Into Reading And Writing Records

• READ
• F.READ
• F.READU
• F.READV
• DBR
• TRANS
• WRITE
• F.WRITE

07 January 2005
Important T24 Routines

• OVERLAY.EX
• FATAL.ERROR

07 January 2005
Workshop 5
Example 6

Write a program that will write a string “Infobasic

programming” onto a sequential file.

07 January 2005
Algorithm

Step1 . Create a non hashed file with the name

“TEMENOS.SEQ”

CREATE.FILE TEMENOS.SEQ TYPE=UD

07 January 2005
Algorithm (Cont.)

Step 2. Open the non hashed file

OPENSEQ filename,recordid to pointer

OPENSEQ SEQ.FILE.NAME,RECORD.NAME TO SEQ.FILE.POINTER

Parameters:
SEQ.FILE.NAME = ‘TEMENOS.SEQ’
RECORD.NAME = ‘1’

07 January 2005
Opening A Sequential File

OPENSEQ SEQ.FILE.NAME,RECORD.NAME TO SEQ.FILE.POINTER ELSE

CREATE SEQ.FILE.POINTER ELSE
CRT “Unable to create file pointer to file “:SEQ.FILE.NAME
STOP
END
END
CRT “Openseq was successful on file “:SEQ.FILE.NAME

07 January 2005
Algorithm (Cont.)

Step 4 :Close the file once the operations are complete.

Use the CLOSESEQ command to close a
sequential file.

CLOSESEQ FilePointer

CLOSESEQ SEQ.FILE.POINTER

07 January 2005
Solution 6

PROGRAM SEQFILE.ACCESS.WRITE
SEQ.FILE.NAME = ‘TEMENOS.SEQ’
RECORD.NAME = ‘1’
OPENSEQ SEQ.FILE.NAME,RECORD.NAME TO SEQ.FILE.POINTER ELSE
CREATE SEQ.FILE.POINTER ELSE
CRT “Unable to create file pointer to file “:SEQ.FILE.NAME
STOP
END
END
CRT “Openseq was successful on file “:SEQ.FILE.NAME
WRITESEQ “Infobasic programming” TO SEQ.FILE.POINTER ELSE
CRT “Unable to perform WRITESEQ”
END
CLOSESEQ SEQ.FILE.POINTER
END

07 January 2005
Workshop 6
Example 7

Write a program that will read the data that has been
written on to the sequential file TEMENOS.SEQ .

07 January 2005
Algorithm

Step 1 : Open the sequential file

Step 2 : Read the data from the sequential file and
display it
Step 3 : Close the sequential file

07 January 2005
Reading A Sequential File

READSEQ

READSEQ is the command that is used to read the

data from a sequential file.

READSEQ variablename FROM filepointer THEN ……

ELSE…..

07 January 2005
Reading A Sequential File

READSEQ Y.MSG FROM SEQ.FILE.POINTER THEN

CRT “Message Extracted :”:Y.MSG
END
ELSE
CRT “Unable to read from file “
END

07 January 2005
 Solution 7

PROGRAM SEQFILE.ACCESS.READ
SEQ.FILE.NAME = ‘TEMENOS.SEQ’
RECORD.NAME = ‘1’
OPENSEQ SEQ.FILE.NAME,RECORD.NAME TO SEQ.FILE.POINTER ELSE
CREATE SEQ.FILE.POINTER ELSE
CRT “Unable to create file pointer to file “:SEQ.FILE.NAME
STOP
END
END
CRT “Openseq was successful on file “:SEQ.FILE.NAME
READSEQ Y.MSG FROM SEQ.FILE.POINTER THEN
CRT “Message Extracted :”:Y.MSG
END
ELSE
CRT “Unable to read from file “
END
CLOSESEQ SEQ.FILE.POINTER
END

07 January 2005
More On OPENSEQ

• An OPENSEQ command can also be used to open a

file provided along with the path of the file and the id.

SEQ.FILE.NAME = ‘./TEMENOS.SEQ/1’

OPENSEQ SEQ.FILE.NAME TO SEQ.FILE.POINTER

• All the other WRITESEQ, READSEQ, CLOSESEQ

statements will remain the same.

07 January 2005
Workshop 7
Subroutines With Arguments

• Subroutines can take in any number of parameters

• Subroutines can return any number of values

• When defining a subroutine, the parameters for that

subroutine are defined

07 January 2005
Example 8 And Solution 8

Create a subroutine that will accept 2 integer

values, multiply them and return the result in a variable.

SUBROUTINE DEMO.CALLED.RTN(ARG.1,ARG.2,ARG.3)
ARG.3 = ARG.1 * ARG.2
RETURN
END

07 January 2005
Solution 8 (Cont.)

Step 2

Create another subroutine that would supply the values

and call the DEMO.CALLELD.RTN.

SUBROUTINE DEMO.CALLING.RTN
VAR.1 = 10
VAR.2 = 20
VAR.3 = ‘’
CALL DEMO.CALLED.RTN(VAR.1,VAR.2,VAR.3)
PRINT ‘Result “:VAR.3
RETURN
END

07 January 2005
Defining Functions

• Functions can be created in infobasic using the

FUNCTION statement

• Functions can taken in any number of arguments

• Functions can and will return only one value using

the RETURN statement

• Functions can be defined in a subroutine before it is

called using the DEFFUN function

07 January 2005
Example 9 And Solution 9

Step 1

Create a function that will accept 2 integer values,

multiply them and return the result in a variable.

FUNCTION DEMO.FUNCTION(ARG.1,ARG.2)
RET.VALUE = ARG.1 * ARG.2
RETURN(RET.VALUE)
END

The RETURN statement is used to return a value in a

function.

07 January 2005
 Solution 9 (Cont.)

Step 2

Create a subroutine that will call the function DEMO.FUNCTION.

SUBROUTINE DEMO.SUB.CALLING.RTN
VAR.1 = 10
VAR.2 = 20
DEFFUN DEMO.FUNCTION(VAL.1,VAL.2)
VAR.3 = DEMO.FUNCTION(VAR.1,VAR.2)
CRT “Result :”:VAR.3
RETURN
END

07 January 2005
Consolidated Workshop