@DATABASE "ARexxGuide.guide"
@VER 1.0c
@INDEX ARx_Index/MAIN
@NODE MAIN " ARexxGuide                            Copyright © 1993, Robin Evans"
@NEXT ARx_Elements.ag/MAIN
@TOC COMPCONT
   @{FG HIGHLIGHT}AN AMIGAGUIDE® TO ARexx@{FG TEXT}                 Edition: 1.0c
   by Robin Evans

   @{" Registration         " link REG}   @{" Comprehensive contents                         " link COMPCONT}
   @{" Introduction         " link ARx_Intro.ag/MAIN}   @{" Tutorial             " link TUTOR}

   Reference
   @{" Basic elements       " link ARx_Elements.ag/MAIN}   @{" Instructions         " link ARx_Instr.ag/MAIN}   @{" Functions            " link ARx_Func.ag/MAIN}
    Guide to the powders     Syntax & explanation     Syntax & explanation
    & potions in the ARexx   of keywords and          of built-in & support
    chemistry set.           instructions             functions.
   @{" Operators            " link ARx_Operator.ag/MAIN}   @{" Commands             " link ARx_Cmd.ag/MAIN}
    Glue for arithmetic,     Utility programs.
    comparison, & logical
    expressions.

   @{" INDEX                                                                   " link ARx_Index/MAIN}

                  Copyright © 1993, Robin Evans.  All rights reserved.
@REM 1.0b: changed stuff about RX path.
@REM 1.0c: added DATE(), TIME() persistence to contents.
@REM Dean also suggests changing the spacing of contents. See Guide_stuff4.a.lha. Didn't do that yet.

@EndNode
@Node REG "ARexxGuide | Registration (1 of 2) | SEND MONEY NOW!"
@PREV MAIN
This guide is shareware. Please use it and pass it on (in its original
archive) to your friends and acquaintances. If you learn something from
the guide or find it helpful in writing ARexx programs, then please take a
moment to fill out the registration card and send in the fee.

Shareware is similar to public broadcasting in this: You can watch or
listen to the stations without sending them any money, just as you can use
shareware application. It might not make any difference. Your favorite
programs might stay on the air whether you call in your pledge or not.
Someone else will still release a cool shareware offering. But if nobody
sends money, the station won't stay on the the air for long. If nobody
sends money, the pool of shareware will begin to dry up. And if you don't
send money, the station won't give much attention to your complaints or
suggestions about its programming.

Public broadcast stations have developed guilt-inducing pledge drives into
something of an art. I can't even approach that level of begging, so
please try to remember the last pledge drive you heard on an NPR or PBS
station and imagine that all of those folks were talking about this guide.
Imagine that and the send in your pledge now.

   @{" Register and send pledge now! " link REGINFO}

Please send comments or requests to any of the following on-line
addresses:
               robin@halcyon.com       on Internet
               R.EVANS6                on GEnie
               r.evans6@genie.geis.com on Internet

I will upload additions to the tutorial sections in the future and will
also send any revised editions of files included here to the same places
where this archive was originally posted. Watch for them.


@EndNode
@Node REGINFO "ARexxGuide | Registration (2 of 2) | THE PITCH"
@NEXT MAIN
   @{FG HIGHLIGHT}The pitch@{FG TEXT}
   ~~~~~~~~~
The basic registration fee for this guide is $15.00. For that you get the
complete reference you see before you now -- information you would pay $25
to $40 for if it were presented in traditional book form.

   But wait... There's more.

For a not-limited time, those who send in a premium registration fee of
$21 will receive, by mail within eight weeks, a nicely-printed quick
reference guide that includes the syntax guides presented here in the
function reference and in the instruction reference.

Sorry, folks, we don't have operators standing by to take your order, but
we do have -- yes, standing by -- representatives of the worlds's postal
services who will deliver your registration fee to the address below.

To make things easier, and to provide information helpful in making future
revisions to this guide, the button below will guide you through an
on-line registration form that can be printed immediately or saved to disk.

                  @{" Fill out registration form " system "rx ARx_IactExamples.rexx ARx_Reg.rexx"}  @{" * " alink IACTEXMP}

      @{FG HIGHLIGHT}Send registration fee (and optional form) to:@{FG TEXT}
                  Robin Evans
                  1020 Seneca #405
                  Seattle WA 98101-2720

      @{FG HIGHLIGHT}And thank you, very much.@{FG TEXT}

One more note: There may be good reasons for not sending in the shareware
fee. Whatever the reasons, though, they should also be good enough reasons
to delete this material from your disks. Please take the extra step of
doing that if you decide against registration.

Next: ARexxGuide contents | Prev: Registration intro | Contents: main

@EndNode
@Node COMPCONT "ARexxGuide | CONTENTS"
@NEXT MAIN
@PREV MAIN
@{FG HIGHLIGHT}Foreward:@{FG TEXT}

   @{FG HIGHLIGHT}Preface@{FG TEXT}
      @{" Acknowledgements                                            " link ARx_Intro.ag/ACKN}
      @{" References                                                  " link ARx_Intro.ag/REF}
      @{" About the author                                            " link ARx_Intro.ag/AUTHOR}

   @{FG HIGHLIGHT}About this guide@{FG TEXT}
      @{" Navigating hints                                            " link ARx_Intro.ag/NAVG}

   @{FG HIGHLIGHT}Intro to ARexx@{FG TEXT}
      @{" Hello World!                                                " link ARx_Intro.ag/HIWRLD}
      @{" Why ARexx?                                                  " link ARx_Intro.ag/WHYREXX}
      @{" Getting it started                                          " link ARx_Intro.ag/STARTUP}
      @{" Writing programs                                            " link ARx_Intro.ag/WRITING}
      @{" Running a script                                            " link ARx_Intro.ag/RUNAREXX}

   @{FG HIGHLIGHT}Tutorial@{FG TEXT}
      @{" Uncrunch.rexx                                               " link ARx_PrgUcr.ag/UCREXPLAN}

