dadllcommonDLL Usage description Library: dadllcommon This library contains common functionality that does not belong to any other, more specific library. Unless specified otherwise the following formats should be used for passing parameters/can be expected as return value: table : ppmmmnnn tablefield: ppmmmnnn.ccccccccc domain : ppcccccccccccc DLL Prototypes function extern convert.char.to.new.line(ref string text.line())
pre : true post : in text.line all ASCII characters 255 are replaced with new
line
characters.
function extern convert.new.line.to.char(ref string text.line())
pre : true post : in text.line all new line characters are replaced with
ASCII
character 255.
function extern display.mess(const string msg())
pre : true post : msg is displayed in the user_message part of the 'progress
window'. The user_messagepart of the window can contain 72
characters at most. desc : see dllusage of function
display.xch.progress()
function extern display.xch.progress(
domain daxch.txch xch.type,
const domain daxch.cxch xch.scheme,
const domain daxch.cbat batch,
domain daxch.batl batchline,
const domain daxch.ttbl triton.table,
const domain daxch.casf ASCII.file,
long run.num,
long try.num,
const string filename(),
long no.read,
long no.processed,
long no.error.rejected,
long no.cond.rejected,
long no.skipped)
pre : true post : Information passed as parameters is displayed in a window
desc : Window should look like:
+------------------------FFFFFFxch_typeFFFFFF-------------------+
| Exchange Scheme: FFFF Records read |
| Batch : FFFF Records processed : FFFF |
| |
| Batchline : FF Records rejected due to errors: FFFF |
| |
| Table : FFFF Records rejected due to conds. : FFFF |
| |
| ASCII File : FFFF Records skipped without action: FFFF |
| |
| Run-/trynumber : FF/FF |
| |
| File : FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
| |
| FFFFFFFFFFFFFFuser_messageFFFFFFFFFFFFFF |
+---------------------------------------------------------------+
function extern long domain.exists(const string domain.name())
pre : true return: whether <domain.name> is an existing domain
function extern long field.exists(
const domain daxch.ttbl table.name,
const domain daxch.tfld field.name,
[ ref string domain.name() ],
[ ref long field.type ],
[ ref long field.flag ],
[ ref long field.depth ])
pre : format of field.name is without table return: whether <field.name> is
an existing field of table <table.name>
(if it is a combined field false will be returned) post : if true is
returned and one or more of the optional parameters
are specified they will be given their proper value
function extern long generate.unique.key()
pre : true return: a unique value is returned by this function which will
never be
returned again.
function extern string get.index.field.name(
const string tble(),
long index.no,
long part.no )
pre : index.no > 0 return: the name of the <part.no>th field in index
<index.no> of table
<tble>. IF either <tble> does not exist or <tble> does not have
an index <index.no> or index <index.no> does not have at least
<part.no> fields THEN the empty string is returned.
Note that the data dictionary is read using the rdi functions,
thus according to the current package combination of the user.
function extern string get.separator(
const domain daxch.cxch xch.scheme )
pre : true return: xch.scheme exists ==> sepa.to.sepa.char
(daxch001.ctrl,daxch001.sepa) otherwise ==> "" state : current record of
daxch001 will not be changed
function extern long index.exists(
const domain daxch.ttbl table.name,
long index.no,
[ ref long no.parts ],
[ ref long duplicate ] )
pre : true return: whether <table.name> has an index with number <index.no>.
post : if true is returned the no.parts contains (if provided) the
number of fields belonging to the index and duplicate,
if provided, tells whether duplicates are allowed.
function extern long is.index.field(
const string tble(),
long index.no,
string field.name(18) fixed )
pre : index.no > 0 return: whether field <field.name> belongs to index
<index.no> of
table <tble>
function extern long is.numeric.constant(const string str())
return: true if and only if str contains a long or float constant
(possibly in scientific notation)
function extern long is.text.buffer.field(const string field.name())
pre : true return: whether <field.name> is "tttxt010.text" or "tttxt015.text"
desc : this function is used to determine whether the field contains
new line characters (table field tttxt010.text usually does).
function extern long is.text.field(const string field.name())
pre : true return: whether field <field.name> is a tttxt???.ctxt field
function extern justify.and.convert.string(
ref string string.value() mb,
const string string.domain())
pre : string.domain is an existing string domain post : string.value is:
- justified to left, right or center
- converted to upper or lower case
- truncated to the domain length according to the definition of
the domain string.domain
function extern long language.exists(string lang(1))
pre : true return: whether <lang> is an existing language
function extern string make.string.const(const string str())
pre : true return : str converted to a string constant as can be used in
literal
code such as dynamic sql or generated scripts).
For example: - double quotes (") have been placed around str
- double quotes within str have been replaced
with 2 double quotes ("")
- leading or trailing spaces are NOT removed
from str
function extern remove.xch.progress()
pre : display.xch.progress() or display.mess() must have been called
before. post : window used by display.xch.progress and display.mess has
been
removed.
function extern string replace(
domain daxch.str stri,
const string pattern(),
const string repl() )
pre : pattern <> "" return: stri with all occurences of pattern replaced with
repl return
string should not exceed length of domain daxch.str
function extern sepa.string.to.sepa(
const string sepa.string(),
ref domain daxch.yesno ctrl,
ref domain daxch.sepa sepa )
pre : valid.separator.string(sepa.string) post : if isspace(sepa.string):
ctrl = no and sepa = ""
if len(sepa.string) = 1: ctrl = no and sepa = sepa.string
if len(sepa.string) = 2: ctrl = yes and sepa = sepa.string(2)
function extern string sepa.to.sepa.char(
domain daxch.yesno ctrl,
domain daxch.sepa sepa )
pre : valid.separator(ctrl, sepa) return: if ctrl = no: sepa
if ctrl = yes: the ASCII character for <Ctrl> sepa
function extern long size.of(const string domain.name())
pre : domain.name is a domain of type string return: the length of the domain
function extern long table.exists(const domain daxch.ttbl table.name)
pre : true return: whether <table.name> is an existing table.
function extern long valid.separator(
domain daxch.yesno ctrl,
domain daxch.sepa sepa )
pre: true return: true if and only if ctrl and sepa make up a valid
separator.
For example:- ctrl = no and sepa not in {, 0--9, A--Z}
- ctrl = yes and sepa in {A--Z, [, \, ], ^}
function extern long valid.separator.string(const string sepa.string())
pre : true return: true if and only if sepa.string is a valid separator.
For example:- isspace(sepa.string)
- len(sepa.string) = 1 and valid.separator
(no, sepa.string)
- len(sepa.string) = 2 and sepa.string(1;1)
= "^" and valid.separator (yes, sepa.string(2)
| |||