Infobasic Programming - Advanced

Information in this document is subject to change without notice.

No part of this document may be reproduced or transmitted in any form or by any means,
electronic or mechanical, for any purpose, without the express written permission of TEMENOS Holdings NV.

Copyright 2002-2003 TEMENOS Holdings NV. All rights reserved.

PRG2 – Infobasic Programming

Published by:
Temenos Training Publications
Temenos Corporate Education Centre,
Temenos India Private Ltd,
No.146, Sterling Road, Nungambakkam, Chennai: 600 034, INDIA.
Ph: +91 44 2822 2001. E-mail: indtr@temenos.com

Authoring Contributions:
Alagammai Palaniappan (First Edition, 2001) – Temenos India Private Ltd.

Thankful Acknowledgements:
Temenos Corporate Training Team

Copyright © 2006 TEMENOS HEADQUARTERS SA

Warning: This document is protected by copyright law and international treaties. No part of this
document may be reproduced or transmitted in any form or by any means, electronic or mechanical,
for any purpose, without the express written permission of TEMENOS Holdings NV Unauthorized
reproduction or distribution of this presentation or any portion of it, may result in severe civil and
criminal penalties, and will be prosecuted to the maximum extent possible under applicable law.”
Information in this document is subject to change without notice.

Trademarks

TEMENOS™, TEMENOS T24™, TEMENOS GLOBUS™, TEMENOS ™, ™ are registered trademarks

of TEMENOS HOLDINGS NV in Switzerland and other countries.

jBASE®, jBC, jEDI, TM and TM are registered trademarks of TEMENOS Holdings NV in Switzerland
and other countries.
UNIX is a registered trademark of The Open Group. All other trademarks and copyrights mentioned herein may
be the trademarks or registered trademarks of their respective owners.

TEMENOS Training Publications Page 2 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Date Version Changes By

2002 1.1 jBASE Changes Alagammai
Palaniappan
2002 1.2 Infobasic Alagammai
Programming Palaniappan
changes
July 2004 1.3 TXN Mgt changes Alagammai
and overall update Palaniappan
September 2004 1.4 EB.READLIST Alagammai
amendment and Palaniappan
CACHE.READ
inclusion
December 2004 1.5 Minor Changes and Sara Cleur
formatting
January 2007 1.6 Formatting changes B.Nandakumar
Feb 2007 1.7 CACHE READ Alagammai
changes, TRANS
removed,
modularising c/w

TEMENOS Training Publications Page 3 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Table of Content
Preface................................................................................................................................................... 6
Scope of this document...................................................................................................................... 6
Who should read this.......................................................................................................................... 6
Conventions Used............................................................................................................................... 6
Software and their versions................................................................................................................ 6
Example 1.............................................................................................................................................. 7
Solution 1............................................................................................................................................ 7
Algorithm......................................................................................................................................... 7
Step 1.............................................................................................................................................. 7
Steps 2 And 3.................................................................................................................................. 7
Step 4.............................................................................................................................................. 7
F.READU......................................................................................................................................... 7
Step 5.............................................................................................................................................. 8
F.WRITE.......................................................................................................................................... 8
Step 6.............................................................................................................................................. 9
Consolidated Solution 1................................................................................................................ 10
An Insight Into Reading And Writing In T24.......................................................................................... 11
CACHE.READ.................................................................................................................................. 14
Important T24 Routines........................................................................................................................ 15
OVERLAY.EX.................................................................................................................................... 15
FATAL.ERROR................................................................................................................................. 15
Writing Data...................................................................................................................................... 15
Creating Subroutines With Arguments.................................................................................................. 16
Example 2......................................................................................................................................... 16
Step 1............................................................................................................................................ 16
Step 2............................................................................................................................................ 16
Defining Functions In Infobasic............................................................................................................. 17
Example 3......................................................................................................................................... 17
Step 1............................................................................................................................................ 17
Step 2............................................................................................................................................ 17
Additional Information........................................................................................................................... 18
LOCATE............................................................................................................................................ 18
F.DELETE......................................................................................................................................... 19
Infobasic Commands........................................................................................................................ 19
MATREAD..................................................................................................................................... 19

TEMENOS Training Publications Page 4 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

MATWRITE................................................................................................................................... 19
CONVERT..................................................................................................................................... 20
DELETE........................................................................................................................................ 20