@{FG HIGHLIGHT}Basic Elements:@{FG TEXT}
      @{" Tokens                                                      " link ARx_Elements.ag/TOKEN}
      @{"    Comment tokens                                           " link ARx_Elements.ag/COMMENT}
      @{"    String tokens                                            " link ARx_Elements.ag/STRING}
      @{"       Hex and binary strings                                " link ARx_Elements.ag/HEXSTRING}
      @{"    Symbol tokens                                            " link ARx_Elements.ag/SYMBOL}
      @{"       Fixed symbols                                         " link ARx_Elements.ag/CONSTANT}
      @{"       Variable symbols                                      " link ARx_Elements.ag/VARSYMBOL}
      @{"    Operator tokens                                          " link ARx_Elements.ag/OPERATOR}
      @{"       Concatenation  || <blank> <abuttal>                   " link ARx_Operator.ag/CONCATENATION}
      @{"       Arithmetic     + - | / // %                           " link ARx_Operator.ag/ARITHMETIC}
      @{"       Comparative    < > = == >= <=                         " link ARx_Operator.ag/COMPARISON}
      @{"       Logical        & | && ~                               " link ARx_Operator.ag/LOGICAL}
      @{"    Reserved characters                                      " link ARx_Elements.ag/SPECCHAR}
      @{"       The comma- continuation character                     " link ARx_Elements.ag/COMMA}
      @{"       The semicolon- clause end symbol                      " link ARx_Elements.ag/SEMICOLON}
      @{"          Using semicolons for in-line scripts               " link ARx_Elements.ag/INLINE}
      @{"       The colon- label identifier                           " link ARx_Elements.ag/LABELID}
      @{"       Parenthesis- Grouping / Function argument list        " link ARx_Elements.ag/PAREN}
      @{" Expressions                                                 " link ARx_Elements2.ag/EXPRESSION}
      @{"    Numbers                                                  " link ARx_Elements2.ag/NUMBER}
      @{"       Numeric precision                                     " link ARx_Elements2.ag/PRECISION}
      @{"    Strings                                                  " link ARx_Elements2.ag/STRINGEXPR}
      @{"       Treating numbers as strings                           " link ARx_Elements2.ag/NUMASTEXT}
      @{"    Variables                                                " link ARx_Elements2.ag/VARIABLE}
      @{"       Using variables                                       " link ARx_Elements2.ag/VARDES}
      @{"       Compound variables                                    " link ARx_Elements2.ag/COMPVAR}
      @{"          Overview: Using compound variables                 " link ARx_Elements2.ag/COMPVAR1}
      @{"          Stem variables                                     " link ARx_Elements2.ag/COMPVAR2}
      @{"          Extending stem variables                           " link ARx_Elements2.ag/COMPVAR3}
      @{"          Substituting values in compound variables          " link ARx_Elements2.ag/COMPVAR4}
      @{"          Using strings as the derived name of a branch      " link ARx_Elements2.ag/COMPVAR5}
      @{"          Setting the default value of a compound variable   " link ARx_Elements2.ag/COMPVAR6}
      @{"          Finding values in a compound variable              " link ARx_Elements2.ag/COMPVAR7}
      @{"       Special variables                                     " link ARx_Elements2.ag/SPECVAR}
      @{"          RC                                                 " link ARx_Elements2.ag/RC}
      @{"          RESULT                                             " link ARx_Elements2.ag/RESULT}
      @{"          SIGL                                               " link ARx_Elements2.ag/SIGL}
      @{"       \"Natural\" data typing in ARexx                        " link ARx_Elements2.ag/VARTYPE}
      @{"    Function calls                                           " link ARx_Elements3.ag/FUNCTION}
      @{"       Internal functions                                    " link ARx_Elements3.ag/PROGFUNC}
      @{"       Built-in functions                                    " link ARx_Elements3.ag/BLTFUNC}
      @{"       Library/Host functions                                " link ARx_Elements3.ag/LIBFUNC}
      @{"       External functions                                    " link ARx_Elements3.ag/EXTFUNC}
      @{"       Function arguments                                    " link ARx_Elements3.ag/FUNCARG}
      @{"    Operations                                               " link ARx_Elements3.ag/OPERATION}
      @{"       Concatenation                                         " link ARx_Operator.ag/CONCATENATION}
      @{"       Arithmetic                                            " link ARx_Operator.ag/ARITHMETIC}
      @{"       Comparative                                           " link ARx_Operator.ag/COMPARISON}
      @{"       Logical                                               " link ARx_Operator.ag/LOGICAL}
      @{"       Conditional expressions                               " link ARx_Elements3.ag/CONDITIONAL}
      @{"    Avoiding accidental commands from expressions            " link ARx_Elements3.ag/ACICMD}
      @{" Clauses                                                     " link ARx_Elements3.ag/CLAUSE}
      @{"    Assignment clauses                                       " link ARx_Elements3.ag/ASSIGNMENT}
      @{"    Instructions                                             " link ARx_Elements3.ag/INSTRUCTION}
      @{"    Command clauses                                          " link ARx_Elements3.ag/COMMAND}
      @{"       Command host: what is it?                             " link ARx_Elements3.ag/HOST}
      @{"       The default host                                      " link ARx_Elements3.ag/DEFHOST}
      @{"       Determining the initial host                          " link ARx_Elements3.ag/INITHOST}
      @{"       Entering commands in a script                         " link ARx_Elements3.ag/CMDSTRING}
      @{"       Example script                                        " link ARx_Elements3.ag/TTXCOMMAND}
      @{"    Label clauses                                            " link ARx_Elements3.ag/LABEL}
      @{"    Null clauses                                             " link ARx_Elements3.ag/NULL}

