Infobasic Programming

Infobasic Programming
T2BTT – R06 – 1.0 Copyright 2005 TEMENOS HEADQUARTERS SA1

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
T2BTT – R06 – 1.0 Copyright 2005 TEMENOS HEADQUARTERS SA2

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
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
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
Dynamic Array
CUSTOMER.NAME = ‘’
RATE = 0
DATE = “121202”
Can store any type and any amount of data.

Only initialisation is required.
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
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
How will this record get stored in a dynamic array?
Storage In A Dynamic Array
TemenosTrgFMIndiaVMUKVMGenevaFMTechnicalVMFunctionalFM
jBASESMT24VMLendingSMFinancialsFMFMTrainer.1
Copyright 2005 TEMENOS
HEADQUARTERS S1A0
T2BTT – R06 – 1.0

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

HEADQUARTERS S1A1
Dimensioned Array (Cont.)
DIM ARRAY2(4)
4 – Rows
Unlimited columns (Each row will be a dynamic array)
HEADQUARTERS S1A2
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
RETURN
END END
HEADQUARTERS S1A3
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 place here
lib.so.1
$TRG.RTN1
Is there place here
lib.so.2
Copyright 2005 TEMENOS HEADQUARTERS S1A4
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
HEADQUARTERS S1A5
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
Executing Programs
Go to the
database prompt
jsh..> TRG.PRG1
PATH =
.;$HOME/globusbin;$HOME/bin;$PATH
Execute the
program
Writing A Simple Infobasic Program
Program to display ‘Hello World’
JED TRG.BP HELLO
PROGRAM HELLO
CRT “Hello World”
END
HEADQUARTERS S1A8
Compile And Execute The Program
 Compile and catalog

EB.COMPILE TRG.BP HELLO
 Execute the program
jsh..>HELLO
Hello World
HEADQUARTERS S1A9
Workshop 1
HEADQUARTERS S2A0
Control Structures
 IF THEN ELSE
IF <condition> THEN
<statements>
END
ELSE
<statements>
END
HEADQUARTERS S2A1
 BEGIN CASE … END CASE
BEGIN CASE
CASE <variable> = <value>
<statements>
<statements>
<statements>
CASE 1
<statements>
END CASE
HEADQUARTERS S2A2
 FOR
FOR <variable> = <initialvalue> TO <maximumvalue>

<statements>
NEXT <variablename>
HEADQUARTERS S2A3
 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
HEADQUARTERS S2A4
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
HEADQUARTERS S2A5
Structure Of A Subroutine
SUBROUTINE SubroutineName
$INSERT I_COMMON
$INSERT I_EQUATE
Actual Statements
Actual Statements
RETURN
END
HEADQUARTERS S2A6
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
Example 2
Write a subroutine that will display the details

(Id, Mnemonic and Nationality)of a customer whose id is 100069
HEADQUARTERS S2A8
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.
HEADQUARTERS S2A9
Open A File
 Use the command OPEN
OPEN FBNK.CUSTOMER…….
But…….
HEADQUARTERS S3A0
Open A File (Cont.)
 OPF – Open File
CALL OPF(FN.CUS,F.CUS)
FN.CUS = ‘F.CUSTOMER’ (File Name)

F.CUS = ‘’ (File Path)
HEADQUARTERS S3A1
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,F.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.
HEADQUARTERS S3A2
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¬¬
HEADQUARTERS S3A3
Extract Values
R.CUSTOMER<1>
R.CUSTOMER<15>
What happens after an upgrade?

HEADQUARTERS S3A4
I_F.CUSTOMER File
HEADQUARTERS S3A5
Display Parts Of A Record
Y.MNEMONIC = R.CUSTOMER<EB.CUS.MNEMONIC>
Y.NATIONALITY = R.CUSTOMER<EB.CUS.NATIONALITY>
HEADQUARTERS S3A6
Display Parts Of A Record(Cont.)
CRT “Customer Id: “:Y.CUS.ID

CRT “Customer Mnemonic: “:Y.MNEMONIC
CRT “Customer Nationality: “:Y.NATIONALITY
HEADQUARTERS S3A7
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’
F.CUS = ‘’
Y.CUS.ID = 100069
Y.MNEMONIC = ‘’
Y.NATIONALITY = ‘’
R.CUSTOMER = ‘’
CUS.ERR1 = ‘’
RETURN
HEADQUARTERS S3A8
Solution 2 (Cont.)
OPENFILES:
RETURN
PROCESS:
CALL F.READ(FN.CUS,Y.CUS.ID,R.CUSTOMER,F.CUS,CUS.ERR1)
CRT “Customer Id: “:Y.CUS.ID
CRT “Customer Mnemonic: “:Y.MNEMONIC
CRT ‘Customer Nationality: “:Y.NATIONALITY
RETURN
END
HEADQUARTERS S3A9
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.

HEADQUARTERS S4A0
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
$INSERT I_COMMON
$INSERT I_EQUATE
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN
INIT:
DEBUG
FN.CUS = ‘F.CUSTOMER’
F.CUS = ‘’
Y.CUS.ID = 100069
HEADQUARTERS S4A1
Debugging……….
Source changed to BP/CUS.DISPLAY.DETAILS

0011 DEBUG
jBASE debugger->S
0012 FN.CUS = 'F.CUSTOMER'
jBASE debugger->S
0013 F.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 F.CUS
F.CUS : File '../mbdemo.data/st/FBNK.CUST000'
HEADQUARTERS S4A2
Workshop 2
HEADQUARTERS S4A3
Example 3
Modify example 2 to display the mnemonic and nationality of all the

