MarcMan

1. Variable S

Value of currently processed item is in variable "S" and after the performing the rule, the value from this particular variable is inserted into the predefined output item.

Example:

200$a->300$b  {      
        WriteToLog(S)           
	S="test" + S            
}

That means, if the rule is empty (200$a->300$b{ }), value S is transmitted without a change, and 300$band field will contain the same as 200$a field contained.

2. Variable TOC

String of the rule behind the arrow is saved into the variable TOC, so in case of 200$a->300$b{ }, "300$b" is saved here, and if you change this in the course of performing the rule, the output in the variable S will be directed somewhere else. For example:

200$a->300$b  {      
        TOC="300$c"         
}

it is the same as if you write:

200$a->300$c  {      

}

This way you can change dynamically the target of the resultunt value at the course of the rule performance. If the value is changed in the rule, the rule should look like as follows:

200$a->All  {      
        TOC="300$c"         
}

Value All says to the reader of the rules, that variable TOC is modified in the rule, and therefore it is indifferent what an expression has on the right side behind the arrow.

3. Variable FROMC

The string of the rule before the arrow is saved in the variable FROMC, thus in case of 200$a->300$b{ } it is saved 200$b. It is variable read only - which means, that you won't get anywhere by changing its value.

4. Variable FROM_IDF

Part of the variable FROMC is saved in the variable FROM_IDF , specifically the first three characters (Mid(FROMC,1,3)). This part, generally indicating the field name (in 200$a it is string "200"), is used so often, that the new variable was created in order not to use the construction shown in the brackets.

5. Variable SET

Variable SET has default value of 1, if you change it to zero, that means, nothing will be set after completing this rule. Which means, that values S and TOC come to nothing.

6. Variable ADD

Variable ADD has default value of 0, if you set it to one, that means, you don't want to replace a value in the current output, but to add a variable S to the current value.

7. Variables NF,NS

Variables NF, NS are probably the most complicated part of the conversion. They solve the situation, where for example there is a repeatable field in the input format, but a field, where values are directed to, is not repeatable, and values from many input subfields are piling up in one single output field:

That is different to the situation, when at every new field 200 a new output field 100 would be created. You can modify this conduct by setting the values NF(Number field), NS(NumberSubfield). These are basically the index values, similarily as it is in the expressions of 200(1)$a(3) type.

The variables NF,NS are input and as well as the output values, similarily to a variable S, which is input as well as output value.

Let's have a record:

200  $afirst value
200  $asecond value
200  $athird value

and rule

200$a->100$a { WriteToLog("NF:" + NF + " - NS:" + NS) }

