Host/API 
|
| Host/API | | Detailed Routine Descriptions |
| |
ZAFTER, Start Creation of an AFTER Key
ARGS: DUMMY
DESC: ZAFTER starts the creation of a DBMS key. It creates
an "AFTER" key. That is, a key which will be used
to select all CIR/record's whose key comes after the
key that is currently being defined. It is normally
called after one of the case/record level
initialisation routines in order to initialise the
key selection options for case or record loops.
Following a call to ZAFTER, key definitions routines
are called to enter values into the key one at a
time. For a case key only one call is made to enter
the value of the case id. For record keys, the case
id is assumed to be the same as the last CIR
retrieved or restored. Therefore, only the record
sort ids have to be inserted into the key. The
sort-ids must be entered in the order of their
appearance in the key being created.
ENTRY: DUMMY (I * 4 ) Dummy argument needed to make a
syntactically correct FORTRAN function. Should
always be 0.
EXIT: None.
| |
ZATTR, Equivalence Long and Short Filenames
ARGS: FILENM,STRING,STRLEN
DESC: ZATTR performs the equivalent of the ATTRIBUTE
command in DBMS. Currently it allows the
equivalencing of a FILENAME (short 1-8 character
name) and a long (quoted filename). After ZATTR is
called use of the short name will reference the file
specified by the long name.
ENTRY: FILENM (N * 8) Short name or "ldi" specification of
ATTRIBUTE command.
STRING (B * n) Long name or string appearing within
quote marks of DSN = subparameter of
ATTRIBUTE command (without quotes).
STRLEN (I * 4) Number of characters in argument STRING.
EXIT: None.
RETURN: The location of the entry in the ATTRIBUTE table
(small positive integer).
| |
ZBEGIN, Start Creation of Starting Key
ARGS: DUMMY
DESC: ZBEGIN is called after a new level in a retrieval
block is started, and prior to retrieving the first
CIR/record. It allows the user to start creating a
key which will be used as the first key to be
processed at the level.
ENTRY: DUMMY (I * 4 ) Dummy argument needed to make a
syntactically correct FORTRAN
function. Should always be 0.
EXIT: None.
| |
ZBLTRC, Store Blank in Variable if Blank Is Missing or Undefined
ARGS: VDESC
DESC: ZBLTRC stores a blank into a variable. If the blank
is a missing value, then it is stored as the
respective missing value. For other values, an
error is returned.
ENTRY: VDESC (D * 8) The descriptor for the variable to be set
to blank.
EXIT: None.
| |
ZCACHE, Set and Retrieve Cache System Control Parameters
ARGS: FNC,VAL
DESC: ZCACHE is used to set and retrieve cache system-control
parameters.
ENTRY: FNC (I * 4) The control function code.
VAL (I * 4) The new value or dummy.
EXIT: None.
RETURN: Negative if error, if not as described below:
FNC VAL Return code Description
1 0 0 Disable cache
1 1 0 Enable cache
2 n 0 Set table space = n
3 n 0 Set number of buffers= n
5 0 0 Set "write when" mode
5 1 0 Set "write thru" mode
11 x 0 Return for cache disabled
11 x 1 Return for cache enabled
12 x n Return table space
13 x n Return number of buffers
15 x 0 Return for "write when" mode
15 x 1 Return for "write thru" mode
| |
ZCALL, Call HOST Function and Check Its Return Value
ARGS: ZFUNC, PRTFL, ENDFL, LBLNO, CODE1, CODE2
DESC: ZCALL enables the programmer to write a more concise
and easier to maintain program by performing the
testing of the return codes and the eventual error
processing. First, ZCALL calls ZFUNC. If ZFUNC
returns a positive value, zero or a negative value
that is between CODE1 and CODE2, ZCALL returns
immediately. If ZCALL does not return immediately,
the following action is taken: PRTFL is 0, nothing
is printed in the log file. PRTFL is 1, a brief
message is printed that indicates the subroutine
name, the error code, and the statement label LBLNO.
If it is 2, the short message is printed followed by
the complete error message on the next line. If
ENDFL is 0, ZCALL returns. If it is -1, the full
HOST system is shutdown but the subroutine returns.
If it is -2, the full system is shutdown and the
subroutine exits directly. If it is n(positive
integer), the current stream (user) is shutdown, the
system switches to user n and the subroutine
returns.
ENTRY: ZFUNC (I * 4) Z function to call, with all its arguments.
PRTFL (I * 4) Print flag, controls if and how a message is
printed.
ENDFL (I * 4) End flag, controls the flow of control after
an error has occurred
LBLNO (I * 4) Statement label number.
CODE1 (I * 4) Error code (Negative 4 digit number or 0).
CODE2 (I * 4) Error code (Negative 4 digit number or 0).
EXIT: None.
RETURN: Return value of ZFUNC.
| |
ZCCNT, Initialise COUNT Case-processing Block for Current Database
ARGS: TCASES,INDEX,START
DESC: ZCCNT is the first of a series of routines that can
be called in order to create "PROCESS CASE" block
with the COUNT option. The purpose of this call is
to initialise the retrieval stack with the required
information. The arguments correspond to the
arguments on the COUNT = clause of the PROCESS CASE
command in RETRIEVAL. ZCCNT can also be used to
process ALL cases by setting INDEX and START to 1
and TCASES to -1.
ENTRY: TCASES(I * 4) Total number of cases to be processed.
INDEX( I * 4) Every INDEX the case will be processed.
START (I * 4) Starting with the START th case in the
database.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZCCNTD, Set Current Database and Initialise COUNT Case-processing Block
ARGS: TCASES,INDEX,START,DBNAME
DESC: ZCCNTD is called to make DBNAME the current database
and to start creating a "PROCESS CASE" block with
the COUNT option. The purpose of this call is to
initialise the retrieval stack with the required
information. The arguments correspond to the
arguments on the COUNT = clause of the PROCESS CASE
command in RETRIEVAL. the database. ZCCNTD can also
be used to process ALL cases by setting INDEX and
START to 1 and TCASES to -1.
ENTRY: TCASES(I * 4) Total number of cases to be processed.
INDEX (I * 4) Every INDEX th case will be processed.
START (I * 4) Starting with the START the case in
the database.
DBNAME(N * 8) The database name to be processed by
this case loop.
EXIT: None.
RETURN: Stack level of the newly created block, negative if error.
| |
ZCDEL, Delete Current Case from Database
ARGS: DUMMY
DESC: ZCDEL is called after a CIR is retrieved to delete
the current CIR and all its associated data records.
ENTRY: DUMMY (I * 4) Dummy argument needed to make a
syntactically correct FORTRAN
function. Should always be 0.
EXIT: None.
| |
ZCEXIT, Terminate Case Processing Level
ARGS: OLDSEED
DESC: ZCEXIT is called to terminate a case level and pop
back one level in the retrieval stack.
ENTRY: None.
EXIT: OLDSEED(I * 4) The current value of the seed is
returned to this argument if this was a
PROCESS loop with the SAMPLE option.
Otherwise the value is undefined.
| |
ZCFIND, Find Case with Given Key
ARGS: OPT, LFLAG, DIRECT, BEGIN
DESC: ZCFIND finds an existent case or creates a new case
with a previously specified key. It is called after
routine ZCGDMY or ZCRDMY has created a dummy block
and after putting values into the caseid variable in
CIR and ( if OPT is 1 ) in other common variables.
When ZCFIND is executed, the value of the caseid is
used to create the case key. If the caseid variable
is undefined, then the dummy block is converted into
a PROCESS CASE ALL block and the next or previous
CIR is read. Otherwise, the dummy block is
converted into a CASE IS block and: a) if OPT is 1,
then the undefined values are updated to the values
read from the found CIR or b) if OPT is 2 the full
current CIR is replaced by the read CIR.
ENTRY: OPT (I * 4) Controls the update/replace of the CIR.
LFLAG (I * 4) Lock flag.
DIRECT (I 4) If PROCESS CASE then use 1 to get the
next case and -1 to get the previous
case.
BEGIN (I * 4) Should be 0 to set the range to all
cases (starting with the first case in
the database) and I to convert to a
PROCESS CASES ALL block (if caseid is
undefined) or CASE IS block (if
caseid is defined).
EXIT: None.
RETURN: -4001 if CIR not found;
-3026 if CIR is found but is incompatible locked;
+0003 if CIR is found and has a compatible lock;
+0004 if CIR is found and available for CASE IS;
+0000 if CIR is found and available for PROCESS
CASE;
negative if error.
| |
ZCFRST, Start-up Case Level Block and Get First CIR
ARGS: LFLAG
DESC: ZCFRST is called after case-block initialisation and
all key creation, and after all key-definition
routines. It starts-up the case block and gets the
first CIR that meets all of the selection options
previously specified. No other case-level function
can be called until this block is successfully
executed. After ZCFRST is executed, no further key
definitions may be made. The system checks that the
current lock flag is compatible with LFLAG and if it
is, LFLAG becomes the new lock.
ENTRY: LFLAG(I * 4) The lock flag.
EXIT: None.
| |
ZCGDMY, Initialise Dummy Case-level Processing
ARGS: DBNAME
DESC: ZCGDMY starts up a case block without accessing the
database. After ZCGDMY has been called and values
put in the CIR, ZCFIND should be called to create
the key and find the CIR. If DBNAME is not all
blanks, it is made the current database.
ENTRY: DBNAME ( N * 8 ) Database name (all blanks means use
current database
EXIT: None.
RETURN: Stack level of the newly created block, negative if error.
| |
ZCIS, Initialise CASE IS Block for Current Database
ARGS: NEW,OLD
DESC: ZCIS is the first of a series of routines that can
be called in order to create "CASE IS" block. The
purpose of this call is to initialise the retrieval
stack with the required information.
ENTRY: NEW (I * 4) It is 1 if a new case can be created by
this level, otherwise it is 0. The
database must have been opened for
update to allow a value of 1.
OLD (I * 4) It is 1 if an old case can be accessed
by this level, otherwise it is 0.
EXIT: None.
RETURN: Stack level of the newly created block, negative if error.
| |
ZCISD, Set Current Database and Initialise CASE IS Block
ARGS: NEW,OLD,DBNAME
DESC: ZCISD is called to make DBNAME the current database
and to start creating a "CASE IS" block. The
purpose of this call is to initialise the retrieval
stack with the required information.
ENTRY: NEW (I * 4) It is 1 if a new case can be created by
this level, otherwise it is 0. The
database must have been opened for
update to allow a value of 1.
OLD (I * 4) It is I if an old case can be accessed
by this level, otherwise it is 0.
DBNAME(N*8) The database name to be processed by the
level being created.
EXIT: None.
RETURN: Stack location of the new block, negative if error.
| |
ZCLAST, Start Case-level Block and Get Last CIR
ARGS: LFLAG
DESC: ZCLAST is called after case-block initialisation and
all key creation, and after all key-definition
routines. It starts-up the case block and gets the
last CIR that meets all of the selection options
previously specified. No other case-level function
can be called until this block is successfully
executed. After ZCLAST is executed, no further key
definitions may be made. The system checks that the
current lock flag is compatible with LFLAG and if it
is, LFLAG becomes the new lock.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZCLEAR, Clear Retrieval Stack for a Stream
ARGS: USERNO
DESC: ZCLEAR calls ZREXIT and ZCEXIT as often as needed
and in the proper order, in order to clear all
levels in the retrieval stack for the specified
user. ZCLEAR should be used to clear the stack when
the current position is unknown.
ENTRY: USERNO(I * 4) The stream number whose retrieval stack
should be cleared.
EXIT: None.
| |
ZCLOCK, Return The Lock Type of the Case Level from
Execution Stack
ARGS: LFLAG
DESC: ZCLOCK returns the lock type of the case level to
which the innermost block in the execution stack
belongs.
ENTRY: None.
EXIT: LFLAG (I * 4) Lock type.
RETURN: 0 if the level is not write-locked. 1 if the level is write-locked.
| |
ZCNEXT, Get Next Case for Current Level
ARGS: LFLAG
DESC: ZCNEXT is called after case-block initialisation and
all key creation, and after all key-definition
routines. It starts-up the case block and gets the
next CIR that meets all of the selection options
previously specified. No other case-level function
can be called until this block is successfully
executed. After ZCNF-XT is executed, no further key
definitions may be made. The system checks that the
current lock flag is compatible with LFLAG and if it
is, LFLAG becomes the new lock.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZCPREV, Start-up Case Level Block and Get Previous CIR
ARGS: LFLAG
DESC: ZCPREV is called after case-block initialisation and
all key creation, and after all key definition
routines. It starts-up the case block and gets the
previous CIR that meets all of the selection options
previously specified. No other case-level function
can be called until this block is successfully
executed. After ZCPREV is executed, no further key
definitions may be made. The system checks that the
current lock flag is compatible with LFLAG and if it
is, LFLAG becomes the new lock.
ENTRY: LFIAG (I * 4) The lock flag.
EXIT: None.
| |
ZCRDMY, Terminate Case-processing Level and Reset to
Dummy
ARGS: DUMMY
DESC: ZCRDMY terminates the processing of the current CIR,
rewrites it to the database if necessary, and then
resets the block to dummy.
ENTRY: DUMMY (I * 4 ) Dummy argument needed to make a
syntactically correct FORTRAN
function. Should always be 0.
EXIT: None.
| |
ZCREST, Restore CIR from Database and Reset Lock Type
ARGS: LFLAG
DESC: ZCREST is called to replace the values of the common
variables in the retrieval stack with the values of
the common variables in the database. Potentially,
it can change the lock type of the CIR.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZCSAM, Initialise SAMPLE Case-processing Block
ARGS: SAMPLE,SEED
DESC: ZCSAM is the first of a series of routines that can
be called in order to create "PROCESS CASE" block
with the SAMPLE option.
ENTRY: SAMPLE(R * 4) Sample size (SAMPLE).
SEED (I * 4) Starting seed for random-number
generator. Same seed always produces the
same random selection sequence. Any odd
value can be used for the seed. See
routine ZCEXIT for obtaining the value
of the seed after the loop is finished.
EXIT: None.
RETURN: Stack location of the new block, negative if error.
| |
ZCSAMD, Set Current Database and Initialise a SAMPLE
Case-processing Block
ARGS: SAMPLE,SEED,DBNAME
DESC: ZCSAMD is called to make DBNAME the current database
and to start creating a "PROCESS CASE" block with
the SAMPLE option. The purpose of this call is to
initialise the retrieval stack with the required
information.
ENTRY: SAMPLE(R * 4) Sample size (SAMPLE).
SEED (I * 4) Starting seed for random-number
generator. Same seed always produces
the same random selection sequence.
Any odd value can be used for the
seed. See routine ZCEXIT for obtaining
the value of the seed after the loop
is finished.
DBNAME(N * 8) The database name to be processed by
this case block (all blanks means use
current database).
EXIT: None.
RETURN: Stack location of the new block, negative if error.
| |
ZCWRIT, Replace Modified CIR on Database and Lock of
Block
ARGS: LFLAG
DESC: ZCNWIT is called to replace the database version of
the CIR with the current version in the retrieval
stack. This process is performed automatically by
the HOST routines when the next CIR is retrieved or
the case level is terminated. However the user may
want to write the modified CIR to the database and
change the lock for further processing.
ENTRY: LFLAG (I * 4) Lock flag.
EXIT: None.
| |
ZDESC, Create Variable Descriptor
ARGS: VDESC,RECTYP,VRNAME,LEVEL
DESC: ZDESC builds-up a variable's descriptor. (Refer to
the Machine Specifics documentation for
additional information on descriptors.) ZDESC can be
called once prior to entering a loop which
references a variable. This avoids the necessity of
creating the variable descriptor for each loop
iteration. Unlike ZDESCD, the database name is not
required.
ENTRY: RECTYP(I * 4) The record type number to which the
variable belongs. Common variables are
indicated by setting this argument to
zero.
VRNAME(N*8) The variable name.
LEVEL (I * 4) Level in the retrieval stack where the
CIR/data record can be found. A zero
value indicates that when the descriptor
is used, the system should start with
the innermost level in the retrieval
stack and search outwards for the first
level which matches the database and
record type specified within the
descriptor. A negative value indicates
that the record is LEVEL levels out from
the innermost level. A positive value
indicates that the record is LEVEL
levels deep in the retrieval stack.
EXIT: VDESC (D*8) Contains the descriptor for the variable
specified by the other arguments.
| |
ZDESCB, Break Descriptor Into Four Integers
ARGS: VDESC,DBNUM,RECTYP,VARNUM,LEVEL
DESC: ZDESCB breaks a descriptor into 4 integers.
ENTRY: VDESC (I * 4) Contains the descriptor.
EXIT: DBNUM (I * 4) The database number in HOST system.
RECTYP(I * 4) The record-type number.
VRNUM (I * 4) The variable number in record.
LEVEL (I * 4) The stack level.
| |
ZDESCD, Create Variable Descriptor
ARGS: VDESC,DBNAME,RECTYP,VRNAME,LEVEL
DESC: ZDESCD looks up a common or record variable name and
returns the variable's descriptor. Refer to the
Machine Specifics documentation for additional
information on descriptors. ZDESCD can be called
once prior to entering a loop which references a
variable. This avoids the necessity of creating the
variable descriptor for each loop iteration.
ENTRY: DBNAME(N*8) The database in which the variable
resides.
RECTYP(I * 4) The record type number to which the vari-
able belongs. Common variables are indi-
cated by setting this argument to zero.
VRNAME(N*8) The variable name.
LEVEL (I * 4) This indicates where the CIR/data record
can be found. A zero value indicates
that when the descriptor is used, the
system should start with the innermost
level in the retrieval stack and search
outwards for the first level which
matches the database and record type
specified within the descriptor. A
negative value indicates that the record
is LEVEL levels out from the innermost
level A positive value indicates that
the record is LEVEL levels deep in the
retrieval stack.
EXIT: VDESC (D 8) Contains the descriptor for the variable
specified by the other arguments.
| |
ZDESCM, Make Descriptor out of Four Integers
ARGS: VDESC,DBNUM,RECTYP,VARNUM,LEVEL
DESC: ZDESCM makes a descriptor from 4 integers.
ENTRY: DBNUM (I * 4) The database number in HOST system.
RECTYP(I * 4) The record type number. It cannot be 0
for a caseless database.
VRNUM (I * 4) The variable number in record.
LEVEL (I * 4) The stack level.
EXIT: VDESC (I * 4) Contains the descriptor for the variable
specified by the other arguments.
| |
ZDETAL, Find Location of File Control Block of DETAIL File
ARGS: DUMMY
DESC: ZDETAL returns the location in table ZERO of the
file control block for the detail file for the
current database.
ENTRY: DUMMY(I * 4) Dummy argument.
EXIT: None.
RETURN: Location of DETAIL file FCB.
| |
ZDTTKY, Enter a Date String into a Key
ARGS: DATEST,LENGTH,DATEMP
DESC: ZDTRKY is called after one of the key initialisation
routines in order to insert the value of a date
string into the next location of the key currently
being defined.
ENTRY: DATEST (B * n) Date string to insert into key.
LENGTH (I * 4) Number of characters in strings DATEST
and DATEMP.
DATEMP (B * n) String containing format for decoding
the date specified in DATEST. Legal
characters are I(ignore), Y(year),
M(month), or D(day). For
example 'MMIDDIYY'
EXIT: None.
| |
ZDTTRC, Move Date into CIR/Record
ARGS: DATEST,LENGTH,DATEMP,VDESC
DESC: ZDTTRC transfers the value of a date string into a
CIR or data record.
ENTRY: DATEST (B * n) Date string to transfer to record.
LENGTH (I * 4) Number of characters in strings DATEST
and DATEMP.
DATEMP (B * n) String containing format for decoding
the date specified in DATEST. Legal
characters are I(ignore), Y(year),
M(month), or D(day).
VDESC (D * 8) Variable descriptor of variable to receive
value.
EXIT: None.
| |
ZDTXIN, Convert Date String into Date Integer
ARGS: DATEST,ORDINAL,DATEMP,LENGTH
DESC: ZDTXIN converts a date encoded as a character string
into a julian integer value.
ENTRY: DATEST (B * n) Date string to convert.
ORDINAL (I * 4) First character in string DATEST to
use.
DATEMP(B * n) String containing format for
decoding the date specified in
DATEST. Legal characters are
I(ignore), Y(year), M(month), or
D(day). For example 'MMIDDIYY'
LENGTH(I * 4) Number of characters in strings
specified above.
EXIT: None.
| |
ZDTXKY, Enter Date String into Key
ARGS: DATEST,ORDINAL,LENGTH,DATEMP
DESC: ZDTXKY is called after one of the key initialisation
routines in order to insert the value of a date
string into the next location of the key currently
being defined.
ENTRY: DATEST (B * n) Date string to insert into key.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value from. For a
simple variable this value is 1.
LENGTH (I * 4) Number of characters in strings
specified above.
DATEMP (B * n) String containing format for
decoding the date specified in
DATEST. Legal characters are
I(ignore), Y(year), M(month), or D
(day). For example 'MMIDDIYY'
EXIT: None.
| |
ZDTXRC, Move Date into CIR/Record
ARGS: DATEST,ORDINAL,LENGTH,DATEMP,VDESC
DESC: ZDTXRC transfers the value of a date string into a
CIR or data record.
ENTRY: DATEST (B * n) Date string to transfer to record.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value from. For a
simple variable this value is 1.
LENGTH (I * 4) Number of characters in strings
specified above.
DATEMP (B * n) String containing format for
decoding the date specified in
DATEST. Legal characters are
I(ignore), Y(year), M(month), or
D(day).
VDESC (D * 8) Variable descriptor of variable to
receive value.
EXIT: None.
| |
ZEND, Terminate Processing of HOST
ARGS: TSUSED
DESC: ZEND terminates a HOST run. It must be called after
using ZENDDB to close all the databases still open
for the run. ZEND ensures that all information
related to the databases are properly handled. All
internal tables are cleared and any scratch files
used are closed and returned.
ENTRY: None.
EXIT: TSUSED (I * 4) The amount of table space actually used
in the current job is returned by HOST via
this argument. If the value is negative then
during the run some tables had to be
swapped to a scratch disk file in order to
continue processing. In this case addition-
al memory should be allocated to reduce
the swapping time the next time the
program is used.
| |
ZENDDB, Terminate the Use of Database
ARGS: DBNAME
DESC: ZENDDB terminates the use of a specified database.
The files are updated and closed. The space
associated with each database is not freed until
ZEND is called. ZENDDB must be called for each open
database prior to calling ZEND. Prior to calling
ZENDDB, all streams must have terminated their use
of the database, otherwise the call fails and
returns a fatal error. Failure to close a database
can cause destruction of the database.
ENTRY: DBNAME(N * 8) Name of the database. This is the same
name that appeared on the database
initialisation routine.
EXIT: None.
| |
ZERMSG, Error Description Routine
ARGS: ERRNUM,BUFFER,BUFLEN,LOGFLG,RNAME
DESC: ZERMSG converts an error code ERRNUM into coded text
that can be printed.
ENTRY: ERRNUM (I * 4) Error code to be converted.
BUFLEN (I * 4) Maximum number of characters to
transfer to error text buffer BUFFER.
LOGFLG (I * 4) Insert error message in log flag. If
the value of this argument is 0 then
no message is placed in the system
log file. If the value of this
argument is I then the message is
placed in the system log file and
also transferred to the BUFFER array.
RNAME (N * 8) Calling routine name to be included
in error message placed in system log
file.
EXIT: BUFFER (B * n) Will contain up to BUFLEN characters
describing the error code ERRNUM.
RETURN: Number of characters in the returned message,
negative if error.
| |
ZEXIT, Exit One Process Level Regardless of Type
ARGS: OSEED
DESC: ZEXIT exits the block at the lowest level in the
current stack, regardless its type(case or record).
ENTRY: None.
EXIT: OSEED(I * 4) If this was a process sample level,
then the current seed value is returned
here so that it can be used on the next
call for the next random-number
generation.
| |
ZFPTKY, Enter Real Value into Key
ARGS: DATA
DESC: ZFPTKY is called after one of the key initialisation
routines in order to insert a real value into the
next location of the key currently being defined.
ENTRY: DATA (R * 4) Real value to insert into key.
EXIT: None.
| |
ZFPTRC, Move Real into CIR/Record
ARGS: DATA,VDESC
DESC: ZFPTRC transfers a real value into a CIR or data
record.
ENTRY: DATA (R * 4) Real value to transfer to record.
VDESC (D * 8) Variable descriptor of variable to
receive value.
EXIT: None.
| |
ZFPXKY, Enter Real Value into Key
ARGS: DATA,ORDINAL,LENGTH
DESC: ZFPXKY is called after one of the key initialisation
routines in order to insert a real value into the
next location of the key currently being defined.
ENTRY: DATA (R * n) Real value to insert into key.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value from. For a
simple variable this value is 1.
LENGTH (I * 4) Number of bytes in value.
EXIT: None.
| |
ZFPXRC, Move Real into CIR/Record
ARGS: DATA,ORDINAL,LENGTH,VDESC
DESC: ZFPXRC transfers a real value into a CIR or data
record.
ENTRY: DATA (R * n) Real value to transfer to record.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value from. For a
simple variable this value is 1.
LENGTH(I * 4) Number of bytes in value.
VDESC (D * 8) Variable descriptor of variable to
receive value.
EXIT: None.
| |
ZFROM, Start Creation of FROM Key
ARGS: DUMMY
DESC: ZFROM starts the creation of a key. It creates a
"FROM" key. That is, a key which is used to select
all CIR/record's whose key matches or comes after
the key that is currently being defined. It is
normally called after one of the case/record level
initialisation routines in order to initialise the
key selection options for case or record loops.
Following a call to ZFROM, other routines are called
to enter values into the key one at a time. For a
case key only one call is made to enter the value of
the case id. For record keys, the case id is
assumed to be the same as the last CIR retrieved or
restored. Therefore, only the record sort ids have
to be inserted into the key. The sort-ids must be
entered in the order of their appearance in the key
being created.
ENTRY: DUMMY(I * 4) Dummy argument to make routine a
syntactically correct FORTRAN function.
Should always be 0.
EXIT: None.
| |
ZINTKY, Enter Integer Value Into Key
ARGS: DATA
DESC: ZINTKY is called after one of the key initialisation
routines in order to insert an integer value into
the next location of the key currently being
defined.
ENTRY: DATA(I * 4) Integer value to insert into key.
EXIT: None.
| |
ZINTRC, Move Integer into CIR/record
ARGS: DATA,VDESC
DESC: ZINTRC transfers an integer value into a CIR or data
record.
ENTRY: DATA (I * 4) Integer value to transfer to record.
VDESC (D * 8) Descriptor for variable to modify.
EXIT: None.
| |
ZINXDT, Convert Integer into Date String
ARGS: IDAYS,DATEST,ORDINAL,LENGTH,DATEMP
DESC: ZINXDT converts an integer value into a date string
according to a specified format.
ENTRY: IDAYS (I * 4) The integer value to convert.
ORDINAL (I * 4) Starting byte number in area DATEST
to transfer the date string to.
LENGTH (I * 4) Number of characters in strings
specified above.
DATEMP (B * n) String containing format for
decoding the date specified in
DATEST. Legal characters are
I(ignore), Y(year), M(month), or
D(day). For example 'MMIDDIYY'
EXIT: DATEST (B * n) The area in which to place the date
string created. Starting at
position ORDINAL as specified above.
| |
ZINXKY, Enter Integer Value Into Key
ARGS: DATA,ORDINAL,LENGTH
DESC: ZINXKY is called after one of the key initialisation
routines in order to insert an integer value into
the next location of the key currently being defined.
ENTRY: DATA (I * n) Integer value to insert into key.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value from. For a simple
variable this value is 1.
LENGTH(I * 4) Number of bytes in value.
EXIT: None.
| |
ZINXRC, Move Integer into CIR/Record
ARGS: DATA,ORDINAL,LENGTH,VDESC
DESC: ZINXRC transfers an integer value into a CIR or data
record.
ENTRY: DATA (I * n) Integer value to transfer to record.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value from. For a
simple variable this value is 1.
LENGTH (I * 4) Number of bytes in value.
VDESC (D * 8) Descriptor for variable to modify.
EXIT: None.
| |
ZINXTM, Convert Integer into Time String
ARGS: ITIME,TIMSTR,ORDINAL,LENGTH,TIMMAP
DESC: ZINXTM converts an integer value into a time string
according to a specified time format.
ENTRY: ITIME (I * 4) The integer to convert.
ORDINAL (I * 4) Starting byte number in area TIMSTR to
transfer the time string to.
LENGTH (I * 4) Number of characters in strings above.
TIMMAP (B * n) String containing the decoding
format for the time string
contained in TIMEST. Legal values
are I(ignore), H(hour), M(minute),
S(second). For example 'HHMMSS'
EXIT: TIMSTR (B * n) The area to receive the time
string. The location the string is
placed in this area is dependent on
ORDINAL.
| |
ZLABEL, Get Value Label for Current Value of a Variable
ARGS: VDESC,STRING,LENGTH
DESC: ZLABEL gets the value label for the current value of
a variable. It is equivalent to the VALLAB
function.
ENTRY: VDESC (D * 8) The variable descriptor.
LENGTH (I * 4) Number of characters of value label
to retrieve.
EXIT: STRING (B * n) String area in which the value label
will be placed.
RETURN: Number of characters actually transferred, negative
if error.
| |
ZLABLN, Get Value Label for Numeric Variable
ARGS: VDESC,VALUE,STRING,LENGTH
DESC: ZLABLN searches the database for the value label
associated with the specified variable and the
numeric value.
ENTRY: VDESC (D * 8) The variable descriptor.
VALUE (R * 8) The specific value whose label is to
be returned.
LENGTH(I * 4) Number of characters of value label to
retrieve.
EXIT: STRING (B * n) Area in which the value label will be
placed.
RETURN: Number of characters actually transferred, negative if error.
| |
ZLABLS, Get Value Label for String Variable
ARGS: VDESC,VALUE,LENGTHI,STRING,LENGTH2
DESC: ZLABILS searches the database for the value label
associated with the specified variable and the
string value.
ENTRY: VDESC (D * 8) The variable descriptor.
VALUE (B * n) The specific value whose label is to
be returned.
LENGTH1(I * 4) Number of characters in the value.
LENGTH2(I * 4) Number of characters of value label
to retrieve.
EXIT: STRING (B * n) Area in which the value label is to
be placed.
RETURN: Number of characters actually transferred, negative if error.
| |
ZLCKRT, Set or Return the Record Type Lock
ARGS: DBNAME,RECTYP,LFLAG
DESC: ZLCKRT sets or returns the lock for a specified
record type. It works only for concurrent HOST.
The routine can be invoked from a regular HOST
program but it does not have any effect, nor does it
return any significant value.
ENTRY: DBNAME(D * 8) The database name to which the record
type belongs.
RECTYP(B * n) If ZLCKRT is invoked to set a record
type lock, RECTYP is the record type
number (0 means CIR). If it is
invoked to return a record type lock,
RECTYP should be set to a negative
value that is the -1 minus the record
type ( i.e. -1 for CIR, - 2 for
rectype 1, etc.)
LFLAG (I * 4) Value to set the lock record type to (
if RECTYP is not negative).
EXIT: LFLAG (B * n) Current value of the lock flag for the
rectype specified by a negative value
of RECTYP.
| |
ZLOGIN, Initialisation of Master Link
ARGS: MDSN,MLEN,SDSN,SLEN
DESC: ZLOGIN specifies the MASTER and SLAVE names (DSNS)
and logs the slave (current process) into the
MASTER. It must be the next routine called after
ZSTART. If it is not called, the default master and
slave names are used. For non-concurrent HOST,
ZLOGIN is not operational.
ENTRY: MDSN (B * n) The MASTER DSN.
MLEN (I * 4) The length of the MDSN.
SDSN (B * n) The SLAVE DSN.
SLEN (I * 4) The length of the SDSN.
EXIT: None.
| |
ZMSLAB, Return Value Label for Missing Value
ARGS: VDESC,VALUE,STRING,LENGTH
DESC: ZMSLAB retrieves the value label for a specified
missing value of a certain variable.
ENTRY: VDESC (D * 8) The descriptor for the variable.
VALUE (I * 4) The missing value whose label is
being returned. (0, 1, 2, 3)
LENGTH(I * 4) Maximum number of characters to
return.
EXIT: STRING (B * n) String area that will have the label
placed in it.
RETURN: The number of characters actually transferred
negative if error.
| |
ZMSTRC, Transfer Missing Value to Variable
ARGS: NUMBER,VDESC
DESC: ZMSTRC sets the value of a specified variable to
either undefined or one of the 3 missing values.
ENTRY: NUMBER(I * 4) The value 0 if the variable is to be
set to undefined or the value 1-3 for
missing value 1-3.
VDESC (D * 8) The descriptor of the destination
variable.
EXIT: None.
| |
ZNCASE, Get Number of Cases in Database
ARGS: DBNAME
DESC: ZNCASE returns the number of cases currently in the
database.
ENTRY: DBNAME (N * 8) The database name.
EXIT: None.
RETURN: The number of cases in the database, negative if error.
| |
ZNEW, Check if New CIR record was Created
ARGS: DUMMY
DESC: ZNEW returns an indication of whether the
CIR/record in the lowest level of the retrieval
stack was just created or if it existed prior to
this reference.
ENTRY: DUMMY (I * 4 ) Dummy argument needed to make a
syntactically correct FORTRAN
function. Should always be 0.
EXIT: None.
RETURN: 0 if CIR/record previously existed, 1 if CIR/record
was just created, negative if error.
| |
ZNOR, Get The Number of Records in Current Case
ARGS: RECTYP
DESC: ZNOR returns the number of records of the specified
type within the current case. This function
corresponds to the COUNT function in DBMS. ZNOR
differs from ZNORD only in that the CIR
corresponding to the innermost block in retrieval
stack is used, regardless of database being used.
ZNOR cannot be used on a caseless database.
ENTRY: RECTYP(I * 4) The record type. If it is zero, then
it returns the total number of records
in the case.
EXIT: None.
RETURN: The number of records of the specified type in the
current case, negative if error.
| |
ZNORD, Get Number of Records in Current Case for Specified Database
ARGS: DBNAME,RECTYP
DESC: ZNORD returns the number of records of the specified
type in the current case for the specified database.
This function corresponds to the COUNT function in
DBMS.
ENTRY: DBNAME (N * 8) The database name. ZNORD searches
backwards from the current level for
a block "belonging" to the specified
database and uses its CIR to return
the value from. ZNORD cannot be used
on a caseless database.
RECTYP (I * 4) The record type. If it is zero, then
it returns the total number of
records in the case.
EXIT: None.
RETURN: The number of records of the specified type in the
current case, negative if error.
| |
ZNRECS, Get Number of Records of Type
ARGS: DBNAME,RECTYP
DESC: ZNRECS returns the number of records of a specified
type currently in the database.
ENTRY: DBNAME (N * 8) The database name.
RECTYP (I * 4) The record type number, 0 for CIR.
EXIT: None.
RETURN: The number or records of the specified type,
negative if error.
| |
ZNSIDS, Get Number of Sort-ids in Record Type
ARGS: DBNAME,RECTYP
DESC: ZNSIDS returns the number of sort-ids in the key for
the specified record type.
ENTRY: DBNAME (N * 8) The database name.
RECTYP (I * 4) The record type number.
EXIT: None.
RETURN: The number of sort-ids in the specified record type,
negative if errors.
| |
ZNVARS, Get the Number of Variables in Record
ARGS: DBNAME,RECTYP
DESC: ZNVARS returns the number of variables in a
specified record type or the CIR. It can be used to
determine if a database is caseless or not.
ENTRY: DBNAME (N * 8) The database name.
RECTYP (I * 4) The record type number. Use zero for
the CIR. If RECTYP is 0 and the
database is caseless, the function
returns 0.
EXIT: None.
RETURN: The number of variables in the specified record
type, zero for the number of variables in the CIR of
a caseless database, negative if error.
| |
ZOPEN, Determine if Database is Available
ARGS: DBNAME
DESC: ZOPEN is called to determine if a specified database
is currently open for use or not.
ENTRY: DBNAME ( N * 8 ) The database name to check.
EXIT: None.
RETURN: Internal database number ( small positive integer ),
negative if error.
| |
ZOPT, Set or Return Various System Options
ARGS: OPT
DESC: ZOPT allows the user to select, deselect or return
various options.
ENTRY: OPT (I * 4) The sum of the options to select if
positive; -1 to return the current
settings.
OPT Description
0*1 or 1*1 allow or disallow the storage of valid
values
0*2 or 1*2 allow or disallow the storage of undefined
values
0*4 or 1*4 allow or disallow the storage of missing
values
0*8 or 1*8 allow or disallow backward search In the
stack when a "from" descriptor level Is 0
0*16 or 1*16 allow or disallow backward search in the
stack when a "to" descriptor level is 0
EXIT: None.
RETURN: 0 if OPT is between 0 and 31, the sum of selected
options if OPT is -1, negative if error.
| |
ZORDB, Initialise Specified Random Database
ARGS: DBNAME,DBPASS,HSPASS,RDPASS,WRPASS, UPD,PREFIX,PRELEN
DESC: ZORDB is called to attach the database. It also
verifies the passwords to ensure database security
and accessibility. It must be called prior to any
reference to the new database. Each open database
requires a significant amount of memory to be
allocated in the table area regardless of whether it
is currently being used or not. ZORDB may only be
called for a database that is in random format.
ENTRY: DBNAME(N * 8) Name of the database. This is the same
name that would appear on an "OLD FILE"
command.
DBPASS(N * 8) The password for the database.
HSPASS(N * 8) The password required to access the
database via HOST. If no password is
required then this field should
contain a blank name.
RDPASS(N * 8) The read security password for the
database. This password is used to
define the default read security level
for any stream which does not
specifically set the read security
level for this database. If the
argument contains 8 blanks then the
standard DBMS default is used for
any stream not specifying a read
security password.
WDPASS(N * 8) The write security password for the
database. This password is used to
define the default write security
level for any stream which does not
specifically set the write security
level for this database. If the
argument contains 8 blanks then the
standard DBMS default is used for
any stream not specifying a write
security password.
UPD (I * 4) Update/nonupdate flag. If UPD is 0
then the database is attached for read
only access. If however the value of
this argument is 1 or 2 then the
database is attached for exclusive
usage in order to allow the job to
modify the database. If the value is 2
then every change to the database
causes the changed internal tables to
be rewritten to the database file. If
the value is 1 then only when HOST
determines it is necessary will the
tables be rewritten to the database
file.
PREFIX(B * n) Prefix used for database filenames.
PRELEN(I * 4) Number of characters in "PREFIX".
EXIT: None.
RETURN: The database number used in creating descriptors if
no errors are encountered ( 1 for 1st opened
database, 2 for 2nd, etc. Negative if error.
| |
ZOSDB, Initialise Specified Sequential Database
ARGS: DBNAME,DBPASS,HSPASS,RDPASS,WRPASS,UPD,
PREFIX,PRELEN,SIFNAM,SOFNAM
DESC: ZOSDB is called initially to attach a sequential
format database. It also verifies the passwords to
ensure database security and accessibility. Each
open database requires a significant amount of
memory to be allocated in the table area regardless
of whether it is currently being used or not. ZOSDB
may only be called for a database which is in
sequential format.
ENTRY: DBNAME(N * 8) Name of the database. This is the same
name that would appear on an "OLD FILE"
command.
DBPASS(N * 8) The password for the database.
HSPASS(N * 8) The password required to access the
database via HOST. If no password is
required then this field should contain
a blank name.
RDPASS(N * 8) The read security password for the
database. This password is used to
define the default read security level
for any stream which does not
specifically set the read security
level for this database. If the
argument contains 8 blanks then the
standard DBMS default is used for any
stream not specifying a read security
password.
WRPASS (N * 8) The write security password for the
database. This password is used to
define the default write security level
for any stream which does not
specifically set the write security
level for this database. If the
argument contains 8 blanks then the
standard DBMS default is used for any
stream not specifying a write security
password.
UPD (I * 4) Update/nonupdate flag. If UPD is 0 then
the database is attached for read only
access. If however the value of this
argument is 1 or 2 then the database is
attached for exclusive usage in order
to allow the job to modify the
database. If the value is 2 then every
change to the database causes the
changed internal tables to be rewritten
to the database file. If the value is I
then only when HOST determines it is
necessary will the tables be rewritten
to the database file.
PREFIX(B * n) Prefix used for database filenames.
PRELEN(I * 4) Number of characters in "PREFIX".
SIFNAM (N * 8) The "FILENAME" of the file containing
the sequential format input database.
SOFNAM (N * 8) The "FILENAME" of the file which will
contain the sequential format output
database. If this is not an update run
then this argument should contain all
blanks.
EXIT: None.
RETURN: The database number used in creating descriptors if
no errors are encountered ( 1 for 1st opened
database, 2 for 2nd, etc ). negative if error.
| |
ZRCNT, Initialise COUNT Record Processing Block
ARGS: RECTYP,TRECS,INDEX,START
DESC: ZRCNT is the first of a series of routines that can
be called in order to create "PROCESS RECORD" block
with the COUNT option. ZRCNT can be used to process
ALL records by setting INDEX and START to 1 and
TRECS to -1. The arguments correspond to the
arguments on the COUNT = clause of the PROCESS CASE
command in RETRIEVAL.
ENTRY: RECTYP(I * 4) The record type number to be
processed.
TRECS (I * 4) Total number of records to be
processed.
INDEX (I * 4) Every INDEX the record will be
processed.
START (I * 4) Starting with the START the record in
the database.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRCNTD, Set Current Database and Initialise COUNT
Record-processing Block
ARGS: RECTYP,TRECS,INDEX,START,DBNAME
DESC: ZRCNTD is called to make DBNAME the current database
and to start creating a "PROCESS RECORD" block with
the COUNT option. The purpose of this call is to
initialise the retrieval stack with the required
information. The arguments correspond to the
arguments on the COUNT = clause of the PROCESS CASE
command in RETRIEVAL.
ENTRY: RECTYP(I * 4) The record type number to be
processed.
TRECS (I * 4) Total number of records to be
processed.
INDEX (I * 4) Every INDEX the record will be
processed.
START (I * 4) Starting with the START the record in
the database.
DBNAME(N * 8) Database name.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRCNTL, Initialise COUNT Record Processing Block
Belonging to CIR
ARGS: RECTYP,TRECS,INDEX,START,LEVEL
DESC: ZRCNTL is called to start creating a "PROCESS
RECORD" block (with the COUNT option) that belongs
to the CIR at the specified level. The purpose of
this call is to initialise the retrieval stack with
the required information. Potentially, it can
switch databases. ZRCNTL can be used to process ALL
records by setting INDEX and START to 1 and TRECS to
-1. The arguments correspond to the arguments on
the COUNT clause of the PROCESS CASE command in
RETRIEVAL.
ENTRY: RECTYP(I * 4) The record type number to be
processed.
TRECS (I * 4) Total number of records to be
processed.
INDEX( I * 4) Every INDEX the record will be
processed.
START (I * 4) Starting with the START the record in
the database.
LEVEL (I * 4) Stack level of the CIR block to which
the record should belong.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRCTDT, Transfer Date from CIR/Record
ARGS: VDESC,DATEST,LENGTH,DATEMAP
DESC: ZRCTDT retrieves a date value from the specified
CIR/data record and converts it to a date string
according to the user specified date map.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
DATEST(B * n) Location to place date string.
LENGTH(I * 4) Number of characters in strings DATEST
and DATEMP.
DATEMP(B * n) String containing the decoding format
for the date string contained in
DATEST. Legal values are W(day of
week) M(month), D(day), Y(year). For
example, 'MM/DD/YY' would produce
'12/31/86'.
EXIT: DATEST(B * n) Will contain date string retrieved
from current CIR/data record.
| |
ZRCTFP, Transfer Floating-point Value from Record
ARGS: VDESC,DATA
DESC: ZRCTFP retrieves a real value from the specified
CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
EXIT: DATA (R * 4) Will contain real value retrieved from
current CIR/data record.
| |
ZRCTIN, Transfer Integer Value from Record
ARGS: VDESC,DATA
DESC: ZRCTIN retrieves an integer value from the specified
CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
EXIT: DATA (I * 4) Will contain integer value retrieved
from current CIR/data record.
| |
ZRCTRC, Transfer Value from One Variable to Another
ARGS: VDESCI,VDESC2
DESC: ZRCTRC transfers data from one variable in one
record to a variable in either another record or the
same record.
ENTRY: VDESC1(D * 8) The descriptor of the source
variable.
VDESC2 (D * 8) The descriptor of the destination
variable.
EXIT: None.
| |
ZRCTST, Transfer String from CIR/Record
ARGS: VDESC,DATA,LENGTH
DESC: ZRCTST retrieves a character string value from the
specified CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
LENGTH(I * 4) Number of characters at location DATA.
EXIT: DATA (B * n) Will contain character string
retrieved from current CIR/data
record.
| |
ZRCTTM, Transfer Time from CIR/Record
ARGS: VDESC,TIMEST,LENGTH,TIMEMP
DESC: ZRCTTM retrieves a time string from the specified
CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
TIMEST (B * n) Location to place time string.
LENGTH (I * 4) Number of characters in strings
TIMEST and TIMEMP.
TIMEMP (B * n) String containing the decoding
format for the time string contained
in TIMEST. Legal values are H(hour),
M(minute), S(second). For example,
'HH:MM:SS' would produce '11:59:59'.
EXIT: TIMEST (B * n) Will contain time string retrieved
from current CIR/data record.
| |
ZRCXDT, Transfer Date from CIR/Record
ARGS: VDESC,DATEST,ORDINAL,LENGTH,DATEMP
DESC: ZRCXDT retrieves a date string from the specified
CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve. See routines ZDESC and
ZDESCD for creating a descriptor.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value to. For a simple
variable this value is 1.
LENGTH(I * 4) Number of characters in strings
specified above.
DATEMP(B * n) String containing format for decoding
the date specified in DATEST. Legal
characters are Y(year), M(month), or
D(day). All other characters are
transferred "as is" to DATEST. For
example, 'MM/DD/YY' would produce
'12/25/81'.
EXIT: DATEST(B * n) Will contain date string retrieved
from current CIR/data record.
| |
ZRCXFP, Transfer Real from CIR/Record
ARGS: VDESC,DATA,ORDINAL,LENGTH
DESC: ZRCXFP retrieves a real value from the specified
CIR/data record.
ENTRY: VIDESC (D * 8) Variable descriptor of variable to
retrieve.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value to. For a simple
variable this value is 1.
LENGTH (I * 4) Number of bytes at location DATA.
EXIT: DATA (R * n) Will contain real value retrieved
from current CIR/data record.
| |
ZRCXIN, Transfer Integer from CIR/Record
ARGS: VDESC,DATA,ORDINAL,LENGTH
DESC: ZRCXIN retrieves an integer value from the specified
CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
ORDINAL (I * 4) Starting byte number in area DATA to
transfer the value to. For a simple
variable this value is 1.
LENGTH(I * 4) Number of bytes at location DATA.
EXIT: DATA (I * n) Will contain integer value retrieved
from current CIR/data record.
| |
ZRCXST, Transfer a String from a CIR/Record
ARGS: VDESC,DATA,ORDINAL,LENGTH
DESC: ZRCXST retrieves a character string value from the
specified CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value to. For a simple
variable this value is 1.
LENGTH (I * 4) Number of bytes at location DATA.
EXIT: DATA (B * n) Will contain character string
retrieved from current CIR/data
record.
| |
ZRCXTM, Transfer Time from CIR/Record
ARGS: VDESC,TIMEST,ORDINAL,LENGTH,TIMEMP
DESC: ZRCXTM retrieves a time string from the specified
CIR/data record.
ENTRY: VDESC (D * 8) Variable descriptor of variable to
retrieve.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value to. For a simple
variable this value is 1.
LENGTH (I * 4) Number of characters in strings
above.
TIMEMP (B * n) String containing the decoding format
for the time string contained in
TIMEST. Legal values are H(hour),
M(minute), S(second). For example,
'HH:MM:SS' would produce '11:59:59'.
EXIT: TIMEST(B * n) Will contain time string retrieved
from current CIR/data record.
| |
ZRDEL, Delete Current Record from Database
ARGS: DUMMY
DESC: ZRDEL is called after a record is retrieved to
delete the current record.
ENTRY: DUMMY (I * 4) Dummy argument needed to make a
syntactically correct FORTRAN
function. Should always be 0.
EXIT: None.
| |
ZREXIT, Terminate Record Processing Level
ARGS: OLDSEED
DESC: ZREXIT is called to terminate a record level and pop
back one level in the retrieval stack. It only
terminates the innermost record level.
ENTRY: None.
EXIT: OLDSEED(I * 4) It is set to the current value of the
seed, if the current level is a
PROCESS RECORD level with the SAMPLE
option. Otherwise it value is
undefined.
| |
ZRFIND, Find Record with Given Key
ARGS: OPT, LFLAG, DIRECT, BEGINR, BEGINK
DESC: ZRFIND finds an existent record or creates a new
record with a previously specified key. It is
called after ZRGDMY, ZRGDML or ZRRDMY has created a
dummy block and after putting values into the record
id variable in the record and ( if OPT is 1 ) in
other record variables. When ZRFIND is executed,
the values of the record ids are used to create the
record key. If the record ids variable are
undefined, then the dummy block is converted into a
PROCESS RFC ALL block and the next or previous
record is read. Otherwise, the dummy block ZRGDMY
is converted into a REC IS block and: a) if OPT is
1, then the undefined values are updated to the
values read from the found record or b) if OPT is 2
the full current record is replaced by the read
record.
ENTRY: OPT (I * 4) Controls the update/replace of the
CIR.
LFLAG (I * 4) Lock flag.
DIRECT (I * 4) If PROCESS REC then use 1 to get the
next record and -1 to get the
previous record.
BEGINR(I * 4) Number of record ids to include in
range.
BEGINK (I * 4) Number of record ids to include in
starting key.
EXIT: None.
RETURN: -4001 if record not found;
-3026 if record is found but is incompatible locked;
+ 0003 if record is found and has a compatible lock;
+ 0004 if record is found and available for REC IS;
+ 0000 if record is found and available for PROCESS
REC; negative if error.
| |
ZRFRST, Start-up a Record Level Block and Get First
Record
ARGS: LFIAG
DESC: ZRFRST is called after record-block initialisation
and all key creations, and after all key-definition
routines. It starts-up the record block and gets
the first record that meets all of the selection
options previously specified. No other record-level
function can be called until this block is
successfully executed. After ZRFRST is executed, no
further key definitions may be made. The system
checks that the current lock flag is compatible with
LFLAG and if it is, LFILAG becomes the new lock.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZRGDMD, Set Current Database and initialise Dummy Block
ARGS: RECTYP, DBNAME
DESC: ZRGDMD is called to make DBNAME the current database
and to start creating a dummy block. The purpose of
this call is to initialise the retrieval stack with
the required information.
ENTRY: RECTYP (I * 4) The record type to be processed.
DBNAME (N * 8) The name of the database from which
the record should be selected.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRGDML, Start Dummy Record Block Belonging to CIR
ARGS: RECTYP,LEVEL
DESC: ZRGDML is called to start creating a dummy block
that belongs to the CIR at the specified level. The
purpose of this call is to initialise the retrieval
stack with the required information. Potentially,
it can switch databases.
ENTRY: RECTYP(I * 4) Record type.
LEVEL (I * 4) Level in stack of the CIR block to
which the record belongs.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRGDMY, Start Dummy Record Block
ARGS: RECTYP
DESC: ZRGDMY is called to start creating a dummy block
that belongs to the CIR at the specified level. The
purpose of this call is to initialise the retrieval
stack with the required information
ENTRY: RECTYP(I * 4) Record type for record block.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRIS, Initialise RECORD IS Block
ARGS: RECTYP,NEW,OLD
DESC: ZRIS is the first of a series of routines that can
be called in order to create "RECORD IS" block. The
purpose of this call is to initialise the retrieval
stack with the required information.
ENTRY: RECTYP(I * 4) The record type to be processed.
NEW (I * 4) NEW is I if a new record can be created
by this level, otherwise it is 0. The
database must have been opened for
UPDATE to allow a value of 1.
OLD (I * 4) OLD is I if an old record can be
accessed by this level, otherwise it is
0.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRISD, Set Current Database and Initialise RECORD IS
Block
ARGS: RECTYP,NEW,OLD,DBNAME
DESC: ZRISD is called to make DBNAMF, the current database
and to start creating a "RECORD IS" block. The
purpose of this call is to initialise the retrieval
stack with the required information.
ENTRY: RECTYP(I * 4) The record type to be processed.
NEW (I * 4) NEW is 0 if a record cannot be created
by this level. The database must have
been opened for UPDATE to allow a value
of 1.
OLD (I * 4) OLD is 0 if an old record cannot be
accessed by this level, otherwise it is
1.
DBNAME(N * 8) The name of the database from which the
record should be selected.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRISL, Initialise RECORD IS Processing Block Belonging to
CIR
ARGS: RECTYP,NEW,OLD,LEVEL
DESC: ZRISL is called to start creating a "RECORD IS"
block that belongs to the CIR at the specified
level. The purpose of this call is to initialise
the retrieval stack with the required information.
Potentially, it can switch databases.
ENTRY: RECTYP(I * 4) The record type to be processed.
NEW (I * 4) NEW is 0 if a new record is not legal
(NEW record IS). 1 if editing record is
legal (OLD record IS or record IS).
OLD (I * 4) OLD is 0 if an old record is not legal
(OLD record IS). 1 if a new record is
legal (NEW record IS or record IS).
LEVEL (I * 4) Level in stack of the CIR block to
which the record belongs.
EXIT: None.
RETURN: Stack level of the newly created block, negative if error.
| |
ZRLAST, Start-up Record Level Block and Get Last Record
ARGS: LFLAG
DESC: ZRLAST is called after record-block initialisation
and all key creation, and after all key definition
routines. It starts-up the record block and gets
the last record that meets all of the selection
options previously specified. No other record-level
function can be called until this block is
successfully executed. After ZRLAST is executed, no
further key definitions may be made. The system
checks that the current lock flag is compatible with
LFLAG and if it is, LFLAG becomes the new lock.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZRLOCK, Get Lock Type of Innermost Level of Execution
Stack
ARGS: LFLAG
DESC: ZRLOCK returns the lock type at the current
innermost level of the execution stack.
ENTRY: None.
EXIT: LFLAG (I * 4) Lock type.
RETURN: 0 if the level is not write-locked.
1 if the level is write-locked.
| |
ZRNAMD, Get the Record Name for Record Type
ARGS: DBNAME,RECTYP,RECNAM
DESC: ZRNAMD lookups a record type and returns the record
name associated with it.
ENTRY: DBNAME ( N * 8 ) The name of the database to which the
record belongs.
RECTYP (I * 4) The record type.
EXIT: RNAME (N * 8) The record name corresponding to
database and record type specified.
| |
ZRNEXT, Start-up Record Level Block and Get Next Record
ARGS: LFLAG
DESC: ZRNEXT is called after record-block initialisation
and all key creation, and after all key definition
routines. It starts-up the record block and gets
the next record that meets all of the selection
options previously specified. No other record-level
function can be called until this block is
successfully executed. After ZRNEXT is executed, no
further key definitions may be made. The system
checks that the current lock flag is compatible with
LFLAG and if it is, LFLAG becomes the new lock.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZRNUM, Get Record Number for Record Name of Current
Database
ARGS: RNAME
DESC: ZRNUM lookups the record name specified in the
current database and returns the corresponding
record type number.
ENTRY: RNAME (N * 8) The record name to lookup.
EXIT: None.
RETURN: Record type number, negative if error.
| |
ZRNUMD, Get Type Number for Record Name of Specified
Database
ARGS: DBNAME,RNAME
DESC: ZRNUMD lookups a record name and returns the record
type value associated with it for the specified
database.
ENTRY: DBNAME(N * 8) The database in which the record
resides.
RNAME(N * 8) The record name to lookup.
EXIT: None.
RETURN: The record type number associated with the specified
record name, negative if error.
| |
ZRPREV, Start-up Record Level Block and Get Previous
Record
ARGS: LFLAG
DESC: ZRPREV is called after record-block initialisation
and all key creation, and after all key definition
routines. It starts-up the record block and gets
the previous record that meets all of the selection
options previously specified. No other record-level
function can be called until this block is
successfully executed. After ZRPREV is executed, no
further key definitions may be made. The system
checks that the current lock flag is compatible with
LFLAG and if it is, LFLAG becomes the new lock.
ENTRY: LFLAG (I * 4) The lock flag.
EXIT: None.
| |
ZRRDMY, Terminate Innermost Level and Reset Block to
Dummy
ARGS: DUMMY
DESC: ZRRDMY terminates all processing at this level,
writes the record if necessary, and resets the block
back to dummy status.
ENTRY: DUMMY(I * 4) Dummy argument needed to make a
syntactically correct FORTRAN function.
Should always be 0.
EXIT: None.
| |
ZRREST, Restore Record from Database
ARGS: LFLAG
DESC: ZRREST is called to replace a record in the
retrieval stack with the corresponding record from
the database.
ENTRY: LFLAG(I * 4) The lock flag.
EXIT: None.
| |
ZRSAM, Initialise Record Processing Loop
ARGS: RECTYP,SAMPLE,SEED
DESC: ZRSAM is the first of a series of routines that can
be called in order to create "PROCESS RECORD" block
with the SAMPLE option.
ENTRY: RECTYP (I * 4) The record type value to be processed.
SAMPLE (R * 4) Sample size (SAMPLE).
SEED (I * 4) Starting seed for random-number
generator. Same seed always produces
the same random selection sequence.
Any odd value can be used for the
seed. See routine ZREXIT for
obtaining the value of the seed after
the loop is finished.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRSAMD, Set Current Database and Initialise SAMPLE
Record-processing block
ARGS: RECTYP,SAMPLE,SEED,DBNAME
DESC: ZRSAMD is called to make DBNAME the current database
and to start creating a "PROCESS CASE" block with
the SAMPLE option. The purpose of this call is to
initialise the retrieval stack with the required
information.
ENTRY: RECTYP(I * 4) Record type.
SAMPLE (R * 4) Sample size ( 0 SAMPLE 1 )
SEED (I * 4) Starting seed.
DBNAME(N * 8) The name of the database form which
the record is selected.
EXIT: None.
RETURN: Stack level of the newly created block, negative if
error.
| |
ZRSAML, Start SAMPLE PROCESS RECORD Block
Belonging to CIR
ARGS: RECTYP,SAMPLE,SEED,LEVEL
DESC: ZRSAML is called to start creating a "PROCESS
RECORD" block (with the SAMPLE option) that belongs
to the CIR at the specified level. The purpose of
this call is to initialise the retrieval stack with
the required information. Potentially, it can
switch databases.
ENTRY: RECTYP(I * 4) The record type value to be processed.
SAMPLE(R * 4) Sample size ( 0 SAMPLE 1 ).
SEED (I * 4) Starting seed. The same seed always
generates the same sequence of random
numbers.
LEVEL (I * 4) Level in stack of the CIR block to
which the record belongs.
EXIT: None.
RETURN: Stack level of the newly created block, negative if error.
| |
ZRWRIT, Replace Modified Record on Database and Lock
of Block
ARGS: LFLAG
DESC: ZRNWIT is called to replace the database version of
the record with the current version in the retrieval
stack. This process is performed automatically by
the HOST routines when the next record is retrieved
or the record level is terminated. However the user
may want to write the modified record to the
database and change the lock for further processing.
ENTRY: LFLAG (I * 4) Lock flag.
EXIT: None.
| |
ZSDESC, Get Descriptor for Sort-id Variable
ARGS: DBNAME,RECTYP,SIDNUM,VDESC
DESC: ZSDESC returns the variable descriptor corresponding
to a specified sort-id of a given record type.
ENTRY: DBNAME(N*8) The database name.
RECTYP(I * 4) The record type number.
SIDNUM(I * 4) The sort-id number.
EXIT: VDESC (D * 8) The descriptor for the specified
sort-id.
| |
ZSECLV, Return the Current Security Values for a Database
ARGS: DBNAME,RDLEV WRLEV
DESC: ZSECLV returns the read and write access levels.
ENTRY: DBNAME N * 8) The database name.
EXIT: RDLEV (I * 4) The read level for the database.
WRLEV (I * 4) The write level for the database.
| |
ZSECUR, Specify Security Passwords
ARGS: DBNAME,RDPASS,WRPASS
DESC: ZSECUR specifies the passwords for the read and
write security levels for a specific database for
the current stream. It should be called for each
database used by each stream, which needs security
levels different from those specified when the
database was initially attached. Otherwise the
default levels specified on the attach call are
assigned. If the passwords specified by ZSECUR
select security levels less than the default values,
then the default values are used.
ENTRY: DBNAME(N * 8) The name of the database the following
security passwords apply to.
RDPASS(N * 8) Read security password for the current
stream.
WRPASS(N * 8) Write security password for the current
stream.
EXIT: None.
| |
ZSTART, Initialise HOST System
ARGS: MAXUSR,TABTYP,TAB1,TAB2
DESC: ZSTART initialises all tables needed by the other
HOST routines. It must be called prior to any other
HOST routine.
ENTRY: MAXUSR (I * 4) Maximum number of streams accessing
the HOST system within this job. A
small amount of space is allocated
for each stream specified regardless
of the number of streams currently
active.
TABTYP (I * 4) Type of table space to be allocated
for use by the HOST system. See
Machine Specifics documentation
for more information on use of this
and the next two associated
arguments.
= 1 The HOST system gets space from the
operating system and returns it when
ZEND is called.
TAB1 (I * 4) Amount of space (in "double-word"s)
to be requested. At the end of the
job the amount actually used is
returned so that a better estimate
can be applied next time.
TAB2 (R * 8) 0. Unused argument for this type but
must appear on call in order to obey
FORTRAN syntax rules.
= 2 The calling routine provides an area
to be used by HOST. This area must
be "doubleword" aligned and must be
available for use at all times (i.e.
if program is segmented then this
area must be in the root segment).
TAB1 (I * 4) Amount of contiguous space available
for use by the HOST system (in units
of "dwrds").
TAB2 (R * 8) Array to be used by the HOST system.
In this case the array TAB2 must
not be modified in any way until
after ZEND is called. If any item of
this array is modified by the user
then the database will probably have
erroneous information written to it
and HOST actions will become unpre-
dictable.
EXIT: None.
| |
ZSTTKY, Enter String Value into Key
ARGS: DATA,LENGTH
DESC: ZSTTKY is called after one of the key initialisation
routines in order to insert a character value into
the next location of the key currently being defined.
ENTRY: DATA (B * n) Character string to insert into key.
LENGTH(I * 4) Number of characters in string.
EXIT: None.
| |
ZSTTRC, Move String into CIR/Record
ARGS: DATA,LENGTH,VDESC
DESC: ZSTTRC transfers a character string into a CIR or
data record.
ENTRY: DATA (B * n) Character string to transfer to record.
LENGTH(I * 4) Number of characters in string.
VDESC (D * 8) Variable descriptor of variable to receive
value.
EXIT: None.
| |
ZSTXKY, Enter String Value into Key
ARGS: DATA,ORDINAL,LENGTH
DESC: ZSTXKY is called after one of the key initialisation
routines in order to insert a character value into
the next location of the key currently being defined.
ENTRY: DATA (B * n) Character string to insert into key.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value from. For a simple
variable this value is 1.
LENGTH(I * 4) Number of characters in string.
EXIT: None.
| |
ZSTXRC, Move String into CIR/Record
ARGS: DATA,ORDINAL,LENGTH,VDESC
DESC: ZSTXRC transfers a character string into a CIR or
data record.
ENTRY: DATA (B * n) Character string to transfer to record.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value from. For a simple
variable this value is 1.
LENGTH(I * 4) Number of bytes in value.
VDESC (D * 8) Variable descriptor of variable to
receive value.
EXIT: None.
| |
ZTHRU, Start Creation of THRU Key
ARGS: DUMMY
DESC: ZTHRU starts the creation of a key. It creates a
"THRU" key. That is, a key which is used to select
all CIR/record's whose key matches or comes before
the key that is currently being defined. It is
normally called after one of the case/record level
initialisation routines in order to initialise the
key selection options for case or record loops.
Following a call to ZTHRU other routines (described
below) are called to enter values into the key one
at a time. For a case key only one call is made to
enter the value of the case id. For record keys,
the case id is assumed to be the same as the last
CIR retrieved or restored. Therefore, only the
record sort ids have to be inserted into the key.
The sort-ids must be entered in the order of their
appearance in the key being created.
ENTRY: DUMMY(I * 4) Dummy argument to make routine a
syntactically correct FORTRAN function.
Should always be 0.
EXIT: None.
| |
ZTIME, Return Current Date and Time as Integers.
ARGS: IDAYS,ISECS
DESC: ZTIME returns the current date and time as standard
julian date and time values. It returns the same
values as the DBMS functions TODAY(0) and NOW(0).
ENTRY: None.
EXIT: IDAYS (I * 4) Number of days since Oct 15, 1582.
ISECS (I * 4) Number of seconds since midnight.
| |
ZTMTKY, Enter Time String into Key
ARGS: TIMEST,LENGTH,TIMEMP
DESC: ZTMTKY is called after one of the key initialisation
routines in order to insert the value of a time
string into the next location of the key currently
being defined.
ENTRY: TIMEST (B * n) Time string to insert into key.
LENGTH (I * 4) Number of characters in strings TIMEST
and TIMEMP.
TIMEMP (B * n) String containing the decoding format
for the time string contained in
TIMEST. Legal values are 1(ignore),
H(hour), M(minute), S(second). For
example: 'HHMMSS'.
EXIT: None.
| |
ZTMTRC, Move Time into CIR/Record
ARGS: TIMEST,LENGTH,TIMEMP,VDESC
DESC: ZTMTRC transfers the value of a time string into a
CIR or data record.
ENTRY: TIMEST (B * n) String containing the time value to transfer
to record.
LENGTH (I * 4) Number of characters in strings TIMEST
and TIMEMP.
TIMEMP (B * n) String containing the decoding format for
the time string contained in TIMEST.
Legal values are I(ignore), H(hour),
M(minute), S(second).
VDESC (D * 8) Variable descriptor of variables to receive
value.
EXIT: None.
| |
ZTMXIN, Convert Time String into Integer
ARGS: TIMEST,ORDINAL,TIMEMP,LENGTH
DESC: ZTMXIN converts a time string into a time integer
value.
ENTRY: TIMEST (B * n) Time string to convert.
ORDINAL(I * 4) First character in string TIMEST to use.
TIMEMP (B * n) String containing the decoding format for
the time string contained in TIMEST.
Legal values are I(ignore), H(hour), M(minute),
S(second). For example: 'HHMMSS'.
LENGTH (I * 4) Number of characters in strings above.
EXIT: None.
RETURN: The integer equivalent of the time string (seconds
since midnight), negative if error.
| |
ZTMXKY, Enter Time String into Key
ARGS: TIMFST,ORDINAL,LENGTH,TIMEMP
DESC: ZTMXKY is called after one of the key initialisation
routines in order to insert the value of a time
string into the next location of the key currently
being defined.
ENTRY: TIMEST (B * n) Time string to insert into key.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value from. For a simple vari-
able this value is 1.
LENGTH (I * 4) Number of characters in strings above.
TIMEMP (B * n) String containing the decoding format for
the time string contained in TIMEST.
Legal values are I(ignore), H(hour),
M(minute), S(second). For example:
'HHMMSS'.
EXIT: None.
| |
ZTMXRC, Move Time into CIR/Record
ARGS: TIMEST,ORDINAL,LENGTH,TIMEMP,VDESC
DESC: ZTMXRC transfers the value of a time string into a
CIR or data record.
ENTRY: TIMEST (B * n) String containing the time value to transfer
to record.
ORDINAL(I * 4) Starting byte number in area DATA to
transfer the value from. For a simple vari-
able this value is 1.
LENGTH (I * 4) Number of characters in strings above.
TIMEMP (B * n) String containing the decoding format for
the time string contained in TIMEST.
Legal values are 1(ignore), H(hour),
M(minute), S(second).
VDESC (D * 8) Variable descriptor of variables to receive
value.
EXIT: None.
| |
ZUNTIL, Start Creation of UNTIL Key
ARGS: DUMMY
DESC: ZUNTIL starts the creation of a key. It creates an
"UNTIL" key. That is, a key which is used to select
all CIR/record's whose key comes before the key that
is currently being defined. It is normally called
after one of the case/record level initialisation
routines in order to initialise the key selection
options for case or record loops. Following a call
to ZUNTIL other routines (described below) are
called to enter values into the key one at a time.
For a case key only one call is made to enter the
value of the case id. For record keys, the case id
is assumed to be the same as the last CIR retrieved
or restored. Therefore, only the record sort ids
have to be inserted into the key. The sort-ids must
be entered in the order of their appearance in the
key being created.
ENTRY: DUMMY(I * 4) Dummy argument to make routine a
syntactically correct FORTRAN function.
Should always be 0.
EXIT: None.
| |
ZUPLEV, Get Specified Database Update Level
ARGS: DBNAME
DESC: ZUPLEV returns the current update level of the
database prior to this update.
ENTRY: DBNAME(N*8) The name of the database.
EXIT: None.
| |
ZUSER, Set to Different Stream
ARGS: USERNO
DESC: ZUSER saves the current stream's retrieval stack and
reactivates the specified stream's stack.
ENTRY: USERNO(I * 4) The number of the stream to process next.
Range is from I to maxnum specified on
HOST initialisation call.
EXIT: None.
| |
ZVARLB, Get Label of Variable
ARGS: VDESC,STRING,LENGTH
DESC: ZVARLB searches the database and return the variable
label for a specified variable.
ENTRY: VDESC (D * 8) The descriptor of the variable.
LENGTH (I * 4) The number of characters of the label to
transfer to STRING.
EXIT: STRING (B * n) The area which will receive the
variable label.
RETURN: Number of characters actually transferred, negative
if error.
| |
ZVERS, Return Version, Revision Numbers and Levels of
HOST
ARGS: VERNUM, VERLEV, REVNUM, REVLEV
DESC: ZVERS returns the version and revision number and
levels of the HOST package that the user is
currently using. It also returns an indication of
whether it is regular or concurrent HOST.
ENTRY: None.
EXIT: VERNUM (I * 4) Version number.
VERLEV (I * 4) Version level.
REVNUM (I * 4) Revision number.
REVLEV (I * 4) Revision level.
RETURN: 0 if regular HOST,1 if concurrent HOST.
| |
ZVNAME, Get Name for Variable Descriptor
ARGS: VDESC,VNAME
DESC: ZVNAME looks up a common or record variable
descriptor and returns the variable's name.
ENTRY: VDESC (D * 8) The variable descriptor.
EXIT: VNAME (N * 8) contains the variable name
corresponding to the variable
descriptor specified.
| |
ZVTYPE, Get Type of Variable
ARGS: VDESC,LENGTH
DESC: ZVTYPE returns the type of a specified variable.
ENTRY: VDESC (D * 8) The descriptor of the variable to get
the type for.
EXIT: LENGTH(I * 4) The size of the variable in bytes.
RETURN: The code of the type of the specified variable,
negative if error.
CODE TYPE
1 String variable
2 Categorical integer variable
3 Date integer variable
4 Time Integer variable
5 Integer variable
6 Real variable
| |
ZWITH, Start Creation of WITH Key
ARGS: DUMMY
DESC: ZWITH starts the creation of a key. It creates a
"WITH" key. ZWITH is used with CASE/RECORD IS
levels to specify a key for a single CIR/record. It
can also be used with the PROCESS RECORD level to
specify the first n sort-ids of a key, which causes
all records with the same first n sort-ids to be
selected in order. It is normally called after one
of the case/record level initialisation routines in
order to initialise the key selection options for
case or record loops. Following a call to ZWITH
other routines (described below) are called to enter
values into the key one at a time. For a case key
only one call is made to enter the value of the case
id. For record keys, the case id is assumed to be
the same as the last CIR retrieved or restored.
Therefore, only the record sort ids have to be
inserted into the key. The sort-ids must be entered
in the order of their appearance in the key being
created.
ENTRY: DUMMY(I * 4) Dummy argument to make routine a
syntactically correct FORTRAN function.
Should always be 0.
EXIT: None.
| |