customers
HEADQUARTERS S4A4
Algorithm
 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
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
HEADQUARTERS S4A6
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
HEADQUARTERS S4A7
EB.READLIST (Cont.)
CALL EB.READLIST(SEL.CMD,SEL.LIST,’’,NO.OF.REC,RET.CODE)
HEADQUARTERS S4A8
Insight Into EB.READLIST – Execute Select
SEL.CMD = “SELECT “:FN.CUS:” WITH SECTOR > 1000”

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
HEADQUARTERS S4A9
Insight Into EB.READLIST - Internal Select
SEL.CMD = “SELECT “:FN.CUS

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
HEADQUARTERS S5A0
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
HEADQUARTERS S5A1
Repeating A Set Of Statements
Use LOOP and REMOVE(Discussed Earlier) to repeat

Steps 3 to 6
HEADQUARTERS S5A2
Solution 3
*Subroutine to display the mnemonic and nationality of all customers
$INSERT I_COMMON
$INSERT I_EQUATE
DEBUG
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN
INIT:
FN.CUS = 'F.CUSTOMER'
F.CUS = ''
Y.CUS.ID = ''
R.CUSTOMER = '‘
CUS.ERR1 = ''
Y.MNEMONIC = ''
Y.NATIONALITY = ''
SEL.CMD = ''
SEL.LIST = ''
NO.OF.REC = 0
RET.CODE = ''
RETURN
HEADQUARTERS S5A3
Solution 3 (Contd.)
OPENFILES:
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
CRT "Customer Id: ":Y.CUS.ID
CRT "Customer Mnemonic: ":Y.MNEMONIC
CRT "Customer Nationality: ":Y.NATIONALITY
REPEAT
RETURN
END
HEADQUARTERS S5A4
Solution 3
 Add a DEBUG statement in the routine

HEADQUARTERS S5A5
Workshop 3
HEADQUARTERS S5A6
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
HEADQUARTERS S5A7
Algorithm
 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
HEADQUARTERS S5A8
Algorithm
 Step 6. Store the customer id, mnemonic and the

nationality in a dynamic array
 Repeat Steps 3 to 6 for all customers

HEADQUARTERS S5A9
Append Data In An Array
ARRAY<-1> = NewValue
ARRAY<-1> = Y.CUS.ID:’*’:Y.MNEMONIC:’*’:Y.NATIONALITY
HEADQUARTERS S6A0
Append Data In An Array (Cont.)
What if an array delimited with VM’s need to formed?

ARRAY<1,-1> = Value
What if an array delimited with SM’s need to be formed?

ARRAY<1,1,-1> = Value
HEADQUARTERS S6A1
Solution 4
*Subroutine to store the id, mnemonic and nationality of all *customers in an array
$INSERT I_COMMON
$INSERT I_EQUATE
GOSUB INIT
GOSUB OPENFILES
GOSUB PROCESS
RETURN
INIT:
FN.CUS = 'F.CUSTOMER'
F.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
HEADQUARTERS S6A2
Solution 4 (Cont.)
OPENFILES:
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
CUS.DETAILS.ARRAY<-1> =
Y.CUS.ID:'*':Y.MNEMONIC:'*':Y.NATIONALITY
REPEAT
RETURN
END
HEADQUARTERS S6A3
Solution 4
 Add a DEBUG statement in the routine

HEADQUARTERS S6A4
Workshop 4
Are there better ways to read data from a file?
HEADQUARTERS S8A0
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.
HEADQUARTERS S8A1
 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
HEADQUARTERS S8A2
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
HEADQUARTERS S8A3
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
– Perform 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

Infobasic Programming

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Infobasic Programming

Загружено:

Авторское право:

Доступные форматы

Infobasic Programming

T2BTT – R06 – 1.0 Copyright 2005 TEMENOS HEADQUARTERS SA1

T2BTT – R06 – 1.0 Copyright 2005 TEMENOS HEADQUARTERS SA2

 Programming language used for T24

 Continuous allocation of bytes

Can store any type and any amount of data.

 Dynamic Arrays (Cont.)

– Uses delimiters to store data of various fields

ASCII Decimal Description

T2BTT – R06 – 1.0

Copyright 2005 TEMENOS

PROGRAM – Executed from the database prompt

EB.COMPILE TRG.BP TRG.RTN1

Check for errors Check JBCDEV_LIB

EB.COMPILE TRG.BP TRG.PRG1

Check for errors Check JBCDEV_BIN

Login into T24

At the command line

Program to display ‘Hello World’

JED TRG.BP HELLO

 Compile and catalog

 Execute the program

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

 LEN(e) Length of the text in expression

 Insert files are available under GLOBUS.BP

 Common variables get loaded when a user signs on

 Some common variables are loaded when specific

Write a subroutine that will display the details

 Step 1. Open the Customer File

 Step 2. Read the Customer file and extract the record

 Use the command OPEN

 OPF – Open File

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

What happens after an upgrade?

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

*Subroutine to display the details of customer 100069

 Compile and catalog the routine

 Execute the routine from the command line.

 See the execution of the routine line by line

Source changed to BP/CUS.DISPLAY.DETAILS

Modify example 2 to display the mnemonic and nationality of all the

 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

 Assign the select statement to a variable

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

 Use the Globus subroutine EB.READLIST to execute the

 Use SSELECT instead of SELECT if you want data in a

 1 - Select Statement To Be Executed

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

How does EB.READLIST execute this SELECT statement?

 Picks up the SELECT statement

 Performs an ‘EXECUTE SEL.CMD’ and store the output

SEL.CMD = “SELECT “:FN.CUS

 Use the facility of internal select in EB.READLIST when

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

Use LOOP and REMOVE(Discussed Earlier) to repeat

SEL.CMD = "SELECT ":FN.CUS

 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.

 Step 1. Open the Customer File