@{FG HIGHLIGHT}Instruction keywords:@{FG TEXT}
      @{" ADDRESS                                                     " link ARx_Instr.ag/ADDRESS}
      @{" ARG                                                         " link ARx_Instr.ag/ARG}
      @{" BREAK                                                       " link ARx_Instr.ag/BREAK}
      @{"    Breaking structure                                       " link ARx_Instr.ag/BREAKSTRUCT}
      @{" CALL                                                        " link ARx_Instr.ag/CALL}
      @{" DO                                                          " link ARx_Instr.ag/DO}
      @{"    <number>                                                 " link ARx_Instr.ag/DOOPT1}
      @{"    Index variable/TO/BY                                     " link ARx_Instr.ag/DOOPT2}
      @{"    FOR                                                      " link ARx_Instr.ag/DOOPT3}
      @{"    WHILE/UNTIL                                              " link ARx_Instr.ag/DOOPT4}
      @{"    FOREVER                                                  " link ARx_Instr.ag/DOOPT5}
      @{"    END                                                      " link ARx_Instr.ag/END}
      @{" DROP                                                        " link ARx_Instr.ag/DROP}
      @{" ECHO                                                        " link ARx_Instr3.ag/SAY}
      @{" EXIT                                                        " link ARx_Instr.ag/EXIT}
      @{" IF                                                          " link ARx_Instr.ag/IF}
      @{"    ELSE                                                     " link ARx_Instr.ag/IF}
      @{" INTERPRET                                                   " link ARx_Instr.ag/INTERPRET}
      @{" ITERATE                                                     " link ARx_Instr.ag/ITERATE}
      @{" LEAVE                                                       " link ARx_Instr.ag/LEAVE}
      @{" NOP                                                         " link ARx_Instr.ag/NOP}
      @{" NUMERIC                                                     " link ARx_Instr2.ag/NUMERIC}
      @{" OPTIONS                                                     " link ARx_Instr2.ag/OPTIONS}
      @{" PARSE                                                       " link ARx_Instr2.ag/PARSE}
      @{"    ARG                                                      " link ARx_Instr2.ag/PARSESRC1}
      @{"    EXTERNAL                                                 " link ARx_Instr2.ag/PARSESRC3}
      @{"    NUMERIC                                                  " link ARx_Instr2.ag/PARSESRC4}
      @{"    PULL                                                     " link ARx_Instr2.ag/PARSESRC2}
      @{"    SOURCE                                                   " link ARx_Instr2.ag/PARSESRC5}
      @{"    VALUE <expression> WITH                                  " link ARx_Instr2.ag/PARSESRC7}
      @{"    VAR                                                      " link ARx_Instr2.ag/PARSESRC8}
      @{"    VERSION                                                  " link ARx_Instr2.ag/PARSESRC6}
      @{"    Templates                                                " link ARx_Instr2.ag/PARSETMP1}
      @{"       Tokenization                                          " link ARx_Instr2.ag/PARSETMP2}
      @{"          The period- placeholder token                      " link ARx_Instr2.ag/PARSETMP2 46}
      @{"       Pattern markers                                       " link ARx_Instr2.ag/PARSETMP3}
      @{"       Positional markers                                    " link ARx_Instr2.ag/PARSETMP4}
      @{"       Using variables as template markers                   " link ARx_Instr2.ag/PARSETMP5}
      @{"       Combining different types of markers                  " link ARx_Instr2.ag/PARSETMP6}
      @{"       Using multiple templates                              " link ARx_Instr2.ag/PARSETMP7}
      @{" PROCEDURE                                                   " link ARx_Instr3.ag/PROCEDURE}
      @{"    EXPOSE                                                   " link ARx_Instr3.ag/EXPOSE}
      @{" PULL                                                        " link ARx_Instr3.ag/PULL}
      @{" PUSH                                                        " link ARx_Instr3.ag/PUSH}
      @{" QUEUE                                                       " link ARx_Instr3.ag/QUEUE}
      @{"    PUSH, QUEUE and REXX data-stream I/O                     " link ARx_Instr3.ag/PUSHNOTE}
      @{" RETURN                                                      " link ARx_Instr3.ag/RETURN}
      @{" SAY                                                         " link ARx_Instr3.ag/SAY}
      @{" SELECT                                                      " link ARx_Instr3.ag/SELECT}
      @{"    WHEN                                                     " link ARx_Instr3.ag/WHEN}
      @{"    OTHERWISE                                                " link ARx_Instr3.ag/OTHERWISE}
      @{" SIGNAL                                                      " link ARx_Instr3.ag/SIGNAL}
      @{"    ON | OFF <interrupt>                                     " link ARx_Instr3.ag/SIGTRAP}
      @{"       BREAK_C                                               " link ARx_Instr3.ag/BREAK_C}
      @{"       | BREAK_D                                             " link ARx_Instr3.ag/BREAK_}
      @{"       | BREAK_E                                             " link ARx_Instr3.ag/BREAK_}
      @{"       | BREAK_F                                             " link ARx_Instr3.ag/BREAK_}
      @{"       ERROR                                                 " link ARx_Instr3.ag/ERROR}
      @{"       FAILURE                                               " link ARx_Instr3.ag/FAILURE}
      @{"       HALT                                                  " link ARx_Instr3.ag/HALT}
      @{"       IOERR                                                 " link ARx_Instr3.ag/IOERR}
      @{"       NOVALUE                                               " link ARx_Instr3.ag/NOVALUE}
      @{"       SYNTAX                                                " link ARx_Instr3.ag/SYNTAX}
      @{"    <label name>                                             " link ARx_Instr3.ag/SIGTRAN}
      @{" TRACE                                                       " link ARx_Instr3.ag/TRACE}
      @{"   Trace options                                             " link ARx_Instr3.ag/TRACEOPT}
      @{"   Interactive tracing-- ?                                   " link ARx_Instr3.ag/TRACEOPT1}
      @{"   Command inhibition-- !                                    " link ARx_Instr3.ag/TRACEOPT2}
      @{" UPPER                                                       " link ARx_Instr3.ag/UPPER}