TEMENOS Training Publications Page 5 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Preface

Scope of this document

This document is meant to give an insight into certain T24 routines (especially reading and writing)
that can be used while writing code for T24.

Who should read this

A consultant who wishes to advance his Infobasic programming skill and write code for T24

Conventions Used

– Features available in the latest available T24 release release are prefixed
with a symbol.

– Main informational notes are marked in italics and prefixed with a

symbol.

– Information requiring special attention are marked in italics and prefixed with
a symbol.

– Syntax / commands and source codes are given in colored

boxes.

– Parameters/Environmental variables are marked in italics and prefixed using

Software and their versions

The following are the various software with their version / release numbers, that are required to run the
commands / source codes / examples given in this document:
– TEMENOS T24 release R4 or above.
– jBASE v 4.1 or above.

TEMENOS Training Publications Page 6 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Example 1
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’.

Solution 1
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 T24 installation to
another).
Step 4.For each of the accounts selected, read the corresponding record from the ACCOUNT file
Step 5.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 6.Update the F.JOURNAL file.
Repeat steps 3 to 5 for all accounts using the LOOP and REPEAT statements.

Step 1
Create the local reference filed CHARGE in the ACCOUNT application using the LOCAL.TABLE and
the LOCAL.REF.TABLE applications.

Steps 2 And 3
As discussed earlier use OPF and EB.READLIST.

Step 4
Now we need to read the record from the ACCOUNT file. Normally we would use the F.READ
statement to read a record from a file. But we need to understand that , when we read a record, we
only obtain a shared lock on the record and hence multiple people can read the record simultaneously.
Since the record that we are to read by might updated by us, we need to ensure that we have
exclusive control over the record. Hence we need to use F.READU instead of F.READ.

F.READU
Parameters
FILEID file name
KEY record-id
REC record returned
F.FILEID file variable
ER returning error message
TEMENOS Training Publications Page 7 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA
2007.1
PRG2 – Infobasic Programming

RETRY 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
‘’ (null) - Retry continuously
CALL F.READU(FN.ACC,Y.AC.ID,R.ACCOUNT,F.ACC,Y.ACC.ERR,RETRY)
The simple rule is, when you want to modify a record, use F.READU and obtain the record.

Step 5
Once the working balance has been extracted and is found to be lesser then 5000, now the local
reference field CHARGE needs to be set to ‘Y’ and the entire account record needs to be written on to
the ACCOUNT file.

To update a local reference field

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

Note that there is just one physical field called LOCAL.REF in most of the applications in T24. By
using LOCAL.TABLE and the LOCAL.REF.TABLE applications, we are just multi-valuing the field
LOCAL.REF and giving the new multi value field a new name. Therefore, once a local reference field
is created, it would not affect the physical layout of the file(would not affect the dict) but will only affect
the STANDARD.SELECTION. All local reference fields will have an entry in the SS application with the
Usr Type set to ‘I’ – I descriptor.

Use the T24 subroutine F.WRITE to write on to a file.

F.WRITE
F.WRITE is a core T24 subroutine that is used to write a record on to a file.

The routine works differently depending on mode of T24.

 If the system is in the Online mode, then F.WRITE will only write the data on to the cache.
 If the system is in the Batch mode (COB is in progress) then it will straight write to the disk and
not to the cache provided the F.WRITE is not within a transaction block.

When the system is in the Online mode, as mentioned earlier, the write will only happen to the cache.
It is only when a subsequent call to JOURNAL.UPDATE is encountered, the data will be flushed to the
disk.

JOURNAL.UPDATE is a core T24 routine that takes care of updating the F.JOURNAL file and also
ensures transaction management. Please note that JOURNAL.UPDATE, if called when the system is
in Batch mode, will not update the JOURNAL file.

Transaction management can be explicitly triggered in T24 using the EB.TRANS routine.

CALL EB.TRANS(“START”, ”Start of transaction block”)

TEMENOS Training Publications Page 8 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA
2007.1
PRG2 – Infobasic Programming

Statement 1
Statement 2
Statement 3
CALL EB.TRANS(“END”, ‘End of transaction block”)

If it any point within a transaction block the transaction needs to aborted, the T24 subroutine
TRANSACTION.ABORT can be called.
CALL TRANSACTION.ABORT

