HELP — VMS 4.6
Additional information available:
:==@ACCOUNTINGALLOCATEANALYZE
APPENDASSIGNATTACHBACKUPCALLCANCELCLOSE
CONNECTCONTINUECONVERTCOPYCREATEDEALLOCATE
DEASSIGNDEBUGDECKDEFINEDELETEDEPOSITDIFFERENCES
DIRECTORYDISCONNECTDISMOUNTDUMPEDIT
ENCRYPTEODEOJEXAMINEEXCHANGEEXITFDL
GOSUBGOTOHELPIFINITIALIZEINQUIREJOB
LIBRARYLINKLOGINLOGOUTMACROMAILMERGE
MESSAGEMONITORMOUNTONOPENPASSWORDPATCH
PHONEPRINTPURGEREADRECALLRECOVERRENAME
REPLYREQUESTRETURNRMSRUNRUNOFFSEARCH
SETSHOWSORTSPAWNSTARTSTOPSUBMIT
SYNCHRONIZETYPEUNLOCKWAITWRITE
ErrorsHintsInstructionsLexicalsLine editingNewFeatures V44
QueuesRTL RoutinesSpecifySymbol AssignSystem Services
Errors
Errors are displayed in the format:
%facility-l-ident, text
facility is the name of the facility that produced the error (for
example, CLI for the Command Language Interpreter).
l is a one letter code indicating the severity of the error.
The severities are:
I - Informational E - Error
S - Success F - Severe error
W - Warning
ident is an abbreviation for the message text.
text is a short description of the nature of the error.
Hints
Type the name of one of the categories listed below to obtain a list of related commands and topics. To obtain detailed information on a topic, press the RETURN key until you reach the "Topic?" prompt and then type the name of the topic. Topics that appear in all upper case are DCL commands.
Additional information available:
Batch and print jobsCommand proceduresContacting peopleCreating processes
Developing programsExecuting programsFiles and directoriesLogical names
Physical devicesSystem managementTerminal environmentUser environment
Batch and print jobs
Submitting batch and print jobs and controlling batch and print queues. ASSIGN/MERGE Moves jobs from one queue to another. ASSIGN/QUEUE Assigns a queue to a device. DEASSIGN/QUEUE Deassigns a queue from a device. DELETE/ENTRY Deletes a job or jobs from a queue. DELETE/QUEUE Deletes a queue and all its jobs. INITIALIZE/QUEUE Creates and initializes a queue. PRINT Places a job in a print queue. SET QUEUE Changes the current status or attributes of a queue. SET QUEUE/ENTRY Changes the attributes of a job. SHOW PRINTER Displays default characteristics defined for a printer. SHOW QUEUE Displays the attributes of the jobs in a queue. START/QUEUE Starts or restarts a queue. STOP/QUEUE Stops a queue. SUBMIT Places a job in a batch queue. SYNCHRONIZE Suspends processing until a specified job completes. Type ? to display the list of HINTS. Type BATCH_AND_PRINT_JOBS to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Command procedures
Performing operations specific to command procedures. Lexical Describes functions that can be used in expressions. Procedure Describes how to invoke command procedures. Specify Describes valid values and expressions. Symbol_Assign Describes symbol assigments statements. DECK Marks the beginning of a special input stream. DELETE/SYMBOL Deletes one or more names from a symbol table. EOD Marks the end of a special input stream. EXIT Terminates a command procedure. GOTO Transfers control to a label in a command procedure. IF Executes a command only if an expression is true. INQUIRE Requests input and assigns the result to a symbol. ON Specifies an action to perform when a condition occurs. SET CONTROL Controls the use of the CTRL/T and CTRL/Y keys. SET ON Sets error checking on or off. SET RESTART_VALUE Sets the value of a batch job restart symbol. SET VERIFY Displays command input as it is read. SHOW SYMBOL Displays the value of a symbol. WAIT Suspends processing for a specified period of time. OPEN Makes a file available for reading or writing. CLOSE Terminates processing of a file. READ Reads and optionally deletes a record from an open file. WRITE Writes a record to an open file. Type ? to display the list of HINTS. Type COMMAND_PROCEDURES to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Contacting people
Communicating with other people using the system.
MAIL Sends/reads messages to/from other users.
PHONE Permits users to communicate by typing messages to
one another's terminal screens.
REPLY Displays a message on one or more terminal screens.
REQUEST Displays a message on the operator's console.
SHOW USERS Lists the interactive users on the system.
Type ? to display the list of HINTS.
Type CONTACTING_PEOPLE to redisplay this particular hint.
Press the RETURN key before typing a command or topic name.
Creating processes
Create and switch control between user processes. (Also see Batch_and_print_jobs) Login Initiates an interactive terminal session. LOGOUT Terminates an interactive terminal session. SET PASSWORD Changes your password. ANALYZE/PROCESS Analyzes a process dump. ATTACH Switches your terminal between SPAWNed processes. CONNECT Connects a physical terminal to a virtual terminal. DISCONNECT Disconnects a physical terminal from a virtual terminal. PRINT Creates a print job. RUN/PROCESS Creates a detached process or subprocess. SET HOST Connects your terminal to another system via DECnet. SHOW NETWORK Displays the nodes you can reach from your system. SPAWN Creates a subprocess with a similar environment. SUBMIT Creates a batch job. Type ? to display the list of HINTS. Type CREATING_PROCESSES to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Developing programs
Creating and debugging images. (Also see Executing_programs and Files_and_directories) ANALYZE/IMAGE Analyzes an image file. ANALYZE/OBJECT Analyzes an object module. DEBUG Invokes the symbolic debugger after a CTRL/Y. DEPOSIT Changes the contents of memory. DIFFERENCES Displays differences in content between two files. DUMP Displays the uninterpreted contents of a file. EDIT Creates (optionally) and edits a file. EXAMINE Displays the contents of memory. LIBRARY Creates or modifies various kinds of libraries. LINK Creates images from object modules. MACRO Creates object modules from macro source programs. MESSAGE Creates object modules from message source programs. PATCH Patches an image. RUN Runs an executable image. SET COMMAND Updates the commands available to the process. Type ? to display the list of HINTS. Type DEVELOPING_PROGRAMS to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Executing programs
Running executable images.
(Also see Developing_programs and Files_and_directories)
CANCEL Cancels a scheduled wakeup request.
CONTINUE Resumes execution of an interrupted command.
DEBUG Invokes the VAX/VMS Debugger after a CTRL/Y.
DEPOSIT Changes the contents of memory.
EXAMINE Displays the contents of memory.
EXIT Terminates execution of an image or command procedure.
RUN Runs an image.
SET COMMAND Updates the commands available to the process.
STOP Abruptly terminates execution of an image, process, or
command procedure.
Type ? to display the list of HINTS.
Type EXECUTING_PROGRAMS to redisplay this particular hint.
Press the RETURN key before typing a command or topic name.
Files and directories
Saving and cataloging information on storage devices. (Also see Developing_programs and Executing_programs) APPEND Appends one file to another. COPY Creates a copy of an existing file or files. CREATE Creates a new file. DELETE Deletes a file or files. DIFFERENCES Displays differences in content between two files. DIRECTORY Displays the names of the files in a directory. EDIT Creates (optionally) and edits a file. MERGE Merges sorted files. PRINT Prints the contents of a file. PURGE Deletes old versions of a file or files. RENAME Recataloges an existing file. SEARCH Locates a character string within a file or files. SORT Sorts the data in a file. TYPE Displays the contents of a file. SET DEFAULT Changes the default device and directory. SHOW DEFAULT Displays the default device and directory. ANALYZE/RMS_FILE Analyzes the internal structure of a file. CONVERT Changes the attributes of a file. CONVERT/RECLAIM Reclaims unused space in an indexed file. CREATE/DIRECTORY Creates a new directory or subdirectory. CREATE/FDL Creates a new file with tailored attributes. DUMP Displays the uninterpreted contents of a file. EDIT/FDL Creates a file definition file. EDIT/SUM Updates a file with multiple files of edit commands. EXCHANGE Reformats files formatted by other operating systems. LIBRARY Creates or modifies various kinds of libraries. RUNOFF Formats one or more documents (text files). SET DIRECTORY Changes the characterisitcs of a directory. SET FILE Changes the characteristics of a file. SET PROTECTION Changes the protection of a file. SET PROTECT/DEF Changes the default protection given to files. SET RMS_DEFAULT Changes the default block and buffer count values. SHOW PROTECTION Displays the default protection. SHOW QUOTA Displays your quota of space on a disk volume. SHOW RMS_DEFAULT Displays the default block and buffer count values. UNLOCK Closes a file accidentally left open. Type ? to display the list of HINTS. Type FILES_AND_DIRECTORIES to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Logical names
Using higher-level names in place of device and file names. (Also see Physical_devices) ASSIGN Equates a logical name to an equivalence string. CREATE/NAME_TABLE Creates a logical name table. DEASSIGN Deletes a logical name. DEFINE Equates a logical name to an equivalence string. SHOW LOGICAL Displays logical names and their equivalencies. SHOW TRANSLATION Displays a logical name and its first equivalence. Type ? to display the list of HINTS. Type LOGICAL_NAMES to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Physical devices
Using physical devices. (Also see Logical_names, and Terminal_environment) ALLOCATE Allocates a device for your exclusive use. DEALLOCATE Releases an allocated device for general use. DISMOUNT Makes a storage device unavailable for processing. INITIALIZE Formats a storage device. MOUNT Makes a storage device available for processing. ANALYZE/DISK Checks the readability and validity of disks. ANALYZE/ERROR_LOG Displays the contents of the system error log. ANALYZE/MEDIA Analyzes the format of a storage device. BACKUP Saves or restores files from storage devices. SET CARD_READER Sets the translation mode for a card reader. SET DEVICE Sets device characteristics. SET MAGTAPE Sets magnetic tape device characteristics. SET PRINTER Sets line printer characteristics. SET PROTECT/DEV Sets protection on a non-files device. SET VOLUME Sets mounted volume characteristics. SHOW DEVICES Displays the status of devices. SHOW ERROR Displays device error counts. SHOW MAGTAPE Displays magnetic tape characteristics. SHOW PRINTER Displays line printer characteristics. Type ? to display the list of HINTS. Type PHYSICAL_DEVICES to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
System management
Monitoring, maintaining, tuning, and trouble-shooting the system. (Also see Batch_and_print_jobs, Logical_names, and Physical_devices) ACCOUNTING Collects, records, and reports accounting information. ANALYZE/CRASH Analyzes a system dump. ANALYZE/DISK Checks the readability and validity of disks. ANALYZE/ERROR_LOG Displays the contents of the system error log. ANALYZE/MEDIA Analyzes the format of a storage device. ANALYZE/RMS_FILE Analyzes the internal structure of a file. ANALYZE/SYSTEM Analyzes the running system. BACKUP Saves or restores files from storage devices. MONITOR Displays performance information on the running system. REPLY Displays a message on one or more terminal screens. REQUEST Displays a message on the operator's console. SET ACCOUNTING Initializes the accounting log file. SET AUDIT Enables auditing of security events. SET COMMAND Updates the commands available to the system. SET DAY Changes the day type. SET LOGINS Sets a limit on the number of interactive users. SET TIME Resets the system clock. SHOW ERROR Displays processor, memory, and device error counts. SHOW MEMORY Displays usage information on memory. SHOW SYSTEM Lists the processes on the running system. SHOW USER Lists the interactive users on the running system. Type ? to display the list of HINTS. Type SYSTEM_MANAGEMENT to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Terminal environment
Manipulating your terminal-specific interactive environment (Also see Physical_devices) Line_editing Describes how to recall and edit commands. CONNECT Connects a physical terminal to a virtual terminal. DEFINE/KEY Equates terminal function keys to command lines. DELETE/KEY Deletes a terminal function key definition. DISCONNECT Disconnects a physical terminal from a virtual terminal. RECALL Recalls previously entered interactive commands. SET CONTROL Controls the use of the CTRL/T and CTRL/Y keys. SET HOST Connects your terminal to another system via DECnet. SET PROMPT Sets the interactive command prompt. SET TERMINAL Sets terminal characteristics. SHOW KEY Displays one or more function key definitions. SHOW TERMINAL Displays terminal characteristics. Type ? to display the list of HINTS. Type TERMINAL_ENVIRONMENT to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
User environment
Examining and controling the user environment. (Also see Logical_names, Physical_devices, and Terminal_environment) SET COMMAND Updates the commands available to the process. SET CONTROL Controls the use of the CTRL/T and CTRL/Y keys. SET DEFAULT Changes the default device and directory. SET HOST Connects your terminal to another system via DECnet. SET MESSAGE Overrides or supplements system messages. SET PASSWORD Changes your password. SET PROCESS Changes your process characteristics. SET PROMPT Sets the interactive command prompt. SET PROTECT/DEF Changes the default protection given to files. SET RMS_DEFAULT Changes the default block and buffer count values. SET UIC Changes the UIC of your process. SET WORKING_SET Changes your working set limit or quota. SHOW DEFAULT Displays the default device and directory. SHOW KEY Displays one or more function key definitions. SHOW LOGICAL Displays logical names and their equivalencies. SHOW PROCESS Displays your process characteristics. SHOW PROTECTION Displays the default protection. SHOW QUOTA Displays your quota of space on a disk volume. SHOW RMS_DEFAULT Displays the default block and buffer count values. SHOW STATUS Displays brief process characteristics. SHOW SYMBOL Displays the value of a symbol. SHOW TERMINAL Displays terminal characteristics. SHOW TIME Displays the current date and time. SHOW TRANSLATION Displays a logical name and its first equivalence. SHOW WORKING_SET Displays your working set limit and quota. Type ? to display the list of HINTS. Type USER_ENVIRONMENT to redisplay this particular hint. Press the RETURN key before typing a command or topic name.
Instructions
Invoking the HELP utility ------------------------- The HELP utility displays information about requested VMS topics. From DCL command level (in response to the $ prompt), you can display a list of topics for which help information is available by typing HELP and pressing the RETURN key. The system responds by displaying a brief description of how to use HELP, followed by a list of topics for which help is available, followed by the prompt "Topic?". You can exit from the HELP facility by typing CTRL/Z (that is, pressing the CONTROL and Z keys simultaneously) in response to any prompt. Specifying topic names ---------------------- To display information on a particular topic, respond to the prompt by typing the name of the topic and pressing the RETURN key. If you are not sure of the name of the topic for which you need help, type the name HINTS. To display information on all available topics, type an asterisk (*). To display all the information on a topic, type the topic name immediately follwed by an ellipsis (...), e.g., SHOW... You can specify percent signs (%) and asterisks (*) in the keyword as wild card (i.e., match all) characters. Abbreviations result in all matches being displayed. Subtopic information -------------------- The information displayed by HELP on a particular topic includes a description of the topic and a list of subtopics that further describe the topic. To display subtopic information, type one of the subtopic names from the list in response to the "Subtopic?" prompt. Special responses to prompts ---------------------------- If you press RETURN in response to the "Subtopic?" prompt instead of typing a subtopic name, the "Topic?" prompt reappears, enabling you to enter another topic name. If you press RETURN in response to the "Topic?" prompt, you will exit from HELP. You can type a question mark (?) in response to any of the prompts to to redisplay the most recently requested text and a list of topic or subtopic names. For example, if you type ? in response to the "Subtopic?" prompt, a list of subtopics is displayed followed by the "Subtopic?" prompt.
Lexicals
A set of functions that return information about character strings and attributes of the current process.
Additional information available:
F$CVSIF$CVTIMEF$CVUIF$DIRECTORYF$EDITF$ELEMENT
F$ENVIRONMENTF$EXTRACTF$FAOF$FILE_ATTRIBUTES
F$GETDVIF$GETJPIF$GETSYIF$IDENTIFIERF$INTEGERF$LENGTH
F$LOCATEF$MESSAGEF$MODEF$PARSEF$PIDF$PRIVILEGE
F$PROCESSF$SEARCHF$SETPRVF$STRINGF$TIMEF$TRNLNMF$TYPE
F$USERF$VERIFY
F$CVSI
Extracts bit fields from character string data and converts the
result, as a signed value, to an integer.
Format:
F$CVSI(bit-position,width,string)
Additional information available:
Return Valuebit-positionwidthstringExamples
Return Value
The integer equivalent of the extracted bit field, converted as a signed value.
bit-position
The offset of the first bit to be extracted. The low-order (rightmost) bit of a string is position number 0 for determining the offset. Specify the offset as an integer expression.
width
The number of bits that are to be extracted for conversion to an integer value. Specify the width as an integer expression.
string
The string from which the bits are taken. Specify the string as a character string expression.
Examples
1. $ A[0,32] = %X2B
$ SHOW SYMBOL A
A = "+"
$ X = F$CVSI(0,4,A)
$ SHOW SYMBOL X
X = -5 Hex = FFFFFFFB Octal = 177773
This example uses an arithmetic overlay to assign the hexadecimal
value 2B to all 32 bits of the symbol A. See the description of the
Assignment Statement for more information on arithmetic overlays.
The symbol A has a string value after the overlay because it was
previously undefined. (If a symbol is undefined, it has a string
value as a result of an arithmetic overlay. If a symbol was
previously defined, it retains the same data type after the overlay.)
The hexadecimal value 2B corresponds to the ASCII value of the plus
sign (+).
Next, the F$CVSI function extracts the low-order 4 bits from the
symbol A; the low order 4 bits contain the binary representation of
the hexadecimal value B. These bits are converted, as a signed
value, to an integer. The converted value, -5, is assigned to the
symbol X.
F$CVTIME
Converts an absolute or a combination time string to a string of the
form "yyyy-mm-dd hh:mm:ss.cc". The F$CVTIME function can also return
information about an absolute, combination, or delta time string.
Format:
F$CVTIME([input_time] [,output_time] [,field])
Additional information available:
Return Valueinput timeoutput timefieldExamples
Return Value
A character string containing the requested information.
input time
The time string for which information is requested. Specify the input time string as a character string expression. You can specify the input time string as an absolute, combination or delta time. If you omit the time argument or if you specify the time as a null string, the current date and time, in absolute time format, is used.
output time
The time format for the information you want returned. Specify the
output item argument as a character string expression that equates to
one of the following strings: ABSOLUTE The requested information
should be returned in absolute time format "dd-mmm-yyyy hh:mm:ss.cc".
COMPARISON The requested information should be returned in the form
"yyyy-mm-dd hh:mm:ss.cc". DELTA The requested information should be
returned in delta format. If you specify DELTA as the output time
argument, then you must also provide a delta time specification for
the input time argument.
ABSOLUTE The requested information should be returned in absolute
time format.
COMPARISON The requested information should be returned in the form
"yyyy-mm-dd hh:mm:ss.cc".
DELTA The requested information should be returned in delta
format. If you specify DELTA as the output time
argument, then you must also provide a delta time
specification for the input time argument.
If you omit the output time argument, the default is COMPARISON.
field
The type of information to be returned. The information is returned
in the time format specified by the output time argument.
Specify the field argument as a character string expression that
evaluates to one of the following strings:
DATE The date field is returned.
DATETIME The entire date and time string is returned.
DAY The day field is returned.
HOUR The hour field is returned.
HUNDREDTH The hundredth of a second field is returned.
MINUTE The minute field is returned.
MONTH The month field is returned. You cannot specify MONTH if
you also specify a delta input time and the DELTA output
time argument.
SECOND The second field is returned.
TIME The time field is returned.
WEEKDAY The weekday that corresponds with the input time argument
is returned. You cannot specify WEEKDAY if you also
specify a delta input time and the DELTA output time
argument. When the weekday is returned, the first letter
is in uppercase, and the following letters are in
lowercase.
YEAR The year field is returned. You cannot specify YEAR if
you also specify a delta input time and the DELTA output
time argument.
If you do not specify a field argument, the default is DATETIME.
Examples
1. $ TIME = F$TIME()
$ SHOW SYMBOL TIME
TIME = "15-APR-1984 10:56:23.10"
$ TIME = F$CVTIME(TIME)
$ SHOW SYMBOL TIME
TIME = "1984-04-15 10:56:23.10"
This example uses the F$TIME function to return the system time as a
character string, and to assign the time to the symbol TIME. Then
the F$CVTIME function is used to convert the system time to an
alternate time format. Note that you do not need to place quotation
marks around the argument TIME because it is a symbol. Symbols are
automatically evaluated when they are used as arguments for lexical
functions.
You can use the resultant string to compare two dates (using .LTS.
and .GTS. operators). For example, you can use F$CVTIME to convert
two time strings and store the results in the symbols TIME_1 and
TIME_2. You can compare the two values, and branch to a label, based
on the results as shown below:
$ IF TIME_1 .LTS. TIME_2 THEN GOTO FIRST
2. $ NEXT = F$CVTIME("TOMORROW",,"WEEKDAY")
$ SHOW SYMBOL NEXT
NEXT = "Tuesday"
In this example, the F$CVTIME returns the weekday that corresponds to
the absolute time keyword "TOMORROW". You must enclose the arguments
"TOMORROW" and "WEEKDAY" in quotation marks because they are
character string expressions. Also, you must include a comma as a
placeholder for the output time argument that is omitted.
F$CVUI
Extracts bit fields from character string data and converts the
result, as an unsigned value, to an integer.
Format:
F$CVUI(bit-position,width,string)
Additional information available:
Return Valuebit-positionwidthstringExample
Return Value
The integer equivalent of the extracted bit field, converted as an unsigned value.
bit-position
The offset of the first bit to be extracted. The low-order (rightmost) bit of a string is position number 0 for determining the offset. Specify the offset as an integer expression.
width
The number of bits that are to be extracted for conversion to an integer value. Specify the width as an integer expression.
string
The string from which the bits are taken. Specify the string as a character string expression.
Example
1. $ A[0,32] = %X2B
$ SHOW SYMBOL A
A = "+"
$ X = F$CVUI(0,4,A)
$ SHOW SYMBOL X
X = 11 Hex = 0000000B Octal = 000013
This example uses an arithmetic overlay to assign the hexadecimal
value 2B to all 32 bits of the symbol A. The symbol A has a string
value after the overlay because it was previously undefined. (If a
symbol is undefined, it has a string value as a result of an
arithmetic overlay. If a symbol was previously defined, it retains
the same data type after the overlay.) The hexadecimal value 2B
corresponds to the ASCII character "+".
Next, the F$CVUI function extracts the low-order 4 bits from the
symbol A; the low-order 4 bits contain the binary representation of
the hexadecimal value B. These bits are converted, as a signed
value, to an integer. The converted value, 11, is assigned to the
symbol X.
F$DIRECTORY
Returns the current default directory name string. The F$DIRECTORY
function has no arguments but must be followed by parentheses.
Format:
F$DIRECTORY()
Additional information available:
Return Value
A character string for the current default directory name, including square brackets ([]). If you use the SET DEFAULT command and specify angle brackets (<>) in a directory specification, the F$DIRECTORY function returns angle brackets in the directory string.
example
1. $ SAVE_DIR = F$DIRECTORY()
$ SET DEFAULT [MALCOLM.TESTFILES]
.
.
.
$ SET DEFAULT 'SAVE_DIR'
This example shows an excerpt from a command procedure that uses the
F$DIRECTORY function to save the current default directory setting.
The assignment statement equates the symbol SAVE_DIR to the current
directory. Then the SET DEFAULT command establishes a new default
directory. Later, the symbol SAVE_DIR is used in the SET DEFAULT
command that restores the original default directory.
Note that you can use the F$ENVIRONMENT function with the DEFAULT
keyword to return the default disk and directory. You should use the
F$ENVIRONMENT function rather than the F$DIRECTORY function in
situations involving more than one disk.
F$EDIT
Edits a string expression based on the edits specified in the
edit-list.
Format:
F$EDIT(string, edit-list)
Additional information available:
Return Valuestringedit-listExamples
Return Value
A character string containing the specified edits.
string
A string to be edited. Specify the string argument as a character string expression.
edit-list
A keyword or a list of keywords that specify the types of edits to be
made to the string. If you use a list of keywords, separate them
with commas. You cannot abbreviate these keywords.
Specify the edit-list argument as a character string expression.
COLLAPSE Removes all spaces and tabs from the string.
COMPRESS Replaces multiple spaces and tabs with a single space.
LOWERCASE Makes the string lower case.
TRIM Removes leading and trailing spaces and tabs from the
string.
UNCOMMENT Removes comments from the string.
UPCASE Makes the string upper case.
Edits are not applied to quoted sections of strings. Therefore, if a
string contains quotation marks, the characters within the quotation
marks are not affected by the edits specified in the edit list.
Examples
1. $ LINE = " THIS LINE CONTAINS A "" QUOTED "" WORD"
$ SHOW SYMBOL LINE
LINE = " THIS LINE CONTAINS A " QUOTED " WORD"
$ NEW_LINE = F$EDIT(LINE, "COMPRESS, TRIM")
$ SHOW SYMBOL NEW_LINE
NEW_LINE = "THIS LINE CONTAINS A " QUOTED " WORD"
This example uses the F$EDIT function to compress and trim a string
by replacing multiple blanks with a single blank, and by removing
leading and trailing blanks. The string LINE contains quotation
marks around the word QUOTED. (To enter quotation marks into a
character string, use double quotations in the assignment statement.)
Note that the F$EDIT function does not compress the spaces in the
quoted section of the string; therefore, the spaces are retained
around the word QUOTED.
2. $ LOOP:
$ READ/END_OF_FILE = DONE INPUT_FILE RECORD
$ RECORD = F$EDIT(RECORD, "TRIM, UPCASE")
$ WRITE OUTPUT_FILE RECORD
$ GOTO LOOP
.
.
.
This example sets up a loop to read records from a file, edit them,
and write them to an output file. The edited records have leading
and trailing blanks removed, and are converted to uppercase.
F$ELEMENT
Extracts an element from a string in which the elements are separated
by a specified delimiter.
Format:
F$ELEMENT(element-number, delimiter, string)
Additional information available:
Return Valueelement-numberdelimiterstringExample
Return Value
A character string containing the specified element.
element-number
The number of the element to be retrieved. Element numbers start with zero. Specify the element-number argument as an integer expression. If the element-number exceeds the number of elements in the string, the delimiter is returned.
delimiter
The delimiter used to separate the elements in the string. The delimiter can be only one character long. Specify the delimiter as a character string expression.
string
A string containing a delimited list of elements. Specify the string as a character string expression.
Example
1. $ DAY_LIST = "MON/TUE/WED/THU/FRI/SAT/SUN"
$ INQUIRE DAY "ENTER DAY (MON TUE WED THU FRI SAT SUN)"
$ NUM = 0
$ LOOP:
$ LABEL = F$ELEMENT(NUM,"/",DAY_LIST)
$ IF LABEL .EQS. "/" THEN GOTO ERROR
$ IF DAY .EQS. LABEL THEN GOTO 'LABEL'
$ NUM = NUM +1
$ GOTO LOOP
$
$ MON:
.
.
.
This example sets up a loop to test an input value against the
elements in a list of values. If the value for DAY matches one of
the elements in DAY_LIST, control is passed to the corresponding
label. If the value returned by the F$ELEMENT function matches the
delimiter, then the value DAY was not present in the DAY_LIST, and
control is passed to the label ERROR.
F$ENVIRONMENT
Obtains information on aspects of the DCL command environment.
Format:
F$ENVIRONMENT(item)
Additional information available:
Return Value
Information that corresponds to the specified item. The return value can be either an integer or a character string, depending on the specified item.
item
A keyword that specifies the type of information to be returned. You
cannot abbreviate keywords for the F$ENVIRONMENT lexical function.
Specify the item argument as a character string expression.
CAPTIVE Returns either the character string "TRUE" or "FALSE"
to indicate whether you are logged into a captive
account.
CONTROL Returns the control characters that are currently
enabled with the SET CONTROL command. The control
characters are returned as a character string.
DEFAULT Returns the current default device and directory
name. This information is returned as a character
string; the returned string is the same as the
output from the SHOW DEFAULT command.
DEPTH Returns the current command procedure depth, as an
integer.
INTERACTIVE Returns either the character string "TRUE" or "FALSE"
to indicate whether the process is interactive.
KEY_STATE Returns a character string indicating the current
locked keypad state.
MAX_DEPTH Returns an integer specifying the maximum allowable
command procedure depth.
MESSAGE Returns a character string containing the current
setting of the the SET MESSAGE command.
NOCONTROL Returns the control characters that are currently
disabled with the SET NOCONTROL command. The
control characters are returned as a character
string.
ON_CONTROL_Y If issued from a command procedure, returns either
the character string "TRUE" or "FALSE" to indicate
whether ON CONTROL_Y is specified.
ON_SEVERITY If issued from a command procedure, returns a
character string indicating the severity level at
which the action specified with the ON command is
taken.
OUTPUT_RATE Returns a delta time string containing the default
output rate. The output rate indicates how often
data is written to a batch job log file while the
batch job is executing.
PROCEDURE Returns the file specification for the command
procedure from which the F$ENVIRONMENT("PROCEDURE")
function is issued. The file specification is
returned as a character string.
PROMPT Returns a character string containing the current
prompt string.
PROMPT_CONTROL Returns either the character string "TRUE" or "FALSE"
to indicate whether a Carriage Return/Line Feed
precedes the prompt.
PROTECTION Returns a character string indicating the current
default file protection.
SYMBOL_SCOPE Returns the character string "[NO]LOCAL, [NO]GLOBAL"
to indicate the current symbol scoping state.
VERIFY_IMAGE Returns either the character string "TRUE" or "FALSE"
to indicate whether the SET VERIFY=IMAGE command is
in effect.
VERIFY_PROCEDURE Returns either the character string "TRUE" or
"FALSE" to indicate whether the SET VERIFY=PROCEDURE
command is in effect.
Examples
1. $ SAVE_MESSAGE = F$ENVIRONMENT("MESSAGE")
$ SET MESSAGE/NOFACILITY/NOIDENTIFICATION
.
.
.
$ SET MESSAGE'SAVE_MESSAGE'
This example uses the F$ENVIRONMENT function to save the current
message setting before changing the setting. At the end of the
command procedure, the original message setting is restored. The
apostrophes surrounding the symbol SAVE_MESSAGE indicate that the
value for the symbol should be substituted.
2. $ MAX = F$ENVIRONMENT("MAX_DEPTH")
$ SHOW SYMBOL MAX
MAX = 16 Hex = 00000010 Octal = 000020
This example uses the F$ENVIRONMENT function to determine the maximum
depth allowable within command procedures.
3. $ SAVE_PROT = F$ENVIRONMENT("PROTECTION")
$ SET PROTECTION = (SYSTEM:RWED,OWNER:RWED,GROUP,WORLD)/DEFAULT
.
.
.
$ SET PROTECTION = ('SAVE_PROT')/DEFAULT
This example uses the F$ENVIRONMENT function to save the current
default protection before changing the protection. At the end of the
command procedure, the original protection is restored. You must
place apostrophes around the symbol SAVE_PROT to request symbol
substitution.
F$EXTRACT
Extracts a substring from a character string expression.
Format:
F$EXTRACT(offset,length,string)
Additional information available:
Return ValueoffsetlengthstringExamples
Return Value
A character string containing the substring that is delimited by the offset and length arguments.
offset
The position, relative to the beginning of the string, that marks the beginning of the substring you want to extract. Specify the offset as an integer expression that is greater than or equal to 0. The offset 0 indicates the first character in the string.
length
The number of characters you want to extract. Specify the length as an integer expression that is greater than or equal to 0.
string
The string from which the substring is to be extracted. Specify the string as a character string expression.
Examples
1. $ NAME = "JOE SMITH"
$ FIRST = F$EXTRACT(0,3,NAME)
$ SHOW SYMBOL FIRST
FIRST = "JOE"
This portion of a command procedure uses the F$EXTRACT function to
extract the first three characters from the character string assigned
to the symbol NAME. The offset and length arguments are integers,
and the string argument is a symbol. You do not need to use
quotations around integers or symbols when they are used as arguments
for lexical functions.
2. $ P1 = "MYFILE.DAT"
$ FILENAME = F$EXTRACT(0,F$LOCATE(".",P1),P1)
This portion of a command procedure shows how to locate a character
within a string, and how to extract a substring ending at that
location.
The lexical function F$LOCATE gives the numeric value representing
the offset position of a period in the character string value of P1.
(The offset position of the period is equal to the length of the
substring before the period.)
This F$LOCATE function is used as an argument in the F$EXTRACT
function to specify the number of characters to extract from the
string. If a procedure is invoked with the parameter MYFILE.DAT,
these statements result in the symbol FILENAME being given the value
MYFILE.
Note that the F$LOCATE function in the above example assumes that the
file specification does not contain a node name or a directory
specification containing a subdirectory name. To obtain the file
name from a full file specification, use the F$PARSE function.
3. $ IF F$EXTRACT(12,2,F$TIME()) .GES. "12" THEN GOTO AFTERNOON
$ MORNING:
$ WRITE SYS$OUTPUT "Good morning!"
$ EXIT
$ AFTERNOON:
$ WRITE SYS$OUTPUT "Good afternoon!"
$ EXIT
This example shows a procedure that displays a different message,
depending on whether the current time is morning or afternoon. It
first obtains the current time of day by using the F$TIME function.
The F$TIME function returns a character string, which is the string
argument for the F$EXTRACT function. The F$TIME function is
automatically evaluated when it is used as an argument, so you do not
need to use quotation marks.
Next, the F$EXTRACT function extracts the hours from the date and
time string returned by F$TIME. The string returned by F$TIME always
contains the hours field beginning at an offset of 12 characters from
the start of the string.
The F$EXTRACT function extracts two characters from the string,
beginning at this offset, and compares the string value extracted
with the string value 12. If the comparison is true, then the
procedure writes "Good afternoon!". Otherwise, it writes "Good
morning!".
Note that you can also use the F$CVTIME function to extract the hour
field from a time specification. This method is easier than the one
shown in the above example.
F$FAO
Invokes the $FAO system service to convert the specified control
string to a formatted ASCII output string. By specifying arguments
for FAO directives in the control string, you can use the F$FAO
function to:
o Insert variable character string data into an output string
o Convert integer values into the ASCII representations of their
decimal, hexadecimal, and octal equivalents, and substitute the
results into the output string
Format:
F$FAO(control-string[,arg1,arg2...arg15])
Additional information available:
Return Valuecontrol-stringarg1,arg2...arg15Examples
Return Value
A character string containing formatted ASCII output. This output string is created from the fixed text and FAO directives in the control string.
control-string
The fixed text of the output string, plus FAO directives. The control string may be any length and may contain any number of FAO directives. Specify the control string as a character string expression. The F$FAO function uses FAO directives to modify or insert ASCII data into the fixed text in the control string.
arg1,arg2...arg15
Arguments that are required by the FAO directives used in the control string. Specify the arguments arg1,arg2...arg15 as integer or character string expressions. If you specify an argument whose type (integer or string) does not match that of the corresponding directive, unpredictable results will be returned.
Examples
1. $ COUNT = 57
$ REPORT = F$FAO("NUMBER OF FORMS = !SL",COUNT)
$ SHOW SYMBOL REPORT
$ REPORT = "NUMBER OF FORMS = 57"
In this command procedure, the FAO directive !SL is used in a control
string to convert the number equated to the symbol COUNT to a
character string. The converted string is inserted into the control
string.
Note that COUNT is assigned an integer value of 57. The F$FAO
function returns the ASCII string, "NUMBER OF FORMS = 57", and
assigns the string to the symbol REPORT.
2. $ A = "ERR"
$ B = "IS"
$ C = "HUM"
$ D = "AN"
$ PHRASE = F$FAO("TO !3(AS)",A,B,C+D)
$ SHOW SYMBOL PHRASE
$ PHRASE = "TO ERRISHUMAN"
In this command procedure, the !AS directive is used to insert the
values assigned to the symbols A, B, C, and D into the control
string.
Since the specified repeat count for the !AS directive is 3, F$FAO
looks for three arguments. The arguments in this example include the
symbol A ("ERR"), the symbol B ("IS"), and the expression C+D
("HUMAN"). Note that the values of these string arguments are
concatenated to form the string "ERRISHUMAN".
3. $ A = "ERR"
$ B = "IS"
$ C = "HUMAN"
$ PHRASE = F$FAO("TO !#(#AS)",3,6,A,B,C)
$ SHOW SYMBOL PHRASE
$ PHRASE = "TO ERR IS HUMAN "
In this command procedure, the F$FAO function is used with the !AS
directive to format a character string. The first number sign (#)
represents the repeat count given by the first argument, 3. The
second number sign (#) represents the field size given by the second
argument, 6. The next three arguments (A,B,C) provide the strings
that are placed into the control string each time the !AS directive
is repeated.
Each argument string is output to a field having a length of six
characters. Since each string is less than six characters, each
field is left-justified and padded with blank spaces. The resulting
string is assigned to the symbol PHRASE.
F$FILE_ATTRIBUTES
Returns attribute information for a specified file.
Format:
F$FILE_ATTRIBUTES(file-spec,item)
Additional information available:
Return Valuefile-specitemExamples
Return Value
Either an integer or a character string, depending on the item you request.
file-spec
The name of the file about which you are requesting information. You must specify the file name as a character string expression. Only one file name may be specified. No wildcard characters are allowed in the file specification.
item
Indicates which attribute of the file is to be returned. The item must be specified as a character string expression, and can be any one of the VAX RMS field names listed below: ALQ BDT BKS BLS CBT CDT CTG DEQ DID DVI EDT EOF FID FSZ GRP KNOWN MBM MRN MRS NOA NOK ORG PRO PVN RAT RCK RDT RFM RVN UIC WCK
Examples
1. $ FILE_ORG = F$FILE_ATTRIBUTES("QUEST.DAT","ORG")
$ SHOW SYMBOL FILE_ORG
FILE_ORG = "SEQ"
This example uses the F$FILE_ATTRIBUTES function to assign the value
of the file organization type to the symbol FILE_ORG. The
F$FILE_ATTRIBUTES function returns the character string "SEQ" to show
that QUEST.DAT is a sequential file.
The QUEST.DAT and ORG arguments for the F$FILE_ATTRIBUTES function
are string literals, and must be enclosed in quotation marks when
used in expressions.
2. $ RFM = F$FILE_ATTRIBUTES("KANSAS::USE$:[CARS]SALES.CMD","RFM")
$ SHOW SYMBOL RFM
RFM = "VAR"
This example uses the F$FILE_ATTRIBUTES function to return
information about a file on a remote node. The function returns the
record format string VAR, indicating that records are variable
length.
F$GETDVI
Invokes the $GETDVI system service to return a specified item of
information for a specified device. This function allows a process
to obtain information for a device to which the process has not
necessarily assigned a channel.
Format:
F$GETDVI(device-name,item)
Additional information available:
Return Valuedevice-nameitemExample
Return Value
Either an integer or a character string, depending on the item you request.
device-name
A physical device name or a logical name equated to a physical device name. Specify the device name as a character string expression.
item
Specifies the type of device information to be returned. The item
must be specified as a character string expression. Specifies the
type of device information to be returned. The item must be
specified as a character string expression. You may specify any one
of the items listed below:
ACPPID ACPTYPE ALL ALLOCLASS
ALT_HOST_AVAIL ALT_HOST_NAME ALT_HOST_TYPE AVL
CCL CLUSTER CONCEALED CYLINDERS
DEVBUFSIZ DEVCHAR DEVCHAR2 DEVCLASS
DEVDEPEND DEVDEPEND2 DEVNAM DEVSTS
DEVTYPE DIR DMT DUA
ELG ERRCNT EXISTS FOD
FOR FREEBLOCKS FULLDEVNAM GEN
HOST_AVAIL HOST_COUNT HOST_NAME HOST_TYPE
IDV LOCKID LOGVOLNAM MAXBLOCK
MAXFILES MBX MNT MOUNTCNT
NET NEXTDEVNAM ODV OPCNT
OPR OWNUIC PID RCK
RCT REC RECSIZ REFCNT
REMOTE_DEVICE RND ROOTDEVNAM RTM
SDI SECTORS SERIALNUM SERVED_DEVICE
SHR SPL SPLDEVNAM SQD
STS SWL TRACKS TRANSCNT
TRM TT_ALTYPEAHD TT_ANSICRT TT_APP_KEYPAD
TT_AUTOBAUD TT_AVO TT_BLOCK TT_BRDCSTMBX
TT_CRFILL TT_DECCRT TT_DIALUP TT_DISCONNECT
TT_DMA TT_DRCS TT_EDIT TT_EDITING
TT_EIGHTBIT TT_ESCAPE TT_FALLBACK TT_HALFDUP
TT_HANGUP TT_HOSTSYNC TT_INSERT TT_LFFILL
TT_LOCALECHO TT_LOWER TT_MBXDSABL TT_MECHFORM
TT_MECHTAB TT_MODEM TT_MODHANGUP TT_NOBRDCST
TT_NOECHO TT_NOTYPEAHD TT_OPER TT_PAGE
TT_PASTHRU TT_PHYDEVNAM TT_PRINTER TT_READSYNC
TT_REGIS TT_REMOTE TT_SCOPE TT_SECURE
TT_SETSPEED TT_SIXEL TT_TTSYNC TT_WRAP
UNIT VOLCOUNT VOLNAM VPROT
WCK
The following F$GETDVI items apply to Volume Shadowing only:
SHDW_CATCHUP_COPYING SHDW_FAILED_MEMBER
SHDW_MASTER SHDW_MASTER_NAME
SHDW_MEMBER SHDW_MERGE_COPYING
SHDW_NEXT_MBR_NAME
Example
1. $ ERR = F$GETDVI("_DQA0","ERRCNT")
$ SHOW SYMBOL ERR
ERR = 0 Hex = 00000000 Octal = 000000
This example shows how to use the F$GETDVI function to return an
error count for the device DQA0. You must place quotation marks
around the device-name _DQA0 and the item ERRCNT because they are
string literals.
F$GETJPI
Invokes the $GETJPI system service to return accounting, status, and
identification information on the specified process. GROUP privilege
is required to obtain information on other processes in the same
group. WORLD privilege is required to obtain information on any
other processes in the system.
Format:
F$GETJPI(pid,item)
Additional information available:
Return Value
Either an integer or a character string, depending on the item you request.
pid
The identification number of the process for which information is being reported. Specify the pid argument as a character string expression.
item
The type of process information to be returned. Specify the item
argument as a character string expression. You may specify any one
of the following items:
ACCOUNT APTCNT ASTACT ASTCNT ASTEN
ASTLM ASTPEN AUTHPRI AUTHPRIV BATCH
BIOCNT BIOLM BUFIO BYTCNT BYTLM
CPULIM CPUTIM CURPRIV DELPEN DFPFC
DFWSCNT DIOCNT DIOLM DIRIO DISAWS
EFCS EFCU EFWM ENQCNT ENQLM
EXCVEC FILCNT FILLM FINALEXC FORCPEN
FREP0VA FREP1VA FREPTECNT GPGCNT GRP
HIBER IMAGECOUNT IMAGNAME IMAGPRIV INQUAN
JOBPRCCNT LOGIN LOGINTIM MEM MODE
MSGMASK MASTER_PID OWNER PAGEFLTS PAGFILCNT
PAGFILLOC PGFLQUOTA PHDFLAGS PHDRES PID
PPGCNT PRCCNT PRCLM PRCNAM PRI
PRIB PROCPRIV PSWAPM PWRAST RES
RESPEN SITESPEC SSFEXC SSFEXE SSFEXCS
SSFEXCU SSRWAIT STATE STS SUSPEN
SWPFILLOC SWPVBN RES TERMINAL TMBU
TQCNT TQLM UIC USERNAME VIRTPEAK
VOLUMES WAKEPEN WALL WSAUTH WSAUTHEXT
WSEXTENT WSPEAK WSQUOTA WSSIZE
Example
1. $ NAME = F$GETJPI("3B0018","USERNAME")
$ SHOW SYMBOL NAME
NAME = "JANE "
This example shows how to use the F$GETJPI function to return the
username for the process number 3B0018. The username is assigned to
the symbol NAME.
F$GETSYI
Invokes the $GETSYI system service to return status and
identification information about the local system (or about a node in
the local VAXcluster, if your system is part of a VAXcluster).
Format:
F$GETSYI(item [,node])
Additional information available:
Return Value
Either an integer or a character string, depending on the item you request.
item
The type of information to be reported about the local node (or about another node in your VAXcluster, if your system is part of a VAXcluster). Specify the item as a character string expression.
node
The node in your VAXcluster for which information is to be returned.
Specify the node as a character string expression. (This argument
can be specified only if your system is part of a VAXcluster.) You
may specify one of the following items for the local node only:
ARCHFLAG BOOTTIME CHARACTER_EMULATED
CPU DECIMAL_EMULATED D_FLOAT_EMULATED
F_FLOAT_EMULATED G_FLOAT_EMULATED PAGEFILE_FREE
PAGEFILE_PAGE SID SWAPFILE_FREE
SWAPFILE_PAGE VERSION
You may specify one of the following items for the local node or in
the VAXCluster:
CLUSTER_FSYSID CLUSTER_FTIME CLUSTER_MEMBER
CLUSTER_NODES CLUSTER_QUORUM CLUSTER_VOTES
NODENAME NODE_AREA NODE_CSID
NODE_HWTYPE NODE_HWVERS NODE_NUMBER
NODE_QUORUM NODE_SWINCARN NODE_SWTYPE
NODE_SWVERS NODE_SYSTEMID NODE_VOTES
SCS_EXISTS
Examples
1. $ SYSID = F$GETSYI("SID")
$ SHOW SYMBOL SYSID
SID = 19923201 Hex = 01300101 Octal = 000401
This example shows how to use the F$GETSYI function to return the
information in the system identification register. Use quotation
marks around the argument SID because it is a string literal. The
value returned by the F$GETSYI function is assigned to the symbol
SYSID. Because a node is not specified, information about your
current node is returned.
2. $ MEM = F$GETSYI("CLUSTER_MEMBER", "LONDON")
$ SHOW SYMBOL MEM
MEM = "TRUE"
This example uses the F$GETSYI function to determine whether the node
LONDON is a member of the local VAXcluster. The "TRUE" indicates
that the remote node LONDON is a member of the VAXcluster.
3. $ LIM = F$GETSYI("BJOBLIM")
$ SHOW SYMBOL LIM
LIM = 16 Hex = 00000010 Octal = 00000000020
This example uses the SYSGEN parameter BJOBLIM as as argument for the
F$GETSYI function. This argument returns the batch job limit for the
current system.
F$IDENTIFIER
Converts an identifier in named format to its integer equivalent, or
vice versa. An identifier is a name or number that identifies a
category of users of a data resource. The system uses identifiers to
determine a user's access to a resource.
Format:
F$IDENTIFIER(identifier,conversion-type)
Additional information available:
Return Valueidentifierconversion-typeExamples
Return Value
An integer value if you are converting an identifier from a name to an integer. The F$IDENTIFIER function returns a string if you are converting an identifier from an integer to a name. If you specify an identifier that is not valid, the F$IDENTIFIER function returns a null string (if you are converting from number to name) or a zero (if you are converting from name to number.)
identifier
The identifier to be converted. Specify the identifier as an integer expression if you are converting an integer to a name. Specify the identifier as a character string expression if you are converting a name to an integer. The F$IDENTIFIER function does not convert letters in the identifier to uppercase. Therefore, you must specify the identifier the same way it is defined in the "rights database". If the identifier is defined using uppercase letters, you must use uppercase letters when you specify the identifier for the F$IDENTIFIER function.
conversion-type
The type of conversion to be performed. Specify the conversion type as a character string expression that evaluates to one of the following strings: "NAME_TO_NUMBER" or "NUMBER_TO_NAME".
Examples
1. $ UIC_INT= F$IDENTIFIER("SLOANE","NAME_TO_NUMBER")
$ SHOW SYMBOL UIC_INT
UIC_INT = 15728665 Hex = 00F00019 Octal = 00074000031
$ UIC = F$FAO("!%U",UIC_INT)
$ SHOW SYMBOL UIC
UIC = [360,031]
This example uses the F$IDENTIFIER to convert the member identifier
from the UIC [MANAGERS,SLOANE] to an integer. The F$IDENTIFIER
function shows that the member identifier SLOANE is equivalent to the
integer 15728665. Note that you must specify the identifier SLOANE
using uppercase letters.
To convert this octal number to a standard numeric UIC, use the F$FAO
function with the !%U directive. (This directive converts a longword
to a UIC in named format.) In this example, the member identifier
SLOANE is equivalent to the numeric UIC [360,031].
2. $ UIC_INT = (%O31 + (%X10000 * %O360))
$ UIC_NAME = F$IDENTIFIER(UIC_INT,"NUMBER_TO_NAME")
$ SHOW SYMBOL UIC_NAME
UIC_NAME = "ODONNELL"
This example obtains the alphanumeric identifier associated with the
numeric UIC [360,031]. First, you must obtain the longword integer
that corresponds to the UIC [360,031]. To do this, place the member
number into the low order word, and place the group number into the
high order word. Next, use the F$IDENTIFIER function to return the
named identifier associated with the integer.
F$INTEGER
Returns the integer equivalent of the result of the specified
expression.
Format:
F$INTEGER(expression)
Additional information available:
Return Value
An integer value which is equivalent to the specified expression.
expression
The expression to be evaluated by the F$INTEGER expression. You can specify either an integer or a character string expression.
Example
1. $ A = "23"
$ B = F$INTEGER("-9" + A)
$ SHOW SYMBOL B
B = -923 Hex=FFFFFC65 Octal=176145
This example shows how to use the F$INTEGER function to equate a
symbol to the integer value returned by the function.
The F$INTEGER function in the above example returns the integer
equivalent of the string expression ("-9" + A). First, the
F$INTEGER function evaluates the string expression by concatenating
the string literal "-9" with the string literal "23". Note that the
value of the symbol A is automatically substituted in a string
expression. Also note that the plus sign (+) is a string
concatenation operator since both arguments are string literals.
After the string expression is evaluated, the F$INTEGER function
converts the resulting character string ("-923") to an integer, and
returns the value -923. This integer value is assigned to the
symbol B.
F$LENGTH
Returns the length of a specified string.
Format:
F$LENGTH(string)
Additional information available:
Return Value
An integer value for the length of the string.
string
The character string of which you are determining the length. Specify the string argument as a character string expression.
Example
1. $ MESSAGE = F$MESSAGE(%X1C)
$ SHOW SYMBOL MESSAGE
MESSAGE = "%SYSTEM-F-EXQUOTA, exceeded quota"
$ STRING_LENGTH = F$LENGTH(MESSAGE)
$ SHOW SYMBOL STRING_LENGTH
STRING_LENGTH = 33 Hex = 00000021 Octal = 000041
The first assignment statement uses the F$MESSAGE function to return
the message which corresponds to the hexadecimal value 1C. The
message is returned as a character string and is assigned to the
symbol MESSAGE.
The F$LENGTH function is then used to return the length of the
character string assigned to the symbol MESSAGE. You do not need to
use quotation marks when you use the symbol MESSAGE as an argument
for the F$LENGTH function. (Quotation marks are not used around
symbols in character string expressions.)
The F$LENGTH function returns the length of the character string and
assigns it to the symbol STRING_LENGTH. At the end of the example,
the symbol STRING_LENGTH has a value equal to the number of
characters in the value of the symbol named MESSAGE, that is, 33.
F$LOCATE
Locates a character or character substring within a string and
returns its offset within the string. If the character or character
substring is not found, the function returns the length of the string
that was searched.
Format:
F$LOCATE(substring,string)
Additional information available:
Return ValuesubstringstringExamples
Return Value
An integer value representing the offset of the substring argument. An offset is the position of a character or a substring relative to the beginning of the string. The first character in a string is always offset position 0 from the beginning of the string (which always begins at the leftmost character). If the substring argument is not found, the F$LOCATE function returns an offset of 1 more than the offset of the last character in the string. (This equals the length of the string.)
substring
The string of characters that you want to locate within the string. Specify the substring as a character string expression.
string
The string in which the characters are to be found. Specify the string as a character string expression.
Examples
1. $ FILE_SPEC = "MYFILE.DAT;1"
$ NAME_LENGTH = F$LOCATE(".",FILE_SPEC)
The F$LOCATE function in this example returns the position of the
period in the string with respect to the beginning of the string.
The period is in offset position 6, so the value 6 is assigned to the
symbol NAME_LENGTH. Note that NAME_LENGTH also equals the length of
the file name portion of the file specification MYFILE.DAT, that is,
6.
The substring argument, the period, is specified as a string literal
and is therefore enclosed in quotation marks. The argument FILE_SPEC
is a symbol, so it should not be placed within quotation marks. It
is automatically replaced by its current value during the processing
of the function.
2. $ INQUIRE TIME "Enter time"
$ IF F$LOCATE(":",TIME) .EQ. F$LENGTH(TIME) THEN -
GOTO NO_COLON
This section of a command procedure compares the results of the
F$LOCATE and F$LENGTH functions to see if they are equal. This
technique is commonly used to determine whether a character or
substring is contained in a string.
In the example, the INQUIRE command prompts for a time value and
assigns the user-supplied time to the symbol TIME. The IF command
checks for the presence of a colon in the string entered in response
to the prompt. If the value returned by the F$LOCATE function equals
the value returned by the F$LENGTH function, the colon is not
present. You use the .EQ. operator (rather than .EQS.) because the
F$LOCATE and F$LENGTH functions return integer values.
Note that quotation marks are used around the substring argument, the
colon, because it is a string literal. However, the symbol TIME does
not require quotation marks because it is automatically evaluated as
a string expression.
F$MESSAGE
Returns a character string containing the message text associated
with a specific system status code.
Format:
F$MESSAGE(status-code)
Additional information available:
Return Valuestatus-codeExample
Return Value
A character string containing the system message which corresponds to the argument you specify.
status-code
The status code for which you are requesting error message text. You must specify the status code as an integer expression.
Example
1. $ ERROR_TEXT = F$MESSAGE(%X1C)
$ SHOW SYMBOL ERROR_TEXT
ERROR_TEXT = "%SYSTEM-F-EXQUOTA, exceeded quota"
This example shows how to use the F$MESSAGE function to determine the
message associated with the status code %X1C. The F$MESSAGE function
returns the message string, which is assigned to the symbol
ERROR_TEXT.
F$MODE
Returns a character string showing the mode in which a process is
executing. The F$MODE function has no arguments, but must be
followed by parentheses.
Format:
F$MODE()
Additional information available:
Return Value
The string "INTERACTIVE" for interactive processes. If the process is noninteractive, the string "BATCH", "NETWORK" or "OTHER" is returned. Note that the return string always contains uppercase letters.
Example
1. $ IF F$MODE() .NES. "INTERACTIVE" THEN GOTO NON_INT_DEF
$ INTDEF: ! Commands for interactive terminal sessions
.
.
.
$ EXIT
$ NON_INT_DEF: !Commands for non-interactive processes
.
.
.
This example shows the beginning of a login command file. The IF
command compares the character string returned by F$MODE with the
character string INTERACTIVE; if they are not equal, control branches
to the label NON_INT_DEF. Otherwise, the statements following the
label INTDEF are executed and the procedure exits before the
statements at NON_INT_DEF. Therefore, this login.com file has two
sets of initialization commands: one for interactive mode and one
for noninteractive mode (including batch and network jobs).
F$PARSE
Invokes the $PARSE RMS service to parse a file specification and return either the expanded file specification or the particular file specification field that you request. Format: F$PARSE(file-spec[,default-spec][,related-spec][,field][,parse-type])
Additional information available:
Return Valuefile-specdefault-specrelated-specfieldparse-typeExamples
Return Value
A character string containing the expanded file specification or the field you specify.
file-spec
The file specification to be parsed. You must specify the file specification as a character string expression.
default-spec
A default file specification. You must specify the default file specification as a character string expression.
related-spec
A related file specification. You must specify the related file specification as a character string expression.
field
The name of a field in a file specification. This argument causes F$PARSE to return a specific portion of a file specification. Specify the field argument as a character string expression. You can specify one of the following field names: NODE Node name DEVICE Device name DIRECTORY Directory name NAME File name TYPE File type VERSION File version number The field name can not be abbreviated.
parse-type
The type of parsing to be performed. By default, the F$PARSE
function verifies that the directory in the file specification exists
on the device in the file specification. Note that the device and
directory can be explicitly given in one of the arguments, or can be
provided by default.
Also, by default the F$PARSE function translates logical names if
they are provided in any of the arguments. The F$PARSE function
stops iterative translation when it encounters a logical name with
the CONCEALED attribute.
You can change how the F$PARSE function parses a file specification
by using one of the following keywords:
NO_CONCEAL Logical names are not concealed. Therefore, logical
name translation does not end when a concealed logical
name is encountered.
SYNTAX_ONLY The syntax of the file specification is checked without
verifying that the specified directory exists on the
specified device.
Examples
1. $ SET DEF DISK2:[FIRST]
$ SPEC = F$PARSE("JAMES.MAR","[ROOT]",,,"SYNTAX_ONLY")
$ SHOW SYMBOL SPEC
SPEC = "DISK2:[ROOT]JAMES.MAR;"
In this example, the F$PARSE function returns the expanded file
specification for the file JAMES.MAR. The example uses the
SYNTAX_ONLY keyword to request that F$PARSE should check the syntax,
but should not verify that the [ROOT] directory exists on DISK2.
The default device and directory are DISK2:[FIRST]. Since the
directory name [ROOT] is specified as the default-spec argument in
the assignment statement, it is used as the directory name in the
output string. Note that the default device returned in the output
string is DISK2 and the default version number for the file is null.
You must place quotation marks around the arguments JAMES.MAR and
ROOT because they are string literals.
If you had not specified syntax-only parsing, and [ROOT] were not on
DISK2, a null string would have been returned.
2. $ SET DEFAULT DB1:[VARGO]
$ SPEC = F$PARSE("INFO.COM",,,"DIRECTORY")
$ SHOW SYMBOL SPEC
SPEC = "[VARGO]"
In this example the F$PARSE function returns the directory name of
the file INFO.COM. Note that, since the default-spec and
related-spec are omitted from the argument list, commas (,) must be
inserted in their place.
3. $ SPEC = F$PARSE("DENVER::DB1:[PROD]RUN.DAT",,,"TYPE")
$ SHOW SYMBOL SPEC
SPEC = ".DAT"
In this example, the F$PARSE function is used to parse a file
specification containing a node name. The F$PARSE function returns
the file type DAT for the file RUN.DAT at the remote node DENVER.
F$PID
The F$PID function returns a process identification (PID) number, and
updates the context symbol to point to the current position in the
system's process list.
Format:
F$PID(context-symbol)
Additional information available:
Return Valuecontext-symbolExample
Return Value
A character string containing the process identification (PID) number of a process in the system's list of processes. The PIDs returned by the F$PID function depend on the privilege of your process. If you have GROUP privilege, the F$PID function returns PIDs of processes in your group. If you have WORLD privilege, the F$PID function returns PIDs of all processes on the system. If you lack GROUP or WORLD privileges, the F$PID function returns only your process PID. After the last PID in the system's process list is returned, the F$PID function returns a null string.
context-symbol
A symbol that DCL uses to store a pointer into the system's list of processes. The F$PID function uses this pointer to return a PID.
Example
1. $ CONTEXT = ""
$ START:
$ PID = F$PID(CONTEXT)
$ IF PID .EQS. "" THEN EXIT
$ SHOW SYMBOL PID
$ GOTO START
This command procedure uses the F$PID function to display a list of
PIDs. The assignment statement declares the symbol CONTEXT, which is
used as the context-symbol argument for the F$PID function. Because
CONTEXT is equated to a null string, the F$PID function will return
the first PID in the process list that it has the privilege to
access.
The PIDs displayed by this command procedure depend on the privilege
of your process. When run with GROUP privilege, the PIDs of users in
your group are displayed. When run with WORLD privilege, the PIDS of
all users on the system are displayed. Without GROUP or WORLD
privilege, only your PID is displayed.
F$PRIVILEGE
Returns a value of either "TRUE" or "FALSE", depending on whether
your current process privileges match the privileges listed in the
argument.
Format:
F$PRIVILEGE(priv-states)
Additional information available:
Return Valuepriv-statesExample
Return Value
A character string containing the value "TRUE" or "FALSE". The F$PRIVILEGE function returns the string "FALSE" if any one of the privileges in the priv-states list is false.
priv-states
A privilege or a list of privileges separated by commas. Specify the priv-states argument as a character string expression. You can specify any privilege except [NO]ALL.
Example
1. $ PROCPRIV = F$PRIVILEGE("OPER,GROUP,TMPMBX,NONETMBX")
$ SHOW SYMBOL PROCPRIV
PROCPRIV = "FALSE"
The F$PRIVILEGE function is used to test whether the process has
OPER, USER, TMPMBX, and NETMBX privileges.
The process in this example has OPER, GROUP, TMPMBX, and NETMBX
privileges. Therefore, a value of "FALSE" is returned because the
process has NETMBX privilege, but NONETMBX was specified in the
priv-states list. Although the Boolean result for the other three
keywords is true, the entire expression is declared false since the
result for NONETMBX was false.
F$PROCESS
Obtains the current process name string. The F$PROCESS function has
no arguments, but must be followed by parentheses.
Format:
F$PROCESS()
Additional information available:
Return Value
A character string containing the current process name.
Example
1. $ NAME = F$PROCESS()
$ SHOW SYMBOL NAME
NAME = "MARTIN"
In this example, the F$PROCESS function returns the current process
name and assigns it to the symbol NAME.
F$SEARCH
Invokes the $SEARCH RMS service to search a directory file and return
the full file specification for a file you name.
Format:
F$SEARCH(file-spec[,stream-id])
Additional information available:
Return Valuefile-specstream-idExamples
Return Value
A character string containing the expanded file specification for the
file-spec argument. If the F$SEARCH function does not find the file
in the directory, the function returns a null ("") string.
file-spec
The file specification to be searched for. You must specify the file-spec argument as a character string expression. If you omit the device or directory names, the F$SEARCH function supplies defaults from your current default disk and directory. The F$SEARCH function does not supply defaults for a file name or type. If you omit the version number, the F$SEARCH function returns the specification for the file with the highest version number. You can use wildcards in the file-spec argument.
stream-id
A search stream identification number. Specify the search stream identification number as a positive integer expression. If you omit the stream-id argument, the F$SEARCH function assumes an implicit single search stream. That is, the F$SEARCH function will start searching at the beginning of the directory file each time you specify a different file-spec argument.
Examples
1. $ START:
$ FILE = F$SEARCH("SYS$SYSTEM:*.EXE")
$ IF FILE .EQS. "" THEN EXIT
$ SHOW SYMBOL FILE
$ GOTO START
This command procedure displays the file-specs of the latest version
of all .EXE files in the SYS$SYSTEM directory. (Only the latest
version is returned because a wildcard is not used as the version
number.) The file-spec argument SYS$SYSTEM:*.EXE is surrounded by
quotation marks because it is a character string expression.
Because no stream-id argument is specified, the F$SEARCH uses a
single search stream. Each subsequent F$SEARCH function uses the
same file-spec argument to return the next file specification of an
.EXE file from SYS$SYSTEM:. After the latest version of each .EXE
file has been displayed, the F$SEARCH function returns a null string
and the procedure exits.
2. $ START:
$ COM = F$SEARCH ("*.COM;*",1)
$ DAT = F$SEARCH ("*.DAT;*",2)
$ SHOW SYMBOL COM
$ SHOW SYMBOL DAT
$ IF (COM.EQS. "") .AND. (DAT.EQS. "") THEN EXIT
$ GOTO START
This command procedure searches the default disk and directory for
both COM and DAT files. Notice that the stream-id is specified for
each F$SEARCH function so that the context for each search is
maintained.
The first F$SEARCH function starts searching from the top of the
directory file for a file with a type of COM. When it finds a COM
file, a pointer is set to maintain the search context. When the
F$SEARCH function is used the second time, it again starts searching
from the top of the directory file for a file with a type of DAT.
When the procedure loops back to the label START, the stream-id
argument allows each F$SEARCH function to start searching in the
correct place in the directory file. After all versions of COM and
DAT files are returned, the procedure exits.
3. $ FILESPEC = F$SEARCH("TRNTO""SMITH SALLY""::DBA1:[PROD]*.DAT")
$ SHOW SYMBOL FILESPEC
FILESPEC = "TRNTO"smith password"::DBA1:[PROD]CARS.DAT"
This example uses the F$SEARCH function to return a file
specification for a file at a remote node. The access control string
is enclosed in double quotation marks because it is part of a
character string expression when it is an argument for the F$SEARCH
function; to include quotation marks in a character string expression
you must specify two sets of quotation marks.
Note that, when the F$SEARCH function returns a node name containing
an access control string, it substitutes the word "password" for the
actual user password.
F$SETPRV
Returns a list of keywords indicating user privileges. In addition,
the F$SETPRV function invokes the $SETPRV system service to enable or
disable specified user privileges. The return string shows the
status of user privileges before changes are made with the F$SETPRV
function.
In order to enable or disable privileges, your process must be
authorized to set the specified privilege. For detailed information
on privilege restrictions, see the description of the $SETPRV system
service in the VAX/VMS System Services Reference Manual.
Format:
F$SETPRV(priv-states)
Additional information available:
Return Valuepriv-statesExamples
Return Value
A character string containing keywords for the current process privileges before they were changed by the F$SETPRV function.
priv-states
A privilege or a list of privileges separated by commas. Specify the priv-states argument as a character string expression.
Examples
1. $ OLDPRIV = F$SETPRV("OPER,NOTMPMBX")
$ SHOW SYMBOL OLDPRIV
OLDPRIV = "NOOPER,TMPMBX"
In this example, the process is authorized to change the OPER and
TMPMBX privileges. The F$SETPRV function enables the OPER privilege
and disables the TMPMBX privilege. In addition, the F$SETPRV
function returns the keywords NOOPER and TMPMBX, showing the state of
these privileges before they were changed.
You must place quotation marks around the list of privilege keywords
because it is a string literal.
2. $ SAVPRIV = F$SETPRV("NOGROUP")
$ SHOW SYMBOL SAVPRIV
SAVPRIV = "GROUP"
$ TEST = F$PRIVILEGE("GROUP")
$ SHOW SYMBOL TEST
TEST = "TRUE"
In this example, the process is not authorized to change the GROUP
privilege. However, the F$SETPRV function still returns the current
setting for the GROUP privilege.
The F$PRIVILEGE function is used to see whether the process has GROUP
privilege. The return string, TRUE, indicates that the process has
GROUP privilege, even though the F$SETPRV function attempted to
disable the privilege.
F$STRING
Returns the string equivalent of the result of the specified
expression.
Format:
F$STRING(expression)
Additional information available:
Return Value
A character string which is equivalent to the specified expression.
expression
The expression to be evaluated by the F$STRING expression. You can specify either an integer or a character string expression.
Example
1. $ A = 5
$ B = F$STRING(-2 + A)
$ SHOW SYMBOL B
B = "3"
The F$STRING function in the above example converts the result of the
integer expression (-2 + A) to the numeric string, "3". First, the
F$STRING function evaluates the expression (-2 + A). Note that 5,
the value of symbol A, is automatically substituted when the integer
expression is evaluated.
After the integer expression is evaluated, the F$STRING function
converts the resulting integer, 3, to the string "3". This string is
assigned to the symbol B.
F$TIME
Returns the current date and time string. The F$TIME function has no
arguments, but must be followed by parentheses.
Format:
F$TIME()
Additional information available:
Return Value
A character string containing the current date and time. The
returned string has the following fixed, 23-character format:
dd-mmm-yyyy hh:mm:ss.cc
Example
1. $ OPEN/WRITE OUTFILE DATA.DAT
$ TIME_STAMP = F$TIME()
$ WRITE OUTFILE TIME_STAMP
This example shows how to use the F$TIME function to time-stamp a
file that you create from a command procedure. OUTFILE is the
logical name for the file DATA.DAT, which is opened for writing. The
F$TIME function returns the current date and time string, and assigns
this string to the symbol TIME_STAMP. The WRITE command writes the
date and time string to OUTFILE.
F$TRNLNM
Translates a logical name and returns the equivalence name string, or
the requested attributes of the logical name. The translation is not
iterative; the equivalence string is not checked to determine whether
it is a logical name.
Format:
F$TRNLNM(logical-name [,table] [,index] [,mode] [,case] [,item])
Additional information available:
Return Valuelogical-nametableindexmodecaseitem
Examples
Return Value
The equivalence name or attribute of the specified logical name. The return value can be a character string or an integer, depending on the arguments you specify with the F$TRNLNM function. The F$TRNLNM function returns a null string if no match is found.
logical-name
The logical name to be translated. You must specify the logical-name argument as a string expression.
table
The logical name table or tables that the F$TRNLNM function should search to translate the logical name. The table argument must be a logical name that translates to a logical name table, or to a list of table names. Specify the table argument as a string expression. If you do not specify a table, the default value is LNM$DCL_LOGICAL.
index
The index of the equivalence name to be returned. If you do not specify an index, the default is 0.
mode
The access mode for the translation. Specify the access mode as a
character string expression that evaluates to one of the following
strings:
USER, SUPERVISOR, EXECUTIVE, or KERNEL.
If you do not specify an access mode, the default mode is USER.
case
The type of case translation to be performed. Specify the case
argument as a character string that evaluates to one of the following
strings:
CASE_BLIND or CASE_SENSITIVE.
If you do not specify the case argument, the default is CASE_BLIND.
item
The type of information that F$TRNLNM should return about the
specified logical name. You can specify any one of the following
strings as an item:
ACCESS_MODE Returns the access mode associated with the logical
name. The access mode is returned as one of the
following character strings: "USER", "SUPERVISOR",
"EXECUTIVE", "KERNEL".
CONCEALED Returns one of the character strings "TRUE" or "FALSE"
to indicate whether the CONCEALED attribute was
specified with the /TRANSLATION_ATTRIBUTES qualifier
when the logical name was created. The CONCEALED
attribute is used to create a concealed logical name.
CONFINE Returns one of the character strings "TRUE" or "FALSE"
to indicate whether the logical name is confined. If
the logical name is confined (TRUE), then the name will
not be copied to subprocesses. If the logical name is
not confined (FALSE), then the name will be copied to
subprocesses.
CRELOG Returns one of the character strings "TRUE" or "FALSE"
to indicate whether the logical name was created with
the $CRELOG system service or with the $CRELNM system
service, using the CRELOG attribute.
If the logical name was created with the $CRELOG system
service or with the $CRELNM system service, using the
CRELOG attribute, then the string "TRUE" is returned.
Otherwise, the string "FALSE" is returned.
LENGTH Returns the length of the equivalence name associated
with the specified logical name. If the logical name
has more than one equivalence name, the F$TRNLNM
function returns the length of the name specified by
the index argument. The length is returned as an
integer.
MAX_INDEX Returns the largest index defined for the logical name.
The index shows how many equivalence names are
associated with a logical name. The index is zero
based; that is, the index 0 refers to the first name in
a list of equivalence names. The index is returned as
an integer.
NO_ALIAS Returns one of the character strings "TRUE" or "FALSE"
to indicate whether the logical name has the NO_ALIAS
attribute. The NO_ALIAS attribute means that a logical
name with the same name cannot be created in an outer
access mode.
TABLE Returns one of the character strings "TRUE" or "FALSE"
to indicate whether the logical name is the name of a
logical name table.
TABLE_NAME Returns the name of the table where the logical name was
found. The table name is returned as a character
string.
TERMINAL Returns one of the character strings "TRUE" or "FALSE"
to indicate whether the TERMINAL attribute was
specified with the /TRANSLATION_ATTRIBUTES qualifier
when the logical name was created. The TERMINAL
attribute indicates that the logical name is not a
candidate for iterative translation.
VALUE Returns the equivalence name associated with the
specified logical name. If the logical name has more
than one equivalence name, the F$TRNLNM function
returns the name specified by the index argument. The
equivalence name is returned as a character string.
VALUE is the default if you do not specify an item
argument.
Examples
1. $ SAVE_DIR = F$TRNLNM("SYS$DISK")+F$DIRECTORY()
.
.
.
$ SET DEFAULT 'SAVE_DIR'
The assignment statement concatenates the values returned by the
F$DIRECTORY and F$TRNLNM functions, and assigns the resulting string
to the symbol SAVE_DIR. The symbol SAVE_DIR consists of a full
device and directory name string.
The argument SYS$DISK is enclosed in quotation marks because it is a
character string. (The command interpreter treats all arguments that
begin with alphabetic characters as symbols or lexical functions,
unless the arguments are enclosed within quotation marks.) None of
the optional arguments are specified, so the F$TRNLNM function uses
the defaults.
At the end of the command procedure, the original default directory
is reset. When you reset the directory, you must place apostrophes
around the symbol SAVE_DIR to force symbol substitution.
2. $ DEFINE/TABLE=LNM$GROUP TERMINAL 'F$TRNLNM("SYS$OUTPUT")'
This example shows a line from a command procedure that (1) uses the
F$TRNLNM function to determine the name of the current output device
and (2) creates a group logical name table entry based on the
equivalence string.
You must place the argument SYS$OUTPUT within quotation marks because
it is a character string.
Also, in this example you must place the F$TRNLNM function within
single quotes to force the lexical function to be evaluated.
Otherwise, the DEFINE command will not automatically evaluate the
lexical function.
F$TYPE
Determines the data type of a symbol.
Format:
F$TYPE(symbol-name)
Additional information available:
Return Value
The string "INTEGER" if the symbol is equated to an integer, or if the symbol is equated to a string in which the characters form a valid integer. The F$TYPE function returns the string "STRING" if the symbol is equated to a character string in which the characters do not form a valid integer. A null string is returned if the symbol is undefined.
symbol
The name of symbol that is evaluated.
Examples
1. $ NUM = "52"
$ TYPE = F$TYPE(NUM)
$ SHOW SYMBOL TYPE
TYPE = "INTEGER"
This example uses the F$TYPE function to determine the data type of
the symbol NUM. NUM is equated to the character string "52".
Because the characters in the string form a valid integer, the F$TYPE
function returns the string "INTEGER".
2. $ NUM = 52
$ TYPE = F$TYPE(NUM)
$ SHOW SYMBOL TYPE
TYPE = "INTEGER"
In this example, the symbol NUM is equated to the integer 52. The
F$TYPE function shows that the symbol has an integer data type.
3. $ CHAR = "FIVE"
$ TYPE = F$TYPE(CHAR)
$ SHOW SYMBOL TYPE
TYPE = "STRING"
In this example, the symbol CHAR is equated to the character string
"FIVE". Because the characters in this string do not form a valid
integer, the F$TYPE function shows that the symbol has a string
value.
F$USER
Returns the current user identification code (UIC), in named format.
The F$USER function has no arguments, but must be followed by
parentheses.
Format:
F$USER()
Additional information available:
Return Value
A character string containing the current user identification (UIC), including square brackets. The UIC is returned in the format [group-identifier, member-identifier].
Example
1. $ UIC = F$USER()
$ SHOW SYMBOL UIC
UIC = "[GROUP6,JENNIFER]"
In this example the F$USER function returns the current user
identification code and assigns it to the symbol UIC.
F$VERIFY
Returns an integer value indicating whether the procedure
verification setting is currently on or off. If used with arguments,
the F$VERIFY function can turn the procedure and image verification
settings on or off. You must include the parentheses after the
F$VERIFY function, whether or not you specify arguments.
Format:
F$VERIFY([procedure-value] [,image-value])
Additional information available:
Return Valueprocedure-valueimage-valueExamples
Return Value
The integer 0 if the procedure verification setting is off, or the integer 1 if the procedure verification setting is on.
procedure-value
An integer expression with a value of 0 to turn procedure verification off, or 1 to turn procedure verification on.
image-value
An integer expression with a value of 0 to turn image verification off, or 1 to turn image verification on.
Examples
1. $ SAVE_PROC_VERIFY = F$ENVIRONMENT("VERIFY_PROCEDURE")
$ SAVE_IMAGE_VERIFY = F$ENVIRONMENT("VERIFY_IMAGE")
$ SET NOVERIFY
.
.
.
$ TEMP = F$VERIFY(SAVE_PROC_VERIFY, SAVE_IMAGE_VERIFY)
This example shows an excerpt from a command procedure. The first
assignment statement assigns the current procedure verification
setting to the symbol SAVE_PROC_VERIFY. The second assignment
statement assigns the current image verification setting to the
symbol SAVE_IMAGE_VERIFY.
Then, the SET NOVERIFY command disables procedure and image
verification. Later, the F$VERIFY function resets the verification
settings, using the original values (equated to the symbols
SAVE_PROC_VERIFY and SAVE_IMAGE_VERIFY). The symbol TEMP contains
the procedure verification before it is changed with the F$VERIFY
function. (In this example the value of TEMP is not used.)
2.
$ VERIFY = F$VERIFY(0)
.
.
.
$ IF VERIFY .EQ. 1 THEN SET VERIFY
This example shows an excerpt from a command procedure that uses the
F$VERIFY function to save the current procedure verification setting
and to turn both procedure and image verification off. At the end of
the command procedure, if procedure verification was originally on,
both the procedure and image verification are turned on.
Line editing
Your terminal has special keys that allow you to recall and edit
previous commands. These keys are described below. Note that some
of these keys may not be available on your keyboard.
Recalling Commands
------------------
The system saves and allows you to access up to 20 of your most recently
entered commands. It saves less than 20 if your commands are very long.
Use the UP-ARROW or CTRL/B keys to recall previously entered commands.
Use the DOWN-ARROW key to reexamine a command that you had retrieved
using UP-ARROW.
If you are supplying commands or data to a program or utility, the
system saves and allows you to access only your single most recently
entered command.
Editing Commands
----------------
To enable the editing keys, execute the command
SET TERMINAL/LINE_EDITING
Append /OVERSTRIKE or /INSERT to the command to specify the default
editing mode that you prefer. /OVERSTRIKE causes a character that you
type to be written over the character that the cursor is currently
pointing at. /INSERT causes the character to be inserted before the
cursor.
Edit Key Function
-------- --------
CTRL/A or Switches between overstrike mode and insert mode. The
F14 default mode is reset at the beginning of each line.
CTRL/D or Moves the cursor one character to the left.
LEFT-ARROW
CTRL/E Moves the cursor to the end of the line.
CTRL/F or Moves the cursor one character to the right.
RIGHT-ARROW
CTRL/H or Moves the cursor to the beginning of the line.
BACKSPACE or
F12
CTRL/J or Deletes the word to the left of the cursor.
LINEFEED or
F13
CTRL/U Deletes characters from the beginning of the line to the
cursor.
NewFeatures V44
New and Changed Features for Version 4.4
o New DCL Commands: CALL, GOSUB, RETURN, and SET SYMBOL. See
the VAX/VMS DCL Dictionary for more information.
o Hyphens in file specifications --- You can now use hyphens in
the following file specification fields: file name, file
type, and directory. You cannot use hyphens in either the
node name or device name field of the file specification.
Logical names for file specifications can also include
hyphens.
o VAXTPU --- The VAX Text Processing Utility (VAXTPU) uses
TPU$SECTION (previously GBL) as a default file type for
section files. You must recompile all current section files
to reflect the change. See the Release Notes for additional
information.
o SDA -- New ATTACH and SPAWN commands have been added to SDA as
well as new qualifiers for the EVALUATE, EXAMINE, SEARCH, SET
PROCESS, and SHOW PROCESS commands. Also, logical operators
have been added to the arithmetic operators. Additionally, the
COPY command releases dump pages in the system paging file to
make them available for paging.
o SORT/MERGE --- The following SORT/MERGE message symbols are
now universal for Version 3.0 compatibility: SOR$_BADLOGIC,
SOR$_CLOSEDEL, SOR$_CLOSEIN, SOR$_CLOSEOUT, SOR$_INSVIRMEM,
SOR$_OPENIN, SOR$_OPENOUT, SOR$_READERR, SOR$_SYSERROR, and
SOR$_WRITEERR.
o Batch and Print Operations --- New features include a
/[NO]RESTART qualifier for the DCL command
START/QUEUE/MANAGER, and the ability to define a
queue-specific default form using the /DEFAULT=form=type
option. For more information, see the following DCL
commands: INITIALIZE/QUEUE, SET QUEUE, and START/QUEUE in
the VAX/VMS DCL Dictionary.
o The /FORM qualifier has been changed to /FORM_MOUNTED for the
following commands: INITIALIZE/QUEUE, START/QUEUE, and SET
QUEUE.
o Authorize Utility --- The Authorize Utility has a new keyword
for the /ATTRIBUTES qualifier; the [NO]DYNAMIC keyword can now
be specified with the following commands: ADD/IDENTIFIER,
GRANT/IDENTIFIER, and MODIFY/IDENTIFIER.
o Cluster Node Names --- A cluster manager can now treat the
nodes in a homogeneous VAXcluster as a single node in a DECnet
network by specifying a cluster node name or address. This
feature makes it easy to send mail or access resources in a
cluster without knowing the currently active nodes. For more
information about cluster node names, see the VAX/VMS
Networking Manual.
o Computer Interconnect (CI) Port Driver (PADRIVER) --- A new
image is supplied with Version 4.4. See the Release Notes for
pertinent information.
o Error Log Utility --- New features include the following
enhancements to the device class keywords for the
ANALYZE/ERROR_LOG qualifiers /EXCLUDE and /INCLUDE: two new
device class keywords, WORKSTATION and LINE_PRINTER; BUS now
includes BI bus error log entries; and DEVICE includes BI
adapter error log entries. In addition, the text associated
with the VAX 11/750 BER register has been updated.
o Networking --- New features include the ability to address the
nodes in a VAXcluster as a single node and to share permanent
database files between VAXcluster nodes. A VAX PSI system can
be configured for more that one DTE and for several network
connections to several PSDNs. For a complete list of the new
networking features, see the New and Changed Features sections
VAX/VMS Networking Manual and the VAX/VMS Networking Control
Program Reference Manual.
o Security --- New features include a new DCL command, SET
RIGHTS_LIST and a new attribute, DYNAMIC. SET RIGHTS_LIST
adds and removes identifiers from the process and system
rights list. You can assign the DYNAMIC attribute to
identifiers to enable nonprivileged users to add or remove
identifiers they hold from their process rights list. For
more information on changes to the security system services,
see the New and Changed Features section of the VAX/VMS System
Services Reference Manual.
o Linker --- The /[NO]TRACEBACK and the /DEBUG qualifiers are
now processed for a shareable image exactly as they are for
an executable image. Previously, the /DEBUG qualifier was
prohibited and the /[NO]TRACEBACK qualifier was ignored, when
linking a shareable image.
o Debugger --- New features include support for VAX DIBOL and
VAX SCAN, screen mode enhancements, support for shareable
image debugging, and several other additions. For more
information, see the Summary of Technical Changes section in
the preface to the VAX/VMS Debugger Reference Manual.
o System Services --- $CHECK_ACCESS, $GETUAI, and $SETUAI are
new services. See the New and Changed Features section of the
VAX/VMS System Services Reference Manual.
o Run-Time Library --- DTK$ routines (for use with DECtalk
devices) are added. Other new routines:
LIB$PAUSE SMG$DISABLE_BROADCAST_TRAPPING
SMG$COPY_VIRTUAL_DISPLAY SMG$GET_PASTING_INFO
SMG$GET_KEYBOARD_ATTRIBUTES SMG$RETURN_INPUT_LINE
SMG$REPLACE_INPUT_LINE SMG$SET_CURSOR_MODE
If SMG$SET_BROADCAST_TRAPPING, SMG$ENABLE_UNSOLICITED_INPUT,
or SMG$SET_OUT_OF_BAND_ASTS specifies an AST routine written
in a language that does not support optional parameters (for
example, VAX BASIC), all system parameters must be specified.
For more information, see the "New and Changed Features"
section of the VAX/VMS Run-Time Library Reference Manual.
o RMS Shared Access --- RMS now supports shared access to any
form of sequential organization file. However, this added
support has a potential effect on mixed-version cluster
operations. See the Release Notes for additional information.
o ANALYZE/RMS_FILE --- The following commands are new: NEXT,
BACK, POSITION/BUCKET, and POSITION/RECORD. These commands
make it easier to examine file structures interactively.
Also, new integrity features check for file structure errors
more thoroughly.
o Print Symbiont --- For changes relating to user-supplied
routines, see the Release Notes for Version 4.4.
o Terminal Driver Support Changes --- See the Release Notes for
information on changes made to VAX/VMS terminal support.
o Drivers --- New features include support for the DR11-WA, a
16-bit parallel direct-memory-access (DMA) interface on the
Q-bus. The CSMA/CD data link (XE and XQ) drivers support the
following elements of the IEEE 802 standard: the 802.2 and
802.3 packet format, 802.2 Class I service, 6-byte
destination and source address fields, and a physical layer
identified as type 10BASE5 (10Mb/s baseband medium with
maximum segment length of 500 m).
o DR11-W/DRV11-WA (XADRIVER) Support --- See the Release Notes
for information.
o TSDRIVER --- The TS11/TU80 device driver, TSDRIVER, has been
modified so that the ONLINE device status is cleared after QIO
functions IO$_UNLOAD and IO$_REWINDOFF are executed. This
brings the behavior of the driver into conformance with that
of other tape device drivers.
Queues
The following DCL commands can be used to control print and batch queues and the entries in them. ASSIGN/MERGE Move jobs from one queue to another ASSIGN/QUEUE Assign a queue to a device DEASSIGN/QUEUE Deassign a queue from a device DELETE/ENTRY Delete a pending entry from a queue DELETE/QUEUE Delete a queue and all its entries INITIALIZE/QUEUE Create and initialize a queue PRINT Place an entry in a print queue SET QUEUE/ENTRY Change the status of a pending entry in a queue SHOW QUEUE Display status of entries in a queue START/QUEUE Start or restart a queue STOP/QUEUE Control queue or current entry in it STOP/REQUEUE Stop and requeue an entry in a print queue SUBMIT Place an entry in a batch queue SYNCHRONIZE Wait for completion of a batch entry
RTL Routines
The VAX Run-Time Library is a collection of procedures available to native mode images at run time. These library procedures are common to all native mode images, regardless of the language processor used to compile or assemble the program.
Additional information available:
DTK$
Additional information available:
DTK$ANSWER_PHONEDTK$DIAL_PHONEDTK$HANGUP_PHONEDTK$INITIALIZE
DTK$LOAD_DICTIONARYDTK$READ_KEYSTROKEDTK$READ_STRING
DTK$RETURN_LAST_INDEXDTK$SET_INDEXDTK$SET_KEYPAD_MODE
DTK$SET_LOGGING_MODEDTK$SET_MODEDTK$SET_SPEECH_MODE
DTK$SET_TERMINAL_MODEDTK$SET_VOICEDTK$SPEAK_FILE
DTK$SPEAK_PHONEMIC_TEXTDTK$SPEAK_TEXTDTK$TERMINATE
DTK$ANSWER_PHONE
DTK$ANSWER_PHONE waits for the phone connected to the DECtalk device
to ring and then answers it.
Format:
DTK$ANSWER_PHONE voice-id [,num-rings] [,text]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
num-rings
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Number of rings DECtalk waits for before answering the phone. The
optional num-rings argument is the address of a signed longword
containing this number. The default is 1 ring.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text that DECtalk speaks after answering the phone. The optional
text argument is the address of a descriptor pointing to the text.
DTK$DIAL_PHONE
DTK$DIAL_PHONE dials the specified number on the telephone.
Format:
DTK$DIAL_PHONE voice-id ,phone-num [,mode] [,text] [,timeout]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk machine. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
phone-num
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Phone number to dial. The phone-num argument is the address of a
descriptor pointing to the specified phone number.
mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mode to use when dialing the phone. The optional mode argument is
the address of a longword bit mask containing this mode.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text to be spoken after the phone is answered. The text argument is
the address of a descriptor pointing to the specified text.
timeout
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Number of seconds to wait for the phone to be answered. The
optional timeout argument is the address of a signed longword
containing this timeout value. If omitted, DECtalk dials the phone
and then returns control to the calling program immediately.
DTK$HANGUP_PHONE
DTK$HANGUP_PHONE speaks an optional message and then hangs up the
phone.
Format:
DTK$HANGUP_PHONE voice-id [,text]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text to be spoken before hanging up the phone. The optional text
argument is the address of a descriptor pointing to the specified
text.
DTK$INITIALIZE
DTK$INITIALIZE initializes a DECtalk device and returns the device's
assigned voice identifier.
Format:
DTK$INITIALIZE new-voice-id ,out-device [,device-type]
Arguments:
new-voice-id
VMS usage: identifier
type: longword (unsigned)
access: write only
mechanism: by reference
Voice identifier of the newly created DECtalk device. The
new-voice-id argument is the address of an unsigned longword that
receives this identifier.
out-device
VMS usage: device_name
type: character string
access: read only
mechanism: by descriptor
File specification or logical name to which the output associated
with the DECtalk device is written. The out-device argument is the
address of a descriptor pointing to this logical name.
device-type
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
Device type of the newly created DECtalk device. The optional
device-type argument is the address of a signed longword that
receives the device-type information. The two valid device types
are:
DTK$K_DTC_01 For DECtalk I.
DTK$K_DTC_03 For DECtalk III.
DTK$LOAD_DICTIONARY
DTK$LOAD_DICTIONARY loads a phonemic definition of a word into the
DECtalk dictionary.
Format:
DTK$LOAD_DICTIONARY voice-id ,text ,substitution
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Word to be loaded into the DECtalk dictionary. The text argument is
the address of a descriptor pointing to the specified word.
substitution
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Phonemic definition of the word specified by the text argument. The
substitution argument is the address of a descriptor pointing to the
phonemic representation of the specified word.
DTK$READ_KEYSTROKE
DTK$READ_KEYSTROKE reads a key entered on the phone keypad.
Format:
DTK$READ_KEYSTROKE voice-id ,key-code [,prompt] [,timeout]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
key-code
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
The DTK$K_TRM_xxxx code for the key entered on the keypad. The
key-code argument is the address of a signed longword that receives
this code. The valid codes are listed in DTKDEF.
prompt
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text to be spoken before waiting for input. The optional prompt
argument is the address of a descriptor pointing to this text.
timeout
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Number of seconds to wait for input. The optional timeout argument
is the address of a signed longword containing the specified number
of seconds the DECtalk device waits for input. If the timeout
argument is omitted, DTK$READ_KEYSTROKE waits for input
indefinitely.
DTK$READ_STRING
DTK$READ_STRING reads a series of keys entered on the phone keypad.
Format:
DTK$READ_STRING voice-id ,out-string [,prompt] [,timeout]
[,term-code]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
out-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which the keys being read are written. The out-string
argument is the address of a descriptor pointing to this string.
prompt
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text to be spoken before waiting for input. The optional prompt
argument is the address of a descriptor pointing to this text.
timeout
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Number of seconds DECtalk waits for input. The optional timeout
argument is the address of a signed longword containing the number
of seconds DECtalk waits for input. If the timeout argument is
omitted, DTK$READ_STRING waits for input indefinitely.
term-code
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
The DTK$K_TRM_xxxx code for terminating key entered. The optional
term-code argument is the address of a signed longword that receives
this code. The valid codes are located in DTKDEF.
DTK$RETURN_LAST_INDEX
DTK$RETURN_LAST_INDEX returns the last index spoken.
Format:
DTK$RETURN_LAST_INDEX voice-id ,p-index
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
p-index
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
Index to be returned. The p-index argument is the address of a
signed longword that receives the index identifier.
DTK$SET_INDEX
DTK$SET_INDEX inserts an index into the current output stream.
Format:
DTK$SET_INDEX voice-id ,p-index
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
p-index
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Index to be inserted. The p-index argument is the address of a
signed longword containing the index value. Valid values are in the
range of 1 to 32767. An index of zero is reserved for use by
DIGITAL.
DTK$SET_KEYPAD_MODE
DTK$SET_KEYPAD_MODE turns recognition of the telephone keypad on or
off.
Format:
DTK$SET_KEYPAD_MODE voice-id ,mode
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mode that determines the status of the telephone keypad. The mode
argument is the address of a longword bit mask containing this mode.
The valid mode specifiers are:
DTK$K_KEYPAD_ON Turns the keypad on.
DTK$K_KEYPAD_OFF Turns the keypad off.
DTK$K_KEYPAD_AUTO Turns the keypad on with auto-stop.
DTK$SET_LOGGING_MODE
DTK$SET_LOGGING_MODE controls the information that is displayed on
the video terminal while the DECtalk device is functioning.
Format:
DTK$SET_LOGGING_MODE voice-id [,new-mode] [,old-mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
new-mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
DECtalk mode to be set. The optional new-mode argument is the
address of a longword bit mask containing the specified mode. Valid
values for new-mode are:
o DTK$M_TEXT
o DTK$M_PHONEME
o DTK$M_RAWHOST
o DTK$M_INHOST
o DTK$M_OUTHOST
o DTK$M_ERROR
o DTK$M_TRACE
o DTK$M_DEBUG
old-mode
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Current mode settings of the DECtalk device. The optional old-mode
argument is the address of a longword bit mask that receives the
current DECtalk settings.
DTK$SET_MODE
DTK$SET_MODE sets or resets the mode settings of the DECtalk
terminal.
Format:
DTK$SET_MODE voice-id [,new-mode] [,old-mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
new-mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
DECtalk mode to be set. The optional new-mode argument is the
address of a longword bit mask containing the specified mode. Valid
values for new-mode are:
o DTK$M_SQUARE
o DTK$M_ASCII (valid for the DTC01 device only)
o DTK$M_MINUS
o DTK$M_EUROPE (valid for the DTC03 device only)
o DTK$M_SPELL (valid for the DTC03 device only)
old-mode
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Current mode settings of the DECtalk device. The optional old-mode
argument is the address of a longword bit mask that receives the
current DECtalk settings.
DTK$SET_SPEECH_MODE
DTK$SET_SPEECH_MODE either starts or stops the DECtalk device's
speech.
Format:
DTK$SET_SPEECH_MODE voice-id ,new-mode [,old-mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
new-mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mode to be set. The new-mode argument is the address of a longword
bit mask containing the specified mode. Valid values are:
DTK$K_SPEAK Start speaking.
DTK$K_STOP Stop speaking when current text is
completed.
DTK$K_HALT Stop speaking immediately.
old-mode
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Current speech mode of the DECtalk device. The optional old-mode
argument is the address of a longword bit mask that receives the
current mode setting before enabling the new mode. The values
returned in old-mode are the same as those valid for the new-mode
argument.
DTK$SET_TERMINAL_MODE
DTK$SET_TERMINAL_MODE controls the attributes of the video terminal
connected to the DECtalk device.
Format:
DTK$SET_TERMINAL_MODE voice-id [,new-mode] [,old-mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
new-mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
DECtalk mode to be set. The optional new-mode argument is the
address of a longword bit mask containing the specified mode. Valid
values for new-mode are:
o DTK$M_HOST
o DTK$M_SPEAK
o DTK$M_EDITED
o DTK$M_HARD
o DTK$M_SETUP
o DTK$M_FILTER
old-mode
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Current mode settings of the DECtalk device. The optional old-mode
argument is the address of a longword bit mask that receives the
current DECtalk settings.
DTK$SET_VOICE
DTK$SET_VOICE changes the DECtalk voice characteristics to match
those specified.
Format:
DTK$SET_VOICE voice-id [,new-voice] [,speech-rate]
[,comma-pause] [,period-pause]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
new-voice
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Type of voice. The optional new-voice argument is the address of a
signed longword containing any valid new-voice value. Valid values
for new-voice are:
DTK$K_VOICE_MALE Standard male voice
DTK$K_VOICE_FEMALE Standard female voice
DTK$K_VOICE_CHILD Standard child voice
DTK$K_VOICE_DEEP_MALE Deep male voice
DTK$K_VOICE_DEEP_FEMALE Deep female voice
DTK$K_VOICE_OLDER_MALE Older male voice
DTK$K_VOICE_LIGHT_FEMALE Light female voice
speech-rate
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Rate at which DECtalk speaks, measured in words per minute. The
optional speech-rate argument is the address of a signed longword
containing this rate. The valid range of values for speech-rate is
120 to 350 words per minute.
comma-pause
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Number of milliseconds by which to increase the time DECtalk pauses
after a comma. The optional comma-pause argument is the address of
a signed longword containing this number. A value of zero resets
the pause time to the hardware default value.
period-pause
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Number of milliseconds by which to increase the time DECtalk pauses
after a period. The optional period-pause argument is the address
of a signed longword containing this number. A value of zero resets
the pause time to the hardware default value.
DTK$SPEAK_FILE
DTK$SPEAK_FILE speaks the text contained in the specified file.
Format:
DTK$SPEAK_FILE voice-id ,filespec [,mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File specification of the file containing the text to be spoken.
The filespec argument is the address of a descriptor pointing to
this file.
mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mode characteristic. The optional mode argument is the address of a
longword bit mask containing the specified mode. Valid values for
the mode argument are:
DTK$K_IMMED Return to the user immediately (default).
DTK$K_WAIT Wait until the text is completely spoken.
DTK$K_STATUS Wait until the text is completely spoken,
and then return a phone status.
DTK$SPEAK_PHONEMIC_TEXT
DTK$SPEAK_PHONEMIC_TEXT sends the specified phonemic text to the
DECtalk device to be spoken.
Format:
DTK$SPEAK_PHONEMIC_TEXT voice-id ,text [,mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Phonemic text to be spoken. The text argument is the address of a
descriptor pointing to the specified phonemic representation of the
text.
mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mode characteristic. The optional mode argument is the address of a
longword bit mask containing the specified mode. Valid values for
the mode argument are:
DTK$K_IMMED Return to the user immediately (default).
DTK$K_WAIT Wait until the text is completely spoken.
DTK$K_STATUS Wait until the text is completely spoken,
and then return a phone status.
DTK$SPEAK_TEXT
DTK$SPEAK_TEXT sends the specified text to the DECtalk device to be
spoken.
Format:
DTK$SPEAK_TEXT voice-id ,text [,mode]
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text to be spoken. The text argument is the address of a descriptor
pointing to the specified text.
mode
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mode characteristic. The optional mode argument is the address of a
longword bit mask containing the specified mode. Valid values for
the mode argument are:
DTK$K_IMMED Return to the user immediately (default).
DTK$K_WAIT Wait until the text is completely spoken.
DTK$K_STATUS Wait until the text is completely spoken,
and then return a phone status.
DTK$TERMINATE
DTK$TERMINATE terminates the use of an initialized DECtalk.
Format:
DTK$TERMINATE voice-id
Arguments:
voice-id
VMS usage: identifier
type: longword (unsigned)
access: read only
mechanism: by reference
Voice identifier of the DECtalk device. The voice-id argument is
the address of an unsigned longword containing this identifier. The
voice identifier is returned by the DTK$INITIALIZE routine.
LIB$
Additional information available:
LIB$ADDXLIB$ANALYZE_SDESCLIB$ASN_WTH_MBXLIB$AST_IN_PROG
LIB$ATTACHLIB$BBCCILIB$BBSSILIB$CALLGLIB$CHARLIB$CRC
LIB$CRC_TABLELIB$CREATE_DIRLIB$CREATE_USER_VM_ZONE
LIB$CREATE_VM_ZONELIB$CRF_INS_KEYLIB$CRF_INS_REF
LIB$CRF_OUTPUTLIB$CURRENCYLIB$CVT_DX_DXLIB$DATE_TIME
LIB$DAYLIB$DAY_OF_WEEKLIB$DECODE_FAULTLIB$DEC_OVER
LIB$DELETE_FILELIB$DELETE_LOGICALLIB$DELETE_SYMBOLLIB$DELETE_VM_ZONE
LIB$DIGIT_SEPLIB$DISABLE_CTRLLIB$DO_COMMANDLIB$EDIV
LIB$EMULLIB$ENABLE_CTRLLIB$ESTABLISHLIB$EXTVLIB$EXTZV
LIB$FILE_SCANLIB$FILE_SCAN_ENDLIB$FIND_FILELIB$FIND_FILE_END
LIB$FIND_IMAGE_SYMBOLLIB$FIXUP_FLTLIB$FLT_UNDER
LIB$FREE_EFLIB$FREE_LUNLIB$FREE_TIMERLIB$FREE_VM
LIB$FREE_VM_PAGELIB$GET_COMMANDLIB$GET_COMMONLIB$GETDVI
LIB$GET_EFLIB$GET_FOREIGNLIB$GET_INPUTLIB$GETJPI
LIB$GET_LUNLIB$GETSYILIB$GET_SYMBOLLIB$GET_VM
LIB$GET_VM_PAGELIB$ICHARLIB$INDEXLIB$INIT_TIMERLIB$INSERT_TREE
LIB$INSQHILIB$INSQTILIB$INSVLIB$INT_OVERLIB$LENLIB$LOCC
LIB$LOOKUP_KEYLIB$LOOKUP_TREELIB$LP_LINESLIB$MATCHC
LIB$MATCH_CONDLIB$MOVC3LIB$MOVC5LIB$MOVTCLIB$MOVTUC
LIB$PAUSELIB$PUT_COMMONLIB$PUT_OUTPUTLIB$RADIX_POINT
LIB$REMQHILIB$REMQTILIB$RENAME_FILELIB$RESERVE_EF
LIB$RESET_VM_ZONELIB$REVERTLIB$RUN_PROGRAMLIB$SCANC
LIB$SCOPY_R_DXLIB$SET_LOGICALLIB$SET_SYMBOLLIB$SFREE1_DD
LIB$SFREEN_DDLIB$SGET1_DDLIB$SHOW_TIMERLIB$SHOW_VM
LIB$SIGNALLIB$SIG_TO_RETLIB$SIG_TO_STOPLIB$SIM_TRAP
LIB$SKPCLIB$SPANCLIB$SPAWNLIB$STAT_TIMERLIB$STAT_VM
LIB$STOPLIB$SUBXLIB$SYS_ASCTIMLIB$SYS_FAOLIB$SYS_FAOL
LIB$SYS_GETMSGLIB$SYS_TRNLOGLIB$TPARSELIB$TRA_ASC_EBC
LIB$TRA_EBC_ASCLIB$TRAVERSE_TREELIB$TRIM_FILESPECLIB$WAIT
LIB$CVT xTBLIB$EMODxLIB$FFxLIB$POLYz
LIB$ADDX
LIB$ADDX adds two signed two's complement integers of arbitrary
length.
Format:
LIB$ADDX a ,b ,result [,len]
Arguments:
a
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
First multiple-precision, signed two's complement integer which
LIB$ADDX adds to the second two's complement integer. The a
argument is the address of the array containing the two's complement
number to be added.
b
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
Second multiple-precision, signed two's complement integer, which
LIB$ADDX adds to the first two's complement integer. The b argument
is the address of the array containing the two's complement number.
result
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference, array reference
Multiple-precision, signed two's complement integer result of the
addition. The result argument is the address of the array into
which LIB$ADDX writes the result of the addition.
len
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Length in longwords of the arrays to be operated on; each array is
of length len. The len argument is the address of a signed longword
integer containing the length. Len must not be negative. This is
an optional argument. If omitted, the default is 2.
LIB$ANALYZE_SDESC
LIB$ANALYZE_SDESC extracts the length and the address at which the
data starts for a variety of string descriptor classes.
Format:
LIB$ANALYZE_SDESC inp-dsc ,len ,data-adr
Arguments:
inp-dsc
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Input descriptor from which LIB$ANALYZE_DESC extracts the data's
length and starting address. The inp-dsc argument is the address of
a descriptor pointing to this descriptor.
len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length of the data; LIB$ANALYSE_DESC extracts this length value from
the input descriptor. The len argument is the address of an
unsigned word integer into which LIB$ANALYZE_SDESC writes the
length.
data-adr
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Starting address of the data; LIB$ANALYZE_DESC extracts this address
from the input descriptor. The data-adr argument is the address of
an unsigned longword into which LIB$ANALYZE_DESC writes the starting
address of the data.
LIB$ASN_WTH_MBX
LIB$ASN_WTH_MBX assigns a channel to a specified device and
associates a mailbox with the device. It returns both the device
channel and the mailbox channel.
Format:
LIB$ASN_WTH_MBX dev-nam ,max-msg ,buf-quo ,dev-chn ,mbx-chn
Arguments:
dev-nam
VMS usage: device_name
type: character string
access: read only
mechanism: by descriptor
Device name which LIB$ASN_WTH_MBX passes to the $ASSIGN service.
The dev-nam argument is the address of a descriptor pointing to the
device name.
max-msg
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Maximum message size that can be sent to the mailbox;
LIB$ASN_WTH_MBX passes this argument to the $CREMBX service. The
max-msg argument is the address of a signed longword integer
containing this maximum message size.
buf-quo
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of system dynamic memory bytes that can be used to buffer
messages sent to the mailbox; LIB$ASN_WTH_MBX passes this argument
to the $CREMBX service. The buf-quo argument is the address of a
signed longword integer containing this buffer quota.
dev-chn
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Device channel which LIB$ASN_WTH_MBS receives from the $ASSIGN
service. The dev_chn argument is the address of a signed word
integer into which $ASSIGN writes the device channel.
mbx-chn
VMS usage: channel
type: word integer (signed)
access: write only
mechanism: by reference
Mailbox channel which LIB$ASN_WTH_MBX receives from the $CREMBX
service. The mbx_chn argument is the address of a signed word
integer into which $CREMBX writes the mailbox channel.
LIB$AST_IN_PROG
LIB$AST_IN_PROG indicates whether an AST is currently in progress.
Format:
LIB$AST_IN_PROG
NONE
LIB$ATTACH
LIB$ATTACH requests the calling process's Command Language
Interpreter (CLI) to detach the terminal of the calling process and
to reattach it to a different process.
Format:
LIB$ATTACH process-id
Argument
process-id
VMS usage: process_id
type: longword integer (unsigned)
access: read only
mechanism: by reference
Identification of the process to which LIB$ATTACH requests the
calling process to attach its terminal. The process-id argument is
the address of an unsigned longword integer containing the process
identification. The specified process must be currently detached
(by means of a SPAWN or ATTACH command, or by a call to LIB$SPAWN or
LIB$ATTACH) and must be part of the caller's job.
LIB$BBCCI
LIB$BBCCI tests and clears a selected bit under memory interlock.
LIB$BBCCI makes the VAX BBCCI instruction available as a callable
procedure.
Format:
LIB$BBCCI position ,base
Arguments:
position
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Bit position, relative to base, of the bit which LIB$BBCCI tests and
clears. The position argument is the address of a signed longword
integer containing the bit position. A position of zero denotes the
low-order bit of the byte base. The bit position is equal to the
offset of the bit chosen from the base position. This offset may
span the entire range of a signed longword integer; negative offsets
access bits in lower-addressed bytes.
base
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
Address of the byte containing bit zero of the field that LIB$BBCCI
references. The base argument is the address of the base position.
The bit that LIB$BBCCI tests and clears is position bits offset from
the low bit of base.
LIB$BBSSI
LIB$BBSSI tests and sets a selected bit under memory interlock.
LIB$BBSSI makes the VAX BBSSI instruction available as a callable
procedure.
Format:
LIB$BBSSI position ,base
Arguments:
position
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Bit position, relative to base, of the bit which LIB$BBSSI tests and
sets. The position argument is the address of a signed longword
integer containing the bit position. A position of zero denotes the
low-order bit of the byte base. The bit position is equal to the
offset of the bit chosen from the base position. This offset may
span the entire range of a signed longword integer; negative offsets
access bits in lower-addressed bytes.
base
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
Address of the byte containing bit zero of the field that LIB$BBSSI
references. The base argument is the address of the base position.
The bit that LIB$BBSSI tests and sets is position bits offset from
the low bit of base.
LIB$CALLG
LIB$CALLG calls a procedure with an argument list specified as an
array of longwords, the first of which is a count of the remaining
longwords. LIB$CALLG is a callable version of the VAX CALLG
instruction.
Format:
LIB$CALLG arglist ,procedure
Arguments:
arglist
VMS usage: arg_list
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Argument list which LIB$CALLG uses to call the specified procedure.
The arglist argument is the address of an array of longwords
containing the argument list. The first longword must contain the
count of the remaining longwords. The maximum value of the count is
255.
procedure
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
Procedure which LIB$CALLG calls with the specified argument list.
The procedure argument is the address of the procedure entry mask
for this procedure.
LIB$CHAR
LIB$CHAR transforms a single 8-bit ASCII character to an ASCII
string consisting of a single character followed by trailing spaces,
if needed, to fill out the string. The range of the input byte is 0
through 255.
Format:
LIB$CHAR one-char-str ,ascii-code
Arguments:
one-char-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
ASCII character string consisting of a single character followed by
trailing spaces, if needed, that LIB$CHAR creates when it transforms
the ASCII character code. The one-char-str argument is the address
of a descriptor pointing to the character string that LIB$CHAR
writes.
ascii-code
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Single 8-bit ASCII character code that LIB$CHAR transforms to an
ASCII string. The ascii-code argument is the address of an unsigned
byte containing the ASCII character code.
LIB$CRC
LIB$CRC calculates the cyclic redundancy check (CRC) for a data
stream. LIB$CRC makes the VAX CRC instruction available as a
callable procedure.
Format:
LIB$CRC table ,inicrc ,stream
Arguments:
table
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
The 16-longword cyclic redundancy check table, created by a call to
LIB$CRC_TABLE. The table argument is the address of a signed
longword integer containing this table. Because this table is
created by LIB$CRC_TABLE and then used as input in LIB$CRC, your
program must call LIB$CRC_TABLE before it calls LIB$CRC.
inicrc
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Initial cyclic redundancy check. The inicrc argument is the address
of a signed longword integer containing the initial cyclic
redundancy check.
stream
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Data stream for which LIB$CRC is calculating the CRC. The stream
argument is the address of a descriptor pointing to the data stream.
LIB$CRC_TABLE
LIB$CRC_TABLE constructs a 16-longword table that uses a cyclic
redundancy check polynomial specification as a bit mask.
Format:
LIB$CRC_TABLE poly ,table
Arguments:
poly
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A bit mask indicating which polynomial coefficients are to be
generated by LIB$CRC_TABLE. The poly argument is the address of an
unsigned longword integer containing this bit mask.
table
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference, array reference
The 16-longword table that LIB$CRC_TABLE produces. The table
argument is the address of a signed longword integer containing the
table.
LIB$CREATE_DIR
LIB$CREATE_DIR creates a directory or subdirectory.
Format:
LIB$CREATE_DIR dev-dir-spec [,owner-UIC] [,prot-enable]
[,prot-value] [,max-versions] [,rvn]
Arguments:
dev-dir-spec
VMS usage: device_name
type: character string
access: read only
mechanism: by descriptor
Directory specification of the directory or subdirectory that
LIB$CREATE_DIR will create. The dev-dir-spec argument is the
address of a descriptor pointing to this directory specification.
owner-UIC
VMS usage: uic
type: longword (unsigned)
access: read only
mechanism: by reference
User Identification Code (UIC) identifying the owner of the created
directory or subdirectory. The owner-UIC argument is the address of
an unsigned longword that contains the UIC. If owner-UIC is zero,
the owner UIC is that of the parent directory.
prot-enable
VMS usage: mask_word
type: word (unsigned)
access: read only
mechanism: by reference
Mask specifying the bits of prot-value to be set. The prot-enable
argument is the address of an unsigned word containing this
protection mask.
prot-value
VMS usage: file_protection
type: word (unsigned)
access: read only
mechanism: by reference
System/Owner/Group/World protection value of the directory you are
creating. The prot-value argument is the address of an unsigned
word which contains this protection mask.
max-versions
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Maximum number of versions allowed for files created in the newly
created directories. The max-versions argument is the address of an
unsigned word containing the value of the maximum number of
versions.
rvn
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Relative volume number within a volume set on which the directory or
subdirectory is created. The rvn argument is the address of an
unsigned word containing the relative volume number. The rvn
argument is optional. The default is arbitrary placement within the
volume set.
LIB$CREATE_USER_VM_ZONE
LIB$CREATE_USER_VM_ZONE creates a new user-defined storage zone.
Format:
LIB$CREATE_USER_VM_ZONE zone-id [,user-arg] [,user-get-rtn]
[,user-free-rtn] [,user-reset-rtn]
[,user-delete-rtn]
Arguments:
zone-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Zone identifier. The zone-id argument is the address of a longword
which is set to the identifier of the newly created zone.
user-arg
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by reference
User argument. LIB$CREATE_USER_VM_ZONE copies the value of user-arg
and supplies the value to all user routines invoked.
user-get-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User allocation routine. The user-get-rtn argument is the address
of the procedure entry mask for the optional user routine that is
invoked each time LIB$GET_VM is called for the zone.
user-free-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User deallocation routine. The user-free-rtn argument is the
address of the procedure entry mask for the optional user routine
that is invoked each time LIB$FREE_VM is called for the zone.
user-reset-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User routine to reset the zone. The user-reset-rtn argument is an
optional user routine that is invoked each time LIB$RESET_VM_ZONE is
called for the zone.
user-delete-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User routine to delete the zone. The user-delete-rtn argument is an
optional user routine that is invoked when LIB$DELETE_VM_ZONE is
called for the zone.
LIB$CREATE_VM_ZONE
LIB$CREATE_VM_ZONE creates a new storage zone according to specified
arguments.
Format:
LIB$CREATE_VM_ZONE zone-id [,algorithm] [,algorithm-arg]
[,flags] [,extend-size] [,initial-size]
[,block-size] [,alignment] [,page-limit] [,p1]
Arguments:
zone-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Zone identifier. The zone-id argument is the address of a longword
that is set to the zone-id of the newly created zone.
algorithm
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Algorithm. The algorithm argument is the address of a longword
integer which contains the code for one of the LIB$VM algorithms:
1 LIB$K_VM_FIRST_FIT First fit
2 LIB$K_VM_QUICK_FIT Quick fit, lookaside list
3 LIB$K_VM_FREQ_SIZES Frequent sizes, lookaside
list
4 LIB$K_VM_FIXED Fixed size blocks
algorithm-arg
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Algorithm argument. The algorithm-arg argument is the address of a
longword integer which contains a value that is specific to the
particular allocation algorithm.
Algorithm Value of algorithm-arg
First fit Not used, may be omitted.
Quick fit The number of lookaside lists used. The
number of lists must be between 1 and
128.
Frequent sizes The number of lookaside lists used. The
number of lists must be between 1 and
16.
Fixed size blocks The fixed request size for each get or
free. The request size must be greater
than 0.
flags
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Flags. The flags argument is the address of a longword integer
which contains flag bits that control various options:
Bit Value Description
Bit 0 LIB$M_VM_BOUNDARY_TAGS Boundary tags for faster freeing
Adds a minimum of eight bytes to
each block
Bit 1 LIB$M_VM_GET_FILL0 LIB$GET_VM : fill with bytes of
0
Bit 2 LIB$M_VM_GET_FILL1 LIB$GET_VM : fill with bytes of
FF (hexadecimal)
Bit 3 LIB$M_VM_FREE_FILL0 LIB$FREE_VM : fill with bytes
of 0
Bit 4 LIB$M_VM_FREE_FILL1 LIB$FREE_VM : fill with bytes
of FF (hexadecimal)
Bit 5 LIB$M_VM_EXTEND_AREA Add extents to existing areas if
possible
extend-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Zone extend size. The extend-size argument is the address of a
longword integer which contains the number of (512-byte) pages to be
added to the zone each time it is extended.
initial-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Initial size for the zone. The initial-size argument is the address
of a longword integer which contains the number of (512-byte) pages
to be allocated for the zone as the zone is created.
block-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Block size of zone. The block-size argument is the address of a
longword integer specifying the allocation quantum (in bytes) for
the zone. All blocks allocated are rounded up to a multiple of
block-size.
alignment
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Block alignment. The alignment argument is the address of a
longword integer which specifies the required address alignment (in
bytes) for each block allocated.
page-limit
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Maximum page limit. The page-limit argument is the address of a
longword integer which specifies the maximum number of (512-byte)
pages that can be allocated for the zone. The value of page-limit
must be between 0 and 32767.
p1
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Smallest block size. The p1 argument is the address of a longword
integer which specifies the smallest block size (in bytes) that has
a lookaside list for the quick fit algorithm.
LIB$CRF_INS_KEY
LIB$CRF_INS_KEY inserts information about a key into a
cross-reference table.
Format:
LIB$CRF_INS_KEY ctl-tbl ,key1 ,val1 ,flags
Arguments:
ctl-tbl
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
Cross-reference table into which LIB$CRF_INS_KEY inserts information
about the key. The ctl-tbl argument is the address of a signed
longword integer pointing to the cross-reference table. You must
name this table each time you call a cross-reference procedure
because you can accumulate information for more than one
cross-reference table at a time.
key1
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
A counted ASCII string that contains a symbol name or an unsigned
binary longword. The key1 argument is the address of a descriptor
pointing to the key.
val1
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Symbol value, the address of which LIB$CRF_INS_KEY inserts in the
cross-reference table. The val1 argument is the address of a signed
longword integer containing this value. Both the key and value
addresses must be permanent addresses in the user's symbol table.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Value used in selecting the contents of the KEY2 and VAL2 fields;
flags is stored with the entry. The flags argument is the address
of an unsigned longword containing the flags. When preparing the
output line, LIB$CRF_OUTPUT uses flags and the 16-bit mask in the
field descriptor table to extract the data. The high-order bit of
the word is reserved for LIB$CRF_INS_KEY.
LIB$CRF_INS_REF
LIB$CRF_INS_REF inserts a reference to a key in a cross-reference
symbol table.
Format:
LIB$CRF_INS_REF ctl-tbl ,key1 ,ref2 ,ref1 ,ref-def
Arguments:
ctl-tbl
VMS usage: vector_longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
Control table associated with this cross-reference. The ctl-tbl
argument is the address of an array containing the control table.
key1
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Key referred to by LIB$CRF_INS_REF. The key1 argument is the
address of a signed longword integer containing the key. The key is
a counted ASCII string that contains a symbol name or an unsigned
binary longword. It must be a permanent address in the user's
symbol table.
ref2
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Counted ASCII string with a maximum of 31 characters, not including
the byte count. The ref2 argument is the address of a descriptor
pointing to the counted ASCII string.
ref1
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
The 16-bit value used in selecting the contents of the REF1 field.
The ref1 argument is the address of a signed longword integer
containing this value. When preparing the output line,
LIB$CRF_OUTPUT uses ref1 and the bit mask in the field descriptor
table to extract the data. The high-order bit of the word is
reserved for LIB$CRF_INS_REF.
ref-def
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Reference/definition indicator that LIB$CRF_INS_REF uses to
distinguish between a reference to a symbol and the definition of
the symbol. The ref-def argument is the address of a signed
longword integer containing this indicator. The only difference
between processing a symbol reference and a symbol definition is
where LIB$CRF_INS_REF stores the information.
LIB$CRF_OUTPUT
LIB$CRF_OUTPUT extracts the information from the cross-reference
tables and formats the output pages.
Format:
LIB$CRF_OUTPUT ctl-tbl ,width ,pag1 ,pag2 ,mode-ind
,del-sav-ind
Arguments:
ctl-tbl
VMS usage: vector_longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
Control table associated with the cross-reference. The ctl-tbl
argument is the address of an array containing the control table.
The table contains the address of the user-supplied routine that
prints the lines formatted by LIB$CRF_OUTPUT.
width
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Width of the output line. The width argument is the address of a
signed longword integer containing the width.
pag1
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of lines on the first page of the output. The pag1 argument
is the address of a signed longword integer containing this number.
This allows the user to reserve space to print header information on
the first page of the cross-reference.
pag2
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of lines per page for the other pages. The pag2 argument is
the address of a signed longword integer containing this number.
mode-ind
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Output mode indicator. The mode-ind is the address of a signed
longword integer containing the mode indicator.
del-sav-ind
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Delete/save indicator which LIB$CRF_OUTPUT uses to determine whether
the table's built-in accumulating symbol information is to be saved
or deleted once the cross-reference is produced. The del-sav-ind is
the address of a signed longword integer containing the delete/save
indicator.
LIB$CURRENCY
LIB$CURRENCY returns the system's currency symbol.
Format:
LIB$CURRENCY currency-str [,out-len]
Arguments:
currency-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Currency symbol. The currency-str argument is the address of a
descriptor pointing to the currency symbol.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of characters that LIB$CURRENCY has written into
currency-str, not counting padding in the case of a fixed-length
string. The out-len argument is the address of an unsigned word
containing the length of the currency symbol. If the input string
is truncated to the size specified in the currency-str descriptor,
out-len is set to this size. Therefore, out-len can always be used
by the calling program to access a valid substring of currency-str.
LIB$CVT_DX_DX
LIB$CVT_DX_DX converts a VAX standard atomic or string datum
described by a source descriptor to another VAX standard atomic or
string datum described by a destination descriptor. This conversion
is supported over a subset of the VAX standard data types.
Format:
LIB$CVT_DX_DX src ,dst [,dst-len]
Arguments:
src
VMS usage: address
type: unspecified
access: read only
mechanism: by descriptor
Source item to be converted by LIBCVT_DX_DX. The src argument is
the address of a descriptor pointing to the source item to be
converted. The type of the item to be converted is contained in the
descriptor.
dst
VMS usage: address
type: unspecified
access: write only
mechanism: by descriptor
Destination of the conversion. The dst argument is the address of a
descriptor pointing to the destination item. The destination
descriptor specifies the data type to which the source item is
converted.
dst-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length in bytes of the destination item (when that item is a string)
that has been converted by LIB$CVT_DX_DX, not including any space
filling. The dst-len argument contains the address of an unsigned
word containing this length.
LIB$CVT xTB
LIB$CVT_DTB, LIB$CVT_HTB and LIB$CVT_OTB return a binary
representation of the ASCII text string representation of a decimal,
hexadecimal, or octal number.
Format:
LIB$CVT_DTB count ,string ,result
LIB$CVT_HTB count ,string ,result
LIB$CVT_OTB count ,string ,result
Arguments:
count
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Byte count of the input ASCII text string. The count argument is a
signed longword integer containing the byte count of the input
string.
string
VMS usage: char_string
type: character string
access: read only
mechanism: by reference
ASCII text string representation of a decimal, hexadecimal, or octal
number which LIB$CVTxTB converts to binary representation. The
string argument is the address of a character string containing this
input string to be converted.
result
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Binary representation of the input string. The result argument is
the address of a signed longword integer containing the converted
string.
LIB$DATE_TIME
LIB$DATE_TIME returns the VAX/VMS system date and time in the
semantics of a user-provided string.
Format:
LIB$DATE_TIME dst-str
Argument
dst-str
VMS usage: date_time
type: character string
access: write only
mechanism: by descriptor
Destination string into which LIB$DATE_TIME writes the system date
and time. The dst-str argument is the address of a descriptor
pointing to the destination string.
LIB$DAY
LIB$DAY returns the number of days since the system zero date of
November 17, 1858, or the number of days from November 17, 1858, to
a user-supplied date.
Format:
LIB$DAY day-number [,user-time] [,day-time]
Arguments:
day-number
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Number of days since the system zero date. The day-number argument
is the address of a signed longword integer containing the day
number.
user-time
VMS usage: date_time
type: quadword integer (signed)
access: read only
mechanism: by reference
User-supplied time, in 100-nanosecond units. The user-time argument
is the address of a signed quadword integer containing the user
time. A positive value indicates an absolute time, while a negative
value indicates a delta time. This is an optional argument. If
omitted, the default is the current system time. This quadword time
value is obtained by calling the system service SYS$BINTIM.
day-time
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Number of 10-millisecond units since midnight of the user-time
argument. The day-time argument is the address of a signed longword
integer into which LIB$DAY writes this number of units.
LIB$DAY_OF_WEEK
LIB$DAY_OF_WEEK returns the numeric day of the week for an input
time value. If 0 is the input time value, the current day of the
week is returned. The days are numbered 1 through 7, with Monday as
day 1 and Sunday as day 7.
Format:
LIB$DAY_OF_WEEK time ,day-num
Arguments:
time
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
Time to be translated to a day of the week, or zero. The time
argument is the address of an unsigned quadword containing the value
of time. Time must be supplied as an absolute system time. To
obtain this time value in proper quadword format call the system
service SYS$BINTIM.
day-num
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Numeric day of week. The day-num argument is the address of a
longword into which LIB$DAY_OF_WEEK writes the integer value
representing the day of the week.
LIB$DECODE_FAULT
LIB$DECODE_FAULT is a tool for building condition handlers which
process instruction fault exceptions. It is called from a condition
handler.
Format:
LIB$DECODE_FAULT signal-args ,mechanism-args ,user-action
[,user-arg] [,instruction-definitions]
Arguments:
signal-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Signal arguments array that was passed from VAX/VMS to your
condition handler. The signal-args argument is the address of the
signal arguments array.
mechanism-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Mechanism arguments array that was passed from VAX/VMS to your
condition handler. The mechanism-args argument is the address of
the mechanism arguments array.
user-action
VMS usage: procedure
type: bound procedure value or procedure entry mask
access: call after stack unwind
mechanism: by descriptor, procedure
User-supplied action routine that LIB$DECODE_FAULT calls to handle
the exception. The user-action argument is the address of a
descriptor pointing to your user action routine. User-action may be
of type "bound procedure value" when called by languages with
up-level addressing. If user-action is not of type "bound procedure
value," it is assumed to be the address of an entry mask.
user-arg
VMS usage: user_arg
type: unspecified
access: read only
mechanism: by value
Additional information passed from your handler without
interpretation to your user action routine. The user-arg argument
contains the value of this additional information. This is an
optional argument; if omitted, zero is used.
instruction-definitions
VMS usage: vector_byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference, array reference
Array of bytes specifying instruction opcodes and operand
definitions which are to replace or supplement the standard
instruction definitions. The instruction-definitions argument is
the address of this array.
LIB$DEC_OVER
LIB$DEC_OVER enables or disables decimal overflow detection for the
calling procedure activation. The previous decimal overflow setting
is returned.
Format:
LIB$DEC_OVER new-setting
ARGUMENT
new-setting
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
New decimal overflow enable setting. The new-setting argument is
the address of an unsigned byte that contains the new decimal
overflow enable setting. Bit 0 set to 1 means enable; bit 0 set to
0 means disable.
LIB$DELETE_FILE
LIB$DELETE_FILE deletes one or more files. The specification of the
file(s) to be deleted may include wildcards.
LIB$DELETE_FILE is similar in function to the DCL command DELETE.
Format:
LIB$DELETE_FILE filespec [,default-filespec] [,related-filespec]
[,success-routine] [,error-routine]
[,confirm-routine] [,user-arg] [,resultant-name]
[,file-scan-context]
Arguments:
filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the Record Management Services (RMS) file
specification of the file(s) to be deleted. The filespec argument
is the address of a descriptor pointing to the file specification.
If the specification includes wildcards, each file that matches the
specification is deleted. The string must not contain more than 255
characters. Any string class is supported.
default-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Default file specification of the file(s) to be deleted. The
default-filespec argument is the address of a descriptor pointing to
the default file specification. This is an optional argument; if
omitted, the default is the null string. Any string class is
supported.
related-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Related file specification of the file(s) to be deleted. The
related-filespec argument is the address of a descriptor pointing to
the related file specification. Any string class is supported.
This is an optional argument; if omitted, the default is the null
string.
success-routine
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference
User-supplied success routine that LIB$DELETE_FILE calls after it
successfully deletes a file. The success-routine argument is the
address of the entry mask of the success routine.
error-routine
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference
User-supplied error routine that LIB$DELETE_FILE calls when it
detects an error. The error-routine argument is the address of the
entry mask of this routine.
confirm-routine
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference
User-supplied confirm routine that LIB$DELETE_FILE calls before each
file is deleted. The confirm-routine argument is the address of the
entry mask of this routine. The value returned by the confirm
routine determines whether or not the file will be deleted. The
confirm routine can be used to select specific files for deletion
based on criteria such as expiration date, size, and so on.
user-arg
VMS usage: user_arg
type: unspecified
access: read only
mechanism: unspecified
User-supplied argument that LIB$DELETE_FILE passes to the error,
success and confirm routines each time they are called. Whatever
mechanism is also used to pass user-arg to LIB$DELETE_FILE is used
to pass it to the routines. This is an optional argument; if
omitted, zero is passed by value.
resultant-name
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which LIB$DELETE_FILE writes the RMS resultant file
specification of the last file processed. The resultant-name
argument is the address of a descriptor pointing to the resultant
name.
file-scan-context
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context for deleting a list of filespecs. The file-scan-context
argument is the address of a longword containing the context value.
LIB$DELETE_LOGICAL
LIB$DELETE_LOGICAL requests the calling process's Command Language
Interpreter (CLI) to delete a supervisor-mode process logical name.
LIB$DELETE_LOGICAL provides the same function as the DCL command
DEASSIGN.
Format:
LIB$DELETE_LOGICAL log-nam [,table-desc]
Arguments:
log-nam
VMS usage: logical_name
type: character string
access: read only
mechanism: by descriptor
Logical name to be deleted. The log-nam argument is the address of
a descriptor pointing to this logical name string. The maximum
length of a logical name is 255 characters.
table-desc
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the table from which the logical name is to be deleted. The
table-desc argument is the address of a descriptor pointing to this
name string. This is an optional argument. If omitted, the
LNM$PROCESS table is used.
LIB$DELETE_SYMBOL
LIB$DELETE_SYMBOL requests the calling process's Command Language
Interpreter (CLI) to delete an existing CLI symbol.
Format:
LIB$DELETE_SYMBOL symbol [,tbl-ind]
Arguments:
symbol
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the symbol to be deleted by LIB$DELETE_SYMBOL. The symbol
argument is the address of a descriptor pointing to this symbol
string. The symbol name is converted to uppercase and trailing
blanks are removed before use.
tbl-ind
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Indicator of the table which contains the symbol to be deleted. The
tbl-ind argument is the address of a signed longword integer that is
this table indicator.
LIB$DELETE_VM_ZONE
LIB$DELETE_VM_ZONE deletes a zone and returns all pages owned by the
zone to the processwide page pool.
Format:
LIB$DELETE_VM_ZONE zone-id
Arguments:
zone-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Zone identifier. The zone-id is the address of a longword that
contains the identifier of a zone created by a previous call to
LIB$CREATE_VM_ZONE or LIB$CREATE_USER_VM_ZONE.
LIB$DIGIT_SEP
LIB$DIGIT_SEP returns the system's digit separator symbol.
Format:
LIB$DIGIT_SEP digit-sep-str [,out-len]
Arguments:
digit-sep-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Digit separator symbol returned by LIB$DIGIT_SEP. The digit-sep-str
argument is the address of a descriptor pointing to the digit
separator.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of characters written into digit-sep-str, not counting
padding in the case of a fixed-length string. The out-len argument
is the address of an unsigned word containing the length of the
digit separator symbol. If the input string is truncated to the
size specified in the digit-sep-str descriptor, out-len is set to
this size. Therefore, out-len can always be used by the calling
program to access a valid substring of digit-sep-str.
LIB$DISABLE_CTRL
LIB$DISABLE_CTRL requests the calling process's Command Language
Interpreter (CLI) to not intercept the selected control characters
when they are typed during an interactive terminal session.
LIB$DISABLE_CTRL provides the same function as the DCL command SET
NOCONTROL.
Format:
LIB$DISABLE_CTRL disable-msk [,old-msk]
Arguments:
disable-msk
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Bit mask indicating which control characters are not to be
intercepted. The disable-msk argument is the address of an unsigned
longword containing this bit mask.
old-msk
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Previous bit mask. The old-msk argument is the address of an
unsigned longword into which LIB$DISABLE_CTRL writes the old bit
mask. The old bit mask is of the same form as disable-msk.
LIB$DO_COMMAND
LIB$DO_COMMAND stops program execution and directs the Command
Language Interpreter to execute a command which you supply as the
argument. If successful, LIB$DO_COMMAND does not return control to
the calling program. Instead, LIB$DO_COMMAND begins execution of
the specified command.
If you want control to return to the caller, use LIB$SPAWN instead.
Format:
LIB$DO_COMMAND cmd-text
Argument
cmd-text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text of the command which LIB$DO_COMMAND executes. The cmd-text
argument is the address of a descriptor pointing to the command
text. The maximum length of the command is 255 characters.
LIB$EDIV
LIB$EDIV performs extended-precision division. LIB$EDIV makes the
VAX EDIV instruction available as a callable procedure.
Format:
LIB$EDIV divisor ,dividend ,quotient ,remainder
Arguments:
divisor
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Divisor. The divisor argument is the address of a signed longword
integer containing the divisor.
dividend
VMS usage: quadword_signed
type: quadword integer (signed)
access: read only
mechanism: by reference
Dividend. The dividend argument is the address of a signed quadword
integer containing the dividend.
quotient
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Quotient. The quotient argument is the address of a signed longword
integer containing the quotient.
remainder
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Remainder. The remainder argument is the address of a signed
longword integer containing the remainder.
LIB$EMODx
The LIB$EMODx procedures perform accurate range reduction of
floating-point arguments. They provide the higher-level language
users with the capability to use the VAX hardware instructions
EMODF, EMODD, EMODG, and EMODH.
Format:
LIB$EMODF multiplier ,mult-ext ,multiplicand ,int ,fract
LIB$EMODD multiplier ,mult-ext ,multiplicand ,int ,fract
LIB$EMODG multiplier ,mult-ext ,multiplicand ,int ,fract
LIB$EMODH multiplier ,mult-ext ,multiplicand ,int ,fract
Arguments:
multiplier
VMS usage: floating_point
type: D_floating, F_floating, G_floating, H_floating
access: read only
mechanism: by reference
Multiplier. For LIB$EMODF, the multiplier argument is an F_floating
number. For LIB$EMODD, the multiplier argument is a D_floating
number. For LIB$EMODG, the multiplier argument is a G_floating
number. For LIB$EMODH, the multiplier argument is an H_floating
number.
mult-ext
VMS usage: byte_signed, word_unsigned
type: byte integer (signed), word (unsigned)
access: read only
mechanism: by reference
The left-justified multiplier-extension bits. For F_floating and
D_floating, the mult-ext argument is an unsigned byte. For
G_floating and H_floating, the mult-ext argument is an unsigned
word.
multiplicand
VMS usage: floating_point
type: D_floating, F_floating, G_floating, H_floating
access: read only
mechanism: by reference
Multiplicand. For LIB$EMODF, the multiplicand argument is an
F_floating number. For LIB$EMODD, the multiplicand argument is a
D_floating number. For LIB$EMODG, the multiplicand argument is a
G_floating number. For LIB$EMODH, the multiplicand argument is an
H_floating number.
int
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Integer portion of the result. The int argument is the address of a
signed longword integer containing the integer portion of the
result.
fract
VMS usage: floating_point
type: D_floating, F_floating, G_floating, H_floating
access: write only
mechanism: by reference
Fractional portion of the result. For LIB$EMODF, the fract argument
is an F_floating number. For LIB$EMODD, the fract argument is a
D_floating number. For LIB$EMODG, the fract argument is a
G_floating number. For LIB$EMODH, the fract argument is an
H_floating number.
LIB$EMUL
LIB$EMUL performs extended-precision multiplication. LIB$EMUL makes
the VAX EMUL instruction available as a callable procedure.
Format:
LIB$EMUL multiplier ,multiplicand ,addend ,product
Arguments:
multiplier
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Multiplier used by LIB$EMUL in the extended-precision
multiplication. The multiplier argument is the address of a signed
longword integer containing the multiplier.
multiplicand
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Multiplicand used by LIB$EMUL in the extended-precision
multiplication. The multiplicand argument is the address of a
signed longword integer containing the multiplicand.
addend
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Addend used by LIB$EMUL in the extended-precision multiplication.
The addend argument is the address of a signed longword integer
containing the addend.
product
VMS usage: quadword_signed
type: quadword integer (signed)
access: write only
mechanism: by reference
Product of the extended-precision multiplication. The product
argument is the address of a signed quadword integer into which
LIB$EMUL writes the product.
LIB$ENABLE_CTRL
LIB$ENABLE_CTRL requests the calling process's Command Language
Interpreter (CLI) to resume interception of the selected control
characters when they are typed during an interactive terminal
session. LIB$ENABLE_CTRL provides the same function as the DCL
command SET CONTROL.
Format:
LIB$ENABLE_CTRL enable-msk [,old-msk]
Arguments:
enable-msk
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Bit mask indicating for which control characters LIB$ENABLE_CTRL is
to enable interception. The enable-msk argument is the address of
an unsigned longword containing this bit mask. Each of the 32 bits
corresponds to one of the 32 possible control characters. If a bit
is set, the corresponding control character is intercepted by the
CLI. Currently, only bits 20 and 25, corresponding to CTRL/T and
CTRL/Y, are recognized.
old-msk
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Previous bit mask. The old-msk argument is the address of an
unsigned longword containing the old bit mask. The old bit mask is
of the same form as enable-msk.
LIB$ESTABLISH
LIB$ESTABLISH moves the address of a condition handling routine
(which can be a user-written or a library procedure) to longword 0
of the stack frame of the caller of LIB$ESTABLISH.
Format:
LIB$ESTABLISH new-handler
Argument
new-handler
VMS usage: procedure
type: procedure entry mask
access: read only
mechanism: by reference
Routine to be set up as the condition handler. The new-handler
argument is the address of the procedure entry mask to this routine.
LIB$EXTV
LIB$EXTV returns a sign-extended longword field that has been
extracted from the specified variable bit field. LIB$EXTV makes the
VAX EXTV instruction available as a callable procedure.
Format:
LIB$EXTV pos ,size ,base
Arguments:
pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Position (relative to the base address) of the first bit in the
field that LIB$EXTV extracts. The pos argument is the address of a
signed longword integer containing the position.
size
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference, array reference
Size of the bit field LIB$EXTV extracts. The size argument is the
address of an unsigned byte containing the size. The maximum size
is 32 bits.
base
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Base address of the bit field LIB$EXTV extracts from the specified
variable bit field. The base argument is an unsigned longword
containing the base address.
LIB$EXTZV
LIB$EXTZV returns a longword zero-extended field that has been
extracted from the specified variable bit field. LIB$EXTZV makes
the VAX EXTZV instruction available as a callable procedure.
Format:
LIB$EXTZV pos ,size ,base
Arguments:
pos
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Position (relative to the base address) of the first bit in the
field LIB$EXTZV extracts. The pos argument is the address of a
signed longword integer containing the position.
size
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Size of the bit field LIB$EXTZV extracts. The size argument is the
address of an unsigned byte containing the size. The maximum size
is 32 bits.
base
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Base address of the bit field LIB$EXTZV extracts. The base argument
is the address of an unsigned longword containing the base address.
LIB$FFx
LIB$FFC and LIB$FFS search the field specified by the start
position, size, and base for the first clear or set bit. LIB$FFC
and LIB$FFS make the VAX FFC and FFS instructions available as
callable procedures.
Format:
LIB$FFC start-pos ,size ,base ,find-pos
LIB$FFS start-pos ,size ,base ,find-pos
Arguments:
start-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Starting position, relative to the base address, of the bit field to
be searched by LIB$FFx. The start-pos argument is the address of a
signed longword integer containing the starting position.
size
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Number of bits to be searched by LIB$FFx. The size argument is the
address of an unsigned byte containing the size of the bit field to
be searched. The maximum size is 32 bits.
base
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Base address of the bit field which LIB$FFx searches. The base
argument is the address of an unsigned longword containing the base
address.
find-pos
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Bit position of the first bit in the specified state (clear or set),
relative to the base address. The find-pos argument is the address
of a signed longword integer into which LIB$FFC writes the position
of the first clear bit and into which LIB$FFS writes the position of
the first set bit.
LIB$FILE_SCAN
LIB$FILE_SCAN searches an area, such as a directory, for all files
matching the file specification given and transfers program
execution to the specified user-written routine. Wildcards are
acceptable. An action routine is called for each file and/or error
found. LIB$FILE_SCAN allows the search sequence to continue even if
an error occurs while processing a particular file.
Format:
LIB$FILE_SCAN fab ,success-rtn ,error-rtn [,context]
Arguments:
fab
VMS usage: fab
type: unspecified
access: read only
mechanism: by reference
File Access Block (FAB) referencing a valid NAM block. The fab
argument is the address of the FAB which contains the address and
length of the file specification being searched for by
LIB$FILE_SCAN.
success-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied success routine that LIB$FILE_SCAN calls when a file
is found. The success-rtn argument is the address of the procedure
entry mask to the success routine. The success routine is invoked
with the FAB address that was passed to LIB$FILE_SCAN. The user
context may be pased to this routine using the FAB$L_CTX field in
the FAB.
error-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied error routine that LIB$FILE_SCAN calls when it
encounters an error. The error-rtn argument is the address of the
procedure entry mask to the error routine. The error routine is
called with the FAB argument that was passed to LIB$FILE_SCAN.
context
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Default file context used in processing file specifications for
multiple input files. The context argument is the address of a
longword, which must be initialized to zero by your program before
the first call to LIB$FILE_SCAN. After the first call,
LIB$FILE_SCAN maintains this longword. You must not change the
value of context in subsequent calls to LIB$FILE_SCAN.
LIB$FILE_SCAN_END
LIB$FILE_SCAN_END is called after each sequence of calls to
LIB$FILE_SCAN. LIB$FILE_SCAN_END deallocates any saved Record
Management Service (RMS) context and deallocates the virtual memory
which had been allocated for holding the related file specification
information.
Format:
LIB$FILE_SCAN_END fab [,context]
Arguments:
fab
VMS usage: fab
type: unspecified
access: modify
mechanism: by reference
File Access Block (FAB) used with LIB$FILE_SCAN. The fab argument
is the address of the FAB which contains the address and length of
the file specification.
context
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Temporary default context used in LIB$FILE_SCAN. The context
argument is the address of a longword containing this temporary
default context.
LIB$FIND_FILE
LIB$FIND_FILE is called with a wildcard file specification for which
it searches. LIB$FIND_FILE returns all file specifications that
satisfy that wildcard file specification.
Format:
LIB$FIND_FILE file-spec ,result-spec ,context [,default-spec]
[,related-spec] [,stv-addr] [,user-flags]
Arguments:
file-spec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File specification, which may contain wildcards, that LIB$FIND_FILE
uses to search for the desired file. The file-spec argument is the
address of a descriptor pointing to the file specification. The
maximum length of a file specification is 255 bytes.
result-spec
VMS usage: char_string
type: character string
access: modify
mechanism: by descriptor
Resultant file specification that LIB$FIND_FILE returns when it
finds a file that matches the specification in the file-spec
argument. The result-spec argument is the address of a descriptor
pointing to the resultant file specification.
context
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Zero or an address of an internal FAB/NAM buffer from a previous
call to LIB$FIND_FILE. The context argument is an unsigned longword
integer containing the address of the context. LIB$FIND_FILE uses
this argument to retain the context when processing multiple input
files. Portions of file specifications that the user does not
specify are inherited from the last files processed because the file
contexts are retained in this argument.
default-spec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Default file specification. The default-spec argument is the
address of a descriptor pointing to the default file specification.
related-spec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Related file specification containing the context of the last file
processed. The related-spec argument is the address of a descriptor
pointing to the related file specification.
stv-addr
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Record Management Service (RMS) secondary status value from a
failing RMS operation. The stv-addr argument is an unsigned
longword containing the address of a longword-length buffer to
receive the RMS secondary status value (usually returned in the file
access block field, FAB$L_STV).
user-flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
User flags. The user-flags argument is the address of an unsigned
longword containing the user flags.
LIB$FIND_FILE_END
LIB$FIND_FILE_END is called once after each sequence of calls to
LIB$FIND_FILE. LIB$FIND_FILE_END deallocates any saved Record
Management Service (RMS) context and deallocates the virtual memory
used to hold the allocated context block.
Format:
LIB$FIND_FILE_END context
Arguments:
context
VMS usage: context
type: longword (unsigned)
access: read only
mechanism: by reference
Zero or the address of a FAB/NAM buffer from a previous call to
LIB$FIND_FILE. The context argument is the address of a longword
that contains this context.
LIB$FIND_IMAGE_SYMBOL
LIB$FIND_IMAGE_SYMBOL reads universal symbols from the shareable
image file. This routine then dynamically activates a shareable
image into the P0 address space of a process.
Format:
LIB$FIND_IMAGE_SYMBOL filename ,symbol-desc ,symbol-val
Arguments:
filename
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the file for which LIB$FIND_IMAGE_SYMBOL is searching. The
filename argument is the address of a descriptor pointing to this
file name string. This argument may contain only the file name.
File type cannot be indicated. If any file specification
punctuation characters (:, [, <, .) are present, the error
SS$_IVLOGNAM is returned.
symbol-desc
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Symbol for which LIB$FIND_IMAGE_SYMBOL is searching in the filename
file. The symbol-desc argument is the address of a descriptor
pointing to the symbol name string. The symbol name string must be
input in uppercase letters; this routine does not perform uppercase
conversion.
symbol-val
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
Symbol value that LIB$FIND_IMAGE_SYMBOL has located. The symbol-val
argument is the address of a signed longword integer into which
LIB$FIND_IMAGE_SYMBOL returns the symbol value. If the symbol is
relocatable, the starting virtual address of the shareable image in
memory will be added to the symbol value.
LIB$FIXUP_FLT
LIB$FIXUP_FLT finds the reserved operand of any F_floating,
D_floating, G_floating, or H_floating instruction (with some
exceptions) after a reserved operand fault has been signaled.
LIB$FIXUP_FLT changes the reserved operand from --0.0 to the value
of the new-operand argument, if present; or to +0.0 if new-operand
is absent.
Format:
LIB$FIXUP_FLT sig-args ,mch-args [,new-operand]
Arguments:
sig-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Signal argument vector. The sig-args argument is the address of an
an array of unsigned longwords containing the signal argument
vector.
mch-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Mechanism argument vector. The mch-args argument is the address of
an array of unsigned longwords containing the mechanism argument
vector.
new-operand
VMS usage: floating-point
type: F_floating
access: read only
mechanism: by reference
An F_floating value to replace the reserved operand. The
new-operand argument is the address of an F_floating number
containing the new operand. This is an optional argument. If
omitted, the default value is +0.0.
LIB$FLT_UNDER
LIB$FLT_UNDER enables or disables floating-point underflow detection
for the calling procedure activation. The previous setting is
returned as a function value.
Format:
LIB$FLT_UNDER new-setting
Argument
new-setting
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
New floating-point underflow enable setting. The new-setting
argument is the address of an unsigned byte containing the new
setting. Bit 0 set to 1 means enable; bit 0 set to 0 means disable.
LIB$FREE_EF
LIB$FREE_EF frees a local event flag previously allocated by
LIB$GET_EF. LIB$FREE_EF is the complement of LIB$GET_EF.
Format:
LIB$FREE_EF event-flag-num
Argument
event-flag-num
VMS usage: ef_number
type: longword integer (signed)
access: read only
mechanism: by reference
Event flag number to be deallocated by LIB$FREE_EF. The
event-flag-num argument is the address of a signed longword integer
that contains the event flag number, which is the value returned to
the user by LIB$GET_EF.
LIB$FREE_LUN
LIB$FREE_LUN releases a logical unit number allocated by LIB$GET_LUN
to the pool of available numbers. LIB$FREE_LUN is the complement of
LIB$GET_LUN.
Format:
LIB$FREE_LUN log-unit-num
Argument
log-unit-num
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Logical unit number to be deallocated. The log-unit-num argument is
the address of a signed longword integer that contains this logical
unit number, which is the value previously returned by LIB$GET_LUN.
LIB$FREE_TIMER
LIB$FREE_TIMER frees the storage allocated by LIB$INIT_TIMER.
Format:
LIB$FREE_TIMER handle-adr
Argument
handle-adr
VMS usage: address
type: longword (unsigned)
access: modify
mechanism: by reference
Pointer to a block of storage containing the value returned by a
previous call to LIB$INIT_TIMER; this is the storage that
LIB$FREE_TIMER deallocates. The handle-adr argument is the address
of an unsigned longword integer containing that value.
LIB$FREE_VM
LIB$FREE_VM deallocates an entire block of contiguous bytes that
were allocated by a previous call to LIB$GET_VM. The arguments
passed are the same as for LIB$GET_VM.
Format:
LIB$FREE_VM num-bytes ,base-adr [,zone-id]
Arguments:
num-bytes
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of contiguous bytes to be deallocated by LIB$FREE_VM. The
num-bytes argument is the address of a signed longword integer that
contains this number. The value of num-bytes must be greater than
zero.
base-adr
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
Address of the first byte to be deallocated by LIB$FREE_VM. The
base-adr argument contains the address of an unsigned longword that
is this address. The value of base-adr must be the address of a
block of memory that was allocated by a previous call to LIB$GET_VM.
zone-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The zone-id argument is the address of a longword that contains a
zone identifier created by a previous call to LIB$CREATE_VM_ZONE or
LIB$CREATE_USER_VM_ZONE.
LIB$FREE_VM_PAGE
LIB$FREE_VM_PAGE deallocates a block of contiguous pages that were
allocated by previous calls to LIB$GET_VM_PAGE.
Format:
LIB$FREE_VM_PAGE num-pages ,base-adr
Arguments:
num-pages
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of pages. The num-pages argument is the address of a
longword integer which specifies the number of contiguous pages to
be deallocated. The value of num-pages must be greater than zero.
base-adr
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
Block address. The base-adr argument is the address of a longword
which contains the address of the first byte of the first page to be
deallocated.
LIB$GET_COMMAND
LIB$GET_COMMAND gets one record of ASCII text from the current
controlling input device, specified by the logical name SYS$COMMAND.
Format:
LIB$GET_COMMAND get-str [,prompt-str] [,out-len]
Arguments:
get-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String that LIB$GET_COMMAND gets from SYS$COMMAND. The get-str
argument is the address of a descriptor pointing to this string.
prompt-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Prompt message that LIB$GET_COMMAND displays on the controlling
terminal. The prompt-str argument is the address of a descriptor
pointing to the prompt. A valid prompt consists of text followed by
no carriage-return/line-feed combination. A colon(:) and one space
are optional.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of bytes written into get-str by LIB$GET_COMMAND, not
counting padding in the case of a fixed string. The out-len
argument is the address of an unsigned word containing this length.
If the input string is truncated to the size specified in the
get-str descriptor, out-len is set to this size. Therefore, out-len
can always be used by the calling program to access a valid
substring of get-str.
LIB$GET_COMMON
LIB$GET_COMMON copies a string in the common area to the destination
string. (The common area is an area of storage which remains
defined across multiple image activations in a process.) The string
length is taken from the first longword of the common area.
Format:
LIB$GET_COMMON dst-str [,chars-copied]
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which LIB$GET_COMMON writes the string
copied from the common area. The dst-str argument is the address of
a descriptor pointing to the destination string.
chars-copied
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of characters written into dst-str by LIB$GET_COMMON, not
counting padding in the case of a fixed-length string. The
chars-copied argument is the address of a signed word integer
containing the number of characters copied. If the input string is
truncated to the size specified in the dst-str descriptor,
chars-copied is set to this size. Therefore, chars-copied can
always be used by the calling program to access a valid substring of
dst-str.
LIB$GETDVI
LIB$GETDVI provides a simplified interface to the $GETDVI system
service. It returns information about the primary and secondary
device characteristics of an I/O device. The calling process need
not have a channel assigned to the device about which it wants
information.
Format:
LIB$GETDVI item-code [,channel] [,device-name] [,out-value]
[,out-string] [,out-len]
Arguments:
item-code
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Code specifying the item of information you are requesting. The
item-code argument is the address of a signed longword integer
containing the item code. All valid $GETDVI item codes, whose names
begin with DVI$_, are accepted.
channel
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by reference
VMS I/O channel assigned to the device for which LIB$GETDVI returns
information. The channel argument is the address of an unsigned
word containing the channel specification. If channel is not
specified, device-name is used instead. You must specify either
channel or device-name, but not both. If both or neither is
specified, the error status LIB$_INVARG is returned.
device-name
VMS usage: device_name
type: character string
access: read only
mechanism: by descriptor
Name of the device for which LIB$GETDVI returns information. The
device-name argument is the address of a descriptor pointing to the
device name string. If this string contains a colon, the colon and
the characters that follow it are ignored.
out-value
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Numeric value of the information requested. The out-value argument
is the address of an unsigned longword containing the numeric value.
If an item is listed as only returning a string value, this argument
is ignored.
out-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String representation of the information requested. The out-string
argument is the address of a descriptor pointing to this
information. If out-string is not specified and if the value
returned has only a string representation, the error status
LIB$_INVARG is returned.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of significant characters written to out-string by
LIB$GETDVI. The out-len argument is the address of an unsigned word
containing this length.
LIB$GET_EF
LIB$GET_EF allocates one local event flag from a process-wide pool
and returns the number of the allocated flag to the caller. If no
flags are available, LIB$GET_EF returns an error as its function
value.
Format:
LIB$GET_EF event-flag-num
Argument
event-flag-num
VMS usage: ef_number
type: longword integer (signed)
access: write only
mechanism: by reference
Number of the local event flag that LIB$GET_EF allocated, or --1 if
no local event flag was available. The event-flag-num argument is
the address of a signed longword integer into which LIB$GET_EF
writes the number of the local event flag that it allocates.
LIB$GET_FOREIGN
LIB$GET_FOREIGN requests the calling image's Command Language
Interpreter (CLI) to return the contents of the "foreign command"
line that activated the current image.
Format:
LIB$GET_FOREIGN get-str [,user-prompt] [,out-len]
[,force-prompt]
Arguments:
get-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String which LIB$GET_FOREIGN uses to receive the foreign command
line. The get-str argument is the address of a descriptor pointing
to this string. If the foreign command text returned was obtained
by prompting to SYS$INPUT (see the description of force-prompt), the
text is translated to uppercase so as to be more consistent with
text returned from the CLI.
user-prompt
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Optional user-supplied prompt for text which LIB$GET_FOREIGN uses if
no command-line text is available. The user-prompt argument is the
address of a descriptor pointing to the user prompt. If omitted, no
prompting is performed. It is recommended that user-prompt be
specified. If user-prompt is omitted and if no command-line text is
available, a zero-length string will be returned.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of bytes written into get-str by LIB$GET_FOREIGN, not
counting padding in the case of a fixed-length get-str. The out-len
argument is the address of an unsigned word into which
LIB$GET_FOREIGN writes the number of bytes.
force-prompt
VMS usage: longword_signed
type: longword integer (signed)
access: modify
mechanism: by reference
Value which LIB$GET_FOREIGN uses to control whether or not prompting
is to be performed. The force-prompt argument is the address of a
signed longword integer containing this value. If the low bit of
force-prompt is zero, or if force-prompt is omitted, prompting is
done only if the CLI does not return a command line. If the low bit
is 1, prompting is done unconditionally. If specified, force-prompt
is set to 1 before returning to the caller.
LIB$GET_INPUT
LIB$GET_INPUT gets one record of ASCII text from the current
controlling input device, specified by SYS$INPUT.
Format:
LIB$GET_INPUT get-str [,prompt-str] [,out-len]
Arguments:
get-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String which LIB$GET_INPUT gets from the input device. The get-str
argument is the address of a descriptor pointing to the character
string into which LIB$GET_INPUT writes the text received from the
current input device.
prompt-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Prompt message that is displayed on the controlling terminal. The
prompt-str argument is the address of a descriptor containing the
prompt. A valid prompt consists of text followed by a colon (:), a
space, and no carriage-return/line-feed combination. The maximum
size of the prompt message is 255 characters. If the controlling
input device is not a terminal, this argument is ignored.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of bytes written into get-str by LIB$GET_INPUT, not counting
padding in the case of a fixed string. The out-len argument is the
address of an unsigned word containing this number. If the input
string is truncated to the size specified in the get-str descriptor,
out-len is set to this size. Therefore, out-len can always be used
by the calling program to access a valid substring of get-str.
LIB$GETJPI
LIB$GETJPI provides a simplified interface to the $GETJPI system
service. It provides accounting, status, and identification
information about a specified process.
LIB$GETJPI obtains only one item of information in a single call.
Format:
LIB$GETJPI item-code [,process-id] [,process-name]
[,out-value] [,out-string] [,out-len]
Arguments:
item-code
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Item identifier code specifying the item of information you are
requesting. The item-code argument is the address of a signed
longword integer containing the item code. You may request only one
item in each call to LIB$GETJPI.
process-id
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification of the process for which you are requesting
information. The process-id argument is the address of an unsigned
longword containing the process identification. If you do not
specify process-id, process-name is used.
process-name
VMS usage: process_name
type: character string
access: read only
mechanism: by descriptor
A 1- to 15-character string specifying the name of the process for
which you are requesting information. The name must correspond
exactly to the name of the process for which you are requesting
information; LIB$GETJPI does not allow trailing blanks or
abbreviations.
out-value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Numeric value of the information you requested. The out-value
argument is the address of a longword or quadword into which
LIB$GETJPI writes the numeric value of this information. If the item
you requested returns only a string value, this argument is ignored.
out-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String representation of the information you requested. The
out-string argument is the address of a character string into which
LIB$GETJPI writes the string representation.
out-len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of significant characters written to out-string by
LIB$GETJPI. The out-len argument is the address of a signed word
integer into which LIB$GETJPI writes the number of characters.
LIB$GET_LUN
LIB$GET_LUN allocates one logical unit number from a process-wide
pool. If a unit is available, its number is returned to the caller.
Otherwise, an error is returned as the function value.
Format:
LIB$GET_LUN log-unit-num
Arguments:
log-unit-num
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Allocated logical unit number or --1 if none was available. The
log-unit-num argument is the address of a longword into which
LIB$GET_LUN returns the value of the allocated logical unit.
LIB$GETSYI
LIB$GETSYI provides a simplified interface to the $GETSYI system
service. The $GETSYI system service obtains status and
identification information about the system. LIB$GETSYI returns
only one item of information in a single call.
Format:
LIB$GETSYI item-code [,out-value] [,out-string] [,out-len]
[,csid] [,node-name]
Arguments:
item-code
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Item code specifying the desired item of information. The item-code
argument is the address of a signed longword integer containing this
item code. All valid $GETSYI item codes are accepted.
out-value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Numeric value returned by LIB$GETSYI. The out-value argument is the
address of a longword or quadword containing this value. If an item
is listed as returning only a string value, this argument is
ignored.
out-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Information returned by LIB$GETSYI. The out-string argument is the
address of a descriptor pointing to the character string that will
receive this information.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of significant characters written to out-string, not
including blank padding or truncated characters. The out-len
argument is the address of an unsigned word into which LIB$GETSYI
returns this number.
csid
VMS usage: longword_unsigned
type: longword (unsigned)
access: modify
mechanism: by reference
Cluster system identification (CSID) of the node for which
information is to be returned. The csid argument is the address of
this CSID. If both csid and node-name are specified, LIB$GETSYI
uses node-name and writes into the csid argument the CSID
corresponding to the node identified by node name.
node-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the node for which information is to be returned. The
node-name argument is the address of a descriptor pointing to the
node name string. If node-name is not specified, csid is used. If
neither node-name nor csid is specified, the caller's node is used.
See the csid argument for more information.
LIB$GET_SYMBOL
LIB$GET_SYMBOL requests the calling process's Command Language
Interpreter (CLI) to return the value of a CLI symbol as a string.
LIB$GET_SYMBOL then returns the string to the caller. Optionally,
LIB$GET_SYMBOL can return the length of the returned value and the
table in which the symbol was found.
Format:
LIB$GET_SYMBOL symbol ,ret-buf [,ret-len] [,tbl-ind]
Arguments:
symbol
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the symbol for which LIB$GET_SYMBOL searches. The symbol
argument is the address of a descriptor pointing to the name of the
symbol. LIB$GET_SYMBOL converts the symbol name to uppercase and
removes trailing blanks before the search. Symbol must begin with a
letter or dollar sign ($). The maximum length of symbol is 255
characters.
ret-buf
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Value of the returned symbol. The ret-buf argument is the address
of a descriptor pointing to a character string into which
LIB$GET_SYMBOL writes the value of the symbol.
ret-len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Length of the symbol value returned by LIB$GET_SYMBOL. The ret-len
argument is the address of a signed word integer into which
LIB$GET_SYMBOL writes the length.
tbl-ind
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Indicator of which table contained the symbol. The tbl-ind argument
is the address of a signed longword integer into which
LIB$GET_SYMBOL writes the table indicator.
LIB$GET_VM
LIB$GET_VM allocates a specified number of contiguous bytes in the
program region and returns the virtual address of the first byte
allocated.
Format:
LIB$GET_VM num-bytes, base-adr [,zone-id]
Arguments:
num-bytes
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of contiguous bytes that LIB$GET_VM allocates. The num-bytes
argument is the address of a longword integer containing the number
of bytes. LIB$GET_VM allocates enough memory to satisfy the
request. Your program should not reference an address before the
first byte address allocated (base-adr) or beyond the last byte
allocated (base-adr + num-bytes -- 1) since that space may be
assigned to another procedure. The value of num-bytes must be
greater than zero.
base-adr
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
First virtual address of the contiguous block of bytes allocated by
LIB$GET_VM. The base-adr argument is the address of an unsigned
longword containing this base address.
zone-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The zone-id argument is the address of a longword that contains a
zone identifier created by a previous call to LIB$CREATE_VM_ZONE or
LIB$CREATE_USER_VM_ZONE. This argument is optional. If zone-id is
omitted or if the longword contains the value 0, LIB$VM's default
zone is used.
LIB$GET_VM_PAGE
LIB$GET_VM_PAGE allocates a specified number of contiguous pages of
memory in the program region and returns the virtual address of the
first page allocated.
Format:
LIB$GET_VM_PAGE num-pages ,base-adr
Arguments:
num-pages
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of pages. The num-pages argument is the address of a
longword integer which specifies the number of contiguous pages to
be allocated. The value of num-pages must be greater than zero.
base-adr
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Block address. The base-adr argument is the address of a longword
which is set to the address of the first byte of the newly allocated
block of pages.
LIB$ICHAR
LIB$ICHAR converts the first character of a source string to an
8-bit ASCII integer extended to a longword.
Format:
LIB$ICHAR src-str
ARGUMENT
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string whose first character is converted to an integer by
LIB$ICHAR. The scr-str argument is the address of a descriptor
pointing to this source string.
LIB$INDEX
LIB$INDEX returns an index, which is the relative position of the
first occurrence of a substring in the source string.
Format:
LIB$INDEX src-str ,sub-str
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string to be searched by LIB$INDEX. The src-str argument is
the address of a descriptor pointing to this source string.
sub-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Substring to be found. The sub-str argument is the address of a
descriptor pointing to this substring.
LIB$INIT_TIMER
LIB$INIT_TIMER stores the current values of specified times and
counts for use by LIB$SHOW_TIMER or LIB$STAT_TIMER.
Format:
LIB$INIT_TIMER [handle-adr]
Argument
handle-adr
VMS usage: longword_unsigned
type: longword (unsigned)
access: modify
mechanism: by reference
Pointer to a control block where the values of times and counts will
be stored. The handle-adr argument contains the address of an
unsigned longword that is this pointer. When you call
LIB$INIT_TIMER, you must use the optional handle-adr argument only
if you want to maintain several sets of statistics simultaneously.
o If handle-adr is omitted, the control block is allocated in
static storage. This method is not AST reentrant.
o If handle-adr is zero, a control block is allocated in dynamic
heap storage. The times and counts will be stored in that block
and the address of the block returned in handle-adr. This method
is fully reentrant and modular.
o If handle-adr is nonzero, it is considered to be the address of a
control block previously allocated by a call to LIB$INIT_TIMER.
If so, the control block is reused, and fresh times and counts
are stored in it.
LIB$INSERT_TREE
LIB$INSERT_TREE inserts a node in a balanced binary tree.
Format:
LIB$INSERT_TREE treehead ,sym-str ,ctrl-flg ,compare-rtn
,alloc-rtn ,newnode [,user-data]
Arguments:
treehead
VMS usage: longword_unsigned
type: longword (unsigned)
access: modify
mechanism: by reference
Tree head for the binary tree. The treehead argument is the address
of a longword that is this tree head.
sym-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Key to be inserted. The sym-str argument is the address of a
descriptor pointing to the symbol key.
ctrl-flg
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Control flags. The ctrl-flg argument is the address of the control
flags. Currently only bit zero is used.
Bit Description
0 If clear, the address of the existing duplicate entry
is returned. If set, duplicate entries are inserted.
compare-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied compare routine that LIB$INSERT_TREE calls to compare
a symbol with a node. The compare-rtn argument is the address of
the entry mask to the compare routine. The compare-rtn argument is
required; LIB$INSERT_TREE always calls the compare routine. The
value returned by the compare routine indicates the relationship
between the symbol key and the node.
alloc-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied allocate routine that LIB$INSERT_TREE calls to
allocate virtual memory for a node. The alloc-rtn argument is the
address of the entry mask to the allocate routine. The alloc-rtn
argument is required; LIB$INSERT_TREE always calls the allocate
routine.
newnode
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Location where the new key is inserted. The newnode argument is the
address of an unsigned longword that is this new node location.
user-data
VMS usage: user_arg
type: unspecified
access: unspecified
mechanism: unspecified
User data that LIB$INSERT_TREE passes to the compare and allocate
routines. User-data is an optional argument.
LIB$INSQHI
LIB$INSQHI inserts a queue entry at the head of the specified
self-relative interlocked queue. LIB$INSQHI makes the VAX/VMS
INSQHI instruction available as a callable procedure.
Format:
LIB$INSQHI entry ,header [,retry-cnt]
Arguments:
entry
VMS usage: quadword_signed
type: quadword integer (signed)
access: modify
mechanism: by reference, array reference
Entry to be inserted by LIB$INSQHI. The entry argument contains the
address of this signed quadword-aligned array that must be at least
eight bytes long. Bytes following the first eight bytes can be used
for any purpose by the calling program.
header
VMS usage: quadword_signed
type: quadword integer (signed)
access: modify
mechanism: by reference
Queue header specifying the queue into which entry is to be
inserted. The header argument contains the address of this signed
aligned quadword integer. Header must be initialized to zero before
first use of the queue; zero means an empty queue.
retry-cnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The number of times the insertion is to be retried in case of
secondary-interlock failure of the queue instruction in a
processor-shared memory application. The retry-cnt argument is the
address of an unsigned longword that contains the retry count value.
A value of 1 causes no retries. The default value is 10.
LIB$INSQTI
LIB$INSQTI inserts a queue entry at the tail of the specified
self-relative interlocked queue. LIB$INSQTI makes the VAX INSQTI
instruction available as a callable procedure.
Format:
LIB$INSQTI entry ,header [,retry-cnt]
Arguments:
entry
VMS usage: quadword_signed
type: quadword integer (signed)
access: modify
mechanism: by reference, array reference
Entry to be inserted at the tail of the queue by LIB$INSQTI. The
entry argument contains the address of this signed quadword-aligned
array that must be at least eight bytes long. Bytes following the
first eight bytes can be used for any purpose by the calling
program.
header
VMS usage: quadword_signed
type: quadword integer (signed)
access: modify
mechanism: by reference
Queue header specifying the queue into which the queue entry is to
be inserted. The header argument contains the address of this
signed aligned quadword integer. Header must be initialized to zero
before first use of the queue; zero means an empty queue.
retry-cnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The number of times the insertion is to be retried in case of
secondary-interlock failure of the queue instruction in a
processor-shared memory application. The retry-cnt argument is the
address of a longword which contains the retry count value. The
default value is 10.
LIB$INSV
LIB$INSV replaces the variable bit field specified by the base,
position, and size arguments with bits 0 through ( size - 1)) of the
source field. If the size of the bit field is zero, nothing is
inserted. LIB$INSV makes the VAX INSV instruction available as a
callable procedure.
Format:
LIB$INSV src ,pos ,size ,base
Arguments:
src
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Source field to be inserted by LIB$INSV. The src argument is the
address of a signed longword integer that contains this source
field.
pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Bit position relative to the base address where insertion of src is
to begin. The pos argument is the address of a longword integer
that contains this relative bit position.
size
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Size of the bit field to be inserted by LIB$INSV. The size argument
is the address of an unsigned byte which contains the size of this
bit field. The maximum size is 32 bits.
base
VMS usage: address
type: aligned bit string
access: write only
mechanism: by reference
Field into which LIB$INSV writes the source field. The base
argument contains the base address of this aligned bit string.
LIB$INT_OVER
LIB$INT_OVER enables or disables integer overflow detection for the
calling procedure activation. The previous integer overflow enable
setting is returned.
Format:
LIB$INT_OVER new-setting
Argument
new-setting
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
New integer overflow enable setting. The new-setting argument is
the address of an unsigned byte which contains the new integer
overflow enable setting. Bit 0 set to 1 means enable, bit 0 set to
0 means disable.
LIB$LEN
LIB$LEN returns the length of a string.
Format:
LIB$LEN src-str
Argument
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string whose length is returned by LIB$LEN. The src-str
argument contains the address of a descriptor pointing to this
source string.
LIB$LOCC
LIB$LOCC locates a character in a string by comparing successive
bytes in the string with the character specified. The search
continues until the character is found or the string has no more
characters. LIB$LOCC makes the VAX LOCC instruction available as a
callable procedure.
Format:
LIB$LOCC char-str ,src-str
Arguments:
char-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String whose initial character is used by LIB$LOCC in the search.
The char-str argument contains the address of a descriptor pointing
to this string. Only the first character of char-str is used, and
its length is not checked.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String to be searched by LIB$LOCC. The src-str argument is the
address of a descriptor pointing to this character string.
LIB$LOOKUP_KEY
LIB$LOOKUP_KEY scans a table of keywords to find one that matches
the keyword or keyword abbreviation specified by search-str.
Format:
LIB$LOOKUP_KEY search-str ,key-table [,key-value] [,full-str]
[,out-len]
Arguments:
search-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String for which LIB$LOOKUP_KEY will search in the keyword table.
The search-str argument is the address of a descriptor pointing to
this string.
key-table
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Keyword table. The key-table argument contains the address of an
array of unsigned longwords that is this keyword table.
key-value
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Value of the keyword found by LIB$LOOKUP_KEY. The key-value
argument contains the address of an unsigned longword that is this
keyword value. LIB$LOOKUP_KEY writes the address of this unsigned
longword into key-value.
full-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Full keyword match. The full-str argument contains the address of a
descriptor pointing to the keyword string. LIB$LOOKUP_KEY writes
the address of this descriptor into full-str if the full keyword is
matched.
out-len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of characters in the keyword, independent of padding. The
out-len argument is the address of a signed word integer that
contains the number of characters in the keyword. LIB$LOOKUP_KEY
writes the address of this signed word integer into out-len.
LIB$LOOKUP_TREE
LIB$LOOKUP_TREE looks up an entry in a balanced binary tree.
Format:
LIB$LOOKUP_TREE treehead ,sym-str ,compare-rtn ,newnode
Arguments:
treehead
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Tree head for the binary tree. The treehead argument is the address
of an unsigned longword that is this tree head.
sym-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Key to be looked up in the binary tree. The sym-str argument is the
address of a descriptor pointing to the symbol key.
compare-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied compare routine that LIB$LOOKUP_TREE calls to compare
a symbol with a node. The compare-rtn argument is the address of
the entry mask to the compare routine. The value returned by the
compare routine indicates the relationship between the symbol key
and the current node.
newnode
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Location where the new symbol was found. The newnode argument is
the address of an unsigned longword that is the new node location.
LIB$LP_LINES
LIB$LP_LINES computes the default number of lines on a printer page.
This procedure can be used by native-mode VAX/VMS utilities that
produce listing files and do pagination.
Format:
LIB$LP_LINES
NONE
LIB$MATCHC
LIB$MATCHC searches a source string for a specified substring and
returns an index, which is the relative position of the first
occurrence of a substring in the source string. LIB$MATCHC makes
the VAX MATCHC instruction available as a callable procedures.
Format:
LIB$MATCHC sub-str ,scr-str
Arguments:
sub-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Substring to be found. The sub-str argument is the address of a
descriptor pointing to this substring.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string to be searched by LIB$MATCHC. The src-str argument is
the address of a descriptor pointing to this source string.
LIB$MATCH_COND
LIB$MATCH_COND checks to see if a given condition value matches a
list of condition values that you supply.
Format:
LIB$MATCH_COND cond-val ,cond-val-i ,...
Arguments:
cond-val
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by reference
Condition value to be matched. The cond-val argument is the address
of an unsigned longword that contains this condition value.
cond-val-i
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by reference
The condition value(s) to be compared to cond-val. The cond-val-i
argument(s) are the address(es) of the unsigned longword(s) that
contain these condition value(s).
LIB$MOVC3
LIB$MOVC3 makes the VAX MOVC3 instruction available as a callable
procedure. The source item is moved to the destination item.
Overlap of the source and destination items does not affect the
result.
Format:
LIB$MOVC3 length ,source ,dest
Arguments:
length
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Number of bytes to be moved from source to dest by LIB$MOVC3. The
length argument is the address of an unsigned word which contains
this number of bytes. The maximum transfer is 65,535 bytes.
source
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
Item to be moved. The source argument is the address of this item.
dest
VMS usage: address
type: unspecified
access: write only
mechanism: by reference
Item into which source will be moved. The dest argument is the
address of this item.
LIB$MOVC5
LIB$MOVC5 makes the VAX MOVC5 instruction available as a callable
procedure. The source item is moved to the destination item.
Overlap of the source and destination items does not affect the
result.
Format:
LIB$MOVC5 src-len ,source ,fill ,dst-len ,dest
Arguments:
src-len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Number of bytes in the source item. The src-len argument is the
address of an unsigned word that contains this number of bytes. The
maximum length of source is 65,535 bytes.
source
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
Item to be moved by LIB$MOVC5. The source argument is the address
of this item. If src-len is zero, indicating that dest is to be
entirely filled by the fill character, then source is ignored by
LIB$MOVC5.
fill
VMS usage: byte_signed
type: byte integer (signed)
access: read only
mechanism: by reference
Character used to pad source to the length of dest. The fill
argument is the address of a signed byte integer that contains this
fill character.
dst-len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Length of dest in bytes. The dst-len argument is the address of an
unsigned word that contains this number of bytes. The maximum value
of dst-len is 65,535 bytes.
dest
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Item into which source will be moved. The dest argument is the
address of this item.
LIB$MOVTC
LIB$MOVTC moves the source string, character by character, to the
destination string after translating each character using the
specified translation table. LIB$MOVTC makes the VAX MOVTC
instruction available as a callable procedure.
Format:
LIB$MOVTC src-str ,fill-char ,trans-tbl ,dst-str
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string to be translated and moved by LIB$MOVTC. The src-str
argument is the address of a descriptor pointing to this source
string.
fill-char
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Fill character used to pad src-str to the length of dst-str. The
fill-char argument is the address of a descriptor pointing to a
string. The first character of this string is used as the fill
character. The length of this string is not checked and fill-char
is not translated.
trans-tbl
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Translation table used by LIB$MOVTC. The trans-tbl argument is the
address of a descriptor pointing to the translation table string.
The translation table string is assumed to be 256 characters long.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which LIB$MOVTC writes the translated
src-str. The dst-str argument is the address of a descriptor
pointing to this destination string.
LIB$MOVTUC
LIB$MOVTUC moves the source string, character by character, to the
destination string after translating each character using the
specified translation table until the stop character is encountered.
LIB$MOVTUC makes the VAX MOVTUC instruction available as a callable
procedure.
Format:
LIB$MOVTUC src-str ,stop-char ,trans-tbl ,dst-str [,fill-char]
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string to be translated and moved by LIB$MOVTUC. The src-str
argument is the address of a descriptor pointing to this source
string.
stop-char
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Stop character that causes LIB$MOVTUC to stop translating the source
string. The stop-char argument is the address of a descriptor
pointing to a string. The first character of this string is used as
the stop character. The length of this string is not checked and
stop-char is not translated.
trans-tbl
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Translation table used by LIB$MOVTUC. The trans-tbl argument is the
address of a descriptor pointing to the translation table string.
The translation table string is assumed to be 256 characters long.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which LIB$MOVTUC writes the translated
src-str. The dst-str argument is the address of a descriptor
pointing to this destination string.
fill-char
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Character used to pad src-str to the length of dst-str. The
fill-char argument is the address of a descriptor pointing to a
string. The first character of this string is used as the fill
character. The length of this string is not checked and fill-char
is not translated.
LIB$PAUSE
LIB$PAUSE suspends program execution and returns control to the
calling command level.
Format:
LIB$PAUSE
NONE
LIB$POLYz
LIB$POLYF, LIB$POLYD, LIB$POLYG, and LIB$POLYH allow higher-level
language users to evaluate polynomials. These procedures use the
VAX hardware instructions POLYF, POLYD, POLYG, and POLYH.
Format:
LIB$POLYF arg ,degree ,coeff ,result
LIB$POLYD arg ,degree ,coeff ,result
LIB$POLYG arg ,degree ,coeff ,result
LIB$POLYH arg ,degree ,coeff ,result
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
arg
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Argument for the polynomial. The arg argument is the address of a
floating-point number that contains this argument. For LIB$POLYF,
arg is an F_floating number. For LIB$POLYD, arg is a D_floating
number. For LIB$POLYG, arg is a G_floating number. For LIB$POLYH,
arg is an H_floating number.
degree
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by reference
Highest numbered non-zero coefficient to participate in the
evaluation. The degree argument is the address of a signed word
integer that contains this highest-numbered coefficient.
coeff
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference, array reference
Floating-point coefficients. The coeff argument is the address of
an array of floating-point coefficients. The coefficient of the
highest-order term of the polynomial is the lowest-addressed element
in the array. For LIB$POLYF, coeff is an array of F_floating
numbers. For LIB$POLYD, coeff is an array of D_floating numbers.
For LIB$POLYG, coeff is an array of G_floating numbers. For
LIB$POLYH, coeff is an array of H_floating numbers.
result
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: write only
mechanism: by reference
Result of the calculation. The result argument is the address of a
floating-point number that contains this result. LIB$POLYF writes
the address of result into an F_floating number. LIB$POLYD writes
the address of result into a D_floating number. LIB$POLYG writes
the address of result into a G_floating number. LIB$POLYH writes
the address of result into an H_floating number.
LIB$PUT_COMMON
LIB$PUT_COMMON copies the contents of a string into the common area.
The common area is an area of storage which remains defined across
multiple image activations in a process. Optionally, LIB$PUT_COMMON
returns the actual number of characters copied. The maximum number
of characters that can be copied is 252.
Format:
LIB$PUT_COMMON src-str [,chars-copied]
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string to be copied to the common area by LIB$PUT_COMMON.
The src-str argument is the address of a descriptor pointing to this
source string.
chars-copied
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of characters copied by LIB$PUT_COMMON to the common area.
The chars-copied argument is the address of a signed word integer
that contains this number of characters. LIB$PUT_COMMON writes this
number into the chars-copied argument.
LIB$PUT_OUTPUT
LIB$PUT_OUTPUT writes a record to the current controlling output
device, specified by SYS$OUTPUT using the VAX RMS $PUT service.
Format:
LIB$PUT_OUTPUT msg-str
ARGUMENT
msg-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Message string written to the current controlling output device by
LIB$PUT_OUTPUT. The msg-str argument is the address of a descriptor
pointing to this message string. VAX RMS handles all formatting, so
the message does not need to include such ASCII formatting
instructions as carriage return (CR).
LIB$RADIX_POINT
LIB$RADIX_POINT returns the system's radix point symbol. This
symbol is used inside a digit string to separate the integer part
from the fraction part. This routine works by attempting to
translate the logical name SYS$RADIX_POINT as a process, group, or
system logical name.
Format:
LIB$RADIX_POINT radix-point-str [,out-len]
Arguments:
radix-point-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Radix point string. The radix-point-str argument is the address of
a descriptor pointing to this radix point string.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
The number of characters written into radix-point-str, not counting
padding in the case of a fixed-length string. The out-len argument
is the address of an unsigned word that contains this number.
LIB$REMQHI
LIB$REMQHI removes an entry from the head of the specified
self-relative interlocked queue. LIB$REMQHI makes the VAX REMQHI
instruction available as a callable procedure.
Format:
LIB$REMQHI header ,remque-adr [,retry-cnt]
Arguments:
header
VMS usage: quadword_signed
type: quadword integer (signed)
access: modify
mechanism: by reference
Queue header specifying the queue from which entry will be removed.
The header argument contains the address of this signed aligned
quadword integer. Header must be initialized to zero before first
use of the queue; zero means an empty queue.
remque-adr
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the removed entry. The remque-adr argument is the
address of an unsigned longword that contains this address. If the
queue was empty, remque-adr is set to the address of the header.
retry-cnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The number of times the operation is to be retried in case of
secondary-interlock failure of the queue instruction in a
processor-shared memory application. The retry-cnt argument is the
address of a longword that contains the retry count value. A value
of 1 causes no retries. The default value is 10.
LIB$REMQTI
LIB$REMQTI removes an entry from the tail of the specified
self-relative interlocked queue. LIB$REMQTI makes the VAX REMQTI
instruction available as a callable procedure.
Format:
LIB$REMQTI header ,remque-adr [,retry-cnt]
Arguments:
header
VMS usage: quadword_signed
type: quadword integer (signed)
access: modify
mechanism: by reference
Queue header specifying the queue from which the entry is to be
deleted. The header argument contains the address of this signed
aligned quadword integer. Header must be initialized to zero before
first use of the queue; zero means an empty queue.
remque-adr
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the removed entry. The remque-adr argument is the
address of a longword that contains this address. If the queue was
empty, remque-adr is set to the address of the header.
retry-cnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The number of times the operation is to be retried in case of
secondary-interlock failure of the queue instruction in a
processor-shared memory application. The retry-cnt argument is the
address of a longword that is this retry count value. A value of 1
causes no retries. The default value is 10.
LIB$RENAME_FILE
LIB$RENAME_FILE changes the name(s) of one or more files. The
specification of the file(s) to be renamed may include wildcards.
LIB$RENAME_FILE is similar in function to the DCL command RENAME.
Format:
LIB$RENAME_FILE old-filespec ,new-filespec [,default-filespec]
[,related-filespec] [,flags] [,success-routine]
[,error-routine] [,confirm-routine] [,user-arg]
[,old-resultant-name] [,new-resultant-name]
[,file-scan-context]
Arguments:
old-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File specification of the file(s) to be renamed. The old-filespec
argument is the address of a descriptor pointing to the old file
specification. The specification may include wildcards, in which
case each file which matches the specification will be renamed. The
string must not contain more than 255 characters. Any string class
is supported.
new-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File specification for the new file name(s). The new-filespec
argument is the address of a descriptor pointing to the new file
specification.
default-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Default file specification of the file(s) to be renamed. The
default-filespec argument is the address of a descriptor pointing to
the default file specification.
related-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Related file specification of the file(s) to be renamed. The
related-filespec argument is the address of a descriptor pointing to
the related file specification. This is an optional argument; if
omitted, the default is the null string. Any string class is
supported.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Longword of flag bits designating optional behavior. The flags
argument is the address of an unsigned longword containing the flag
bits. This is an optional argument; if omitted, the default is that
all flags are clear.
success-routine
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference
User-supplied success routine that LIB$RENAME_FILE calls after each
successful rename. The success-routine argument is the address of
the entry mask to the success routine.
error-routine
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference
User-supplied error routine that LIB$RENAME_FILE calls when it
detects an error. The error-routine argument is the address of the
entry mask to the error routine. The value returned by the error
routine determines whether LIB$RENAME_FILE processes more files.
confirm-routine
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference
User-supplied confirm routine that LIB$RENAME_FILE calls before it
renames a file. The confirm-routine argument is the address of the
entry mask to the confirm routine. The value returned by the
confirm routine determines whether or not LIB$RENAME_FILE renames
the file.
user-arg
VMS usage: user_arg
type: unspecified
access: read only
mechanism: unspecified
Value that LIB$RENAME_FILE passes to the success, error and confirm
routines each time they are called. Whatever mechanism is used to
pass user-arg to LIB$RENAME_FILE is also used to pass it to the
user-supplied routines. This is an optional argument; if omitted,
zero is passed by value.
old-resultant-name
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which LIB$RENAME_FILE copies the old resultant file
specification of the last file processed. This is an optional
argument. If present, it is used to store the file specification
passed to the user-supplied routines instead of a default class S,
type T string. Any string class is supported.
new-resultant-name
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which LIB$RENAME_FILE writes the new RMS resultant file
specification of the last file processed. The new-resultant-name
argument is the address of a descriptor pointing to the new name.
This is an optional argument. If present, it is used to store the
file specification passed to the user-supplied routines instead of a
class S, type T string. Any string class is supported.
file-scan-context
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context for renaming a list of filespecs. The file-scan-context is
the address of a longword which contains this context. You must
initialize this longword to zero before the first of a series of
calls to LIB$RENAME_FILE. LIB$RENAME_FILE uses the file scan
context to retain the file context for multiple input files.
LIB$RESERVE_EF
LIB$RESERVE_EF allocates a local event flag number specified by
event-flag-num.
Format:
LIB$RESERVE_EF event-flag-num
argument
event-flag-num
VMS usage: ef_number
type: longword integer (signed)
access: read only
mechanism: by reference
Event flag number to be allocated by LIB$RESERVE_EF. The
event-flag-num argument contains the address of a signed longword
integer that is this event flag number.
LIB$RESET_VM_ZONE
LIB$RESET_VM_ZONE frees all blocks of memory that were previously
allocated from the zone.
Format:
LIB$RESET_VM_ZONE zone-id
Arguments:
zone-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Zone identifier. The zone-id is the address of a longword that
contains the identifier of a zone created by a previous call to
LIB$CREATE_VM_ZONE or LIB$CREATE_USER_VM_ZONE.
LIB$REVERT
LIB$REVERT deletes the condition handler established by
LIB$ESTABLISH by clearing the address pointing to the condition
handler from the activated procedure's stack frame.
Format:
LIB$REVERT
NONE
LIB$RUN_PROGRAM
LIB$RUN_PROGRAM causes the current program to stop running and
begins execution of another program.
Format:
LIB$RUN_PROGRAM pgm-name
Argument
pgm-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File name of the program to be run in place of the current program.
The pgm-name argument contains the address of a descriptor pointing
to this file name string.
LIB$SCANC
LIB$SCANC is used to find a specified set of characters in the
source string. LIB$SCANC makes the VAX SCANC instruction available
as a callable procedure.
Format:
LIB$SCANC src-str ,table-arr ,mask
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string used by LIB$SCANC to index into a table. The src-str
argument contains the address of a descriptor pointing to this
source string.
table-arr
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference, array reference
Table that LIB$SCANC indexes into and ANDs with the mask byte. The
table-arr argument contains the address of an unsigned byte array
that is this table.
mask
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Mask that is ANDed with bytes in table-arr. The mask argument
contains the address of an unsigned byte that is this mask.
LIB$SCOPY_R_DX
LIB$SCOPY_R_DX copies a source string passed by reference to a
destination string.
Format:
LIB$SCOPY_R_DX src-len ,src-adr ,dst-str
Arguments:
src-len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Length of the source string. The src-len argument contains the
address of an unsigned word that is this length.
src-adr
VMS usage: char_string
type: character string
access: read only
mechanism: by reference
Source string to be copied to the destination string by
LIB$SCOPY_R_DX. The src-adr argument is the address of this source
string.
dst-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Destination string to which the source string is copied. The
dst-str argument contains the address of a descriptor pointing to
this destination string.
LIB$SET_LOGICAL
LIB$SET_LOGICAL requests the calling process's Command Language
Interpreter (CLI) to define or redefine a supervisor-mode process
logical name. It provides the same function as the DCL DEFINE
command.
Format:
LIB$SET_LOGICAL log-nam [,value] [,table-desc] [,attributes]
[,item-list]
Either the item-list or value argument must be
specified. If both item-list and value are
specified, the value argument is ignored.
Arguments:
log-nam
VMS usage: logical_name
type: character string
access: read only
mechanism: by descriptor
Logical name to be defined or redefined. The log-nam argument
contains the address of a descriptor pointing to this logical name
string. The maximum length of a logical name is 255 characters.
value
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Value to be given to the logical name. The value argument contains
the address of a descriptor pointing to this value string. The
maximum length of a logical name value is 255 characters.
table-desc
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the table in which to create the logical name. The
table-desc argument contains the address of a descriptor pointing to
the logical name table. If no table is specified, LNM$PROCESS is
used as the default.
attributes
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Logical name or translation attributes. The attributes argument is
the address of an unsigned longword which contains the logical name
or translation attributes.
item-list
VMS usage: item_list
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Item list describing the equivalence names for this logical name.
The item-list argument contains the address of an unsigned longword
array that contains this item list. If item-list is not specified,
the logical name will have only one value, as specified in the value
argument.
LIB$SET_SYMBOL
LIB$SET_SYMBOL requests the calling process's Command Language
Interpreter (CLI) to define or redefine a CLI symbol.
Format:
LIB$SET_SYMBOL symbol ,value [,tbl-ind]
Arguments:
symbol
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name of the symbol to be defined or modified by LIB$SET_SYMBOL. The
symbol argument is the address of a descriptor pointing to this
symbol string. If you redefine a previously defined CLI symbol, the
symbol value is modified to the new value that you provide.
value
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Value to be given to the symbol. The value argument is the address
of a descriptor pointing to this value string.
tbl-ind
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Indicator of the table which will contain the defined symbol. The
tbl-ind argument is the address of a signed longword integer that is
this table indicator.
LIB$SFREE1_DD
LIB$SFREE1_DD returns one dynamic string area to free storage.
Format:
LIB$SFREE1_DD dsc-adr
ARGUMENT
dsc-adr
VMS usage: quadword_unsigned
type: quadword (unsigned)
access: modify
mechanism: by reference
Dynamic descriptor specifying the area to be deallocated. The
dsc-adr argument is the address of an unsigned quadword that is this
descriptor. The descriptor is assumed to be dynamic and its class
field is not checked.
LIB$SFREEN_DD
LIB$SFREEN_DD returns one or more dynamic strings to free storage.
Format:
LIB$SFREEN_DD dsc-num ,first-dsc
Arguments:
dsc-num
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Number of adjacent descriptors to be flagged by LIB$FREEN_DD as
having no allocated area (DSC$A_POINTER = 0 and DSC$W_LENGTH = 0).
The dsc-num argument contains the address of an unsigned longword
that is this number. The deallocated area is returned to free
storage.
first-dsc
VMS usage: vector_quadword_unsigned
type: quadword (unsigned)
access: modify
mechanism: by reference, array reference
First descriptor of an array of descriptors. The first-dsc argument
contains the address of an unsigned quadword that is this first
descriptor. The descriptors are assumed to be dynamic, and their
class fields are not checked.
LIB$SGET1_DD
LIB$SGET1_DD allocates dynamic virtual memory to the string
descriptor you specify.
Format:
LIB$SGET1_DD length ,string
Arguments:
length
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Number of bytes of dynamic virtual memory to be allocated by
LIB$SGET1_DD. The length argument is the address of an unsigned
word that contains this number. The amount of storage allocated may
be rounded up automatically. If the number of bytes is zero, a
small amount of space is allocated.
string
VMS usage: quadword_unsigned
type: quadword (unsigned)
access: modify
mechanism: by reference
Descriptor of the dynamic string to which LIB$SGET1_DD will allocate
the dynamic virtual memory. The string argument contains the
address of an unsigned quadword that is this descriptor.
LIB$SHOW_TIMER
LIB$SHOW_TIMER returns times and counts accumulated since the last
call to LIB$INIT_TIMER and displays them on SYS$OUTPUT. A
user-supplied action routine may change this default behavior.
Format:
LIB$SHOW_TIMER [handle-adr] [,code] [,action-rtn [,user-arg]]
Arguments:
handle-adr
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
Block of storage containing the value returned by a previous call to
LIB$INIT_TIMER. The handle-adr argument is the address of an
unsigned longword integer containing that value.
o If specified, the pointer must be the same value returned by a
previous call to LIB$INIT_TIMER.
o If omitted, LIB$SHOW_TIMER will use a block of memory allocated
by LIB$INIT_TIMER.
o If handle-adr is omitted and LIB$INIT_TIMER has not been called
previously, the error LIB$_INVARG is returned. LIB$INIT_TIMER
must be called prior to a call to LIB$SHOW_TIMER.
code
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Integer specifying the statistic you want; if it is omitted or zero,
all five statistics are returned on one line. The code argument is
the address of a signed longword integer containing the statistic
code.
action-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied action routine called by LIB$SHOW_TIMER. The
action-rtn argument is the address of the entry mask to this
routine. The default action of LIB$SHOW_TIMER is to write the
results to SYS$OUTPUT. An action routine is useful if you want to
write the results to a file, or in general, anywhere other than
SYS$OUTPUT.
user-arg
VMS usage: user_arg
type: unspecified
access: read only
mechanism: by value
A 32-bit value to be passed to the action routine without
interpretation. If omitted, LIB$SHOW_TIMER passes a zero by value
to the user routine.
LIB$SHOW_VM
LIB$SHOW_VM returns the statistics accumulated from calls to
LIB$GET_VM/LIB$FREE_VM and LIB$GET_VM_PAGE/LIB$FREE_VM_PAGE.
Format:
LIB$SHOW_VM [code] [,action-rtn [,user-arg]]
Arguments:
code
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Code specifying any one of the statistics to be written to
SYS$OUTPUT or passed to an action routine for processing. The code
argument is the address of a signed longword integer containing the
statistic code. This is an optional argument. If the statistic
code is omitted or is zero, statistics for values 1, 2, and 3 are
returned on one line.
action-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied action routine called by LIB$SHOW_VM. By default,
LIB$SHOW_VM returns statistics to SYS$OUTPUT. An action routine is
useful when you want to return statistics to a file or, in general,
to anyplace other than SYS$OUTPUT. The action-rtn argument is the
address of the entry mask to the action routine. The routine
returns either a success or failure condition value, which will be
returned as the value of LIB$SHOW_VM.
user-arg
VMS usage: user_arg
type: unspecified
access: read only
mechanism: unspecified
A 32-bit value to be passed directly to the action routine without
interpretation. That is, the contents of the argument list entry
user-arg are copied to the argument list entry for action-rtn.
LIB$SIGNAL
LIB$SIGNAL generates a signal that indicates that an exception
condition has occurred in your program. If a condition handler does
not take corrective action and the condition is severe, then your
program will exit.
Format:
LIB$SIGNAL condition-value1 [,number1] [,FAO-arg1...,FAO-argn1]
[,condition-value2] [,number2]
[,FAO-arg2...,FAO-argn2]
Only the condition-value1 argument must be specified;
other arguments are optional. The number1 argument,
if specified, contains the number of FAO arguments
that will be associated with condition-value1. The
condition-value2 argument is optional; it may be
specified with or without the number2 or FAO-arg2
arguments. The number2 argument, if specified,
contains the number of FAO arguments that will be
associated with condition-value2. You may specify
condition-value3, condition-value4, condition-value5,
and so on, along with their corresponding number and
FAO arguments.
Arguments:
condition-value
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by value
VAX 32-bit condition value. The condition-value argument is an
unsigned longword that contains this condition value.
number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of FAO arguments associated with the condition value. The
number argument is a signed longword integer that contains this
number. If omitted or specified as zero, no FAO arguments follow.
FAO-arg(s)
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: unspecified
Additional FAO (formatted ASCII output) argument(s) which are
associated with the specified condition value.
LIB$SIG_TO_RET
LIB$SIG_TO_RET converts any signaled condition value to a value
returned as a function. This value is returned to the caller of the
user procedure containing LIB$SIG_TO_RET. This routine may be
established as or called from a condition handler.
Format:
LIB$SIG_TO_RET sig-args ,mch-args
Arguments:
sig-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Signal argument vector. The sig-args argument contains the address
of an array of unsigned longwords that is this signal argument
vector stack.
mch-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Mechanism arguments vector. The mch-args argument contains the
address of an array of unsigned longwords that is this mechanism
arguments vector stack.
LIB$SIG_TO_STOP
LIB$SIG_TO_STOP converts a signaled condition to a signaled
condition that cannot be continued.
Format:
LIB$SIG_TO_STOP sig-args ,mch-args
Arguments:
sig-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: modify
mechanism: by reference, array reference
Signal argument vector. The sig-args argument contains the address
of an array of unsigned longwords that is this signal argument
vector stack.
mch-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Mechanism argument vector. The mch-args argument contains the
address of an array of longwords that is this mechanism argument
vector stack.
LIB$SIM_TRAP
LIB$SIM_TRAP converts floating faults to floating traps. It can be
enabled as a condition handler or can be called by one.
Format:
LIB$SIM_TRAP sig-args ,mch-args
Arguments:
sig-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: modify
mechanism: by reference, array reference
Signal argument vector. The sig-args argument contains the address
of an array of longwords that is this signal argument vector stack.
mch-args
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Mechanism argument vector. The mch-args argument contains the
address of an array of longwords that is this mechanism argument
vector stack.
LIB$SKPC
LIB$SKPC compares each character of a given string with a given
character and returns the relative position of the first nonequal
character as an index. LIB$SKPC makes the VAX SKPC instruction
available as a callable procedure.
Format:
LIB$SKPC char-str ,src-str
Arguments:
char-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String whose initial character is to be used by LIB$SKPC in the
comparison. The char-str argument contains the address of a
descriptor pointing to this string. Only the first character of
char-str is used, and the length of char-str is not checked.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String to be searched by LIB$SKPC. The src-str argument contains
the address of a descriptor pointing to this string.
LIB$SPANC
LIB$SPANC is used to skip a specified set of characters in the
source string. LIB$SPANC makes the VAX SPANC instruction available
as a callable procedure.
Format:
LIB$SPANC src-str ,table-arr ,mask
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string used by LIB$SPANC to index into table-arr. The
src-str argument contains the address of a descriptor pointing to
this source string.
table-arr
VMS usage: vector_byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference, array reference
Table that LIB$SPANC indexes into and ANDs with the mask byte. The
table-arr argument contains the address of an unsigned byte array
that is this table.
mask
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Mask that is ANDed with bytes in table-arr. The mask argument
contains the address of an unsigned byte that is this mask.
LIB$SPAWN
LIB$SPAWN requests the command language interpreter (CLI) of the
calling process to spawn a subprocess for executing CLI commands.
LIB$SPAWN provides the same function as the DCL SPAWN command.
Format:
LIB$SPAWN [command-string] [,input-file] [,output-file] [,flags]
[,process-name] [,process-id] [,completion-status]
[,completion-efn] [,completion-astadr]
[,completion-astarg] [,prompt] [,cli]
Arguments:
command-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
CLI command to be executed by the spawned subprocess. The
command-string argument is the address of a descriptor pointing to
this CLI command string. If omitted, commands are taken from the
file specified by input-file.
input-file
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Equivalence name to be associated with the logical name SYS$INPUT in
the logical name table for the subprocess. The input-file argument
is the address of a descriptor pointing to this equivalence string.
If omitted, the default is the caller's SYS$INPUT.
output-file
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Equivalence name to be associated with the logical names SYS$OUTPUT
and SYS$ERROR in the logical name table for the subprocess. The
output-file argument is the address of a descriptor pointing to this
equivalence string. If omitted, the default is the caller's
SYS$OUTPUT.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Flag bits that designate optional behavior. The flags argument is
the address of an unsigned longword that contains these flag bits.
By default, all flags are clear.
process-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Name defined for the subprocess. The process-name argument is the
address of a descriptor pointing to this name string. If omitted, a
unique process name will be generated. If you supply a name and it
is not unique, LIB$SPAWN will return the condition value
SS$_DUPLNAM.
process-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Process identification of the spawned subprocess. The process-id
argument is the address of an unsigned longword that contains this
process identification value.
completion-status
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
The final completion status of the subprocess. The
completion-status argument is the address of an unsigned longword.
LIB$SPAWN writes the address of the final completion status of the
subprocess into completion-status.
completion-efn
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
The number of a local event flag to be set when the spawned
subprocess completes. The completion-efn argument is the address of
an unsigned byte that contains this event flag number. If omitted,
no event flag is set.
completion-astadr
VMS usage: procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by reference
Entry mask of a procedure to be called by means of an AST when the
subprocess completes. The completion-astadr argument is the address
of this procedure entry mask.
completion-astarg
VMS usage: user_arg
type: unspecified
access: read only
mechanism: unspecified
A value to be passed to the AST procedure. Typically, the
completion-astarg argument is the address of a block of storage the
AST procedure will use.
prompt
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Prompt string to use in the subprocess. The prompt argument is the
address of a descriptor pointing to this prompt string. If omitted,
the subprocess will use the same prompt string that the parent
process uses.
cli
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File specification for the command language interpreter (CLI) to be
run in the subprocess. The cli argument is the address of this file
specification string's descriptor. The CLI specified must reside in
SYS$SYSTEM with a file type of EXE, and it must be installed. No
directory or file type may be specified.
LIB$STAT_TIMER
LIB$STAT_TIMER returns to its caller one of five available
statistics. Unlike LIB$SHOW_TIMER, which formats the values for
output, LIB$STAT_TIMER returns the value as an unsigned longword or
quadword.
Format:
LIB$STAT_TIMER code ,value [,handle-adr]
Arguments:
code
VMS usage: function_code
type: longword integer (signed)
access: read only
mechanism: by reference
Code which specifies the statistic to be returned. The code
argument contains the address of a signed longword integer that is
this code. It must be an integer from 1 to 5.
value
VMS usage: user_arg
type: unspecified
access: write only
mechanism: by reference
The statistic returned by LIB$STAT_TIMER. The value argument
contains the address of a longword or quadword that is this
statistic. All statistics are longword integers except elapsed
time, which is a quadword.
handle-adr
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
Pointer to a block of storage. The optional handle-adr argument
contains the address of an unsigned longword that is this pointer.
LIB$STAT_VM
LIB$STAT_VM returns to its caller one of six statistics available
from calls to LIB$GET_VM/LIB$FREE_VM and
LIB$GET_VM_PAGE/LIB$FREE_VM_PAGE. Unlike LIB$SHOW_VM, which formats
the values for output and displays them on SYS$OUTPUT, LIB$STAT_VM
returns the statistic in the value argument. Only one of the
statistics is returned by each call to LIB$STAT_VM.
Format:
LIB$STAT_VM code ,value
Arguments:
code
VMS usage: function_code
type: longword integer (signed)
access: read only
mechanism: by reference
Code specifying which statistic is to be returned. The code
argument contains the address of a signed longword integer that is
this code.
Code Statistic
1 Number of successful calls to LIB$GET_VM
2 Number of successful calls to LIB$FREE_VM
3 Number of bytes allocated by LIB$GET_VM but not yet
deallocated by LIB$FREE_VM
5 Number of calls to LIB$GET_VM_PAGE
6 Number of calls to LIB$FREE_VM_PAGE
7 Number of pages allocated by LIB$GET_VM_PAGE but not
yet deallocated by LIB$FREE_VM_PAGE
value
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Value of the statistic returned by LIB$STAT_VM. The value argument
contains the address of a signed longword integer that is this
value.
LIB$STOP
LIB$STOP generates a signal that indicates that an exception
condition has occurred in your program. Exception conditions
signaled by LIB$STOP cannot be continued from the point of the
signal.
Format:
LIB$STOP condition-value1 [,number1] [,FAO-arg1...,FAO-argn1]
[,condition-value2] [,number2] [,FAO-arg2...,FAO-argn2]
Only the condition-value1 argument must be specified;
other arguments are optional. The number1 argument,
if specified, contains the number of FAO arguments
that will be associated with condition-value1. The
condition-value2 argument is optional; it may be
specified with or without the number2 or
FAO-arg2 arguments. The number2 argument, if
specified, contains the number of FAO arguments that
will be associated with condition-value2. You may
specify condition-value3, condition-value4,
condition-value5, and so on, along with their
corresponding number and FAO arguments.
Arguments:
condition-value
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by value
VAX 32-bit condition value. The condition-value argument is an
unsigned longword that contains this condition value.
number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of FAO arguments associated with the condition value. The
number argument is a a signed longword integer that contains this
number. If omitted or specified as zero, no FAO arguments follow.
FAO-arg(s)
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: by value
Additional FAO (formatted ASCII output) argument(s) which are
associated with the specified condition value. The FAO-arg(s)
argument is the address of a signed longword integer or a character
string that contains these additional FAO arguments.
LIB$SUBX
LIB$SUBX performs subtraction on signed two's complement integers of
arbitrary length.
Format:
LIB$SUBX a ,b ,diff [,len]
Arguments:
a
VMS usage: vector_longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
Minuend; a multiple-precision, signed two's complement integer. The
a argument is the address of an array of signed longword integers
that contains the minuend.
b
VMS usage: vector_longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference, array reference
Subtrahend; a multiple-precision, signed two's complement integer.
The b argument is the address of an array of signed longword
integers that contains the subtrahend.
diff
VMS usage: vector_longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference, array reference
Difference; a multiple-precision, signed two's complement integer
result. The diff argument is the address of an array of signed
longword integers that contains the difference.
len
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Length in longwords of the arrays to be operated on by LIB$SUBX.
The len argument contains the address of a signed longword integer
that is this length. Len must not be negative. The default length
is 2.
LIB$SYS_ASCTIM
LIB$SYS_ASCTIM calls the system service $ASCTIM to convert a binary
date and time value, returning the ASCII string using the semantics
of the caller's string.
Format:
LIB$SYS_ASCTIM [out-len] ,dst-str [,user-time] [,cnv-flg]
Arguments:
out-len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of bytes written into dst-str, not counting padding in the
case of a fixed-length string. The out-len argument contains the
address of a signed word integer that is this number.
dst-str
VMS usage: time_name
type: character string
access: write only
mechanism: by descriptor
Destination string into which LIB$SYS_ASTIM writes the ASCII time
string. The dst-str argument contains the address of a descriptor
pointing to the destination string.
user-time
VMS usage: date_time
type: quadword integer (signed)
access: read only
mechanism: by reference
Value that LIB$SYS_ASCTIM converts to ASCII string form. The
user-time argument contains the address of a signed quadword integer
that is this value.
cnv-flg
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Conversion indicator. The cnv-flg argument contains the address of
an unsigned longword that is this conversion indicator.
LIB$SYS_FAO
LIB$SYS_FAO calls $FAO, returning a string in the semantics you
provide. If called with other than a fixed-length string for
output, the length of the resultant string is limited to 256 bytes
and truncation will occur.
Format:
LIB$SYS_FAO ctr-str [,out-len] ,out-buf [,p1,...,pn]
Arguments:
ctr-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
ASCII control string, consisting of the fixed text of the output
string and FAO directives. The ctr-str argument contains the
address of a descriptor pointing to this control string.
out-len
VMS usage: word_integer
type: word integer (signed)
access: write only
mechanism: by reference
Length of the output string. The out-len argument contains the
address of a signed word integer that is this length.
out-buf
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Fully formatted output string returned by LIB$SYS_FAO. The out-buf
argument contains the address of a descriptor pointing to this
output string.
p1---pn
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: unspecified
Directive argument(s) contained in longwords. Depending on the
directive, a p argument can be a value to be converted, the address
of the string to be inserted, or a length or argument count. The
passing mechanism for each of these arguments should be the one
expected by the $FAO system service.
LIB$SYS_FAOL
LIB$SYS_FAOL calls the system service routine $FAOL, returning the
string in the semantics you provide. If called with other than a
fixed-length string for output, the length of the resultant string
is limited to 256 bytes and truncation will occur.
Format:
LIB$SYS_FAOL ctr-str ,[out-len] ,out-buf ,p1 - pn
Arguments:
ctr-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
ASCII control string, consisting of the fixed text of the output
string and FAO directives. The ctr-str argument contains the
address of a descriptor pointing to this control string.
out-len
VMS usage: word_integer
type: word integer (signed)
access: write only
mechanism: by reference
Length of the output string. The out-len argument contains the
address of a signed word integer that is this length.
out-buf
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Fully formatted output string returned by LIB$SYS_FAOL. The out-buf
argument contains the address of a descriptor pointing to this
output string.
p1 -- pn
VMS usage: varying_arg
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Directive argument(s). The p1 -- pn arguments are contained in an
array of unsigned longword directive arguments. Depending on the
directive, a p argument can be a value to be converted, the address
of the string to be inserted, or a length or argument count. The
passing mechanism for each of these arguments should be the one
expected by the $FAOL system service.
LIB$SYS_GETMSG
LIB$SYS_GETMSG calls the System Service $GETMSG and returns a
message string into dst-str using the semantics of the caller's
string.
Format:
LIB$SYS_GETMSG msg-id ,[msg-len] ,dst-str [,flags] [,out-arr]
Arguments:
msg-id
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Message identification to be retrieved by LIB$SYS_GETMSG. The
msg-id argument contains the address of a signed longword integer
that is this message identification.
msg-len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of characters written into dst-str, not counting padding in
the case of a fixed-length string. The msg-len argument contains
the address of a signed word integer that is this number.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string. The dst-str argument contains the address of a
descriptor pointing to this destination string. LIB$SYS_GETMSG
writes the message that has been returned by $GETMSG into dst-str.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Four flag bits for message content. The flags argument is the
address of an unsigned longword that contains these flag bits. The
default value is a longword with bits zero through 3 set to 1. The
flags argument is passed to LIB$SYS_GETMSG by reference and changed
to value for use by $GETMSG.
out-arr
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference, array reference
A 4-byte array to receive message-specific information. The out-arr
argument contains the address of this array of unsigned longwords.
LIB$SYS_TRNLOG
LIB$SYS_TRNLOG uses the system service $TRNLOG to translate a
logical name, LIB$SYS_TRNLOG returns the logical name's translation
using the semantics of the caller's string.
Format:
LIB$SYS_TRNLOG logical-name ,[dst-len] ,dst-str [,table]
[,acc-mode] [,dsb-msk]
Arguments:
logical-name
VMS usage: logical_name
type: character string
access: read only
mechanism: by descriptor
Logical name. The logical-name argument contains the address of a
descriptor pointing to this logical name string.
dst-len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Number of characters written into dst-str, not counting padding in
the case of a fixed-length string. The dst-len argument contains
the address of a signed word integer that is this number.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which LIB$SYS_TRNLOG writes the logical name
translation. The dst-str argument contains the address of a
descriptor pointing to this destination string.
table
VMS usage: byte_integer
type: byte integer (signed)
access: write only
mechanism: by reference
Logical name table number. The table argument contains the address
of a signed byte integer that is this table number.
acc-mode
VMS usage: access_mode
type: byte integer (signed)
access: write only
mechanism: by reference
Access mode of entry (process table only). The acc-mode argument
contains the address of a signed byte integer that is this access
mode.
dsb-msk
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Table search disable mask. The dsb-msk argument contains the
address of an unsigned byte that is this mask.
LIB$TPARSE
LIB$TPARSE is a general-purpose, table-driven parser implemented as
a finite-state automaton, with extensions that make it suitable for
a wide range of applications. LIB$TPARSE parses a string and
returns a message indicating whether or not the input string is
valid.
Format:
LIB$TPARSE arg-blk ,state-tbl ,key-tbl
Arguments:
arg-blk
VMS usage: address
type: longword (unsigned)
access: modify
mechanism: by reference
LIB$TPARSE argument block. The arg-blk argument contains the
address of this argument block.
state-tbl
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
Starting state in the state table. The state-tbl argument is the
address of this starting state.
key-tbl
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
Keyword table. The key-tbl argument is the address of this keyword
table.
LIB$TRA_ASC_EBC
LIB$TRA_ASC_EBC translates an ASCII string to an EBCDIC string.
Format:
LIB$TRA_ASC_EBC src-str ,dst-str
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string (ASCII) to be translated by LIB$TRA_ASC_EBC . The
src-str argument contains the address of a descriptor pointing to
this source string.
dst-str
VMS usage: byte_unsigned
type: byte (unsigned)
access: write only
mechanism: by descriptor
Destination string (EBCDIC). The dst-str argument contains the
address of a descriptor pointing to this destination string.
LIB$TRA_EBC_ASC
LIB$TRA_EBC_ASC translates an EBCDIC string to an ASCII string.
Format:
LIB$TRA_EBC_ASC src-str ,dst-str
Arguments:
src-str
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by descriptor
String (EBCDIC) to be translated by LIB$TRA_EBC_ASC. The src-str
argument contains the address of a descriptor pointing to this
source string.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string (ASCII). The dst-str argument contains the
address of the descriptor of this destination string.
LIB$TRAVERSE_TREE
LIB$TRAVERSE_TREE calls an action routine for each node in a binary
tree.
Format:
LIB$TRAVERSE_TREE treehead ,action-rtn [,user-data]
Arguments:
treehead
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Tree head of the binary tree. The treehead argument is the address
of an unsigned longword that is the tree head in the binary tree
traversal.
action-rtn
VMS usage: procedure
type: procedure entry mask
access: function call (before return)
mechanism: by reference, procedure reference
User-supplied action routine called by LIB$TRAVERSE_TREE for each
node in the tree. The action-rtn argument is the address of the
entry mask to the action routine.
user-data
VMS usage: user_arg
type: unspecified
access: read only
mechanism: by reference
User data that LIB$TRAVERSE_TREE passes to your action routine. The
user-data argument contains the address of this user data. This is
an optional argument; the default value is zero.
LIB$TRIM_FILESPEC
LIB$TRIM_FILESPEC takes a file specification, such as an RMS
resultant name string, and shortens it (if necessary) so that it
fits into a field of fixed width.
Format:
LIB$TRIM_FILESPEC in-file ,out-file [,width] [,out-len]
Arguments:
in-file
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
File specification to be trimmed. The in-file argument contains the
address of a descriptor pointing to this file specification string.
out-file
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Trimmed file specification. The out-file argument contains the
address of a descriptor pointing to this trimmed file specification
string. LIB$TRIM_FILESPEC writes the trimmed file specification
into out-file.
width
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Maximum field width desired. The width argument is the address of
an unsigned word that contains this maximum field width.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length of the trimmed file specification, not including any blank
padding or truncated characters. The out-len argument is the
address of an unsigned word that contains this length. This is an
optional argument.
LIB$WAIT
LIB$WAIT places the current process into hibernation for the number
of seconds specified in its argument.
Format:
LIB$WAIT seconds
ARGUMENT
seconds
VMS usage: floating_point
type: F_floating
access: read only
mechanism: by reference
The number of seconds to wait. The seconds argument contains the
address of an F_floating number that is this number.
MTH$
Additional information available:
MTH$xACOSMTH$xACOSDMTH$xASINMTH$xASIND
MTH$xATANMTH$xATANDMTH$xATAN2MTH$xATAND2
MTH$xATANHMTH$CxABSMTH$CxCOSMTH$CxEXP
MTH$CxLOGMTH$xCMPLXMTH$xCONJGMTH$xCOS
MTH$xCOSDMTH$xCOSHMTH$CxSINMTH$CxSQRT
MTH$CVT x xMTH$CVT xA xAMTH$xEXPMTH$xIMAG
MTH$xLOGMTH$xLOG2MTH$xLOG10MTH$xREAL
MTH$xSINMTH$xSINCOSMTH$xSINCOSDMTH$xSINDMTH$xSINH
MTH$xSQRTMTH$xTANMTH$xTANDMTH$xTANH
MTH$xACOS
Given the cosine of an angle, MTH$xACOS returns that angle (in
radians).
Format:
MTH$ACOS x
MTH$DACOS x
MTH$GACOS x
MTH$HACOS h_radians ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The cosine of the angle whose value (in radians) is to be returned.
The x argument is the address of a floating-point number that is
this cosine. The absolute value of x must be less than or equal to
1. For MTH$ACOS, x specifies an F_floating number. For MTH$DACOS,
x specifies a D_floating number. For MTH$GACOS, x specifies a
G_floating number. For MTH$HACOS, x specifies an H_floating number.
h_radians
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in radians) whose cosine is specified by x. The h_radians
argument is the address of an H_floating number that is this angle.
MTH$HACOS writes the address of the angle into h_radians. The
h_radians argument is used only by the MTH$HACOS routine.
MTH$xACOSD
Given the cosine of an angle, MTH$xACOSD returns that angle (in
degrees).
Format:
MTH$ACOSD x
MTH$DACOSD x
MTH$GACOSD x
MTH$HACOSD h_degrees ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, G_floating, D_floating, H_floating
access: read only
mechanism: by reference
Cosine of the angle whose value (in degrees) is to be returned. The
x argument is the address of a floating-point number that is this
cosine. The absolute value of x must be less than or equal to 1.
For MTH$ACOSD, x specifies an F_floating number. For MTH$DACOSD, x
specifies a D_floating number. For MTH$GACOSD, x specifies a
G_floating number. For MTH$HACOSD, x specifies an H_floating
number.
h_degrees
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in degrees) whose cosine is specified by x. The h_degrees
argument is the address of an H_floating number that is this angle.
MTH$HACOSD writes the address of the angle into h_degrees. The
h_degrees argument is used only by the MTH$HACOSD routine.
MTH$xASIN
Given the sine of an angle, MTH$xASIN returns that angle (in
radians).
Format:
MTH$ASIN x
MTH$DASIN x
MTH$GASIN x
MTH$HASIN h_radians ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The sine of the angle whose value (in radians) is to be returned.
The x argument is the address of a floating-point number that is
this sine. The absolute value of x must be less than or equal to 1.
For MTH$ASIN, x specifies an F_floating number. For MTH$DASIN, x
specifies a D_floating number. For MTH$GASIN, x specifies a
G_floating number. For MTH$HASIN, x specifies an H_floating number.
h_radians
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in radians) whose sine is specified by x. The h_radians
argument is the address of an H_floating number that is this angle.
MTH$HASIN writes the address of the angle into h_radians. The
h_radians argument is used only by the MTH$HASIN routine.
MTH$xASIND
Given the sine of an angle, MTH$xASIND returns that angle (in
degrees).
Format:
MTH$ASIND x
MTH$DASIND x
MTH$GASIND x
MTH$HASIND h_degrees ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Sine of the angle whose value (in degrees) is to be returned. The x
argument is the address of a floating-point number that is this
sine. The absolute value of x must be less than or equal to 1. For
MTH$ASIND, x specifies an F_floating number. For MTH$DASIND, x
specifies a D_floating number. For MTH$GASIND, x specifies a
G_floating number. For MTH$HASIND, x specifies an H_floating
number.
h_degrees
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in degrees) whose cosine is specified by x. The h_degrees
argument is the address of an H_floating number that is this angle.
MTH$HASIND writes the address of the angle into h_degrees. The
h_degrees argument is used only by the MTH$HASIND routine.
MTH$xATAN
Given the tangent of an angle, MTH$xATAN returns that angle (in
radians).
Format:
MTH$ATAN x
MTH$DATAN x
MTH$GATAN x
MTH$HATAN h_radians ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The tangent of the angle whose value (in radians) is to be returned.
The x argument is the address of a floating-point number that is
this tangent. For MTH$ATAN, x specifies an F_floating number. For
MTH$DATAN, x specifies a D_floating number. For MTH$GATAN, x
specifies a G_floating number. For MTH$HATAN, x specifies an
H_floating number.
h_radians
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in radians) whose tangent is specified by x. The h_radians
argument is the address of an H_floating number that is this angle.
MTH$HATAN writes the address of the angle into h_radians. The
h_radians argument is used only by the MTH$HATAN routine.
MTH$xATAND
Given the tangent of an angle, MTH$xATAND returns that angle (in
degrees).
Format:
MTH$ATAND x
MTH$DATAND x
MTH$GATAND x
MTH$HATAND h_degrees ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The tangent of the angle whose value (in degrees) is to be returned.
The x argument is the address of a floating-point number that is
this tangent. For MTH$ATAND, x specifies an F_floating number. For
MTH$DATAND, x specifies a D_floating number. For MTH$GATAND, x
specifies a G_floating number. For MTH$HATAND, x specifies an
H_floating number.
h_degrees
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in degrees) whose tangent is specified by x. The h_degrees
argument is the address of an H_floating number that is this angle.
MTH$HATAND writes the address of the angle into h_degrees. The
h_degrees argument is used only by the MTH$HATAND routine.
MTH$xATAN2
Given y and x, MTH$xATAN2 returns the angle (in radians) whose
tangent is given by the quotient of y and x, (y/x).
Format:
MTH$ATAN2 y ,x
MTH$DATAN2 y ,x
MTH$GATAN2 y ,x
MTH$HATAN2 h_radians ,y ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
y
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Dividend. The y argument is the address of a floating-point number
that is this dividend. For MTH$ATAN2, y specifies an F_floating
number. For MTH$DATAN2, y specifies a D_floating number. For
MTH$GATAN2, y specifies a G_floating number. For MTH$HATAN2, y
specifies an H_floating number.
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Divisor. The x argument is the address of a floating-point number
that is this divisor. For MTH$ATAN2, x specifies an F_floating
number. For MTH$DATAN2, x specifies a D_floating number. For
MTH$GATAN2, x specifies a G_floating number. For MTH$HATAN2, x
specifies an H_floating number.
h_radians
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in radians) whose tangent is specified by (y/x). The
h_radians argument is the address of an H_floating number that is
this angle. MTH$HATAN2 writes the address of the angle into
h_radians. The h_radians argument is used only by the MTH$HATAN2
routine.
MTH$xATAND2
Given y and x, MTH$xATAND2 returns the angle (in degrees) whose
tangent is given by the quotient of y and x, (y/x).
Format:
MTH$ATAND2 y ,x
MTH$DATAND2 y ,x
MTH$GATAND2 y ,x
MTH$HATAND2 h_degrees ,y ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
y
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Dividend. The y argument is the address of a floating-point number
that is this dividend. For MTH$ATAND2, y specifies an F_floating
number. For MTH$DATAND2, y specifies a D_floating number. For
MTH$GATAND2, y specifies a G_floating number. For MTH$HATAND2, y
specifies an H_floating number.
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Divisor. The x argument is the address of a floating-point number
that is this divisor. For MTH$ATAND2, x specifies an F_floating
number. For MTH$DATAND2, x specifies a D_floating number. For
MTH$GATAND2, x specifies a G_floating number. For MTH$HATAND2, x
specifies an H_floating number.
h_degrees
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Angle (in degrees) whose tangent is specified by (y/x). The
h_degrees argument is the address of an H_floating number that is
this angle. MTH$HATAND2 writes the address of the angle into
h_degrees. The h_degrees argument is used only by the MTH$HATAND2
routine.
MTH$xATANH
Given the hyperbolic tangent of an angle, MTH$xATANH returns the
hyperbolic arc tangent of that angle.
Format:
MTH$ATANH x
MTH$DATANH x
MTH$GATANH x
MTH$HATANH h_atanh ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Hyperbolic tangent of an angle. The x argument is the address of a
floating-point number that is this hyperbolic tangent. For
MTH$ATANH, x specifies an F_floating number. For MTH$DATANH, x
specifies a D_floating number. For MTH$GATANH, x specifies a
G_floating number. For MTH$HATANH, x specifies an H_floating
number.
h_atanh
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Hyperbolic arc tangent of the hyperbolic tangent specified by x.
The h_atanh argument is the address of an H_floating number that is
this hyperbolic tangent. MTH$HATANH writes the address of the
hyperbolic tangent into h_atanh. The h_atanh argument is used only
by the MTH$HATANH routine.
MTH$CxABS
MTH$CxABS returns the absolute value of a complex number (r,i).
Format:
MTH$CABS complex-number
MTH$CDABS complex-number
MTH$CGABS complex-number
Each of the above three formats accepts as input one
of the three floating-point complex types.
ARGUMENT
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
A complex number (r,i), where r and i are both floating-point
complex values. The complex-number argument is the address of this
complex number. For MTH$CABS, complex-number specifies an
F_floating complex number. For MTH$CDABS, complex-number specifies
a D_floating complex number. For MTH$CGABS, complex-number
specifies a G_floating complex number.
MTH$CxCOS
MTH$CxCOS returns the complex cosine of a complex number.
Format:
MTH$CCOS complex-number
MTH$CDCOS complex-cosine ,complex-number
MTH$CGCOS complex-cosine ,complex-number
Each of the above three formats accepts as input one
of the three floating-point types.
Arguments:
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
A complex number (r,i) where r and i are floating-point numbers.
The complex-number argument is the address of this complex number.
For MTH$CCOS, complex-number specifies an F_floating complex number.
For MTH$CDCOS, complex-number specifies a D_floating complex number.
For MTH$CGCOS, complex-number specifies a G_floating complex number.
complex-cosine
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: write only
mechanism: by reference
Complex cosine of the complex-number. The complex cosine routines
that have D_floating and G_floating complex input values write the
address of the complex cosine into the complex-cosine argument. For
MTH$CDCOS, the complex-cosine argument specifies a D_floating
complex number. For MTH$CGCOS, the complex-number argument
specifies a G_floating complex number. For MTH$CCOS, complex-number
is not used.
MTH$CxEXP
MTH$CxEXP returns the complex exponential of a complex number.
Format:
MTH$CEXPP complex-number
MTH$CDEXP complex-exp ,complex-number
MTH$CGEXP complex-exp ,complex-number
Each of the above three formats accepts as input one
of the three floating-point complex types.
Arguments:
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
Complex number whose complex exponential is to be returned. This
complex number has the form (r,i), where "r" is the real part and
"i" is the imaginary part. The complex-number argument is the
address of this complex number. For MTH$CEXP, complex-number
specifies an F_floating number. For MTH$CDEXP, complex-number
specifies a D_floating number. For MTH$CGEXP, complex-number
specifies a G_floating number.
complex-exp
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: write only
mechanism: by reference
Complex exponential of complex-number. The complex exponential
routines that have D_floating complex and G_floating complex input
values write the complex-exp into this argument. For MTH$CDEXP,
complex-exp argument specifies a D_floating complex number. For
MTH$CGEXP, complex-exp specifies a G_floating complex number. For
MTH$CCEXP, complex-exp is not used.
MTH$CxLOG
MTH$CxLOG returns the complex natural logarithm of a complex number.
Format:
MTH$CLOG complex-number
MTH$CDLOG complex-natlog ,complex-number
MTH$CGLOG complex-natlog ,complex-number
Each of the above three formats accepts as input one
of the three floating-point complex types.
Arguments:
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
Complex number whose complex natural logarithm is to be returned.
This complex number has the form (r,i), where "r" is the real part
and "i" is the imaginary part. The complex-number argument is the
address of this complex number. For MTH$CLOG, complex-number
specifies an F_floating number. For MTH$CDLOG, complex-number
specifies a D_floating number. For MTH$CGLOG, complex-number
specifies a G_floating number.
complex-natlog
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: write only
mechanism: by reference
Natural logarithm of the complex number specified by complex-number.
The complex natural logarithm routines that have D_floating complex
and G_floating complex input values write the address of the complex
natural logarithm into complex-natlog. For MTH$CDLOG, the
complex-natlog argument specifies a D_floating complex number. For
MTH$CGLOG, the complex-natlog argument specifies a G_floating
complex number. For MTH$CLOG, complex-natlog is not used.
MTH$xCMPLX
MTH$xCMPLX returns a complex number from two floating-point input
values.
Format:
MTH$CMPLX real-part ,imag-part
MTH$DCMPLX complx ,real-part ,imag-part
MTH$GCMPLX complx ,real-part ,imag-part
Each of the above three formats accepts as input one
of three floating-point types.
Arguments:
real-part
VMS usage: floating_point
type: F_floating, D_floating, G_floating
access: write only
mechanism: by reference
Real part of a complex number. The real-part argument is the
address of a floating-point number that contains this real part, r
of (r,i). For MTH$CMPLX, real-part specifies an F_floating number.
For MTH$DCMPLX, real-part specifies a D_floating number. For
MTH$GCMPLX, real-part specifies a G_floating number.
imag-part
VMS usage: floating_point
type: F_floating, D_floating, G_floating
access: write only
mechanism: by reference
Imaginary part of a complex number. The imag-parg argument is the
address of a floating-point number that contains this imaginary
part, i of (r,i). For MTH$CMPLX, imag-part specifies an F_floating
number. For MTH$DCMPLX, imag-part specifies a D_floating number.
For MTH$GCMPLX, imag-part specifies a G_floating number.
complx
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: write only
mechanism: by reference
The floating-point complex value of a complex number. The complex
exponential functions that have D_floating complex and G_floating
complex input values write the address of this floating-point
complex value into complx. For MTH$DCMPLX, complx specifies a
D_floating complex number. For MTH$GCMPLX, complx specifies a
G_floating complex number. For MTH$CMPLX, complx is not used.
MTH$xCONJG
MTH$xCONJG returns the complex conjugate (r,-i) of a complex number
(r,i).
Format:
MTH$CONJG complex-number
MTH$DCONJG complex-conjugate ,complex-number
MTH$GCONJG complex-conjugate ,complex-number
Each of the above three formats accepts as input one
of the three floating-point complex types.
Arguments:
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
A complex number (r,i), where r and i are floating-point numbers.
The complex-number argument is the address of this floating-point
complex number. For MTH$CONJG, complex-number specifies an
F_floating number. For MTH$DCONJG, complex-number specifies a
D_floating number. For MTH$GCONJG, complex-number specifies a
G_floating number.
complex-conjugate
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: write only
mechanism: by reference
The complex conjugate (r,-i) of the complex number specified by
complex-number. MTH$DCONJG and MTH$GCONJG write the address of this
complex conjugate into complex-conjugate. For MTH$DCONJG, the
complex-conjugate argument specifies the address of a D_floating
complex number. For MTH$GCONJG, the complex-conjugate argument
specifies the address of a G_floating complex number. For
MTH$CONJG, complex-conjugate is not used.
MTH$xCOS
MTH$xCOS returns the cosine of a given angle (in radians).
Format:
MTH$COS x
MTH$DCOS x
MTH$GCOS x
MTH$HCOS h_cosine ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The angle in radians. The x argument is the address of a
floating-point number. For MTH$COS, x is an F_floating number. For
MTH$DCOS, x specifies a D_floating number. For MTH$GCOS, x
specifies a G_floating number. For MTH$HCOS, x specifies an
H_floating number.
h_cosine
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Cosine of the angle specified by x. The h_cosine argument is the
address of an H_floating number that is this cosine. MTH$HCOS
writes the address of the cosine into h_cosine. The h_cosine
argument is used only by the MTH$HCOS routine.
MTH$xCOSD
MTH$xCOSD returns the cosine of a given angle (in degrees).
Format:
MTH$COSD x
MTH$DCOSD x
MTH$GCOSD x
MTH$HCOSD h_cosine ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Angle (in degrees). The x argument is the address of a
floating-point number. For MTH$COSD, x specifies an F_floating
number. For MTH$DCOSD, x specifies a D_floating number. For
MTH$GCOSD, x specifies a G_floating number. For MTH$HCOSD, x
specifies an H_floating number.
h_cosine
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Cosine of the angle specified by x. The h_cosine argument is the
address of an H_floating number that is this cosine. MTH$HCOSD
writes this cosine into h_cosine. The h_cosine argument is used
only by the MTH$HCOSD routine.
MTH$xCOSH
MTH$xCOSH returns the hyperbolic cosine of the input value.
Format:
MTH$COSH x
MTH$DCOSH x
MTH$GCOSH x
MTH$HCOSH h_cosh ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of this input value.
For MTH$COSH, x specifies an F_floating number. For MTH$DCOSH, x
specifies a D_floating number. For MTH$GCOSH, x specifies a
G_floating number. For MTH$HCOSH, x specifies an H_floating number.
h_cosh
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Hyperbolic cosine of the input value specified by x. The h_cosh
argument is the address of an H_floating number that is this
hyperbolic cosine. MTH$HCOSH writes the address of the hyperbolic
cosine into h_cosh. The h_cosh argument is used only by the
MTH$HCOSH routine.
MTH$CxSIN
MTH$CxSIN returns the complex sine of a complex number (r,i).
Format:
MTH$CSIN complex-number
MTH$CDSIN complex-sine ,complex-number
MTH$CGSIN complex-sine ,complex-number
Each of the above three formats accepts as input one
of the three floating-point complex types.
Arguments:
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
A complex number (r,i), where r and i are floating-point numbers.
The complex-number argument is the address of this complex number.
For MTH$CSIN, complex-number specifies an F_floating complex number.
For MTH$CDSIN, complex-number specifies a D_floating complex number.
For MTH$CGSIN, complex-number specifies a G_floating complex number.
complex-sine
VMS usage: floating_point
type: D_floating, G_floating
access: write only
mechanism: by reference
Complex sine of the complex number. The complex sine routines with
D_floating complex and G_floating complex input values write the
address of the complex sine into this complex-sine argument. For
MTH$CDSIN, complex-sine specifies a D_floating complex number. For
MTH$CGSIN, complex-sine specifies a G_floating complex number. For
MTH$CSIN, complex-sine is not used.
MTH$CxSQRT
MTH$CxSQRT returns the complex square root of a complex number
(r,i).
Format:
MTH$CSQRT complex-number
MTH$CDSQRT complex-sqrt ,complex-number
MTH$CGSQRT complex-sqrt ,complex-number
Each of the above three formats accepts as input one
of the three floating-point complex types.
Arguments:
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
Complex number (r,i). The complex-number argument contains the
address of this complex number. For MTH$CSQRT, complex-number
specifies an F_floating number. For MTH$CDSQRT, complex-number
specifies a D_floating number. For MTH$CGSQRT, complex-number
specifies a G_floating number.
complex-sqrt
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: write only
mechanism: by reference
Complex square root of the complex number specified by
complex-number. The complex square root routines that have
D_floating complex and G_floating complex input values write the
complex square root into complex-sqrt. For MTH$CDSQRT, complex-sqrt
specifies a D_floating complex number. For MTH$CGSQRT, complex-sqrt
specifies a G_floating complex number. For MTH$CSQRT, complex-sqrt
is not used.
MTH$CVT x x
MTH$CVT_D_G and MTH$CVT_G_D convert one double-precision value to
the destination data type and return the result as a function value.
MTH$CVT_D_G converts a D_floating value to G_floating and
MTH$CVT_G_D converts a G_floating value to a D_floating value.
Format:
MTH$CVT_D_G source
MTH$CVT_G_D source
ARGUMENT
source
VMS usage: floating_point
type: D_floating, G_floating
access: read only
mechanism: by reference
The input value to be converted. The source argument is the address
of this input value. For MTH$CVT_D_G, the source argument specifies
a D_floating number. For MTH$CVT_G_D, the source argument specifies
a G_floating number.
MTH$CVT xA xA
MTH$CVT_DA_GA and MTH$CVT_GA_DA convert a contiguous array of
double-precision values to the destination data type and return the
results as an array. MTH$CVT_DA_GA converts D_floating values to
G_floating and MTH$CVT_GA_DA converts G_floating values to
D_floating.
Format:
MTH$CVT_DA_GA source ,dest [,count]
MTH$CVT_GA_DA source ,dest [,count]
Arguments:
source
VMS usage: floating_point
type: D_floating, G_floating
access: read only
mechanism: by reference, array reference
Input array of values to be converted. The source argument is the
address of an array of floating-point numbers. For MTH$CVT_DA_GA,
source specifies an array of D_floating numbers. For MTH$CVT_GA_DA,
source specifies an array of a G_floating numbers.
dest
VMS usage: floating_point
type: G_floating, D_floating
access: write only
mechanism: by reference, array reference
Output array of converted values. The dest argument is the address
of an array of floating-point numbers. For MTH$CVT_DA_GA, dest
specifies an array of G_floating numbers. For MTH$CVT_GA_DA, dest
specifies an array of D_floating numbers.
count
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of array elements to be converted. The default value is 1.
The count argument is the address of this number of elements.
MTH$xEXP
MTH$xEXP returns the exponential of the input value.
Format:
MTH$EXP x
MTH$DEXP x
MTH$GEXP x
MTH$HEXP h_exp ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of a floating-point
number. For MTH$EXP, x specifies an F_floating number. For
MTH$DEXP, x specifies a D_floating number. For MTH$GEXP, x
specifies a G_floating number. For MTH$HEXP, x specifies an
H_floating number.
h_exp
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Exponential of the input value specified by x. The h_exp argument
is the address of an H_floating number that is this exponential.
MTH$HEXP writes the address of the exponential into h_exp. The
h_exp argument is used only by the MTH$HEXP routine.
MTH$xIMAG
MTH$xIMAG returns the imaginary part of a complex number.
Format:
MTH$AIMAG complex-number
MTH$DIMAG complex-number
MTH$GIMAG complex-number
Each of the above three formats corresponds to one
of the three floating-point complex types.
ARGUMENT
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
The input complex number. The complex-number argument is the
address of this floating-point complex number. For MTH$AIMAG,
complex-number specifies an F_floating number. For MTH$DIMAG,
complex-number specifies a D_floating number. For MTH$GIMAG,
complex-number specifies a G_floating number.
MTH$xLOG
MTH$xLOG returns the natural (base e) logarithm of the input
argument.
Format:
MTH$ALOG x
MTH$DLOG x
MTH$GLOG x
MTH$HLOG h_natlog ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of a floating-point
number that is this value. For MTH$ALOG, x specifies an F_floating
number. For MTH$DLOG, x specifies a D_floating number. For
MTH$GLOG, x specifies a G_floating number. For MTH$HLOG, x
specifies an H_floating number.
h_natlog
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Natural logarithm of x. The h_natlog argument is the address of an
H_floating number that is this natural logarithm. MTH$HLOG writes
the address of this natural logarithm into h_natlog. The h_natlog
argument is used only by the MTH$HLOG routine.
MTH$xLOG2
MTH$xLOG returns the base 2 logarithm of the input value specified
by x.
Format:
MTH$ALOG2 x
MTH$DLOG2 x
MTH$GLOG2 x
MTH$HLOG2 h_log2 ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of a floating-point
number that is this input value. For MTH$ALOG2, x specifies an
F_floating number. For MTH$DLOG2, x specifies a D_floating number.
For MTH$GLOG2, x specifies a G_floating number. For MTH$HLOG2, x
specifies an H_floating number.
h_log2
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Base 2 logarithm of x. The h_log2 argument is the address of an
H_floating number that is this base 2 logarithm. MTH$HLOG2 writes
the address of this logarithm into h_log2. The h_log2 argument is
used only by the MTH$HLOG2 routine.
MTH$xLOG10
MTH$xLOG10 returns the common (base 10) logarithm of the input
argument.
Format:
MTH$ALOG10 x
MTH$DLOG10 x
MTH$GLOG10 x
MTH$HLOG10 h_log10 ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of a floating-point
number. For MTH$ALOG10, x specifies an F_floating number. For
MTH$DLOG10, x specifies a D_floating number. For MTH$GLOG10, x
specifies a G_floating number. For MTH$HLOG10, x specifies an
H_floating number.
h_log10
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Common logarithm of the input value specified by x. The h_log10
argument is the address of an H_floating number that is this common
logarithm. MTH$HLOG10 writes the address of the common logarithm
into h_log10. The h_log10 argument is used only by the MTH$HLOG10
routine.
MTH$RANDOM
MTH$RANDOM is a general random-number generator.
Format:
MTH$RANDOM seed
ARGUMENT
seed
VMS usage: longword_unsigned
type: longword (unsigned)
access: modify
mechanism: by reference
The integer seed, a 32-bit number whose high-order 24 bits are
converted by MTH$RANDOM to an F_floating random number. The seed
argument is the address of an unsigned longword that contains this
integer seed. The seed is modified by each call to MTH$RANDOM.
MTH$xREAL
MTH$xREAL returns the real part of a complex number.
Format:
MTH$REAL complex-number
MTH$DREAL complex-number
MTH$GREAL complex-number
Each of the above three formats accepts as input
one of the three floating-point complex types.
ARGUMENT
complex-number
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by reference
The complex number whose real part is returned by MTH$REAL. The
complex-number argument is the address of this floating-point
complex number. For MTH$REAL, complex-number is an F_floating
complex number. For MTH$DREAL, complex-number is a D_floating
complex number. For MTH$GREAL, complex-number is a G_floating
complex number.
MTH$xSIN
MTH$xSIN returns the sine of a given angle (in radians).
Format:
MTH$SIN x
MTH$DSIN x
MTH$GSIN x
MTH$HSIN h_sine ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Angle (in radians). The x argument is the address of a
floating-point number that is this angle. For MTH$SIN, x specifies
an F_floating number. For MTH$DSIN, x specifies a D_floating
number. For MTH$GSIN, x specifies a G_floating number. For
MTH$HSIN, x specifies an H_floating number.
h_sine
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
The sine of the angle specified by x. The h_sine argument is the
address of an H_floating number that is this sine. MTH$HSIN writes
the address of the sine into h_sine. The h_sine argument is used
only by the MTH$HSIN routine.
MTH$xSINCOS
MTH$xSINCOS returns the sine and the cosine of a given angle (in
radians).
Format:
MTH$SINCOS x ,sine ,cosine
MTH$DSINCOS x ,sine ,cosine
MTH$GSINCOS x ,sine ,cosine
MTH$HSINCOS x ,sine ,cosine
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Angle (in radians) whose sine and cosine are to be returned. The x
argument is the address of a floating-point number that is this
angle. For MTH$SINCOS, x is an F_floating number. For MTH$DSINCOS,
x is a D_floating number. For MTH$GSINCOS, x is a G_floating
number. For MTH$HSINCOS, x is an H_floating number.
sine
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: write only
mechanism: by reference
Sine of the angle specified by x. The sine argument is the address
of a floating-point number. MTH$SINCOS writes an F_floating number
into sine. MTH$DSINCOS writes a D_floating number into sine.
MTH$GSINCOS writes a G_floating number into sine. MTH$HSINCOS
writes an H_floating number into sine.
cosine
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: write only
mechanism: by reference
Cosine of the angle specified by x. The cosine argument is the
address of a floating-point number. MTH$SINCOS writes an F_floating
number into cosine. MTH$DSINCOS writes a D_floating number into
cosine. MTH$GSINCOS writes a G_floating number into cosine.
MTH$HSINCOS writes an H_floating number into cosine.
MTH$xSINCOSD
MTH$xSINCOSD returns the sine and cosine of a given angle (in
degrees).
Format:
MTH$SINCOSD x ,sine ,cosine
MTH$DSINCOSD x ,sine ,cosine
MTH$GSINCOSD x ,sine ,cosine
MTH$HSINCOSD x ,sine ,cosine
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Angle (in degrees) whose sine and cosine are returned by
MTH$xSINCOSD. The x argument is the address of a floating-point
number that is this angle. For MTH$SINCOSD, x is an F_floating
number. For MTH$DSINCOSD, x is a D_floating number. For
MTH$GSINCOSD, x is a G_floating number. For MTH$HSINCOSD, x is an
H_floating number.
sine
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: write only
mechanism: by reference
Sine of the angle specified by x. The sine argument is the address
of a floating-point number. MTH$SINCOSD writes an F_floating number
into sine. MTH$DSINCOSD writes a D_floating number into sine.
MTH$GSINCOSD writes a G_floating number into sine. MTH$HSINCOSD
writes an H_floating number into sine.
cosine
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: write only
mechanism: by reference
Cosine of the angle specified by x. The cosine argument is the
address of a floating-point number. MTH$SINCOSD writes an
F_floating number into cosine. MTH$DSINCOSD writes a D_floating
number into cosine. MTH$GSINCOSD writes a G_floating number into
cosine. MTH$HSINCOSD writes an H_floating number into cosine.
MTH$xSIND
MTH$xSIND returns the sine of a given angle (in degrees).
Format:
MTH$SIND x
MTH$DSIND x
MTH$GSIND x
MTH$HSIND h_sine ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Angle (in degrees). The x argument is the address of a
floating-point number that is this angle. For MTH$SIND, x specifies
an F_floating number. For MTH$DSIND, x specifies a D_floating
number. For MTH$GSIND, x specifies a G_floating number. For
MTH$HSIND, x specifies an H_floating number.
h_sine
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Sine of the angle specified by x. The h_sine argument is the
address of an H_floating number that is this sine. MTH$HSIND writes
the address of the angle into h_sine. The h_sine argument is used
only by the MTH$HSIND routine.
MTH$xSINH
MTH$xSINH returns the hyperbolic sine of the input value specified
by x.
Format:
MTH$SINH x
MTH$DSINH x
MTH$GSINH x
MTH$HSINH h_sinh ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of a floating-point
number that is this value. For MTH$SINH, x specifies an F_floating
number. For MTH$DSINH, x specifies a D_floating number. For
MTH$GSINH, x specifies a G_floating number. For MTH$HSINH, x
specifies an H_floating number.
h_sinh
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Hyperbolic sine of the input value specified by x. The h_sinh
argument is the address of an H_floating number that is this
hyperbolic sine. MTH$HSINH writes the address of the hyperbolic
sine into h_sinh. The h_sinh argument is used only by the MTH$HSINH
routine.
MTH$xSQRT
MTH$xSQRT returns the square root of the input value x.
Format:
MTH$SQRT x
MTH$DSQRT x
MTH$GSQRT x
MTH$HSQRT h_sqrt ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Input value. The x argument is the address of a floating-point
number that contains this input value. For MTH$SQRT, x specifies an
F_floating number. For MTH$DSQRT, x specifies a D_floating number.
For MTH$GSQRT, x specifies a G_floating number. For MTH$HSQRT, an
H_floating number.
h_sqrt
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Square root of the input value specified by x. The h_sqrt argument
is the address of an H_floating number that is this square root.
MTH$HSQRT writes the address of the square root into h_sqrt. The
h_sqrt argument is used only by the MTH$HSQRT routine.
MTH$xTAN
MTH$xTAN returns the tangent of a given angle (in radians).
Format:
MTH$TAN x
MTH$DTAN x
MTH$GTAN x
MTH$HTAN h_tan ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by value
The input angle (in radians). The x argument is the address of a
floating-point number that is this angle. For MTH$TAN, x specifies
an F_floating number. For MTH$DTAN, x specifies a D_floating
number. For MTH$GTAN, x specifies a G_floating number. For
MTH$HTAN, x specifies an H_floating number.
h_tan
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Tangent of the angle specified by x. The h_tan argument is the
address of an H_floating number that is this tangent. MTH$HTAN
writes the address of the tangent into h_tan. The h_tan argument is
used only by the MTH$HTAN routine.
MTH$xTAND
MTH$xTAND returns the tangent of a given angle (in degrees).
Format:
MTH$TAND x
MTH$DTAND x
MTH$GTAND x
MTH$HTAND h_tan ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input angle (in degrees). The x argument is the address of a
floating-point number which is this angle. For MTH$TAND, x
specifies an F_floating number. For MTH$DTAND, x specifies a
D_floating number. For MTH$GTAND, x specifies a G_floating number.
For MTH$HTAND, x specifies an H_floating number.
h_tan
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Tangent of the angle specified by x. The h_tan argument is the
address of an H_floating number that is this tangent. MTH$HTAND
writes the address of the tangent into h_tan. The h_tan argument is
used only by the MTH$HTAN routine.
MTH$xTANH
MTH$xTANH returns the hyperbolic tangent of the input value.
Format:
MTH$TANH x
MTH$DTANH x
MTH$GTANH x
MTH$HTANH h_tanh ,x
Each of the above four formats accepts as input one
of the four floating-point types.
Arguments:
x
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by reference
The input value. The x argument is the address of a floating-point
number that contains this input value. For MTH$TANH, x specifies an
F_floating number. For MTH$DTANH, x specifies a D_floating number.
For MTH$GTANH, x specifies a G_floating number. For MTH$HTANH, x
specifies an H_floating number.
h_tanh
VMS usage: floating_point
type: H_floating
access: write only
mechanism: by reference
Hyperbolic tangent of the value specified by x. The h_tanh argument
is the address of a H_floating number that is this hyperbolic
tangent. MTH$HTANH writes the address of the hyperbolic tangent
into h_tanh. The h_tanh argument is used only by the MTH$TANH
routine.
MTH$UMAX
MTH$UMAX computes the unsigned longword maximum of n unsigned
longword arguments, where n is greater than or equal to 1.
Format:
MTH$UMAX arg1 [... ,argn]
Arguments:
arg1
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
First of the arguments of which MTH$UMAX computes the maximum. The
arg1 argument is an unsigned longword which contains the first
value.
argn
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Last of the arguments of which MTH$UMAX computes the maximum. The
argn argument is an unsigned longword which contains the last of the
values which MTH$UMAX compares to find the maximum.
MTH$UMIN
MTH$UMIN computes the unsigned longword minimum of n unsigned
longword arguments, where n is greater than or equal to 1.
Format:
MTH$UMIN arg1 [... ,argn]
Arguments:
arg1
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
First of the arguments of which MTH$UMIN computes the minimum. The
arg1 argument is an unsigned longword which contains the first
value.
argn
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Last of the arguments of which MTH$UMIN computes the minimum. The
argn argument is an unsigned longword which contains the last of the
values which MTH$UMIN compares to find the minimum.
OTS$
Additional information available:
OTS$CNVOUTOTS$CVT_L_TBOTS$CVT_L_TIOTS$CVT_L_TL
OTS$CVT_L_TOOTS$CVT_L_TUOTS$CVT_L_TZOTS$CVT_TB_L
OTS$CVT_TI_LOTS$CVT_TL_LOTS$CVT_TO_LOTS$CVT_TU_L
OTS$CVT_TZ_LOTS$DIV_PK_LONGOTS$DIV_PK_SHORTOTS$MOVE3
OTS$MOVE5OTS$POWIIOTS$POWJJOTS$POWLULU
OTS$SCOPY_DXDXOTS$SCOPY_R_DXOTS$SFREE1_DDOTS$SFREEN_DD
OTS$SGET1_DD
OTS$CVT T zOTS$DIVCxOTS$MULCxOTS$POWCxCx
OTS$POWCxJOTS$POWDxOTS$POWGxOTS$POWHx
OTS$POWxLUOTS$POWRx
OTS$CNVOUT
OTS$CNVOUT, OTS$CNVOUT_G and OTS$CNVOUT_H convert a D_floating,
G_floating or H_floating number to a character string in the FORTRAN
E format.
Format:
OTS$CNVOUT value ,out-string ,digits-in-fract
OTS$CNVOUT_G value ,out-string ,digits-in-fract
OTS$CNVOUT_H value ,out-string ,digits-in-fract
Arguments:
value
VMS usage: floating_point
type: D_floating, G_floating, H_floating
access: read only
mechanism: by reference
Value that OTS$CNVOUT converts to a character string. For
OTS$CNVOUT, the value argument is the address of a D_floating number
containing the value. For OTS$CNVOUT_G, the value argument is the
address of a G_floating number containing the value. For
OTS$CNVOUT_H, the value argument is the address of an H_floating
number containing the value.
out-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed length
Output string into which OTS$CNVOUT writes the character string
result of the conversion. The out-string argument is the address of
a descriptor pointing to the output string.
digits-in-fract
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of digits in the fractional portion of the result. The
digits-in-fract argument is an unsigned longword containing the
number of digits to be written to the fractional portion of the
result.
OTS$CVT_L_TB
OTS$CVT_L_TB converts an unsigned integer value of arbitrary length
to binary representation in an ASCII text string. By default, a
longword is converted.
Format:
OTS$CVT_L_TB value ,out-str [,int-digits] [,value-size]
Arguments:
value
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: by reference
Unsigned integer value that OTS$CVT_L_TB converts to binary
representation in an ASCII text string. The value argument is the
address of this integer value.
out-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed-length
ASCII text string that OTS$CVT_L_TB creates when it converts the
integer value. The out-str argument is the address of a descriptor
pointing to this ASCII text string. The string is assumed to be
fixed length (DSC$K_CLASS_S).
int-digits
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Minimum number of digits in the binary representation to be
generated. The int-digits argument is a signed longword integer
containing this minumum number. This is an optional argument. If
omitted, the default is 1. If the actual number of significant
digits is less than the minimum number of digits, leading zeros are
produced. If the minimum number of digits is zero and the value of
the integer to be converted is also zero, OTS$CVT_L_TB creates a
blank string.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Size of the integer to be converted, in bytes. The value-size
argument is a signed longword integer containing the byte size.
This is an optional argument. If omitted, the default is 4.
OTS$CVT_L_TI
OTS$CVT_L_TI converts a signed integer to a decimal ASCII text
string. This procedure supports FORTRAN Iw and Iw.m output and
BASIC output conversion.
Format:
OTS$CVT_L_TI value ,out-str [,int-digits] [,value-size] [,flags]
Arguments:
value
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: by reference
Signed integer value that OTS$CVT_L_TI converts to a decimal ASCII
text string. The value argument is the address of this integer
value.
out-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed length
Decimal ASCII text string that OTS$CVT_L_TI creates when it converts
the signed integer. The out-str argument is the address of a
descriptor pointing to this text string. The string is assumed to
be fixed-length (DSC$K_CLASS_S).
int-digits
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Minimum number of digits to be generated when OTS$CVT_L_TI converts
the signed integer to a decimal ASCII text string. The int-digits
argument is a signed longword integer containing this number. This
is an optional argument. If omitted, the default value is 1. If
the actual number of significant digits is smaller, OTS$CVT_L_TI
inserts leading zeros into the output string. If int-digits is zero
and value is zero, OTS$CVT_L_TI writes a blank string to the output
string.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the value to be converted to text. The
value-size argument is a signed longword integer containing this
value size. The value size must be either 1, 2, or 4. If value
size is 1 or 2, the value is sign-extended to a longword before
conversion. This is an optional argument. If omitted, the default
is 4.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Caller-supplied flags that you may use if you want OTS$CVT_L_TI to
insert a plus sign before the converted number. The flags argument
is an unsigned longword containing the flags.
OTS$CVT_L_TL
OTS$CVT_L_TL converts an integer to ASCII text string representation
using FORTRAN L (logical) format.
Format:
OTS$CVT_L_TL value ,out-str
Arguments:
value
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Value that OTS$CVT_L_TL converts to an ASCII text string. The value
argument is the address of a signed longword integer containing this
integer value.
out-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed length
Output string that OTS$CVT_L_TL creates when it converts the integer
value to an ASCII text string. The out-str argument is the address
of a descriptor pointing to this ASCII text string.
OTS$CVT_L_TO
OTS$CVT_L_TO converts an unsigned integer to an octal ASCII text
string. OTS$CVT_L_TO supports FORTRAN Ow and Ow.m output conversion
formats.
Format:
OTS$CVT_L_TO value ,out-str [,int-digits] [,value-size]
Arguments:
value
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: by reference
Integer value that OTS$CVT_L_TO converts to an octal ASCII text
string. The value argument is the address of this integer value.
out-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed length
Output string that OTS$CVT_L_TO creates when it converts the integer
value to an octal ASCII text string. The out-str argument is the
address of a descriptor pointing to the octal ASCII text string.
The string is assumed to be fixed-length (DSC$K_CLASS_S).
int-digits
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Minimum number of digits that OTS$CVT_L_TO generates when it
converts the integer value to an octal ASCII text string. The
int-digits argument is a signed longword integer containing the
minimum number of digits. This is an optional argument. If
omitted, the default is 1. If the actual number of significant
digits in the octal ASCII text string is less than the minimum
number of digits, OTS$CVT_L_TO inserts leading zeros into the output
string. If int-digits is zero and value is zero, OTS$CVT_L_TO
writes a blank string to the output string.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Size of the integer to be converted, in bytes. The value-size
argument is a signed longword integer containing the number of bytes
in the integer to be converted by OTS$CVT_L_TO. This is an optional
argument. If omitted, the default is 4.
OTS$CVT_L_TU
OTS$CVT_L_TU converts a byte, word or longword value to unsigned
decimal representation in an ASCII text string. By default, a
longword is converted.
Format:
OTS$CVT_L_TU value ,out-str [,int-digits] [,value-size]
Arguments:
value
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: by reference
Unsigned byte, word or longword that OTS$CVT_L_TU converts to
unsigned decimal representation in an ASCII text string. (The value
of the value-size argument determines whether value is a byte, word
or longword.) The value argument is the address of the unsigned
integer.
out-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed-length
Output string (fixed-length) that OTS$CVT_L_TU creates when it
converts the integer value to unsigned decimal representation in an
ASCII text string. The out-str argument is the address of a
descriptor pointing to this ASCII text string.
int-digits
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Minimum number of digits in the ASCII text string that OTS$CVT_L_TU
creates. The int-digits argument is an unsigned longword containing
the minimum number. This is an optional argument. If omitted, the
default is 1.
value-size
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Size of the integer value to be converted, in bytes. The value-size
argument is an unsigned longword containing the size of the integer
value. This is an optional argument. If omitted, the default is 4.
The only values that OTS$CVT_L_TU allows are 1, 2 and 4. If any
other value is specified, OTS$CVT_L_TU uses the default value, 4.
OTS$CVT_L_TZ
OTS$CVT_L_TZ converts an unsigned integer to a hexadecimal ASCII
text string. OTS$CVT_L_TZ supports FORTRAN Zw and Zw.m output
conversion formats.
Format:
OTS$CVT_L_TZ value ,out-str [,int-digits] [,value-size]
Arguments:
value
VMS usage: varying_arg
type: unspecified
access: read only
mechanism: by reference
Integer value that OTS$CVT_L_TZ converts to a hexadecimal ASCII text
string. The value argument is the address of this integer value.
out-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor, fixed length
Output string that OTS$CVT_L_TZ creates when it converts the integer
value to a hexidecimal ASCII text string. The out-str argument is
the address of a descriptor pointing to this ASCII text string. The
string is assumed to be fixed-length (DSC$K_CLASS_S).
int-digits
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Minimum number of digits in the ASCII text string that OTS$CVT_L_TZ
creates when it converts the integer. The int-digits argument is a
signed longword integer containing this minimum number. This is an
optional argument. If omitted, the default is 1. If the actual
number of significant digits in the text string that OTS$CVT_L_TZ
creates is less than this minimum number, OTS$CVT_L_TZ inserts
leading zeros in the output string. If the minimum number of digits
is zero and the integer value to be converted is also zero,
OTS$CVT_L_TZ writes a blank string to the output string.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Size of the integer that OTS$CVT_L_TZ converts, in bytes. The
value-size argument is a signed longword integer containing the
value size. This is an optional argument. If omitted, the default
is 4.
OTS$CVT_TB_L
OTS$CVT_TB_L converts an ASCII text string representation of an
unsigned binary value to an unsigned integer value of arbitrary
length. By default, the result is a longword. Valid input
characters are the blank and the digits 0 and 1. No sign is
permitted.
Format:
OTS$CVT_TB_L inp-str ,value [,value-size] [,flags]
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Input string containing the ASCII text string representation of an
unsigned binary value that OTS$CVT_TB_L converts to an integer
value. The inp-str argument is the address of a descriptor pointing
to the ASCII text string.
value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Integer that OTS$CVT_TB_L creates when it converts the ASCII text
string. The value argument is the address of the integer value.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the value created when OTS$CVT_TB_L
converts the ASCII text string to an integer value. The value-size
argument contains the value size. If value-size contains a zero or
a negative number, OTS$CVT_TB_L returns an error code as the
condition value. This is an optional argument. If omitted, the
default is 4.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
User-supplied flags that OTS$CVT_TB_L uses to determine how to
interpret blanks and tabs. The flags argument contains the value of
the user-supplied flags.
OTS$CVT_TI_L
OTS$CVT_TI_L converts an ASCII text string representation of a
decimal number to a signed byte, word, or longword integer value.
The result is a longword by default, but the calling program can
specify a byte or a word value instead.
Format:
OTS$CVT_TI_L inp-str ,value [,value-size] [,flags]
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed-length or dynamic string
Input ACSII text string that OTS$CVT_TI_L converts to a signed byte,
word, or longword. The inp-str argument is the address of a
descriptor pointing to the input string.
value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Signed byte, word, or longword integer value (depending on
value-size) that OTS$CVT_TI_L creates when it converts the ASCII
text string. The value argument is the address of the integer
value.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the value that OTS$CVT_TI_L creates when
it converts the ASCII text string to an integer value. Valid values
for the value-size argument are 1, 2, and 4. The contents of
value-size determine whether the integer value that OTS$CVT_TI_L
creates is a byte, word, or longword. If an invalid value is given,
OTS$CVT_TI_L returns an error. This is an optional argument. If
omitted, the default is 4 and OTS$CVT_TI_L returns a longword
integer.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
User-supplied flags that OTS$CVT_TI_L uses to determine how blanks
and tabs are interpreted. The flags argument is an unsigned
longword containing the value of the flags.
Bit Description
0 If set, OTS$CVT_TI_L ignores all blanks. If clear,
OTS$CVT_TI_L ignores leading blanks but interprets
blanks after the first legal character as zeros.
4 If set, OTS$CVT_TI_L ignores tabs. If clear,
OTS$CVT_TI_L interprets tabs as invalid characters.
OTS$CVT_TL_L
OTS$CVT_TL_L converts an ASCII text string representation of a
FORTRAN-77 L format to a byte, word, or longword integer value. The
result is a longword by default, but the calling program can specify
a byte or a word value instead.
Format:
OTS$CVT_TL_L inp-str ,value [,value-size]
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed-length or dynamic string
Input string containing an ASCII text representation of a FORTRAN-77
L format that OTS$CVT_TL_L converts to a byte, word or longword
integer value. The inp-str argument is the address of a descriptor
pointing to the input string.
value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Integer value that OTS$CVT_TL_L creates when it converts the ACSII
text input string. The value argument is the address of this
integer value. OTS$CVT_TL_L returns a minus one (-1) as the
contents of the value argument if the character denoted by "Letter:"
is "T" or "t". Otherwise, OTS$CVT_TL_L sets value to zero.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the integer value that OTS$CVT_TL_L
creates when it converts the ASCII text input string. The
value-size argument contains the number of bytes. Valid values are
1, 2, and 4. These values determine whether OTS$CVT_TL_L returns a
byte, word or longword integer value. If an invalid value is given,
OTS$CVT_TL_L returns an error. This is an optional argument. If
omitted, the default is 4 and OTS$CVT_TL_L returns a longword
integer value.
OTS$CVT_TO_L
OTS$CVT_TO_L converts an ASCII text string representation of an
unsigned octal value to an unsigned integer of an arbitrary length.
The result is a longword by default, but the calling program can
specify any number of bytes.
Format:
OTS$CVT_TO_L inp-str ,value [,value-size] [,flags]
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed-length or dynamic string
Input string containing an ASCII text string representation of an
unsigned octal value that OTS$CVT_TO_L converts to an unsigned
integer. The inp-str argument is the address of a descriptor
pointing to the input string. The valid input characters are blanks
and the digits 0 through 7. No sign is permitted.
value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Integer value that OTS$CVT_TO_L creates when it converts the input
string. The value argument is the address of the unsigned integer
value.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the unsigned integer value. The
value-size argument contains the number of bytes. If the content of
the value-size argument is zero or a negative number, OTS$CVT_TO_L
returns an error. This is an optional argument. If omitted, the
default is 4 and OTS$CVT_TO_L returns a longword integer.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
User-supplied flags that OTS$CVT_TO_L uses to determine how blanks
within the input string are interpreted. The flags argument
contains the user-supplied flags.
Bit 0 If set, OTS$CVT_TO_L ignores all blanks. If clear,
OTS$CVT_TO_L interprets blanks as zeros.
OTS$CVT_TU_L
OTS$CVT_TU_L converts an ASCII text string representation of an
unsigned decimal value to an unsigned byte, word, or longword value.
By default, the result is a longword. Valid input characters are
the space and the digits 0 through 9. No sign is permitted.
Format:
OTS$CVT_TU_L inp-str ,value [,value-size] [,flags]
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed-length
Input string (fixed-length) containing an ASCII text string
representation of an unsigned decimal value that OTS$CVT_TU_L
converts to a byte, word, or longword value. The inp-str argument
is the address of a descriptor pointing to the input string.
value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Byte, word, or longword (depending on value-size) into which
OTS$CVT_TU_L writes the converted value. The value argument is the
address of the byte, word, or longword.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the value created when OTS$CVT_TU_L
converts the input string. The value-size argument contains the
number of bytes. OTS$CVT_TU_L allows value sizes of 1, 2 and 4. If
any other value is specified, or if value-size is omitted,
OTS$CVT_TU_L uses the default, 4.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
User-supplied flags which OTS$CVT_TU_L uses to determine how blanks
and tabs are interpreted. The flags argument contains the
user-supplied flags.
Bit Description
0 If set, OTS$CVT_TU_L ignores blanks. If clear,
OTS$CVT_TU_L interprets blanks as zeros.
4 If set, OTS$CVT_TU_L ignores tabs. If clear, OTS$CVT_TU_L
interprets tabs as invalid characters.
OTS$CVT T z
The OTS$CVT_T_z routines convert an ASCII text string
representation of a numeric value to a D_floating, F_floating,
G_floating, or H_floating value.
Format:
OTS$CVT_T_D inp-str ,value [,digits-in-fract] [,scale-factor]
[,flags] [,ext-bits]
OTS$CVT_T_F inp-str ,value [,digits-in-fract] [,scale-factor]
[,flags] [,ext-bits]
OTS$CVT_T_G inp-str ,value [,digits-in-fract] [,scale-factor]
[,flags] [,ext-bits]
OTS$CVT_T_H inp-str ,value [,digits-in-fract] [,scale-factor]
[,flags] [,ext-bits]
Each of the above four formats corresponds to one of
the four floating-point types.
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed-length or dynamic string
Input string containing an ASCII text string representation of a
numeric value that OTS$CVT_T_Z converts to a D_floating, F_floating,
G-floating, or H-floating value. The inp-str argument is the
address of a descriptor pointing to the input string.
value
VMS usage: floating_point
type: D_floating, F_floating, G_floating, H_floating
access: write only
mechanism: by reference
Floating-point value that OTS$CVT_T_z creates when it converts the
input string. The value argument is the address of the
floating-point value. For OTS$CVT_T_D, value is a D_floating
number. For OTS$CVT_T_F, value is an F_floating number. For
OTS$CVT_T_G, value is a G_floating number. For OTS$CVT_T_H, value
is an H_floating number.
digits-in-fract
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of digits in the fraction if no decimal point is included in
the input string. The digits-in-fract argument contains the number
of digits. This is an optional argument. If omitted, the default
is zero.
scale-factor
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Scale factor. The scale-factor argument contains the value of the
scale factor. If bit 6 of the flags argument is clear, the
resultant value is divided by 10**factor unless the exponent is
present. If bit 6 of flags is set, the scale factor is always
applied. This is an optional argument. If omitted, the default is
zero.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
User-supplied flags. The flags argument contains the user-supplied
flags.
Bit 0 If set, OTS$CVT_T_z ignores blanks. If clear,
OTS$CVT_T_z interprets blanks as zeros.
Bit 1 If set, OTS$CVT_T_z allows only E or e exponents. If
clear, OTS$CVT_T_z allows E, e, D, d, Q and q
exponents. (Bit 1 is clear for BASIC and set for
FORTRAN.)
Bit 2 If set, OTS$CVT_T_z interprets an underflow as an
error. If clear, OTS$CVT_T_z does not interpret an
underflow as an error.
Bit 3 If set, OTS$CVT_T_z truncates the value. If clear,
OTS$CVT_T-z rounds the value.
Bit 4 If set, OTS$CVT_T_z ignores tabs. If clear, OTS$CVT_T_z
interprets tabs as invalid characters.
Bit 5 If set, an exponent must begin with a valid exponent
letter. If clear, the exponent letter may be omitted.
Bit 6 If set, OTS$CVT_T_z always applies the scale factor. If
clear, OTS$CVT_T_z applies the scale factor only if
there is no exponent present in the string.
ext-bits
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Extra precision bits. The ext-bits argument is the address of a
signed word integer containing the extra precision bits. If
present, value is not rounded, and the first n bits after truncation
are returned in this argument. For D_floating and F_floating, n
equals 8 and the bits are returned as a byte. For G_floating and
H_floating, n equals 11 and 15, respectively, and the bits are
returned as a word, left-justified.
OTS$CVT_TZ_L
OTS$CVT_TZ_L converts an ASCII text string representation of an
unsigned hexadecimal value to an unsigned integer of an arbitrary
length. The result is a longword by default, but the calling
program can specify either 1, 2 or 4 bytes to receive either a byte,
word, or longword value.
Format:
OTS$CVT_TZ_L inp-str ,value [,value-size] [,flags]
Arguments:
inp-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed-length or dynamic string
Input string containing an ASCII text string representation of an
unsigned hexadecimal value that OTS$CVT_TZ_L converts to an unsigned
integer. The inp-str argument is the address of a descriptor
pointing to the input string. Valid input characters are the space,
the digits 0 through 9, and the letters A through F. No sign is
permitted. Lowercase letters a through f are acceptable.
value
VMS usage: varying_arg
type: unspecified
access: write only
mechanism: by reference
Integer value created when OTS$CVT_TZ_L converts the input string.
The value argument is the address of the integer value.
value-size
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes occupied by the integer value. The value-size
argument contains the number of bytes. If the value size is zero or
a negative number, OTS$CVT_TZ_L returns an input conversion error.
This is an optional argument. If omitted, the default is 4.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
User-supplied flags that OTS$CVT_TZ_L uses to determine how blanks
are interpreted. The flags argument is an unsigned longword
containing these user-supplied flags.
Bit 0 If set, OTS$CVT_TZ_L ignores blanks. If set,
OTS$CVT_TZ_L interprets blanks as zeros.
OTS$DIVCx
OTS$DIVC, OTS$DIVCD_R3 and OTS$DIVCG_R3 return a complex result of a
complex division on complex numbers.
Format:
OTS$DIVC dividend ,divisor
OTS$DIVCD_R3 dividend ,divisor
OTS$DIVCG_R3 dividend ,divisor
Each of the above three formats corresponds to one
of the three floating-point complex types.
Arguments:
dividend
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex dividend. The dividend argument contains a floating-point
complex value. For OTS$DIVC, dividend is an F_floating complex
number. For OTS$DIVCD_R3, dividend is a D_floating complex number.
For OTS$DIVCG_R3, dividend is a G_floating complex number.
divisor
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex divisor. The divisor argument contains the value of the
divisor. For OTS$DIVC, divisor is an F_floating complex number.
For OTS$DIVCD_R3, divisor is a D_floating complex number. For
OTS$DIVCG_R3, divisor is a G_floating complex number.
OTS$DIV_PK_LONG
OTS$DIV_PK_LONG divides fixed-point decimal data, which is stored in
packed decimal form, when precision and scale requirements for the
quotient call for multiple precision division. The divisor must
have a precision of thirty or thirty-one digits.
Format:
OTS$DIV_PK_LONG divd ,divr ,divr-prec ,quot ,quot-prec
,prec-data ,scale-data
Arguments:
divd
VMS usage: address
type: packed decimal string
access: read only
mechanism: by reference
Dividend. The divd argument is the address of a packed decimal
string which contains the shifted dividend.
divr
VMS usage: address
type: packed decimal string
access: read only
mechanism: by reference
Divisor. The divr argument is the address of a packed decimal
string which contains the divisor.
divr-prec
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Precision of the divisor. The divr-prec argument is a signed word
integer which contains the precision of the divisor. The high order
bits are filled with zeros.
quot
VMS usage: address
type: packed decimal string
access: write only
mechanism: by reference
Quotient. The quot argument is the address of the packed decimal
string into which OTS$DIV_PK_LONG writes the quotient.
quot-prec
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Precision of the quotient. The quot-prec argument is a signed word
integer that contains the precision of the quotient. The high order
bits are filled with zeros.
prec-data
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Additional digits of precision required. The prec-data argument is
a signed word integer that contains the value of the additional
digits of precision required.
scale-data
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
The scale-data argument is a signed word integer that contains the
scale data.
OTS$DIV_PK_SHORT
OTS$DIV_PK_SHORT divides fixed-point decimal data, which is stored
in packed decimal form, when precision and scale requirements for
the quotient call for multiple-precision division. The divisor can
have a maximum precision of twenty-nine digits.
Format:
OTS$DIV_PK_SHORT divd ,divr ,divr-prec ,quot ,quot-prec
,prec-data
Arguments:
divd
VMS usage: address
type: packed decimal string
access: read only
mechanism: by reference
Dividend.The divd argument is the address of a packed decimal string
which contains the shifted dividend.
divr
VMS usage: address
type: packed decimal string
access: read only
mechanism: by reference
Divisor. The divr argument is the address of a packed decimal
string which contains the divisor.
divr-prec
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Precision of the divisor. The divr-prec argument is a signed word
integer which contains the precision of the divisor. The high-order
bits are filled with zeros.
quot
VMS usage: address
type: packed decimal string
access: write only
mechanism: by reference
Quotient. The quot argument is the address of a packed decimal
string into which OTS$DIV_PK_SHORT writes the quotient.
quot-prec
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Precision of the quotient. The quot-prec argument is a signed word
integer which contains the precision of the quotient. The
high-order bits are filled with zeros.
prec-data
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Additional digits of precision required. The prec-data argument is
a signed word integer which contains the value of the additional
digits of precision required.
OTS$MOVE3
OTS$MOVE3 moves up to 2**31-1 bytes, (2,147,483,647 bytes) from a
specified source address to a specified destination address.
Format:
OTS$MOVE3 length ,source ,dest
Arguments:
length
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes of data to move. The length argument contains the
number of bytes to move. The value of length may range from 0 to
2,147,483,647 bytes.
source
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference, array reference
Data to be moved by OTS$MOVE3. The source argument contains the
address of an unsigned byte array that contains this data.
dest
VMS usage: byte_unsigned
type: byte (unsigned)
access: write only
mechanism: by reference, array reference
Item into which source will be moved. The dest argument is the
address of an unsigned byte array into which OTS$MOVE3 writes the
source data.
OTS$MOVE5
OTS$MOVE5 moves up to 2**31-1 bytes, (2,147,483,647 bytes) from a
specified source address to a specified destination address, with
separate source and destination lengths, and with fill. Overlap of
the source and destination arrays does not affect the result.
Format:
OTS$MOVE5 srclen ,source ,fill ,dstlen ,dest
Arguments:
srclen
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Number of bytes of data to move. The srclen argument contains a
signed longword integer that is this number. The value of srclen
may range from 0 to 2,147,483,647.
source
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference, array reference
Data to be moved by OTS$MOVE5. The source argument contains the
address of an unsigned byte array that contains this data.
fill
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by value
Character used to pad the source data if scrclen is less than
dstlen. The fill argument contains the address of an unsigned byte
that is this character.
dstlen
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Size of the destination area in bytes. The dstlen argument is a
signed longword integer containing this size. The value of dstlen
may range from 0 through 2,147,483,647.
dest
VMS usage: byte_unsigned
type: byte (unsigned)
access: write only
mechanism: by reference, array reference
Item into which source will be moved. The dest argument is the
address of an unsigned byte array into which OTS$MOVE5 will write
the source data.
OTS$MULCx
OTS$MULCD_R3 and OTS$MULCG_R3 calculate the complex product of two
complex values.
Format:
OTS$MULCD_R3 multiplier ,multiplicand
OTS$MULCG_R3 multiplier ,multiplicand
The above formats correspond to the D_floating and
G_floating complex types.
Arguments:
multiplier
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex multiplier. The multiplier argument contains the
multiplier. For OTS$MULCD_R3, multiplier is a D_floating complex
number. For OTS$MULCG_R3, multiplier is a G_floating complex
number.
multiplicand
VMS usage: complex_number
type: D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex multiplicand. The multiplicand argument contains the
multiplicand. For OTS$MULCD_R3, multiplicand is a D_floating
complex number. For OTS$MULCG_R3, multiplicand is an F_floating
complex number.
OTS$POWCxCx
OTS$POWCC, OTS$POWCDCD_R3 and OTS$POWCGCG_R3 return the result of
raising a complex base to a complex exponent.
Format:
OTS$POWCC base ,exponent
OTS$POWCDCD_R3 base ,exponent
OTS$POWCGCG_R3 base ,exponent
Each of the above three formats corresponds to one
of the three floating-point complex types.
Arguments:
base
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex base. The base argument contains the value of the base.
For OTS$POWCC, base is an F_floating complex number. For
OTS$POWCDCD_R3, base is a D_floating complex number. For
OTS$POWCGCG_R3, base is a G_floating complex number.
exponent
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex exponent. The exponent argument contains the value of the
exponent. For OTS$POWCC, exponent is an F_floating complex number.
For OTS$POWCDCD_R3, exponent is a D_floating complex number. For
OTS$POWCGCG_R3, exponent is a G_floating complex number.
OTS$POWCxJ
These procedures return the complex result of raising a complex base
to an integer exponent.
Format:
OTS$POWCJ base ,exponent
OTS$POWCDJ_R3 base ,exponent
OTS$POWCGJ_R3 base ,exponent
Each of the above three formats corresponds to one
of the three floating-point complex types.
Arguments:
base
VMS usage: complex_number
type: F_floating complex, D_floating complex, G_floating complex
access: read only
mechanism: by value
Complex base. The base argument contains the complex base. For
OTS$POWCJ, base is an F_floating complex number. For OTS$POWCDJ_R3,
base is a D_floating complex number. For OTS$POWCGJ_R3, base is a
G_floating complex number.
exponent
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Exponent. The exponent argument is a signed longword integer
containing the exponent.
OTS$POWDx
OTS$POWDD, OTS$POWDJ, and OTS$POWDR raise a D_floating base to a
D_floating, longword, or F_floating exponent.
Format:
OTS$POWDD base ,exponent
OTS$POWDJ base ,exponent
OTS$POWDR base ,exponent
The above formats correspond to raising the
D_floating base to a D_floating, longword, or
F_floating exponent.
Arguments:
base
VMS usage: floating_point
type: D_floating
access: read only
mechanism: by value
Base. The base argument is a D_floating number containing the base.
exponent
VMS usage: floating_point
type: D_floating, longword integer (signed), F_floating
access: read only
mechanism: by value
Exponent. The exponent argument contains the exponent. For
OTS$POWDD, exponent is a D_floating number. For OTS$POWDJ, exponent
is a signed longword integer. For OTS$POWDR, exponent is an
F_floating number.
OTS$POWGx
OTS$POWGG and OTS$POWGJ raise a G_floating base to a G_floating or
longword exponent.
Format:
OTS$POWGG base ,exponent
OTS$POWGJ base ,exponent
Arguments:
base
VMS usage: floating_point
type: G_floating
access: read only
mechanism: by value
Base which OTS$POWGx raises to a G_floating or longword exponent.
The base argument is a G_floating number containing the base.
exponent
VMS usage: floating_point
type: G_floating, longword integer (signed)
access: read only
mechanism: by value
Exponent to which OTS$POWGx raises the base. For OTS$POWGG, the
exponent argument is a G_floating number containing the exponent.
For OTS$POWGJ, the exponent argument is a signed longword integer
containing the exponent.
OTS$POWHx
OTS$POWHH_R3 and OTS$POWHJ_R3 raise an H_floating base to an
H_floating or longword exponent.
Format:
OTS$POWHH_R3 base ,exponent
OTS$POWHJ_R3 base ,exponent
The above formats correspond to raising an
H_floating number to either an H_floating or a signed
longword integer exponent.
Arguments:
base
VMS usage: floating_point
type: H_floating
access: read only
mechanism: by value
Base. The base argument is an H_floating number containing the
base.
exponent
VMS usage: longword_signed
type: H_floating, longword integer (signed)
access: read only
mechanism: by value
Exponent. The exponent argument contains the exponent. For
OTS$POWHH_R3, exponent is an H_floating number. For OTS$POWHJ_R3,
exponent is a signed longword integer.
OTS$POWII
OTS$POWII raises a word base to a word exponent.
Format:
OTS$POWII base ,exponent
Arguments:
base
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Base. The base argument is a signed word integer containing the
base.
exponent
VMS usage: word_signed
type: word integer (signed)
access: read only
mechanism: by value
Exponent. The exponent argument is a signed word integer containing
the exponent.
OTS$POWJJ
OTS$POWJJ raises a signed longword base to a signed longword
exponent.
Format:
OTS$POWJJ base ,exponent
Arguments:
base
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Base. The base argument is a signed longword integer containing the
base.
exponent
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by value
Exponent. The exponent argument is a signed longword integer
containing the exponent.
OTS$POWLULU
OTS$POWLULU returns the result of raising an unsigned longword
integer base to an unsigned longword integer exponent.
Format:
OTS$POWLULU base, exponent
Arguments:
base
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Unsigned longword integer base. The base argument contains the
value of the integer base.
exponent
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Unsigned longword integer exponent. The exponent argument contains
the value of the integer exponent.
OTS$POWxLU
OTS$POWRLU, OTS$POWDLU, OTS$POWGLU, and OTS$POWHLU_R3 return the
result of raising a floating-point base to an unsigned longword
integer exponent.
Format:
OTS$POWRLU base ,exponent
OTS$POWDLU base ,exponent
OTS$POWGLU base ,exponent
OTS$POWHLU_R3 base ,exponent
Arguments:
base
VMS usage: floating_point
type: F_floating, D_floating, G_floating, H_floating
access: read only
mechanism: by value
Floating-point base. The base argument contains the value of the
base. For OTS$POWRLU, base is an F_floating number. For
OTS$POWDLU, base is a D_floating number. For OTS$POWGLU, base is a
G_floating number. For OTS$POWHLU_R3, base is an H_floating number.
exponent
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Integer exponent. The exponent argument contains the value of the
unsigned longword integer exponent.
OTS$POWRx
OTS$POWRD, OTS$POWRJ, and OTS$POWRR raise an F_floating base to a
D_floating, longword,or F_floating exponent.
Format:
OTS$POWRD base ,exponent
OTS$POWRJ base ,exponent
OTS$POWRR base ,exponent
The above formats correspond to raising the base to
a D_floating, longword and F_floating exponent.
Arguments:
base
VMS usage: floating_point
type: F_floating
access: read only
mechanism: by value
Base. The base argument is an F_floating number containing the
base.
exponent
VMS usage: varying_arg
type: D_floating, longword integer (signed), F_floating
access: read only
mechanism: by value
Exponent. The exponent argument contains the exponent. For
OTS$POWRD, exponent is a D-floating number. For OTS$POWRJ, exponent
is a signed longword integer. For OTS$POWRR, exponent is an
F_floating number.
OTS$SCOPY_DXDX
OTS$SCOPY_DXDX copies a source string to a destination string. Both
strings are passed by descriptor.
Format:
OTS$SCOPY_DXDX src-str ,dst-str
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string. The src-str argument is the address of a descriptor
pointing to the source string. The descriptor class can be
unspecified, fixed length, dynamic, scalar decimal, array,
noncontiguous array, or varying.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string. The dst-str argument is the address of a
descriptor pointing to the destination string. The class field
determines the appropriate action.
OTS$SCOPY_R_DX
OTS$SCOPY_R_DX copies a source string passed by reference to a
destination string.
Format:
OTS$SCOPY_R_DX src-len ,src-adr ,dst-str
Arguments:
src-len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by value
Length of the source string. The src-len argument is an unsigned
word integer containing the length of the source string.
src-adr
VMS usage: char_string
type: character string
access: read only
mechanism: by reference
Source string. The src-adr argument is the address of the source
string.
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string. The dst-str argument is the address of a
descriptor pointing to the destination string. The class field
determines the appropriate action. The length field (DSC$W_LENGTH)
alone or both the address (DSC$A_POINTER) and length fields can be
modified if the string is dynamic. For varying strings, the current
length is rewritten.
OTS$SFREE1_DD
OTS$SFREE1_DD returns one dynamic string area to free storage.
Format:
OTS$SFREE1_DD dyn-dsc
Arguments:
dyn-dsc
VMS usage: quadword_unsigned
type: quadword (unsigned)
access: modify
mechanism: by reference
Dynamic string descriptor. The dyn-dsc argument is the address of
the dynamic string descriptor. The descriptor is assumed to be
dynamic and its class field is not checked.
OTS$SFREEN_DD
OTS$SFREEN_DD takes as input a vector of one or more dynamic string
areas and returns them to free storage.
Format:
OTS$SFREEN_DD dsc-num ,first-dsc
Arguments:
dsc-num
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of adjacent descriptors to be flagged as having no allocated
area (DSC$A_POINTER = 0 and DSC$W_LENGTH = 0) and to have their
allocated areas returned to free storage by OTS$SFREEN_DD. The
dsc-num argument is an unsigned longword containing this number.
first-dsc
VMS usage: quadword_unsigned
type: quadword (unsigned)
access: modify
mechanism: by reference
First string descriptor of an array of string descriptors. The
first-dsc argument is the address of the first string descriptor.
The descriptors are assumed to be dynamic, and their class fields
are not checked.
OTS$SGET1_DD
OTS$SGET1_DD allocates a specified number of bytes of dynamic
virtual memory to a specified string descriptor.
Format:
OTS$SGET1_DD len ,dyn-dsc
Arguments:
len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by value
Number of bytes to be allocated. The len argument contains the
number of bytes. The amount of storage allocated is automatically
rounded up. If the number of bytes is zero, a small number of bytes
is allocated.
dyn-dsc
VMS usage: quadword_unsigned
type: quadword (unsigned)
access: modify
mechanism: by reference
Dynamic string descriptor to which the area is to be allocated. The
dyn-str argument is the address of the dynamic string descriptor.
The class field is not checked but it is set to dynamic (DSC$B_CLASS
= 2). The length field (DSC$W_LENGTH) is set to len and the address
field (DSC$A_POINTER) is set to the string area allocated (first
byte beyond the header).
SMG$
Additional information available:
SMG$ADD_KEY_DEFSMG$BEGIN_DISPLAY_UPDATESMG$BEGIN_PASTEBOARD_UPDATE
SMG$CANCEL_INPUTSMG$CHANGE_PBD_CHARACTERISTICSSMG$CHANGE_RENDITION
SMG$CHANGE_VIRTUAL_DISPLAYSMG$CHECK_FOR_OCCLUSIONSMG$CONTROL_MODE
SMG$COPY_VIRTUAL_DISPLAYSMG$CREATE_KEY_TABLESMG$CREATE_PASTEBOARD
SMG$CREATE_VIRTUAL_DISPLAYSMG$CREATE_VIRTUAL_KEYBOARD
SMG$CURSOR_COLUMNSMG$CURSOR_ROWSMG$DEFINE_KEY
SMG$DEL_TERM_TABLESMG$DELETE_CHARSSMG$DELETE_KEY_DEF
SMG$DELETE_LINESMG$DELETE_PASTEBOARDSMG$DELETE_VIRTUAL_DISPLAY
SMG$DELETE_VIRTUAL_KEYBOARDSMG$DISABLE_BROADCAST_TRAPPING
SMG$DISABLE_UNSOLICITED_INPUTSMG$DRAW_LINESMG$DRAW_RECTANGLE
SMG$ENABLE_UNSOLICITED_INPUTSMG$END_DISPLAY_UPDATE
SMG$END_PASTEBOARD_UPDATESMG$ERASE_CHARSSMG$ERASE_DISPLAY
SMG$ERASE_LINESMG$ERASE_PASTEBOARDSMG$FIND_CURSOR_DISPLAY
SMG$FLUSH_BUFFERSMG$GET_BROADCAST_MESSAGESMG$GET_CHAR_AT_PHYSICAL_CURSOR
SMG$GET_DISPLAY_ATTRSMG$GET_KEY_DEFSMG$GET_KEYBOARD_ATTRIBUTES
SMG$GET_NUMERIC_DATASMG$GET_PASTING_INFOSMG$GET_PASTEBOARD_ATTRIBUTES
SMG$GET_TERM_DATASMG$HOME_CURSORSMG$INIT_TERM_TABLE
SMG$INIT_TERM_TABLE_BY_TYPESMG$INSERT_CHARSSMG$INSERT_LINE
SMG$INVALIDATE_DISPLAYSMG$LABEL_BORDERSMG$LIST_KEY_DEFS
SMG$LOAD_KEY_DEFSSMG$MOVE_VIRTUAL_DISPLAYSMG$PASTE_VIRTUAL_DISPLAY
SMG$POP_VIRTUAL_DISPLAYSMG$PUT_CHARSSMG$PUT_CHARS_HIGHWIDE
SMG$PUT_CHARS_WIDESMG$PUT_LINESMG$PUT_LINE_HIGHWIDE
SMG$PUT_LINE_WIDESMG$PUT_PASTEBOARDSMG$PUT_VIRTUAL_DISPLAY_ENCODED
SMG$READ_COMPOSED_LINESMG$READ_FROM_DISPLAYSMG$READ_KEYSTROKE
SMG$READ_STRINGSMG$READ_VERIFYSMG$REPAINT_LINESMG$REPAINT_SCREEN
SMG$REPASTE_VIRTUAL_DISPLAYSMG$REPLACE_INPUT_LINE
SMG$RESTORE_PHYSICAL_SCREENSMG$RETURN_CURSOR_POS
SMG$RETURN_INPUT_LINESMG$RING_BELLSMG$SAVE_PHYSICAL_SCREEN
SMG$SCROLL_DISPLAY_AREASMG$SET_BROADCAST_TRAPPING
SMG$SET_CURSOR_ABSSMG$SET_CURSOR_MODESMG$SET_CURSOR_REL
SMG$SET_DEFAULT_STATESMG$SET_DISPLAY_SCROLL_REGION
SMG$SET_KEYPAD_MODESMG$SET_OUT_OF_BAND_ASTSSMG$SET_PHYSICAL_CURSOR
SMG$SNAPSHOTSMG$UNPASTE_VIRTUAL_DISPLAY
SMG$ADD_KEY_DEF
SMG$ADD_KEY_DEF adds a keypad key definition to a table of key
definitions.
Format:
SMG$ADD_KEY_DEF key-table-id ,key-name [,if-state] [,attributes]
[,equiv-string] [,state-string]
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifies the key table to which you are adding a key definition.
The key-table-id argument is the address of an unsigned longword
that contains the key table identifier.
key-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Identifies the key whose value you are defining. The key-name
argument is the address of a descriptor pointing to this key name.
The SMG$ADD_KEY_DEF procedure changes the string to uppercase and
removes trailing blanks.
if-state
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Qualifies the value returned when key-name is struck. The if-state
argument is the address of a descriptor pointing to the state
string.
attributes
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Longword bit mask specifying additional attributes of this key
definition. The attributes argument is the address of an unsigned
longword that contains this attribute mask. If omitted, the mask is
zero.
equiv-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Character string to be substituted for the keystroke in the returned
line. The equiv-string argument is the address of a descriptor
pointing to this equivalence string.
state-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Contains a new state name which becomes the current state when this
key is pressed. The state-string argument is the address of a
descriptor pointing to the new state string.
SMG$BEGIN_DISPLAY_UPDATE
SMG$BEGIN_DISPLAY_UPDATE saves, or batches, all output to a virtual
display until a matching call to SMG$END_DISPLAY_UPDATE is
encountered.
Format:
SMG$BEGIN_DISPLAY_UPDATE display-id
Argument
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display for which output is to be batched.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
SMG$BEGIN_PASTEBOARD_UPDATE
SMG$BEGIN_PASTEBOARD_UPDATE saves, or batches, all output to a
pasteboard until a matching call to SMG$END_PASTEBOARD_UPDATE is
encountered.
Format:
SMG$BEGIN_PASTEBOARD_UPDATE pasteboard-id
Argument
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard for which output is to be batched. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier. Pasteboard-id is returned by
SMG$CREATE_PASTEBOARD.
SMG$CANCEL_INPUT
SMG$CANCEL_INPUT immediately cancels any read-in-progress that was
issued by SMG$READ_COMPOSED_LINE, SMG$READ_KEYSTROKE,
SMG$READ_STRING or SMG$READ_VERIFY.
Format:
SMG$CANCEL_INPUT keyboard-id
Argument
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual keyboard for which the input is to be
cancelled. The keyboard-id argument is the address of an unsigned
longword that contains the keyboard identifier. Keyboard-id is
returned by SMG$CREATE_VIRTUAL_KEYBOARD.
SMG$CHANGE_PBD_CHARACTERISTICS
SMG$CHANGE_PBD_CHARACTERISTICS lets you change the width, height,
and background color associated with a pasteboard.
Format:
SMG$CHANGE_PBD_CHARACTERISTICS pasteboard-id [,desired-width]
[,resulting-width] [,desired-height]
[,resulting-height] [,desired-background-color]
[,resulting-background-color]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard whose characteristics are to be changed.
The pasteboard-id argument is the address of an unsigned longword
that contains the pasteboard identifier.
desired-width
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
New width for the pasteboard. The desired-width argument is the
address of a signed longword integer that contains the desired
width. If omitted, the width does not change.
resulting-width
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Physical width of the pasteboard. The resulting-width argument is
the address of a signed longword integer into which is written the
actual width of the pasteboard.
desired-height
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
New height for the pasteboard. The desired-height argument is the
address of a signed longword integer that contains the desired
height of the pasteboard. If omitted, the height does not change.
resulting-height
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Physical height of the pasteboard. The resulting-height argument is
the address of a signed longword integer into which is written the
actual height of the pasteboard.
desired-background-color
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Symbolic name for the desired color. The desired-background-color
argument is the address of an unsigned longword that contains the
desired color.
resulting-background-color
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the actual color chosen. The resulting-background-color
argument is the address of an unsigned longword into which is
written the actual background color. If the terminal does not
support the specified color, the nearest approximation is chosen.
SMG$CHANGE_RENDITION
SMG$CHANGE_RENDITION changes the video attributes for all or part of
a virtual display.
Format:
SMG$CHANGE_RENDITION display-id ,start-row ,start-col
,rows ,columns [,rendition-set]
[,rendition-complement]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display whose default rendition is to be
changed. The display-id argument is the address of an unsigned
longword that contains the display identifier.
start-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Starting row position to receive the new rendition. The start-row
argument is the address of a signed longword integer that contains
the number of the starting row.
start-col
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Starting column position to receive the new rendition. The
start-col argument is the address of a signed longword integer that
contains the number of the starting column.
rows
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of rows to receive the new rendition. The rows argument is
the address of a signed longword integer that contains the number of
rows to be affected.
columns
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of columns to receive the new rendition. The columns
argument is the address of a signed longword integer that contains
the number of columns to be affected.
rendition-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the specified portion of the
virtual display. The rendition-set argument is the address of an
unsigned longword whose bits control the video rendition. Each bit
in this argument affects the corresponding attribute in the display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the specified portion of the
virtual display. The rendition-complement argument is the address
of an unsigned longword whose bits control the video rendition.
SMG$CHANGE_VIRTUAL_DISPLAY
SMG$CHANGE_VIRTUAL_DISPLAY lets you change the dimensions, border,
and video attributes of a virtual display.
Format:
SMG$CHANGE_VIRTUAL_DISPLAY display-id ,rows ,columns
[,display-attributes] [,video-attributes] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display whose attributes are to be changed.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
rows
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the new number of rows for the virtual display. The rows
argument is the address of a signed longword integer that contains
the number of rows in the virtual display.
columns
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the new number of columns for the virtual display. The
columns argument is the address of a signed longword integer that
contains the number of columns in the virtual display.
display-attributes
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies whether the virtual display is bordered (the default).
The display-attributes argument is the address of an unsigned
longword that contains the display attributes mask.
video-attributes
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default rendition to be applied to all output in a
virtual display, unless overridden by a call to a specific output
routine. The video-attributes argument is the address of an
unsigned longword that contains the video attributes mask.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set specifier. At this time,
the only valid value is SMG$C_ASCII, which is also the default.
SMG$CHECK_FOR_OCCLUSION
SMG$CHECK_FOR_OCCLUSION checks to see whether a virtual display is
covered by another virtual display.
Format:
SMG$CHECK_FOR_OCCLUSION display-id ,pasteboard-id
,occlusion-state
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be checked. The display-id
argument is the address of an unsigned longword that contains the
display identifier. Display-id is returned by
SMG$CREATE_VIRTUAL_DISPLAY.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard to be checked. The pasteboard-id argument
is the address of an unsigned longword that contains the pasteboard
identifier. Pasteboard-id is returned by SMG$CREATE_PASTEBOARD.
occlusion-state
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the value denoting whether the display is occluded. The
occlusion-state argument is the address of a signed longword integer
into which the occlusion state is written. Occlusion-state is set
to 1 if the display is occluded or set to 0 if the display is not
occluded on the specified pasteboard. If the procedure does not
return SS$_NORMAL, the contents of occlusion-state are undefined.
SMG$CONTROL_MODE
SMG$CONTROL_MODE controls the mode of the pasteboard. This includes
buffering, minimal updating, whether the screen is cleared when the
pasteboard is deleted, and whether tab characters are used for
screen formatting.
Format:
SMG$CONTROL_MODE pasteboard-id [,new-mode] [,old-mode]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard to be changed. The pasteboard-id argument
is the address of an unsigned longword that contains the pasteboard
identifier. Pasteboard-id is returned by SMG$CREATE_PASTEBOARD.
new-mode
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the new control settings to be used. The new-mode
argument is the address of an unsigned longword that contains the
mode settings. A bit set to 1 forces that mode to be employed while
a bit set to 0 inhibits that mode of operation.
old-mode
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the control settings that were in effect prior to calling
this procedure. The old-mode argument is the address of an unsigned
longword into which is written the former mode settings. A bit set
to 1 indicates that the specified mode was employed while a bit set
to 0 indicates that the mode was inhibited.
SMG$COPY_VIRTUAL_DISPLAY
SMG$COPY_VIRTUAL_DISPLAY creates a copy of an existing virtual
display and assigns to it a new virtual display number.
Format:
SMG$COPY_VIRTUAL_DISPLAY curr-display-id ,new-display-id
Arguments:
curr-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Display identifier of the virtual display to be replicated. The
curr-display-id argument is the address of the unsigned longword
that contains the display identifier.
new-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the display identifier of the newly created virtual
display. The new-display-id argument is the address of the unsigned
longword that receives the new display identifier.
SMG$CREATE_KEY_TABLE
SMG$CREATE_KEY_TABLE creates a table for key definitions.
Format:
SMG$CREATE_KEY_TABLE new-key-table-id
Argument
new-key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the identifier of the newly-created key table. The
new-key-table-id argument is the address of an unsigned longword
into which is written the key table identifier.
SMG$CREATE_PASTEBOARD
SMG$CREATE_PASTEBOARD creates a pasteboard and returns its assigned
pasteboard-id.
Format:
SMG$CREATE_PASTEBOARD new-pasteboard-id [,output-device]
[,pb-rows] [,pb-columns] [,preserve-screen-flag]
Arguments:
new-pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the identifier of the newly created pasteboard. The
new-pasteboard-id argument is the address of an unsigned longword
into which is written the new pasteboard identifier.
output-device
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Specifies the file specification or logical name to which the output
associated with this pasteboard will be written. The output-device
argument is the address of a descriptor that points to the name of
the output device. If omitted, output is sent to SYS$OUTPUT.
pb-rows
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the number of rows on the device specified in the
output-device argument. The pb-rows argument is the address of a
signed longword integer into which is written the number of rows on
the specified device.
pb-columns
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the number of columns on the device specified in the
output-device argument. The pb-columns argument is the address of a
signed longword integer into which is written the number of columns
on the specified device.
preserve-screen-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies whether the screen is cleared before the Screen Management
Facility performs any output to it. The preserve-screen-flag
argument is the address of an unsigned longword that contains the
screen preservation flag. If preserve-screen-flag is set to 0, the
screen is initially cleared; if set to 1, the screen is not
initially cleared. The default action is to clear the screen. The
Screen Management Facility works best when it can manage the entire
screen. Therefore, setting this flag to 1 is discouraged.
SMG$CREATE_VIRTUAL_DISPLAY
SMG$CREATE_VIRTUAL_DISPLAY creates a virtual display and returns its
assigned display id.
Format:
SMG$CREATE_VIRTUAL_DISPLAY num-rows, num-columns, new-display-id
[,display-attributes] [,video-attributes]
[,char-set]
Arguments:
num-rows
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of rows in the newly created virtual display.
The num-rows argument is the address of a signed longword integer
that contains the desired number of rows.
num-columns
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of columns in the newly created virtual
display. The num-columns argument is the address of a signed
longword integer that contains the desired number of columns.
new-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the display-id of the newly created virtual display. The
display-id argument is the address of an unsigned longword into
which is written the display identifier.
display-attributes
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies whether the virtual display is bordered (the default is no
border). The display-attributes argument is the address of an
unsigned longword that contains the display attributes mask.
video-attributes
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default rendition to be applied to all output in this
virtual display unless overridden by a call to a specific output
routine (for example, SMG$CHANGE_RENDITION). The video-attributes
argument is the address of an unsigned longword that contains the
video attributes mask.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set specifier. At this time,
the only valid value is SMG$C_ASCII, which is also the default.
SMG$CREATE_VIRTUAL_KEYBOARD
SMG$CREATE_VIRTUAL_KEYBOARD creates a virtual keyboard and returns
its assigned keyboard-id.
Format:
SMG$CREATE_VIRTUAL_KEYBOARD new-keyboard-id [,filespec]
[,default-filespec] [,resultant-filespec]
[,recall-size]
Arguments:
new-keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the keyboard identifier of the newly created virtual
keyboard. The new-keyboard-id argument is the address of an
unsigned longword into which is written the keyboard identifier.
filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the file specification or logical name of the file
or terminal to be used for this virtual keyboard. The filespec
argument is the address of a descriptor pointing to the file
specification. If omitted, this defaults to SYS$INPUT.
default-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the default file specification. The
default-filespec argument is the address of a descriptor pointing to
the default file specification. If omitted, the null string is
used.
resultant-filespec
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which the procedure writes the fully expanded file
specification of the file used. The resultant-filespec argument is
the address of a descriptor pointing to the string into which is
written the file specification that was used.
recall-size
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Number of input lines to be saved for later recall. The optional
recall-size argument is the address of an unsigned byte containing
the specified number of lines. A value of zero turns off input line
recall. By default, 20 lines are saved for later recall.
SMG$CURSOR_COLUMN
SMG$CURSOR_COLUMN returns the virtual cursor's current column
position in a specified virtual display.
Format:
SMG$CURSOR_COLUMN display-id
ARGUMENT
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The display for which the column position is returned. The
display-id argument is the address of an unsigned longword that
contains the display identifier.
SMG$CURSOR_ROW
SMG$CURSOR_ROW returns the virtual cursor's current row position in
a specified virtual display.
Format:
SMG$CURSOR_ROW display-id
ARGUMENT
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The display for which the row position is returned. The display-id
argument is the address of an unsigned longword that contains the
display identifier.
SMG$DEFINE_KEY
SMG$DEFINE_KEY performs the DEFINE/KEY command you provide.
Format:
SMG$DEFINE_KEY key-table-id ,command-line
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identification of the key definition table for which the DEFINE/KEY
command is to be performed. The key-table-id argument is the
address of an unsigned longword that contains the key table
identifier.
command-line
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the DEFINE/KEY command to be performed. The
command-line argument is the address of a descriptor pointing to the
command to be performed.
SMG$DEL_TERM_TABLE
SMG$DEL_TERM_TABLE terminates access to TERMTABLE.EXE and frees the
associated virtual address space.
Format:
SMG$DEL_TERM_TABLE
NONE
SMG$DELETE_CHARS
SMG$DELETE_CHARS deletes characters in a virtual display.
Format:
SMG$DELETE_CHARS display-id ,num-chars ,row ,column
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifies the virtual display from which characters are to be
deleted. The display-id argument is the address of an unsigned
longword integer that contains the display identifier.
num-chars
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of characters to be deleted. The num-chars
argument is the address of a signed longword integer that contains
the number of characters to be deleted.
row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row position at which to start the deletion. The row
argument is the address of a signed longword integer that contains
the row number at which to start the deletion.
column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column position at which to start the deletion. The
column argument is the address of a signed longword integer that
contains the column position at which to start the deletion.
SMG$DELETE_KEY_DEF
SMG$DELETE_KEY_DEF deletes a key definition from a specified table
of key definitions.
Format:
SMG$DELETE_KEY_DEF key-table-id ,key-name [,if-state]
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifies the key table from which the key definition is deleted.
The key-table-id argument is the address of an unsigned longword
that contains the key table identifier.
key-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the name of the key whose definition is to be
deleted. The key-name argument is the address of a descriptor
pointing to the key name. Key-name is stripped of trailing blanks
and converted to uppercase before use.
if-state
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing a state name which further qualifies key-name.
The if-state argument is the address of a descriptor pointing to the
state name. If omitted, the null state is used. Thus if a key has
several definitions depending on various values of if-state, this
routine lets you delete only one of those definitions.
SMG$DELETE_LINE
SMG$DELETE_LINE deletes lines from a virtual display.
Format:
SMG$DELETE_LINE display-id ,start-line [,number-lines]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifies the virtual display from which lines are to be deleted.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
start-line
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the first line to be deleted from the virtual display.
The start-line argument is the address of a signed longword integer
that contains the number of the first line to be deleted.
number-lines
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of lines to be deleted. The number-lines
argument is the address of a signed longword integer that contains
the number of lines to be deleted. If omitted, one line is deleted.
SMG$DELETE_PASTEBOARD
SMG$DELETE_PASTEBOARD deletes a pasteboard.
Format:
SMG$DELETE_PASTEBOARD pasteboard-id [,clear-screen-flag]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard to be deleted. The pasteboard-id argument
is the address of an unsigned longword that contains the pasteboard
identifier.
clear-screen-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Determines whether this routine clears the screen after deleting the
specified pasteboard. The clear-screen-flag argument is the address
of an unsigned longword that contains the flag. If
clear-screen-flag is 1, the screen is cleared; if 0, the screen is
not cleared. If this argument is omitted, the default is to clear
the screen.
SMG$DELETE_VIRTUAL_DISPLAY
SMG$DELETE_VIRTUAL_DISPLAY deletes a virtual display.
Format:
SMG$DELETE_VIRTUAL_DISPLAY display-id
Argument
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be deleted. The display-id
argument is the address of an unsigned longword that contains the
display identifier.
SMG$DELETE_VIRTUAL_KEYBOARD
SMG$DELETE_VIRTUAL_KEYBOARD deletes a virtual keyboard.
Format:
SMG$DELETE_VIRTUAL_KEYBOARD keyboard-id
Argument
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual keyboard to be deleted. The keyboard-id
argument is the address of an unsigned longword that contains the
keyboard identifier.
SMG$DISABLE_BROADCAST_TRAPPING
SMG$DISABLE_BROADCAST_TRAPPING disables the trapping of broadcast
messages for the specified terminal.
Format:
SMG$DISABLE_BROADCAST_TRAPPING pasteboard-id
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard for the terminal to be affected. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier. Pasteboard-id is returned by
SMG$CREATE_PASTEBOARD.
SMG$DISABLE_UNSOLICITED_INPUT
SMG$DISABLE_UNSOLICITED_INPUT disables the invocation of AST
routines for unsolicited input.
Format:
SMG$DISABLE_UNSOLICITED_INPUT pasteboard-id
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the keyboard (associated with the specified pasteboard)
for which unsolicited input is being disabled. The pasteboard-id
argument is the address of an unsigned longword that contains the
pasteboard identifier. Pasteboard-id is returned by
SMG$CREATE_PASTEBOARD.
SMG$DRAW_LINE
SMG$DRAW_LINE draws a horizontal or vertical line.
Format:
SMG$DRAW_LINE display-id ,start-row ,start-column ,end-row
,end-column [,rendition-set] [,rendition-complement]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display on which the line is to be drawn. The
display-id argument is the address of an unsigned longword that
contains the display identifier. Display-id is returned by
SMG$CREATE_VIRTUAL_DISPLAY.
start-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row at which to begin drawing the line. The start-row
argument is the address of a signed longword integer that contains
the row number at which to begin drawing the line.
start-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which to begin drawing the line. The
start-column argument is the address of a signed longword integer
that contains the column number at which to begin drawing the line.
end-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row at which the drawn line ends. The end-row
argument is the address of a signed longword integer that contains
the row number at which the drawn line ends.
end-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which the drawn line ends. The end-column
argument is the address of a signed longword integer that contains
the column number at which the drawn line ends.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask which denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask which denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display. Video attributes which can be manipulated in this manner
are the same as those for the rendition-set argument.
SMG$DRAW_RECTANGLE
SMG$DRAW_RECTANGLE draws a rectangle.
Format:
SMG$DRAW_RECTANGLE display-id ,top-left-row ,top-left-column
,bottom-right-row ,bottom-right-column
[,rendition-set] [,rendition-complement]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display on which the rectangle is to be drawn.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
top-left-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row number of the top left-hand corner of the
rectangle. The top-left-row argument is the address of a signed
longword integer that contains the row number of the top left-hand
corner of the rectangle.
top-left-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column number of the top left-hand corner of the
rectangle. The top-left-column argument is the address of a signed
longword integer that contains the column number of the top
left-hand corner of the rectangle.
bottom-right-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row number of the bottom right-hand corner of the
rectangle. The bottom-right-row argument is the address of a signed
longword integer that contains the row number of the bottom
right-hand corner of the rectangle.
bottom-right-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column number of the bottom right-hand corner of the
rectangle. The bottom-right-column argument is the address of a
signed longword integer that contains the column number of the
bottom right-hand corner of the rectangle.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask that denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask that denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display. Video attributes that can be manipulated in this manner
are the same as for the rendition-set argument.
SMG$ENABLE_UNSOLICITED_INPUT
SMG$ENABLE_UNSOLICITED_INPUT detects unsolicited input and calls an
AST routine in response.
Format:
SMG$ENABLE_UNSOLICITED_INPUT pasteboard-id ,AST-routine
[,AST-argument]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard for which unsolicited input is being
enabled. The pasteboard-id argument is the address of an unsigned
longword that contains the pasteboard identifier. Pasteboard-id is
returned by SMG$CREATE_VIRTUAL_PASTEBOARD.
AST-routine
VMS usage: ast_procedure
type: procedure entry mask
access: read only
mechanism: by reference
The address of an AST routine to be called upon receipt of
unsolicited input at the terminal. The AST-routine argument is the
address of the routine's procedure entry mask, that is, the address
of the routine itself.
AST-argument
VMS usage: user_arg
type: longword
access: read only
mechanism: by value
A value to be passed to the AST routine. The AST-argument argument
contains the value to be passed to the AST routine.
SMG$END_DISPLAY_UPDATE
SMG$END_DISPLAY_UPDATE ends update batching for a virtual display.
Format:
SMG$END_DISPLAY_UPDATE display-id
Argument
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be affected. The display-id
argument is the address of a longword that contains the display
identifier.
SMG$END_PASTEBOARD_UPDATE
SMG$END_PASTEBOARD_UPDATE ends update batching for a pasteboard.
Format:
SMG$END_PASTEBOARD_UPDATE pasteboard-id
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard on which the batch count is to be
decremented. The pasteboard-id argument is the address of an
unsigned longword that contains the pasteboard identifier.
Pasteboard-id is returned by SMG$CREATE_PASTEBOARD. If the batch
count reaches 0, all buffered output for the specified pasteboard is
written out.
SMG$ERASE_CHARS
SMG$ERASE_CHARS erases characters in a virtual display by replacing
them with blanks.
Format:
SMG$ERASE_CHARS display-id ,number-of-chars ,row-number
,column-number
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display from which characters will be erased.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
number-of-chars
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of characters to be replaced with blanks. The
number-of-chars argument is the address of a signed longword integer
that contains the number of characters to be replaced with blanks.
row-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row on which the erase operation begins. The
row-number argument is the address of a signed longword integer that
contains the number of the row at which the erasure is to begin.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column on which the erase operation begins. The
column-number argument is the address of a signed longword integer
that contains the number of the column at which the erasure is to
begin.
SMG$ERASE_DISPLAY
SMG$ERASE_DISPLAY erases all or part of a virtual display by
replacing text characters with blanks.
Format:
SMG$ERASE_DISPLAY display-id [,start-row] [,start-column]
[,end-row] [,end-column]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be erased. The display-id argument
is the address of an unsigned longword that contains the display
identifier.
start-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row at which the erase operation begins. The
start-row argument is the address of a signed longword integer that
contains the number of the row at which the erasure begins.
start-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which the erase operation begins. The
start-column argument is the address of a signed longword integer
that contains the number of the column at which the erasure begins.
end-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row at which the erase operation ends, that is, the
last row to be erased. The end-row argument is the address of a
signed longword integer that contains the number of the last row to
be erased.
end-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which the erase operation ends, that is, the
last column to be erased. The end-column argument is the address of
a signed longword integer that contains the number of the last
column to be erased.
SMG$ERASE_LINE
SMG$ERASE_LINE erases all or part of a line in a virtual display.
Format:
SMG$ERASE_LINE display-id [,line-number] [,column-number]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be affected. The display-id
argument is the address of an unsigned longword that contains the
display identifier. Display-id is returned by
SMG$CREATE_VIRTUAL_DISPLAY.
line-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the line at which the erase operation starts. The
line-number argument is the address of a signed longword integer
that contains the number of the row at which the erasure starts. If
omitted, column-number is also ignored and the current cursor
position is used.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which the erase operation starts. The
column-number argument is the address of a signed longword integer
that contains the number of the column at which the erasure starts.
If omitted, row-number is also ignored and the current cursor
position is used.
SMG$ERASE_PASTEBOARD
SMG$ERASE_PASTEBOARD erases a pasteboard; that is, it clears the
screen.
Format:
SMG$ERASE_PASTEBOARD pasteboard-id
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard to be erased. The pasteboard-id argument
is the address of an unsigned longword that contains the pasteboard
identifier. Pasteboard-id is returned by SMG$CREATE_PASTEBOARD.
SMG$FIND_CURSOR_DISPLAY
SMG$FIND_CURSOR_DISPLAY returns the identifier of the most recently
pasted virtual display that contains the physical cursor.
Format:
SMG$FIND_CURSOR_DISPLAY pasteboard-id ,returned-display-id
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard (physical screen) in which the cursor is to
be found. The pasteboard-id argument is the address of a longword
that contains the pasteboard identifier. Pasteboard-id is returned
by SMG$CREATE_PASTEBOARD.
returned-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the identifier of the display in which the cursor was
found. The returned-display-id argument is the address of a
longword into which is written the display identifier.
SMG$FLUSH_BUFFER
SMG$FLUSH_BUFFER flushes all buffered output to the terminal.
Format:
SMG$FLUSH_BUFFER pasteboard-id
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard to be flushed. The pasteboard-id argument
is the address of an unsigned longword that contains the pasteboard
identifier. Pasteboard-id is returned by SMG$CREATE_PASTEBOARD.
SMG$GET_BROADCAST_MESSAGE
SMG$GET_BROADCAST_MESSAGE determines whether a message has been
broadcast to the pasteboard and returns the message.
Format:
SMG$GET_BROADCAST_MESSAGE pasteboard-id [,message]
[,message-length]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the terminal to be checked for the presence of a broadcast
message. The pasteboard-id argument is the address of an unsigned
longword that contains the pasteboard identifier. Pasteboard-id is
returned by SMG$CREATE_PASTEBOARD.
message
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
A string that receives the broadcast message, if such a message is
available. The message argument is the address of a descriptor that
points to the storage into which the message text is written. If
this argument is omitted, the broadcast message is discarded.
message-length
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference
Receives the actual length of the broadcast message. The
message-length argument is the address of a word into which is
written the length of the message.
SMG$GET_CHAR_AT_PHYSICAL_CURSOR
SMG$GET_CHAR_AT_PHYSICAL_CURSOR returns the character at the current
physical cursor position.
Format:
SMG$GET_CHAR_AT_PHYSICAL_CURSOR pasteboard-id ,character
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard on which to retrieve the character. The
pasteboard-id argument is the address of a longword that contains
the pasteboard identifier.
character
VMS usage: byte_unsigned
type: byte (unsigned)
access: write only
mechanism: by reference
Returned character code. The character argument is the address of
an unsigned byte into which is written the character's ASCII code.
SMG$GET_DISPLAY_ATTR
SMG$GET_DISPLAY_ATTR returns attributes associated with a virtual
display.
Format:
SMG$GET_DISPLAY_ATTR display-id [,height] [,width]
[,display-attributes] [,video-attributes] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display for which information is requested.
The display-id argument is the address of an unsigned longword that
contains the display identifier. Display-id is returned by
SMG$CREATE_VIRTUAL_DISPLAY.
height
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the number of rows in the display. The height argument is
the address of a signed longword integer into which the height is
written.
width
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the number of columns in the display. The width argument
is the address of a signed longword integer into which is written
the number of columns in the display.
display-attributes
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the current default display attributes (for example,
SMG$M_BORDER). The display-attributes argument is the address of an
unsigned longword into which the current display attributes are
written.
video-attributes
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the current default video attributes. The video-attributes
argument is the address of an unsigned longword into which the
current video attributes are written.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that specifies the character set. At this time, the only
valid value is SMG$C_ASCII, which is also the default.
SMG$GET_KEY_DEF
SMG$GET_KEY_DEF returns the key definition for a specified key.
Format:
SMG$GET_KEY_DEF key-table-id ,key-name [,if-state] [,attributes]
[,equiv-string] [,state-string]
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the key table from which you are extracting a definition.
The key-table-id argument is the address of an unsigned longword
that contains the key table identifier. Key-table-id is returned by
SMG$CREATE_KEY_TABLE.
key-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Specifies the name of the key associated with the definition. The
key-name argument is the address of a descriptor pointing to the key
name.
if-state
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Specifies the current state name in effect after the key is pressed.
The if-state argument is the address of a descriptor pointing to the
state name.
attributes
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the attributes bit mask for this key definition. The
attributes argument is the address of a longword into which is
written the bit mask describing the key's attributes.
equiv-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Receives the equivalence string for this key definition. The
equiv-string argument is the address of a descriptor pointing to the
storage into which is written the equivalence string.
state-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Receives the new state name, if any, which is set by this key
definition. The state-string argument is the address of a
descriptor pointing to the storage into which is written the new
state string.
SMG$GET_KEYBOARD_ATTRIBUTES
SMG$GET_KEYBOARD_ATTRIBUTES gets information about a virtual
keyboard and leaves it in a user-supplied area: the keyboard
information table (KIT).
Format:
SMG$GET_KEYBOARD_ATTRIBUTES keyboard-id ,p-kit ,p-kit-size
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Keyboard identifier. The keyboard-id argument is the address of an
unsigned longword containing the identification of the virtual
keyboard from which to read. A virtual-keyboard is created by
calling the SMG$CREATE_VIRTUAL_KEYBOARD routine.
p-kit
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the keyboard information table. The p-kit argument is
the address of an unsigned longword that contains a pointer to the
keyboard information table (KIT). The KIT is a byte block whose
size and field references are described in $SMGDEF. It is the
caller's responsibility to allocate the correct size block and to
pass its address to this routine.
p-kit-size
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Size of the keyboard information table. The p-kit-size argument is
the address of an unsigned longword containing the size of the KIT
in bytes.
SMG$GET_NUMERIC_DATA
SMG$GET_NUMERIC_DATA accesses TERMTABLE.EXE and returns the numeric
sequence that causes a terminal to perform a specified operation.
Format:
SMG$GET_NUMERIC_DATA termtable-address ,request-code
,buffer-address
Arguments:
termtable-address
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the address of the TERMTABLE entry for the desired
terminal. The termtable-address argument is the address of an
unsigned longword that contains the address of TERMTABLE
information.
request-code
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Request code which specifies the desired capability. The
request-code argument is a signed longword constant containing this
request code. The request code is of the form SMG$K_code where code
corresponds to a keyword in the terminal capabilities table, for
example, ANSI_CRT.
buffer-address
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the first byte of the longword to which
SMG$GET_NUMERIC_DATA writes the numeric capability data. The
buffer-address argument is an unsigned longword which contains the
address of this buffer.
SMG$GET_PASTING_INFO
Provided that the specified virtual display is currently pasted, the
row and column of the pasting are returned.
Format:
SMG$GET_PASTING_INFO display-id ,pasteboard-id ,pasted-flag
[,pasteboard-row] [,pasteboard-col]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifier of the virtual display to be examined. The display-id
argument is the address of an unsigned longword containing the
identifier of this virtual display.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifier of the pasteboard on which the virtual display is pasted.
The pasteboard-id argument is the address of an unsigned longword
containing the identifier of this pasteboard.
pasted-flag
VMS usage: boolean
type: longword (unsigned)
access: write only
mechanism: by reference
Flag indicating the status of the specified virtual display with
respect to the specified pasteboard. The pasted-flag argument is
the address of an unsigned longword indicating this status.
pasteboard-row
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
Row of the pasteboard that contains row 1 of the specified virtual
display. The optional pasteboard-row argument is the address of a
signed longword containing the row number of the pasteboard row that
contains the first row of the virtual display.
pasteboard-col
VMS usage: longword_signed
type: longword (signed)
access: write only
mechanism: by reference
Column of the pasteboard that contains column 1 of the specified
virtual display. The optional pasteboard-col argument is the
address of a signed longword containing the column number of the
pasteboard column that contains the first column of the virtual
display.
SMG$GET_PASTEBOARD_ATTRIBUTES
SMG$GET_PASTEBOARD_ATTRIBUTES gets pasteboard attributes and stores
them in the pasteboard information table.
Format:
SMG$GET_PASTEBOARD_ATTRIBUTES pasteboard-id ,pb-info-table
,pb-info-table-size
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard for which information is requested. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier.
pb-info-table
VMS usage: vector_byte_unsigned
type: byte (unsigned)
access: write only
mechanism: by reference, array reference
Receives the pasteboard attributes. The pb-info-table argument is
the address of an array of unsigned bytes into which is written the
pasteboard attributes.
pb-info-table-size
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the number of bytes in the pb-info-table. The
pb-info-table-size argument is the address of an unsigned longword
that contains the size (in bytes) of the pb-info-table.
SMG$GET_TERM_DATA
SMG$GET_TERM_DATA accesses TERMTABLE.EXE and returns the character
sequence that causes a terminal to perform a specified operation.
Format:
SMG$GET_TERM_DATA termtable-address ,request-code
,max-buffer-length ,return-length
,buffer-address [,input-argument-vector]
Arguments:
termtable-address
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the address of the TERMTABLE entry for the desired
terminal. The termtable-address argument is the address of an
unsigned longword that contains the address of TERMTABLE
information.
request-code
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Longword constant of the form SMG$K_code, where code is the name of
the desired capability field. The request-code argument is the
address of an unsigned longword that contains the request code.
max-buffer-length
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Maximum length of the buffer into which the requested capability
data is written. The max-buffer-length argument is the address of a
signed longword integer that contains the maximum number of bytes
that can be written into the buffer.
return-length
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the number of bytes actually written into the buffer. The
return-length argument is the address of a signed longword integer
into which is written the number of bytes transferred into the
buffer.
buffer-address
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the first byte of the buffer which is to receive the
capability data. The buffer-address argument is an unsigned
longword that contains the address of the buffer.
input-argument-vector
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference, array reference
Address of a list of longwords used for capabilities that require a
variable number of arguments, and for those that require
substitution or arithmetic operations on an argument. The
input-argument-vector argument is the address of an array of
unsigned longwords that contains capability arguments. The first
longword must contain the number of arguments that follow.
SMG$HOME_CURSOR
SMG$HOME_CURSOR moves the virtual cursor to the specified corner of
a virtual display.
Format:
SMG$HOME_CURSOR display-id [,position]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display in which the virtual cursor is moved.
The display-id argument is the address of a longword that contains
the display identifier. Display-id is returned by
SMG$CREATE_VIRTUAL_DISPLAY.
position
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the point to which the virtual cursor moves. The position
argument is the address of a longword that contains the position
code.
SMG$INIT_TERM_TABLE
SMG$INIT_TERM_TABLE initializes the TERMTABLE database for the
terminal named, so that subsequent calls to SMG$GET_TERM_DATA can
extract information and command strings for that terminal.
Format:
SMG$INIT_TERM_TABLE terminal-name, term-entry-address
Arguments:
terminal-name
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Specifies the name of the terminal. The terminal-name argument is
the address of a descriptor pointing to the terminal name. The name
must be an entry in TERMTABLE.EXE
term-entry-address
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the entry for a particular type of terminal in
TERMTABLE.EXE. The term-entry-address argument is the address of an
unsigned longword that contains the address of TERMTABLE
information.
SMG$INIT_TERM_TABLE_BY_TYPE
SMG$INIT_TERM_TABLE_BY_TYPE initializes the TERMTABLE database for
the terminal named, so that subsequent calls to SMG$GET_TERM_DATA
can extract information and command strings for that terminal.
Format:
SMG$INIT_TERM_TABLE_BY_TYPE terminal-type ,term-entry-address
[,terminal-name]
Arguments:
terminal-type
VMS usage: byte_signed
type: byte integer (signed)
access: read only
mechanism: by reference
The device type of the terminal, as designated by a VMS symbolic
terminal type or by another value returned by the $GETDVI system
service. The terminal-type argument is the address of a signed byte
integer that contains the terminal type.
term-entry-address
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of the entry for a particular type of terminal in
TERMTABLE.EXE. The term-entry-address argument is the address of an
unsigned longword into which is written the address of a terminal
entry.
terminal-name
VMS usage: device_name
type: character string
access: write only
mechanism: by descriptor
A string into which is written the terminal name associated with the
device type. The terminal-name argument is the address of a
descriptor pointing to the storage into which the terminal name is
written.
SMG$INSERT_CHARS
SMG$INSERT_CHARS inserts characters into a virtual display.
Format:
SMG$INSERT_CHARS display-id ,string ,row ,column
[,rendition-set] [,rendition-complement]
[,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The pasteboard-id argument
is the address of an unsigned longword that contains the pasteboard
identifier. Display-id is returned by SMG$CREATE_VIRTUAL_DISPLAY.
string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
The character string to be inserted. The string argument is the
address of a descriptor that points to the string to be inserted.
row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
The row position at which to begin the insertion. The row argument
is the address of a signed longword integer that contains the row
number.
column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
The column position at which to begin the insertion. The column
argument is the address of a signed longword integer that contains
the column number.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask which denotes video attributes for the characters inserted.
The rendition-set argument is the address of an unsigned longword
that contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask which denotes video attributes for the characters inserted.
The rendition-complement argument is the address of an unsigned
longword that contains a video attributes mask. Each bit attribute
in this argument causes the corresponding attribute to be set in the
display. Video attributes which can be manipulated in this manner
are the same as those for the rendition-set argument.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$INSERT_LINE
SMG$INSERT_LINE inserts a line into a virtual display and scrolls
the display.
Format:
SMG$INSERT_LINE display-id ,line-number [,string] [,direction]
[,rendition-set] [,rendition-complement]
[,wrap-flag] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
line-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the line number at which the string is inserted and at
which point scrolling begins. The line-number argument is the
address of a signed longword integer that contains the line number.
string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
The character string to be inserted by SMG$INSERT_LINE. The string
argument is the address of a descriptor pointing to this string.
direction
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the scrolling direction. The direction argument is the
address of a longword that contains the direction code. Valid
values are SMG$M_UP and SMG$M_DOWN. SMG$M_UP is the default.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask that denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask that denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask.
wrap-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the action to take if the text does not fit on the line.
The wrap-flag argument is the address of an unsigned longword that
contains the flag. Zero specifies no wrap (the default) while 1
specifies wrap.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of a longword that
contains the character set code. At this time, the only valid value
is SMG$C_ASCII, which is also the default.
SMG$INVALIDATE_DISPLAY
SMG$INVALIDATE_DISPLAY marks a display as invalid and causes the
entire display to be redrawn.
Format:
SMG$INVALIDATE_DISPLAY display-id
Argument
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
SMG$LABEL_BORDER
SMG$LABEL_BORDER supplies a label for a virtual display's border.
Format:
SMG$LABEL_BORDER display-id [,label-text] [,position] [,units]
[,rendition_set] [,rendition-complement]
[,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
label-text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
The new label for this display's border. The label-text argument is
the address of a descriptor pointing to the label text. If omitted,
the display becomes unlabeled.
position
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies which of the display's borders contains the label. The
position argument is the address of an unsigned longword that
contains the position code.
units
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the character position at which the label begins within
the border. The units argument is the address of a signed longword
integer that contains the character position. If omitted, the label
is centered in the specified border.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask which denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display. Video attributes which can be manipulated in this manner
are the same as those for the rendition-set argument.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$LIST_KEY_DEFS
SMG$LIST_KEY_DEFS returns the definition (equivalence string)
associated with a specified key in a specified key table.
Format:
SMG$LIST_KEY_DEFS key-table-id ,context [,key-name] [,if-state]
[,attributes] [,equiv-string] [,state-string]
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read-only
mechanism: by reference
Specifies the key table from which you are extracting a key
definition. The key-table-id argument is the address of an unsigned
longword that contains the key table identifier.
context
VMS usage: context
type: longword integer (signed)
access: modify
mechanism: by reference
Provides a means to extract a series of key definitions from a key
table. The context argument is the address of a signed longword
integer that contains the context variable. For the first call to
this routine, you should set the context argument to zero.
key-name
VMS usage: char_string
type: character string
access: modify
mechanism: by descriptor
Identifies the key whose value you are listing. The key-name
argument is the address of a descriptor pointing to the key name.
if-state
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Receives the state name which qualifies the next definition in the
key table. The if-state argument is the address of a descriptor
pointing to the storage into which the state name is written.
attributes
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Attributes of this key definition. The attributes argument is the
address of an unsigned longword into which is written the key
attributes.
equiv-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
The character string into which is written the equivalence string
for the next key definition. The equiv-string argument is the
address of a descriptor pointing to the storage into which the
equivalence string is written.
state-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
A string into which is written the new state name, if any, which is
set by the next key definition. The state-string argument is the
address of a descriptor pointing to the storage into which the state
name is written. If this key definition sets a state, the
attributes flag SMG$V_KEY_SETSTATE is set.
SMG$LOAD_KEY_DEFS
SMG$LOAD_KEY_DEFS loads a file of key definitions (DEFINE/KEY
commands) into a specified key table.
Format:
SMG$LOAD_KEY_DEFS key-table-id ,filespec [,default-filespec]
[,lognam-flag]
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the key table into which you are loading key definitions.
The key-table-id argument is the address of an unsigned longword
that contains the key table identifier.
filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the file specification for the file of DEFINE/KEY
commands. The filespec argument is the address of a descriptor
pointing to the file specification.
default-filespec
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing the default file specification for the file of
DEFINE/KEY commands. The default-filespec argument is the address
of a descriptor pointing to the default file specification. If
omitted, the null string is used.
lognam-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies whether filespec is to be treated as a logical name. The
lognam-flag argument is the address of an unsigned longword that
contains the flag. If set, lognam-flag specifies that filespec
should be translated, but if this is not possible, that the null
string be used.
SMG$MOVE_VIRTUAL_DISPLAY
SMG$MOVE_VIRTUAL_DISPLAY relocates a virtual display on a pasteboard
and preserves the pasting order.
Format:
SMG$MOVE_VIRTUAL_DISPLAY display-id ,pasteboard-id
,pasteboard-row ,pasteboard-column
[,top-display-id]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be moved. The display-id argument
is the address of an unsigned longword that contains the display
identifier.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard on which the movement is to take place.
The pasteboard-id argument is the address of an unsigned longword
that contains the pasteboard identifier.
pasteboard-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row of the pasteboard that is to contain row 1 of the
specified virtual display. The pasteboard-row argument is the
address of a signed longword integer that contains the row number.
pasteboard-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column of the pasteboard that is to contain column 1
of the specified virtual display. The pasteboard-column argument is
the address of a signed longword integer that contains the column
number.
top-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifier of the virtual display under which the unpasted
display-id will be pasted. The top-display-id argument is the
address of an unsigned longword containing the specified virtual
display identifier. Note that the use of the top-display-id
argument is only valid when the virtual display specified by
display-id is not currently pasted and the virtual display specified
by top-display-id is pasted.
SMG$PASTE_VIRTUAL_DISPLAY
SMG$PASTE_VIRTUAL_DISPLAY pastes a virtual display to a pasteboard.
Format:
SMG$PASTE_VIRTUAL_DISPLAY display-id ,pasteboard-id
,pasteboard-row ,pasteboard-column
[,top-display-id]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be pasted. The display-id argument
is the address of an unsigned longword that contains the display
identifier.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard to which the display is to be pasted. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier.
pasteboard-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row of the pasteboard that is to contain row 1 of the
specified virtual display. The pasteboard-row argument is the
address of a signed longword integer that contains the row number.
pasteboard-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column of the pasteboard that is to contain column 1
of the specified virtual display. The pasteboard-column argument is
the address of a signed longword integer that contains the column
number.
top-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Identifier of the virtual display under which to paste display-id.
The optional top-display-id argument is the address of an unsigned
longword containing this identifier. Note that the virtual display
specified by top-display-id must already be pasted.
SMG$POP_VIRTUAL_DISPLAY
SMG$POP_VIRTUAL_DISPLAY deletes a specified virtual display and all
displays that were pasted on the specified pasteboard after the
specified virtual display.
Format:
SMG$POP_VIRTUAL_DISPLAY display-id ,pasteboard-id
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the lowest (first) virtual display to be deleted. The
display-id argument is the address of an unsigned longword that
contains the display identifier. All displays that are higher in
the pasting order (that is, all displays that were pasted after the
specified display) are deleted as well.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard on which the display deletions take place.
The pasteboard-id argument is the address of an unsigned longword
that contains the pasteboard identifier.
SMG$PUT_CHARS
SMG$PUT_CHARS overwrites characters in a virtual display with the
text you specify.
Format:
SMG$PUT_CHARS display-id ,text [,line-number] [,column-number]
[,erase-flag] [,rendition-set]
[,rendition-complement] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Characters to be written to the virtual display. The text argument
is the address of a descriptor pointing to the character string.
line-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the line at which output begins. If line-number is
omitted, output begins on the current line. The line-number
argument is the address of a signed longword integer that contains
the line number.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which output begins. If column-number is
omitted, output begins on the current column. The column-number
argument is the address of a signed longword integer that contains
the column number.
erase-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies whether to erase the line before writing the specified
text. The erase-flag argument is the address of an unsigned
longword that contains the flag. If set, the line will be erased.
The default is not to erase.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$PUT_CHARS_HIGHWIDE
SMG$PUT_CHARS_HIGHWIDE writes double-height, double-width characters
to a virtual display.
Format:
SMG$PUT_CHARS_HIGHWIDE display-id ,text [,line-number]
[,column-number] [,rendition-set]
[,rendition-complement] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Characters to be written to the virtual display. The text argument
is the address of a descriptor pointing to the text.
line-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the line at which output begins. The line-number argument
is the address of a signed longword integer that contains the line
number. If line-number is omitted or if it is equal to zero, output
begins on the current line.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which output begins. The column-number
argument is the address of a signed longword integer that contains
the column number. If column-number is omitted or if it is equal to
zero, output begins on the current column.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$PUT_CHARS_WIDE
SMG$PUT_CHARS_WIDE writes double-width characters to a virtual
display.
Format:
SMG$PUT_CHARS_WIDE display-id ,text [,line-number]
[,column-number] [,rendition-set]
[,rendition-complement] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Characters to be written to the virtual display. The text argument
is the address of a descriptor pointing to the text.
line-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the line at which output begins. If line-number is
omitted, output begins on the current line. The line-number
argument is the address of a signed longword integer that contains
the line number.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which output begins. If column-number is
omitted, output begins on the current column. The column-number
argument is the address of a signed longword integer that contains
the column number.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask which denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display. Video attributes which can be manipulated in this manner
are the same as those for the rendition-set argument.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$PUT_LINE
SMG$PUT_LINE writes a line of text to a virtual display.
Format:
SMG$PUT_LINE display-id ,text [,line-advance] [,rendition-set]
[,rendition-complement] [,wrap-flag] [,char-set]
[,direction]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
The characters to be written to the virtual display. The text
argument is the address of a descriptor pointing to the text.
line-advance
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of lines to advance after output. The
line-advance argument is the address of a signed longword integer
that contains the number of lines to advance. The default is 1.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask that denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A mask that denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display. Video attributes that can be manipulated in this manner
are the same as those for the rendition-set argument.
wrap-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the action to take if the text does not fit on the line.
The wrap-flag argument is the address of an unsigned longword that
contains the flag. Zero specifies no wrap (the default) while 1
specifies wrap.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
direction
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the direction to scroll, if scrolling is necessary. The
direction argument is the address of an unsigned longword that
contains the direction code. Valid values are SMG$M_UP and
SMG$M_DOWN. SMG$M_UP is the default.
SMG$PUT_LINE_HIGHWIDE
SMG$PUT_LINE_HIGHWIDE writes lines with double high and double wide
characters.
Format:
SMG$PUT_LINE_HIGHWIDE display-id ,text [,line-adv]
[,rendition-set] [,rendition-complement]
[,wrap-flag] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Display identifier. The display-id argument is the address of an
unsigned longword that contains the display identifier of the
virtual display.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Text output. The text argument is the address of the descriptor
pointing to the output string.
line-adv
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Lines to advance. The line-adv argument is the address of a signed
longword that contains the number of lines to advance after the
output. This argument is optional.
rendition-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Set rendition. The rendition-set argument is the address of an
unsigned longword that contains attribute information. Each 1-bit
attribute in this argument causes the corresponding attribute to be
set in the display.
rendition-complement
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Complement rendition. The rendition-complement argument is the
address of an unsigned longword that contains attribute information.
Each 1-bit attribute in this argument causes the corresponding
attribute to be complemented in the display .
wrap-flag
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
The value used to determine if wrapping is enabled or not. The
wrap-flag argument is an unsigned longword that contains this value.
A 0 means no wrap; a 1 means wrap enabled. If the value is omitted,
no wrap is the default.
char-set
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character-set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$PUT_LINE_WIDE
SMG$PUT_LINE_WIDE writes a line of double-width text to a virtual
display.
Format:
SMG$PUT_LINE_WIDE display-id ,text [,line-advance]
[,rendition-set] [,rendition-complement]
[,wrap-flag] [,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of an unsigned longword that contains the display
identifier.
text
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Characters to be written to the virtual display. The text argument
is the address of a descriptor pointing to the text.
line-advance
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of lines to advance after output. The
line-advance argument is the address of a signed longword integer
that contains the number of lines to advance.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask that denotes video attributes for the drawn line. The
rendition-set argument is the address of an unsigned longword that
contains a video attributes mask. Each bit attribute in this
argument causes the corresponding attribute to be set in the
display.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Mask that denotes video attributes for the line drawn. The
rendition-complement argument is the address of an unsigned longword
that contains a video attributes mask.
wrap-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the action to take if the text does not fit on the line.
The wrap-flag argument is the address of an unsigned longword that
contains the flag. 0 specifies no wrap (the default) while 1
specifies wrap.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$PUT_PASTEBOARD
SMG$PUT_PASTEBOARD accesses the contents of a pasteboard.
Format:
SMG$PUT_PASTEBOARD pasteboard-id ,p-rtn ,p-prm ,p-ff-flag
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Pasteboard identifier. The pasteboard-id argument is the address of
an unsigned longword containing the pasteboard identifier.
p-rtn
VMS usage: longword_unsigned
type: procedure entry mask
access: read only
mechanism: by reference
Pasteboard routine. The p-rtn argument is the address of the
routine to be called.
p-prm
VMS usage: user_arg
type: longword integer (signed)
access: read only
mechanism: by reference
Pasteboard argument. The p-prm argument is a user-specified
argument to be passed to the action routine. If omitted, a 0 will
be passed as the user argument.
p-ff-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
A flag (0 or 1). If 1, then the first line passed to the action
routine will be a form feed. If not specified, then no form-feed
line will be sent.
SMG$PUT_VIRTUAL_DISPLAY_ENCODED
SMG$PUT_VIRTUAL_DISPLAY_ENCODED lets you write a string that has
multiple video renditions to a virtual display.
Format:
SMG$PUT_VIRTUAL_DISPLAY_ENCODED display-id ,encoded-length
,encoded-text [,line-number]
[,column-number] [,placeholder-arg]
[,char-set]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display affected. The display-id argument is
the address of a signed longword integer that contains the display
identifier.
encoded-length
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Length of the encoded string. The encoded-length argument is the
address of an unsigned longword that contains the length of the
encoded string.
encoded-text
VMS usage: address
type: unspecified
access: read only
mechanism: by reference
A data structure or record passed by reference. The encoded-text
argument is the address of the data.
line-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the line at which output begins. The line-number argument
is the address of a signed longword integer that contains the line
number. If line-number is omitted or if it is equal to zero, output
begins on the current line.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column at which output begins. The column-number
argument is the address of a signed longword integer that contains
the column number. If column-number is omitted or if it is equal to
zero, output begins on the current column.
placeholder-arg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Reserved placeholder. The placeholder-arg argument is a reserved
placeholder.
char-set
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the default character set for all text in this virtual
display. The char-set argument is the address of an unsigned
longword that contains the character set code. At this time, the
only valid value is SMG$C_ASCII, which is also the default.
SMG$READ_COMPOSED_LINE
SMG$READ_COMPOSED_LINE reads a line of input composed of normal
keystrokes and equivalence strings.
Format:
SMG$READ_COMPOSED_LINE keyboard-id ,key-table-id ,received-text
[,prompt-string] [,received-string-length]
[,display-id] [,function-keys-flag]
[,ini-string] [,timeout] [,rendition-set]
[,rendition-complement] [,terminator-code]
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual keyboard from which input is to be read. The
keyboard-id argument is the address of an unsigned longword that
contains the keyboard identifier.
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the key table to be used for translating keystrokes. The
key-table-id argument is the address of an unsigned longword that
contains the key table identifier.
received-text
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which SMG$READ_COMPOSED_LINE writes the complete
composed line. The received-text argument is the address of a
descriptor pointing to the storage in which the composed line is
written.
prompt-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String used to prompt for the read operation. The prompt-string
argument is the address of a descriptor pointing to the prompt
string.
received-string-length
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Receives the number of characters read or the maximum length of
received-text, whichever is less. The received-string-length
argument is the address of an unsigned longword into which
SMG$READ_COMPOSED_LINE writes the number of characters read.
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Display identifier. The display-id argument is the address of an
unsigned longword that contains the display identifier. This
argument is optional only if you are not using the Screen Management
Facility's output routines.
function-keys-flag
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Function keys. The function-keys-flag argument is the address of an
unsigned longword. If function-keys-flag equals 1, then the
function keys can be used and line editing is disabled. If
function-keys-flag equals zero, line editing is enabled and the
function keys cannot be used.
ini-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Optional string that contains the initial characters of the field.
The ini-string argument is the address of a descriptor pointing to
the string.
timeout
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Optional timeout count. The timeout argument is the address of a
signed longword containing the timeout count. If the timeout
argument is specified, all characters entered before the timeout are
returned in the buffer. If the timeout argument is omitted,
characters are returned in the buffer until a terminator is
encountered.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Optional attribute specifier. The rendition-set argument is the
address of a longword bit mask in which each 1-bit attribute causes
the corresponding attribute to be set in the display. The following
attributes can be specified by the rendition-set argument:
SMG$M_BLINK Displays characters blinking.
SMG$M_BOLD Displays characters in higher-than-normal
intensity (bolded).
SMG$M_REVERSE Displays characters in reverse video ---
that is, using the opposite default
rendition of the virtual display.
SMG$M_UNDERLINE Displays characters underlined.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Optional attribute complement specifier. The rendition-complement
argument is the address of a longword bit mask rendition-set in
which each 1-bit attribute causes the corresponding attribute to be
complemented in the display. All of the attributes that can be
specified with the rendition-set argument can be complemented with
the rendition-complement argument. The display-id argument must be
specified when the rendition-complement argument is used.
terminator-code
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Key terminator code. The terminator-code argument is an unsigned
word into which is written a code indicating what character or key
terminated the read. Key terminator codes are of the form
SMG$K_TRM_keyname.
SMG$READ_FROM_DISPLAY
SMG$READ_FROM_DISPLAY reads a line of text from a virtual display.
Format:
SMG$READ_FROM_DISPLAY display-id ,returned-string
[,terminator-string][,row]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display from which text is read. The
display-id argument is the address of an unsigned longword that
contains the display identifier.
returned-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which SMG$READ_FROM_DISPLAY writes the information read
from the virtual display. The returned-string argument is the
address of a descriptor pointing to the storage into which the
string is written.
terminator-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing a terminator or terminators that end the backward
search, thus determining the starting position of the returned
string. The terminator-string argument is the address of a
descriptor pointing to the string of terminators. If omitted, no
back searching is performed; the returned string starts with the
character at the current cursor position.
row
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
The row argument is the address of a signed longword that contains
the row of the display-id to read from. This is an optional
argument.
SMG$READ_KEYSTROKE
SMG$READ_KEYSTROKE reads a keystroke and returns that keystroke's
terminator code.
Format:
SMG$READ_KEYSTROKE keyboard-id ,terminator-code [,prompt-string]
[,timeout] [,display-id] [,rendition-set]
[,rendition-complement]
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Keyboard identifier. The keyboard-id argument is an unsigned
longword containing the identification of the virtual keyboard from
which to read. A virtual keyboard is created by calling the
SMG$CREATE_VIRTUAL_KEYBOARD routine.
terminator-code
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Key terminator code. The terminator-code argument is an unsigned
word into which is written a code indicating what character or key
terminated the read. Key terminator codes are of the form
SMG$K_TRM_keyname.
prompt-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Prompt string. The prompt-string argument is an optional string
that is used as the prompt for the read operation.
timeout
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Timeout count. The timeout argument is optional. If specified, any
character typed before the timeout is returned in the buffer.
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Display identifier. The optional display-id argument is the address
of an unsigned longword that contains the identifier of the virtual
display in which the read is to be performed. If the optional
prompt-string argument is specified while there are multiple virtual
displays pasted, the display-id argument is required to determine in
which virtual display the prompt string will be written. If the
prompt-string argument is not specified, then do not specify the
display-id argument.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attribute specifier. The optional rendition-set argument is the
address of a longword bit mask in which each 1-bit attribute causes
the corresponding attribute to be set in the display. The following
attributes can be specified by the rendition-set argument:
SMG$M_BLINK Displays characters blinking.
SMG$M_BOLD Displays characters in higher-than-normal
intensity (bolded).
SMG$M_REVERSE Displays characters in reverse video ---
that is, using the opposite default
rendition of the virtual display.
SMG$M_UNDERLINE Displays characters underlined.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attribute complement specifier. The optional rendition-complement
argument is the address of a longword bit mask in which each 1-bit
attribute causes the corresponding attribute to be complemented in
the display. All of the attributes that can be specified with the
rendition-set argument can be complemented with the
rendition-complement argument. The display-id argument must be
specified when using the rendition-complement argument.
SMG$READ_STRING
SMG$READ_STRING reads a string from a virtual keyboard.
Format:
SMG$READ_STRING keyboard-id ,received-text [,prompt-string]
[,max-length] [,modifiers] [,timeout]
[,terminator-set] [,received-string-length]
[,terminator-code] [,display-id] [,ini-string]
[,rendition-set] [,rendition-complement]
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual keyboard from which input is to be read. The
keyboard-id argument is the address of an unsigned longword that
contains the keyboard identifier.
received-text
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which the input line is written. The received-text
argument is the address of a descriptor pointing to the storage into
which the text is written.
prompt-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String used to prompt for the read operation. The prompt argument
is the address of a descriptor pointing to the prompt string.
max-length
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the maximum number of characters to be read. The
max-length argument is the address of a signed longword integer that
contains the maximum number of characters to be read. The maximum
valid value for this argument is 512. If omitted, 512 is the
default.
modifiers
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Bit mask that specifies optional behavior. The modifiers argument
is the address of an unsigned longword that contains the bit mask.
timeout
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of seconds allowed between the time the prompt
is issued and the completion of the input operation. The timeout
argument is the address of a signed longword integer that contains
the number of seconds.
terminator-set
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed length
Either a mask that specifies which characters are to be treated as
terminators (short form) or a descriptor pointing to such a mask
(long form). The terminator-set argument is the address of a
descriptor pointing to the mask.
received-string-length
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Receives the number of characters read or the maximum size of
received-text, whichever is less. The received-string-length
argument is the address of an unsigned word into which is written
the number of characters or the maximum size.
terminator-code
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Key terminator code. The terminator-code argument is an unsigned
word into which is written a code indicating what character or key
terminated the read. Key terminator codes are of the form
SMG$K_TRM_keyname.
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Display identifier. The display-id argument is the address of an
unsigned longword that contains the display identifier.
ini-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Initial character string. The ini-string argument is the address of
a descriptor pointing to the optional string that contains the
initial characters of the field.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attribute specifier. The optional rendition-set argument is the
address of a longword bit mask in which each 1-bit attribute causes
the corresponding attribute to be set in the display. The following
attributes can be specified using the rendition-set argument:
SMG$M_BLINK Displays characters blinking.
SMG$M_BOLD Displays characters in higher-than-normal
intensity (bolded).
SMG$M_REVERSE Displays characters in reverse video ---
that is, using the opposite default
rendition of the virtual display.
SMG$M_UNDERLINE Displays characters underlined.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attribute complement specifier. The optional rendition-complement
argument is the address of a longword bit mask in which each 1-bit
attribute causes the corresponding attribute to be complemented in
the display. All of the attributes that can be specified with the
rendition-set argument can be complemented with
rendition-complement. The display-id argument must be specified
when using the rendition-complement argument.
SMG$READ_VERIFY
SMG$READ_VERIFY reads a sequence of characters and verifies the
sequence.
Format:
SMG$READ_VERIFY keyboard-id ,out-string ,in-string ,pic-string
,fill-char ,clear-char [,prompt-string]
[,modifiers] [,timeout] [,terminator-set]
[,ini-offset] [,terminator-code] [,display-id]
[,alt-echo-string] [,alt-display-id]
[,rendition-set] [,rendition-complement]
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Keyboard identifier. The keyboard-id argument is the address of an
unsigned longword integer containing the identifier of the virtual
keyboard from which to read. The virtual keyboard is created by
calling the SMG$CREATE_VIRTUAL_KEYBOARD routine.
out-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Output string into which SMG$READ_VERIFY writes the characters that
are read. The out-string argument is the address of a descriptor
pointing to this output string.
in-string
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Input string that contains the initial characters of the field. The
in-string argument is the address of a descriptor pointing to the
input string.
pic-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Picture string that contains a picture of what the field is to look
like. The pic-string argument is the address of a descriptor
pointing to the picture string.
fill-char
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Fill character. The fill-char argument is the address of a
descriptor pointing to the string that contains the character to be
used as a fill character in the in-string argument.
clear-char
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Clear character. The clear-char argument is the address of a
descriptor pointing to the string that contains the character to be
displayed for each occurrence of fill-char in in-string.
prompt-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Prompt string. The prompt-string argument is the address of a
descriptor pointing to the string that SMG$READ_VERIFY uses as the
prompt for the read operation. This is an optional argument.
modifiers
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Modifiers. The modifiers argument is a longword bit mask that
specifies optional behavior. The bits defined are the same as for
the $QIO item-list entry TRM$_MODIFIERS. This is an optional
argument.
timeout
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Timeout count. The timeout argument is optional. If specified, all
the characters typed in before the timeout are returned in the
buffer. If omitted, characters are returned in the buffer until a
terminator is seen.
terminator-set
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor, fixed length
Either a mask that specifies which characters are to be treated as
terminators (short form) or a descriptor pointing to such a mask
(long form). The terminator-set argument is the address of a
descriptor pointing to the mask.
ini-offset
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Input string offset. The ini-offset argument is a longword that
contains the number of characters (from the in-string argument) to
output after the prompt before waiting for input.
terminator-code
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Key terminator code. The terminator-code argument is an unsigned
word into which SMG$READ_VERIFY writes a code indicating what
character or key terminated the read. Key terminator codes are of
the form SMG$K_TRM_keyname.
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Display identifier. The optional display-id argument is the address
of an unsigned longword integer that contains the identifier of the
virtual display in which the read is to be performed. If specified,
SMG$READ_VERIFY begins the read at the current virtual cursor
position in that virtual display. If omitted, the read begins in
the current physical cursor position. Note that the length of the
prompt-string plus the input is limited to the number of visible
columns in the display.
alt-echo-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Alternate echo string. The alt-echo-string argument is a string
that is printed after the first character is typed during the read
operation. This is an optional argument.
alt-display-id
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Alternate display identification. The alt-display-id is a signed
longword integer containing the identification of the virtual
display in which the alt-echo-string argument is to be printed.
This is an optional argument. If specified, the output begins at
the current virtual cursor position in that virtual display. If
omitted, the value of the display-id argument is used as the
default. If display-id is not specified, the output begins in the
current physical cursor position.
rendition-set
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attribute specifier. The optional rendition-set argument is the
address of a longword bit mask in which each 1-bit attribute causes
the corresponding attribute to be set in the display. The following
attributes can be specified using the rendition-set argument:
SMG$M_BLINK Displays characters blinking.
SMG$M_BOLD Displays characters in higher-than-normal
intensity (bolded).
SMG$M_REVERSE Displays characters in reverse video ---
that is, using the opposite default
rendition of the virtual display.
SMG$M_UNDERLINE Displays characters underlined.
rendition-complement
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attribute complement specifier. The optional rendition-complement
argument is the address of a longword bit mask in which each 1-bit
attribute causes the corresponding attribute to be complemented in
the display. All of the attributes that can be specified with the
rendition-set argument can be complemented with the
rendition-complement argument. The display-id argument must be
specified when using the rendition-complement argument.
SMG$REPAINT_LINE
SMG$REPAINT_LINE repaints a series of lines on the current screen.
Format:
SMG$REPAINT_LINE pasteboard-id ,row-start [,num-of-lines]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Pasteboard identifier. The pasteboard-id argument is the address of
the pasteboard associated with the physical screen to be repainted.
row-start
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Starting row number. The row-start argument is the address of the
physical row number to start repainting.
num-of-lines
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by reference
Number of contiguous lines to repaint. The num-of-lines argument is
the address of a signed longword containing the number of lines.
This argument is optional. If not specified, the default is 1.
SMG$REPAINT_SCREEN
SMG$REPAINT_SCREEN repaints the current screen after nonSMG I/O has
occurred.
Format:
SMG$REPAINT_SCREEN pasteboard-id
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the terminal screen to be repainted. The pasteboard-id
argument is the address of an unsigned longword that contains the
pasteboard identifier.
SMG$REPASTE_VIRTUAL_DISPLAY
SMG$REPASTE_VIRTUAL_DISPLAY moves a virtual display to a new
position on the pasteboard. The pasting order is not preserved.
Format:
SMG$REPASTE_VIRTUAL_DISPLAY display-id ,pasteboard-id ,pb-row
,pb-column [,top-display-id]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be repasted. The display-id
argument is the address of an unsigned longword that contains the
display identifier.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard on which the display is repasted. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier.
pb-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the pasteboard row that is to contain row 1 of the
specified virtual display. The pb-row argument is the address of a
signed longword integer that contains the pasteboard row.
pb-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the pasteboard column that is to contain column 1 of the
specified virtual display. The pb-column argument is the address of
a signed longword integer that contains the pasteboard column.
top-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Optional identifier of the virtual display under which display-id
will be pasted. The top-display-id argument is the address of an
unsigned longword containing the identifier of this virtual display.
Note that the virtual display specified by top-display-id must
already be pasted.
SMG$REPLACE_INPUT_LINE
SMG$REPLACE_INPUT_LINE replaces the specified lines in the recall
buffer with the specified string.
Format:
SMG$REPLACE_INPUT_LINE keyboard-id [,out-line] [,num-of-lines]
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Keyboard identifier. The keyboard-id argument is the address of an
unsigned longword containing the identifier of the virtual keyboard
from which to read. The virtual keyboard is created by calling the
SMG$CREATE_VIRTUAL_KEYBOARD routine.
out-line
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String that contains the line to be entered into the recall buffer.
The out-line argument is the address of a descriptor pointing to
this string. The default is a null string, which removes the last
line entered.
num-of-lines
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Number of lines to be replaced. The num-of-lines argument is the
address of an unsigned byte containing the number of lines to be
replaced with out-line. The default value for the num-of-lines
argument is 1 (the last line entered).
SMG$RESTORE_PHYSICAL_SCREEN
SMG$RESTORE_PHYSICAL_SCREEN rewrites the screen image as it was at
the time the SMG$SAVE_PHYSICAL_SCREEN routine was called.
Format:
SMG$RESTORE_PHYSICAL_SCREEN pasteboard-id ,saved-display-id
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the physical screen to be restored. The pasteboard-id
argument is the address of an unsigned longword that contains the
pasteboard identifier.
saved-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display created by the
SMG$SAVE_PHYSICAL_SCREEN routine. The saved-display-id argument is
the address of an unsigned longword that contains this display
identifier.
SMG$RETURN_CURSOR_POS
SMG$RETURN_CURSOR_POS returns the current virtual cursor position in
a specified virtual display.
Format:
SMG$RETURN_CURSOR_POS display-id ,row-number ,column-number
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display whose current cursor position you are
requesting. The display-id argument is the address of an unsigned
longword that contains the display identifier. Display-id is
returned by SMG$CREATE_VIRTUAL_DISPLAY.
row-number
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the cursor's current row position within the specified
virtual display. The row-number argument is the address of a
longword into which is written the current row position.
column-number
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Receives the cursor's current column position within the specified
virtual display. The column-number argument is the address of a
longword into which is written the current column position.
SMG$RETURN_INPUT_LINE
SMG$RETURN_INPUT_LINE returns to the caller the requested line from
the recall buffer. This line is retrieved either by matching it
with a specified string or by specifying the appropriate line
number.
Format:
SMG$RETURN_INPUT_LINE keyboard-id ,out-line [,match-string]
[,line-num] [,out-length]
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Keyboard identifier. The keyboard-id argument is the address of an
unsigned longword containing the identifier of the virtual keyboard
from which to read. The virtual keyboard is created by calling the
SMG$CREATE_VIRTUAL_KEYBOARD routine.
out-line
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String into which is written the complete recalled line. The
out-line argument is the address of a descriptor pointing to this
string.
match-string
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Match string to be used when searching for the line to be recalled.
The optional match-string argument is the address of a descriptor
pointing to this match string. The search begins with the last line
typed.
line-num
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
Line number to be used when searching for the line to be recalled.
The optional line-num argument is the address of an unsigned byte
containing the number of the line to be recalled. The last line
typed is line number 1.
out-length
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length of the out-line string. The optional out-length argument is
the address of an unsigned word containing either the number of
characters read or the maximum length of out-line, whichever is
less.
SMG$RING_BELL
SMG$RING_BELL sounds the terminal bell or buzzer.
Format:
SMG$RING_BELL display-id [,number-of-times]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display for which the bell or buzzer sounds.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
number-of-times
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of times the bell or buzzer is sounded. The
number-of-times argument is the address of a signed longword integer
that contains the number of times the bell or buzzer is sounded. If
omitted, 1 is used.
SMG$SAVE_PHYSICAL_SCREEN
SMG$SAVE_PHYSICAL_SCREEN saves the contents of the screen so that a
later call to SMG$RESTORE_PHYSICAL_SCREEN can restore it.
Format:
SMG$SAVE_PHYSICAL_SCREEN pasteboard-id ,saved-display-id
[,desired-row-start] [,desired-row-end]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the physical screen whose contents are to be saved. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier.
saved-display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Receives the display id of the display created to contain the
contents of the physical screen. The saved-display-id argument is
the address of an unsigned longword into which the display
identifier is written.
desired-row-start
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the first row to be saved. The desired-row-start argument
is the address of a signed longword integer that contains the row
number. If omitted, row 1 of the pasteboard is used.
desired-row-end
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the last row to be saved. The desired-row-end argument is
the address of a signed longword integer that contains the row
number. If omitted, the last row of the pasteboard is used.
SMG$SCROLL_DISPLAY_AREA
SMG$SCROLL_DISPLAY_AREA scrolls a rectangular region of a virtual
display.
Format:
SMG$SCROLL_DISPLAY_AREA display-id
[,starting-row ,starting-column]
[,height] [,width] [,direction]
[,count]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display in which scrolling takes place. The
display-id argument is the address of an unsigned longword that
contains the display identifier.
starting-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the first row of the scrolling region. The starting-row
argument is the address of a signed longword integer that contains
the starting row.
starting-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the first column of the scrolling region. The
starting-column argument is the address of a signed longword integer
that contains the starting column.
height
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of rows in the scrolling region. The height
argument is the address of a signed longword integer that contains
the number of rows.
width
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of columns in the scrolling region. The width
argument is the address of a signed longword integer that contains
the number of columns.
direction
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the direction to scroll. The direction argument is the
address of an unsigned longword that contains the direction code.
count
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of lines to scroll. The count argument is the
address of a signed longword integer that contains the number of
lines to scroll. If omitted, one line is scrolled.
SMG$SET_BROADCAST_TRAPPING
SMG$SET_BROADCAST_TRAPPING enables the trapping of broadcast
messages.
Format:
SMG$SET_BROADCAST_TRAPPING pasteboard-id [,AST-routine]
[,AST-argument]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard for the terminal to be affected. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier.
AST-routine
VMS usage: ast_procedure
type: procedure entry mask
access: read only
mechanism: by reference
The address of an AST routine to be called when a message is
received at the terminal. The AST-routine argument is the address
of the routine's procedure entry mask --- that is, the address of
the routine itself.
AST-argument
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
A value to be passed to the AST routine. AST-argument is the value
to be passed to the AST routine.
SMG$SET_CURSOR_ABS
SMG$SET_CURSOR_ABS moves the virtual cursor to the specified
position in a virtual display.
Format:
SMG$SET_CURSOR_ABS display-id [,row] [,column]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display in which to set the virtual cursor
position. The display-id argument is the address of an unsigned
longword that contains the display identifier.
row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the row position to which the virtual cursor moves. The
row argument is the address of a signed longword integer that
contains the row number. If omitted, the cursor remains at the
current row.
column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the column position to which the virtual cursor moves.
The column argument is the address of a signed longword integer that
contains the column number. If omitted, the virtual cursor remains
at the current column.
SMG$SET_CURSOR_MODE
SMG$SET_CURSOR_MODE turns the physical cursor on or off.
Format:
SMG$SET_CURSOR_MODE pasteboard-id ,cursor-mode
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Pasteboard identifier. The pasteboard-id argument is the address of
an unsigned longword that contains the pasteboard identifier.
cursor-mode
VMS usage: boolean
type: longword (unsigned)
access: read only
mechanism: by reference
Longword that determines whether or not the physical cursor is
displayed. The cursor-mode argument is the address of an unsigned
longword that determines the status of the physical cursor: if
cursor-mode is zero, the physical cursor is displayed; if
cursor-mode is set to 1, the physical cursor is invisible.
SMG$SET_CURSOR_REL
SMG$SET_CURSOR_REL moves the virtual cursor the specified number of
rows and columns from the current virtual cursor position in a
virtual display.
Format:
SMG$SET_CURSOR_REL display-id [,delta-row] [,delta-column]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display in which to move the virtual cursor.
The display-id argument is the address of an unsigned longword that
contains the display identifier.
delta-row
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of rows to move the virtual cursor. The
delta-row argument is the address of a signed longword integer that
contains the number of rows to move. If omitted, the virtual cursor
remains at the current row position. If delta-row is positive, the
virtual cursor moves downward the specified number of rows. If
delta-row is negative, the virtual cursor moves upward the specified
number of rows.
delta-column
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the number of columns to move the cursor. The
delta-column argument is the address of a longword that contains the
number of columns to move. If omitted, the virtual cursor remains
at the current column position. If delta-column is positive, the
virtual cursor moves the specified number of columns to the right.
If delta-column is negative, the virtual cursor moves the specified
number of columns to the left.
SMG$SET_DEFAULT_STATE
SMG$SET_DEFAULT_STATE sets and/or returns the current default state
for a key table.
Format:
SMG$SET_DEFAULT_STATE key-table-id [,new-state] [,old-state]
Arguments:
key-table-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the key table in which you are setting or inquiring about
a default state. The key-table-id argument is the address of an
unsigned longword that contains the key table identifier.
new-state
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Specifies the new default state for the entire key table. The
new-state argument is the address of a descriptor pointing to the
new state string. The specified state name is converted to
uppercase and stripped of trailing blanks before use.
old-state
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Receives the existing default state name of the specified key
definition table. The old-state argument is the address of a
descriptor pointing to the storage into which the old state string
is written.
SMG$SET_DISPLAY_SCROLL_REGION
SMG$SET_DISPLAY_SCROLL_REGION creates a scrolling region in a
virtual display.
Format:
SMG$SET_DISPLAY_SCROLL_REGION display-id [,starting-line]
[,ending-line]
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display in which scrolling takes place. The
display-id argument is the address of an unsigned longword that
contains the display identifier.
starting-line
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the first line of the scrolling region. The starting-line
argument is the address of a signed longword integer that contains
the starting line number. If omitted, the first line of the display
is used.
ending-line
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Specifies the last line of the scrolling region. The ending-line
argument is the address of a signed longword integer that contains
the ending line number. If omitted, the last line of the virtual
display is used.
SMG$SET_KEYPAD_MODE
SMG$SET_KEYPAD_MODE sets the terminal's numeric keypad to either
numeric or applications mode.
Format:
SMG$SET_KEYPAD_MODE keyboard-id ,new-mode
Arguments:
keyboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual keyboard whose mode is to be changed. The
keyboard-id argument is the address of an unsigned longword that
contains the keyboard identifier.
new-mode
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies whether the keypad is to be in applications or numeric
mode. The new-mode argument is the address of an unsigned longword
that contains the new mode setting. If the low-order bit is clear,
the keypad is set to numeric mode; if the low-order bit is set, the
keypad is set to applications mode. All other bits must be zero.
SMG$SET_OUT_OF_BAND_ASTS
SMG$SET_OUT_OF_BAND_ASTS either enables or disables the trapping of
out-of-band characters.
Format:
SMG$SET_OUT_OF_BAND_ASTS pasteboard-id ,control-char-mask
,AST-routine [,AST-argument]
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the terminal for which out-of-band characters are enabled
or disabled. The pasteboard-id argument is the address of an
unsigned longword that contains the pasteboard identifier.
Pasteboard-id is returned by SMG$CREATE_PASTEBOARD.
control-char-mask
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies which control characters are to be the new out-of-band
control characters. The control-char-mask argument is the address
of an unsigned longword that contains the mask. You create this
mask by setting the bit that corresponds to the ASCII value of the
desired character. For example, to specify that CTRL/A (ASCII value
1) is an out-of-band control character, you set bit 1 in the
control-char-mask. If no bits are set in this mask, then no
out-of-band ASTs occur.
AST-routine
VMS usage: ast_procedure
type: procedure entry mask
access: read only
mechanism: by reference
The address of an AST routine to be called when an out-of-band
control character is typed at the terminal. The AST-routine
argument is the address of the routine's procedure entry mask ---
that is, the address of the routine itself.
AST-argument
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
The argument you supply for the AST. The AST-argument argument is
an unsigned longword that contains the value to be passed to the AST
routine. However, the AST routine may also need to know the
out-of-band character and the pasteboard-id at which it was typed.
Therefore, the Screen Management Facility creates a 3-longword
structure to hold this information and passes the address of this
structure as the first argument to the AST routine. The remaining
four arguments are R0, R1, PC, and PSL.
SMG$SET_PHYSICAL_CURSOR
SMG$SET_PHYSICAL_CURSOR moves the physical cursor to the specified
position on the physical screen.
Format:
SMG$SET_PHYSICAL_CURSOR pasteboard-id ,pb-row ,pb-column
Arguments:
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the physical screen whose physical cursor is to move. The
pasteboard-id argument is the address of an unsigned longword that
contains the pasteboard identifier.
pb-row
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the row to which the physical cursor moves. The pb-row
argument is the address of an unsigned longword that contains the
row number.
pb-column
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the column to which the physical cursor moves. The
pb-column argument is the address of an unsigned longword that
contains the column number.
SMG$SNAPSHOT
SMG$SNAPSHOT writes the current pasteboard buffer to the file or
hardcopy terminal specified by pasteboard-id.
Format:
SMG$SNAPSHOT pasteboard-id [,ff-flag]
ARGUMENT
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the file or hardcopy terminal to receive the contents of
the pasteboard buffer. The pasteboard-id argument is the address of
an unsigned longword that contains the pasteboard identifier. The
output device assiocated with pasteboard-id is specified by the
output-device argument of SMG$CREATE_PASTEBOARD.
ff-flag
VMS usage: boolean
type: longword (unsigned)
access: read only
mechanism: by reference
Form-feed flag. The ff-flag argument is the address of an unsigned
longword containing a Boolean value. If the value of ff-flag is 1,
then the first record output will be a form feed (<FF>). If the
value of ff-flag is zero, then an initial form-feed record will not
be output.
SMG$UNPASTE_VIRTUAL_DISPLAY
SMG$UNPASTE_VIRTUAL_DISPLAY removes a virtual display from a
pasteboard.
Format:
SMG$UNPASTE_VIRTUAL_DISPLAY display-id ,pasteboard-id
Arguments:
display-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the virtual display to be removed from a pasteboard. The
display-id argument is the address of an unsigned longword that
contains the display identifier.
pasteboard-id
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Specifies the pasteboard (physical screen) from which the virtual
display is removed. The pasteboard-id argument is the address of an
unsigned longword that contains the pasteboard identifier.
STR$
Additional information available:
STR$ADDSTR$ANALYZE_SDESCSTR$APPENDSTR$CASE_BLIND_COMPARE
STR$COMPARESTR$COMPARE_EQLSTR$COMPARE_MULTISTR$CONCAT
STR$COPY_DXSTR$COPY_RSTR$DIVIDESTR$DUPL_CHAR
STR$FIND_FIRST_IN_SETSTR$FIND_FIRST_NOT_IN_SETSTR$FIND_FIRST_SUBSTRING
STR$FREE1_DXSTR$GET1_DXSTR$LEFTSTR$LEN_EXTR
STR$MATCH_WILDSTR$MULSTR$POSITIONSTR$POS_EXTR
STR$PREFIXSTR$RECIPSTR$REPLACESTR$RIGHTSTR$ROUND
STR$TRANSLATESTR$TRIMSTR$UPCASE
STR$ADD
STR$ADD adds two strings of digits.
Format:
STR$ADD asign ,aexp ,adigits ,bsign ,bexp ,bdigits
,csign ,cexp ,cdigits
Arguments:
asign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the first operand. The asign argument is the address of an
unsigned longword containing this sign. Zero is considered
positive; 1 is considered negative.
aexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which adigits has to be multiplied to get the
absolute value of the first operand. The aexp argument is the
address of a signed longword integer containing this exponent.
adigits
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String of unsigned digits representing the absolute value of the
first operand before aexp is applied. The adigits argument is the
address of a descriptor pointing to this string. This string must
be an unsigned decimal number.
bsign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the second operand. The bsign argument is the address of an
unsigned longword containing the second operand's sign. Zero is
considered positive; one is considered negative.
bexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which bdigits has to be multiplied to get the
absolute value of the second operand. The bexp argument is the
address of a signed longword integer containing the second operand's
exponent.
bdigits
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String of unsigned digits representing the absolute value of the
second operand before bexp is applied. The bdigits argument is the
address of a descriptor pointing to this string. This string must
be an unsigned decimal number.
csign
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Sign of the result. The csign argument is the address of a signed
longword integer containing the result's sign. Zero is considered
positive.
cexp
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Power of 10 by which cdigits has to be multiplied to get the
absolute value of the result. The cexp argument is the address of a
signed longword integer containing the result's exponent.
cdigits
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
String of unsigned digits representing the absolute value of the
result before cexp is applied. The cdigits argument is the address
of a descriptor pointing to this string. This string is an unsigned
decimal number.
STR$ANALYZE_SDESC
STR$ANALYZE_SDESC extracts the length and starting address of the
data for a variety of string descriptor classes.
Format:
STR$ANALYZE_SDESC inp-dsc ,len ,data-adr
Arguments:
inp-dsc
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Input descriptor from which STR$ANALYZE_SDESC extracts the length of
the data and the address at which the data starts. The inp-dsc
argument is the address of a descriptor pointing to the input data.
len
VMS usage: word_signed
type: word integer (signed)
access: write only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Length of the data; this length is extracted from the descriptor by
STR$ANALYZE_SDESC. The len argument is the address of a signed word
integer into which STR$ANALYZE_SDESC writes the data length.
data-adr
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Address of the data; this address is extracted from the descriptor
by STR$ANALYZE_SDESC. The data-adr argument is an unsigned longword
into which STR$ANALYZE_SDESC writes the address of the data.
STR$APPEND
STR$APPEND appends a source string to the end of a destination
string. The destination string must be a dynamic or varying string.
Format:
STR$APPEND dst-str ,src-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string to which STR$APPEND appends the source string.
The dst-str argument is the address of a descriptor pointing to the
destination string. This destination string must be dynamic or
varying.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string that STR$APPEND appends to the end of the destination
string. The src-str argument is the address of a descriptor
pointing to this source string.
STR$CASE_BLIND_COMPARE
STR$CASE_BLIND_COMPARE compares two input strings of any supported
class and data type without regard to whether the alphabetic
characters are uppercase or lowercase.
Format:
STR$CASE_BLIND_COMPARE src1-str ,src2-str
Arguments:
src1-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
First string. The src1-str argument is the address of a descriptor
pointing to the first string.
src2-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Second string. The src2-str argument is the address of a descriptor
pointing to the second string.
STR$COMPARE
STR$COMPARE compares the contents of two strings. If the strings
are unequal in length, the shorter string is considered to be filled
with blanks to the length of the longer string before the comparison
is made.
Format:
STR$COMPARE src1-str ,src2-str
Arguments:
src1-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
First string. The src1-str argument is the address of a descriptor
pointing to the first string.
src2-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Second string. The src2-str argument is the address of a descriptor
pointing to the second string.
STR$COMPARE_EQL
STR$COMPARE_EQL compares two strings to see if they have the same
length and contents. Uppercase and lowercase characters are not
considered equal.
Format:
STR$COMPARE_EQL src1-str ,src2-str
Arguments:
src1-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
First source string. The src1-str argument is the address of a
descriptor pointing to the first source string.
src2-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Second source string. The src2-str argument is the address of a
descriptor pointing to the second source string.
STR$COMPARE_MULTI
STR$COMPARE_MULTI compares two character strings for equality using
the DEC Multinational character set.
Format:
STR$COMPARE_MULTI src1-str ,src2-str [,case-blind-flag]
[,foreign-lang]
Arguments:
src1-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
First string in the comparison. The src1-str argument is the
address of a descriptor pointing to the first string.
src2-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Second string in the comparison. The src2-str argument is the
address of a descriptor pointing to the second string.
case-blind-flag
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
A single flag bit. The case-blind-flag argument is a signed
longword integer that contains this flag bit. The default value of
case-blind-flag is zero.
Bit Symbol Meaning
0 CASEBLIND If set, uppercase and lowercase characters are
equivalent.
foreign-lang
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Indicator which determines the foreign language table to be used.
The foreign-lang argument is an unsigned longword that contains this
foreign language table indicator. The default value of foreign-lang
is 1.
Value Language
1 Multinational table
2 Danish table
3 Finnish/Swedish table
4 German table
5 Norwegian table
6 Spanish table
STR$CONCAT
STR$CONCAT takes up to 254 source strings and concatenates them into
a single destination string.
Format:
STR$CONCAT dst-str ,src1-str [... ,srcn-str]
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$CONCAT concatenates all specified
source strings. The dst-str argument is the address of a descriptor
pointing to this destination string.
src1-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
First source string. The src1-str argument is the address of a
descriptor pointing to the first source string. STR$CONCAT requires
at least one source string.
srcn-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Nth source string. The scrn-str argument is the address of a
descriptor pointing to the Nth source string. The largest value of
N that STR$CONCAT allows is 254.
STR$COPY_DX
STR$COPY_DX copies a source string to a destination string. Both
strings are passed by descriptor.
Format:
STR$COPY_DX dst-str ,src-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$COPY_DX writes the source string.
The dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string that STR$COPY_DX copies into the destination string.
The src-str argument is the address of a descriptor pointing to this
source string. The descriptor class of the source string can be
unspecified, fixed length, dynamic, scalar decimal, array,
noncontiguous array, or varying.
STR$COPY_R
STR$COPY_R copies a source string passed by reference to a
destination string.
Format:
STR$COPY_R dst-str ,src-len ,src-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$COPY_R copies the source string.
The dst-str argument is the address of a descriptor pointing to the
destination string.
src-len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Length of the source string. The src-len argument is the address of
an unsigned word containing the length of the source string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by reference
Source string which STR$COPY_R copies into the destination string.
The src-str argument is the address of the source string.
STR$DIVIDE
STR$DIVIDE divides two decimal strings.
Format:
STR$DIVIDE asign ,aexp ,adigits ,bsign ,bexp ,bdigits
,tot-digits ,rnd-trunc ,csign ,cexp ,cdigits
Arguments:
asign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the first operand. The asign argument is the address of an
unsigned longword containing the first operand's sign. Zero is
considered positive; 1 is considered negative.
aexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which adigits has to be multiplied to get the
absolute value of the first operand. The aexp argument is the
address of the first operand's exponent.
adigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
First operand's numeric string. The adigits argument is the address
of a descriptor pointing to the first operand's numeric string. The
string must be an unsigned decimal number.
bsign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the second operand. The bsign argument is the address of an
unsigned longword containing the second operand's string. Zero is
considered positive; 1 is considered negative.
bexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which bdigits has to be multiplied to get the
absolute value of the second operand. The bexp argument is the
address of the second operand's exponent.
bdigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
Second operand's numeric string. The bdigits argument is the
address of a descriptor pointing to the second operand's number
string. The string must be an unsigned decimal number.
tot-digits
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of digits to the right of the decimal point. The tot-digits
argument is the address of s signed longword integer containing the
number of total digits. STR$DIVIDE uses this number to carry out
the division.
rnd-trunc
VMS usage: longword_unsigned
type: aligned bit string
access: read only
mechanism: by reference
Indicator of whether STR$DIVIDE is to round or truncate the result;
zero means truncate, 1 means round. The rnd-trunc argument is the
address of an aligned bit string containing this indicator.
csign
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Sign of the result. The csign argument is the address of a signed
longword integer containing the sign of the result. Zero is
considered positive; 1 is considered negative.
cexp
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Power of 10 by which cdigits has to be multiplied to get the
absolute value of the result. The cexp argument is the address of a
signed longword integer containing the exponent.
cdigits
VMS usage: char_string
type: num. string, unsigned
access: write only
mechanism: by descriptor
Result's numeric string. The cdigits argument is the address of a
descriptor pointing to the numeric string of the result. This
string is an unsigned decimal number.
STR$DUPL_CHAR
STR$DUPL_CHAR generates a string containing n duplicates of the
input character. If the destination string is an "empty" dynamic
string descriptor, STR$DUPL_CHAR will allocate and initialize the
string.
Format:
STR$DUPL_CHAR dst-str [,length] [,char]
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$DUPL_CHAR writes length copies of
the input character. The dst-str argument is the address of a
descriptor pointing to the destination string.
length
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of times char will be duplicated. The length argument is the
address of a signed longword integer containing the number. This is
an optional argument. If omitted, the default is 1.
char
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by reference
ASCII character which STR$DUPL_CHAR writes length times into the
destination string. The char argument is the address of an unsigned
byte containing this character. This is an optional argument. If
omitted, the default is a space.
STR$FIND_FIRST_IN_SET
STR$FIND_FIRST_IN_SET searches a string one character at a time,
from left to right, comparing each character in the string to every
character in a specified set of characters for which it is
searching. STR$FIND_FIRST_IN_SET returns the position in the string
where the first matching character was found. Zero is returned if
no match is found.
Format:
STR$FIND_FIRST_IN_SET src-str ,set-of-chars
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String which STR$FIND_FIRST_IN_SET compares to the set of
characters, looking for the first match. The src-str argument is
the address of a descriptor pointing to the character string.
set-of-chars
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Set of characters which STR$FIND_FIRST_IN_SET is searching for in
the string. The src-str argument is the address of a descriptor
pointing to the set of characters.
STR$FIND_FIRST_NOT_IN_SET
STR$FIND_FIRST_NOT_IN_SET searches a string, comparing each
character to the characters in a specified set of characters. The
string is searched character by character, from left to right.
STR$FIND_FIRST_NOT_IN_SET returns the position of the first
character in the string that does not match any of the characters in
the selected set of characters.
Format:
STR$FIND_FIRST_NOT_IN_SET src-str ,set-of-chars
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String which STR$FIND_FIRST_NOT_IN_SET searches. The src-str
argument is the address of a descriptor pointing to the string.
set-of-chars
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
The set of characters which STR$FIND_FIRST_NOT_IN_SET compares to
the string, looking for a nonmatch. The set-of-chars argument is
the address of a descriptor pointing to this set of characters.
STR$FIND_FIRST_SUBSTRING
STR$FIND_FIRST_SUBSTRING finds the first substring (in a provided
list of substrings) occurring in a given string.
Format:
STR$FIND_FIRST_SUBSTRING src-str ,index ,sub-string-index
,sub-string1 ... [,sub-stringn]
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String that STR$FIND_FIRST_SUBSTRING searches. The src-str argument
is the address of a descriptor pointing to the string.
index
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Earliest position within src-str at which STR$FIND_FIRST_SUBSTRING
found a matching substring; zero if no matching substring was found.
The index argument is the address of a signed longword integer
containing this position.
sub-string-index
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Ordinal number of the sub-string that matched (1 for the first, 2
for the second, and so on), or zero if STR$FIND_FIRST_SUBSTRING
found no substrings that matched. The sub-string-index argument is
the address of a signed longword integer containing this ordinal
number.
sub-string1
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
First specified substring for which STR$FIND_FIRST_SUBSTRING
searches in src-str. The src-str argument is the address of a
descriptor pointing to the first substring.
sub-stringn
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Nth specified substring which STR$FIND_FIRST_SUBSTRING will search
for in the string. The sub-stringn argument is the address of a
descriptor pointing to the Nth substring.
STR$FREE1_DX
STR$FREE1_DX deallocates one dynamic string.
Format:
STR$FREE1_DX dsc-adr
ARGUMENT
dsc-adr
VMS usage: char_string
type: character string (unsigned)
access: modify
mechanism: by descriptor
Dynamic string descriptor of the dynamic string which STR$FREE1_DX
deallocates. The dsc-adr argument is the address of a descriptor
pointing to the string to be deallocated. The class field
(DSC$B_CLASS) is checked.
STR$GET1_DX
STR$GET1_DX allocates a specified number of bytes of dynamic virtual
memory to a specified dynamic string descriptor.
Format:
STR$GET1_DX len ,str
Arguments:
len
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Number of bytes which STR$GET1_DX allocates. The len argument is
the address of an unsigned word containing this number.
str
VMS usage: char_string
type: character string
access: modify
mechanism: by descriptor
Dynamic string descriptor to which STR$GET1_DX allocates the area.
The str argument is the address of an unsigned quadword containing
the string descriptor.
STR$LEFT
STR$LEFT copies a substring of a source string into a destination
string.
Format:
STR$LEFT dst-str ,src-str ,end-pos
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$LEFT copies the substring. The
dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string from which STR$LEFT extracts the substring which it
copies into the destination string. The src-str argument is the
address of a descriptor pointing to the source string.
end-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Relative position in the source string at which the substring ends.
The end-pos argument is the address of a signed longword integer
containing the ending position.
STR$LEN_EXTR
STR$LEN_EXTR copies a substring of a source string into a
destination string.
Format:
STR$LEN_EXTR dst-str ,src-str ,start-pos ,length
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$LEN_EXTR copies the substring.
The dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string from which STR$LEN_EXTR extracts the substring that it
copies into the destination string. The src-str argument is the
address of a descriptor pointing to the source string.
start-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Relative position in the source string at which the substring that
STR$LEN_EXTR copies starts. The start-pos argument is the address
of a signed longword integer containing the starting position.
length
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Number of characters in the substring that STR$LEN_EXTR copies to
the destination string. The length argument is the address of a
signed longword integer containing the length of the substring.
STR$MATCH_WILD
STR$MATCH_WILD is used to compare a pattern string that includes
wildcard characters with a candidate string. It returns a condition
value of STR$_MATCH if the strings match and STR$_NOMATCH if they do
not match.
Format:
STR$MATCH_WILD cand-str ,pattern-str
Arguments:
cand-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String to which the pattern string is compared. The cand-str
argument is the address of a descriptor pointing to the candidate
string.
pattern-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
String containing wildcard characters. The pattern-str argument is
the address of a descriptor pointing to the pattern string. The
wildcards in the pattern string are translated when STR$MATCH_WILD
searches the candidate string to determine if it matches the pattern
string.
STR$MUL
STR$MUL multiplies two decimal strings.
Format:
STR$MUL asign ,aexp ,adigits ,bsign ,bexp ,bdigits
,csign ,cexp ,cdigits
Arguments:
asign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the first operand. The asign argument is the address of an
unsigned longword containing the first operand's sign. Zero is
considered positive; 1 is considered negative.
aexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which adigits has to be multiplied to get the
absolute value of the first operand. The aexp argument is the
address of a signed longword integer containing this exponent.
adigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
First operand's numeric string. The adigits argument is the address
of a descriptor pointing to the numeric string of the first operand.
The string must be an unsigned decimal number.
bsign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the second operand. The bsign argument is the address of an
unsigned longword containing the sign of the second operand. Zero
is considered positive; 1 is considered negative.
bexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which bdigits has to be multiplied to get the
absolute value of the second operand. The bexp argument is the
address of a signed longword integer containing this exponent.
bdigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
Second operand's numeric string. The bdigits argument is the
address of a descriptor pointing to the second operand's numeric
string. The string must be an unsigned decimal number.
csign
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Sign of the result. The csign argument is the address of a signed
longword integer containing the sign of the result. Zero is
considered positive; 1 is considered negative.
cexp
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Power of 10 by which cdigits has to be multiplied to get the
absolute value of the result. The cexp argument is the address of a
signed longword integer containing this exponent.
cdigits
VMS usage: char_string
type: num. string, unsigned
access: write only
mechanism: by descriptor
Result's numeric string. The cdigits argument is the address of a
descriptor pointing to the numeric string of the result. The string
will be an unsigned decimal number.
STR$POSITION
STR$POSITION searches for the first occurrence of a single substring
within a source string. If STR$POSITION finds the substring, it
returns the relative position of that substring. If the substring
is not found, STR$POSITION returns a zero.
Format:
STR$POSITION src-str ,sub-str [,start-pos]
Arguments:
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string within which STR$POSITION searches for the substring.
The src-str argument is the address of a descriptor pointing to the
source string.
sub-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Substring for which STR$POSITION searches. The sub-str argument is
the address of a descriptor pointing to the substring.
start-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Relative position in the source string at which STR$POSITION begins
the search. The start-pos argument is the address of a signed
longword integer containing the starting position. Although this is
an optional argument, it is required if you are using the JSB entry
point.
STR$POS_EXTR
STR$POS_EXTR copies a substring of a source string into a
destination string.
Format:
STR$POS_EXTR dst-str ,src-str ,start-pos ,end-pos
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$POS_EXTR copies the substring.
The dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string from which STR$POS_EXTR extracts the substring that it
copies into the destination string. The src-str argument is the
address of a descriptor pointing to the source string.
start-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Relative position in the source string at which the substring that
STR$POS_EXTR copies starts. The start-pos argument is the address
of a signed longword integer containing the starting position.
end-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Relative position in the source string at which the substring that
STR$POS_EXTR copies ends. The end-pos argument is the address of a
signed longword integer containing the ending position.
STR$PREFIX
STR$PREFIX inserts a source string at the beginning of a destination
string. The destination string must be dynamic or varying.
Format:
STR$PREFIX dst-str ,src-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string (dynamic or varying); STR$PREFIX copies the
source string into the beginning of this destination string. The
dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string which STR$PREFIX copies into the beginning of the
destination string. The src-str argument is the address of a
descriptor pointing to the source string.
STR$RECIP
STR$RECIP takes the reciprocal of the first decimal string to the
precision limit specified by the second decimal string and returns
the result as a decimal string.
Format:
STR$RECIP asign ,aexp ,adigits ,bsign ,bexp ,bdigits
,csign ,cexp ,cdigits
Arguments:
asign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the first operand. The asign argument is the address of an
unsigned longword containing the first operand's sign. Zero is
considered positive; 1 is considered negative.
aexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which adigits has to be multiplied to get the
absolute value of the first operand. The aexp argument is the
address of a signed longword integer containing this exponent.
adigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
First operand's numeric string. The adigits argument is the address
of a descriptor pointing to the first operand's numeric string. The
string must be an unsigned decimal number.
bsign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the second operand. The bsign argument is the address of an
unsigned longword containing the sign of the second operand. Zero
is considered positive; 1 is considered negative.
bexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which bdigits has to be multiplied to get the
absolute value of the second operand. The bexp argument is the
address of a signed longword integer containing this exponent.
bdigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
Second operand's numeric string. The bdigits argument is the
address of a descriptor pointing to the second operand's numeric
string. The string must be an unsigned decimal number.
csign
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Sign of the result. The csign argument is the address of a signed
longword integer containing the result's sign. Zero is considered
positive; 1 is considered negative.
cexp
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Power of 10 by which cdigits has to be multiplied to get the
absolute value of the result. The cexp argument is the address of a
signed longword integer containing this exponent.
cdigits
VMS usage: char_string
type: num. string, unsigned
access: write only
mechanism: by descriptor
Result's numeric string. The cdigits argument is the address of a
descriptor pointing to the result's numeric string. The string will
be an unsigned decimal number.
STR$REPLACE
STR$REPLACE copies a source string to a destination string,
replacing part of the string with another string. The substring to
be replaced is specified by its starting and ending positions.
Format:
STR$REPLACE dst-str ,src-str ,start-pos ,end-pos ,rpl-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$REPLACE writes the new string
created when it replaces the substring. The dst-str argument is the
address of a descriptor pointing to the destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string. The src-str argument is the address of a descriptor
pointing to the source string.
start-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Position in the source string at which the substring which
STR$REPLACE replaces begins. The start-pos argument is the address
of a signed longword integer containing the starting position. The
position is relative to the start of the source string.
end-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Position in the source string at which the substring which
STR$REPLACE replaces ends. The end-pos argument is the address of a
signed longword integer containing the ending position. The
position is relative to the start of the source string.
rpl-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Replacement string with which STR$REPLACE replaces the substring.
The rpl-str argument is the address of a descriptor pointing to this
replacement string.
STR$RIGHT
STR$RIGHT copies a substring of a source string into a destination
string.
Format:
STR$RIGHT dst-str ,src-str ,start-pos
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$RIGHT copies the substring. The
dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string from which STR$RIGHT extracts the substring that it
copies into the destination string. The src-str argument is the
address of a descriptor pointing to the source string.
start-pos
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference for CALL entry point,
by value for JSB entry point
Relative position in the source string at which the substring that
STR$RIGHT copies starts. The start-pos argument is the address of a
signed longword integer containing the starting position.
STR$ROUND
STR$ROUND rounds or truncates a decimal string to a specified number
of significant digits and places the result in another decimal
string.
Format:
STR$ROUND places ,trunc-flg ,asign ,aexp ,adigits
,csign ,cexp ,cdigits
Arguments:
places
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Maximum number of decimal digits that STR$ROUND retains in the
result. The places argument is the address of a signed longword
integer containing the number of decimal digits.
trunc-flg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Function flag. Zero indicates that the decimal string is rounded; 1
indicates that it is truncated. The trunc-flg argument is the
address of an unsigned longword containing this function flag.
asign
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Sign of the first operand. The asign argument is the address of an
unsigned longword string containing this sign. A value of zero
indicates that the number is positive, while a value of 1 indicates
that the number is negative.
aexp
VMS usage: longword_signed
type: longword integer (signed)
access: read only
mechanism: by reference
Power of 10 by which adigits has to be multiplied to get the
absolute value of the first operand. The aexp argument is the
address of a signed longword integer containing this exponent.
adigits
VMS usage: char_string
type: num. string, unsigned
access: read only
mechanism: by descriptor
First operand's numeric string. The adigits argument is the address
of a descriptor pointing to this numeric string. The string must be
an unsigned decimal number.
csign
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Sign of the result. The csign argument is the address of a signed
longword integer containing the result's sign. A value of zero
indicates that the number is positive, while a value of 1 indicates
that the number is negative.
cexp
VMS usage: longword_signed
type: longword integer (signed)
access: write only
mechanism: by reference
Power of 10 by which cdigits has to be multiplied to get the
absolute value of the result. The cexp argument is the address of a
signed longword integer containing this exponent.
cdigits
VMS usage: char_string
type: num. string, unsigned
access: write only
mechanism: by descriptor
Result's numeric string. The cdigits argument is the address of a
descriptor pointing to this numeric string. The string will be an
unsigned decimal number.
STR$TRANSLATE
STR$TRANSLATE successively compares each character in a source
string to all characters in a match string. If a source character
has a match, the destination character is taken from the translate
string. Otherwise, STR$TRANSLATE moves the source character to the
destination string.
Format:
STR$TRANSLATE dst-str ,src-str ,trans-str ,match-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string. The dst-str argument is the address of a
descriptor pointing to the destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string. The src-str argument is the address of a descriptor
pointing to the source string.
trans-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Translate string. The trans-str argument is the address of a
descriptor pointing to the translate string.
match-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Match string. The match-str argument is the address of a descriptor
pointing to the match string.
STR$TRIM
STR$TRIM copies a source string to a destination string and deletes
the trailing blank and tab characters.
Format:
STR$TRIM dst-str ,src-str [,out-len]
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$TRIM copies the trimmed string.
The dst-str argument is the address of a descriptor pointing to the
destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string which STR$TRIM trims and then copies into the
destination string. The src-str argument is the address of a
descriptor pointing to the source string.
out-len
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of bytes that STR$TRIM has written into dst-str, not counting
padding in the case of a fixed-length string. The out-len argument
is the address of an unsigned word into which STR$TRIM writes the
length of the output string. If the input string is truncated to
the size specified in the dst-str description, out-len is set to
this size. Therefore, out-len can always be used by the calling
program to access a valid substring of dst-str.
STR$UPCASE
STR$UPCASE converts a source string to uppercase and writes the
converted string into the destination string. When you need to
compare characters without regard to case, you can first use
STR$UPCASE to convert both characters to uppercase. STR$UPCASE
converts all characters in the multinational character set.
Format:
STR$UPCASE dst-str ,src-str
Arguments:
dst-str
VMS usage: char_string
type: character string
access: write only
mechanism: by descriptor
Destination string into which STR$UPCASE writes the string it has
converted to uppercase. The dst-str argument is the address of a
descriptor pointing to the destination string.
src-str
VMS usage: char_string
type: character string
access: read only
mechanism: by descriptor
Source string that STR$UPCASE converts to uppercase. The src-str
argument is the address of a descriptor pointing to the source
string.
Specify
This help category contains information on the syntax of various entities used in DCL.
Additional information available:
Date TimeExpressionFile SpecIntegerPrivilegeProtectionString
Symbol
Date Time
When a command requires a qualifier that specifies a date/time value, the value is either an absolute date/time, a delta time, or a combination of the two. See Section 2.5 of the VAX/VMS Digital Command Language Dictionary for more information on correct syntax for time specifications.
Additional information available:
Absolute
Absolute time is a specific date and/or time of day.
An absolute date/time has one of the following formats:
[dd-mmm-yyyy[:]][hh:mm:ss.cc]
TODAY
YESTERDAY
TOMORROW
If you specify both the date and the time, the intervening colon
is required. You can omit any of the trailing fields in the date
or time. You can omit any of the fields in the middle of the
format as long as you specify the punctuation marks.
Combination
Combination time consists of an absolute time value plus or minus
a delta time value.
A combination time has the following format:
"absolute-delta"
"absolute+delta"
The absolute and delta times allow the same flexibility as is
described in the other help sections. The quotes are required.
Delta
Delta time is an offset from the current time to a time in the future.
A delta time has the following format:
[dddd-] [hh:mm:ss.cc]
You can truncate delta time on the right. You can also omit any of the
fields in the middle of the format as long as you specify the punctuation
marks.
Expression
When DCL evaluates an expression, it determines a value based on the operations specified in the expression. The value can be an integer or a character string. Some expression operators are conventional mathematical symbols, for example, plus sign (+). Others specify logical and comparison operations, and consist of letters surrounded by periods, for example, .EQS. Operators are assigned a precedence which determines their order of evaluation. Parentheses may always be used to override this order.
Additional information available:
Arithmetic
Operator Precedence Description
.OR. 1 Logical OR
.AND. 2 Logical AND
.NOT. 3 Logical NOT
.EQ. 4 Arithmetic equal
.GE. 4 Arithmetic greater than or equal
.GT. 4 Arithmetic greater than
.LE. 4 Arithmetic less than or equal
.LT. 4 Arithmetic less than
.NE. 4 Arithmetic not equal
+ 5 Arithmetic plus
- 5 Arithmetic minus
* 6 Arithmetic times
/ 6 Arithmetic divide
String
Operator Precedence Description
.EQS. 4 String equal
.GES. 4 String greater than or equal
.GTS. 4 String greater than
.LES. 4 String less than or equal
.LTS. 4 String less than
.NES. 4 String not equal
+ 5 String concatenation
- 5 String reduction
File Spec
File specifications provide the system with the information
necessary to identify a unique file or device. A file spec has
the following format:
node::device:[directory]filename.type;version
The punctuation marks are required to separate the fields of the
file spec. These fields are:
node Network node name
device Device name
directory Directory name or sequence
filename File name
type File type
version File version number
Integer
DCL treats all numeric values as integers. If you do not specify
an explicit radix, numeric values are interpreted as decimal.
You may specify an explicit radix as follows:
%D1000 decimal radix
%O1357 octal radix
%X12AF hexadecimal radix
No blanks are allowed between the radix symbol and the number.
Privilege
Your set of privileges affects the system resources and system functions you are allowed to use.
Additional information available:
ACNTALLALLSPOOLALTPRIBUGCHKBYPASSCMEXEC
CMKRNLDETACHDIAGNOSEEXQUOTAGROUPGRPNAMGRPPRV
LOG_IOMOUNTNETMBXOPERPFNMAPPHY_IOPRMCEB
PRMGBLPRMJNLPRMMBXPSWAPMREADALLSECURITYSETPRV
SHARESHMEMSYSGBLSYSLCKSYSNAMSYSPRVTMPJNL
TMPMBXVOLPROWORLD
ACNT
Create a process for which no accounting is performed.
ALL
All privileges.
ALLSPOOL
Allocate spooled devices.
ALTPRI
Increase the base execution priority for any process.
BUGCHK
Make bug check error log entries.
BYPASS
Access resources without regard to UIC protection.
CMEXEC
Change mode to Executive.
CMKRNL
Change mode to Kernel.
DETACH
Create detached processes.
DIAGNOSE
Issue diagnostic I/O requests.
EXQUOTA
Exceed resource quotas.
GROUP
Control execution of other processes in the same group.
GRPNAM
Enter names in the group logical name table.
GRPPRV
Allow access to files in group along with the system category.
LOG_IO
Issue logical I/O requests.
MOUNT
Issue mount volume I/O requests.
NETMBX
Create a network device.
OPER
Perform system operator functions.
PFNMAP
Create or delete sections mapped by page frame.
PHY_IO
Issue physical I/O requests.
PRMCEB
Create permanent common event flag clusters.
PRMGBL
Create permanent global clusters.
PRMJNL
Create permanent journal.
PRMMBX
Create permanent mailbox devices.
PSWAPM
Change process swap mode.
READALL
Bypass restrictions otherwise preventing process from reading a file.
SECURITY
Perform security-related functions.
SETPRV
Grant a process any privilege.
SHARE
Assign a channel to a device.
SHMEM
Create or delete data structures in shared memory.
SYSGBL
Create system global sections.
SYSLCK
Request locks on system resources.
SYSNAM
Enter names in the system logical name table.
SYSPRV
Access resources as if the process has a system UIC.
TMPJNL
Create a temporary journal.
TMPMBX
Create temporary mailbox devices.
VOLPRO
Override protection on a volume.
WORLD
Control the execute of any process on the system.
Protection
Volume and file protection is specified as follows:
(SYSTEM:rwed,OWNER:rwed,GROUP:rwed,WORLD:rwed)
There are four categories of protection, one for system
processes, one for the owner of the file, one for other members
of the owner's group, and one for members of other groups. For
each category, any combination of four different types of access
may be specified:
R - read access
W - write access
E - execute access (for execution of images)
D - delete access
If you want to deny all access to a category, you must specify
the category name without a colon, for example:
/PROTECTION=(OWNER:RWE,GROUP,WORLD)
String
A character string value is represented as a sequence of
characters enclosed in quotation marks ("). A quotation mark in
a character string must be represented by two quotation marks.
In certain contexts, the quotation marks are optional.
Symbol
A symbol is an entity which has a name and a value. The name can consist of the letters, digits, underscore (_) and dollar sign ($). It can be composed of up to 255 characters. The value of the symbol can be a 32-bit integer or a string of between zero and 255 characters. Symbols are defined in DCL with the assignment statement. This is described under the HELP SYMBOL_ASSIGN.
UIC
A UIC is a User Identification Code and can be in either numeric or
named format. When a DCL command requires a UIC specification, you
can specify either format. However, the system converts all UIC's
to numeric format when determining a user's access to a data resource.
A UIC in numeric format consists of a group number and a member number
in the format:
[g,m]
where:
g is an octal number in the range 0 through 37777
representing the group number.
m is an octal number in the range 0 through 37777
representing the member number.
The square brackets are required in the UIC specification. You may also
omit leading zeros when specifying group and member numbers.
A UIC in named format consists of a member identifier and, optionally, a
group identifier, as shown below:
[member-identifier]
[group-identifier,member-identifier]
The group and member identifiers can each contain up to 32 alphanumeric
characters and must contain at least one alphabetic character. The names
can include the characters A through Z, dollar signs ($) and underscores
(_), and the numbers 0 through 9. The brackets are required in the UIC
specification.
The member number is unique for each for each user on the system, and is
equivalent to the user's numeric UIC (including both the group and the
member numbers). The group identifier is equivalent to only the group
portion of the UIC.
Symbol Assign
Defines a symbolic name for a character string or integer value.
Format:
symbol-name =[=] expression
symbol-name[bit-position,size] =[=] replacement-expression
Additional information available:
ParametersExamplesString Assign
Parameters
symbol-name Defines a 1- through 255-character alphanumeric string name for the symbol. The symbol name must begin with an alphabetic character (uppercase and lowercase characters are equivalent), an underscore, or a dollar sign. After the first character, the name can contain any alphanumeric characters from the DEC multinational character set, underscores, or dollar signs. If you specify a single equal sign (=) in the assignment statement, the symbol name is placed in the local symbol table for the current command level. If you specify double equal signs (==) in the assignment statement, the symbol name is placed in the global symbol table. expression Specifies the value on the right-hand side of an assignment statement. An expression can consist of a character string value, an integer value, a symbol name, a lexical function, or a combination of these entities. The components of an expression are evaluated, and the result is assigned to a symbol. All literal character strings must be enclosed in quotation marks. If you specify an expression containing a symbol, the command interpreter uses the symbol's value in evaluating the expression. The result of expression evaluation is either a character string or an integer value. The data type of a symbol is determined by the data type of the expression. If the expression evaluates to a string, the symbol is assigned a string value. If the expression evaluates to an integer, the symbol is assigned an integer value. For a summary of operators used in expressions, details on how to specify expressions, and details on how expressions are evaluated, see Chapter 4 in the VAX/VMS DIGITAL Command Language Dictionary. DCL uses a buffer that is 1024 bytes long to hold an assignment statement, and to evaluate the expression. The length of the symbol name, the expression, and the expression's calculations cannot exceed 1024 bytes. [bit-position,size] Specifies that a binary overlay is to be inserted in the current 32-bit value of a symbol-name. This type of assignment statement evaluates the current value of the symbol-name and replaces the specified number of bits with the result of the replacement-expression. The bit-position is the location relative to bit 0 at which the overlay is to occur. If the symbol that you are overlaying is an integer, then the bit position must be less than 32. Also, the sum of the bit position and the size must be less than or equal to 32. If the symbol you are overlaying is a string, then the bit position must be less than 6152. Because each character is represented using 8 bits, you can begin an overlay at any character through the 768th. (The 768th character starts in bit position 6144.) The sum of the bit position and the size must be less than or equal to 6152. The size is the number of bits to be overlaid. If you specify a size that is greater than 32, then DCL reduces the size to 32. The square brackets are required notation; no spaces are allowed between the symbol name and the left bracket. Specify values for bit-position and size as integer expressions. replacement-expression Specifies the value that is used to overlay the symbol you are modifying. Specify the replacement-expression as an integer expression. If the symbol you are modifying is an integer, the replacement-expression defines a bit pattern which is overlaid on the value assigned to the symbol. If the symbol you are modifying is a character string, the result of the replacement-expression defines a bit pattern which is overlaid on the specified bits of the character string. If the symbol you are modifying is undefined, the result of the replacement-expression is overlaid on a null string.
Examples
1. $ LIST == "DIRECTORY"
$ TIME == "SHOW TIME"
$ QP == "SHOW QUEUE/DEVICE"
$ SS == "SHOW SYMBOL"
The file SYNONYM.COM contains the assignment statements shown;
these are user-defined synonyms for commands. Execute this command
procedure as follows:
$ @SYNONYM
After the command procedure creates the global symbol definitions,
you can use these synonyms (LIST, TIME, QP,and SS) at the
interactive command level. Note that the assignments are global;
otherwise, the symbol names would have been deleted after the file
SYNONYM.COM completed execution.
2. $ COUNT = 0
$ LOOP:
$ COUNT = COUNT + 1
.
.
.
$ IF COUNT .LT.5 THEN GOTO LOOP
The symbol COUNT is initially assigned a numeric value of 0; a loop
is established to increment the value of COUNT by 1 each time the
loop is entered. Note that when the symbol name COUNT appears on
the right-hand side of an arithmetic assignment statement, the
command interpreter automatically substitutes its current value.
The IF command tests the value of COUNT; if it is less than 5, the
procedure branches to the label LOOP and the statements between the
label LOOP through the IF command are executed again. When the
value of the symbol count reaches 5, the loop is not executed again
and the command following the IF command is executed.
3. $ A = 25
$ CODE = 4 + F$INTEGER("6") - A
$ SHOW SYMBOL CODE
CODE = -15 HEX = FFFFFFF1 Octal = 1777761
This example contains two assignment statements. The first
statement assigns the value 25 to the symbol A. The second
assignment statement evaluates an expression containing an integer
(4), a lexical function (F$INTEGER("6")), and the symbol A. The
result of the expression, -15, is assigned to the symbol CODE.
String Assign
Defines a symbolic name for a character string value.
Format:
symbol-name :=[=] string
symbol-name[offset,size] :=[=] replacement-string
Additional information available:
Parameters
symbol-name
Defines a 1- through 255-character string name for the symbol. The
symbol name must begin with an alphabetic character (uppercase and
lowercase characters are equivalent), an underscore, or a dollar
sign. After the first character, the name can contain any
alphanumeric characters from the DEC Multinational Character Set,
underscores, or dollar signs.
If you specify a single equal sign (:=) in the assignment statement,
the symbol name is placed in the local symbol table for the current
command level.
If you specify double equal signs (:==) in the assignment statement,
the symbol name is placed in the global symbol table.
string
Specifies a character string value to be equated to the symbol. The
string can contain any alphanumeric or special characters. DCL uses
a buffer that is 1024 bytes long to hold a string assignment
statement, Therefore, the length of the symbol name, the string, and
any symbol substitution within the string cannot exceed 1024
characters.
With the := string assignment statement, you do not need to enclose
a string literal in quotation marks. String values are
automatically converted to uppercase. Also, any leading and
trailing spaces and tabs are removed, and multiple spaces and tabs
between characters are compressed to a single space.
Note that, in general, it is easier to use the assignment statement
(=) to create symbols with string values. The assignment statement
does not automatically upcase and remove extra spaces. Also, the
assignment statement allows you to perform string operations in
expressions.
If you want to prohibit uppercase conversion and retain required
space and tab characters in a string, you must place quotation marks
around the string. To use quotation marks in a string, enclose the
entire string in quotation marks and use a double set of quotation
marks within the string. For example:
$ TEST := "this is a ""test"" string"
$ SHOW SYMBOL TEST
TEST = "this is a "test" string"
In this example, the spaces, lowercase letters, and quotation marks
are preserved in the symbol definition.
You can continue a symbol assignment on more than one line by using
the hyphen as a continuation character. For example:
$ LONG_STRING := THIS_IS_A_VERY_LONG-
_$ _SYMBOL_STRING
To assign a null string to a symbol using the string assignment
statement, do not specify a string. For example:
$ NULL :=
Specify the string as a string literal, or as a symbol or lexical
function which evaluates to a string literal. If you use symbols or
lexical functions, place apostrophes around them to request symbol
substitution. See Chapter 5 in the VAX/VMS DIGITAL Command Language
Dictionary for more information on symbol substitution.
You can also use the string assignment statement to define a foreign
command. See Section 4.10 in the VAX/VMS DIGITAL Command Language
Dictionary for more information about foreign commands.
[offset,size]
Specifies that a portion of a symbol value is to be overlaid with a
replacement string. This form of the string assignment statement
evaluates the value assigned to a symbol-name and then replaces the
portion of the value (defined by the offset and size) with the
replacement string. The square brackets are required notation, and
no spaces are allowed between the symbol name and the left bracket.
The offset specifies the character position relative to the
beginning of the symbol-name's string value at which replacement is
to begin. Offset values start at 0.
If the offset is greater than the offset of the last character in
the string you are modifying, spaces are inserted between the end of
the string and the offset where the replacement string is added.
The maximum offset value you can specify is 768.
The size specifies the number of characters to replace. Size values
start at 1.
Specify the offset and size as integer expressions. See Section
4.6.2 in the VAX/VMS DIGITAL Command Language Dictionary for more
information on integer expressions. The value of the size plus the
offset must not exceed 769.
replacement-string
Specifies the string that is used to overlay the string you are
modifying. If the replacement-string is shorter than the size
argument, the replacement string is blank-filled on the right until
it equals the specified size. Then the replacement string is used
to overlay the string assigned to the symbol-name. If the
replacement string is longer than the size argument, then the
replacement string is truncated on the right to the specified size.
You can specify the replacement-string as a string literal, or as a
symbol or lexical function which evaluates to a string literal. If
you use symbols or lexical functions, place apostrophes around them
to request symbol substitution. See Chapter 5 in the VAX/VMS
DIGITAL Command Language Dictionary for more information on symbol
substitution.
Examples
1. $ TIME := SHOW TIME
$ TIME
15-APR-1984 11:55:44
The symbol TIME is equated to the command string SHOW TIME. Because
the symbol name appears as the first word in a command string, the
command interpreter automatically substitutes it with its string
value and executes the command SHOW TIME.
2. $ STAT := $DBA1:[CRAMER]STAT
$ STAT
This example shows how to define STAT as a foreign command. The
symbol STAT is equated to a string that begins with a dollar sign
followed by a file specification. The command interpreter assumes
that the file specification is that of an executable image, that is,
a file with a file type of EXE. Thus, the symbol STAT in this
example becomes a synonym for the command:
$ RUN DBA1:[CRAMER]STAT.EXE
When you subsequently type STAT, the command interpreter executes
the image.
3. $ A = "this is a big space."
$ SHOW SYMBOL A
A = "this is a big space."
$ B := 'A'
$ SHOW SYMBOL B
B = "THIS IS A BIG SPACE."
This example compares the assignment and the string assignment
statements. The symbol A is defined using the assignment statement,
so lowercase letters and multiple spaces are retained. The symbol B
is defined using the string assignment statement. Note that the
apostrophes are required; otherwise, the symbol name B would have
been equated to the literal string A. However, when symbol A's
value is assigned to symbol B, the letters are converted to
uppercase and multiple spaces are compressed.
System Services
This help category provides an overview and the format of each of the VAX/VMS system services.
Additional information available:
$ABORT_RU$ADD_HOLDER$ADD_IDENT$ADJSTK
$ADJWSL$ALLOC$ASCEFC$ASCTIM$ASCTOID$ASSIGN$BINTIM
$BRKTHRU$BRKTHRUW$CANCEL$CANEXH$CANTIM$CANWAK
$CHANGE_ACL$CHECK_ACCESS$CHKPRO$CLREF$CMEXEC
$CMKRNL$CNTREG$COMMIT_RU$CRELNM$CRELNT$CREMBX
$CREPRC$CREATE_RDB$CRETVA$CRMPSC$DACEFC$DALLOC
$DASSGN$DCLAST$DCLCMH$DCLEXH$DELLNM$DELMBX$DELPRC
$DELTVA$DEQ$DGBLSC$DISMOU$DLCEFC$END_RU$ENQ
$ENQW$ERAPAT$EXIT$EXPREG$FAO$FILESCAN$FIND_HELD
$FIND_HOLDER$FINISH_RDB$FORCEX$FORMAT_ACL
$GETDVI$GETDVIW$GETJPI$GETJPIW$GETLKI$GETLKIW$GETMSG
$GETQUI$GETQUIW$GETSYI$GETSYIW$GETTIM$GETUAI$GRANTID
$HIBER$IDTOASC$LCKPAG$LKWSET$MGBLSC$MOD_HOLDER
$MOD_IDENT$MOUNT$MTACCESS$NUMTIM$PARSE_ACL
$PREPARE_RU$PURGWS$PUTMSG$QIO$QIOW$READEF
$REM_HOLDER$REM_IDENT$RESUME$REVOKID$SCHDWK
$SETAST$SETEF$SETEXV$SETIME$SETIMR$SETPRA$SETPRI
$SETPRN$SETPRT$SETPRV$SETRWM$SETSFM$SETSSF$SETSTK
$SETSWM$SETUAI$SNDERR$SNDJBC$SNDJBCW$SNDOPR$START_RU
$SUSPND$SYNCHSYS$RMSRUNDWNSYS$SETDDIRSYS$SETDFPROT
$TRNLNM$ULKPAG$ULWSET$UNWIND$UPDSEC$UPDSECW$WAITFR
$WAKE$WFLAND$WFLOR
$ABORT_RU
Applicable only if you have the RMS Journaling option. See the VAX
RMS Journaling Manual.
The Abort Recovery Unit Service terminates the current recovery unit
and restores all connected files to their states before the recovery
unit was started, for an application using RMS Journaling. You can
abort a recovery unit at any time after you invoke the $START_RU
service and before you invoke the $END_RU or $COMMIT_RU service.
Note that you can use the $ABORT_RU service after using the
$PREPARE_RU service, as long as you have not issued a call to the
$COMMIT_RU service.
After you abort the recovery unit, all files that were connected to
the recovery unit during $START_RU are available for further
processing. Remember that the $ABORT_RU call restores only the
records for those files that were marked for recovery unit journaling and
connected to the current recovery unit.
Format:
SYS$ABORT_RU ru_handle
Arguments:
ru_handle
VMS Usage: ru_handle
type: longword (unsigned)
access: read only
mechanism: by reference
The ru_handle argument is the address of an unsigned longword that
contains the recovery unit handle returned by the $START_RU system
service.
$ADD_HOLDER
The Add Holder Record to Rights Database service adds the specified
holder record to the target identifier.
Format:
SYS$ADD_HOLDER id ,holder ,[attrib]
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Target identifier granted to the specified holder when $ADD_HOLDER
completes execution. The id argument is a longword containing the
binary value of the target identifier.
holder
VMS usage: rights_holder
type: quadword (unsigned)
access: read only
mechanism: by reference
Holder identifier that is granted access to the target identifier
when $ADD_HOLDER completes execution. The holder argument is the
address of a quadword data structure that consists of a longword
containing the holder's UIC identifier followed by a longword
containing a value of zero.
attrib
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Attributes to be placed in the holder record when the $ADD_HOLDER
completes execution. The attrib argument is a longword containing a
bitmask specifying the attributes. A holder is granted a specified
attribute only if the target identifier has the attribute.
$ADD_IDENT
The Add Identifier to Rights Database service adds the specified
identifier to the rights database.
Format:
SYS$ADD_IDENT name ,[id] ,[attrib] ,[resid]
Arguments:
name
VMS usage: char-string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Identifier name to be added to the rights database when $ADD_IDENT
completes execution. The name argument is the address of the
descriptor pointing to the identifier name string.
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Identifier to be created when $ADD_IDENT completes execution. The
id argument is a longword containing the binary value of the
identifier to be created.
attrib
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Attributes placed in the identifier's record when $ADD_IDENT
completes execution. The attrib argument is a longword containing a
bitmask specifying the attributes.
resid
VMS usage: rights_id
type: longword (unsigned)
access: write only
mechanism: by reference
Identifier value assigned by the system when $ADD_IDENT completes
execution. The resid argument is the address of a longword in which
the system-assigned identifier value is written.
$ADJSTK
The Adjust Outer Mode Stack Pointer service modifies the stack
pointer for a less privileged access mode. This service is used by
the operating system to modify a stack pointer for a less privileged
access mode after placing arguments on the stack.
Format:
SYS$ADJSTK [acmode] ,[adjust] ,newadr
Arguments:
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode for which the stack pointer is to be adjusted. The
acmode argument is this longword value. If not specified, a default
value of 0 (kernel access mode) is used.
adjust
VMS usage: word_signed
type: word (signed)
access: read only
mechanism: by value
Signed adjustment value to be used to modify the value specified by
the newadr argument. The adjust argument is a signed longword,
which is the adjustment value.
newadr
VMS usage: address
type: longword (unsigned)
access: modify
mechanism: by reference
Value that $ADJUST is to adjust. The newadr argument is the address
of this longword value. The value specified by this argument is
both read and written by $ADJSTK. $ADJSTK reads the value specified
and adjusts it by the value of the adjust argument (if specified).
After this adjustment is made, $ADJSTK writes the adjusted value
back into the longword specified by newadr and then loads the stack
pointer with the adjusted value.
$ADJWSL
The Adjust Working Set Limit service adjusts a process's current
working set limit by the specified number of pages and returns the
new value to the caller. The working set limit specifies the
maximum number of process pages that may be resident in physical
memory.
Format:
SYS$ADJWSL [pagcnt] ,[wsetlm]
Arguments:
pagcnt
VMS usage: longword_signed
type: longword (signed)
access: read only
mechanism: by value
Signed adjustment value specifying the number of pages to add (if
positive) or subtract (if negative) from the current working set
limit. The pagcnt argument is this signed longword value.
wsetlm
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Value of the working set limit, returned by $ADJWSL. The wsetlm
argument is the address of this longword value. The wsetlm argument
specifies the newly adjusted value if pagcnt was specified, and it
specifies the old, unadjusted value if pagcnt was not specified.
$ALLOC
The Allocate Device service allocates a device for exclusive use by
a process and its subprocesses. No other process can allocate the
device or assign channels to it until the image that called $ALLOC
exits or explicitly deallocates the device with the Deallocate
Device ($DALLOC) service.
Format:
SYS$ALLOC devnam ,[phylen] ,[phybuf] ,[acmode] ,[flags]
Arguments:
devnam
VMS usage: device_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Device name of the device to be allocated. The devnam argument is
the address of a character string descriptor pointing to the device
name string.
phylen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Word into which $ALLOC writes the length of the device name string
for the device it has allocated. The phylen is the address of this
word.
phybuf
VMS usage: device_name
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Buffer into which $ALLOC writes the device name string for the
device it has allocated. The phybuf is the address of a character
string descriptor pointing to this buffer.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the allocated device. The acmode
argument is a longword containing the access mode.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Longword of status flags indicating whether to interpret the devnam
argument as type of the device to be allocated. Only one flag
exists, bit 0. When it is set, the $ALLOC service allocates the
first available device having the type specified in the devnam
argument.
$ASCEFC
The Associate Common Event Flag Cluster service causes a named
common event flag cluster to be associated with a process for the
execution of the current image and to be assigned a process-local
cluster number for use with other event flag services. If the named
cluster does not exist but the process has suitable privilege, the
service creates the cluster.
Format:
SYS$ASCEFC efn ,name ,[prot] ,[perm]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of any event flag contained within the desired common event
flag cluster. The efn argument is a longword value specifying this
number.
name
VMS usage: ef_cluster_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the common event flag cluster with which to associate. The
name argument is the address of a character string descriptor
pointing to this name string.
prot
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Protection specifier that allows or disallows access to the common
event flag cluster by processes with the same UIC group number as
the creating process. The prot argument is a longword value, which
is interpreted as Boolean.
perm
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Permanent specifier that marks a common event flag cluster as either
permanent or temporary. The perm argument is a longword value,
which is interpreted as Boolean.
$ASCTIM
The Convert Binary Time to ASCII String service converts an absolute
or delta time from 64-bit system time format to an ASCII string.
Format:
SYS$ASCTIM [timlen] ,timbuf ,[timadr] ,[cvtflg]
Arguments:
timlen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length (in bytes) of the ASCII string returned by $ASCTIM. The
timlen argument is the address of a word containing this length.
timbuf
VMS usage: time_name
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Buffer into which $ASCTIM writes the ASCII string. The timbuf
argument is the address of a character string descriptor pointing to
the buffer.
timadr
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
Time value that $ASCTIM is to convert. The timadr argument is the
address of this 64-bit time value. A positive time value represents
an absolute time. A negative time value represents a delta time.
If a delta time is specified, it must be less than 10,000 days.
cvtflg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Conversion indicator specifying which date and time fields $ASCTIM
should return. The cvtflg argument is a longword value, which is
interpreted as Boolean. A value of 1 specifies that $ASCTIM should
return only the hour, minute, second, and hundredth of second
fields. A value of 0 (the default) specifies that $ASCTIM should
return the full date and time.
$ASCTOID
The Translate Identifier Name to Identifier service translates the
specified identifier name into its binary identifier value.
Format:
SYS$ASCTOID name ,[id] ,[attrib]
Arguments:
name
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Identifier name translated when $ASCTOID completes execution. The
name argument is the address of a descriptor pointing to the
identifier name.
id
VMS usage: rights_id
type: longword (unsigned)
access: write only
mechanism: by reference
Identifier value resulting when $ASCTOID completes execution. The
id argument is the address of a longword in which the identifier
value is written.
attrib
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Attributes associated with the identifier returned in id when
$ASCTOID completes execution. The attrib argument is the address of
a longword containing a bitmask specifying the attributes.
$ASSIGN
The Assign I/O Channel service (1) provides a process with an I/O
channel so that input/output operations can be performed on a device
or (2) establishes a logical link with a remote node on a network.
Format:
SYS$ASSIGN devnam ,chan ,[acmode] ,[mbxnam]
Arguments:
devnam
VMS usage: device_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the device to which $ASSIGN is to assign a channel. The
devnam argument is the address of a character string descriptor
pointing to the device name string.
chan
VMS usage: channel
type: word (unsigned)
access: write only
mechanism: by reference
Number of the channel that is assigned. The chan argument is the
address of a word into which $ASSIGN writes the channel number.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the channel. The acmode argument
specifies the access mode. The most privileged access mode used is
the access mode of the caller. I/O operations on the channel can
only be performed from equal and more privileged access modes.
mbxnam
VMS usage: device_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Logical name of the mailbox to be associated with the device. The
mbxnam argument is the address of a character string descriptor
pointing to the logical name string.
$BINTIM
The Convert ASCII String to Binary Time service converts an ASCII
string to an absolute or delta time value in the system 64-bit time
format suitable for input to the Set Timer ($SETIMR) or Schedule
Wakeup ($SCHDWK) services.
Format:
SYS$BINTIM timbuf ,timadr
Arguments:
timbuf
VMS usage: time_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
The timbuf argument specifies the address of a character string
descriptor pointing to the VAX/VMS time string. The VAX/VMS time
string specifies the absolute or delta time to be converted by
$BINTIM. The VAX/VMS Data Type Table describes the VAX/VMS time
string.
timadr
VMS usage: date_time
type: quadword (unsigned)
access: write only
mechanism: by reference
The timadr argument is the address of the VAX/VMS quadword system
time, which receives the converted time.
$BRKTHRU
The Breakthrough service sends a message to one or more terminals.
The $BRKTHRU service completes asynchronously; that is, it returns
to the caller after queueing the message request, without waiting
for the message to be written to the specified terminal(s).
For synchronous completion, use the Breakthrough and Wait
($BRKTHRUW) service. The $BRKTHRUW service is identical to the
$BRKTHRU service in every way except that $BRKTHRUW returns to the
caller after the message is written to the specified terminal(s).
The $BRKTHRU service supersedes the Broadcast ($BRDCST) service.
New programs should be written using $BRKTHRU, and old programs
using $BRDCST should be converted to use $BRKTHRU as convenient.
Format:
SYS$BRKTHRU [efn] ,msgbuf [,sendto] [,sndtyp] [,iosb]
[,carcon] [,flags] [,reqid] [,timout] [,astadr]
[,astprm]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when the message has been written
to the specified terminal(s). The efn argument is a longword
containing this number.
msgbuf
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Message text to be sent to the specified terminal(s). The msgbuf
argument is the address of a descriptor pointing to this message
text.
sendto
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of a single device (terminal) or single username to which to
send the message. The sendto argument is the address of a
descriptor pointing to this name.
sndtyp
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Terminal type to which $BRKTHRU is to send the message. The sndtyp
argument is a longword value specifying the terminal type.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block that is to receive the final completion status.
The iosb is the address of this quadword block.
carcon
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Carriage control specifier indicating the carriage control sequence
that is to follow the message that $BRKTHRU sends to the
terminal(s). The carcon argument is a longword containing the
carriage control specifier.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Flag bit mask specifying options for the $BRKTHRU operation. The
flags argument is a longword value that is the logical OR of each
desired flag option.
reqid
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Class requestor identification, which identifies to $BRKTHRU the
application (or image) that is calling $BRKTHRU. The reqid argument
is this longword identification value.
timout
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Timeout value, which is the number of seconds that must elapse
before an attempted write by $BRKTHRU to a terminal is considered to
have failed. The timout argument is this longword value (in
seconds).
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine to be executed after $BRKTHRU has sent the
message to the specified terminal(s). The astadr argument is the
address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST routine specified by the
astadr argument. The astprm argument specifies this longword
parameter.
$BRKTHRUW
The Breakthrough and Wait service sends a message to one or more
terminals.
The $BRKTHRUW service operates synchronously; that is, it returns to
the caller after the message has been sent to the specified
terminal(s).
For asynchronous operations, use the Breakthrough ($BRKTHRU)
service; $BRKTHRU returns to the caller after queueing the message
request, without waiting for the message to be delivered.
In all other respects, $BRKTHRUW is identical to $BRKTHRU. Refer to
the documentation of $BRKTHRU for all other information about the
$BRKTHRUW service.
The $BRKTHRU and $BRKTHRUW services supersede the Broadcast
($BRDCST) service. New code should be written using $BRKTHRU or
$BRKTHRUW, and old code using $BRDCST should be converted to use
$BRKTHRU or $BRKTHRUW as convenient. $BRDCST is now an obsolete
system service and will no longer be enhanced.
Format:
SYS$BRKTHRUW [efn] ,msgbuf [,sendto] [,sndtyp] [,iosb]
[,carcon] [,flags] [,reqid] [,timout] [,astadr]
[,astprm]
$CANCEL
The Cancel I/O On Channel service cancels all pending I/O requests
on a specified channel. In general, this includes all I/O requests
that are queued as well as the request currently in progress.
Format:
SYS$CANCEL chan
ARGUMENT
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
I/O channel on which I/O is to be canceled. The chan argument is a
longword containing the channel number.
$CANEXH
The Cancel Exit Handler service deletes an exit control block from
the list of control blocks for the calling access mode. Exit
control blocks are declared by the Declare Exit Handler ($DCLEXH)
service and are queued according to access mode in a last-in
first-out order.
Format:
SYS$CANEXH [desblk]
ARGUMENT
desblk
VMS usage: exit_handler_block
type: longword (unsigned)
access: read only
mechanism: by reference
Control block describing the exit handler to be canceled. The
desblk is the address of this control block. If desblk is not
specified or is specified as 0, all exit control blocks are canceled
for the current access mode.
$CANTIM
The Cancel Timer Request service cancels all or a selected subset of
the Set Timer requests previously issued by the current image
executing in a process. Cancellation is based on the request
identification specified in the Set Timer ($SETIMR) service. If
more than one timer request was given the same request
identification, all requests with that request identification are
canceled.
Format:
SYS$CANTIM [reqidt] ,[acmode]
Arguments:
reqidt
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
Request identification of the timer request(s) to be canceled. The
reqidt argument is a longword containing this identification. If
reqidt is specified as 0 (the default), all timer requests are
canceled.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode of the request(s) to be canceled. The acmode argument
is a longword containing the access mode.
$CANWAK
The Cancel Wakeup service removes all scheduled wake-up requests for
a process from the timer queue, including those made by the caller
or by other processes. Scheduled wake-up requests are made with the
Schedule Wakeup ($SCHDWK) service.
Format:
SYS$CANWAK [pidadr] ,[prcnam]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process for which wakeups are to
be canceled. The pidadr is the address of a longword specifying the
PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the process for which wakeups are to be canceled. The
prcnam argument is the address of a character string descriptor
pointing to the process name string.
$CHANGE_ACL
The Change Access Control List service creates or modifies an
object's access control list.
Format:
SYS$CHANGE_ACL [chan] ,objtyp ,[objnam] ,itmlst ,[acmode]
,[nullarg] ,[contxt]
Arguments:
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
Number of the I/O channel assigned to the object whose ACL is
modified when $CHANGE_ACL completes execution. The chan argument is
a word containing the number of the channel. If objnam is
specified, chan must be omitted or specified as zero.
objtyp
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Type of object whose ACL is modified when $CHANGE_ACL completes
execution. The objtyp argument is the address of a longword
containing a value indicating whether the object is a file or a
device. The symbols are defined in the system macro library
($ACLDEF).
objnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the object whose ACL is modified when $CHANGE_ACL completes
execution. The objnam argument is the address of a descriptor
pointing to a character text string containing the name of the
object. The maximum length of objnam depends on the object.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Modifications to be made to the ACL when $CHANGE_ACL completes
execution. The itmlst argument is the address of a variable length
data structure defining the changes to be made.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by reference
Access mode to use in checking file access protection. The acmode
argument is the address of a longword containing the access mode.
Acmode defaults to kernel mode; however, the system compares acmode
against the caller's access mode and uses the least privileged mode.
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
contxt
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context value that points to an ACE. The contxt argument is the
address of a longword containing the context value.
$CHECK_ACCESS
The Check Access system service determines, on behalf of a
third-party user, whether the user can access the object specified.
Format:
SYS$CHECK_ACCESS objtyp ,objnam ,usrnam ,itmlst
Arguments:
objtyp
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Type of object being accessed. The objtyp argument is the address
of a longword containing a value specifying the type of object. The
symbols are defined in the system macro library ($ACLDEF).
objnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the object being accessed. The objnam argument is the
address of a descriptor pointing to a character text string
containing the name of the object. The maximum length of objnam
depends on the object.
usrnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the user attempting access. The usrnam argument is the
address of a descriptor pointing to a character text string
containing the user name of the user attempting to gain access to
the specified object. The user name string may contain a maximum of
12 alphanumeric characters.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Attributes describing how the object is to be accessed and
information returned after $CHECK_ACCESS performs the protection
check (for instance, security alarm information).
$CHKPRO
The Check Access Protection system service determines whether an
accessor with the specified rights and privileges can access an
object with the specified attributes.
Format:
SYS$CHKPRO itmlst
Arguments:
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Protection attributes of the object and the rights and privileges of
the accessor used when $CHKPRO determines if the accessor can access
the object. The itmlst argument is the address of an item list of
descriptors used to specify the protection attributes of the object
and the rights and privileges of the accessor.
$CLREF
The Clear Event Flag service clears (sets to 0) an event flag in a
local or common event flag cluster.
Format:
SYS$CLREF efn
Argument
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be cleared. The efn argument is a
longword containing this number.
$CMEXEC
The Change to Executive Mode service changes the access mode of the
calling process to executive mode. This service allows a process to
change its access mode to executive, execute a specified routine,
and then return to the access mode in effect before the call was
issued.
Format:
SYS$CMEXEC routin ,[arglst]
Arguments:
routin
VMS usage: procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by reference
Routine to be executed while the process is in executive mode. The
routin argument is the address of the entry point to this routine.
arglst
VMS usage: arg_list
type: longword (unsigned)
access: read only
mechanism: by reference
Argument list to be passed to the routine specified by the routin
argument. The arglst argument is the address of this argument list.
$CMKRNL
The Change to Kernel Mode service changes the access mode of the
calling process to kernel mode. This service allows a process to
change its access mode to kernel, execute a specified routine, and
then return to the access mode in effect before the call was issued.
Format:
SYS$CMKRNL routin ,[arglst]
Arguments:
routin
VMS usage: procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by reference
Routine to be executed while the process is in kernel mode. The
routin argument is the address of the entry point to this routine.
arglst
VMS usage: arg_list
type: longword (unsigned)
access: read only
mechanism: by reference
Argument list to be passed to the routine specified by the routin
argument. The arglst argument is the address of this argument list.
$CNTREG
The Contract Program/Control Region service deletes a specified
number of pages from the current end of the program or control
region of a process's virtual address space. The deleted pages
become inaccessible, and references to them cause access violations.
Format:
SYS$CNTREG pagcnt ,[retadr] ,[acmode] ,[region]
Arguments:
pagcnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of pages to be deleted from the current end of the program or
control region. The pagcnt argument is a longword specifying this
number.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference
Starting and ending pages of the deleted area. The retadr argument
is the address of a two-longword array to receive the virtual
addresses of the starting page and ending page of the deleted area.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode of the owner of the pages to be deleted. The acmode
argument is a longword containing the access mode.
region
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Indicator specifying which region of memory (P0 or P1) is to be
contracted. The region argument is a longword containing the
indicator. A value of 0 (the default) indicates that the program
region (P0 region) is to be contracted, and a value of 1 indicates
that the control region (P1 region) is to be contracted.
$COMMIT_RU
Applicable only if you have the RMS Journaling option. See the VAX
RMS Journaling Manual.
The Commit Recovery Unit Service is used only after a call to the
Prepare Recovery Unit Service in an application using RMS Journaling
or after a call to the $END_RU service that has returned a status of
RUF$_RUNOTCOM. When you use $COMMIT_RU, the recovery unit is
terminated, and the records that were modified within the recovery
unit are available for further processing. If no processing takes
place in your application between the $PREPARE_RU and $COMMIT_RU
calls, you can replace these two calls with the single $END_RU call.
Format:
SYS$COMMIT_RU ru_handle
Arguments:
ru_handle
VMS Usage: ru_handle
type: longword (unsigned)
access: read only
mechanism: by reference
The ru_handle argument is the address of an unsigned longword that
contains the recovery unit handle returned by the $START_RU system
service.
$CRELNM
The Create Logical Name service creates a logical name and specifies
its equivalence name(s).
Format:
SYS$CRELNM [attr] ,tabnam ,lognam ,[acmode] ,[itmlst]
Arguments:
attr
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attributes to be associated with the logical name. The attr
argument is the address of a longword bit mask specifying these
attributes.
tabnam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the table in which to create the logical name. The tabnam
argument is the address of a descriptor that points to the name of
this table. This argument is required.
lognam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the logical name to be created. The lognam argument is the
address of a descriptor that points to the logical name string.
Logical name strings of logical names created within either the
system or process directory table must consist of alphanumeric
characters, dollar signs, and underscores; the maximum length is 31
characters. The maximum length of logical name strings created
within other tables is 255 characters with no restrictions on the
types of characters that can be used. This argument is required.
acmode
VMS usage: access_mode
type: byte (unsigned)
access: read only
mechanism: by reference
Access mode to be associated with the logical name. The acmode
argument is the address of a byte that specifies the access mode.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list describing the equivalence name(s) to be defined for the
logical name and information to be returned to the caller. The
itmlst argument is the address of a list of item descriptors, each
of which specifies information about an equivalence name. The list
of item descriptors is terminated by a longword of 0. This argument
is required.
$CRELNT
The Create Logical Name Table service creates a process-private or
shareable logical name table.
Format:
SYS$CRELNT [attr] ,[resnam] ,[reslen] ,[quota]
,[promsk] ,[tabnam] ,partab ,[acmode]
Arguments:
attr
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attributes to affect the creation of the logical name table and to
be associated with the newly created logical name table. The attr
argument is the address of a longword bit mask specifying these
attributes.
resnam
VMS usage: logical_name
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Name of the newly created logical name table, returned by $CRELNT.
The resnam argument is the address of a descriptor pointing to this
name. The name is a character string whose maximum length is 31
characters.
reslen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length in bytes of the name of the newly created logical name table,
returned by $CRELNT. The reslen argument is the address of a word
to receive this length.
quota
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Maximum number of bytes of memory to be allocated for logical names
contained in this logical name table. The quota argument is the
address of a longword specifying this value.
promsk
VMS usage: file_protection
type: word (unsigned)
access: read only
mechanism: by reference
Protection mask to be associated with the newly created shareable
logical name table. The promsk argument is the address of a word
that contains a value that represents four 4-bit fields, where each
field describes the type of access allowed for system, owner, group,
and world users.
tabnam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
The name of the new logical name table. The tabnam argument is the
address of a character string descriptor pointing to this name
string. Table names are contained in either the process or system
directory table (LNM$PROCESS_DIRECTORY or LNM$SYSTEM_DIRECTORY).
Therefore table names must consist of alphanumeric characters,
dollar signs, and underscores; the maximum length is 31 characters.
partab
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Parent table name. The partab argument is the address of a
character string descriptor pointing to this name string. The only
valid values for this argument are the names of the directory tables
LNM$PROCESS_DIRECTORY or LNM$SYSTEM_DIRECTORY. SYSPRV privilege is
required to specify the system directory table LNM$SYSTEM_DIRECTORY.
This argument is required.
acmode
VMS usage: access_mode
type: byte (unsigned)
access: read only
mechanism: by reference
Access mode to be associated with the newly created logical name
table. The acmode argument is the address of a byte containing this
access mode. The $PSLDEF macro defines symbolic names for the four
access modes.
$CREMBX
The Create Mailbox and Assign Channel service creates a virtual
mailbox device named MBAn: and assigns an I/O channel to it. The
system provides the unit number, n, when it creates the mailbox. If
a mailbox with the specified name already exists, the $CREMBX
service assigns a channel to the existing mailbox.
Format:
SYS$CREMBX [prmflg] ,chan ,[maxmsg] ,[bufquo] ,[promsk]
,[acmode] ,[lognam]
Arguments:
prmflg
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Indicator specifying whether the created mailbox is to be permanent
or temporary. The prmflg argument is a byte value. A value of 1
specifies a permanent mailbox; a value of 0, which is the default,
specifies a temporary mailbox. Any other values result in an error.
chan
VMS usage: channel
type: word (unsigned)
access: write only
mechanism: by reference
Channel number assigned by $CREMBX to the mailbox. The chan
argument is the address of a word into which $CREMBX writes the
channel number.
maxmsg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Maximum size (in bytes) of a message that can be sent to the
mailbox. The maxmsg argument is a longword value containing this
size. If maxmsg is not specified or is specified as 0, VAX/VMS
provides a default value.
bufquo
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of bytes of system dynamic memory that can be used to buffer
messages sent to the mailbox. The bufquo argument is a longword
value containing this number. If bufquo is not specified or is
specified as 0, VAX/VMS provides a default value.
promsk
VMS usage: file_protection
type: longword (unsigned)
access: read only
mechanism: by value
Protection mask to be associated with the created mailbox. The
promsk argument is a longword value that is the combined value of
the bits set in the protection mask. Cleared bits grant access and
set bits deny access to each of the four classes of user: world,
group, owner, and system. The following diagram depicts these
protection bits.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the channel to which the mailbox
is assigned. The acmode argument is a longword containing the
access mode.
lognam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Logical name to be assigned to the mailbox. The lognam argument is
the address of a character string descriptor pointing to the logical
name string.
$CREPRC
The Create Process service creates a subprocess or detached process
on behalf of the calling process.
Format:
SYS$CREPRC [pidadr] ,[image] ,[input] ,[output] ,[error]
,[prvadr] ,[quota] ,[prcnam] ,[baspri] ,[uic]
,[mbxunt] ,[stsflg]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: write only
mechanism: by reference
Process identification (PID) of the newly created process. The
pidadr argument is the address of a longword into which $CREPRC
writes the PID.
image
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the image to be activated in the newly created process. The
image argument is the address of a character string descriptor
pointing to the file specification of the image.
input
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Equivalence name to be associated with the logical name SYS$INPUT in
the logical name table of the created process. The input argument
is the address of a character string descriptor pointing to the
equivalence name string.
output
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Equivalence name to be associated with the logical name SYS$OUTPUT
in the logical name table of the created process. The output
argument is the address of a character string descriptor pointing to
the equivalence name string.
error
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Equivalence name to be associated with the logical name SYS$ERROR in
the logical name table of the created process. The error argument
is the address of a character string descriptor pointing to the
equivalence name string.
prvadr
VMS usage: mask_privileges
type: quadword (unsigned)
access: read only
mechanism: by reference
Privileges to be given to the created process. The prvadr argument
is the address of a quadword bit vector wherein each bit corresponds
to a privilege; setting a bit gives the privilege.
quota
VMS usage: item_quota_list
type: longword (unsigned)
access: read only
mechanism: by reference
Process quotas to be established for the created process; these
quotas limit the created process's use of system resources. The
quota argument is the address of a list of quota descriptors, where
each quota descriptor consists of a 1-byte quota name followed by a
longword that specifies the desired value for that quota. The list
of quota descriptors is terminated by the symbolic name
PQL$_LISTEND.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name to be assigned to the created process. The prcnam is
the address of a character string descriptor pointing to a 1- to
15-character process name string.
baspri
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Base priority to be assigned to the created process. The baspri
argument is a longword value in the range 0 to 31, where 31 is the
highest possible priority and 0 is the lowest. Normal priorities
are in the range 0 through 15, and real-time priorities are in the
range 16 through 31.
uic
VMS usage: uic
type: longword (unsigned)
access: read only
mechanism: by value
User identification code (UIC) to be assigned to the created
process. The uic argument is a longword value containing the UIC.
mbxunt
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by value
Unit number of a mailbox to receive a termination message when the
created process is deleted. The mbxunt argument is a word
containing this number.
stsflg
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Options selected for the created process. The stsflg argument is a
longword bit vector wherein a bit corresponds to an option. Only
bits 0 to 10 are used; bits 11 to 31 are reserved and must be 0.
$CREATE_RDB
The Create Rights Database service initializes a rights database.
Format:
SYS$CREATE_RDB [sysid]
Arguments:
sysid
VMS usage: system_access_id
type: quadword (unsigned)
access: read only
mechanism: by reference
System identification value associated with the rights database when
$CREATE_RDB completes execution. The sysid argument is the address
of quadword containing the system identification value. If sysid is
omitted, the current system time in 64-bit format is used.
$CRETVA
The Create Virtual Address Space service adds a range of demand-zero
allocation pages to a process's virtual address space for the
execution of the current image.
Format:
SYS$CRETVA inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Address of a two-longword array containing the starting and ending
virtual addresses of the pages to be created. If the starting and
ending virtual addresses are the same, a single page is created.
Only the virtual page number portion of the virtual addresses is
used; the low-order 9 bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference--array reference
or descriptor
Address of a two-longword array to receive the starting and ending
virtual addresses of the pages actually created.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode and protection for the new pages. The acmode argument
is a longword containing the access mode.
$CRMPSC
The Create and Map Section service allows a process to associate
(map) a section of its address space with (1) a specified section of
a file (a disk file section) or (2) with specified physical
addresses represented by page frame numbers (a page frame section).
This service also allows the process to create either type of
section, and to specify that that section be available only to the
creating process (private section) or to all processes that map to
it (global section).
Format:
SYS$CRMPSC [inadr] ,[retadr] ,[acmode] ,[flags] ,[gsdnam]
,[ident] ,[relpag] ,[chan] ,[pagcnt] ,[vbn] ,[prot]
,[pfc]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses into which the section is to
be mapped. The inadr is the address of a two-longword array
containing, in order, the starting and the ending process virtual
addresses. Only the virtual page number portion of each virtual
address is used; the low-order 9 bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by
reference--array reference or descriptor
Starting and ending process virtual addresses into which the section
was actually mapped by $CRMPSC. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode that is to be the owner of the pages created during the
mapping. The acmode argument is a longword containing the access
mode.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Flag mask specifying the type of section to be created or mapped to,
as well as its characteristics. The flags argument is a longword
bit vector wherein each bit corresponds to a flag. The $SECDEF
macro defines a symbolic name for each flag. The flags argument is
constructed by performing a logical OR operation on the symbol names
for all desired flags.
gsdnam
VMS usage: section_name
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
Name of the global section. The gsdnam is the address of a
character string descriptor pointing to this name string.
ident
VMS usage: section_id
type: quadword (unsigned)
access: read only
mechanism: by reference
Identification value specifying the version number of a global
section, and, for processes mapping to an existing global section,
the criteria for matching the identification. The ident argument is
the address of a quadword structure containing three fields.
relpag
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Relative page number within the global section of the first page in
the section to be mapped. The relpag argument is a longword
containing this page number.
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
Number of the channel on which the file has been accessed. The chan
argument is a word containing this number.
pagcnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of pages in the section. The pagcnt argument is a longword
containing this number.
vbn
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Virtual block number in the file that marks the beginning of the
section. The vbn argument is a longword containing this number. If
vbn is not specified or is specified as 0 (the default), the section
is created beginning with the first virtual block in the file.
prot
VMS usage: file_protection
type: longword (unsigned)
access: read only
mechanism: by value
Numeric value representing the protection mask to be applied to the
global section. This value is ORed with the protection mask
associated with the file; if the file protection does not allow
access to a particular category of user and the protection mask
allows access, access is denied.
pfc
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Page fault cluster size. If specified, the cluster size indicates
how many pages are to be brought into memory when a page fault
occurs for a single page. This argument is not used for physical
page frame sections or for global sections in memory shared by
multiple processors.
$DACEFC
The Disassociate Common Event Flag Cluster service releases the
calling process's association with a common event flag cluster.
Format:
SYS$DACEFC efn
Argument
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of any event flag in the common cluster to be disassociated.
The efn argument is a longword containing this number. The number
must be in the range of 64 through 95 for cluster 2, and 96 through
127 for cluster 3.
$DALLOC
The Deallocate Device service deallocates a previously allocated
device. The issuing process relinquishes exclusive use of the
device thus allowing other processes to assign or allocate that
device.
Format:
SYS$DALLOC [devnam] ,[acmode]
Arguments:
devnam
VMS usage: device_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the device to be deallocated. The devnam argument is the
address of a character string descriptor pointing to the device name
string. The string may be either a physical device name or a
logical name. If it is a logical name, it must translate to a
physical device name.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode on behalf of which the deallocation is to be performed.
The acmode argument is a longword containing the access mode.
$DASSGN
The Deassign I/O Channel service deassigns (releases) an I/O channel
that was acquired using the Assign I/O Channel ($ASSIGN) service.
Format:
SYS$DASSGN chan
Argument
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
Number of the I/O channel to be deassigned. The chan argument is a
word containing this number.
$DCLAST
The Declare AST service queues an AST for the calling access mode or
for a less privileged access mode. For example, a routine executing
in supervisor mode can declare an AST for either supervisor or user
mode.
Format:
SYS$DCLAST astadr ,[astprm] ,[acmode]
Arguments:
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack
unwinding
mechanism: by reference
AST service routine to be executed. The astadr argument is the
address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST routine specified by the
astadr argument. The astprm argument is a longword containing this
parameter.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode for which the AST is to be declared. The most
privileged access mode used is the access mode of the caller. The
resultant mode is the access mode for which the AST is declared.
$DCLCMH
The Declare Change Mode or Compatibility Mode Handler service
specifies the address of a routine to receive control when (1) a
Change Mode to User or Change Mode to Supervisor instruction trap
occurs, or (2) a compatibility mode fault occurs.
Format:
SYS$DCLCMH addres ,[prvhnd] ,[type]
Arguments:
addres
VMS usage: procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
Routine to receive control when a change mode trap or a
compatibility mode fault occurs. The addres argument is the address
of the entry mask to this routine.
prvhnd
VMS usage: address
type: longword (unsigned)
access: write only
mechanism: by reference
Address of a previously declared handler. The prvhnd argument is
the address of a longword containing the address of the previously
declared handler.
type
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Handler type indicator. The type argument is a longword value. The
value 0 (the default) indicates that a change mode handler is to be
declared for the access mode at which the request is issued; the
value 1 specifies that a compatibility mode handler is to be
declared.
$DCLEXH
The Declare Exit Handler service declares an exit handling routine
that will receive control when an image exits. Image exit normally
occurs when the image currently executing in a process returns
control to the operating system. Image exit may also occur when the
Exit ($EXIT) or Force Exit ($FORCEX) services are called.
Format:
SYS$DCLEXH desblk
Argument
desblk
VMS usage: exit_handler_block
type: longword (unsigned)
access: read only
mechanism: by reference
Exit handler control block. The desblk is the address of this
control block.
$DELLNM
The Delete Logical Name service deletes all logical names with the
specified name at the specified access mode or outer access mode, or
it deletes all the logical names with the specified access mode or
outer access mode in a specified table. If any logical names being
deleted are also the names of logical name tables, then all of the
logical names contained within those tables and all of their
subtables are also deleted.
Format:
SYS$DELLNM tabnam ,[lognam] ,[acmode]
Arguments:
tabnam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
Name of a logical name table or name of a list of tables in which to
search for the logical name that is to be deleted. The tabnam
argument is the address of a descriptor that points to the table
name. This argument is required.
lognam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
Logical name to be deleted. The lognam argument is the address of a
descriptor that points to the logical name string.
acmode
VMS usage: access_mode
type: byte (unsigned)
access: read only
mechanism: by reference
Access mode to be used in the delete operation. The acmode argument
is the address of a byte containing this access mode. The $PSLDEF
macro defines symbolic names for the four access modes.
$DELMBX
The Delete Mailbox service marks a permanent mailbox for deletion.
The actual deletion of the mailbox and of its associated logical
name assignment occur when no more I/O channels are assigned to the
mailbox.
Format:
SYS$DELMBX chan
Argument
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
Number of the channel assigned to the mailbox that is to be deleted.
The chan is a word containing this number.
$DELPRC
The Delete Process service allows a process to delete itself or
another process.
Format:
SYS$DELPRC [pidadr] ,[prcnam]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process to be deleted. The
pidadr argument is the address of a longword that contains the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
Process name of the process to be deleted. The prcnam is the
address of a character string descriptor pointing to a 1- to
15-character process name string.
$DELTVA
The Delete Virtual Address Space service deletes a range of
addresses from a process's virtual address space. Upon successful
completion of the service, the deleted pages are inaccessible, and
references to them cause access violations.
Format:
SYS$DELTVA inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses of the pages to be deleted.
The inadr argument is the address of a two-longword array
containing, in order, the starting and the ending process virtual
addresses. If the starting and ending virtual addresses are the
same, a single page is deleted. Only the virtual page number
portion of each virtual address is used; the low-order 9 bits are
ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference
Starting and ending process virtual addresses of the pages that
$DELTVA has actually deleted. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode on behalf of which the service is to be performed. The
acmode argument is a longword containing the access mode.
$DEQ
The Dequeue Lock Request service dequeues (unlocks) granted locks;
dequeues the sublocks of a lock; or cancels an ungranted lock
request. The calling process must have previously acquired the lock
or queued the lock request by calling the Enqueue Lock Request
($ENQ) service.
The $DEQ, $ENQ, $ENQW (Enqueue Lock Request and Wait), and $GETLKI
(Get Lock Information) services together provide the user interface
to the VAX/VMS lock management facility.
Format:
SYS$DEQ [lkid] [,valblk] [,acmode] [,flags]
Arguments:
lkid
VMS usage: lock_id
type: longword (unsigned)
access: read only
mechanism: by value
Lock identification of the lock to be dequeued. The lkid argument
specifies this lock identification.
valblk
VMS usage: lock_value_block
type: longword (unsigned)
access: modify
mechanism: by reference
Lock value block for the resource associated with the lock to be
dequeued. The valblk argument is the address of the 16-byte lock
value block. This argument is not used when the LCK$M_DEQALL flag
is specified.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode of the lock to be dequeued. The acmode argument is a
longword containing the access mode.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Flags specifying options for the $DEQ operation. The flags argument
is a longword bit mask that is the logical OR of each bit set, where
each bit corresponds to an option.
$DGBLSC
The Delete Global Section service marks an existing permanent global
section for deletion. The actual deletion of the global section
takes place when all processes that have mapped the global section
have deleted the mapped pages.
Format:
SYS$DGBLSC [flags] ,gsdnam ,[ident]
Arguments:
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Mask indicating global section characteristics. The flags argument
is a longword value. A value of 0 (the default) specifies a group
global section; a value of SEC$M_SYSGBL specifies a system global
section.
gsdnam
VMS usage: section_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the global section to be deleted. The gsdnam is the address
of a character string descriptor pointing to this name string.
ident
VMS usage: section_id
type: quadword (unsigned)
access: read only
mechanism: by reference
Identification value specifying the version number of the global
section to be deleted and the matching criteria to be applied. The
ident argument is the address of a quadword structure containing
three fields.
$DISMOU
The Dismount Volume service dismounts a mounted volume or volume
sets.
Format:
SYS$DISMOU devnam ,[flags]
Arguments:
devnam
VMS usage: device_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Device name of the device to be dismounted. The devnam argument is
the address of a character string descriptor pointing to the device
name string. The string may be either a physical device name or a
logical name. If it is a logical name, it must translate to a
physical device name.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
A longword bit vector specifying options for the dismount operation.
The flags argument is a longword bit vector wherein a bit, when set,
selects the corresponding option. Each bit has a symbolic name;
these names are defined by the $DMTDEF macro.
$DLCEFC
The Delete Common Event Flag Cluster service marks a permanent
common event flag cluster for deletion. The cluster is actually
deleted when no more processes are associated with it.
Format:
SYS$DLCEFC name
Argument
name
VMS usage: ef_cluster_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the common event flag cluster to be deleted. The name
argument is the address of a character string descriptor pointing to
the name of the cluster.
$END_RU
Applicable only if you have the RMS Journaling option. See the VAX
RMS Journaling Manual.
The End Recovery Unit Service denotes the end of a recovery unit in
applications that use RMS Journaling. Use the $END_RU service when
you reach the end of a transaction (or other logical point in the
course of an application where data integrity would not be
compromised in the event of a system crash). The $END_RU service is
actually a combination of two other recovery unit services,
$PREPARE_RU and $COMMIT_RU. When you use $COMMIT_RU, the recovery
unit is terminated, and the records that were modified within the
recovery unit are available for further processing.
Format:
SYS$END_RU ru_handle
Arguments:
ru_handle
VMS Usage: ru_handle
type: longword (unsigned)
access: read only
mechanism: by reference
The ru_handle argument is the address of an unsigned longword that
contains the recovery unit handle returned by the $START_RU system
service.
$ENQ
The Enqueue Lock Request service queues a new lock or lock
conversion on a resource.
The $ENQ service completes asynchronously; that is, it returns to
the caller after queueing the lock request, without waiting for the
lock to be either granted or converted.
For synchronous completion, use the Enqueue Lock Request and Wait
($ENQW) service. The $ENQW service is identical to the $ENQ service
in every way except that $ENQW returns to the caller when the lock
is either granted or converted.
The $ENQ, $ENQW, $DEQ (Dequeue Lock Request), and $GETLKI (Get Lock
Information) services together provide the user interface to the
VAX/VMS lock management facility.
Format:
SYS$ENQ [efn] ,lkmode ,lksb [,flags] [,resnam]
[,parid] [,astadr] [,astprm] [,blkast]
[,acmode] [,nullarg]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when the lock request has been
granted. The efn argument is a longword containing this number.
lkmode
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Lock mode requested. The lkmode argument is a longword specifying
this lock mode.
lksb
VMS usage: lock_status_block
type: longword (unsigned)
access: write only
mechanism: by reference
Lock status block in which $ENQ writes the final completion status
of the operation. The lksb argument is the address of the 8-byte
lock status block.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Flags specifying options for the $ENQ operation. The flags argument
is a longword bit mask that is the logical OR of each bit set, where
each bit corresponds to an option.
resnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the resource to be locked by this lock. The resnam argument
is the address of a character string descriptor pointing to this
name. The name string may be from 1 to 31 bytes in length.
parid
VMS usage: lock_id
type: longword (unsigned)
access: read only
mechanism: by value
Lock identification of the parent lock. The parid argument is a
longword containing this identification value.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack
unwinding
mechanism: by reference
AST service routine to be executed when the lock is either granted
or converted. The astadr argument is the address of the entry mask
of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST routine specified by the
astadr argument. The astprm argument specifies this longword
parameter.
blkast
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack
unwinding
mechanism: by reference
Blocking AST routine to be called whenever this lock is granted and
is blocking any other lock requests. The blkast argument is the
address of the entry mask to this routine.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the lock. The acmode argument is
a longword containing the access mode.
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
$ENQW
The Enqueue Lock Request and Wait service queues a lock on a
resource.
The $ENQW service completes synchronously; that is, it returns to
the caller when the lock has been either granted or converted.
For asynchronous completion, use the Enqueue Lock Request ($ENQ)
service; $ENQ returns to the caller after queueing the lock request,
without waiting for the lock to be either granted or converted.
In all other respects, $ENQW is identical to $ENQ. Refer to the
documentation of $ENQ for all other information about the $ENQW
service.
The $ENQ, $ENQW, $DEQ (Dequeue Lock Request), and $GETLKI (Get Lock
Information) services together provide the user interface to the
VAX/VMS lock management facility.
Format:
SYS$ENQW [efn] ,lkmode ,lksb [,flags] [,resnam] [,parid]
[,astadr] [,astprm] [,blkast] [,acmode] [,nullarg]
$ERAPAT
The Get Security Erase Pattern service generates a security erase
pattern. A user-written erase routine can then write this pattern
into areas of memory containing sensitive data that is no longer in
use to prevent the inadvertent disclosure of the sensitive data.
Format:
SYS$ERAPAT [type] ,[count] ,[patadr]
Arguments:
type
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Type of storage to be written over with the erase pattern. The type
argument is a longword containing the type of storage.
count
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
The number of times that $ERAPAT has been called in a single
security erase operation. The count argument is a longword
containing the iteration count.
patadr
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
The security erase pattern to be written. The patadr is the address
of a longword into which the security erase pattern is to be
written.
$EXIT
The Exit service is used by the operating system to initiate image
run-down when the current image in a process completes execution.
Control normally returns to the command interpreter.
Format:
SYS$EXIT [code]
Argument
code
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by value
Longword value to be saved in the process header as the completion
status of the current image. If not specified in a macro call, a
value of 1 is passed as the completion code for VAX MACRO and VAX
BLISS-32 and, a value of 0 is passed for other languages. This
value can be tested at the command level to provide conditional
command execution.
$EXPREG
The Expand Program/Control Region service adds a specified number of
new virtual pages to a process's program region or control region
for the execution of the current image. Expansion occurs at the
current end of that region's virtual address space.
Format:
SYS$EXPREG pagcnt ,[retadr] ,[acmode] ,[region]
Arguments:
pagcnt
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number of pages to add to the current end of the program or control
region. The pagcnt argument is a longword value containing this
number.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference
Starting and ending process virtual addresses of the pages that
$EXPREG has actually added. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the newly added pages. The acmode
argument is a longword containing the access mode.
region
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Number specifying which program region is to be expanded. The
region argument is a longword value. A value of 0 (the default)
specifies that the program region (P0 region) is to be expanded. A
value of 1 specifies that the control region (P1 region) is to be
expanded.
$FAO
The Formatted ASCII Output service (1) converts a binary value into
an ASCII character string in decimal, hexadecimal, or octal notation
and returns the character string in an output string and (2) inserts
variable character string data into an output string.
The Formatted ASCII Output with List Parameter ($FAOL) service
provides an alternate way to specify input parameters for a call to
the $FAO system service. The formats for both $FAO and $FAOL appear
below.
Format:
SYS$FAO ctrstr ,[outlen] ,outbuf ,[p1]...[Pn]
SYS$FAOL ctrstr ,[outlen] ,outbuf [,prmlst]
Arguments:
ctrstr
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Control string passed to $FAO. The ctrstr argument is the address
of a character string descriptor pointing to the control string.
outlen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length in bytes of the fully formatted output string returned by
$FAO. The outlen argument is the address of a word containing this
value.
outbuf
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Output buffer into which $FAO writes the fully formatted output
string. The outbuf argument is the address of a character string
descriptor pointing to the output buffer.
p1 to pn
VMS usage: varying_arg
type: longword (unsigned)
access: read only
mechanism: by value
FAO directive parameter(s). The p1 argument is a longword
containing the parameter needed by the first FAO directive
encountered in the control string, the p2 argument is a longword
containing the parameter needed for the second FAO directive, and so
on for the remaining arguments up to and including p20. If an FAO
directive does not require a parameter, that FAO directive is
processed without reading a parameter from the argument list.
prmlst
VMS usage: vector_longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by
reference
List of FAO directive parameters to be passed to the $FAOL service.
The prmlst argument is the address of a list of longwords wherein
each longword is a parameter. $FAOL processes these parameters
sequentially as it encounters, in the control string, FAO directives
that require parameters.
$FILESCAN
The Scan String for File Specification service searches a string for
a file specification and parses the components of that file
specification.
Format:
SYS$FILESCAN srcstr ,valuelst ,[fldflags]
Arguments:
srcstr
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
String to be searched for the file specification. The srcstr
argument is the address of a descriptor pointing to this string.
valuelst
VMS usage: item_list_2
type: longword (unsigned)
access: modify
mechanism: by reference
Item list specifying which components of the file specification are
to be returned by $FILESCAN; the components are the node, device,
directory, file name, file type and version number. The itmlst
argument is the address of a list of item descriptors wherein each
item descriptor specifies one component. The list of item
descriptors is terminated by a longword of 0.
fldflags
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Longword flag mask in which $FILESCAN sets a bit for each file
specification component found in the input string. The fldflags
argument is the address of this longword flag mask.
$FIND_HELD
The Find Identifiers Held by User service returns the identifier(s)
held by a specified holder. When called repeatedly with a context
longword, it returns in succession all the identifiers held by the
specified holder.
Format:
SYS$FIND_HELD holder ,[id] ,[attrib] ,[contxt]
Arguments:
holder
VMS usage: rights_holder
type: quadword (unsigned)
access: read only
mechanism: by reference
Holder whose identifier(s) are to be found when $FIND_HELD completes
execution. The holder argument is the address of a quadword data
structure containing the holder identifier. This quadword data
structure consists of a longword containing the holder UIC, followed
by a longword containing the value zero.
id
VMS usage: rights_id
type: longword (unsigned)
access: write only
mechanism: by reference
Identifier value found when $FIND_HELD completes execution. The id
argument is the address of a longword containing the identifier
value with which the holder is associated.
attrib
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Attributes associated with the identifier returned in id when the
$ADD_HOLDER completes execution. The attrib argument is the address
of a longword containing a bitmask specifying the attributes.
contxt
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context value used when repeatedly calling $FIND_HELD. The contxt
argument is the address of a longword used while searching for all
identifiers. The context value must be initialized to zero, and the
resulting context of each call to $FIND_HELD must be presented to
each subsequent call. Once contxt has been passed to SYS$FIND_HELD,
do not modify its value.
$FIND_HOLDER
The Find Holder of Identifier service returns the holder of a
specified identifier. When called repeatedly with a context
longword, it returns all the holders of the specified identifier in
the order in which they were added.
Format:
SYS$FIND_HOLDER id ,[holder] ,[attrib] ,[contxt]
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Binary identifier value whose holder(s) is found by $FIND_HOLDER.
The id argument is a longword containing the binary identifier
value.
holder
VMS usage: rights_holder
type: quadword (unsigned)
access: write only
mechanism: by reference
Holder identifier returned when $FIND_HOLDER completes execution.
The holder argument is the address of a quadword containing the
holder identifier. The first longword contains the UIC of the
holder with the high-order word containing the group number and the
low-order word containing the member number. The second longword
contains the value zero.
attrib
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Mask of attributes associated with the holder record specified by
holder. The attrib argument is the address of a longword containing
the attribute mask.
contxt
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context value used while searching for all the holders of the
specified identifier when executing $FIND_HOLDER. The contxt
argument is the address of a longword containing the context value.
When calling $FIND_HOLDER repeatedly, contxt must be set initially
to zero and the resulting context of each call to $FIND_HOLDER must
be presented to each subsequent call. Once the argument has been
passed to SYS$FIND_HOLDER, do not modify its value.
$FINISH_RDB
The Terminate Rights Database Context service deallocates the record
stream and clears the context value used with $FIND_HELD,
$FIND_HOLDER, or $IDTOASC.
Format:
SYS$FINISH_RDB contxt
Arguments:
contxt
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context value to be cleared when $FINISH_RDB completes execution.
The contxt argument is a longword containing the address of the
context value.
$FORCEX
The Force Exit system service causes an Exit ($EXIT) service call to
be issued on behalf of a specified process.
Format:
SYS$FORCEX [pidadr] ,[prcnam] ,[code]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process to be forced to exit.
The pidadr argument is the address of a longword containing the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name of the process that is to be forced to exit. The
prcnam argument is the address of a character string descriptor
pointing to a 1- to 15-character process name string.
code
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by value
Completion code value to be used as the exit parameter. The code
argument is a longword containing this value. If code is not
specified, a value of 0 is passed as the completion code.
$FORMAT_ACL
The Format Access Control List Entry service formats the specified
ACL entry (ACE) into a text string.
Format:
SYS$FORMAT_ACL aclent ,[acllen] ,aclstr ,[width] ,[trmdsc]
,[indent] ,[accnam]
Arguments:
aclent
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Description of the ACE formatted when $FORMAT_ACL completes
execution. The aclent argument is the address of a descriptor
pointing to a buffer containing the description of the input ACE.
The first byte of the buffer contains the length of the ACE; the
second byte contains a value that identifies the type of ACE, which
in turn determines the ACE format.
acllen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length of the output string resulting when $FORMAT_ACL completes
execution. The acllen argument is the address of a word containing
the number of characters written to aclstr.
aclstr
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Formatted ACE resulting when $FORMAT_ACL completes its execution.
The aclstr argument is the address of a string descriptor pointing
to a buffer containing the output string.
width
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Maximum width of the formatted ACE resulting when $FORMAT_ACL
completes its execution. The width argument is the address of a
word containing the maximum width of the formatted ACE. If this
argument is omitted or contains zero, an infinite length display
line is assumed. When the width is exceeded, the character
specified by trmdsc is inserted.
trmdsc
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Line termination character(s) used in the formatted ACE. The trmdsc
argument is the address of a descriptor pointing to character string
containing the termination character(s) for each formatted ACE that
are inserted when the width has been exceeded.
indent
VMS usage: word_unsigned
type: word (unsigned)
access: read only
mechanism: by reference
Number of blank characters beginning each line of the formatted ACE.
The indent argument is the address of a word containing the number
of blank characters you want inserted at the beginning of each
formatted ACE.
accnam
VMS usage: access_bit_names
type: longword (unsigned)
access: read only
mechanism: by reference
Names of the bits in the access mask when executing the $FORMAT_ACL.
The accnam argument is the address of an array of 32 quadword
descriptors that define the names of the bits in the access mask.
Each element points to the name of a bit. The first element names
bit 0, the second element names bit 1 and so on.
$GETDVI
The Get Device/Volume Information service returns information about
an I/O device; this information consists of primary and secondary
device characteristics.
The $GETDVI service completes asynchronously; that is, it returns to
the caller after queuing the information request, without waiting
for the requested information to be returned.
For synchronous completion, use the Get Device/Volume Information
and Wait ($GETDVIW) service. The $GETDVIW service is identical to
the $GETDVI service in every way except that $GETDVIW returns to the
caller with the requested information.
Format:
SYS$GETDVI [efn] ,[chan] ,[devnam] ,itmlst [,iosb] [,astadr]
[,astprm] [,nullarg]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when $GETDVI returns the
requested information. The efn argument is a longword containing
this number.
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
Number of the I/O channel assigned to the device about which
information is desired. The chan argument is a word containing this
number.
devnam
VMS usage: device_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
The name of the device about which $GETDVI is to return information.
The devnam argument is the address of a character string descriptor
pointing to this name string.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying which information about the device is to be
returned. The itmlst argument is the address of a list of item
descriptors, each of which describes an item of information. The
list of item descriptors is terminated by a longword of 0.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block which is to receive the final completion status.
The iosb is the address of the quadword I/O status block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack
unwinding
mechanism: by reference
AST service routine to be executed when $GETDVI completes. The
astadr is the address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine specified by
the astadr argument. The astprm argument is the longword parameter.
nullarg
VMS usage: null_arg
type: quadword (unsigned)
access: read only
mechanism: by reference
Place-holding argument. This argument is reserved to DIGITAL.
$GETDVIW
The Get Device/Volume Information and Wait service returns
information about an I/O device; this information consists of
primary and secondary device characteristics.
The $GETDVIW service completes synchronously; that is, it returns to
the caller with the requested information.
For asynchronous completion, use the Get Device/Volume Information
($GETDVI) service; $GETDVI returns to the caller after queueing the
information request, without waiting for the information to be
returned.
In all other respects, $GETDVIW is identical to $GETDVI. Refer to
the documentation of $GETDVI for all other information about the
$GETDVIW service.
Format:
SYS$GETDVIW [efn] ,[chan] ,[devnam] ,itmlst [,iosb] [,astadr]
[,astprm] [,nullarg]
$GETJPI
The Get Job/Process Information service returns information about
one or more processes on the system.
The $GETJPI service completes asynchronously; that is, it returns to
the caller after queuing the information request, without waiting
for the requested information to be returned.
For synchronous completion, use the Get Job/Process Information and
Wait ($GETJPIW) service. The $GETJPIW service is identical to the
$GETJPI service in every way except that $GETJPIW returns to the
caller with the requested information.
Format:
SYS$GETJPI [efn] ,[pidadr] ,[prcnam] ,itmlst [,iosb] [,astadr]
[,astprm]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when $GETJPI returns the
requested information. The efn argument is a longword containing
this number.
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process about which $GETJPI is
to return information. The pidadr argument is the address of a
longword containing the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the process about which $GETJPI is to return information.
The prcnam argument is the address of a character string descriptor
pointing to this name string.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying which information about the process(es) is to
be returned. The itmlst argument is the address of a list of item
descriptors, each of which describes an item of information. The
list of item descriptors is terminated by a longword of 0.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block which is to receive the final completion status.
The iosb is the address of the quadword I/O status block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine to be executed when $GETJPI completes. The
astadr is the address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine specified by
the astadr argument. The astprm argument is the longword parameter.
$GETJPIW
The Get Job/Process Information and Wait service returns information
about one or more processes on the system.
The $GETJPIW service completes synchronously; that is, it returns to
the caller with the requested information.
For asynchronous completion, use the Get Job/Process Information
($GETJPI) service; $GETJPI returns to the caller after queueing the
information request, without waiting for the information to be
returned.
In all other respects, $GETJPIW is identical to $GETJPI. Refer to
the documentation of $GETJPI for all other information about the
$GETJPIW service.
Format:
SYS$GETJPIW [efn] ,[pidadr] ,[prcnam] ,itmlst [,iosb]
[,astadr] [,astprm]
$GETLKI
The Get Lock Information service returns information about the lock
database on a VAX/VMS system.
The $GETLKI service completes asynchronously; that is, it returns to
the caller after queuing the information request, without waiting
for the information to be returned.
For synchronous completion, use the Get Lock Information and Wait
($GETLKIW) service; $GETLKIW returns to the caller with the
requested information. In all other respects, $GETLKIW is identical
to $GETLKI.
The $GETLKI, $GETLKIW, $ENQ (Enqueue Lock Request), $ENQW (Enqueue
Lock Request and Wait), and $DEQ (Dequeue Lock Request) services
together provide the user interface to the VAX/VMS lock management
facility.
Format:
SYS$GETLKI [efn] ,lkidadr ,itmlst [,iosb] [,astadr]
[,astprm] [,nullarg]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when $GETLKI completes. The efn
argument is a longword containing this number. If efn is not
specified, $GETLKI sets event flag 0.
lkidadr
VMS usage: lock_id
type: longword (unsigned)
access: modify
mechanism: by reference
Lock identification (lock id) for the lock about which information
is to be returned. The lock id is the second longword in the lock
status block, which was created when the lock was granted. The
lkidadr argument is the address of this longword.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying the lock information that $GETLKI is to return.
The itmlst argument is the address of a list of item descriptors,
each of which describes an item of information. The list of item
descriptors is terminated by a longword of 0.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O Status Block that is to receive the final completion status.
The iosb argument is the address of a quadword.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine to be executed when the service completes. The
astadr argument is the address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine specified by
the astadr argument. The astprm argument is the longword parameter.
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
$GETLKIW
The Get Lock Information and Wait service returns information about
the lock database on a VMS system.
The $GETLKIW service completes synchronously; that is, it returns to
the caller with the requested information.
For asynchronous completion, use the Get Lock Information ($GETLKI)
service; $GETLKI returns to the caller after queueing the
information request, without waiting for the information to be
returned.
In all other respects, $GETLKIW is identical to $GETLKI. Refer to
the documentation of $GETLKI for all other information about the
$GETLKIW service.
The $GETLKI, $GETLKIW, $ENQ (Enqueue Lock Request), $ENQW (Enqueue
Lock Request and Wait), and $DEQ (Dequeue Lock Request) services
together provide the user interface to the VAX/VMS lock management
facility.
Format:
SYS$GETLKIW [efn] ,lkidadr ,itmlst [,iosb] [,astadr] [,astprm]
[,nullarg]
$GETMSG
The Get Message service locates and returns message text associated
with a given message identification code into the caller's buffer.
The message can be from the system message file or can be a
user-defined message.
Format:
SYS$GETMSG msgid ,msglen ,bufadr ,[flags]
,[outadr]
Arguments:
msgid
VMS usage: cond_value
type: longword (unsigned)
access: read only
mechanism: by value
Identification of the message to be retrieved. The msgid argument
is a longword value containing the message identification. Each
message has a unique identification, contained in bits 3 through 27
of system longword condition values.
msglen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Length of the message string returned by $GETMSG. The msglen
argument is the address of a word into which $GETMSG writes this
length.
bufadr
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Buffer to receive the message string. The bufadr argument is the
address of a character string descriptor pointing to the buffer into
which $GETMSG writes the message string. The maximum size of any
message string is 256 bytes.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Message components to be returned. The flags argument is a longword
bit vector, wherein a bit when set specifies that that message
component is to be returned.
outadr
VMS usage: vector_byte_unsigned
type: byte (unsigned)
access: write only
mechanism: by reference
Optional information to be returned by $GETMSG. The outadr is the
address of a four-byte array into which $GETMSG writes the following
information:
Byte Contents
0 Reserved
1 Count of FAO arguments associated with message
2 User-specified value in message, if any
3 Reserved
$GETQUI
The Get Queue Information ($GETQUI) service returns information
about queues and the jobs initiated from those queues. The $GETQUI
and $SNDJBC services together provide the user interface to the
VAX/VMS Job Controller, which is the VAX/VMS queue and accounting
manager.
The $GETQUI service completes asynchronously; that is, it returns to
the caller after queuing the request, without waiting for the
operation to complete.
For synchronous completion, use the Get Queue Information and Wait
($GETQUIW) service. The $GETQUIW service is identical to $GETQUI in
every way except that $GETQUIW returns to the caller after the
operation has completed.
Format:
SYS$GETQUI [efn] ,func [,nullarg] [,itmlst] [,iosb] [,astadr]
[,astprm]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when $GETQUI completes. The efn
argument is a longword containing this number. The efn argument is
optional.
func
VMS usage: function_code
type: word (unsigned)
access: read only
mechanism: by value
Function code specifying the function that $GETQUI is to perform.
The func argument is a word containing this function code. The
$QUIDEF macro defines the names of each function code.
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list supplying information to be used in performing the
function specified by the func argument. The itmlst argument is the
address of the item list. The item list consists of one or more
item descriptors, each of which specifies an item code. The item
list is terminated by an item code of 0 or by a longword of 0.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block into which $GETQUI writes the completion status
after the requested operation has completed. The iosb is the
address of the I/O status block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack
unwinding
mechanism: by reference
AST service routine to be executed when $GETQUI completes. The
astadr argument is the address of the entry mask of this routine.
astprm
VMS usage: user_parm
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine specified by
the astadr argument. The astprm argument is this longword
parameter.
$GETQUIW
The Get Queue Information and Wait for Completion service ($GETQUIW)
returns information about queues and jobs initiated from those
queues. The $SNDJBC service is the major interface to the VAX/VMS
Job Controller, which is the VAX/VMS queue and accounting manager.
The $GETQUIW service completes synchronously; that is, it returns to
the caller with the requested information. For asynchronous
completion use the Get Queue Information ($GETQUI) service; $GETQUI
returns to the caller after queuing the information request, without
waiting for the information to be returned.
In all other respects, $GETQUIW is identical to $GETQUI. Refer to
the documentation of $GETQUI for all other information about the
$GETQUIW service.
Format:
SYS$GETQUIW [efn] ,func [,nullarg] [,itmlst] [,iosb] [,astadr]
[,astprm]
$GETSYI
The Get SystemWide Information service returns information about the
local VAX system or about other VAX systems in a cluster.
For Version 4.0 of VAX/VMS, both the $GETSYI service and the Get
System-Wide Information and Wait ($GETSYIW) service complete
synchronously; that is, they return to the caller with the requested
information.
However, in the future, $GETSYI will be modified to complete
asynchronously; that is, it will return to the caller after queueing
the information request, without waiting for the information to be
returned. For this reason, DIGITAL recommends that you use the
$GETSYIW service for synchronous completion.
Format:
SYS$GETSYI [efn] ,[csidadr] ,[nodename] ,itmlst [,iosb]
[,astadr] [,astprm]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when the $GETSYI request
completes. The efn argument is a longword containing this number.
csidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Cluster system identification of the VAX node about which $GETSYI is
to return information. The csidadr is the address of a longword
containing this identification value.
nodename
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the VAX node about which $GETSYI is to return information.
The nodename argument is the address of a character string
descriptor pointing to this name string.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying which information about the VAX node(s) is to
be returned. The itmlst argument is the address of a list of item
decriptors, each of which describes an item of information. The
list of item descriptors is terminated by a longword of 0.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block which is to receive the final completion status.
The iosb is the address of the quadword I/O status block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine to be executed when $GETSYI completes. The
astadr is the address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine specified by
the astadr argument. The astprm argument is the longword parameter.
$GETSYIW
The Get System-Wide Information and Wait service returns information
about the local VAX system or about other VAX systems in a cluster.
For Version 4.0 of VAX/VMS, the $GETSYIW service is identical to the
Get System-Wide Information ($GETSYI) service. Both services return
the same information, and both complete synchronously; that is, they
return to the caller with the requested information.
However, in the future the $GETSYI service will be modified to
complete asynchronously; that is, it will return to the caller after
queueing the information request, without waiting for the
information to be returned. For this reason, DIGITAL recommends
that you use the $GETSYIW service for synchronous completion.
Refer to the documentation of $GETSYI for all other information
about the $GETSYIW service.
Format:
SYS$GETSYIW [efn] ,[csidadr] ,[nodename] ,itmlst [,iosb]
[,astadr] [,astprm]
$GETTIM
The Get Time service returns the current system time in 64-bit
format.
Format:
SYS$GETTIM timadr
Argument
timadr
VMS usage: date_time
type: quadword (unsigned)
access: write only
mechanism: by reference
Address of a quadword that is to receive the current time in 64-bit
format.
$GETUAI
The Get User Authorization Information ($GETUAI) service returns
authorization information about a specified user.
Format:
SYS$GETUAI [nullarg] ,[nullarg] ,usrnam ,itmlst ,[nullarg]
,[nullarg] ,[nullarg]
Arguments:
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
usrnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
Name of the user about whom $GETUAI returns authorization
information. The usrnam argument is the address of a descriptor
pointing to a character text string containing the user name. The
user name string may contain a maximum of 12 alphanumeric
characters.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying which information from the specified user's UAF
(user authorization file) record is to be returned. The itmlst
argument is the address of a list of one or more item descriptors,
each of which specifies an item code. The item list is terminated
by an item code of 0 or by a longword of 0.
$GRANTID
The Grant Identifier to Process service adds the specified
identifier record to the process' rights list or to the system
rights list. If the identifier is already in the rights list, the
attributes are modified as specified.
Format:
SYS$GRANTID [pidadr] ,[prcnam] ,[id] ,[name] ,[prvatr]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification number (PID) of the process affected when
$GRANTID completes execution. The pidadr argument is the address of
longword containing the PID of process to be affected. Use --1 to
indicate the system rights list. When pidadr is passed, it is also
returned; therefore, you must pass it as a variable rather than a
constant. If neither pidadr nor prcnam is specified, your own
process is used.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name on which $GRANTID operates. The prcnam argument is the
address of a character string descriptor containing the process
name. The maximum length of the name is 15 characters. Since the
UIC group number is interpreted as part of the process name, you
must use pidadr to specify the rights list of a process in a
different group. If neither pidadr nor prcnam is specified, your
own process is used.
id
VMS usage: rights_holder
type: quadword (unsigned)
access: modify
mechanism: by reference
Identifier and attributes to be granted when $GRANTID completes
execution. The id argument is the address of a quadword containing
the binary identifier code to be granted in the first longword and
the attributes in the second longword.
name
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the identifier granted when $GRANTID completes execution.
The name argument is the address of a descriptor pointing to the
name of the identifier. Either id or name must be specified.
prvatr
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Previous attributes of the identifier. The prvatr argument is the
address of a longword used to store the attributes of the identifier
if it was previously present in the rights list. If the identifier
was added rather than modified, prvatr is ignored.
$HIBER
The Hibernate service allows a process to make itself inactive but
to remain known to the system so that it can be interrupted, for
example, to receive ASTs. A hibernate request is a
wait-for-wake-event request. When the Wake Process from Hibernation
($WAKE) service is called or when a Schedule Wakeup ($SCHDWK)
service comes due, the process continues execution at the
instruction following the Hibernate call.
Format:
SYS$HIBER
None
$IDTOASC
The Translate Identifier to Identifier Name service translates the
specified identifier value to its identifier name.
Format:
SYS$IDTOASC id ,[namlen] ,[nambuf] ,[resid] ,[attrib]
,[contxt]
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Binary identifier value translated by $IDTOASC. The id argument is
a longword containing the binary value of the identifier. To
determine the identifier names of all identifiers in the rights
database, specify id as --1 and call SYS$IDTOASC repeatedly until it
returns the status code SS$_NOSUCHID. The identifiers are returned
in alphabetical order.
namlen
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of characters in the identifier name translated by $IDTOASC.
The namlen argument is the address of a word containing the length
of the identifier name written to nambuf.
nambuf
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Identifier name text string returned when $IDTOASC completes the
translation. The nambuf argument is the address of a descriptor
pointing to the buffer in which the identifier name is written.
resid
VMS usage: rights_id
type: longword (unsigned)
access: write only
mechanism: by reference
Identifier value of the identifier name returned in nambuf. The
resid argument is the address of a longword containing the 32-bit
code of the identifier.
attrib
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Mask of attributes associated with the identifier returned in resid.
The attrib argument is the address of a longword containing the
attribute mask.
contxt
VMS usage: context
type: longword (unsigned)
access: modify
mechanism: by reference
Context value used when repeatedly calling $IDTOASC. The contxt
argument is the address of a longword used while searching for all
identifiers. The context value must be initialized to zero, and the
resulting context of each call to $IDTOASC must be presented to each
subsequent call. Once contxt has been passed to $IDTOASC, do not
modify its value.
$LCKPAG
The Lock Pages In Memory service locks a page or range of pages in
memory. The specified virtual pages are forced into the working set
and then locked in memory. A locked page is not swapped out of
memory if its process's working set is swapped out. These pages are
not candidates for page replacement and in this sense are locked in
the working set as well.
Format:
SYS$LCKPAG inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses of the range of pages to be
locked. The inadr is the address of a two-longword array
containing, in order, the starting and the ending process virtual
addresses. Only the virtual page number portion of each virtual
address is used; the low-order 9 bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference--array reference
or descriptor
Starting and ending process virtual addresses of the pages that
$LCKPAG actually locked. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the pages to be locked. The
acmode argument is a longword containing the access mode. The
$PSLDEF macro defines the four access modes.
$LKWSET
The Lock Pages in Working Set service locks a range of pages in the
working set; if the pages are not already in the working set, it
brings them in and locks them. A page that is locked in the working
set does not become a candidate for replacement.
Format:
SYS$LKWSET inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses of the range of pages to be
locked in the working set. The inadr is the address of a
two-longword array containing, in order, the starting and the ending
process virtual addresses. Only the virtual page number portion of
each virtual address is used; the low-order 9 bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference
Starting and ending process virtual addresses of the range of pages
actually locked by $LCKWSET. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the pages to be locked. The
acmode argument is a longword containing the access mode. The
$PSLDEF macro defines the four access modes.
$MGBLSC
The Map Global Section service establishes a correspondence between
(maps) pages in the process's virtual address space and physical
pages occupied by a global section.
Format:
SYS$MGBLSC inadr ,[retadr] ,[acmode] ,[flags] ,gsdnam ,[ident]
,[relpag]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses in the process's virtual
address space (either the P0 or P1 regions) into which the section
is to be mapped. The inadr is the address of a two-longword array
containing, in order, the starting and the ending process virtual
addresses. Only the virtual page number portion of each virtual
address is used; the low-order 9 bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference
Starting and ending process virtual addresses into which the section
was actually mapped by $MGBLSC. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode to be associated with the pages that are mapped into the
process virtual address space. The acmode argument is a longword
containing the access mode. The $PSLDEF macro defines symbols for
the four access modes.
flags
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Flag mask specifying options for the operation. The flags argument
is a longword bit vector wherein a bit when set specifies the
corresponding option.
gsdnam
VMS usage: section_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the global section. The gsdnam argument is the address of a
character string descriptor pointing to this name string.
ident
VMS usage: section_id
type: quadword (unsigned)
access: read only
mechanism: by reference
Identification value specifying the version number of a global
section, and, for processes mapping to an existing global section,
the criteria for matching the identification. The ident argument is
the address of a quadword structure containing three fields.
relpag
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Relative page number within the section of the first page to be
mapped. The relpag argument is a longword containing this number.
$MOD_HOLDER
The Modify Holder Record in Rights Database service modifies the
specified holder record of the target identifier in the rights
database. Identifier attributes may be added, or removed, or both.
Format:
SYS$MOD_HOLDER id ,holder ,[set_attrib] ,[clr_attrib]
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Binary value of target identifier whose holder record is modified
when $MOD_HOLDER completes execution. The id argument is a longword
containing the identifier value.
holder
VMS usage: rights_holder
type: quadword (unsigned)
access: read only
mechanism: by reference
Identifier of holder being modified when $MOD_HOLDER completes
execution. The holder argument is the address of a quadword
containing the UIC identifier of the holder in the first longword
and the value of zero in the second longword.
set_attrib
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Bitmask of attributes to be enabled for the identifier when
$MOD_HOLDER completes execution. The set_attrib argument is a
longword containing the attribute mask.
clr_attrib
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Bitmask of attributes to be disabled for the identifier when
$MOD_HOLDER completes execution. The clr_attrib argument is a
longword containing the attribute mask.
$MOD_IDENT
The Modify Identifier in Rights Database service modifies the
specified identifier record in the rights database. Identifier
attributes may be added, or removed, or both. The identifier name
or value may be changed.
Format:
SYS$MOD_IDENT id ,[set_attrib] ,[clr_attrib] ,[new_name]
,[new_value]
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Binary value of identifier whose identifier record is modified when
$MOD_IDENT completes execution. The id argument is a longword
containing the identifier value.
set_attrib
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Bitmask of attributes to be enabled for the identifier when
$MOD_IDENT completes execution. The set_attrib argument is a
longword containing the attribute mask.
clr_attrib
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Bitmask of attributes to be disabled for the identifier when
$MOD_IDENT completes execution. The clr_attrib argument is a
longword containing the attribute mask.
new_name
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
New name to be given to the specified identifier. The new_name
argument is the address of the descriptor pointing to the identifier
name string.
new_value
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
New value to be assigned to the specified identifier. The new_value
argument is a longword containing the binary value of the specified
identifier. When the identifier value is changed, $MOD_IDENT also
changes the value of the identifier in all of the holder records in
which the specified identifier appears.
$MOUNT
The Mount Volume service mounts a tape, disk volume, or volume set
and specifies options for the mount operation.
Format:
SYS$MOUNT itmlst
Argument
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying options for the mount operation. The itmlst
argument is the address of a list of item descriptors, each of which
specifies an option and provides the information needed to perform
the operation.
$MTACCESS
The Magnetic Tape Accessibility service allows installations to
provide their own routine to interpret and output the accessibility
field in the VOL1 and HDR1 labels of an ANSI labeled magnetic tape.
(ANSI refers to the American National Standard for Magnetic Tape
Labels and File Structure for Information Interchange---ANSI,
x3.27-1978)
Format:
SYS$MTACCESS lblnam ,[uic] ,[std_version] ,[access_char]
,[access_spec] ,type
Arguments:
lblnam
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
ANSI label to be processed. The lblnam argument is the address of a
longword containing the label. On input, the label passed is either
the VOL1 or HDR1 label read from the magnetic tape; on output of
labels, this field is zero. The type of label passed is determined
by type.
uic
VMS usage: uic
type: longword (unsigned)
access: read only
mechanism: by value
UIC of the user performing the operation. The uic argument is a
longword containing the UIC.
std_version
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Decimal equivalent of the ANSI standard version read from the VOL1
label. The std_version argument is a longword containing the
standard version number.
access_char
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Accessibility character specified by the user. The access_char
argument is a byte containing the accessibility character used for
the output of labels.
access_spec
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Value specifying whether the accessibility character passed in
access_char was specified by the user.
type
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Type of accessibility field to process.
$NUMTIM
The Convert Binary Time to Numeric Time service converts an absolute
or delta time from 64-bit system time format to binary integer date
and time values.
Format:
SYS$NUMTIM timbuf ,[timadr]
Arguments:
timbuf
VMS usage: vector_word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Buffer into which $NUMTIM writes the converted date and time. The
numtim argument is the address of a 7-word structure.
timadr
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
The 64-bit time value to be converted. The timadr argument is the
address of a quadword containing this time. A positive time value
represents an absolute time, while a negative time value indicates a
delta time.
$PARSE_ACL
The Parse Access Control List Entry service parses the specified
text string and converts it into the binary representation for an
access control list entry (ACE).
Format:
SYS$PARSE_ACL aclstr ,aclent ,[errpos] ,[accnam]
Arguments:
aclstr
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Formatted ACE that is parsed when $PARSE_ACL completes execution.
The aclstr argument is the address of a string descriptor pointing
to the text string to be parsed.
aclent
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by descriptor--fixed
length string descriptor
Description of the ACE that is parsed when $PARSE_ACL completes
execution. The aclent argument is the address of a descriptor
pointing to the buffer in which the ACE is written. The first byte
of the buffer contains the length of the ACE; the second byte
contains a value that identifies the type of ACE, which in turn
defines the format of the ACE. See the SYS$FORMAT_ACL service for
information on the ACE types and their associated formats.
errpos
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
Number of characters from aclstr processed by SYS$PARSE_ACL. The
errpos argument is the address of a word that receives the number of
characters actually processed by the service. If the service fails,
this count points to the failing point in the string.
accnam
VMS usage: access_bit_names
type: longword (unsigned)
access: read only
mechanism: by reference
Names of the bits in the access mask when executing $PARSE_ACL. The
accnam argument is the address of an array of 32 quadword
descriptors that define the names of the bits in the access mask.
Each element points to the name of a bit. The first element names
bit 0, the second element names bit 1, and so on.
$PREPARE_RU
Applicable only if you have the RMS Journaling option. See the VAX
RMS Journaling Manual.
The Prepare Recovery Unit Service marks a point in the recovery unit
of an application using RMS Journaling where all modifications to
records within a recovery unit are complete. When you issue a call
to the $PREPARE_RU service, no further modifications are permitted
for any files that are connected to the recovery unit that was
started with the $START_RU call) until that recovery unit is no
longer active. After you issue a $PREPARE_RU call, the recovery unit
must be terminated with either a call to the $ABORT_RU service or
the $COMMIT_RU service.
Although you cannot modify any data between the $PREPARE_RU and
$COMMIT_RU calls or between the $PREPARE_RU and $ABORT_RU calls, you
can include other processing (such as data verification) to
determine whether you wish to commit or abort the recovery unit.
After using $PREPARE_RU, do not issue a call to the $END_RU service;
use $COMMIT_RU to end the recovery unit and retain the record
modifications that were made during the recovery unit.
Format:
SYS$PREPARE_RU ru_handle
Arguments:
ru_handle
VMS Usage: ru_handle
type: longword (unsigned)
access: read only
mechanism: by reference
The ru_handle argument is the address of an unsigned longword that
contains the recovery unit handle returned by the $START_RU system
service.
$PURGWS
The Purge Working Set service removes a specified range of pages
from the calling process's current working set to make room for
pages required by a new program segment. However, the Adjust
Working Set Limit ($ADJWSL) service is the preferred mechanism for
controlling a process's use of physical memory resources.
Format:
SYS$PURGWS inadr
Argument
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses of the range of pages to be
purged. The inadr is the address of a two-longword array
containing, in order, the starting and the ending process virtual
addresses. Only the virtual page number portion of each virtual
address is used; the low-order 9 bits are ignored.
$PUTMSG
The Put Message service writes one or more error messages to
SYS$ERROR (and to SYS$OUTPUT if it is different than SYS$ERROR).
$PUTMSG is a generalized message formatting and output routine used
by VAX/VMS to write informational and error messages to processes.
Format:
SYS$PUTMSG msgvec ,[actrtn] ,[facnam] ,[actprm]
Arguments:
msgvec
VMS usage: cntrlblk
type: longword (unsigned)
access: read only
mechanism: by reference
Message argument vector specifying the message(s) to be written and
options that $PUTMSG is to use in writing the message(s). The
msgvec argument is the address of the message vector.
actrtn
VMS usage: procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
User-supplied action routine to be executed during message
processing. The actrtn argument is the address of the entry mask of
this routine.
facnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Facility prefix to be used in the first or only message written by
$PUTMSG. The facnam argument is the address of a character string
descriptor pointing to this facility prefix.
actprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
Parameter to be passed to the action routine. The actprm is a
longword value containing this parameter. If actprm is not
specified, no parameter is passed.
$QIO
The Queue I/O Request service queues an I/O request to a channel
associated with a device.
The $QIO service completes asynchronously; that is, it returns to
the caller immediately after queuing the I/O request, without
waiting for the I/O operation to complete.
For synchronous completion, use the Queue I/O Request and Wait
($QIOW) service. The $QIOW service is identical to the $QIO service
in every way except that $QIOW returns to the caller after the I/O
operation has completed.
Format:
SYS$QIO [efn] ,chan ,func [,iosb] [,astadr] [,astprm]
[,p1] [,p2] [,p3] [,p4] [,p5] [,p6]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Event flag that $QIO is to set when the I/O operation actually
completes. The efn argument is a longword value containing the
number of the event flag.
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
I/O channel that is assigned to the device to which the request is
directed. The chan argument is a word value containing the number
of the I/O channel; however, $QIO uses only the low-order word.
func
VMS usage: function_code
type: word (unsigned)
access: read only
mechanism: by value
Device-specific function codes and function modifiers specifying the
operation to be performed. The func is a longword value containing
the function code.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block to receive the final completion status of the I/O
operation. The iosb is the address of the quadword I/O status
block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine to be executed when the I/O completes. The
astadr argument is the address of a longword value that is the entry
mask to the AST routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine. The astprm
argument is a longword value containing the AST parameter.
p1 to p6
VMS usage: varying_arg
type: longword (unsigned)
access: read only
mechanism: by reference
Optional device- and function-specific I/O request parameters.
$QIOW
The Queue I/O Request and Wait service queues an I/O request to a
channel associated with a device.
The $QIOW service completes synchronously; that is, it returns to
the caller after the I/O operation has actually completed.
For asynchronous completion, use the Queue I/O Request ($QIO)
service; $QIO returns to the caller after queuing the I/O request,
without waiting for the I/O operation to be completed.
In all other respects, $QIOW is identical to $QIO. Refer to the
documentation of $QIO for all other information about the $QIOW
service.
Format:
SYS$QIOW [efn] ,chan ,func [,iosb] [,astadr] [,astprm]
[,p1] [,p2] [,p3] [,p4] [,p5] [,p6]
$READEF
The Read Event Flags service returns the current status of all 32
event flags in a local or common event flag cluster. In addition,
the condition value returned indicates whether the specified event
flag is set or clear.
Format:
SYS$READEF efn ,state
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of any event flag in the cluster whose status is to be
returned. The efn argument is a longword containing this number.
Specifying an event flag within a cluster requests that $READEF
return the status of all event flags in that cluster.
state
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
State of all event flags in the specified cluster. The state
argument is the address of a longword into which $READEF writes the
state (set or clear) of the 32 event flags in the cluster.
$REM_HOLDER
Deletes the specified holder record from the target identifier's
list of holders.
Format:
SYS$REM_HOLDER id ,holder
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Binary value of target identifier whose holder is deleted when
$REM_HOLDER completes execution. The id argument is a longword
containing the identifier value.
holder
VMS usage: rights_holder
type: quadword (unsigned)
access: read only
mechanism: by reference
Identifier of holder being deleted when $REM_HOLDER completes
execution. The holder argument is the address of a quadword
containing the UIC identifier of the holder in the first longword
and the value of zero in the second longword.
$REM_IDENT
The Remove Identifier from Rights Database service removes the
specified identifier record and all its holder records (if any) from
the rights database.
Format:
SYS$REM_IDENT id
Arguments:
id
VMS usage: rights_id
type: longword (unsigned)
access: read only
mechanism: by value
Binary value of identifier deleted from rights database when
$REM_IDENT completes execution. The id argument is a longword
containing the identifier value.
$RESUME
The Resume Process service (1) causes a process previously suspended
by the Suspend Process ($SUSPND) service to resume execution or (2)
cancels the effect of a subsequent suspend request.
Format:
SYS$RESUME [pidadr] ,[prcnam]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process that is to be resumed.
The pidadr argument is the address of a longword containing the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the process to be resumed. The prcnam is the address of a
character string descriptor pointing to the process name, which is a
character string of from 1 to 15 characters.
$REVOKID
The Revoke Identifier from Process service removes the specified
identifier from the process's rights list, or from the system rights
list. If the identifier is listed as a holder of any other
identifier, the appropriate holder records are also deleted.
Format:
SYS$REVOKID [pidadr] ,[prcnam] ,[id] ,[name]
,[prvatr]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification number (PID) of the process affected when
$REVOKID completes execution. The pidadr argument is the address of
longword containing the PID of process to be affected. Use --1 to
indicate the system rights list. When pidadr is passed, it is also
returned; therefore, you must pass it as a variable rather than a
constant.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name on which $REVOKID operates. The prcnam argument is the
address of a character string descriptor containing the process
name. The maximum length of the name is 15 characters. Since the
UIC group number is interpreted as part of the process name, you
must use pidadr to specify the rights list of a process in a
different group.
id
VMS usage: rights_id
type: quadword (unsigned)
access: modify
mechanism: by reference
Identifier and attributes to be removed when $REVOKID completes
execution. The id argument is the address of a quadword containing
the binary identifier code to be removed in the first longword and
the attributes in the second longword.
name
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the identifier removed when $REVOKID completes execution.
The name argument is the address of a descriptor pointing to the
name of the identifier.
prvatr
VMS usage: mask_longword
type: longword (unsigned)
access: write only
mechanism: by reference
Attributes of the deleted identifier. The prvatr argument is the
address of a longword used to store the attributes of the
identifier.
$SCHDWK
The Schedule Wakeup service schedules the awakening of a process
that has placed itself in a state of hibernation with the Hibernate
($HIBER) service. A wakeup can be scheduled for a specified
absolute time or for a delta time, and can be repeated at fixed
intervals.
Format:
SYS$SCHDWK [pidadr] ,[prcnam] ,daytim ,[reptim]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process that is to be awakened.
The pidadr argument is the address of a longword containing the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the process to be awakened. The prcnam is the address of a
character string descriptor pointing to the process name, which is a
character string of from 1 to 15 characters.
daytim
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
Time at which the process is to be awakened. The daytim argument is
the address of a quadword containing this time in the system 64-bit
time format. A positive time value specifies an absolute time at
which the specified process is to be awakened. A negative time
value specifies an offset (delta time) from the current time.
reptim
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
Time interval at which the wakeup request is to be repeated. The
reptim argument is the address of a quadword containing this time
interval. The time interval must be expressed in delta time format.
$SETAST
The Set AST Enable service enables or disables the delivery of ASTs
for the access mode from which the service call was issued.
Format:
SYS$SETAST enbflg
Argument
enbflg
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Value specifying whether ASTs are to be enabled. The enbflg
argument is a byte containing this value. A value of 1 enables AST
delivery for the calling access mode; a value of 0 disables AST
delivery.
$SETEF
The Set Event Flag service sets an event flag in a local or common
event flag cluster. The condition value returned by $SETEF
indicates whether the specified flag was previously set or clear.
Once the event flag is set, processes waiting for the event flag to
be set resume execution.
Format:
SYS$SETEF efn
Argument
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set. The efn argument is a longword
containing this number.
$SETEXV
The Set Exception Vector service (1) assigns a condition handler
address to the primary, secondary, or last chance exception vectors
or (2) removes a previously assigned handler address from any of
these three vectors.
Format:
SYS$SETEXV [vector] ,[addres] ,[acmode] ,[prvhnd]
Arguments:
vector
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Vector for which a condition handler is to be established or
removed. The vector argument is a longword value. A value of 0
(the default) specifies the primary vector; a value of 1, the
secondary vector; and a value of 2, the last chance exception
vector.
addres
VMS usage: procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
Condition handler address to be established for the exception vector
specified by vector. The addres argument is a longword value
containing the address of the entry mask to the condition handler
routine.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode for which the exception vector is to be modified. The
acmode argument is a longword containing the access mode. The
$PSLDEF macro defines symbols for the four access modes.
prvhnd
VMS usage: procedure
type: longword (unsigned)
access: write only
mechanism: by reference
Previous condition handler address contained by the specified
exception vector. The prvhnd argument is the address of a longword
into which $SETEF writes the handler address.
$SETIME
The Set System Time service (1) changes the value of or (2)
recalibrates the system time.
The system time is defined by a quadword value that specifies the
number of 100 nanosecond intervals since 00:00 o'clock, November 17,
1858.
The system time is the reference used for nearly all timer-related
software activities in VAX/VMS.
Format:
SYS$SETIME [timadr]
Argument
timadr
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
New time value for the system time. The timadr argument is the
address of a quadword containing the new system time value. The new
system time value is an absolute time value specifying the number of
100 nanosecond intervals since 00:00 o'clock, November 17, 1858. A
negative (delta) time value is invalid.
$SETIMR
The Set Timer service sets the timer to expire at a specified time.
When the timer expires, an event flag is set and (optionally) an AST
routine executes.
Format:
SYS$SETIMR [efn] ,daytim ,[astadr] ,[reqidt]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Event flag to be set when the timer expires. The efn argument is a
longword value containing the number of the event flag. If efn is
not specified, event flag 0 is set.
daytim
VMS usage: date_time
type: quadword (unsigned)
access: read only
mechanism: by reference
Time at which the timer expires. The daytim argument is the address
of a quadword time value. A positive time value specifies an
absolute time at which the timer expires; a negative time value
specifies an offset (delta time) from the current time.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine that is to execute when the timer expires. The
astadr is the address of the entry mask of this routine. If astadr
is not specified or is specified as 0 (the default), no AST routine
executes.
reqidt
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
Identification of the timer request. The reqidt is a longword value
containing a number that uniquely identifies the timer request. If
reqidt is not specified, the value 0 is used.
$SETPRA
The Set Power Recovery AST service establishes a routine to receive
control after a power recovery is detected.
Format:
SYS$SETPRA astadr ,[acmode]
Arguments:
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
Power recovery AST routine to receive control when a power recovery
is detected. The astadr is the address of the entry mask of this
routine.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode at which the power recovery AST routine is to execute.
The acmode argument is a longword containing the access mode. The
$PSLDEF macro defines symbols for the four access modes.
$SETPRI
The Set Priority service changes a process's base priority. The
base priority is used to determine the order in which executable
processes are to run.
Format:
SYS$SETPRI [pidadr] ,[prcnam] ,pri ,[prvpri]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process whose priority is to be
set. The pidadr argument is the address of the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name of the process whose priority is to be changed. The
prcnam argument is the address of a character string descriptor
pointing to a 1- to 15-character process name string.
pri
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
New base priority to be established for the process. The pri
argument is a longword value containing the new priority.
Priorities which are not real time are in the range 0 through 15;
real-time priorities are in the range 16 through 31.
prvpri
VMS usage: longword_unsigned
type: longword (unsigned)
access: write only
mechanism: by reference
Base priority of the process before the call to $SETPRI. The prvpri
argument is the address of a longword into which $SETPRI writes the
process's previous base priority.
$SETPRN
The Set Process Name service allows a process to establish or to
change its own process name.
Format:
SYS$SETPRN [prcnam]
Argument
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name to be given to the calling process. The prcnam
argument is the address of a character string descriptor pointing to
a 1- to 15-character process name string. If prcnam is not
specified, the calling process is given no name.
$SETPRT
The Set Protection on Pages service allows a process to change the
protection on a page or range of pages.
Format:
SYS$SETPRT inadr ,[retadr] ,[acmode] ,prot ,[prvprt]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses of the range of pages whose
protection is to be changed. The inadr is the address of a
two-longword array containing, in order, the starting and the ending
process virtual addresses. Only the virtual page number portion of
each virtual address is used; the low-order 9 bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference--array reference
or descriptor
Starting and ending virtual addresses of the range of pages whose
protection was actually changed by $SETPRT. The retadr is the
address of a two-longword array containing, in order, the starting
and ending process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode associated with the call to $SETPRT. The acmode
argument is a longword containing the access mode. The $PSLDEF
macro defines symbols for the four access modes.
prot
VMS usage: page_protection
type: longword (unsigned)
access: read only
mechanism: by value
Page protection to be assigned to the specified pages. The prot
argument is a longword value containing the protection code. Only
bits 0 to 3 are used; bits 4 to 31 are ignored.
prvprt
VMS usage: page_protection
type: byte (unsigned)
access: write only
mechanism: by reference
Protection previously assigned to the last page in the range. The
prvprt argument is the address of a byte into which $SETPRT writes
the protection of this page. The prvprt argument is useful only
when protection for a single page is being changed.
$SETPRV
The Set Privileges service enables or disables specified privileges
for the calling process.
Format:
SYS$SETPRV [enbflg] ,[prvadr] ,[prmflg] ,[prvprv]
Arguments:
enbflg
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Indicator specifying whether the specified privileges are to be
enabled or disabled. The enbflg is a byte value. A value of 1
specifies that the privileges specified in the prvadr argument are
to be enabled. A value of 0 (the default) indicates that the
privileges are to be disabled.
prvadr
VMS usage: mask_privileges
type: quadword (unsigned)
access: read only
mechanism: by reference
Privileges to be enabled or disabled for the calling process. The
prvadr argument is the address of a quadword bit vector wherein each
bit corresponds to a privilege that is to be enabled or disabled.
prmflg
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Indicator specifying whether the privileges are to be affected
permanently or temporarily. The prmflg is a byte value. A value of
1 specifies that the privileges are to be affected permanently, that
is, until they are again changed by using $SETPRV or until the
process is deleted. A value of 0 (the default) specifies that the
privileges are to be affected temporarily, that is, until the
current image exits (at which time the process's permanently enabled
privileges will be restored).
prvprv
VMS usage: mask_privileges
type: quadword (unsigned)
access: write only
mechanism: by reference
Privileges previously possessed by the calling process. The prvprv
argument is the address of a quadword bit vector wherein each bit
corresponds to a privilege that was previously either enabled or
disabled. If prvprv is not specified or is specified as 0, the
previous privilege mask is not returned.
$SETRWM
The Set Resource Wait Mode service allows a process to specify what
action system services should take when system resources required
for their execution are unavailable.
When resource wait mode is enabled, system services will wait for
the required system resources to become available and then will
continue execution.
When resource wait mode is disabled, system services will return to
the caller when required system resources are unavailable.
The condition value returned by $SETRWM indicates whether resource
wait mode was previously enabled or previously disabled.
Format:
SYS$SETRWM [watflg]
Argument
watflg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Indicator specifying whether system services should wait for
required resources. The watflg argument is a longword value. A
value of 0 (the default) specifies that system services should wait
until resources needed for their execution become available. A
value of 1 specifies that system services should return failure
status immediately when resources needed for their execution are
unavailable.
$SETSFM
The Set System Service Failure Exception Mode service allows a
process to specify whether or not VMS should generate a software
exception when a system service returns an error or severe error
condition value to the calling process.
The $SETSFM indicates in the condition value it returns whether
system service exception mode was enabled or disabled previous to
the call (to $SETSFM).
Initially, system service failure exception mode is disabled, so the
caller should explicitly test for successful completion following a
system service call.
Format:
SYS$SETSFM [enbflg]
Argument
enbflg
VMS usage: boolean
type: byte (unsigned)
access: read only
mechanism: by value
Number specifying whether the system service failure exception mode
is to be enabled. The enbflg argument is a byte value. A value of
1 specifies that the system service failure exception mode is
enabled. A value of 0 (the default) specifies that the system
service failure exception mode is disabled.
$SETSSF
The Set System Services Filter service inhibits user-mode calls to
certain system services. The following system services cannot be
inhibited by $SETSSF:
$ASCTIM $BINTIM $EXIT $FAO
$FAOL $PUTMSG $UNWIND
Format:
SYS$SETSSF [mask]
Arguments:
mask
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Category of system services that are to be inhibited for user-mode
calls. The mask argument is a longword value of which only the
first byte is significant. The first byte is a bit vector wherein a
bit when set specifies a category of system service to be inhibited.
Only bits 0 and 1 are used; bits 2 to 7 are reserved.
$SETSTK
The Set Stack Limits ($SETSTK) service allows a process to change
the size of its supervisor, executive, and kernel stacks by altering
the values in the stack limit and base arrays held in P1
(per-process) space.
Format:
SYS$SETSTK inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Range of addresses that express the stack's new limits. The inadr
argument is the address of a two-longword array containing, in
order, the address of the top of the stack and the address of the
base of the stack. Since stacks in P1 space expand from high to low
addresses, the address of the base of the stack must be greater than
the address of the top of the stack.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference
Range of addresses that express the stack's previous limits. The
retadr argument is the address of a two-longword array into which
$SETSTK writes, in the first longword, the previous address of the
top of the stack and, in the second longword, the previous address
of the base of the stack.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode of the stack to be altered. The acmode argument is a
longword containing the access mode. The $PSLDEF macro defines
symbols for the four access modes. The most privileged access mode
used is the access mode of the caller.
$SETSWM
The Set Process Swap Mode service allows a process to control
whether or not it can be swapped out of the balance set.
When process swap mode is enabled, the process can be swapped out;
when disabled, the process remains in the balance set until (1)
process swap mode is re-enabled or (2) the process is deleted.
The $SETSWM service returns a condition value indicating whether
process swap mode was enabled or disabled previous to the call to
$SETSWM.
To lock some but not necessarily all process pages into the balance
set, use the Lock Pages in Memory ($LCKPAG) service.
Format:
SYS$SETSWM [swpflg]
Argument
swpflg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Indicator specifying whether or not the process can be swapped. The
swpflg is a longword value. A value of 0 (the default) enables
process swap mode, meaning the process can be swapped. A value of 1
disables process swap mode, meaning the process cannot be swapped.
$SETUAI
The Set User Authorization Information ($SETUAI) service is used to
modify the user authorization file (UAF) record for a specified
user.
Format:
SYS$SETUAI [nullarg] ,[nullarg] ,usrnam ,itmlst ,[nullarg]
,[nullarg]
Arguments:
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
usrnam
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by
descriptor-fixed length string descriptor
Name of the user whose user authorization file (UAF) record is
modified. The usrnam argument is the address of a descriptor
pointing to a character text string containing the user name. The
user name string may contain a maximum of 12 alphanumeric
characters.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list specifying which information from the specified user's UAF
(user authorization file) record is to be modified. The itmlst
argument is the address of a list of one or more item descriptors,
each of which specifies an item code. The item list is terminated
by an item code of 0 or by a longword of 0.
$SNDERR
The Send Message to Error Logger service writes a user-specified
message to the system error log file, preceding it with the date and
time.
Format:
SYS$SNDERR msgbuf
Argument
msgbuf
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by
descriptor--fixed length string descriptor
Message to be written to the error log file. The msgbuf argument is
the address of a character string descriptor pointing to the message
text.
$SNDJBC
The Send to Job Controller ($SNDJBC) service creates, stops, and
manages queues and the batch and print jobs in those queues. See
the Description section for a discussion of the types of queue
supported by the VAX/VMS batch/print facility. The $SNDJBC and
$GETQUI services together provide the user interface to the VAX/VMS
Job Controller, which is the VAX/VMS queue and accounting manager.
The $SNDJBC service completes asynchronously, that is, it returns to
the caller after queueing the request, without waiting for the
operation to complete.
To synchronize the completion of most operations, use the Send to
Job Controller and Wait ($SNDJBCW) service. The $SNDJBCW service is
identical to $SNDJBC in every way except that $SNDJBCW returns to
the caller after the operation has completed.
The $SNDJBC and $SNDJBCW services supersede the Send Message to
Symbiont Manager ($SNDSMB) and Send Message to Accounting Manager
($SNDACC) services. New programs should be written using $SNDJBC or
$SNDJBCW, instead of $SNDSMB or $SNDACC, and old programs using
$SNDSMB or $SNDACC should be converted to use $SNDJBC or $SNDJBCW as
convenient.
Format:
SYS$SNDJBC [efn] ,func [,nullarg] [,itmlst] [,iosb] [,astadr]
[,astprm]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag to be set when $SNDJBC completes. The efn
argument is a longword containing this number. The efn argument is
optional.
func
VMS usage: function_code
type: word (unsigned)
access: read only
mechanism: by value
Function code specifying the function that $SNDJBC is to perform.
The func argument is a word containing this function code. The
$SJCDEF macro defines the names of each function code.
nullarg
VMS usage: null_arg
type: longword (unsigned)
access: read only
mechanism: by value
Place-holding argument. This argument is reserved to DIGITAL.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list supplying information to be used in performing the
function specified by the func argument. The itmlst argument is the
address of the item list. The item list consists of one or more
item descriptors, each of which specifies an item code. The item
list is terminated by an item code of 0 or by a longword of 0.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block into which $SNDJBC writes the completion status
after the requested operation has completed. The iosb is the
address of the I/O status block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference
AST service routine to be executed when $SNDJBC completes. The
astadr argument is the address of the entry mask of this routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST service routine specified by
the astadr argument. The astprm argument is this longword
parameter.
$SNDJBCW
The Send to Job Controller and Wait for Completion ($SNDJBW) and
$GETQUI services together provide the user interface to the Job
Controller (JBC) facility. The $SNDJBW service allows the user to
create, stop, and manage queues and the jobs in those queues.
Queues may be generic, batch, execution, or output queues. Jobs may
be batch or print jobs.
The $SNDJBCW service queues a request to the Job Controller. For
most operations, $SNDJBCW completes synchronously, that is, it
returns to the caller after the operation has completed. However,
if the requested operation is a pause queue, stop queue, or abort
job operation, $SNDJBCW returns to the caller after queueing the
request. There is no way to synchronize completion of these
operations. Also, $SNDJBCW does not wait for a job to complete
before it returns to the caller; to synchronize completion of a job,
the caller must specify the SJC$_SYNCHRONIZE_JOB function code.
The $SNDJBCW service is identical to the Send to Job Controller
($SNDJBC) service except that $SNDJBC completes asynchronously; the
$SNDJBC service returns to the caller immediately after queueing the
request, without waiting for the operation to complete.
The $SNDJBC and $SNDJBCW services supersede the Send Message to
Symbiont Manager ($SNDSMB) and Send Message to Accounting Manager
($SNDACC) services. New programs should be written using $SNDJBC or
$SNDJBCW, instead of $SNDSMB or $SNDACC, and old programs using
$SNDSMB or $SNDACC should be converted to use $SNDJBC or $SNDJBCW as
convenient.
Format:
SYS$SNDJBCW [efn] ,func [,nullarg] [,itmlst] [,iosb] [,astadr]
[,astprm]
$SNDOPR
The $SNDOPR service performs the following functions:
o Sends a user request to operator terminals
o Sends a user cancellation-request to operator terminals
o Sends an operator reply to a user terminal
o Enables an operator terminal
o Displays the status of an operator terminal
o Initializes the operator log file
Format:
SYS$SNDOPR msgbuf ,[chan]
Arguments:
msgbuf
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
User buffer specifying the operation to be performed and information
needed to perform that operation. The msgbuf is the address of a
character string descriptor pointing to the buffer.
chan
VMS usage: channel
type: word (unsigned)
access: read only
mechanism: by value
Channel assigned to the mailbox to which the reply is to be sent.
The chan argument is a longword value containing the number of the
channel. If chan is not specified or is specified as 0 (the
default), no reply is sent.
$START_RU
Applicable only if you have the RMS Journaling option. See the VAX
RMS Journaling Manual.
The Start Recovery Unit Service denotes the beginning of a recovery
unit for use in RMS Journaling. When a recovery unit is started,
all files that have been opened by the application and marked for
recovery unit journaling (or, more specifically, all streams that
are connected to files marked for recovery unit journaling), and not
already in an active recovery unit join that new recovery unit. All
operations involving those files are part of the recovery unit until
the recovery unit is completed. If a file is involved in a recovery
unit, you cannot close the file before the recovery unit has been
completed. (More specifically, you cannot disconnect a stream
until the recovery unit has been completed.)
Format:
SYS$START_RU ru_handle
Arguments:
ru_handle
VMS Usage: ru_handle
type: longword (unsigned)
access: write only
mechanism: by reference
The ru_handle argument is the address of an unsigned longword
to which the recovery unit handle is to be returned.
$SUSPND
The Suspend Process service allows a process to suspend itself or
another process. A suspended process cannot receive ASTs or
otherwise be executed until another process resumes or deletes it.
Format:
SYS$SUSPND [pidadr] ,[prcnam]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process to be suspended. The
pidadr argument is the address of the longword PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the process to be suspended. The prcnam argument is the
address of a character string descriptor pointing to a 1- to
15-character process name string.
$SYNCH
The Synchronize service checks the completion status of a system
service that completes asynchronously.
The service whose completion status is to be checked must have been
called with the efn and iosb arguments specified because the $SYNCH
service uses the event flag and I/O status block of the service to
be checked.
Format:
SYS$SYNCH [efn] ,[iosb]
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag specified in the call to the system service
whose completion status is to be checked by $SYNCH. The efn
argument is a longword containing this number.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block specified in the call to the system service whose
completion status is to be checked by $SYNCH. The iosb argument is
the address of this quadword I/O status block.
SYS$RMSRUNDWN
The RMS Rundown service closes all files opened by RMS for the image
or process and halts I/O activity. This routine performs a $CLOSE
service for each file that is opened for processing.
Format:
SYS$RMSRUNDWN buf-addr, type-value
Arguments:
buf-addr
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by
descriptor
A descriptor pointing to a 22-byte buffer that will receive the
device identification (16 bytes) and the file identification (6
bytes) of an improperly closed output file. The buf-addr argument
is the address of the descriptor that points to the buffer.
type-value
VMS usage: byte_unsigned
type: byte (unsigned)
access: read only
mechanism: by value
A single byte code that specifies the type of I/O rundown to be
performed. The type-value argument is the actual value used.
SYS$SETDDIR
The Set Default Directory service allows you to read and/or change
the default directory string for the process. You should restore
the old default directory string to its original status unless you
want the changed default directory string to last beyond the exit of
your image.
Format:
SYS$SETDDIR [new-dir-addr] [,length-addr] [,cur-dir-addr]
Arguments:
new-dir-addr
VMS usage: char_string
type: character-coded text string
access: read only
mechanism: by
descriptor-fixed length string descriptor
A descriptor of the new default directory. The new-dir-addr
argument is the address of the descriptor that points to the buffer
containing the new directory specification that RMS will use to set
the new process-default directory. If the default directory is not
to be changed, the value of the new-dir-addr argument should be 0.
length-addr
VMS usage: word_unsigned
type: word (unsigned)
access: write only
mechanism: by reference
A word that is to receive the length of the current default
directory. The length-addr argument is the address of the word that
will receive the length. Specify a value of 0 if you do not want
this value returned.
cur-dir-addr
VMS usage: char_string
type: character-coded text string
access: write only
mechanism: by
descriptor-fixed length string descriptor
A descriptor of a buffer that is to receive the current default
directory string. The cur-dir-addr argument is the address of the
descriptor that points to the buffer area that is to receive the
current directory string. Specify a value of 0 if you do not want
this to be used.
SYS$SETDFPROT
The Set Default File Protection service allows you to read and/or
write the default file protection for the process. You should
restore the old default file protection specification unless you
want the changed default to last beyond the exit of your image.
Format:
SYS$SETDFPROT [new-def-prot-addr,] [cur-def-prot-addr]
Arguments:
new-def-prot-addr
VMS usage: file_protection
type: word (unsigned)
access: read only
mechanism: by
reference
A word that specifies the new default file protection specification.
The new-def-prot-addr argument is the address of the word that
specifies the desired protection. Specify a value of 0 if you do
not want the process-default file protection to be changed.
cur-def-prot-addr
VMS usage: file_protection
type: word (unsigned)
access: write only
mechanism: by
reference
A word that is to receive the current default file protection
specification. The cur-def-prot-addr argument is the address of the
word that receives the current process-default protection. Specify
0 if this is not wanted.
$TRNLNM
The Translate Logical Name service returns information about a
logical name.
Format:
SYS$TRNLNM [attr] ,tabnam ,lognam ,[acmode] ,[itmlst]
Arguments:
attr
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by reference
Attributes controlling the search for the logical name. The attr
argument is the address of a longword bit mask specifying these
attributes.
tabnam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Name of the table or name of a list of table names in which to
search for the logical name. The tabnam argument is the address of
a descriptor pointing to this name. This argument is required.
lognam
VMS usage: logical_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Logical name about which information is to be returned. The lognam
argument is the address of a descriptor pointing to the logical name
string. This argument is required.
acmode
VMS usage: access_mode
type: byte (unsigned)
access: read only
mechanism: by reference
Access mode to be used in the translation. The acmode argument is
the address of a byte specifying the access mode. The $PSLDEF macro
defines symbolic names for the four access modes.
itmlst
VMS usage: item_list_3
type: longword (unsigned)
access: read only
mechanism: by reference
Item list describing the information that $TRNLNM is to return. The
itmlst argument is the address of a list of item descriptors, each
of which specifies or controls an item of information to be
returned. The list of item descriptors is terminated by a longword
of 0.
$ULKPAG
The Unlock Pages from Memory service unlocks pages that were
previously locked in memory by the Lock Pages in Memory ($LCKPAG)
service.
Locked pages are automatically unlocked and deleted at image exit.
Format:
SYS$ULKPAG inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference
Starting and ending virtual addresses of the pages to be unlocked.
The inadr is the address of a two-longword array containing, in
order, the starting and the ending process virtual addresses. Only
the virtual page number portion of each virtual address is used; the
low-order 9 bits are ignored. If the starting and ending virtual
addresses are the same, a single page is unlocked.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference--array reference
or descriptor
Starting and ending process virtual addresses of the pages actually
unlocked by $ULKPAG. The retadr is the address of a two-longword
array containing, in order, the starting and ending process virtual
addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode on behalf of which the request is being made. The
acmode argument is a longword containing the access mode. The
$PSLDEF macro defines the symbols for the four access modes.
$ULWSET
The Unlock Pages from Working Set service unlocks pages that were
previously locked in the working set by the Lock Pages in Working
Set ($LKWSET) service. Unlocked pages become candidates for
replacement within the process's working set.
Format:
SYS$ULWSET inadr ,[retadr] ,[acmode]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference--array reference or
descriptor
Starting and ending virtual addresses of the pages to be unlocked.
The inadr is the address of a two-longword array containing, in
order, the starting and the ending process virtual addresses. Only
the virtual page number portion of each virtual address is used; the
low-order 9 bits are ignored. If the starting and ending virtual
address are the same, a single page is unlocked.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference--array reference
or descriptor
Starting and ending process virtual addresses of the pages that were
actually unlocked by $CRMPSC. The retadr is the address of a
two-longword array containing, in order, the starting and ending
process virtual addresses.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode on behalf of which the request is being made. The
acmode argument is a longword containing the access mode. The
$PSLDEF macro defines the symbols for the four access modes.
$UNWIND
The Unwind Call Stack service unwinds the procedure call stack; that
is, it removes a specified number of call frames from the stack.
Optionally, it may return control to a new PC after unwinding the
stack. $UNWIND is intended to be called from within a
condition-handling routine.
Format:
SYS$UNWIND [depadr] ,[newpc]
Arguments:
depadr
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by reference
Depth to which the procedure call stack is to be unwound. The
depadr argument is the address of a longword value. The value 0
specifies the call frame of the procedure that was executing when
the condition occurred (that is, no call frames are unwound), 1
specifies the caller of that frame, 2 specifies the caller of the
caller of that frame, and so on.
newpc
VMS usage: address
type: longword (unsigned)
access: read only
mechanism: by reference
New value for the program counter (PC); this value replaces the
current value of the PC in the call frame of the procedure that
receives control when the unwinding operation is complete. The
newpc argument is a longword value containing the address at which
execution is to resume.
$UPDSEC
The Update Section File on Disk service writes all modified pages in
an active private or global section back into the section file on
disk. One or more I/O requests are queued, based on the number of
pages that have been modified.
Format:
SYS$UPDSEC inadr ,[retadr] ,[acmode] ,[updflg]
,[efn] ,[iosb] ,[astadr] ,[astprm]
Arguments:
inadr
VMS usage: address_range
type: longword (unsigned)
access: read only
mechanism: by reference--array reference or
descriptor
Starting and ending virtual addresses of the pages that are to be
written to the section file if they have been modified. The inadr
is the address of a two-longword array containing, in order, the
starting and the ending process virtual addresses. Only the virtual
page number portion of each virtual address is used; the low-order 9
bits are ignored.
retadr
VMS usage: address_range
type: longword (unsigned)
access: write only
mechanism: by reference--array reference
or descriptor
Addresses of the first and last pages that were actually queued for
writing, in the first $QIO request, back to the section file on
disk. The retadr argument is the address of a two-longword array
containing, in order, the address of the first page and the address
of the last page.
acmode
VMS usage: access_mode
type: longword (unsigned)
access: read only
mechanism: by value
Access mode on behalf of which the service is performed. The acmode
argument is a longword containing the access mode. The $PSLDEF
macro defines the symbols for the four access modes.
updflg
VMS usage: longword_unsigned
type: longword (unsigned)
access: read only
mechanism: by value
Update specifier for read/write global sections. The updflg
argument is a longword value. The value 0 (the default) specifies
that all read/write pages in the global section are to be written to
the section file on disk, regardless of whether or not they have
been modified. The value 1 specifies that (1) the caller is the
only process actually writing the global section, and (2) only those
pages that were actually modified by the caller are to be written to
the section file on disk.
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Event flag to be set when the section file on disk is actually
updated. The efn argument is a longword specifying the number of
the event flag.
iosb
VMS usage: io_status_block
type: quadword (unsigned)
access: write only
mechanism: by reference
I/O status block that is to receive the final completion status of
the updating operation. The iosb argument is the address of the
quadword I/O status block.
astadr
VMS usage: ast_procedure
type: procedure entry mask
access: call without stack unwinding
mechanism: by
reference--procedure reference or descriptor
AST routine to be executed when the section file has been updated.
The astadr argument is the address of the entry mask of this
routine.
astprm
VMS usage: user_arg
type: longword (unsigned)
access: read only
mechanism: by value
AST parameter to be passed to the AST routine. The astprm argument
is this longword parameter.
$UPDSECW
The Update Section File on Disk and Wait service writes all modified
pages in an active private or global section back into the section
file on disk. One or more I/O requests are queued, based on the
number of pages that have been modified.
The $UPDSECW service completes synchronously; that is, it returns to
the caller after writing all updated pages.
For asychronous completion, use the Update Section File on Disk
($UPDSEC) service; $UPDSEC returns to the caller after queuing the
update request, without waiting for the pages to be updated.
In all other respects, $UPDSECW is identical to $UPDSEC. Refer to
the documentation of $UPDSEC for all other information about the
$UPDSECW service.
Format:
SYS$UPDSECW inadr [,retadr] [,acmode] [,updflg] [,efn] [,iosb]
[,astadr] [,astprm]
$WAITFR
The Wait for Single Event Flag service tests a specific event flag
and returns immediately if the flag is set. Otherwise, the process
is placed in a wait state until the event flag is set.
Format:
SYS$WAITFR efn
Argument
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of the event flag for which to wait. The efn argument is a
longword containing this number.
$WAKE
The Wake Process from Hibernation service activates a process that
has placed itself in a state of hibernation with the Hibernate
($HIBER) service.
Format:
SYS$WAKE [pidadr] ,[prcnam]
Arguments:
pidadr
VMS usage: process_id
type: longword (unsigned)
access: modify
mechanism: by reference
Process identification (PID) of the process to be awakened. The
pidadr argument is the address of a longword containing the PID.
prcnam
VMS usage: process_name
type: character-coded text string
access: read only
mechanism: by descriptor--fixed
length string descriptor
Process name of the process to be awakened. The prcnam argument is
the address of a character string descriptor pointing to a 1- to
15-character process name string.
$WFLAND
The Wait for Logical AND of Event Flags service allows a process to
specify a set of event flags for which it wishes to wait. The
process is put in a wait state until all specified event flags are
set, at which time $WFLAND returns to the caller and execution
resumes.
Format:
SYS$WFLAND efn ,mask
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of any event flag within the event flag cluster that is to be
used. The efn argument is a longword containing this number.
Specifying the number of an event flag within the cluster serves to
identify the event flag cluster.
mask
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Event flags for which the process is to wait. The mask argument is
a longword bit vector wherein a bit, when set, selects the
corresponding event flag for which to wait.
$WFLOR
The Wait for Logical OR of Event Flags service allows a process to
specify a set of event flags for which it wishes to wait. The
process is put in a wait state until any one of the specified event
flags is set, at which time $WFLOR returns to the caller and
execution resumes.
Format:
SYS$WFLOR efn ,mask
Arguments:
efn
VMS usage: ef_number
type: longword (unsigned)
access: read only
mechanism: by value
Number of any event flag within the event flag cluster that is to be
used. The efn argument is a longword containing this number.
Specifying the number of an event flag within the cluster serves to
identify the event flag cluster.
mask
VMS usage: mask_longword
type: longword (unsigned)
access: read only
mechanism: by value
Event flags for which the process is to wait. The mask argument is
a longword bit vector wherein a bit, when set, selects the
corresponding event flag for which to wait.