@{FG HIGHLIGHT}ARexx functions:@{FG TEXT}
      @{" Comparison functions                                        " link ARx_Func.ag/CMPRLIST}
      @{"    ABBREV                                                   " link ARx_Func.ag/ABBREV()}
      @{"    COMPARE                                                  " link ARx_Func.ag/COMPARE()}
      @{"    FIND                                                     " link ARx_Func.ag/FIND()}
      @{"    INDEX                                                    " link ARx_Func.ag/INDEX()}
      @{"    LASTPOS                                                  " link ARx_Func.ag/LASTPOS()}
      @{"       Locating file names with LASTPOS() and MAX()          " link ARx_Notes.ag/FILENAME}
      @{"    POS                                                      " link ARx_Func.ag/POS()}
      @{"    VERIFY                                                   " link ARx_Func.ag/VERIFY()}
      @{"       Checking unique datatypes with VERIFY()               " link ARx_Notes.ag/VERIFYNOTE}
      @{" String manipulation                                         " link ARx_Func.ag/STRLIST}
      @{"    CENTER                                                   " link ARx_Func.ag/CENTER()}
      @{"    COMPRESS                                                 " link ARx_Func.ag/COMPRESS()}
      @{"       Counting characters using COMPRESS()                  " link ARx_Notes.ag/COUNTCHAR}
      @{"    COPIES                                                   " link ARx_Func.ag/COPIES()}
      @{"    DELSTR                                                   " link ARx_Func.ag/DELSTR()}
      @{"    INSERT                                                   " link ARx_Func.ag/INSERT()}
      @{"    LEFT                                                     " link ARx_Func.ag/LEFT()}
      @{"       Formatting output with RIGHT(), LEFT(), and TRUNC()   " link ARx_Notes.ag/FORMATNOTE}
      @{"    LENGTH                                                   " link ARx_Func.ag/LENGTH()}
      @{"    OVERLAY                                                  " link ARx_Func.ag/OVERLAY()}
      @{"    REVERSE                                                  " link ARx_Func.ag/REVERSE()}
      @{"    RIGHT                                                    " link ARx_Func.ag/RIGHT()}
      @{"    STRIP                                                    " link ARx_Func.ag/STRIP()}
      @{"    SUBSTR                                                   " link ARx_Func.ag/SUBSTR()}
      @{"    TRANSLATE                                                " link ARx_Func.ag/TRANSLATE()}
      @{"    TRIM                                                     " link ARx_Func.ag/TRIM()}
      @{"    UPPER                                                    " link ARx_Func.ag/UPPER()}
      @{"    XRANGE                                                   " link ARx_Func.ag/XRANGE()}
      @{" Word manipulation                                           " link ARx_Func2.ag/WORDLIST}
      @{"    DELWORD                                                  " link ARx_Func2.ag/DELWORD()}
      @{"    SPACE                                                    " link ARx_Func2.ag/SPACE()}
      @{"    SUBWORD                                                  " link ARx_Func2.ag/SUBWORD()}
      @{"    WORD                                                     " link ARx_Func2.ag/WORD()}
      @{"    WORDINDEX                                                " link ARx_Func2.ag/WORDINDEX()}
      @{"    WORDLENGTH                                               " link ARx_Func2.ag/WORDLENGTH()}
      @{"    WORDS                                                    " link ARx_Func2.ag/WORDS()}
      @{" Char/Num translation                                        " link ARx_Func2.ag/TRANLIST}
      @{"    B2C                                                      " link ARx_Func2.ag/B2C()}
      @{"    C2B                                                      " link ARx_Func2.ag/C2B()}
      @{"    C2D                                                      " link ARx_Func2.ag/C2D()}
      @{"    C2X                                                      " link ARx_Func2.ag/C2X()}
      @{"    D2C                                                      " link ARx_Func2.ag/D2C()}
      @{"    D2X                                                      " link ARx_Func2.ag/D2X()}
      @{"    X2C                                                      " link ARx_Func2.ag/X2C()}
      @{"    X2D                                                      " link ARx_Func2.ag/X2D()}
      @{" Number manipulation                                         " link ARx_Func2.ag/NUMLIST}
      @{"    ABS                                                      " link ARx_Func2.ag/ABS()}
      @{"    HASH                                                     " link ARx_Func2.ag/HASH()}
      @{"    MAX                                                      " link ARx_Func2.ag/MAX()}
      @{"    MIN                                                      " link ARx_Func2.ag/MIN()}
      @{"    RANDOM                                                   " link ARx_Func2.ag/RANDOM()}
      @{"    RANDU                                                    " link ARx_Func2.ag/RANDU()}
      @{"    SIGN                                                     " link ARx_Func2.ag/SIGN()}
      @{"    TRUNC                                                    " link ARx_Func2.ag/TRUNC()}
      @{" Informational                                               " link ARx_Func2.ag/INFOLIST}
      @{"    DATE                                                     " link ARx_Func2.ag/DATE()}
      @{"       DATE() Options                                        " link ARx_Func2.ag/DATESUB}
      @{"       Persistence of DATE() & TIME() settings               " link ARx_Notes.ag/TIMEPERSIST}
      @{"    SHOW                                                     " link ARx_Func2.ag/SHOW()}
      @{"    SHOWDIR                                                  " link ARx_Func2.ag/SHOWDIR()}
      @{"    SHOWLIST                                                 " link ARx_Func2.ag/SHOWLIST()}
      @{"       SHOWLIST() Options                                    " link ARx_Func2.ag/SHOWLISTSUB}
      @{"    TIME                                                     " link ARx_Func2.ag/TIME()}
      @{"       TIME() Options                                        " link ARx_Func2.ag/TIMESUB}
      @{"       The elapsed time counter                              " link ARx_Notes.ag/TIMENOTE}
      @{"       Persistence of DATE() & TIME() settings               " link ARx_Notes.ag/TIMEPERSIST}
      @{" File input/output                                           " link ARx_Func3.ag/FILEIOLIST}
      @{"    Overview of I/O functions                                " link ARx_Notes.ag/IOFUNC}
      @{"    Setting the logical file name                            " link ARx_Notes.ag/LOGFILE}
      @{"    Using I/O functions other devices                        " link ARx_Notes.ag/OTHERIO}
      @{"    Standard I/O files                                       " link ARx_Notes.ag/STDIO}
      @{"    CLOSE                                                    " link ARx_Func3.ag/CLOSE()}
      @{"    EOF                                                      " link ARx_Func3.ag/EOF()}
      @{"    LINES                                                    " link ARx_Func3.ag/LINES()}
      @{"    OPEN                                                     " link ARx_Func3.ag/OPEN()}
      @{"    READCH                                                   " link ARx_Func3.ag/READCH()}
      @{"    READLN                                                   " link ARx_Func3.ag/READLN()}
      @{"    SEEK                                                     " link ARx_Func3.ag/SEEK()}
      @{"    WRITECH                                                  " link ARx_Func3.ag/WRITECH()}
      @{"    WRITELN                                                  " link ARx_Func3.ag/WRITELN()}
      @{" File management                                             " link ARx_Func3.ag/FILEMGTLIST}
      @{"    DELETE                                                   " link ARx_Func3.ag/DELETE()}
      @{"    EXISTS                                                   " link ARx_Func3.ag/EXISTS()}
      @{"    MAKEDIR                                                  " link ARx_Func3.ag/MAKEDIR()}
      @{"    RENAME                                                   " link ARx_Func3.ag/RENAME()}
      @{"    STATEF                                                   " link ARx_Func3.ag/STATEF()}
      @{" ARexx control                                               " link ARx_Func3.ag/ARXLIST}
      @{"    ADDRESS                                                  " link ARx_Func3.ag/ADDRESS()}
      @{"    ADDLIB                                                   " link ARx_Func3.ag/ADDLIB()}
      @{"    ARG                                                      " link ARx_Func3.ag/ARG()}
      @{"    DATATYPE                                                 " link ARx_Func3.ag/DATATYPE()}
      @{"       DATATYPE() Options                                    " link ARx_Func3.ag/DATATYPESUB}
      @{"    DELAY                                                    " link ARx_Func3.ag/DELAY()}
      @{"    DIGITS                                                   " link ARx_Func3.ag/DIGITS()}
      @{"    ERRORTEXT                                                " link ARx_Func3.ag/ERRORTEXT()}
      @{"    FORM                                                     " link ARx_Func3.ag/FORM()}
      @{"    FUZZ                                                     " link ARx_Func3.ag/FUZZ()}
      @{"    GETCLIP                                                  " link ARx_Func3.ag/GETCLIP()}
      @{"       Using the clip list                                   " link ARx_Notes.ag/CLIPLIST}
      @{"    PRAGMA                                                   " link ARx_Func3.ag/PRAGMA()}
      @{"    REMLIB                                                   " link ARx_Func3.ag/REMLIB()}
      @{"    SETCLIP                                                  " link ARx_Func3.ag/SETCLIP()}
      @{"    SOURCELINE                                               " link ARx_Func3.ag/SOURCELINE()}
      @{"       In-line data                                          " link ARx_Notes.ag/INLDATA}
      @{"    SYMBOL                                                   " link ARx_Func3.ag/SYMBOL()}
      @{"    TRACE                                                    " link ARx_Func3.ag/TRACE()}
      @{"    VALUE                                                    " link ARx_Func3.ag/VALUE()}
      @{"       Using VALUE()                                         " link ARx_Notes.ag/VALUENOTE}
      @{" Message ports                                               " link ARx_Func4.ag/PORTLIST}
      @{"    Using ports in ARexx programs                            " link ARx_Notes.ag/PORTXMP}
      @{"    CLOSEPORT                                                " link ARx_Func4.ag/CLOSEPORT()}
      @{"    GETARG                                                   " link ARx_Func4.ag/GETARG()}
      @{"    GETPKT                                                   " link ARx_Func4.ag/GETPKT()}
      @{"    OPENPORT                                                 " link ARx_Func4.ag/OPENPORT()}
      @{"    REPLY                                                    " link ARx_Func4.ag/REPLY()}
      @{"    TYPEPKT                                                  " link ARx_Func4.ag/TYPEPKT()}
      @{"    WAITPKT                                                  " link ARx_Func4.ag/WAITPKT()}
      @{" Memory management                                           " link ARx_Func4.ag/MEMLIST}
      @{"    ALLOCMEM                                                 " link ARx_Func4.ag/ALLOCMEM()}
      @{"    BADDR                                                    " link ARx_Func4.ag/BADDR()}
      @{"    EXPORT                                                   " link ARx_Func4.ag/EXPORT()}
      @{"    FORBID                                                   " link ARx_Func4.ag/FORBID()}
      @{"    FREEMEM                                                  " link ARx_Func4.ag/FREEMEM()}
      @{"    FREESPACE                                                " link ARx_Func4.ag/FREESPACE()}
      @{"    GETSPACE                                                 " link ARx_Func4.ag/GETSPACE()}
      @{"    IMPORT                                                   " link ARx_Func4.ag/IMPORT()}
      @{"    NEXT                                                     " link ARx_Func4.ag/NEXT()}
      @{"    NULL                                                     " link ARx_Func4.ag/NULL()}
      @{"    OFFSET                                                   " link ARx_Func4.ag/OFFSET()}
      @{"    PERMIT                                                   " link ARx_Func4.ag/PERMIT()}
      @{"    STORAGE                                                  " link ARx_Func4.ag/STORAGE()}
      @{" Bit-wise operations                                         " link ARx_Func4.ag/BITLIST}
      @{"    BITAND                                                   " link ARx_Func4.ag/BITAND()}
      @{"    BITCHG                                                   " link ARx_Func4.ag/BITCHG()}
      @{"    BITCLR                                                   " link ARx_Func4.ag/BITCLR()}
      @{"    BITCOMP                                                  " link ARx_Func4.ag/BITCOMP()}
      @{"    BITOR                                                    " link ARx_Func4.ag/BITOR()}
      @{"    BITSET                                                   " link ARx_Func4.ag/BITSET()}
      @{"    BITTST                                                   " link ARx_Func4.ag/BITTST()}
      @{"    BITXOR                                                   " link ARx_Func4.ag/BITXOR()}