There is an index of currently processing field in NF variable at the input. (in our case, variable would contain successively 1,2,3 and in three cases the NS would be 1 ($a is always alone and first). From the rule indicated above there would be three lines in the log file.

NF:1 - NS:1 
NF:2 - NS:1 
NF:3 - NS:1

Output would then be directed into the field 100(NF)$a(NS) thus successively till:

100(1)$a(1)
100(2)$a(1)
100(3)$a(1) 

As there was no 100 field before processing of the rule, three new fields with index 1-3 would be created successively. This is a standard behaviour. If you want to change this behaviour in order to have the situation as it is in the picture, your rule would look as follows:

200$a->100$a { NS=NF; NF=1 }

Output would then be directed into a field 100(NF)$a(NS) thus successively to:

100(1)$a(1) 
100(1)$a(2)  
100(1)$a(3)

Only one field 100 with three subfields $a would be created. If you want that all subfields $a would combine into one single subfield $a of one single subfield $100, you would proceed as followed:

200$a->100$a { NS=1; NF=1; ADD=1 }

The result would be

100$afirst valuesecond valuethird value

WriteToLog

Description:	Function writes a line "value" into a log file
Call example:	WriteToLog(value)
Input arguments:	Designation Data type Note value text string or numeric value any text string or numeric value
Return value:	-
Example:	WriteToLog("i=" + i) Execution of the example indicated above causes a printing of the variable value also in the log file.

GetRecord

Description:	GetRecord returs the output, thus rising record into a format txt. You can find more information on this format in chapter Text format
Call example:	GetRecord()
Return value:	Record in txt format.
Example:	In case of such output record nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut command would WriteToLog("*******************************") WriteToLog(GetRecord()) WriteToLog("*******************************") cause a printing into a log file: ******************************* nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut *******************************

ClearFile

Description:	Function serves for reducing the file with a set name to zero size. If the file still doesn't exist, empty file with set name is created.
Call example:	ClearFile(file name)
Input arguments:	Designation Data type Note file name text string file name, which should be reduced to zero size, file doesn't have to exist Attention! - convertor has to have a right to create such a file resp. to write into it
Return value:	Return value is 0, if the file reduction was processed successfully; otherwise the error message is printed out into a log file about an impossibility to process a record reduction operation.
Example:	ClearFile("/tmp/outrecord.txt") Execution of the example mentioned above causes a file reduction /tmp/outrecord.txt to zero size.

WriteOutRecordToFile

Description:	Function serves for calling the immediate write of the input record including possible already processed modifications to the file in a given format. If the file stil doesn't exist, it is created by calling up this function. If it does exist, the write out record is added to the end of the file.
Call example:	WriteOutRecordToFile(file name,record format)
Input arguments:	Designation Data type Note file name text string file name, where record should be written, file doesn't have to exist Attention! - convertor has to have right to create such a record resp. to write into it record format text string these are only admissible values: aleph, iso and txt (More on record formats,see record formats)
Return value:	Return value is 0, if the file reduction was processed successfully; otherwise the error message is printed out into a log file about an impossibility to process a write operation.
Example:	WriteOutRecordToFile("/tmp/outrecord.txt","txt") Execution of the example mentioned above causes immediate write of output record including possible already processed modifications into a file /tmp/outrecord.txt in text format.

TranslateAsciiChars

Description:	Function translates all character occurences in a set input text string, character by character, from a source character set into a target character set.
Call example:	TranslateAsciiChars(text,source character set, target character set)
Input arguments:	Designation Data type Note text text string any text string; if text string is not an argument, error message prints out into a log file source character set textový řetězec Attention! - only ASCII characters can be set, and their number must corresponds with a number of characters in argument - target character set target character set text string Attention! - only ASCII characters can be set, and their number must corresponds with a number of characters in argument - source character set
Return value:	Return value is a requested input text string, where all character occurences from source character set are replaced with the corresponding characters from target character set.
Example:	t = TranslateAsciiChars("male","elma","ELMA") WriteToLog("male -> "+t) Execution record of an example indicated above in the log file would look like as follows: male -> MALE

StripAsciiChars

Description:	Function removes (strips) from requested input text string, all character occurences, from a particular character set, resp. removes characters that are not indicated in the requested character set.
Call example:	StripAsciiChars(text,character set,complement)
Input arguments:	Designation Data type Note text text string any text string; if a text string is not an argument, error message prints out into a log file character set text string Attention! - only ASCII characters can be set target character set number Attention! - only value 1 or 0 can be set, if another value is indicated, nothing will be changed in the input text string; if value is set to 0, all characters indicated in that character set are removed from the input string. if value is set to 1, the complement to that character set is removed from the input string, thus not indicated characters in that set.
Return value:	Return value is a requested input string, where all character occurrences from source character set are substituted by the corresponding characters from the target character set.
Example:	t = StripAsciiChars("i n t e r l a c e d - t e x t"," ",0) WriteToLog("text= "+t) Execution record of an example indicated above in the log file would look like as follows: text = interlaced-text Similarily: t = StripAsciiChars(".0a9de8f7g6ty5j4k3ad2a","0123456789",1) WriteToLog("numbers only= "+t) Execution record of an example indicated above in the log file would look like as follows: numbers only = 0987654321

Mid

Description:	Function returns a part of the string beginning with start, of length length.
Call example:	Mid(string, start, length) or Mid(string, start)
Input arguments:	Designation Data type Note string text string any text string; if a text string is not an argument, error message prints out into a log file start number start of the string part.Value would be 1 for first word. [length] number Optional parameter. If you don't indicate the parameter, the returned part will be from start argument to the string end.
Return value:	Return value is a corresponding string part.
Example:	WriteToLog("short text = " + Mid("something text",3,3)) Execution of the example indicated above writes a following text into a log file: short text = som

Len

Description:	Function returns a length of the string.
Call example:	Len(string)
Input arguments:	Designation Data type Note string text string any text string; if a text string is not an argument, error message prints out into a log file
Return value:	Return value is the length of the string as a number.
Example:	WriteToLog("length of text = " + Len("something text")) Execution of the example indicated above writes a following text into a log file: length of text = 14

Find

Description:	Function finds a substring in the string and returns a position of the fist substring occurence either from the string start or from the start position.
Call example:	Find(string, substring, start) or Find(string, substring)
Input arguments:	Designation Data type Note string text string any text string; if a text string is not an argument, error message prints out into a log file substring text string any string, which should be found in the string, requested as a first argument [start] number position in the string string, where the find of the substring string should start
Return value:	Return value is a number - occurence position counted from 1.
Example:	WriteToLog("Position=" + Find("something text text","te")) Execution of the example indicated above writes a following text into a log file: Pozice=11

FindReverse

Description:	Function finds a substring in the string reversely and returns a position of the first substring occurence either from the string end or from the start position.
Call example:	FindReverse(string, substring, start) or FindReverse(string, substring)
Input arguments:	Designation Data type Note string text string any text string; if a text string is not an argument, error message prints out into a log file substring text string any string that should be found in the string, set as a first argument of the reverse search. [start] number position in the string string, where the find of the substring string should start
Return value:	Return value is a number - occurence position counted from 1.
Example:	WriteToLog("Position=" +FindReverse("something text text","te")) Execution of the example indicated above writes a following text into a log file: Position=16

Trim

Description:	Function trims (removes) the string spaces, from the right and from left. It doesn't trim (remove) the spaces, which are inside the text.
Call example:	Trim(string)
Input arguments:	Designation Data type Note string text string any text string; if a text string is not an argument , error message prints out into a log file
Return value:	Return value is a string with no spaces from the right and left.
Example:	WriteToLog("<" +Trim(" something text ") + ">") Execution of the example indicated above writes a following text into a log file: <something text>

TrimChars

Description:	Function trims the characters from the string, from right and left, that are in the character group. It doesn't trim the characters that are inside the text, which doesn't start nor end by any of the characters in the character group.
Call example:	TrimChars(string, character group)
Input arguments:	Designation Data type Note string text string any text string; if a text string is not an argument, error message prints out into a log file character group text string character group, which should be removed from the string start and end. That means, the character group,which contains any number of character occurences from this parameter, will be removed from the string start and end.
Return value:	Return value is a string with no spaces from right and left.
Example:	WriteToLog("<"+TrimChars(";(( t-ext,a ,,/",",()/;: -")+">") Execution of the example indicated above writes a following text into a log file: <t-ext,a>

Replace

Description:	Function scans the string and all substring occurences replaces with replacement text
Call example:	Replace(string, substring, replacement)
Input arguments:	Designation Data type Note string text string any text string substring text string any text string, which should be found in the string set as first argument, and replaced with the third argument replacement text string any text string,which should replace a string, set as second argument
Return value:	Return value is a string.
Example:	WriteToLog("Rewritten = " + Replace("this text","te","---")) Execution of the example indicated above writes a following text into a log file: Přepsaný = this ---xt

SplitByChars

Description:	Function splits the string into the value arrays, which are separated in the string by one of the separator array elements. The result will appear in the array called array name, and in the array called separator array name they are indicated separators, which separated individual values. Method determines how the separation should be performed.
Call example:	SplitByChars(string, separators, array name, separator array name, method)
Input arguments:	Designation Data type Note string text string any text string separators text string array including separators array name text string array name, that still doesn't have to exist,and where you find separated individiual values, after the command execution. Separator array name text string array name,that still doesn't have to exist, and where, after the command execution, you find the separators,by which the string was separated as they appeared one after another. method text string Might have following values: "BYALL" in the string, the separators don't have to go successivelly,as they are indicated in the separator arrray "BYORDER" in the string, the separators must go successively as theyappear in the separator array, but some of them can be omitted "BYORDERDIRECT" in the string, the separators must go successively as theyappear in the separator array, none can be omitted
Re-entry value:	One if command run successfuly or zero in the opposite case.
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBondy, Egon ; writer (dramatist) 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut And in this rule: 260$a->All { Array("Separators" , "," , " ; " , "(" , ")") If SplitByChars( S , "Separators" , "Hodnoty" , "Znacky" , "BYORDERDIRECT" )==0 Then      WriteToLog("Chyba")      Exit Endif For i=1 To CountArray("Hodnoty")    WriteToLog("Hodnota: " + GetArray("Hodnoty",i) + "- Oddělovač: " + GetArray("Znacky",i)) Next The result would be in the log file as such: Hodnota: Bondy - Oddělovač: , Hodnota: Egon - Oddělovač:  ;  Hodnota: writer - Oddělovač:  (  Hodnota: dramatist - Oddělovač:  )

Table

Description:	Function opens a table saved in the file of the particular name, and finds there a value corresponding with the indicator. File structure defining a table is the same as the file structure with the convertor's parameters, and the rules for the indicator write are the same as the rules for the parameter write. (see Configuration file structure)
Call example:	Table(file name,indicator, alternative return value) or Table(file name, indicator)
Input arguments:	Designation Data type Note file name text string any text string; if a text string is not an argument, error message prints out into a log file Attention! - field with a particular name has to already exist in the directory TablesDirectory (see convertor parameter TablesDirectory) indicator name text string indicator whose corresponding value should be found in the table [alternative return value] text string optional argument any text string, which should be returned, if the indicator is not found in the table
Return value:	Return value is either an indicator value found in requested table, or a value of the third argument; if the indicator was not found in the table, if the third argument is not indicated and the indicator was not found, the return value is a string consisting of letters "X" of same length that requested indicator has.
Example:	If there is a file den.tbl in the directory specified by parameter TablesDirectory, containing: 1=Monday 2=Tuesday 3=Wednesday 4=Thursday 5=Friday 6=Saturday 7=Sunday Then the execution of the following example: t = Table("day.tbl","1","not found") WriteToLog("day = "+t) t = Table("day.tbl","8","not found") WriteToLog("den = "+t) would cause, that the record would appear in the log file as follows: day = Monday day = not found

GetMarcInValue

Description:	Function returns a value that is in line with a command in the current record at the input. Command requires the same syntax, which is used for writing the rules. You can find more information on how to write those rules in the chapter Record access expressions. e.g. command types: GetMarcInValue("200(2)$a(1)") Unlike the record access expressions, it is necessary to indicate field and subfield index in the rule letterheads. It needs to be clear then, which field or subfield you have in mind. For example if you call: GetMarcInValue("200$a") The program doesn't recognize, which 200 field and which $a subfield you have in mind.This procedure fails, eventhough there is only one field and its subfield in the record. It is necessary to indicate specifically: GetMarcInValue("200(1)$a(1)")
Call example:	GetMarcInValue(expression)
Input arguments:	Designation Data type Note expression text string text string in form of Record access expression
Return value:	Return value is an entity value, which you designated in the expression. If your expression is wrong or particular entity was not found, function returns an empty string.
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut following example would: WriteToLog("value = " + GetMarcInValue("260(1)$a(1)")) cause a writing of the following text into a log file: value = Basel : and following WriteToLog("value = " + GetMarcInValue("700(1)I1")) would cause a writing of the following text into a log file: value = 1

GetMarcOutValue

Description:	Function returns a value that is in accordance with a command in the current record at the output (it is record that is being created at the conversion process). Command requires the same syntax, which is used for writing the rules.You can find more information on how to write those rules in the chapter Record access expressions. Expression types: GetMarcOutValue("200(2)$a(1)") Unlike the record access expressions , it is necessary to indicate field and subfield index in the rule letter heads . It needs to be clear then, which field or subfield you have in mind. For example if you call: GetMarcOutValue("200$a") The program doesn't recognize, which 200 field and which $a subfield you have in mind. This procedure fails, eventhough there is only one field and its subfield in the record. It is necessary to indicate specifically: GetMarcOutValue("200(1)$a(1)")
Call example:	GetMarcOutValue(expression)
Input arguments:	Designation Data type Note expression text string text string in form of Record access expressions
Return value:	Return value is an entity value, which you designated in the expression. If your expression is wrong and requested entity was not found, function returns an empty string.
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut following command would: WriteToLog("value = " + GetMarcOutValue("260(1)$a(1)")) cause a writing of the following text into the log file: value = Basel : and following: WriteToLog("value = " + GetMarcOutValue("700(1)I1")) would cause a writing of the following text into the log file: value = 1

MaxI

Description:	Function returns a maximum command index at the input. Command requires the same syntax, which is used for writing the rules.You can find more information on how to write those rules in the chapter Record access expressions. Command types: MaxI("200(1)$a") Unlike the record access expressions, requested entity index can't be indicated in the rule letterheads. At the same time, there is no point in requesting an indicator index, to indicate a construction of the entity parts in the curly brackets, and the like. Admissible commands would for example be: MaxI("200") or MaxI("200(1)$a") but not MaxI("200$a") as it is not clear, which 200 field you have in mind. And also not MaxI("200(1)$a(1)") as in this case there is nothing to count.
Call example:	MaxI(expression)
Input arguments:	Designation Data type Note expression text string text string in form of Record access expressions
Return value:	Return value is a number, that indicates an entity number, requested in the your command.
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: WriteToLog("count = " + MaxI("260(1)$a")) cause writing of the following text into the log file: count = 1 and following WriteToLog("count = " + MaxI("700")) would cause a writing of the following text into the log file: count = 2

MaxO

Description:	Function returns a maximum command index at the output. (it is record that is being created at the conversion process). Command requires the same syntax, which is used for writing the rules.You can find more information on how to write those rules in the chapter Record access expressions. Command types: MaxO("200(1)$a") Unlike the record access expressions, requested entity index can't be indicated in the rule letterheads. At the same time, there is no point in requesting an indicator index, to indicate a construction of the entity parts in the curly brackets, and the like. Admissible commands would for example be MaxO("200") or MaxO("200(1)$a") but not MaxO("200$a") as it is not clear,which 200 field you have in mind. And also not MaxO("200(1)$a(1)") as in this case there is nothing to count.
Call example:	MaxO(expression)
Input argumentys	Designation Data type Note expression text string text string in form of Record access expressions
Return value:	Return value is a number, that indicates the entity number requested in your command.
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: WriteToLog("count = " + MaxO("260(1)$a")) cause writing of the following text into the log file: count = 1 and following WriteToLog("count = " + MaxO("700")) cause writing of the following text into the log file: count = 2

NeibField

Description:	Function examines the environment of the currently processed field in the input record, and returns a field name. Displacement determines, where to look in the environment. For example at: NeibField(-1) it returns a field, which is the first before the currently processed field. And at NeibField(1) it returns a field, which is the first after the currently processed field.
Call example:	NeibField(displacement)
Input arguments:	Designation Data type Note displacement number Positive or negative number determining displacement
Return value:	If it doesn't find such, it returns an empty string.
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: 260$a->150$a { WriteToLog("before = " + NeibField(-1)) } cause a writing of the following text into the log file: before = 005 and following 700$a->150$a { WriteToLog("before = " + NeibField(-1)) } would cause a writing of the following text into the log file: before = 260 before = 700

NeibSubField

Description:	It examines the environment of the currently processed subfield in the input record, and returns a subfield name. Displacement determines, where to look in the environment.The function doesn't cross the field borders, which means, it only operates in the current field. For example at NeibSubField(-1) it returns a subfield, which is the first before the currently processed subfield, in the currently processed field. And at NeibField(1) it returns a subfield,which is the first after the currently processed subfield, in the currently processed field.
Call example:	NeibSubField(displacement)
Input arguments:	Designation Data type Note displacement number Positive or negative number determining displacement
Return value:	If it doesn't find such, it returns an empty string.
Example:	In this input record: Following command would: 260$a->150$a { WriteToLog("after = " + NeibField(1)) } cause a writing of the following text into the log file: after = b and following 700$4->150$a { WriteToLog("before = " + NeibField(-1)) } cause a writing of the following text into the log file: before = a before = a

IsSubBefore

Description:	In the input record, it examines a subfield that is before the currently processed subfield in the currently processed field, and finds out, if there is a field with subfield name indicator.
Call example:	IsSubBefore(subfield name)
Input arguments:	Designation Data type Note subfield name text string of length 1. subfield indentificator, that should be found
Return value:	It returns number 1, if there is a field with subfield name identificator, or 0 if there isn't.
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: 260$b->150$a { WriteToLog("a is before= " + IsSubBefore("a")) } cause writing of the following text into the log file: a is before = 1 and following 700$4->150$a { WriteToLog("b is before = " + IsSubBefore("b")) } would cause writing of the following text into the log file: b is before = 0 b is before = 0

SetValue

Description:	Function in the accordance with the command, in form ofRecord access expressions sets the value in newly formed thus in the output record. Value is an entity value, that should be set (analogy of variable S in the rule),field index is a field index, where a value should be directed to (analogy of variable NF in the rule), subfield index is a subfield index, where the value should be directed to (analogy of variable NS in the rule) and if add is set to 1, value will be added to the already existing value (analogy of variable ADD in the rule) If an index is zero, that means, similar to variables NF and NS, that a field, respectively subfield should be added, otherwise a field with the particular index and subfield with the particular index is retrieved, and value is either inserted into it (if add equals zero) or adds(if add equeals one). This command is an alternative way, how to influence the output record in the rule. This way it is possible to create from one rule more outputs.
Call example:	SetValue(command, value, field index , subfield index, add)
Input arguments:	Designation Data type Note command text string text string in form of Record access expressions value text string setting value field index number field index, where the value should be directed to subfield index number subfield index, where the value should be directed to add number if the current value should be overwritten or value added Possible values 0 1
Return value:	-
Example:	In this input record: 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut After the following command: 260$b->All { SetValue("500$a","valueA",1,1,0) SetValue("500$b","valueB",1,1,0) SET=0 } the output record would look like as follows: 001 zpk20010038759 005 20010110000000.0 500 $avalueA$bvalueB 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut Or after the following command: 260$b->All { SetValue("500I1","1",1,0,0) SetValue("500$a","valueA",1,1,0) SetValue("500$b","valueB",1,1,0) SetValue("500$a","valueA",1,1,1) SetValue("500$b","valueB",0,0,0) SET=0 } the output record would look like as follows:

BreakError

Description:	This function breaks the conversion of the current record, the record is marked as faulty and along with the message, is handled as any other badly converted record. Then it continues with the conversion of the next record in the package. Record is saved into the file InRecordErrorFile and your message appears in the log file.
Call example:	BreakError(message)
Input arguments:	Designation Data type Note message text string any text string including a problem message
Return value:	-
Example:

ContinueError

Description:	By this function the record is marked as faulty, nevertheless, the conversion of the current record doesn't break, record is marked as faulty and along with the message, is handled as any other badly converted record. Conversion continues as if no error occurred. Record is saved into the file InRecordErrorFile and your message appears in the log file. This function is used for example in detailed control of the record by the help of the rules. You can find more information on this control in the chapter Control file
Call example:	ContinueError(message)
Input arguments:	Designation Data type Note message text string any text string including a problem message
Return value:	-
Example:

GetMaxUnsignedInteger

Description:	Function returns largest integer value, that occurs in form of text string in the requested string. Any no numerical character is considered as a number separator. Sign - (which is minus) is interpreted also as a separator.
Call example:	GetMaxUnsignedInteger(text)
Input arguments:	Designation Data type Note text text string any text string; if a text string is not an argument, the error message writes into the log file
Return value:	The largest integer occuring in form of the text string in the requested string , or empty string, in case there is no number in the requested string.
Example:	i = GetMaxUnsignedInteger("A10-11.20") WriteToLog("i = "+GetString(i)) Execution record of an example indicated above in the log file would look like as follows: i = 20

GetInteger

Description:	Function tries to convert a string into a number.
Call example:	GetInteger(text)
Input arguments:	Designation Data type Note text text string any text string; if a text string is not an argument, the error message writes into the log file
Return value:	Either a number corresponding with a number in the text string, otherwise it returns zero.
Example:	Command WriteToLog("suma = " + (GetInteger("125") + 3)) Execution of the example above in the log file would look like as follows: suma = 128

GetString

Description:	Function converts a string into a number.
Call example:	GetString(number)
Input arguments:	Designation Data type Note number number
Return value:	Text corresponding with a number.
Example:	Command WriteToLog("Number = " + GetString(5)) Execution of the example indicated above in the log file would look like as follows: Number = 5 Which in this case, it is purposeless, as the automatic type conversion would do the same in the following example: WriteToLog("Number = " + 5) However, in this case: i=200 MaxI(GetString(i)) there would be a point.

Modulo

Description:	Function returns the remainder after dividing the number1 by number2
Call example:	Modulo(number1, number2)
Input arguments:	Designation Data type Note number1 number divident number2 number divisor
Return value:	Remainder after dividing number1 by number2.
Example:	Command WriteToLog("modulo = " + Modulo(20,3)) Execution of the example indicated above in the log file would look like as follows: modulo = 2

Array

Description:	Function creates a new array array name, with the elements element1 to elementN. Function has a variable number of parameters. First element is an array name and other elements are array elements ...
Call example:	Array(array name, element1,element2 ......)
Input arguments:	Designation Data type Note array name text string any text string; if a text string is not an argument, the error message writes into the log file value1 text string or number any value value2 text string or number any value ... ... ...
Return value:	-
Example:	Array("Days","Mon","Tue","Wed","Thu","Fri","Sat","Sun") WriteToLog("first = " + GetArray("Days",1)) Execution record of an example indicated above in the log file would look like as follows: first = Mon

AddArray

Description:	Function adds another value to the end of the existing array with a particular name.
Call example:	AddArray(array name, value)
Input arguments:	Designation Data type Note array name text string any text string; if a text string is not an argument, the error message writes into the log file value text string or value any value
Return value:	-
Example:	a = Array("A") AddArray("A","a") AddArray("A","b") WriteToLog("A = ("+GetArray("A",1)+","+GetArray("A",2)+")") Execution record of an example indicated above in the log file would look like as follows: A = (a,b)

GetArray

Description:	Function returns a value, which is saved in the array with a particular name, on a position set by requested index.
Call example:	GetArray(array name, index)
Input arguments:	Designation Data type Note array name text string any text string; if a text string is not an argument, the error message writes into the log file Attention! - array with a particular name must be already created index number index of value location in the array, array elements are indexed from one.
Return value:	-
Example:	Array("Days","Mon","Tue","Wed","Thu","Fri","Sat","Sun") WriteToLog("fifth = "+GetArray("Days",5)) Execution record of an example indicated above in the log file would look like as follows: fifth = Fri

CountArray

Description:	Function returns a size of an array array name
Call example:	CountArray(array name)
Input arguments:	Designation Data type Note array name text string any text string; if a text string is not an argument, the error message writes into the log file Attention! - array with a particular name must be already created
Return value:	-
Example:	Array("Days","Mon","Tue","Wed","Thu","Fri","Sat","Sun") WriteToLog("size = "+CountArray("Days")) Execution record of an example indicated above in the log file would look like as follows: size = 7

SetMem

Description:	Function creates a variable from a command, which is passed to the function in form of string. That can be an advantage, if you need to create variables on the basis of some parameter. Function practically does the same as if you write variable name=value
Call example:	SetMem(variable name,value)
Input arguments:	Designation Data type Note variable name text string any text string representing a variable name value text string or number. any value
Return value:	-
Example:	Following example clarifies the function purpose: SetMem("group" + 1,20) WriteToLog("value = " + group1) writes into the log file: value = 20 This function is used quite frequently due to the following principle. We have a following input record: 2602 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut and following rules, where two rules lead to the same output record, and our aim is to create always new fields for both of the cases: /*field 260*/ 260I1->300I1 { WriteToLog("300 NF = " + NF) } 260$a->300$a { WriteToLog("300 NF = " + NF) } /*field 700*/ 700I1->300I1 { WriteToLog("700 NF = " + NF) } 700$a->300$a { WriteToLog("700 NF = " + NF) } In this case the result would be as followed: 3001 $aBrodtbeck, Thomas 3001 $aBrodtbeck, Thomas and the following would write into the log file: 300 NF = 1 300 NF = 1 700 NF = 1 700 NF = 1 700 NF = 2 700 NF = 2 But that is not what we want. Point is, that values variables NF,NS determine, to which output field index the result should be saved. As first field 700 has got index one, the final value writes to the 300 field with the index, and field 300, created at the conversion of 260 field, is overwritten. Not even following construction would help us, that says, that a new field should always be created: /*pole 260*/ 260I1->300I1 { NF=0 } 260$a->300$a { NF=0 } /*pole 700*/ 700I1->300I1 { NF=0 } 700$a->300$a { NF=0 } the result would then be: 3002 300 $aBasel : 3001 300 $aBrodtbeck, Thomas 3001 300 $aBrodtbeck, Thomas The only right way is following: /*field 260*/ 260I1->300I1 { SetMem("IF" + FROM_IDF + NF, MaxO("300")+1) NF=GetMem("IF" + FROM_IDF + NF) } 260$a->300$a { NF=GetMem("IF" + FROM_IDF + NF) } /*pole 700*/ 700I1->300I1 { SetMem("IF" + FROM_IDF + NF, MaxO("300")+1) NF=GetMem("IF" + FROM_IDF + NF) } 700$a->300$a { NF=GetMem("IF" + FROM_IDF + NF) } This complicated construction in the rule for the first indicator, which is definately performed first in the set of rules for 700 field, finds out through the function MaxO how many 300 fields already exist at the output. It will increase this value by one, and that's going to be an index, where this field will be converted to. It must remember this index, and must provide it to the other rules for this field. Variable name must be then unique for this field occurence, and therefore creates, through the use of SetMem function, an unique variable for each field (through variable FROM_IDF) The following variables would thus be created: IF2601=1 IF7001=2 IF7002=3 and the result would look like as: 3002 $aBasel : 3001 $aBrodtbeck, Thomas. 3001 $aBrodtbeck, Thomas. By using this SetMem function you should always use this construction, whenever you can't be sure, whether the field, where your field is directed to, is repeatable and can be created in another way than from the field, whose conversion you are just generating!

GetMem

Description:	Function returns a value preremembered by SetMem function and designated as variable name name.
Call example:	GetMem(variable name)
Input arguments:	Designation Data type Note variable name text string any text string representing a variable name
Return value:	Variable value. Can be a number or a text string.
Example:	Read Help on function SetMem carefully.

IsSet

Description:	Function finds out if variable name variable exist.
Call example:	IsSet(variable name)
Input arguments:	Designation Data type Note variable name text string any text string representing a variable name
Return value:	Number one, provided that a variable exists, otherwise it's zero.
Example:	Read Help on function SetMem carefully.

MarcFieldsCount

Description:	According to the Source parameter value, function detects the number of the fields in the input or output record. Note: Label is not considered as a field.
Call example:	MarcFieldsCount(source)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record
Return value:	Number indicating a number of the fields .
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: Before->Before { WriteToLog("size input fields = " + MarcFieldsCount("I")) } cause a write of the following text into the log file: size input fields = 5

MarcGetFieldInfo

Description:	According to the Source parameter value, function returns a field information with Index Index in the input or output record. Note: Label is not considered as a field.
Call example:	MarcGetFieldInfo(source, index, searched feature)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction. searched feature text string "ID" - field name "I1" - first indicator "I2" - second indicator "CountSub" - field's subfield number
Return value:	Value including requested information.
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: Before->Before { FCount = MarcFieldsCount("I") For i=0 To FCount-1 WriteToLog("field = " + MarcGetFieldInfo("I",i,"ID")) Next } cause a write of the following text into the log file: field = 001 field = 005 field = 260 field = 700 field = 700

MarcSetFieldInfo

Description:	According to the Source parameter value, function sets a field information with Index index in the input or output record. Note: Label is not considered as a field.
Call example:	MarcSetFieldInfo(source, index, preset feature, value)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction preset feature text string "ID" - field name "I1" - first indicator "I2" - second indicator value text string preset value
Return value:	-
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: After->After { FCount = MarcFieldsCount("O") For i=0 To FCount-1 MarcSetFieldInfo("O",i,"ID","111") Next } cause a following output record: nam 2200229 a 4500 111 zpk20010038759 111 20010110000000.0 111 $aBasel :$bNatursforschende Gesellschaft 1111 $aBrodtbeck, Thomas.$4aut 1111 $aBrodtbeck, Thomas.$4aut

MarcGetSubFieldInfo

Description:	According to the Source parameter value, function returns a subfield information with subfield index Index to the appropriate field with field index index in the input or output record. Note: Label is not considered as a field
Call example:	MarcGetSubFieldInfo(Source, field index, subfield index, searched feature)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record field index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction subfield index number subfield sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcGetFieldInfo function with "CountSub" parameter searched feature text string "ID" - subfield name "Value" - subfield value "Index" - subfield index (value (NS) "LinkingFieldID" - if subfield contains inserted field,function returns name of this field, otherwise empty string "LinkingFieldI1" - if subfield contains inserted field,function returns first indicator of this field, otherwise empty string "LinkingFieldI2" - if subfield contains inserted field,function returns second indicator of this field, otherwise empty string "LinkingFieldCount" - number of subfields in the inserted field
Return value:	Value containing requested information.
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: Before->Before { FCount = MarcFieldsCount("I") For i=0 To FCount-1 IDF = MarcGetFieldInfo("I",i,"ID") SCount=MarcGetFieldInfo("I",i,"CountSub") For j=0 To SCount IDS = MarcGetSubFieldInfo("I",i,j,"ID") WriteToLog("field=" + IDF + ";subfield=" + IDS) Next Next } cause a write of the following text into the log file: field=001;subfield=E field=005;subfield=E field=260;subfield=a field=260;subfield=b field=700;subfield=a field=700;subfield=4 field=700;subfield=a field=700;subfield=4

MarcSetSubFieldInfo

Description:	According to the Source parameter value, function sets the subfield value with subfield index Index to the approptiate field with field index index in the input or output record. Note: Label is not considered as a field
Call example:	MarcSetSubFieldInfo(source, field index, subfield index, searched feature, value)
Input arguments:	Designation Data type Poznámka source text string Possible values "I" It is input record "O" It is output record field index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction subfield index number subfield sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcGetFieldInfo function with "CountSub" parameter searched feature text string "ID" - subfield name "Value" - subfield value "LinkingFieldID" - if subfield contains inserted field,function returns name of this field, otherwise empty string "LinkingFieldI1" - if subfield contains inserted field,function returns first indicator of this field, otherwise empty string "LinkingFieldI2" - if subfield contains inserted field,function returns second indicator of this field, otherwise empty string value text string preset value
Return value:	-
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: After->After { FCount = MarcFieldsCount("O") For i=0 To FCount-1 IDF = MarcGetFieldInfo("O",i,"ID") SCount=MarcGetFieldInfo("O",i,"CountSub") For j=0 To SCount MarcSetSubFieldInfo("O",i,j,"ID","x") Next Next } cause this output nam 2200229 a 4500 001 $xzpk20010038759 005 $x20010110000000.0 260 $xBasel :$xNatursforschende Gesellschaft 7001 $xBrodtbeck, Thomas.$xaut 7001 $xBrodtbeck, Thomas.$xaut

MarcGetLinkingSubFieldInfo

Description:	According to the Source parameter value, function returns the inserted subfield information with inserted field subfield Index index subfield with subfield index index field with field Index index in the input or output record. Note: Label is not considered as a field.
Call example:	MarcGetLinkingSubFieldInfo(source, field index, subfield index, inserted field subfield index, searched feature)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record field index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction subfield index number subfield sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcGetFieldInfo function with "CountSub" parameter inserted field subfield Index number subfield sequence number, which you have in mind, counted from zero. searched feature text string "ID" - subfield name "Value" - subfield value "Index" - subfield index
Return value:	value containing requested information
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 460 $120012$apodpole1$bpodpole2 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: Before->Before { FCount = MarcFieldsCount("I") For i=0 To FCount-1 SCount=MarcGetFieldInfo("I",i,"CountSub") For j=0 To SCount LCount = MarcGetSubFieldInfo("I",i,j, "LinkingFieldCount") If LCount > 0 Then For k=0 To LCount IDL=MarcGetLinkingSubFieldInfo("I",i,j,k,"ID") WriteToLog("link=" + IDL) Next Endif Next Next } cause a write of the following text into the log file: link=a link=b

MarcSetLinkingSubFieldInfo

Description:	According to the Source parameter value, function sets the value of inserted subfield with inserted field subfield Index index, subfield with subfield index index, field with field Index index in the input or output record. Note: Label is not considered as a field
Call example:	MarcSetLinkingSubFieldInfo(source, field index, subfield index, inserted field subfield index, preset feature, value)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record field index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction subfield index number subfield sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcGetFieldInfo function with "CountSub" parameter inserted field subfield index number subfield sequence number, which you have in mind, counted from zero preset feature text string "ID" - subfield name "Value" - subfield value value text string preset value
Return value:	-
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 460 $120012$asubfield1$bsubfield2 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: After->After { FCount = MarcFieldsCount("O") For i=0 To FCount-1 SCount=MarcGetFieldInfo("O",i,"CountSub") For j=0 To SCount LCount = MarcGetSubFieldInfo("O",i,j, "LinkingFieldCount") If LCount > 0 Then For k=0 To LCount MarcSetLinkingSubFieldInfo("I",i,j,k,"ID","x") Next Endif Next Next } cause this result nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 460 $120012$xsubfield1$xsubfield2 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut

GetLabel

Description:	According to the Source parameter value, function returns a label value in form of a string either in the input or output record.
Call example:	GetLabel(source)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record
Return value:	Label value in form of a string
Example:	In this input record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: Before->Before { WriteToLog("Label = " + GetLabel("I")) } cause a write of the following text into the log file: Label = nam 2200229 a 4500

SetLabel

Description:	According to the source parameter value, function sets a label value in form of a string either in the input or output record. Value should be 24 characters long.
Call example:	SetLabel(source)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record
Return value:	-
Example:	In this output record: -----nkm 22----- 450- 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: After->After { SetLabel("O","-----akm 23----- 450-")) } cause a following output: -----akm 23----- 450- 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut

CopyField

Description:	Function creates a field copy with index index in the output record. Created copy includes subfield and inserted fields indicators.
Call example:	CopyField(index)
Input arguments:	Designation Data type Note index number field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCountfunction
Return value:	-
Example:	In this output record: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut following command would: After->After { FCount = MarcFieldsCount("I") For i=0 To FCount-1 CopyField(i) Next } cause the output of: nam 2200229 a 4500 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut 001 zpk20010038759 005 20010110000000.0 260 $aBasel :$bNatursforschende Gesellschaft 7001 $aBrodtbeck, Thomas.$4aut 7001 $aBrodtbeck, Thomas.$4aut

SortSubfields

Description:	Function sorts either input or output field with field index (if need be with field name name)according to the rule rule. Rule can for examle look like as follows: "[a,b,e,f](x,y,z)[1]". In this case, they are three sets of subfields indicators. Each set is closed in either brackets or parenthesis. If a set is closed in the brackets, that means, that the fields from the field being sorted, are selected in the result, and are kept in the same sequence as they were in the original field. If a set is closed in the parenthesis, that means, that hereby selected characters are additionaly sorted in accordance with a sequence indicated in the parenthesis.
Call example:	SortSubfields(source, field index or field name, rule)
Input arguments:	Designation Data type Note source text string Possible values "I" It is input record "O" It is output record field index or field name number or text string field sequence number, which you have in mind, counted from zero. The ceiling value can be detected through MarcFieldsCount function or field identificator (then the rule applies to all fields of this type) rule text string sorting rule
Return value:	-
Example:	In such structured field of the input record: $200 $b$a$y$1$2$e$f$x following command would: SortSubfields("I","200","[a,b,e,f](x,y,z)[1]") cause this result $200 $b$a$e$f$x$y$1$2 First, the fields from the set 1[a,b,e,f] were selected from the input, and were kept in the original sequence; then the fields from the set 2 (x,y,z) were selected from the input and were sorted in accordance with a sequence indicated in the rule; and then all elements from the set [1] were selected, and only then everything what was left there is indicated, which is subfield $2.