The JOURNAL.UPDATE routine in T24, has the EB.TRANS embedded in it.

Syntax
F.WRITE(<filename>,<id of record>,<dynamic record variable>)

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

Step 6
Use the T24 subroutine JOURNAL.UPDATE to update the F.JOURNAL file.

CALL JOURNAL.UPDATE(Y.AC.ID)
Note
While writing subroutines that would get executed during the Online stage of T24, a call to F.WRITE
will fail if it does not find a subsequent call to JOURNAL.UPDATE. During the batch stage, since the
F.JOURNAL file is not maintained, a call to F.WRITE does not require a subsequent call to
JOURNAL.UPDATE.

TEMENOS Training Publications Page 9 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Consolidated Solution 1

*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’
F.ACC = ‘’
Y.AC.ID = ‘’
R.ACCOUNT = ‘’
Y.ACC.ERR = ‘’
RETRY = ‘’
RETURN
OPENFILES:
CALL OPF(FN.ACC,F.ACC)
RETURN
PROCESS:
SEL.CMD=“SELECT “:FN.ACC:” WITH CATEGORY=6001 AND WORKING.BALANCE < 5000”
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.ACC.ID,R.ACCOUNT,F.ACC,Y.ACC.ERR,RETRY)
      R.ACCOUNT<AC.LOCAL.REF,1> = ‘Y’
      CALL F.WRITE(FN.ACC,Y.ACC.ID,R.ACCOUNT)
Y.AC.ID = ‘’
R.ACCOUNT = ‘’
    REPEAT

TEMENOS Training Publications Page 10 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

In the above example, F.WRITE is called within a loop and JOURNAL.UPDATE is called outside the
loop. In this case the system is in Online mode and hence all the writes triggered by F.WRITE would
happen only to the cache. It is only when the control comes out of the loop the data from the cache will
actually get flushed to the disk. Care should be taken when calling F.WRITE within a loop – it might
lead to using up all the cache.
Note: Use JOURNAL.UPDATE cautiously. Only mainline routines like the one above will need a call to
JOURNAL.UPDATE. When routines are attached to T24, T24 itself will make a call to
JOURNAL.UPDATE

An Insight Into Reading And Writing In T24

There are a number of ways using which data can be retrieved from T24. We need to choose the right
method of extracting data to achieve performance.
As we have already discussed, F.READ and F.READU can be used to read data from files in T24. It is
very important for us to understand how data is read by these routines and the best way to read data
so that we get the optimum performance.

Working of F.READ
1. Obtain the file name and the record id
2. Perform SMS validations
3. Check if the record is in cache. If it is in cache, will fetch it
4. If it is not in cache, read from the file in the disk and load the record into cache

Working of F.READU
1. Obtain the file name and record id
2. Perform SMS validations
3. Check if the record is in cache and if so, check if it is locked. If not locked, go to the disk and
lock it
4. If the record is not in cache, read and lock the record from the disk

F.READU holds info of all record locks so that they can be released during a transaction abort.
Whenever we lock a record using F.READU, the lock gets released when
a. That record is written back to the file
b. When the program terminates
c. When an explicit RELEASE statement is encountered
TEMENOS Training Publications Page 11 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA
2007.1
PRG2 – Infobasic Programming

In T24, in many routines, even if there is no explicit RELEASE statement, the locks get releases. This
is because of the RELEASE statement in JOURNAL.UPDATE.

Working of F.READV
Similar to F.READU, but fetches only one field of the record unlike F.READ that fetches the whole
record.

READ: Extract data from a file. F.READ and F.READV call READ internally to extract data. Always use
F.READ, F.READU or F.READV to extract data. Never use READ.

     READ <Record> FROM <File Name>, <ID> ELSE <Message>
READ REC FROM F.FL, ID ELSE GOSUB “Record Not Found”

READU: Extract data from a file and lock it. F.READU internally calls this to extract data.

     READU <Record> FROM <File Name>, <ID> ELSE <Message>
READU REC FROM F.FL, ID ELSE GOSUB CRT “Record Not Found”

Please note, when we use READ or READU, we need to specify the actual name of the file that we
are to open, as OPF is not called to open the file.

The jBASE command OPEN can be used to open files.