@{FG HIGHLIGHT}ARexx operators:@{FG TEXT}
      @{" Concatenation                                               " link ARx_Operator.ag/CONCATENATION}
      @{" Arithmetic                                                  " link ARx_Operator.ag/ARITHMETIC}
      @{"    Table of arithmetic operators                            " link ARx_Operator.ag/ARITHTABLE}
      @{" Comparison                                                  " link ARx_Operator.ag/COMPARISON}
      @{"    Table of comparison operators                            " link ARx_Operator.ag/CMPRTABLE}
      @{" Logical                                                     " link ARx_Operator.ag/LOGICAL}
      @{"    Table of logical operators                               " link ARx_Operator.ag/LOGTABLE}
      @{" About operator precedence                                   " link ARx_Operator.ag/PRIORITY}

@{FG HIGHLIGHT}AmigaDOS command programs:@{FG TEXT}
      @{" RexxMast                                                    " link ARx_Cmd.ag/REXXMAST}
      @{" RXC                                                         " link ARx_Cmd.ag/RXC}
      @{" RX                                                          " link ARx_Cmd.ag/RX}
      @{" HI                                                          " link ARx_Cmd.ag/HI}
      @{" RXLIB                                                       " link ARx_Cmd.ag/RXLIB}
      @{" RXSET                                                       " link ARx_Cmd.ag/RXSET}
      @{" TCO                                                         " link ARx_Cmd.ag/TCO}
      @{" TCC                                                         " link ARx_Cmd.ag/TCC}
      @{" TS                                                          " link ARx_Cmd.ag/TS}
      @{" TE                                                          " link ARx_Cmd.ag/TE}
      @{" WaitForPort                                                 " link ARx_Cmd.ag/WAITFORPORT}

   @{FG HIGHLIGHT}Useful tools:@{FG TEXT}
      @{" WShell                                                      " link ARx_Cmd.ag/WSHELL}
      @{" ExecIO                                                      " link ARx_Cmd.ag/EXECIO}

