Trailing-Edge
-
PDP-10 Archives
-
BB-AI48A-BM
-
dtr20-sources/str.mac
There are no other files named str.mac in the archive.
TITLE STR Home of text strings for DATATRIEVE-20
COMMENT #
COPYRIGHT (c) 1984 BY
DIGITAL EQUIPMENT CORPORATION, MAYNARD
MASSACHUSETTS. ALL RIGHTS RESERVED.
THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY
BE USED AND COPIED ONLY IN ACCORDANCE WITH THE
TERMS OF SUCH LICENSE AND WITH THE INCLUSION OF THE
ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER
COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE
MADE AVAILABLE TO ANY OTHER PERSON. NO TITLE TO
AND OWNERSHIP OF THE SOFTWARE IS HEREBY
TRANSFERRED.
THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO
CHANGE WITHOUT NOTICE AND SHOULD NOT BE CONSTRUED
AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR
RELIABILITY OF ITS SOFTWARE ON EQUIPMENT THAT IS
NOT SUPPLIED BY DIGITAL.
This module contains text strings which can be changed
when installing DATATRIEVE. In general, two major facilities
are resident here; they are the Foreign Language Facility and
Customer Written Functions. Error message strings of
the Foreign Language Facility are resident in ERR.MAC.
The Foreign Language Facility permits the customers to change
any keyword or text string into another language.
Customer Written Functions allow the customers to write
their own functions.
EDIT HISTORY
EDIT 1 PMV 7-Feb-84 Make FIN ambiguous (FINd and FINish)
EDIT 2 PMV 7-Feb-84 Correctly alphabetize FN$STR_FIRST_CHAR
EDIT 4 POM 8-Feb-84 Change spelling of H_FLOAT to H_FLOATING
EDIT 7 PMV 8-Feb-84 Add error message for missing picture
EDIT 24 SZ 1-Mar-84 Make certain keyword tables global
EDIT 41 PMV 21-Mar-84 Add error message for unbalanced quotes
EDIT 43 PMV 26-Mar-84 Add string for wild-carded file names
EDIT 45 PMV 27-Mar-84 Add STRUCS table for uppercasing strings
EDIT 51 SZ 5-Apr-84 Add keywords for SET DISPLAY_USER_INPUT
EDIT 53 PMV 17-Apr-84 Make STR TWOSEG
EDIT 56 PMV 20-Apr-84 Use IFIW for STRCAS, STRUCS, STRSIX
#
COMMENT #
Foreign Language Facility -- TEXT STRING GENERAL INFO
Strings are accessed by using a string pointer vector
and a string length vector. As a result, strings may
be changed or be made of a different length, but the
names of string tables and the order of the strings
in each table must NOT BE CHANGED! Also note that
the context in which the string is used may limit its
size. Making a string very long may cause unpredicatable
results.
VECTOR labels must be global, and declared external in
KWMAC.REQ. Vector offsets are each given a symbolic name
in KWMAC.REQ.
The ENG$S macro builds the vector of pointers and the strings
themselves. The ENG$L macro builds the vector of string
lengths. If a particular string table is always accessed as
ASCIZ strings, then the length vector need not be built.
#
SEARCH MONSYM,MACSYM
TWOSEG 400000 ;Put all strings in the high segment
; Define macros to make string definition easier
; Define macros which build string pointers
DEFINE SP(Z),< POINT 7,[ASCIZ ~'Z~]>
; Define a macro which yields string length
DEFINE SL(Z),< LEN.==0
IRPC Z,<LEN.==LEN.+1>
EXP LEN. >
; Define a macro which builds a vector of string pointers
DEFINE ENG$S(NAME),<NAME(SP)>
DEFINE GER$S(NAME),<;;>
DEFINE FRN$S(NAME),<;;>
DEFINE SPN$S(NAME),<;;>
; Define a macro which builds a vector of string lengths
DEFINE ENG$L(NAME),<NAME(SL)>
DEFINE GER$L(NAME),<;;>
DEFINE FRN$L(NAME),<;;>
DEFINE SPN$L(NAME),<;;>
; Define a macro which builds string descriptors
DEFINE DESC(TEXT),<
LEN.==0
IRPC TEXT,<LEN.==LEN.+1>
1006,,LEN.
POINT 7,[ASCIZ ~'TEXT~]
>
; Define a macro which builds ASCIC (ASCII counted) strings
DEFINE ASCIC(TEXT),<
LEN.==0
IRPC TEXT,<LEN.==LEN.+1>
EXP LEN.-2
ASCIZ 'TEXT
>
; Assorted descriptors and ASCIC strings
STRDSC::
[DESC < >]
STRCUR:: 0 ; Name of the CURRENT collection
ASCIC /CURRENT/
;
; Foreign Language Facility -- TEXT STRINGS
;
; Random string table
; The content and length of these strings can be changed,
; but their position in the table cannot!
DEFINE RND($STR),<
$STR <!Buffer overflow, text lost.
> ; Placed in input stream if text in
; edited temp file overflows
; incore buffer
$STR <SYSTEM:EXEC.EXE> ; File to get on PUSH
$STR <EDITOR:> ; File to get on EDIT
$STR <DTR-EDIT.J> ; Prefix of edit temp file
$STR <DTR-COLLECTION.TMP.-1> ; FSG temp file name
$STR <EDIT > ; EXEC command to cause editing
$STR <??DATATRIEVE ERROR, > ; Prefix of SEVERE errors
$STR <*****> ; Prefix of help blurb in Help file
$STR <HLP:DTR.COMBINED-HLP> ; Name of help file
$STR <Not a valid variable, collection, plot, or table name>
; Syntax error sub message (bad names)
$STR <Context variable cannot be qualified>
; Syntax error sub message
$STR <Double negation not allowed> ; Syntax error sub message
$STR <Not a valid term in a value expression>
; Syntax error sub message
$STR <FILLER> ; For record definition
$STR <REDEFINES> ; ditto
$STR <OCCURS> ; ditto
$STR <Not a valid field name> ; Syntax error sub message
$STR <Edit string longer than 256 characters>
; Syntax error sub message
$STR <USAGE> ; For record definition
$STR <BLANK> ; ditto
$STR <COMPUTED BY> ; ditto
$STR <DEFAULT> ; ditto
$STR <JUSTIFY> ; ditto
$STR <MISSING> ; ditto
$STR <PICTURE> ; ditto
$STR <QUERY HEADER> ; ditto
$STR <QUERY NAME> ; ditto
$STR <SCALE> ; ditto
$STR <SIGN> ; ditto
$STR <SYNC> ; ditto
$STR <VALID IF> ; ditto
$STR <Not a valid query name> ; Syntax error sub message
$STR <EDIT STRING> ; Record parsing
$STR <Does not appear to be a statement or command>
; Syntax error sub message
$STR <DD-MMM-YYYY> ; Default date edit string
$STR <-9.9999999E+99> ; Default float edit string
$STR <No > ; SHOW set options
$STR <Abort> ;
$STR <Prompt> ;
$STR <Data_loss_warning> ;
$STR <Computed value> ; SHOW variables or fields
$STR <Indexed field> ;
$STR <Number> ;
$STR <Character string> ;
$STR <Date> ;
$STR <, indexed field> ;
$STR <List> ;
$STR < > ; 80 spaces
$STR <***** Parsing completes, resulting in SYN tree:> ; For tracing
$STR <***** Precompilation completes, resulting in ICS tree:>
$STR <***** Compilation completes, resulting in EXE tree:>
$STR <***** Command execution begins of SYN tree:>
$STR <***** Statement execution of EXE node:>
$STR <creat> ; RMS functions for error message
$STR <putt> ;
$STR <gett> ;
$STR <open> ;
$STR <clos> ;
$STR <connect> ;
$STR <display> ;
$STR <disconnect>
$STR <free>
$STR <Start of trace file for Datatrieve-20 V1.0 > ; More tracing
$STR <End of trace file for Datatrieve-20 V1.0 > ; More tracing
$STR <Not a valid dictionary path name> ; Dictionary access error sub message
$STR <Not a domain name from the domain list> ; View definition error sub mess
$STR <OCCURS clause requires at least one FROM field at a lower level>
$STR <CDD$TOP> ; Dictionary logical name
$STR <CDD$DEFAULT> ; Dictionary logical name
$STR <CDD$PLOTS> ; Dictionary logical name
$STR <.CDD-> ; Dic element file type prefix
$STR <DSK:> ; Dictionary logical name
$STR <Domain table> ; Dic access error sub message
$STR <Dictionary table> ; Dic access error sub message
$STR <Not a valid domain name> ; Error sub message
$STR <Not a valid plot name> ; Error sub message
$STR <Error in level number, not between 1 and 65 and increasing>
$STR <Procedure> ; Dictionary stuff
$STR <Record>
$STR <Domain>
$STR <Table>
$STR <Plot>
$STR <Plot Name>
$STR <Entry>
$STR <Delete>
$STR <Define>
$STR <End_procedure>
$STR <End_table>
$STR <End_plot>
$STR <Search>
$STR <AVERAGE> ; Statistical function col titles
$STR <MAX>
$STR <MIN>
$STR <TOTAL>
$STR <COUNT>
$STR <STANDARD_DEVIATION>
$STR <RUNNING_TOTAL>
$STR <RUNNING_COUNT>
$STR <find> ; More RMS functions
$STR <updat>
$STR <delet>
$STR <COUNT or RUNNING COUNT must be enclosed in parentheses before FROM or VIA>
$STR <DTR$DATE_INPUT> ; Logical name for date input format
$STR <SYS$CURRENCY> ; Logical name for dollar sign
$STR <SYS$RADIX_POINT> ; Logical name for radix point
$STR <SYS$DIGIT_SEP> ; Logical name for comma
$STR <TAKE > ; EXEC command for PUSH foo.bar
$STR <-30> ; Object type of DDMF server
$STR <;USER:> ; Network file spec
$STR <;PASS:> ; Network file spec
$STR <;CHARGE:> ; Network file spec
$STR <DCN:> ; Network file spec
$STR <Verify> ; Set command option word
$STR <SYS:ADT.EXE> ; ADT program
$STR <PAGE> ; Suberror, report writer AT
$STR <REPORT> ; ditto
$STR <Cannot end a PICTURE or EDIT string with a comma or period>
$STR <Missing picture or edit string>
; Syntax error sub message
$STR <*> ; Wild file name (or extension)
$STR <Display_user_input for errors> ; more show set-up options
$STR <Display_user_input for warnings> ; ditto
$STR <Releas> ; another RMS function error
$STR <Lock_wait> ; another set-up option
>
; Note that the first string is a CRLF with a length of 3. This
; includes the null in the string length so that when a CRLF is
; copied into a buffer in DATATRIEVE, the string becomes ASCIZ
STRRND:: POINT 7,[ASCIZ /
/]
ENG$S(RND)
LENRND:: ^D3
ENG$L(RND)
;
; Foreign Language Facility -- SHOW READY TEXT STRINGS
;
DEFINE FIL($STR),<
$STR <RMS> ; Types of domains
$STR <DBMS>
$STR <View>
$STR <Port>
$STR <Remote>
$STR <Relative> ; Types of RMS files
$STR <Indexed>
$STR <Sequential>
$STR <Exclusive> ; Ways of locking files and records
$STR <Shared>
$STR <Protected>
$STR <Read> ; Access privileges
$STR <Write>
$STR <Modify>
$STR <Extend>
>
STRFIL:: ENG$S(FIL)
LENFIL:: ENG$L(FIL)
;
; Foreign Language Facility -- PROMPT STRINGS
;
; (Note that <> cannot be used, they are magic to MACRO)
STRPMT::
POINT 7,[ASCIZ "DTR> "]
POINT 7,[ASCIZ "CON> "]
POINT 7,[ASCIZ "DFN> "]
POINT 7,[ASCIZ "RW> "]
;
; Foreign Language Facility -- DAYS of the WEEK
DEFINE WKD($STR),<
$STR <Monday>
$STR <Tuesday>
$STR <Wednesday>
$STR <Thursday>
$STR <Friday>
$STR <Saturday>
$STR <Sunday>
>
STRWKD:: ENG$S(WKD)
LENWKD:: ENG$L(WKD)
;
; Foreign Language Facility -- MONTHS of the YEAR
;
DEFINE MON($STR),<
$STR <January>
$STR <February>
$STR <March>
$STR <April>
$STR <May>
$STR <June>
$STR <July>
$STR <August>
$STR <September>
$STR <October>
$STR <November>
$STR <December>
>
STRMON:: ENG$S(MON)
LENMON:: ENG$L(MON)
;
; Foreign Language Facility -- POOL NAMES FOR SHOW MEMORY COMMAND
DEFINE PLN($STR),<
$STR <Null>
$STR <Permanent>
$STR <Parse>
$STR <Run time>
$STR <Execution>
$STR <Domain>
$STR <Cluster>
$STR <Source>
$STR <Collection>
$STR <Plot>
>
STRPLN:: ENG$S(PLN)
;
; Foreign Language Facility -- HELP TOPICS
DEFINE HLP($STR),<
$STR <Procedure>
$STR <Exit_command>
$STR <Close_command>
$STR <Edit_command>
$STR <Open_command>
$STR <Push_command>
$STR <Set_option>
$STR <Show_option>
$STR <Indirect_file>
$STR <Abort_statement>
$STR <Begin_statement>
$STR <Display_statement>
$STR <If_statement>
$STR <Print_statement>
$STR <Release_option>
$STR <Repeat_statement>
$STR <While_statement>
$STR <Value_expression>
$STR <Statement>
$STR <Statement_or_command>
$STR <Help_command>
$STR <Boolean_expression>
$STR <Name>
$STR <Numeric_or_string_literal>
$STR <Prompt_expression>
$STR <Record_selection_expression>
$STR <Sort_list>
$STR <Function>
$STR <Statistical_function>
$STR <Trace_option>
$STR <Relational_operator>
$STR <Declare_statement>
$STR <Field_definition_clause>
$STR <Picture_or_edit_string>
$STR <Header_segment>
$STR <Assignment_statement>
$STR <Output_file_specification>
$STR <Print_list>
$STR <Define_subcommand>
$STR <Plot_definition>
$STR <Dictionary_path_name>
$STR <Define_file_option>
$STR <Delete_command>
$STR <Extract_command>
$STR <Adt_command>
$STR <Ready_command>
$STR <Finish_command>
$STR <Domain_name>
$STR <Sum_statement>
$STR <Select_statement>
$STR <Sort_statement>
$STR <Store_statement>
$STR <Modify_statement>
$STR <Drop_statement>
$STR <Erase_statement>
$STR <Find_statement>
$STR <For_statement>
$STR <List_statement>
$STR <On_statement>
$STR <Report_statement>
$STR <Report_at_statement>
$STR <Report_set_statement>
$STR <Report_print_statement>
$STR <End_report_statement>
>
STRHLP:: ENG$S(HLP)
COMMENT #
Foreign Language Facility -- PARSING TABLES
This section of STR contains the FDBs and KEYWORD tables for
use by the COMND% and TBxxx% JSYSs.
Note that the two date tables have no associated FDBs because
they are used solely by TBxxx and not COMND
If you change any strings, the entire table must remain
in alphabetical order, and the data associated with the
string must remain the same!!!!!
#
; Macros used to build English keyword table entries.
DEFINE KEYBEG(XXXX),<
IF1,<IFDEF K$'XXXX,<PRINTX ? 'XXXX has already been used as a keyword table>>
K$'XXXX: XWD L$'XXXX,L$'XXXX ;;Length of table,,Max length of table
>
DEFINE KEYEND(XXXX),<
L$'XXXX==.-K$'XXXX-1 ;;Length is here minus start minus 1
>
DEFINE ENG$K(STRING,DATA),<[ASCIZ ~'STRING~],,DATA>
DEFINE ENG$I(STRING,DATA),<[CM%FW!CM%INV
ASCIZ ~'STRING~],,DATA>
DEFINE ENG$N(STRING,DATA),<[CM%FW!CM%INV!CM%NOR
ASCIZ ~'STRING~],,0>
DEFINE ENG$A(STRING,DATA),<IRP STRING,<[CM%FW!CM%INV!CM%ABR
ASCIZ ~'STRING~],,DATA>>
; Macros used to build foreign language keyword table entries.
; When you wish to make a foreign language DATATRIEVE, replace
; xxx$K, xxx$I, etc. with definitions similar to ENG$K, ENG$I, etc.
; You should also make ENG$K words invisible so that network
; users can still use English commands with a foreign DATATRIEVE.
DEFINE GER$K(STRING,DATA),<;;> ;German
DEFINE GER$I(STRING,DATA),<;;> ;Invisible German keywords
DEFINE GER$N(STRING,DATA),<;;> ;Invisible German non-keywords
DEFINE GER$A(STRING,DATA),<;;> ;Invisible German keyword abbreviations
DEFINE FRN$K(STRING,DATA),<;;> ;French
DEFINE FRN$I(STRING,DATA),<;;> ;Invisible French keywords
DEFINE FRN$N(STRING,DATA),<;;> ;Invisible French non-keywords
DEFINE FRN$A(STRING,DATA),<;;> ;Invisible French keyword abbreviations
DEFINE SPN$K(STRING,DATA),<;;> ;Spanish
DEFINE SPN$I(STRING,DATA),<;;> ;Invisible Spanish keywords
DEFINE SPN$N(STRING,DATA),<;;> ;Invisible Spanish non-keywords
DEFINE SPN$A(STRING,DATA),<;;> ;Invisible Spanish keyword abbreviations
;
; Foreign Language Facility -- KEYWORD TABLES
STRKST::
KEYBEG(STAT) ; Statements
ENG$N(A)
ENG$K(Abort,^D1)
GER$K(Aendere,^D11)
GER$K(Ausschliesse,^D5)
GER$K(Ausstreiche,^D6)
GER$K(Auswaehle,^D17)
ENG$K(Begin,^D2)
GER$K(Begin,^D2)
GER$K(Bei,^D12)
GER$K(Berichte,^D16)
ENG$N(De)
ENG$K(Declare,^D3)
GER$K(Deklariere,^D3)
ENG$K(Display,^D4)
ENG$K(Drop,^D5)
GER$K(Drucke,^D14)
ENG$N(E)
GER$K(Einzeichne,^D13)
GER$K(Ende,^D1)
ENG$K(Erase,^D6)
ENG$N(Fin)
ENG$K(Find,^D7)
GER$K(Finde,^D7)
ENG$K(For,^D8)
GER$K(Fuer,^D8)
ENG$K(If,^D9)
ENG$K(List,^D10)
GER$K(Liste,^D10)
ENG$K(Modify,^D11)
ENG$N(O)
ENG$K(On,^D12)
ENG$K(Plot,^D13)
ENG$K(Print,^D14)
ENG$N(Re)
ENG$K(Repeat,^D15)
ENG$K(Report,^D16)
GER$K(Schaue,^D4)
GER$K(Schreibe,^D19)
ENG$N(Se)
ENG$K(Select,^D17)
ENG$K(Sort,^D18)
GER$K(Sortiere,^D18)
ENG$K(Store,^D19)
ENG$K(Sum,^D20)
GER$K(Summiere,^D20)
GER$K(Waehrend,^D21)
GER$K(Wenn,^D9)
ENG$K(While,^D21)
GER$K(Wiederhole,^D15)
KEYEND(STAT)
STRKCM::
KEYBEG(COMM) ; Commands
GER$K(Abbreche,^D6)
GER$K(Abschliesse,^D8)
ENG$K(Adt,^D1)
GER$K(Adt,^D1)
GER$K(Ausgebe,^D5)
GER$K(Befreie,^D13)
GER$K(Bereite,^D12)
ENG$K(Close,^D2)
ENG$K(Define,^D3)
GER$K(Definiere,^D3)
ENG$K(Delete,^D4)
ENG$K(Edit,^D5)
GER$K(Eroeffne,^D10)
ENG$K(Exit,^D6)
ENG$K(Extract,^D7)
ENG$K(Finish,^D8)
ENG$K(Help,^D9)
GER$K(Herauszeihe,^D7)
GER$K(Hilfe,^D9)
GER$K(Loesche,^D4)
GER$K(Nimm,^D16)
ENG$K(Open,^D10)
ENG$K(Push,^D11)
ENG$K(Ready,^D12)
ENG$K(Release,^D13)
GER$K(Rette,^D11)
GER$K(Schliesse,^D2)
ENG$K(Set,^D14)
GER$K(Setze,^D14)
ENG$K(Show,^D15)
ENG$K(Take,^D16)
GER$K(Zeige,^D15)
KEYEND(COMM)
KEYBEG(DEFI) ; Define command options
ENG$K(Domain,^D1)
ENG$K(File,^D2)
ENG$K(Plot,^D3)
ENG$K(Port,^D4)
ENG$K(Procedure,^D5)
ENG$K(Record,^D6)
ENG$K(Table,^D7)
KEYEND(DEFI)
KEYBEG(PSTA) ; Plot Statement options
ENG$K(Begin,^D1)
ENG$A(<D,Da,Dat,Date,Date-exp>,K$PST1)
K$PST1: ENG$K(Date_exp,^D2)
ENG$K(If,^D3)
ENG$K(Incr,^D4)
ENG$K(Plot,^D5)
ENG$K(Print,^D6)
ENG$K(Sort,^D7)
ENG$K(While,^D8)
KEYEND(PSTA)
KEYBEG(TRAC) ; Open command options
ENG$K(Compilation,^D1)
ENG$A(<En,Ent,Entr,Entry,Entry-exit>,K$TRA1)
K$TRA1: ENG$K(Entry_exit,^D2)
ENG$K(Execution,^D4)
ENG$K(Parsing,^D8)
ENG$K(Precompilation,^D16)
KEYEND(TRAC)
KEYBEG(SHOW) ; Show command options
ENG$K(All,^D1)
ENG$K(Collections,^D2)
ENG$K(Current,^D3)
ENG$K(Dictionary,^D4)
ENG$K(Domains,^D5)
ENG$K(Fields,^D6)
ENG$A(<M,Me,Mem,Memo,Memor,Memory,Memory-use>,K$SHO1)
K$SHO1: ENG$K(Memory_use,^D7)
ENG$K(Plots,^D8)
ENG$K(Procedures,^D9)
ENG$K(Ready,^D10)
ENG$K(Records,^D11)
ENG$A(<S,Se,Set,Set-up>,K$SHO2)
K$SHO2: ENG$K(Set_up,^D12)
ENG$K(Tables,^D13)
ENG$K(Variables,^D14)
KEYEND(SHOW)
KEYBEG(SET) ; Set command options
ENG$K(Abort,^D1)
ENG$A(<C,Co,Col,Colu,Colum,Column,Columns,Columns-page>,K$SET1)
K$SET1: ENG$K(Columns_page,^D2)
ENG$A(<Da,Dat,Data,Data-loss-warning>,K$SET2)
K$SET2: ENG$K(Data_loss_warning,^D3)
ENG$K(Dictionary,^D4)
ENG$A(<Dis,Disp,Displ,Displa,Display,Display-user-input>,K$SET3)
K$SET3: ENG$K(Display_user_input,^D13)
ENG$K(Lock_wait,^D14)
ENG$K(No,^D7)
ENG$K(Plots,^D8)
ENG$K(Prompt,^D9)
ENG$K(Search,^D11)
ENG$K(Verify,^D12)
KEYEND(SET)
KEYBEG(NOSE) ; Set NO options
ENG$K(Abort,^D1)
ENG$A(<Da,Dat,Data,Data-loss-warning>,K$NOS1)
K$NOS1: ENG$K(Data_loss_warning,^D3)
ENG$A(<Dis,Disp,Displ,Displa,Display,Display-user-input>,K$NOS2)
K$NOS2: ENG$K(Display_user_input,^D13)
ENG$K(Lock_wait,^D14)
ENG$K(Prompt,^D9)
ENG$K(Search,^D11)
ENG$K(Verify,^D12)
KEYEND(NOSE)
KEYBEG(SDUI) ; Set Display_User_Input
ENG$K(Any,^D1)
ENG$K(Error,^D2)
ENG$K(Warning,^D3)
KEYEND(SDUI)
KEYBEG(PW) ; Single Plot function words
ENG$K(<$>,^D1)
ENG$K(Center,^D2)
ENG$K(Clrlin,^D3)
ENG$K(Clrscr,^D4)
ENG$K(Cos,^D5)
ENG$K(Cvt,^D6)
ENG$K(Date,^D7)
ENG$I(Date-com,^D8)
ENG$I(Date-str,^D9)
ENG$K(Date_com,^D8)
ENG$K(Date_str,^D9)
ENG$A(<En,Ent,Ente,Enter,Enter-regis>,K$PW1)
K$PW1: ENG$K(Enter_regis,^D10)
ENG$A(<Ex,Exi,Exit,Exit-regis>,K$PW2)
K$PW2: ENG$K(Exit_regis,^D11)
ENG$K(Int,^D12)
ENG$K(Length,^D13)
ENG$K(Log,^D14)
ENG$K(Lx,^D15)
ENG$K(Lxy,^D16)
ENG$K(Ly,^D17)
ENG$K(Max,^D18)
ENG$K(Min,^D19)
ENG$K(Mod,^D20)
ENG$K(Quote,^D21)
ENG$K(Rx,^D22)
ENG$K(Rxy,^D23)
ENG$K(Ry,^D24)
ENG$K(Search,^D25)
ENG$K(Sin,^D26)
ENG$K(Size,^D27)
ENG$K(Sqrt,^D28)
ENG$A(<Su,Sub,Sub-str>,K$PW3)
K$PW3: ENG$K(Sub_str,^D29)
ENG$K(Txy,^D30)
KEYEND(PW)
KEYBEG(FRVI) ; From and Via operators
ENG$K(From,^D1)
ENG$K(Via,^D2)
KEYEND(FRVI)
STRKSF::
KEYBEG(STAF) ; Statistical functions
ENG$K(Average,^D1)
ENG$K(Count,^D2)
ENG$K(Max,^D3)
ENG$K(Min,^D4)
ENG$K(Running,^D5)
ENG$A(<S,St,Std,Std-dev>,K$STA1)
K$STA1: ENG$K(Std_dev,^D6)
ENG$K(Total,^D7)
KEYEND(STAF)
STRKRN::
KEYBEG(RUNN) ; Running options
ENG$K(Count,^D1)
ENG$K(Total,^D2)
KEYEND(RUNN)
KEYBEG(ARIT) ; Arithmetic operators
ENG$K(<*>,^D1)
ENG$K(<+>,^D2)
ENG$K(<->,^D3)
ENG$K(</>,^D4)
ENG$K(<|>,^D5)
ENG$K(<||>,^D6)
ENG$K(<|||>,^D7)
KEYEND(ARIT)
KEYBEG(PLAR) ; Plot arithmetic operators
ENG$K(<*>,^D1)
ENG$K(<**>,^D2)
ENG$K(<+>,^D3)
ENG$K(<->,^D4)
ENG$K(</>,^D5)
ENG$K(<|>,^D6)
KEYEND(PLAR)
KEYBEG(RELO) ; Relational operators
[ASCIZ ~<~],,1
[ASCIZ ~=~],,2
[ASCIZ ~>~],,3
ENG$K(After,^D3)
ENG$K(Before,^D1)
ENG$K(Between,^D4)
ENG$K(Bt,^D4)
ENG$K(Containing,^D5)
ENG$K(Equals,^D2)
ENG$K(GE,^D6)
ENG$I(Greater-equal,^D6)
ENG$I(Greater-than,^D3)
ENG$K(Greater_equal,^D6)
ENG$K(Greater_than,^D3)
ENG$K(GT,^D3)
ENG$K(In,^D7)
ENG$K(LE,^D8)
ENG$I(Less-equal,^D8)
ENG$I(Less-than,^D1)
ENG$K(Less_equal,^D8)
ENG$K(Less_than,^D1)
ENG$K(LT,^D1)
ENG$K(Missing,^D9)
ENG$K(NE,^D10)
ENG$K(Not,^D11)
ENG$K(Notequal,^D10)
ENG$I(Not-equal,^D10)
ENG$K(Not_equal,^D10)
KEYEND(RELO)
KEYBEG(PREL) ; Plot relational operators
[ASCIZ ~<~],,^D1
; Plot does not use "=" on purpose
[ASCIZ ~>~],,^D2
ENG$K(EQ,^D3)
ENG$K(GE,^D4)
ENG$K(GT,^D2)
ENG$K(LE,^D5)
ENG$K(LT,^D1)
ENG$K(NE,^D6)
KEYEND(PREL)
KEYBEG(FUNC) ; Functions
ENG$K(FN$Abs,^D0)
ENG$K(FN$Atan,^D7)
ENG$K(FN$Cos,^D8)
ENG$K(FN$Create_log,^D9)
ENG$K(FN$Date,^D10)
ENG$K(FN$Day,^D11)
ENG$I(FN$Day-of-week,^D37)
ENG$K(FN$Day_of_week,^D37)
ENG$A(<FN$De,FN$Del,FN$Dele,FN$Delet,FN$Delete,FN$Delete-log>,K$FUN1)
K$FUN1: ENG$K(FN$Delete_log,^D12)
ENG$K(FN$Exp,^D13)
ENG$K(FN$Floor,^D14)
ENG$K(FN$Hex,^D15)
ENG$K(FN$Hour,^D16)
ENG$K(FN$Hundredth,^D17)
ENG$A(<FN$I,FN$In,FN$Ini,FN$Init,FN$Init-timer>,K$FUN2)
K$FUN2: ENG$K(FN$Init_timer,^D18)
ENG$K(FN$Julian,^D19)
ENG$K(FN$Ln,^D20)
ENG$K(FN$Log10,^D21)
ENG$K(FN$Minute,^D22)
ENG$K(FN$Mod,^D1)
ENG$K(FN$Month,^D23)
ENG$K(FN$Nint,^D24)
ENG$K(FN$Octal,^D36)
ENG$A(<FN$Op,FN$Ope,FN$Open,FN$Opens,FN$Opens-left>,K$FUN3)
K$FUN3: ENG$K(FN$Opens_left,^D5)
ENG$K(FN$Second,^D25)
ENG$A(<FN$Sh,FN$Sho,FN$Show,FN$Show-timer>,K$FUN4)
K$FUN4: ENG$K(FN$Show_timer,^D26)
ENG$K(FN$Sign,^D27)
ENG$K(FN$Sin,^D28)
ENG$K(FN$Sqrt,^D29)
ENG$I(FN$Str-extract,^D2)
ENG$I(FN$Str-first-char,^D3)
ENG$I(FN$Str-loc,^D6)
ENG$K(FN$Str_extract,^D2)
ENG$K(FN$Str_first_char,^D3)
ENG$K(FN$Str_loc,^D6)
ENG$K(FN$Tan,^D30)
ENG$K(FN$Time,^D31)
ENG$A(<FN$Tr,FN$Tra,FN$Tran,FN$Trans,FN$Trans-log>,K$FUN5)
K$FUN5: ENG$K(FN$Trans_log,^D4)
ENG$K(FN$Upcase,^D32)
ENG$K(FN$Week,^D33)
ENG$K(FN$Width,^D34)
ENG$K(FN$Year,^D35)
KEYEND(FUNC)
KEYBEG(BOOL) ; Boolean operators
ENG$K(And,^D1)
ENG$K(But,^D1)
ENG$K(Or,^D2)
KEYEND(BOOL)
STRKDC::
KEYBEG(DECL) ; Field declaration options
ENG$N(B)
ENG$K(Blank,^D1)
ENG$N(Comp)
ENG$K(Computed,^D2)
ENG$N(D)
ENG$K(Default,^D3)
ENG$A(<E,Ed,Edi,Edit,Edit-string>,K$DEC1)
K$DEC1: ENG$K(Edit_string,^D4)
ENG$A(<J,Ju,Jus,Just,Justi,Justif,Justifi>,K$DEC2)
K$DEC2: ENG$K(Justified,^D5)
ENG$I(Justify,^D5)
ENG$K(Missing,^D6)
ENG$K(Occurs,^D7)
ENG$N(Pi)
ENG$K(Picture,^D8)
ENG$I(Query-header,^D9)
ENG$I(Query-name,^D10)
ENG$K(Query_header,^D9)
ENG$K(Query_name,^D10)
ENG$N(Re)
ENG$K(Redefines,^D11)
ENG$K(Scale,^D12)
ENG$K(Sign,^D13)
ENG$K(Synchronized,^D14)
ENG$K(Usage,^D15)
ENG$N(Va)
ENG$K(Valid,^D16)
KEYEND(DECL)
KEYBEG(LEFT) ; Left or Right
ENG$K(Left,^D1)
ENG$K(Right,^D2)
KEYEND(LEFT)
STRKUS::
KEYBEG(USAG) ; Usage types
ENG$K(Byte,^D1)
ENG$K(Comp,^D1)
ENG$I(Comp-1,^D2)
ENG$I(Comp-2,^D3)
ENG$I(Comp-3,^D6)
ENG$I(Comp-5,^D6)
ENG$K(Comp_1,^D2)
ENG$K(Comp_2,^D3)
ENG$K(Comp_3,^D6)
ENG$K(Comp_5,^D6)
ENG$K(Date,^D5)
ENG$A(<Di,Dis,Disp,Displ,Displa,Display>,K$USA1)
ENG$I(Display-6,^D4)
ENG$I(Display-7,^D6)
ENG$I(Display-8,^D8)
ENG$K(Display_6,^D4)
K$USA1: ENG$K(Display_7,^D6)
ENG$K(Display_8,^D8)
ENG$K(Double,^D3)
ENG$K(Integer,^D1)
ENG$K(Long,^D7)
ENG$K(Packed,^D6)
ENG$K(Quad,^D7)
ENG$K(Real,^D2)
ENG$I(VAX-date,^D9)
ENG$I(VAX-float,^D10)
ENG$K(VAX_date,^D9)
ENG$K(VAX_float,^D10)
ENG$K(Word,^D1)
ENG$K(Zoned,^D6)
KEYEND(USAG)
KEYBEG(SIGN) ; Leading or trailing
ENG$K(Leading,^D1)
ENG$K(Trailing,^D2)
KEYEND(SIGN)
KEYBEG(SORT) ; Sort order
ENG$K(Ascending,^D1)
ENG$K(Decreasing,^D2)
ENG$K(Descending,^D2)
ENG$K(Increasing,^D1)
KEYEND(SORT)
KEYBEG(SELE) ; Select options
ENG$K(First,^D1)
ENG$K(Last,^D2)
ENG$K(Next,^D3)
ENG$K(None,^D5)
ENG$K(Prior,^D4)
KEYEND(SELE)
STRKFM::
KEYBEG(FORM) ; Print format options
ENG$K(Column,^D1)
ENG$A(<N,Ne,New,New-page>,K$FOR1)
K$FOR1: ENG$K(New_page,^D2)
ENG$K(Skip,^D3)
ENG$K(Space,^D4)
ENG$K(Tab,^D5)
KEYEND(FORM)
KEYBEG(VERB) ; Open command verbosity levels
ENG$K(High,^D1)
ENG$K(Low,^D2)
ENG$K(Medium,^D3)
KEYEND(VERB)
KEYBEG(DFIL) ; Define file options
ENG$K(Allocation,^D1)
ENG$K(Key,^D2)
ENG$K(Max,^D3)
ENG$K(Stream,^D4)
ENG$K(Supersede,^D5)
ENG$K(Variable,^D6)
KEYEND(DFIL)
KEYBEG(KEYT) ; Define indexed file options
ENG$K(Change,^D1)
ENG$K(Dup,^D2)
KEYEND(KEYT)
KEYBEG(TAB) ; Define table options
ENG$A(<E,Ed,Edi,Edit,Edit-string>,K$TAB1)
K$TAB1: ENG$K(Edit_string,^D1)
ENG$A(<Q,Qu,Que,Quer,Query,Query-header>,K$TAB2)
K$TAB2: ENG$K(Query_header,^D2)
KEYEND(TAB)
KEYBEG(PDEC) ; Define Plot declarations
ENG$K(Real,^D1)
ENG$K(String,^D2)
ENG$K(Vector,^D3)
KEYEND(PDEC)
KEYBEG(DEC) ; Declare used in Define Plot
ENG$K(Declare,^D1)
KEYEND(DEC)
KEYBEG(AS)
ENG$K(As,^D1)
KEYEND(AS)
KEYBEG(ACCE)
ENG$K(Extend,^D1)
ENG$K(Modify,^D2)
ENG$K(Read,^D3)
ENG$K(Write,^D4)
KEYEND(ACCE)
KEYBEG(LOCK)
ENG$K(Exclusive,^D1)
ENG$K(Protected,^D2)
ENG$K(Shared,^D3)
KEYEND(LOCK)
KEYBEG(RUSA)
ENG$K(Usage,^D1)
KEYEND(RUSA)
KEYBEG(RUST)
ENG$A(<D,Di,Dis,Disp,Displ,Displa,Display>,K$RUS1)
ENG$I(Display-6,^D1)
ENG$I(Display-7,^D2)
ENG$I(Display-8,^D3)
ENG$K(Display_6,^D1)
K$RUS1: ENG$K(Display_7,^D2)
ENG$K(Display_8,^D3)
KEYEND(RUST)
KEYBEG(RW) ; Report Writer statements
ENG$K(At,^D1)
ENG$A(<E,En,End,End-report>,K$RW1)
K$RW1: ENG$K(End_report,^D2)
ENG$K(Print,^D3)
ENG$K(Set,^D4)
KEYEND(RW)
KEYBEG(RSET) ; Report Set options
ENG$A(<C,Co,Col,Colu,Colum,Column,Columns,Columns-page>,K$RSE1)
K$RSE1: ENG$K(Columns_page,^D1)
ENG$K(Date,^D2)
ENG$A(<L,Li,Lin,Line,Lines,Lines-page>,K$RSE2)
K$RSE2: ENG$K(Lines_page,^D3)
ENG$I(Max-lines,^D4)
ENG$I(Max-pages,^D5)
ENG$K(Max_lines,^D4)
ENG$K(Max_pages,^D5)
ENG$K(Number,^D6)
ENG$A(<R,Re,Rep,Repo,Repor,Report,Report-name>,K$RSE3)
K$RSE3: ENG$K(Report_name,^D7)
KEYEND(RSET)
KEYBEG(RNO) ; Report No Set options
ENG$K(Date,^D1)
ENG$K(Number,^D2)
KEYEND(RNO)
KEYBEG(RAT) ; Report At options
ENG$K(Bottom,^D1)
ENG$K(Top,^D2)
KEYEND(RAT)
KEYBEG(TOPB) ; Report Top/Bottom options
ENG$K(Page,^D1)
ENG$K(Report,^D2)
KEYEND(TOPB)
KEYBEG(RFOM) ; Report Print formating
ENG$K(Column,^D1)
ENG$K(Skip,^D3)
ENG$K(Space,^D4)
ENG$K(Tab,^D5)
KEYEND(RFOM)
KEYBEG(RHDR) ; Header formats for rw
ENG$A(<C,Co,Col,Colu,Colum,Column,Column-header>,K$RHD1)
K$RHD1: ENG$K(Column_header,^D1)
ENG$A(<R,Re,Rep,Repo,Repor,Report,Report-header>,K$RHD2)
K$RHD2: ENG$K(Report_header,^D2)
KEYEND(RHDR)
KEYBEG(RBRK) ; Part of AT REPORT PRINT list
ENG$I(New-page,^D1)
ENG$I(New-section,^D2)
ENG$K(New_page,^D1)
ENG$K(New_section,^D2)
KEYEND(RBRK)
; Single word keyword tables. This may seem odd, but it's the only
; way to have case insensitivity and abbreviations on single words
KEYBEG(WHEN)
ENG$K(When,^D1)
KEYEND(WHEN)
KEYBEG(BY)
ENG$K(By,^D1)
KEYEND(BY)
KEYBEG(VALU)
ENG$K(Value,^D1)
KEYEND(VALU)
KEYBEG(IS)
ENG$K(Is,^D1)
KEYEND(IS)
KEYBEG(SEPA)
ENG$K(Separate,^D1)
KEYEND(SEPA)
KEYBEG(ZERO)
ENG$K(Zero,^D1)
KEYEND(ZERO)
KEYBEG(ANY)
ENG$K(Any,^D1)
KEYEND(ANY)
KEYBEG(THEN)
ENG$K(Then,^D1)
KEYEND(THEN)
KEYBEG(THE)
ENG$K(The,^D1)
KEYEND(THE)
KEYBEG(END)
ENG$K(End,^D1)
KEYEND(END)
KEYBEG(NOT)
ENG$K(Not,^D1)
KEYEND(NOT)
KEYBEG(AND)
ENG$K(And,^D1)
KEYEND(AND)
KEYBEG(OR)
ENG$K(Or,^D1)
KEYEND(OR)
KEYBEG(OF)
ENG$K(Of,^D1)
KEYEND(OF)
KEYBEG(ELSE)
ENG$K(Else,^D1)
KEYEND(ELSE)
KEYBEG(TIME)
ENG$K(Times,^D1)
KEYEND(TIME)
KEYBEG(TO)
ENG$K(To,^D1)
KEYEND(TO)
KEYBEG(DEPE)
ENG$K(Depending,^D1)
KEYEND(DEPE)
KEYBEG(ON)
ENG$K(On,^D1)
KEYEND(ON)
KEYBEG(IF)
ENG$K(If,^D1)
KEYEND(IF)
KEYBEG(CHAR)
ENG$K(Character,^D1)
KEYEND(CHAR)
KEYBEG(ALL)
ENG$K(All,^D1)
KEYEND(ALL)
KEYBEG(FIRS)
ENG$K(First,^D1)
KEYEND(FIRS)
KEYBEG(IN)
ENG$K(In,^D1)
KEYEND(IN)
KEYBEG(CROS)
ENG$K(Cross,^D1)
KEYEND(CROS)
KEYBEG(WITH)
ENG$K(With,^D1)
KEYEND(WITH)
KEYBEG(SORD)
ENG$K(Sorted,^D1)
KEYEND(SORD)
KEYBEG(OVER)
ENG$K(Over,^D1)
KEYEND(OVER)
KEYBEG(USIN)
ENG$K(Using,^D1)
KEYEND(USIN)
KEYBEG(VERI)
ENG$K(Verify,^D1)
KEYEND(VERI)
KEYBEG(OCCU)
ENG$K(Occurs,^D1)
KEYEND(OCCU)
KEYBEG(FOR)
ENG$K(For,^D1)
KEYEND(FOR)
KEYBEG(FROM)
ENG$K(From,^D1)
KEYEND(FROM)
KEYBEG(NO)
ENG$K(No,^D1)
KEYEND(NO)
KEYBEG(AT)
ENG$K(At,^D1)
KEYEND(AT)
KEYBEG(PORT)
ENG$K(Port,^D1)
KEYEND(PORT)
KEYBEG(STRU)
ENG$K(Structure,^D1)
KEYEND(STRU)
KEYBEG(DATA)
ENG$K(Datatype,^D1)
KEYEND(DATA)
KEYBEG(SIZE)
ENG$K(Size,^D1)
KEYEND(SIZE)
KEYBEG(SCAL)
ENG$K(Scale,^D1)
KEYEND(SCAL)
KEYBEG(DIGI)
ENG$K(Digits,^D1)
KEYEND(DIGI)
KEYBEG(CHAS)
ENG$K(Characters,^D1)
KEYEND(CHAS)
KEYBEG(VSTR)
ENG$K(String,^D1)
KEYEND(VSTR)
KEYBEG(SEPO)
ENG$K(Overpunched,^D1)
ENG$K(Separate,^D2)
KEYEND(SEPO)
KEYBEG(SIGU)
ENG$K(Signed,^D1)
ENG$K(Unsigned,^D2)
KEYEND(SIGU)
KEYBEG(CDDL)
ENG$K(Date,^D1)
ENG$K(H_floating,^D2) ;EDIT 4
ENG$K(Numeric,^D3)
ENG$K(PDP10_date,^D4)
ENG$K(PDP10_double,^D5)
ENG$K(PDP10_long,^D6)
ENG$K(PDP10_numeric6,^D7)
ENG$K(PDP10_numeric7,^D8)
ENG$K(PDP10_real,^D9)
ENG$K(PDP10_text6,^D10)
ENG$K(PDP10_text7,^D11)
ENG$K(PDP10_word,^D12)
ENG$K(Text,^D13)
ENG$K(Varying,^D14)
KEYEND(CDDL)
KEYBEG(EPRO)
ENG$N(End)
ENG$I(End-procedure,^D1)
ENG$K(End_procedure,^D1)
KEYEND(EPRO)
KEYBEG(ETAB)
ENG$N(End)
ENG$I(End-table,^D1)
ENG$K(End_table,^D1)
KEYEND(ETAB)
KEYBEG(EPLO)
ENG$A(<E,En,End,End-plot>,K$EPL1)
K$EPL1: ENG$K(End_plot,^D1)
KEYEND(EPLO)
KEYBEG(REA)
ENG$K(Real,^D1)
KEYEND(REA)
KEYBEG(STR)
ENG$K(String,^D1)
KEYEND(STR)
KEYBEG(DAT)
ENG$K(Date,^D1)
KEYEND(DAT)
KEYBEG(VEC)
ENG$K(Vector,^D1)
KEYEND(VEC)
KEYBEG(DESC)
ENG$K(Descending,^D1)
KEYEND(DESC)
KEYBEG(DO)
ENG$K(Do,^D1)
KEYEND(DO)
KEYBEG(ENT)
ENG$K(Entry,^D1)
KEYEND(ENT)
KEYBEG(DOMA)
ENG$K(Domain,^D1)
KEYEND(DOMA)
KEYBEG(PRI)
ENG$K(Print,^D1)
KEYEND(PRI)
; Here are the break masks used by the FDBs on the next few pages
M$ARB: 004020000400 ;^F ^M ^[
100000000020 ;" ?
0
0
M$REL: -1
777757777420
400000000740
400000000760
M$ARIT: -1
777453777777
-1
777777777570
M$FUNC: -1 ; $ _ - letters numbers
757754001760
400000000740
400000000760
M$FLD: -1
757754001760
400000000740
400000000760
M$PRO: -1
757744001760
400000000740
400000000760
M$PIC: -1 ; Break on: all control chars
500000001400 ; Space " : ;
0
000000000020 ; delete
M$ST: 777377777777
377777777777
-1
-1
M$DEF: -1
777754001760 ; letters numbers _ AND -
400000000740
400000000760
; Define a macro to make English FDB vector entries
DEFINE ENG$D(TYP,FLGS,DATA,HLPM,DEFM,BRKADR),<
IFB <BRKADR>,<
[FLDDB. (<TYP>,<FLGS>,<DATA>,<HLPM>,<DEFM>)]
>
IFNB <BRKADR>,<
[FLDBK. (<TYP>,<FLGS>,<DATA>,<HLPM>,<DEFM>,<BRKADR>)]
>
>
; Define macros for foreign language FDB vector entries
DEFINE GER$D(TYP,FLGS,DATA,HLPM,DEFM,BRKADR),<
>
DEFINE FRN$D(TYP,FLGS,DATA,HLPM,DEFM,BRKADR),<
>
DEFINE SPN$D(TYP,FLGS,DATA,HLPM,DEFM,BRKADR),<
>
; Define a symbol for the new flag to allow semi colons as tokens
CM%NOC==:1B11
; Here is the FDB vector
LIT ;Dump accumulated literals
RELOC ;This must go in the low segment
$$FDB:: 0
ENG$D (.CMINI)
; Keyword tables
ENG$D (.CMKEY,CM%NOC,K$COMM,<Command,>)
ENG$D (.CMKEY,CM%NOC,K$DEFI,<Dictionary object,>)
ENG$D (.CMKEY,CM%NOC,HLPKEY##,<A Datatrieve-20 topic,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$SHOW,<Show option,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$SET,<Set option,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$NOSE,<Set option,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$STAT,<Statement,>)
ENG$D (.CMKEY,CM%NOC,K$FRVI)
ENG$D (.CMKEY,CM%NOC,K$STAF,<Statistical function,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$RUNN)
ENG$D (.CMKEY,CM%BRK!CM%NOC,K$ARIT,<Arithmetic or string operator,>,,M$ARIT)
ENG$D (.CMKEY,CM%NOC,K$PLAR,<Arithmetic or string operator,>,,M$ARIT)
ENG$D (.CMKEY,CM%NOC,K$FUNC,<Function,>,,M$FUNC)
ENG$D (.CMKEY,CM%NOC,K$BOOL,<Boolean operator,>)
ENG$D (.CMKEY,CM%NOC,K$RELO,<Relational operator,>,,M$REL)
ENG$D (.CMKEY,CM%NOC,K$PREL,<Relational operator,>,,M$REL)
ENG$D (.CMKEY,CM%NOC!CM%SDH,K$ANY,<ANY record selection expression>)
ENG$D (.CMKEY,CM%NOC,K$THEN)
ENG$D (.CMKEY,CM%NOC,K$THE)
ENG$D (.CMKEY,CM%NOC,K$END)
ENG$D (.CMKEY,CM%NOC!CM%SDH,K$NOT,<NOT boolean expression>)
ENG$D (.CMKEY,CM%NOC,K$AND)
ENG$D (.CMKEY,CM%NOC,K$OR)
ENG$D (.CMKEY,CM%NOC,K$OF)
ENG$D (.CMKEY,CM%NOC,K$ELSE)
ENG$D (.CMKEY,CM%NOC,K$TRAC,<Trace option,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$DECL,<Field definition clause,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$LEFT)
ENG$D (.CMKEY,CM%NOC,K$USAG,<Usage option,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$WHEN)
ENG$D (.CMKEY,CM%NOC,K$BY)
ENG$D (.CMKEY,CM%NOC,K$VALU)
ENG$D (.CMKEY,CM%NOC,K$IS)
ENG$D (.CMKEY,CM%NOC,K$SIGN)
ENG$D (.CMKEY,CM%NOC,K$SEPA)
ENG$D (.CMKEY,CM%NOC,K$ZERO)
ENG$D (.CMKEY,CM%NOC,K$TIME)
ENG$D (.CMKEY,CM%NOC,K$TO)
ENG$D (.CMKEY,CM%NOC,K$DEPE)
ENG$D (.CMKEY,CM%NOC,K$ON)
ENG$D (.CMKEY,CM%NOC,K$IF)
ENG$D (.CMKEY,CM%NOC,K$CHAR)
ENG$D (.CMKEY,CM%NOC,K$ALL)
ENG$D (.CMKEY,CM%NOC,K$FIRS)
ENG$D (.CMKEY,CM%NOC,K$IN)
ENG$D (.CMKEY,CM%NOC,K$CROS)
ENG$D (.CMKEY,CM%NOC,K$WITH)
ENG$D (.CMKEY,CM%NOC,K$SORD)
ENG$D (.CMKEY,CM%NOC,K$OVER)
ENG$D (.CMKEY,CM%NOC,K$SORT)
ENG$D (.CMKEY,CM%NOC,K$USIN)
ENG$D (.CMKEY,CM%NOC,K$VERI)
ENG$D (.CMKEY,CM%NOC,K$FORM,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$SELE)
ENG$D (.CMKEY,CM%NOC,K$VERB)
ENG$D (.CMKEY,CM%NOC,K$OCCU)
ENG$D (.CMKEY,CM%NOC,K$FOR)
ENG$D (.CMKEY,CM%NOC,K$FROM)
ENG$D (.CMKEY,CM%NOC,K$NO)
ENG$D (.CMKEY,CM%NOC,K$EPRO,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$ETAB,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$EPLO,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$ENT,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$PDEC,<Variable name,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$PSTA,<Variable name,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$PW,<Plot Expression,>,,M$FUNC)
ENG$D (.CMKEY,CM%NOC,K$DEC)
ENG$D (.CMKEY,CM%NOC,K$REA)
ENG$D (.CMKEY,CM%NOC,K$STR)
ENG$D (.CMKEY,CM%NOC,K$DAT)
ENG$D (.CMKEY,CM%NOC,K$VEC)
ENG$D (.CMKEY,CM%NOC,K$DESC)
ENG$D (.CMKEY,CM%NOC,K$DO)
ENG$D (.CMKEY,CM%NOC,K$DOMA)
ENG$D (.CMKEY,CM%NOC,K$DFIL,<File creation option,>)
ENG$D (.CMKEY,CM%NOC,K$KEYT,<Indexed file option,>)
ENG$D (.CMKEY,CM%NOC,K$TAB,<Table option,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$AS)
ENG$D (.CMKEY,CM%NOC,K$ACCE,<Access modes,>)
ENG$D (.CMKEY,CM%NOC,K$LOCK,<Access options,>)
ENG$D (.CMKEY,CM%NOC,K$RUSA)
ENG$D (.CMKEY,CM%NOC,K$RUST,<Default character type for the record,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$AT)
ENG$D (.CMKEY,CM%NOC,K$PORT)
ENG$D (.CMKEY,CM%NOC,K$STRU)
ENG$D (.CMKEY,CM%NOC,K$DATA)
ENG$D (.CMKEY,CM%NOC,K$SIZE)
ENG$D (.CMKEY,CM%NOC,K$SCAL)
ENG$D (.CMKEY,CM%NOC,K$DIGI)
ENG$D (.CMKEY,CM%NOC,K$CHAS)
ENG$D (.CMKEY,CM%NOC,K$VSTR)
ENG$D (.CMKEY,CM%NOC,K$SEPO)
ENG$D (.CMKEY,CM%NOC,K$SIGU)
ENG$D (.CMKEY,CM%NOC,K$CDDL,<Datatype,>,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$RW,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$RSET,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$RNO)
ENG$D (.CMKEY,CM%NOC,K$RAT)
ENG$D (.CMKEY,CM%NOC,K$TOPB)
ENG$D (.CMKEY,CM%NOC,K$RFOM,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$RHDR,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$RBRK,,,M$DEF)
ENG$D (.CMKEY,CM%NOC,K$PRI)
ENG$D (.CMKEY,CM%NOC,K$SDUI,,,M$DEF)
; Noise words
ENG$D (.CMNOI,CM%NOC,SP<with>)
ENG$D (.CMNOI,CM%NOC,SP<and FINISH all domains>)
ENG$D (.CMNOI,CM%NOC,SP<Command Level and TAKE>)
ENG$D (.CMNOI,CM%NOC,SP<trace file>)
ENG$D (.CMNOI,CM%NOC,SP<text from>)
ENG$D (.CMNOI,CM%NOC,SP<option>)
ENG$D (.CMNOI,CM%NOC,SP<everything about>)
ENG$D (.CMNOI,CM%NOC,<SP<statement, displaying value expression>>)
ENG$D (.CMNOI,CM%NOC,SP<a block of statements with>)
ENG$D (.CMNOI,CM%NOC,SP<value expression>)
ENG$D (.CMNOI,CM%NOC,SP<boolean expression>)
ENG$D (.CMNOI,CM%NOC,SP<value of>)
ENG$D (.CMNOI,CM%NOC,<SP<collection, table, plot, or variable>>)
ENG$D (.CMNOI,CM%NOC,SP<repetition count>)
ENG$D (.CMNOI,CM%NOC,SP<local or global variable or port>)
ENG$D (.CMNOI,CM%NOC,SP<verbosity>)
ENG$D (.CMNOI,CM%NOC,SP<dictionary object>)
ENG$D (.CMNOI,CM%NOC,SP<procedure.path.name>)
ENG$D (.CMNOI,CM%NOC,SP<indirect file name>)
ENG$D (.CMNOI,CM%NOC,SP<trace option>)
ENG$D (.CMNOI,CM%NOC,SP<domain path name>)
ENG$D (.CMNOI,CM%NOC,SP<record path name>)
ENG$D (.CMNOI,CM%NOC,SP<RMS file>)
ENG$D (.CMNOI,CM%NOC,SP<for domain>)
ENG$D (.CMNOI,CM%NOC,SP<table path name>)
ENG$D (.CMNOI,CM%NOC,SP<table domain path name>)
ENG$D (.CMNOI,CM%NOC,SP<plot path name>)
ENG$D (.CMNOI,CM%NOC,SP<plot statement>)
ENG$D (.CMNOI,CM%NOC,SP<local variable>)
ENG$D (.CMNOI,CM%NOC,SP<code field : description field>)
ENG$D (.CMNOI,CM%NOC,SP<dictionary path name>)
ENG$D (.CMNOI,CM%NOC,SP<run Application Design Tool>)
ENG$D (.CMNOI,CM%NOC,SP<domain>)
ENG$D (.CMNOI,CM%NOC,SP<the record that is the>)
ENG$D (.CMNOI,CM%NOC,SP<records in collection>)
ENG$D (.CMNOI,CM%NOC,SP<a record in domain>)
ENG$D (.CMNOI,CM%NOC,SP<existing record(s)>)
ENG$D (.CMNOI,CM%NOC,SP<selected record from collection>)
ENG$D (.CMNOI,CM%NOC,SP<existing record(s)>)
ENG$D (.CMNOI,CM%NOC,SP<a collection of records in RSE>)
ENG$D (.CMNOI,CM%NOC,SP<each record in RSE>)
ENG$D (.CMNOI,CM%NOC,SP<port path name>)
ENG$D (.CMNOI,CM%NOC,SP<of position>)
ENG$D (.CMNOI,CM%NOC,SP<location>)
ENG$D (.CMNOI,CM%NOC,SP<print list value>)
ENG$D (.CMNOI,CM%NOC,SP<value expression on file>)
ENG$D (.CMNOI,CM%NOC,SP<for message type>)
; File specifications
ENG$D (.CMIFI,CM%NOC)
ENG$D (.CMOFI,CM%NOC)
ENG$D (.CMFIL,CM%NOC)
; Random tokens
ENG$D (.CMCFM,CM%NOC)
ENG$D (.CMTOK,CM%NOC!CM%SDH,SP<@>,<@Indirect command file>)
ENG$D (.CMCMA,CM%NOC)
ENG$D (.CMTOK,CM%NOC,SP<;>)
ENG$D (.CMUQS,CM%NOC!CM%SDH,M$ARB,<Remainder of input line (No recognition possible)>)
ENG$D (.CMTOK,CM%NOC!CM%SDH,SP<:>,<:Procedure.path.name>)
ENG$D (.CMTOK,CM%NOC!CM%DPP,SP<:>,,<:>)
ENG$D (.CMNUX,CM%NOC,^D10)
ENG$D (.CMQST,CM%NOC)
ENG$D (.CMFLT,CM%NOC)
ENG$D (.CMTOK,CM%NOC!CM%SDH,SP<*>,<*."prompt-name">)
ENG$D (.CMTOK,CM%NOC!CM%SDH,SP<**>,<**."prompt-name">)
ENG$D (.CMTOK,CM%NOC,<SP<(>>)
ENG$D (.CMTOK,CM%NOC,<SP<)>>)
ENG$D (.CMTOK,CM%NOC,SP<->)
ENG$D (.CMTOK,CM%NOC,SP<.>)
ENG$D (.CMFLD,CM%NOC!CM%SDH,,<Name>,,M$FLD)
ENG$D (.CMTOK,CM%NOC,SP</>)
ENG$D (.CMFLD,CM%NOC!CM%SDH,,<Picture or edit string>,,M$PIC)
ENG$D (.CMFLD,CM%NOC!CM%SDH,,<Picture or edit string>,,M$ST)
ENG$D (.CMTOK,CM%NOC!CM%DPP,SP<=>,,<=>)
ENG$D (.CMFLD,CM%NOC!CM%SDH,,<Procedure.path.name>,,M$PRO)
ENG$D (.CMDIR,CM%NOC)
ENG$D (.CMQST,CM%NOC!CM%SDH)
ENG$D (.CMTOK,CM%NOC!CM%SDH,SP<">)
LIT ;Dump accumulated literals
RELOC ;Back to the high segment
;
; Foreign Language Facility -- DATE WORDS
STRKWD::
KEYBEG(KWD)
ENG$K(Now,^D1)
ENG$K(Today,^D2)
ENG$K(Tomorrow,^D3)
ENG$K(Yesterday,^D4)
KEYEND(KWD)
STRKMN::
KEYBEG(KMN)
ENG$K(April,^D3)
ENG$K(August,^D7)
ENG$K(December,^D11)
ENG$K(February,^D1)
ENG$K(January,^D0)
ENG$K(July,^D6)
ENG$K(June,^D5)
ENG$K(March,^D2)
ENG$K(May,^D4)
ENG$K(November,^D10)
ENG$K(October,^D9)
ENG$K(September,^D8)
KEYEND(KMN)
; Here is the translation table which converts lower case to upper
; and dashes to underscores.
STRCAS::
IFIW [REPEAT ^D16,<"?",,"?">
" ",,"!"
"""",,"#"
"$",,"%"
"&",,"'"
"(",,")"
"*",,"+"
",",,"_"
".",,"/"
"0",,"1"
"2",,"3"
"4",,"5"
"6",,"7"
"8",,"9"
":",,";"
"<",,"="
">",,"?"
"@",,"A"
"B",,"C"
"D",,"E"
"F",,"G"
"H",,"I"
"J",,"K"
"L",,"M"
"N",,"O"
"P",,"Q"
"R",,"S"
"T",,"U"
"V",,"W"
"X",,"Y"
"Z",,"["
"\",,"]"
"^",,"_"
"`",,"A"
"B",,"C"
"D",,"E"
"F",,"G"
"H",,"I"
"J",,"K"
"L",,"M"
"N",,"O"
"P",,"Q"
"R",,"S"
"T",,"U"
"V",,"W"
"X",,"Y"
"Z",,"{"
"|",,"}"
"~",,"?"]
; Here is the translation table which converts lower case to upper case.
STRUCS::
IFIW [REPEAT ^D16,<"\",,"\">
" ",,"!"
"""",,"#"
"$",,"%"
"&",,"'"
"(",,")"
"*",,"+"
",",,"-"
".",,"/"
"0",,"1"
"2",,"3"
"4",,"5"
"6",,"7"
"8",,"9"
":",,";"
"<",,"="
">",,"?"
"@",,"A"
"B",,"C"
"D",,"E"
"F",,"G"
"H",,"I"
"J",,"K"
"L",,"M"
"N",,"O"
"P",,"Q"
"R",,"S"
"T",,"U"
"V",,"W"
"X",,"Y"
"Z",,"["
"\",,"]"
"^",,"_"
"`",,"A"
"B",,"C"
"D",,"E"
"F",,"G"
"H",,"I"
"J",,"K"
"L",,"M"
"N",,"O"
"P",,"Q"
"R",,"S"
"T",,"U"
"V",,"W"
"X",,"Y"
"Z",,"{"
"|",,"}"
"~",,"\"]
; Here is the translation table which converts ASCII to SIXBIT
STRSIX::
IFIW [REPEAT ^D4,<'\',,'\'>
'\',,' '
REPEAT ^D11,<'\',,'\'>
' ',,'!'
'"',,'#'
'$',,'%'
'&',,''''
'(',,')'
'*',,'+'
',',,'-'
'.',,'/'
'0',,'1'
'2',,'3'
'4',,'5'
'6',,'7'
'8',,'9'
':',,';'
'<',,'='
'>',,'?'
'@',,'A'
'B',,'C'
'D',,'E'
'F',,'G'
'H',,'I'
'J',,'K'
'L',,'M'
'N',,'O'
'P',,'Q'
'R',,'S'
'T',,'U'
'V',,'W'
'X',,'Y'
'Z',,'['
'\',,']'
'^',,'_'
'\',,'A'
'B',,'C'
'D',,'E'
'F',,'G'
'H',,'I'
'J',,'K'
'L',,'M'
'N',,'O'
'P',,'Q'
'R',,'S'
'T',,'U'
'V',,'W'
'X',,'Y'
'Z',,'['
'\',,']'
'\',,'\']
; Plotting escape sequences sent to the terminal
DEFINE PLS($STR)<
$STR <> ;; Escape Character
$STR <[0K> ;; Clear line
$STR <[2J> ;; Clear Screen
$STR <P> ;; Enter regis Part I
$STR <p> ;; Enter regis Part II
$STR <P[,500]\[1;24r[24;0f> ;; Move regis cursor to y location 500
;; Exit regis mode
;; Set scrolling region to lines 1 to 24
;; Move cursor to start of line 24
>
STRPLS:: ENG$S(PLS)
LENPLS:: ENG$L(PLS)
;
; Customer Written Functions -- GENERAL INFO
; Function blocks
;
; Define here some symbols for use in the function blocks
; and some macros to build the function blocks
; Symbols for the way in which data is returned
F.STA==1 ; Output is in first input arg and R0
; returns status, 0=OK. A non-zero status will result
; in an error message being printed. If the value is
; positive, it will be printed in the message as the
; function status. If the value is negative, it will
; be taken as a JSYS error code, and the corresponding
; monitor message will be printed.
F.INP==2 ; Output is in 1st input arg and r0 means nothing
F.R0==3 ; Output is in R0
F.R0R1==4 ; Output is in R0 and R1
; Note that F.STA and F.INP work only for string return args.
; Symbols for datatype
F.Z==0 ; Undefined
F.L==1 ; One word signed integer
F.Q==2 ; Double word signed integer
F.F==3 ; One word d floating
F.D==4 ; Double precision floating
F.DAT==5 ; TOPS-20 date time word
F.T==6 ; 7 bit ascii string
F.NU==7 ; Unsigned 7 bit ascii numeric
F.NL==^D8 ; Left sep sign 7 bit ascii numeric
F.NLO==^D9 ; Left overpunched 7 bit ascii numeric
F.NR==^D10 ; Right sep 7 bit ascii numeric
F.NRO==^D11 ; Right overpunched 7 bit ascii numeric
F.P==^D12 ; Packed
; Macros for making function blocks
;
; Certain rules must be followed when designing functions.
; 1. The functions data type may be any supported data type
; (Z is unsupported).
; 2. The result of the function can be returned in any way,
; except that datatypes which use pointers may not return
; results in the ACs.
; 3. Only one return parameter may be specified. To be Fortran
; compatible it must be the first parameter.
; 4. The functions must preserve all used ACs except 0 and 1.
; 5. The functions may assume that the stack is avaliable for
; local variables and is quite large.
; 6. The function may not halt or output error or warning messages
; to the TTY (unless that is its specific function). If the
; function has a potential for failure, use the return type
; which returns a status.
; 7. Passed data may be required to be of any datatype from among
; the following: L,Q,D,F,DATE, and T. Other data types are not
; supported until the compiler can build FNA nodes with
; sufficient room for in class conversion for strings.
; 8. The right half of the key word table is the offset into the
; function block vector. Make sure that the offset and the
; vector match properly.
;
; ENG$F(ADDR,NAME,PARMI,DATAT,RETTYP,DTRCNT,STRLEN,ARGCNT)
; ADDR - External subroutine address.
; NAME - DTR name of function.
; PARMI - Which sub arg is the return value arg. Only datatypes
; with pointers are returned this way. All one and two
; word datatypes are returned in registers 0 and 1.
; DATAT - Output datatype (use the above symbols).
; RETTYP - Technique to return value (use symbols).
; DTRCNT - Arg count in DTR syntax.
; STRLEN - Length of returned string.
; ARGCNT - Actual number of arguments to sub.
;
DEFINE ENG$F(ADDR,NAME,PARMI,DATAT,RETTYP,DTRCNT,STRLEN,ARGCNT),<
ADDR
POINT 7,[ASCIZ ~'NAME~]
LEN.==0
IRPC NAME,<LEN.==LEN.+1>
PARMI,,LEN.
RETTYP,,DATAT
STRLEN,,DTRCNT
ARGCNT
>
; Define macros for the foreign language function blocks
DEFINE GER$F(ADDR,NAME,PARMI,DATAT,RETTYP,DTRCNT,STRLEN,ARGCNT),<
>
DEFINE FRN$F(ADDR,NAME,PARMI,DATAT,RETTYP,DTRCNT,STRLEN,ARGCNT),<
>
DEFINE SPN$F(ADDR,NAME,PARMI,DATAT,RETTYP,DTRCNT,STRLEN,ARGCNT),<
>
; $ARG is used once for every argument to the subroutine
;
; ORDER - Order in the DTR syntax.
; DATATYP - Required datatype of the argument.
;
; The first arg in DTR syntax is numbered one. However, if there is an
; arg added to return a value in, it should be listed as number 0.
;
DEFINE $ARG(ORDER,DATATYP),<
ORDER,,DATATYP
>
; DATATRIEVE function blocks
; Note: these function blocks MUST be in order by the function sequence
; number (the number after the function name in the K$FUNC table).
; The comment before each block has the form:
;nn funct-name (arg-type, arg-type, ...) [where-function-is-defined]
; All args actually passed are listed, which may be more than you give
; in DATATRIEVE syntax.
STRFUN::
;0 FN$Abs(double-float) [MTHLIB]
[ENG$F(DABS.##,FN$Abs,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;1 FN$Mod(double-float, double-float) [MTHLIB]
[ENG$F(DMOD.##,FN$Mod,0,F.D,F.R0R1,2,0,2)
$ARG(1,F.D)
$ARG(2,F.D)]
;2 FN$String_extract(string, string, integer, integer) [FUNLIB]
[ENG$F(FNSEXT##,FN$String_extract,1,F.T,F.INP,3,^D256,4)
$ARG(0,F.T)
$ARG(1,F.T)
$ARG(2,F.L)
$ARG(3,F.L)]
;3 FN$Str_first_char(string) [FUNLIB]
[ENG$F(FNSFCH##,FN$Str_first_char,0,F.L,F.R0,1,0,1)
$ARG(1,F.T)]
;4 FN$Trans_log(string,string) [FUNLIB]
[ENG$F(FNTRLG##,FN$Trans_log,1,F.T,F.STA,1,^D256,2)
$ARG(0,F.T)
$ARG(1,F.T)]
;5 FN$Opens_left() [FUNLIB]
[ENG$F(FNOPLT##,FN$Opens_left,0,F.L,F.R0,0,0,0)]
;6 FN$Str_loc(string,string) [FUNLIB]
[ENG$F(FNSLOC##,FN$Str_loc,0,F.L,F.R0,2,0,2)
$ARG(1,F.T)
$ARG(2,F.T)]
;7 FN$Atan(double-float) [MTHLIB]
[ENG$F(DATAN.##,FN$Atan,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;8 FN$Cos(double-float) [MTHLIB]
[ENG$F(DCOS.##,FN$Cos,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;9 FN$Create_log(string,string,string) [FUNLIB]
[ENG$F(FUNCRL##,FN$Create_log,1,F.T,F.STA,2,0,3)
$ARG(0,F.T)
$ARG(1,F.T)
$ARG(2,F.T)]
;10 FN$Date(date) [FUNLIB]
; The user will normally call this function passing a string date.
; Since the argument is documented as being a date-time word, EFN
; will call DTR$$MOV_MOVE to convert the type to date before passing
; it to FUNDAT. FUNDAT simply returns its arg.
[ENG$F(FUNDAT##,FN$Date,0,F.DAT,F.R0,1,0,1)
$ARG(1,F.DAT)]
;11 FN$Day(date) [FUNLIB]
[ENG$F(FUNDAY##,FN$Day,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;12 FN$Delete_log(string,string) [FUNLIB]
[ENG$F(FUNDEL##,FN$Delete_log,1,F.T,F.STA,1,0,2)
$ARG(0,F.T)
$ARG(1,F.T)]
;13 FN$Exp(double-float) [MTHLIB]
[ENG$F(DEXP.##,FN$Exp,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;14 FN$Floor(double-float) [FUNLIB]
; Despite VAX documentation, DTR32 V2 implements the "normal" floor
; function for this, i.e. floor (-3.1) = -4.
[ENG$F(FUNFLR##,FN$Floor,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;15 FN$Hex(integer) [FUNLIB]
[ENG$F(FUNHEX##,FN$Hex,1,F.T,F.INP,1,^D9,2)
$ARG(0,F.T)
$ARG(1,F.L)]
;16 FN$Hour(date) [FUNLIB]
[ENG$F(FUNHR##,FN$Hour,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;17 FN$Hundredth(date) [FUNLIB]
[ENG$F(FUNHUN##,FN$Hundredth,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;18 FN$Init_timer() [FUNLIB]
[ENG$F(FUNITM##,FN$Init_timer,1,F.T,F.STA,0,0,1)
$ARG(0,F.T)]
;19 FN$Julian(date) [FUNLIB]
[ENG$F(FUNJLD##,FN$Julian,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;20 FN$Ln(double-float) [MTHLIB]
[ENG$F(DLOG.##,FN$Ln,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;21 FN$Log10(double-float) [MTHLIB]
[ENG$F(DLG10.##,FN$Log10,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;22 FN$Minute(date) [FUNLIB]
[ENG$F(FUNMIN##,FN$Minute,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;23 FN$Month(date) [FUNLIB]
[ENG$F(FUNMON##,FN$Month,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;24 FN$Nint(double-floating) [MTHLIB]
[ENG$F(DNINT.##,FN$Nint,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;25 FN$Second(date) [FUNLIB]
[ENG$F(FUNSEC##,FN$Second,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;26 FN$Show_timer() [FUNLIB]
[ENG$F(FUNSTM##,FN$Show_timer,1,F.T,F.STA,0,^D40,1)
$ARG(0,F.T)]
;27 FN$Sign(double-float) [FUNLIB]
[ENG$F(FUNSIG##,FN$Sign,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;28 FN$Sin(double-float) [MTHLIB]
[ENG$F(DSIN.##,FN$Sin,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;29 FN$Sqrt(double-float) [MTHLIB]
[ENG$F(DSQRT.##,FN$Sqrt,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;30 FN$Tan(double-floating) [MTHLIB]
[ENG$F(DTAN.##,FN$Tan,0,F.D,F.R0R1,1,0,1)
$ARG(1,F.D)]
;31 FN$Time(date) [FUNLIB]
[ENG$F(FUNTIM##,FN$Time,1,F.T,F.INP,1,^D10,2)
$ARG(0,F.T)
$ARG(1,F.DAT)]
;32 FN$Upcase(string) [FUNLIB]
[ENG$F(FUNUPC##,FN$Upcase,1,F.T,F.INP,1,^D256,2)
$ARG(0,F.T)
$ARG(1,F.T)]
;33 FN$Week(date) [FUNLIB]
[ENG$F(FUNWK##,FN$Week,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;34 FN$Width(string,integer) [FUNLIB]
[ENG$F(FUNWID##,FN$Width,1,F.T,F.STA,1,0,2)
$ARG(0,F.T)
$ARG(1,F.L)]
;35 FN$Year(date) [FUNLIB]
[ENG$F(FUNYR##,FN$Year,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
;36 FN$Octal(integer) [FUNLIB]
[ENG$F(FUNOCT##,FN$Octal,1,F.T,F.INP,1,^D12,2)
$ARG(0,F.T)
$ARG(1,F.L)]
;37 FN$Day_of_week(date) [FUNLIB]
[ENG$F(FUNDOW##,FN$Day_of_week,0,F.L,F.R0,1,0,1)
$ARG(1,F.DAT)]
END