OPEN: Open files to file variables.

   OPEN <File Name> TO <File Variable> ELSE ABORT
   OPEN “FBNK.CUSTOMER” TO F.FL ELSE ABORT

TEMENOS Training Publications Page 12 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Working of DBR (T24 subroutine)

The DBR routine can be used to extract the value of a single field from a record. This internally does a
READ and obtains the record. From the record, it fetches the required field’s value and returns it to the
user. Please note that the file from which the data needs to be retrieved need not be explicitly opened
for DBR as DBR would open the file internally.
Incoming Parameters:
Field 1 = File Name (without 'F.')
Field 2 = Name of the filed as in the insert file whose value needs to be fetched
Field 3 = miscellaneous arguments (delimiter = '.')
a) ""
Or 'L' = Take value field in accordance to language
Or 'F' = Take full field
b) Not used
c) Not used
d) Delimiter argument
e) Ignore error

Outgoing Parameters:

Value of the field that has been fetched

CALL DBR(<FileName:FM:FldToBeFetched:FM:”LangSpecFld”>,<ID>,<RetVar>)
CALL DBR(“CUSTOMER”:FM:EB.CUS.SHORT.NAME:FM:”L”:,100069,Y.RET.VAL)

All the above routines are core T24 routines that can be used to extract data from T24. All these
routines in-turn have to call Infobasic commands to actually obtain data. Following are the various
Infobasic commands that can be used to extract data.

TEMENOS Training Publications Page 13 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

CACHE.READ
CACHE.READ is a routine that is used to read a record from a file in T24. CACHE.READ will
 Check if the record required is in cache
 Is yes, check if it is not older than the number of seconds specified in the field
CACHE.EXPIRY in SPF. If not older, extract the record and return to the user
 Else will perform F.READ to extract the record
 Load the extracted record on to cache
 Return the record to the user.

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

FILENAME = Name of file - without the mnemonic (Example: F.CUSTOMER)

ID = Valid values are
ID of a record itself or the following literals
‘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
CACHE.READ is not used to extract a record from a file, but also for executing SELECT statements.
If the string ‘SelectIDs’ is passed to CACHE.READ, it will in turn call EB.READLIST which will execute
an ‘Internal’ select.
If ‘SSelectIDs’ or ‘SSelectARs’ is passed to CACHE.READ, it will in turn call EB.READLIST that will
execute the select statement supplied to it.

When To Use CACHE.READ Against F.READ

CACHE.READ maintains a buffer that is not bound within a transaction boundary and gets reset only
on exiting the current T24 session
So, what this means is, any record that will not, in a production environment be changed by any
transaction that a user may input, can be retrieved using CACHE.READ. To put things in perspective,
a typical example could be reading a record from the VERSION application which obviously will not
be changed during the course of normal day to day operation by a user in a production system. As a
standard rule of thumb, all parameter files which require a one time setup and do not contain any
dynamic data, can be retrieved using CACHE.READ.
CACHE.READ should not be used on any financial files.

TEMENOS Training Publications Page 14 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Important T24 Routines

OVERLAY.EX
This is the routine that is called when a user signs on into T24. It clears and loads all the common
variables, opens common files etc.

CALL OVERLAY.EX

FATAL.ERROR
Routine to display system errors, log them to the protocol file and exit. The text that needs to be
displayed as a fatal error needs to be set in the common variable TEXT. The FATAL.ERROR routine
takes in one parameter. This parameter can hold any value, but is usually set to the name of the file on
which the fatal error occurred.

TEXT = “Customer File Not Accessible”
CALL FATAL.ERROR(“CUSTOMER”)

The above command will result in updating a record in the PROTOCOL file with the ID : <UserName> .
This user name is the name of the user for whom the fatal error was generated.

Writing Data
We have already learnt that F.WRITE is used to write data on to T24. F.WRITE internally calls WRITE
to actually write.

WRITE <Record> ON <Filename>,<ID> ON ERROR <Message>

WRITE
Please note that when a WRITE is executed on a record that has been locked, the WRITE statement
will release the lock.
Always used F.WRITE to write records to the database.

TEMENOS Training Publications Page 15 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Creating Subroutines With Arguments

All this while we have been learning about subroutines that just display the value on the screen or
store the value on to an array. This section will now introduce you to the process of creating
subroutines that can take in arguments or parameters and return values as well. Let us understand it
with a simple example.