@{" GLOSSARY                                                          " link GLOSSARY}
@{" INDEX                                                             " link ARx_Index/MAIN}

@{FG HIGHLIGHT}Interactive examples@{FG TEXT}  @{" * " alink IACTEXMP}
   @{" Registration form                                              " system "rx ARx_IactExamples.rexx ARx_Reg.rexx"}
   @{" Comparison demonstration                                       " system "rx ARx_IactExamples.rexx ARx_Cmpr.rexx"}
   @{" NUMERIC demonstration                                          " system "rx ARx_IactExamples.rexx ShowNumeric"}
   @{" TRACE demonstration                                            " system "rx ARx_Trace.rexx"}
   @{" Standard I/O demonstration                                     " system "rx ARx_IactExamples.rexx ShowStdIO"}
   @{" Break-key demonstration                                        " system "rx ARx_IactExamples.rexx DoBreak"}

@EndNode
@Node TUTOR "ARexxGuide | TURORIAL"
@NEXT ARx_PrgUcr.ag/UCREXPLAN
@PREV MAIN
   @{FG HIGHLIGHT}AN AMIGAGUIDE® TO ARexx@{FG TEXT}                 Edition: 1.0c
   by Robin Evans

   @{" UnCrunch.rexx " link ARx_PrgUcr.ag/UCREXPLAN} A shell-based program to undo archives made
                   with different archiving utilities.

   Each line of code in the program is explained in the accompanying
   tutorial sections.

   More tutorials will be made available in the future. Be sure to specify
   what you'd like to see covered when you register.


                 Copyright © 1993, Robin Evans.  All rights reserved.

    This guide is @{" shareware " link REG}. If you find it useful, please register.

@EndNode
@Node GLOSSARY " ARexxGuide | GLOSSARY (Press -Retrace- to return to previous node)
@PREV MAIN
@NEXT MAIN

@{FG HIGHLIGHT}Boolean value@{FG TEXT}        Either true or false, which -- in ARexx -- is
      considered to be 1 for true and 0 for false. Named after the
      mathematician George Boole.

@{FG HIGHLIGHT}CON:@{FG TEXT}                 Or: Console Window. A @{" logical device " link ArexxGuide.guide/GLOSSARY  45} that creates
      a text window on the Workbench or other public screen. This device
      cab be used as the <filename> with the @{" file I/O " link ARx_Func3.ag/FILEIOLIST} functions to
      direct output to a window opened by the script.

@{FG HIGHLIGHT}Control structure@{FG TEXT}    A programming construct that allows a series of
      statements to be executed as part of a block. The instructions @{" DO " link ARx_Instr.ag/DO},
      @{" SELECT " link ARx_Instr3.ag/SELECT}, and @{" IF " link ARx_Instr.ag/IF} create control structures in ARexx.

@{FG HIGHLIGHT}Debug@{FG TEXT}                To search for and eliminate (eventually) problems or
      'bugs' in a program. The @{" TRACE " link ARx_Instr3.ag/TRACE} instruction aids debugging in ARexx.

@{FG HIGHLIGHT}Dyadic@{FG TEXT}               Having two parts. In ARexx, the term refers to
      operations that have two operands (2 + 2, for instance). Some
      operations have only one operation (-1, for instance) and are
      referred to here as 'prefix' operations. The more technical name
      for the opposite of a dyadic operation is unary operation.

@{FG HIGHLIGHT}Egregious@{FG TEXT}            It means "very bad," but use of this word shows that
      the writer has spent too much time in the company of lawyers. (Which
      may be the same thing, come to think of it.)

@{FG HIGHLIGHT}Interpreter@{FG TEXT}          A program that translates source code (the program
      lines you write) into machine instructions. It does that each time
      the program is run. @{" RexxMast " link ARx_Cmd.ag/REXXMAST} is ARexx interpreter program.

@{FG HIGHLIGHT}I/O@{FG TEXT}                  Input/Output. The term refers to the various ways
      of obtaining data and displaying or saving it. The I/O system on the
      Amiga includes disk drives, windows, and requesters.

@{FG HIGHLIGHT}Iteration@{FG TEXT}            A program-ese synonym for 'repetition'. To a human
      the instruction to "Do forever" would be a Sysephean punishment. To
      a computer, it is just another task. In ARexx, iteration is performed
      by a single instruction, @{" DO " link ARx_Instr.ag/DO}, which has a wide range of options to
      give the programmer control over when the iteration stops.

@{FG HIGHLIGHT}Keyword@{FG TEXT}              The word that identifies an ARexx instruction or
      the option to an instruction. Keywords and instructions are detailed
      in the @{" Instruction reference " link ARX_INSTR.AG/MAIN}.

@{FG HIGHLIGHT}Logical device@{FG TEXT}       A part of the computer system defined through
      software. In AmigaDOS, logical devices intervene between the
      application program (including ARexx) and such hardware devices as
      disk drives, printers, and the monitor screen.

@{FG HIGHLIGHT}Loop@{FG TEXT}                 A section of program code that is repeated (or
      @{" iterated " link ArexxGuide.guide/GLOSSARY  35}). Looping in ARexx is controlled by the @{" DO " link ARx_Instr.ag/DO} instruction.

@{FG HIGHLIGHT}Mantra@{FG TEXT}               In Hinduism, a sacred formula, repeated over and
      over again, that is believed to posses special power. (Looking up
      this word demonstrates one of two things: either the user wasn't
      around for the 60's or wasn't paying attention. < put ;-) smiley
      here > )

@{FG HIGHLIGHT}Nested@{FG TEXT}               To place one thing within another just as an egg is
      placed in a bird's nest. A nested function is one function used as
      an argument to another function as in RIGHT(TRUNC(Amount, 2), 6).
      Here the @{" TRUNC() " link ARx_Func2.ag/TRUNC()} function, which truncates the decimal points on
      a number, is nested within the @{" RIGHT() " link ARx_Func.ag/RIGHT()} function, which right-
      justifies the resulting number.