Example 2
Step 1
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

While defining subroutines in Infobasic, we cannot specify which are the incoming and which are the
return parameters. Therefore just specify the arguments one after the other along with the subroutine
definition as done above. Since the subroutine is storing the result in the variable ARG.3, the system
would understand that ARG.3 is the return parameter.

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

TEMENOS Training Publications Page 16 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Defining Functions In Infobasic

Functions can also be defined in Infobasic. These functions can take in any number of parameters but
return only one value. Let us understand it with a simple example.

Example 3
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.

Step 2
Now the function defined above can be called from any program/subroutine. Now create a subroutine
that would supply values and call the above-defined function. When calling a function, the function
needs to be defined first using the DEFFUN command and only then the function should be called.

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

Incase of a function, only the incoming parameters need to be defined. There can and will be only one
return value and that will directly get assigned to the variable on the right side of the equation as
defined above.

Un-initialized variables VAL.1 and VAL.2 have been given to demonstrate that any variable can be
given at the time of defining a function.

TEMENOS Training Publications Page 17 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

Additional Information
LOCATE
LOCATE statement is used to locate the position of a string or determine the position to insert in to
maintain a specific sequence.

Syntax

LOCATE expr IN dynamic.array<FIELD,VALUE>,STARTPOS
BY sort.expr SETTING variable
THEN statements ELSE statements

Additional Information

Sort.Expr :

AL Ascending left(Alpha sort)

AR Ascending right(Numeric sort)
DL Descending left(High-low alpha sort)
DR Descending right(High-low numeric sort)

Example

DAYS = “MON:”FM:”TUE”:FM:”WED”:FM:”THU”:FM:”FRI”
LOCATE “WED” IN DAYS SETTING FOUND ELSE FOUND = 0
CRT “Position of WED in DAYS dynamic array :”:FOUND
LOCATE “SAT” IN DAYS BY “AL” SETTING POS ELSE 
INS “SAT” BEFORE DAYS<POS>
END
CRT “Position where SAT has been inserted :”:POS
CRT “Days dynamic array after inserting SAT :”:DAYS

Output

Position of WED in DAYS dynamic array : 3

Position where SAT has been inserted : 2
Days dynamic array after inserting SAT : MONSATTUEWEDTHUFRI

TEMENOS Training Publications Page 18 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1
PRG2 – Infobasic Programming

F.DELETE
F.DELETE is also a core T24 subroutine that is used to delete a record from a file.

Syntax

F.DELETE(FileName,Id of the record to be deleted)

CALL F.DELETE(FN.CUS,Y.CUSID)

Infobasic Commands

MATREAD
MATREAD is a command that is used to read the contents of a dimensioned/dynamic array. You can
specify the id of the record to be picked up from the array. Incase the read is successful, then the
statements following the ‘THEN’ statements are executed else the statements following the ‘ELSE’
statement are executed.

Syntax

MATREAD array FROM file.variable, record.ID THEN statements ELSE statements

Example

MATRED Array1 from F.REGISTER.DETAILS,ID1 THEN ….. ELSE …..

The above statement will search for a record with id specified in the variable ID1, if found, it will
transfer the record to the array Array1.

MATWRITE
MATWRITE is used to build a dynamic array from a specified dimensioned array and write it to the file
opened to file.variable using a key of record.id.

Syntax

MATWRITE matrix ON file.variable,KEY
TEMENOS Training Publications Page 19 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA
2007.1
PRG2 – Infobasic Programming

Example

  DIM ARRAY1(5)
MATREAD ARRAY1 FROM TEM1,101 ELSE
MAT ARRAY1 = ‘’
END
MATWRITE ARRAY1 ON TEM1,100

CONVERT
Use the CONVERT command to convert characters to other characters.

Y.STRING = “TEMENOSFMT24”
CONVERT FM TO VM IN Y.STRING
CRT Y.STRING
TEMENOSVMT24

DELETE
Use the DELETE command to delete a record. The F.DELETE T24 routine uses this statement to
delete a record.

DELETE <FileName>,<ID>

TEMENOS Training Publications Page 20 of 20 Copyright © 2006 TEMENOS HEADQUARTERS SA

2007.1