@{FG HIGHLIGHT}NIL:@{FG TEXT}                 A logical device recognized by AmigaDOS that will
      throw away input or output directed to it.

@{FG HIGHLIGHT}Preferences@{FG TEXT}          A series of programs that are part of the Amiga OS.
      They allow the user to customize most aspects of the system.

@{FG HIGHLIGHT}Prototyping@{FG TEXT}          The process of developing an initial version of a
      software application in one language to test the logic of the code
      and the usefulness of contemplated options.

@{FG HIGHLIGHT}PRT:@{FG TEXT}                 A logical device recognized by AmigaDOS that directs
      output to the printer currently defined in @{" Preferences " link ArexxGuide.guide/GLOSSARY  69}. This
      device can be used as the <filename> with the @{" file I/O " link ARx_Func3.ag/FILEIOLIST} functions
      to print material from an ARexx script.

@{FG HIGHLIGHT}Reserved@{FG TEXT}             A @{" token " link ARx_Elements.ag/TOKEN} that serves a specialized purpose in the
      language and cannot be used for any other purpose. REXX has a
      limited set of reserved tokens. The single characters representing
      @{" operators " link ARx_Elements3.ag/OPERATION} and @{" special characters " link ARx_Elements.ag/SPECCHAR} are reserved in all situations.
      @{" Instruction " link ARx_Elements3.ag/INSTRUCTION} @{" keywords " link ArexxGuide.guide/GLOSSARY  41} and sub-keywords are reserved only within
      the limited range of the instruction itself. The variables [x] and
      [b] -- although they are not technically reserved -- should be
      avoided because of possible conflicts with @{" hex and binary strings " link ARx_Elements.ag/HEXSTRING}.

@{FG HIGHLIGHT}STDERR@{FG TEXT}               Standard error device. This is the @{" logical name " link ARx_Notes.ag/LOGFILE}
      assigned to a device to which ARexx will send error messages and
      the output of @{" tracing " link ARx_Instr3.ag/TRACE}. If the @{" trace console " link ARx_Cmd.ag/TCO} is open, that will
      become STDERR. The @{" PARSE EXTERNAL " link ARx_Instr2.ag/PARSESRC3} instruction retrieves input
      from this device.

@{FG HIGHLIGHT}STDIN@{FG TEXT}                Standard input device. This is the @{" logical name " link ARx_Notes.ag/LOGFILE}
      assigned to a device from which ARexx will retrieve input then the
      @{" PARSE PULL " link ARx_Instr2.ag/PARSESRC2} instruction is used. It is usually the shell from which
      a program was launched, although a script started from another
      environment will often have STDIN assigned to @{" NIL: " link ArexxGuide.guide/GLOSSARY  66}.

@{FG HIGHLIGHT}STDOUT@{FG TEXT}               Standard output device. This is the @{" logical name " link ARx_Notes.ag/LOGFILE}
      of the device to which ARexx will output the expression used in a
      @{" SAY " link ARx_Instr3.ag/SAY} instruction. It is usually the shell from which a program was
      launched, although a script started from another environment will
      often have STDOUT assigned to @{" NIL: " link ArexxGuide.guide/GLOSSARY  66}.

@{FG HIGHLIGHT}Subroutine@{FG TEXT}           A section of code separated from the main body of
      a program. In ARexx, subroutines are identified by @{" labels " link ARx_Elements3.ag/LABEL} and
      usually serve as @{" internal functions " link ARx_Elements3.ag/PROGFUNC}.


























@EndNode
@Node IACTEXMP "ARexxGuide | Interactive examples -- Requirements"
@PREV MAIN
@NEXT MAIN
The @{" registration form " link REGINFO} and several @{" interactive examples " link ArexxGuide.guide/COMPCONT  326} scattered
throughout ARexxGuide use ARexx scripts to provide the interactive
environment. Because they must try to run a script, the buttons impose
some extra requirements:

      1. The @{" RX " link ARx_Cmd.ag/RX} command must be located in a directory that is included
         in the Workbench command search path.

The RX command is included in a special directory, "rexxc," on Workbench
disks distributed by Commodore. If that directory is not included in your
search path, the links will fail. Either add "sys:rexxc" to the search
path or move RX to a directory like "C:" that is already in the path.

(AmigaGuide has a built-in "RX" link command. It is not used here because
scripts launched with the command exhibit some inconsistent behavior.)

      2. The #?.rexx files distributed with the ARexxGuide archive must be
         stored either in the @{" REXX: directory " link ARx_Intro.ag/STARTUP 18} or in ARexxGuide's current
         directory.

The most versatile place to store any .rexx file is in the REXX: directory
since it can then be found and launched by RX no matter what the current
directory. That directory can become crowded, however. Since the
@{" interpreter " link ArexxGuide.guide/GLOSSARY  27} looks for files first in the current directory, it can be a
useful alternative for task-specific ARexx scripts like those included
with this guide.

If the guide is launched from a shell or directory utility, the "CD"
command should be used before launching the guide to change the working
directory to the location of the .rexx files. If the guide is launched
with an icon, the .rexx files should be stored in the same directory as
the icon's .info file.

      3. AmigaGuide should be launched as a command rather than through a
         call to the ShowNode() function of amigaguide.library.

Scripts that use the library function to launch AmigaGuide files have
circulated on the nets. Using the function limits AmigaGuide's ability to
call ARexx scripts.

@EndNode