.LM 5;.RM 70
.SP 1
.ENABLE BAR
.NF
.FIGURE 10
.CENTER 70;DOCUMENT MP-1-3415
.S 1
.BB
.CENTER 70;File:  CLUSTER::[MP1Q.MANUALS]FLECSUIM.RNO
.S 1
.CENTER 70;Under RSX-11M and VMS
.EB
.S 6
.CENTER 70;FLECS and ALECS User's Manual
.s 3
.center 70;This manual corresponds to version 22 of FLECS
.center 70;As Modified at LAMPF
.s 3
.BB
.center 70;August 27, 1984
.EB
.s 5
.center 70;GROUP MP-1
.s 5
.center 70;Clinton P. Anderson Meson Physics Facility (LAMPF)
.center 70;Los Alamos National Laboratory
.center 70;Los Alamos, New Mexico 87545
.page
.center 70;TABLE OF CONTENTS
.s 1
.IF TOC
.REQUIRE "FLECSUIM.RNT"
.LM 5;.RM 70;.FILL;.JUSTIFY
.ELSE TOC
.PAGE
DUMMY PAGE TO HOLD SPACE FOR 2ND PAGE OF TABLE OF CONTENTS
.LM 5;.RM 70;.FILL;.JUSTIFY
.ENDIF TOC
.LM 5;.RM 70;.FILL;.JUSTIFY
.PAGE
.LM+10;.RM-10
.FIGURE 10
.fill
.justify
.CENTER 60;ABSTRACT
.s 1
This document describes the FLECS and ALECS programming languages which
allow use of standard structured programming techniques in FORTRAN
and MACRO-11 programs, respectively.
.s 5
.center 60;REVISION LIST
.LM 5;.RM 72
.LM +10
.s 1
.I -10
05-Jan-75 (Terry Beyer) written.
.BR
.I -10
17-Jan-79 (Civil Aeromedical Institute) put into RUNOFF format.
.BR
.I -10
01-Oct-82 (MAO) revised to currently used FLECS/ALECS at LAMPF; DSR format.
.BR
.I -10
19-Sep-83 (MAO) Document new listing format, new command files,
.br
response to long lines, and generation of either PDP or VAX MACRO.
.br
.i -10
27-Aug-84 (MAO) Document ".IMPLICIT NONE"; revise Sec.#10.
.page
.LM 5
.FLAGS CAPITALIZE
.LOWER CASE
.HL 1 ^^INTRODUCTION\\
.send toc.skip1
.P
<FORTRAN CONTAINS FOUR BASIC MECHANISMS FOR CONTROLLING PROGRAM FLOW:
^^CALL/RETURN, IF, DO\\, AND VARIOUS FORMS OF THE ^^GO#TO\\.
.P
<FLECS <(&FORTRAN &^LANGUAGE &^EXTENSIONS AND &^CONTROL &^STRUCTURES) HAS ADDITIONAL CONTROL
MECHANISMS THAT MAKE IT EASIER TO WRITE <FORTRAN BY
ELIMINATING MUCH OF THE CLERICAL DETAIL ASSOCIATED WITH CONSTRUCTING
<FORTRAN PROGRAMS.
<FLECS IS ALSO EASIER TO READ AND COMPREHEND.
.P
^THIS MANUAL IS A BRIEF, BUT COMPLETE, INTRODUCTION
TO <FLECS.  ^IT IS NOT A PRIMER ON <FLECS OR STRUCTURED
PROGRAMMING.
^THE READER IS ASSUMED TO BE A KNOWLEDGEABLE <FORTRAN PROGRAMMER.
.P
^PROGRAMMERS TO WHOM TRANSPORTABILITY OF THEIR PROGRAMS IS A 
.INDEX ^TRANSPORTABILITY
CONCERN SHOULD NOTE THAT THE <FLECS TRANSLATOR SOURCE
CODE IS IN THE PUBLIC DOMAIN AND IS MADE FREELY AVAILABLE.
^THE TRANSLATOR WAS WRITTEN WITH TRANSPORTABILITY IN MIND AND
REQUIRES LITTLE EFFORT TO MOVE FROM ONE MACHINE TO ANOTHER.
.P
<FLECS IS IMPLEMENTED ON BOTH THE <PDP-11 AND THE <VAX-11/780.
^THE MANNER OF IMPLEMENTATION IS THAT OF A PREPROCESSOR THAT
TRANSLATES <FLECS PROGRAMS INTO <FORTRAN PROGRAMS.
^THE RESULTING <FORTRAN PROGRAM IS THEN PROCESSED IN THE
USUAL WAY.
^THE TRANSLATOR ALSO PRODUCES A NICELY FORMATTED LISTING OF
THE <FLECS PROGRAM THAT GRAPHICALLY PRESENTS THE CONTROL
STRUCTURES USED.
.P
^THE FOLLOWING DIAGRAM ILLUSTRATES THE TRANSLATING PROCESS:
.LM +3
.S 1
.NOFILL
.TEST PAGE 9
<FLECS             <FLECS               ^TRANSLATED
^SOURCE----------->^TRANSLATOR---------><FORTRAN
^PROGRAM                 !             SOURCE
                        !               !
                        !               !
                  ^INDENTED            ^TO
                  ^LISTING             <FORTRAN
                                      ^COMPILER
.FILL
.P
.LM 5
^THE USEFULNESS OF <FLECS FOR <FORTRAN PROGRAMS MAKES IT CLEAR THAT A
STRUCTURED PREPROCESSOR IS DESIRABLE FOR ANY LANGUAGE LACKING THE APPROPRIATE
CONSTRUCTS.
^AT <LAMPF, WE HAVE THEREFORE IMPLEMENTED AN "<ALECS" PREPROCESSOR FOR <PDP
<MACRO-11 OR <VAX-11 <MACRO ASSEMBLY LANGUAGE ROUTINES.
<ALECS IMPLEMENTS ALL OF THE STRUCTURED CONSTRUCTS USED IN <FLECS (EXCEPT <DO).
^EXCEPT AS NOTED, THE MATERIAL IN THIS MANUAL APPLIES TO BOTH
<ALECS AND <FLECS.
^HOWEVER, IN ^SEC.#8, SOME SPECIAL RESTRICTIONS AND FEATURES OF <ALECS ARE GIVEN.
.HL 2 ^&^RETENTION OF <FORTRAN ^FEATURES\&
.P
^THE <FLECS TRANSLATOR EXAMINES EACH STATEMENT IN THE <FLECS
.INDEX ^^FORTRAN\\ FEATURES
PROGRAM TO SEE IF IT IS AN ^&EXTENDED STATEMENT\& (A STATEMENT
.INDEX EXTENDED STATEMENT
VALID IN <FLECS BUT NOT IN <FORTRAN).
^IF IT IS RECOGNIZED AS AN EXTENDED STATEMENT, THE TRANSLATOR
GENERATES THE CORRESPONDING <FORTRAN STATEMENTS.
^IF, HOWEVER, THE STATEMENT IS NOT RECOGNIZED AS AN EXTENDED STATEMENT,
THE TRANSLATOR ASSUMES IT MUST BE A <FORTRAN STATEMENT AND PASSES
IT THROUGH UNALTERED.
^THUS, ^&THE <FLECS SYSTEM DOES NOT RESTRICT THE USE OF <FORTRAN STATEMENTS;\&
IT SIMPLY PROVIDES ADDITIONAL STATEMENTS WHICH MAY BE USED.
^IN PARTICULAR, ^^GO#TO\\S, ARITHMETIC ^^IF\\S, ^^CALL\\S, ARITHMETIC
STATEMENT FUNCTIONS, AND ANY OTHER <FORTRAN STATEMENTS, COMPILER
DEPENDENT OR OTHERWISE, MAY BE USED IN A <FLECS PROGRAM.
^SIMILARLY, <ALECS ALLOWS FULL USE OF <MACRO-11 OR <VAX-11 <MACRO FEATURES.
.P
<FORTRAN HAS A NUMBER OF SPECIAL CONVENTIONS FOR DEALING WITH TABS,
AND <FLECS/ALECS USE THE SAME CONVENTIONS
(SEE THE <FORTRAN LANGUAGE MANUAL).
^THROUGHOUT THIS MANUAL, WE WILL DESCRIBE STATEMENTS AS STARTING
IN COLUMN 7, ETC., BUT, IN FACT, THE <FORTRAN TAB CONVENTIONS ARE ALSO ALLOWED.
.HL 2 ^&^C\\ORRELATION OF <FLECS AND <FORTRAN ^SOURCES\&
.P
^ONE DIFFICULTY OF PREPROCESSOR SYSTEMS LIKE <FLECS IS THAT ERROR
MESSAGES THAT COME FROM THE <FORTRAN COMPILER MUST BE RELATED BACK
TO THE ORIGINAL <FLECS SOURCE PROGRAM. ^THIS DIFFICULTY IS REDUCED
.INDEX LINE NUMBERS
BY THE TRANSLATOR BY PUTTING THE <FLECS LINE NUMBER IN COLUMNS
73-80 OF THE <FORTRAN CODE.
^THUS, IF THE COMPILER FLAGS A LINE OF
INPUT AS BEING IN ERROR, CHECK THAT LINE IN THE <FORTRAN INPUT FILE
AND AT ITS END WILL BE THE NUMBER OF THE SOURCE LINE IN THE <FLECS
INPUT FILE.  ^NOTE THAT A <FLECS LINE MAY PRODUCE MORE THAN ONE LINE
OF <FORTRAN CODE, SO SEVERAL LINES OF <FORTRAN CODE MAY POINT TO THE
SAME LOCATION IN THE <FLECS INPUT.
.P
^ON THE <FLECS LISTING FILE THE <FLECS LINE NUMBER IS GIVEN IN THE
LEFTMOST COLUMN.  ^TO THE RIGHT OF THESE NUMBERS IS GIVEN THE LINE NUMBER
OF THE <FORTRAN CODE GENERATED BY THAT <FLECS LINE.  ^THE <FORTRAN
LINE NUMBER IS USEFUL IF YOU GET A <FORTRAN EXECUTION-TIME ERROR WITH A
<FORTRAN LINE NUMBER AND YOU ONLY HAVE THE <FLECS LISTING FILE.  ^THE
<FORTRAN LINE NUMBERS GIVEN IN THE <FLECS FILE DISAGREE WITH THE TRUE
<FORTRAN LINE NUMBERS IN THE FOLLOWING CASES:
.LIST
.LE;^D-LINES ARE ALWAYS COUNTED BY <FLECS.  ^THUS THE LINE NUMBERS ARE
CORRECT ONLY IF <FORTRAN COMPILES ^D-LINES.
.LE;^LINES FROM <FORTRAN <INCLUDE FILES ARE NOT COUNTED BY <FLECS.  ^TO
GET SUCH LINES COUNTED, USE A <FLECS <.INCLUDE FILE (SEE ^SEC.#9.4).
.LE;^LINES WITH <FLECS KEYWORDS MAY GENERATE FROM ZERO TO MANY LINES
OF <FORTRAN CODE.  ^FOR SUCH KEYWORD LINES, THE <FORTRAN LINE NUMBER WILL BE
EITHER THE LAST OR NEXT TO LAST <FORTRAN LINE ACTUALLY GENERATED.
.END LIST
.P
^NOTE <PDP AND <VAX <FORTRAN COMPILERS NUMBER LINES DIFFERENTLY, SO DO NOT
BE SURPRISED IF <FLECS LISTINGS ARE DIFFERENT FOR THE TWO SYSTEMS.
^ALSO NOTE THE <FLECS </FU SWITCH MAY CHANGE THE LINE NUMBERING.
.PAGE
.send toc.skip1
.HL 1 ^^STRUCTURED STATEMENTS\\
.send toc.skip1
.P
^A BASIC NOTION OF <FLECS IS THAT OF THE ^&STRUCTURED STATEMENT\&
WHICH CONSISTS OF A ^&CONTROL PHRASE\& AND ITS ^&SCOPE\&.
.INDEX STRUCTURED STATEMENT
<FORTRAN HAS TWO STRUCTURED STATEMENTS, THE LOGICAL <IF AND
THE <DO.
^THE FOLLOWING EXAMPLE ILLUSTRATES THIS TERMINOLOGY:
.INDEX ^^IF\\
.INDEX ^^DO\\
.LM +3
.S 1
.NOFILL
.TEST PAGE 7
#####STRUCTURED STATEMENT
:----------------------------------:
###CONTROL PHRASE##########SCOPE
:-----------------------: :--------:
#KEYWORD###SPECIFICATION
:--------:#:------------:
  ^^IF         (X.EQ.Y)########U=V+W\\
.S 2
.TEST PAGE 6
#KEYWORD###SPECIFICATION
:--------:#:------------:
###^^DO######30 I = 1,N####\\CONTROL PHRASE  )
###^^A(I)  = B(I)+C########)###############(##\\STRUCTURED
###^^L(I)  = I-K(I)########(##\\SCOPE########(##STATEMENT
30#<CONTINUE\\##############)###############)
.FILL
.S 1
.LM 5
^NOTE THAT EACH STRUCTURED STATEMENT CONSISTS OF A CONTROL PHRASE
.INDEX CONTROL PHRASE
THAT CONTROLS THE EXECUTION OF A SET OF ONE OR MORE STATEMENTS
CALLED ITS SCOPE.
.INDEX SCOPE
^ALSO NOTE THAT EACH CONTROL PHRASE CONSISTS OF A 
^&KEYWORD\& PLUS
.INDEX KEYWORDS
SOME ADDITIONAL INFORMATION CALLED THE ^&SPECIFICATION\&.
.INDEX SPECIFICATION
^A STATEMENT THAT DOES NOT CONSIST OF A CONTROL PHRASE AND A SCOPE
IS SAID TO BE A ^&SIMPLE STATEMENT\&.
.INDEX SIMPLE STATEMENT
^EXAMPLES OF SIMPLE STATEMENTS ARE ASSIGNMENT STATEMENTS,
SUBROUTINE ^^CALL\\S, ARITHMETIC ^^IF\\S, AND ^^GO#TO\\S.
.P
^THE PROBLEM WITH THE <FORTRAN LOGICAL <IF STATEMENT IS THAT ITS
SCOPE MAY CONTAIN ONLY A SINGLE SIMPLE STATEMENT.
^THIS RESTRICTION IS ELIMINATED IN THE CASE OF THE <DO, BUT AT THE
COST OF CLERICAL DETAIL (HAVING TO STOP THINKING ABOUT THE PROBLEM WHILE
A STATEMENT NUMBER IS INVENTED).
^NOTE ALSO THAT THE <IF SPECIFICATION IS ENCLOSED IN PARENTHESES
WHILE THE <DO SPECIFICATION IS NOT.
.P
^IN <FLECS THERE IS A UNIFORM CONVENTION FOR WRITING CONTROL PHRASES
AND INDICATING THEIR SCOPES.
^IN WRITING A STRUCTURED STATEMENT, THE KEYWORD IS PLACED ON A LINE
BEGINNING IN COLUMN 7 FOLLOWED BY ITS SPECIFICATION ENCLOSED IN
PARENTHESES.
^THE REMAINDER OF THE LINE IS LEFT BLANK EXCEPT FOR COMMENTS (SEE ^SEC.#10).
^THE STATEMENTS COMPOSING THE SCOPE ARE PLACED ON SUCCESSIVE
LINES.
^THE END OF THE SCOPE IS INDICATED BY A <FIN STATEMENT.
.INDEX ^^FIN\\
^THIS CREATES A ^&MULTILINE STRUCTURED\& STATEMENT.
.INDEX MULTILINE STRUCTURED STATEMENT
.TEST PAGE 13
.SKIP 1
^EXAMPLES OF MULTILINE STRUCTURED STATEMENTS:
.S 1
.NOFILL
###^^IF (X.EQ.Y)
###|##U = V+W
###|##R = S+T
###|____FIN\\
.S 1
###^^DO (I=1,N)
###|##A(I) = B(I)+C
###|##C = C*2.14-3.14
###|____FIN\\
.S 1
.FILL
^NOTE: ^THE STATEMENT NUMBER HAS BEEN ELIMINATED FROM THE <DO
SPECIFICATION SINCE IT IS NO LONGER NECESSARY, THE END OF THE
LOOP BEING SPECIFIED BY THE <FIN.
.P
^NESTING OF STRUCTURED STATEMENTS IS PERMITTED TO ANY DEPTH.
.SKIP 1
.INDEX NESTING
^EXAMPLE OF NESTED STRUCTURED STATEMENTS:
.S 1
.NOFILL
.TEST PAGE 8
###^^IF (X.EQ.Y)
###|##U = V+W
###|##DO (I = 1,N)
###|##|##A(I) = B(I)+C
###|##|##C = C*2.14-3.14
###|##|____FIN
###|##R = S+T
###|____FIN\\
.P
.FILL
^WHEN THE SCOPE OF A CONTROL PHRASE CONSISTS OF A SINGLE 
^&SIMPLE\&
STATEMENT, IT MAY BE PLACED ON THE SAME LINE AS THE CONTROL PHRASE
AND THE <FIN MAY BE DISPENSED WITH.
^THIS CREATES A ^&ONE-LINE STRUCTURED STATEMENT\&.
.INDEX ONE-LINE STRUCTURED STATEMENT
.SKIP 1
^EXAMPLES OF ONE-LINE STRUCTURED STATEMENTS:
.S 1
.TP 4
###^^IF (X.EQ.Y) U=V+W\\
.S 1
###^^DO (I=1,N)  A(I) = B(I)+C\\
.P
^SINCE EACH CONTROL PHRASE MUST BEGIN ON A NEW LINE, IT IS NOT POSSIBLE
TO HAVE A ONE-LINE STRUCTURED STATEMENT WHOSE SCOPE CONSISTS OF A
STRUCTURED STATEMENT.
.SKIP 1
^EXAMPLE OF ^&INVALID\& CONSTRUCTION:
.TP 3
.S 1
###^^IF (X.EQ.Y) DO (I=1,N) A(I) = B(I)+C\\
.P
^TO ACHIEVE THE EFFECT DESIRED ABOVE, THE <IF MUST BE
WRITTEN IN A MULTILINE FORM.
.SKIP 1
.TP 7
^EXAMPLE OF VALID CONSTRUCTION:
.S 1
.NOFILL
###^^IF (X.EQ.Y)
###|##DO (I=1,N) A(I) = B(I)+C
###|____FIN\\
.P
.FILL
<FLECS PROVIDES, IN ADDITION TO <IF AND <DO, SEVERAL
USEFUL STRUCTURED STATEMENTS NOT AVAILABLE IN <FORTRAN.
^AFTER A BRIEF EXCURSION INTO THE SUBJECT OF INDENTATION,
WE WILL PRESENT THESE ADDITIONAL STRUCTURES.
.PAGE
.send toc.skip1
.HL 1 ^^INDENTATION, LINES, AND THE LISTING\\
.send toc.skip1
.P
^IN THE EXAMPLES OF MULTILINE STRUCTURED STATEMENTS ABOVE,
THE STATEMENTS IN THE SCOPE WERE INDENTED, AND AN ^L-SHAPED
.INDEX INDENTATION
LINE WAS DRAWN CONNECTING THE KEYWORD OF THE CONTROL
PHRASE TO THE MATCHING <FIN.
^THE RESULTING GRAPHIC EFFECT HELPS TO REVEAL THE STRUCTURE
OF THE PROGRAM.
^THE RULES FOR USING INDENTATION AND ^^FIN\\S ARE QUITE
SIMPLE AND UNIFORM.
^THE CONTROL PHRASE OF A MULTILINE STRUCTURED STATEMENT ALWAYS
CAUSES INDENTATION OF THE STATEMENTS THAT FOLLOW.
^NOTHING ELSE CAUSES INDENTATION.
^A LEVEL OF INDENTATION (I.E., A SCOPE) IS ALWAYS TERMINATED BY
A <FIN.
^NOTHING ELSE TERMINATES A LEVEL OF INDENTATION.
.P
^WHEN WRITING A <FLECS PROGRAM ON PAPER, THE PROGRAMMER SHOULD
ADOPT THE INDENTATION AND LINE-DRAWING CONVENTIONS SHOWN IN
.INDEX SOURCE PREPARATION
<FLECS LISTINGS.
^WHEN PREPARING A <FLECS SOURCE PROGRAM IN MACHINE-READABLE
FORM, HOWEVER, EACH STATEMENT SHOULD BEGIN IN COLUMN 7.
^WHEN THE <FLECS TRANSLATOR PRODUCES THE LISTING, IT WILL
REINTRODUCE THE CORRECT INDENTATION AND PRODUCE CORRESPONDING
LINES.
^IF THE PROGRAMMER ATTEMPTS TO INTRODUCE HIS OWN INDENTATION WITH
THE USE OF LEADING BLANKS, THE PROGRAM WILL BE TRANSLATED CORRECTLY, BUT
THE RESULTING LISTING WILL BE IMPROPERLY INDENTED.
.INDEX LISTING
.SKIP 1
^EXAMPLE OF INDENTATION:
.TP 12
.LS
.LM +5
.LE; ^PROGRAM AS WRITTEN ON PAPER BY PROGRAMMER.
.S 1
.NF
#^^IF(X.EQ.Y)
#|##U=V+W
#|  DO(I=1,N)
#|  |  A(I)=B(I)+C
#|  |  C=C*2.14-3.14
#|  |____FIN
#|  R=S+T
#|____FIN\\
.TP 10
.FILL
.LE; ^PROGRAM AS ENTERED INTO COMPUTER.
.S 1
.NF
#^^IF (X.EQ.Y)
#U = V+W
#DO (I = 1,N)
#A(I) = B(I)+C
#C = C*2.14-3.14
#FIN
#R = S+T
#FIN\\
.FILL
.TP 10
.LE; ^PROGRAM AS LISTED BY <FLECS TRANSLATOR.
.S 1
.NF
#^^IF (X.EQ.Y)
#.##U = V+W
#.##DO (I = 1,N)
#.##.##A(I) = B(I)+C
#.##.##C = C*2.14-3.14
#.##...FIN
#.##R = S+T
#...FIN\\
.ELS
.LM 5
.FILL
.S 1
^THE CORRECTLY INDENTED LISTING IS A TREMENDOUS AID IN READING AND
WORKING WITH PROGRAMS.
^EXCEPT FOR THE DOTS AND SPACES USED FOR INDENTATION, THE LINES
ARE LISTED EXACTLY AS THEY APPEAR IN THE SOURCE PROGRAM;
THAT IS, THE INTERNAL SPACING OF COLUMNS 7-72 IS PRESERVED.
^THERE IS SELDOM ANY NEED TO REFER TO THE STRAIGHT LISTING OF THE
SOURCE THAT IS NOT INDENTED.
.P
^COMMENT LINES ARE TREATED IN THE FOLLOWING WAY ON THE LISTING TO
.INDEX COMMENT LINE
PREVENT INTERRUPTION OF THE DOTTED LINES INDICATING SCOPE.
^A COMMENT LINE THAT CONTAINS ONLY BLANKS IN COLUMNS 2-6
WILL BE LISTED WITH COLUMNS 7-72 INDENTED AT THE
THEN-CURRENT LEVEL OF INDENTATION AS IF THE LINE WERE AN EXECUTABLE
STATEMENT.
^IF, HOWEVER, ONE OR MORE NONBLANK CHARACTERS APPEAR IN
COLUMNS 2-6 OF A COMMENT LINE, THE LINE  WILL BE LISTED WITHOUT
INDENTATION.
^BLANK LINES MAY BE INSERTED IN THE SOURCE AND WILL BE TREATED
AS EMPTY COMMENTS.
.PAGE
.send toc.skip1
.HL 1 ^^CONTROL STRUCTURES\\
.send toc.skip1
.P
^THE COMPLETE SET OF CONTROL STRUCTURES
.INDEX CONTROL STRUCTURES
PROVIDED BY <FLECS IS GIVEN BELOW.
^THE SYMBOL [^L] IS USED TO INDICATE A LOGICAL EXPRESSION.
.INDEX LOGICAL EXPRESSION
^THE SYMBOL $ IS USED TO INDICATE A SCOPE OF ONE OR MORE STATEMENTS.
^SOME STATEMENTS, AS INDICATED BELOW, DO NOT HAVE A ONE-LINE
CONSTRUCTION.
.P
^A CONVENIENT SUMMARY OF THE INFORMATION IN THIS SECTION MAY BE
FOUND IN ^APPENDIX ^A  ALONG WITH FLOW CHARTS FOR THE STRUCTURES.
.HL 2 ^&^D\\ECISION ^STRUCTURES\&
.P
^DECISION STRUCTURES ARE STRUCTURED STATEMENTS THAT CONTROL THE
.INDEX DECISION STRUCTURES
EXECUTION OF THEIR SCOPES ON THE BASIS OF A LOGICAL EXPRESSION
OR TEST. ^FLOW CHARTS FOR THE STRUCTURES ARE GIVEN IN ^APPENDIX ^A.
.HL 3 ^&<IF\&
.INDEX ^^IF\\
.P
^DESCRIPTION: ^THE <IF STATEMENT CAUSES A LOGICAL EXPRESSION TO
BE EVALUATED. ^IF THE VALUE IS TRUE, THE SCOPE IS EXECUTED ONCE
AND CONTROL PASSES TO THE NEXT STATEMENT. ^IF THE VALUE IS FALSE,
CONTROL PASSES DIRECTLY TO THE NEXT STATEMENT FOLLOWING THE SCOPE WITHOUT EXECUTION
OF THE SCOPE.
.TP 4
.S 1
^GENERAL FORM:
.S 1
.NOFILL
	^^IF ( [L] ) $\\
.S 1
.TP 8
^EXAMPLES:
.S 1
	^^IF (X.EQ.Y) U = V+W\\
.S 1
	^^IF (T.GT.0.AND.S.LT.R)
	.  I = I+1
	.  Z = 0.1
	...FIN\\
.FILL
.HL 3 ^&<UNLESS\&
.P
.INDEX ^^UNLESS\\
^DESCRIPTION: "^^UNLESS#(#[L]#)"\\ IS FUNCTIONALLY EQUIVALENT
TO "^^IF#(.NOT.(#[L]#))"\\ BUT IS MORE CONVENIENT IN SOME CONTEXTS.
.TP 3
.S 1
^GENERAL ^FORM:
.SKIP
.NOFILL
	^^UNLESS ( [L] ) $
.S 1
.TP 8
E\\XAMPLES:
.S 1
	^^UNLESS (X.NE.Y) U = V+W
.S 1
	UNLESS (T.LE.0.OR.S.GE.R)
	.  I = I+1
	.  Z = 0.1
	...FIN\\
.FILL
.HL 3 ^&^^WHEN...ELSE\\\&
.P
.INDEX ^^WHEN...ELSE\\
^DESCRIPTION:  ^THE <WHEN...ELSE STATEMENTS CORRESPOND TO THE
<IF...THEN...ELSE STATEMENT OF ^ALGOL, <PL_/1, ^PASCAL, ETC.
^IN <FLECS, BOTH THE <WHEN AND THE <ELSE ACT AS STRUCTURED
STATEMENTS, ALTHOUGH ONLY THE <WHEN HAS A  SPECIFICATION.
^THE <ELSE STATEMENT MUST IMMEDIATELY FOLLOW THE SCOPE OF THE <WHEN.
^THE SPECIFIER OF THE <WHEN IS EVALUATED, AND EXACTLY ONE OF THE TWO
SCOPES IS EXECUTED.
^THE SCOPE OF THE <WHEN IS EXECUTED IF THE EXPRESSION IS TRUE,
AND THE SCOPE OF THE <ELSE STATEMENT IS EXECUTED IF THE EXPRESSION
IS FALSE.
^IN EITHER CASE, CONTROL PASSES TO THE NEXT STATEMENT FOLLOWING THE
SCOPE OF THE
<ELSE STATEMENT.
.S 1
.TP 4
^GENERAL FORM:
.S 1
.NOFILL
	^^WHEN ( [L] ) $1
	ELSE $2\\
.S 1
.TP 25
^EXAMPLES:
.S 1
	^^WHEN (X.EQ.Y) U = V+W
	ELSE U = V-W\\
.S 1
	^^WHEN (X.EQ.Y)
	.  U = V+W
	.  T = T+1.5
	...FIN
	ELSE U = V-W\\
.S 1
	^^WHEN (X.EQ.Y) U = V+W
	ELSE
	.  U = V-W
	.  T = T+1.5
	...FIN\\
.S 1
	^^WHEN (X.EQ.Y)
	.  U = V+W
	.  T = T-1.5
	...FIN
	ELSE
	.  U = V-W
	.  T = T+1.5
	...FIN\\
.S 1
.FILL
^NOTE:  <WHEN AND <ELSE ALWAYS COME AS A PAIR OF STATEMENTS,
NEVER SEPARATELY.
^EITHER THE <WHEN OR THE <ELSE OR BOTH MAY ASSUME THE
MULTILINE FORM.
<ELSE IS CONSIDERED TO BE A CONTROL PHRASE, HENCE IT CANNOT BE
PLACED ON THE SAME LINE AS <WHEN.
^THUS, "^^WHEN#(#[L]#)#$1#ELSE#$2"\\ IS ^&NOT\& VALID.
.HL 3 ^&^^CONDITIONAL\\\&
.P
.INDEX ^^CONDITIONAL\\
^DESCRIPTION:
^THE <CONDITIONAL STATEMENT IS BASED ON THE <LISP
CONDITIONAL.
^LOGICAL EXPRESSIONS ARE EVALUATED ONE BY ONE UNTIL
THE FIRST TRUE EXPRESSION IS ENCOUNTERED.
^THE SCOPE CORRESPONDING TO THAT EXPRESSION IS EXECUTED, AND CONTROL
THEN PASSES TO THE FIRST STATEMENT FOLLOWING THE SCOPE OF THE <CONDITIONAL.
^IF ALL EXPRESSIONS ARE FALSE, NO SCOPE IS EXECUTED.
(^SEE, HOWEVER, THE NOTE ABOUT <OTHERWISE BELOW.)
.S 1
.TP 10
^GENERAL ^FORM:
.S 1
.NOFILL
	^^CONDITIONAL
	.  ( [L1] ) $1
	.  ( [L2] ) $2
	.     .      .
	.     .      .
	.     .      .
	. ( [L\N] )  $\N
	...FIN\\
.S 1
.TP 17
^EXAMPLES:
.S 1
	^^CONDITIONAL
	.  (X.LT. -5.0) U = U+W
	.  (X.LE. 1.0)  U = U+W+Z
	.  (X.LE.10.5)  U = U-Z
	...FIN\\
.S 1
	^^CONDITIONAL
	.  (A.EQ.B)  Z = 1.0
	.  (A.LE.C)
	.  .  Y = 2.0
	.  .  Z = 3.4
	.  ...FIN
	.  (A.GT.C.AND.A.LT.B)  Z=6.2
	.  (OTHERWISE)  Z = 0.0
	...FIN\\
.S 1
.FILL
^NOTE THAT THE <CONDITIONAL ITSELF DOES NOT POSSESS A ONE-LINE FORM.
^HOWEVER, EACH "(#[^LI]#)#$I" IS TREATED AS A STRUCTURED STATEMENT
AND MAY BE IN ONE-LINE OR MULTILINE FORM.
^NOTE ALSO THAT THE RESERVED WORD <OTHERWISE REPRESENTS A CATCHALL CONDITION.
.INDEX ^^OTHERWISE\\
^THAT IS, "(^^OTHERWISE)#$\\I" IS EQUIVALENT TO
"^^(.TRUE.)#$\\I" IN A ^^CONDITIONAL\\ STATEMENT.
.HL 3 ^&^^SELECT\&\\
.INDEX ^^SELECT\\
.P
^DESCRIPTION:
^THE <SELECT STATEMENT IS SIMILAR TO THE <CONDITIONAL
BUT IS MORE SPECIALIZED.
^IT ALLOWS AN EXPRESSION TO BE TESTED FOR EQUALITY TO EACH EXPRESSION
IN A LIST OF EXPRESSIONS.
^WHEN THE FIRST MATCHING EXPRESSION IS ENCOUNTERED, A CORRESPONDING
SCOPE IS EXECUTED, AND THE <SELECT STATEMENT TERMINATES.
^IN THE DESCRIPTION BELOW, ^^[EL1], [EL2],..., [EL3]\\ REPRESENT
ARBITRARY BUT COMPATIBLE EXPRESSIONS.
^ANY TYPE OF EXPRESSION (INTEGER, REAL, COMPLEX, ...)
IS ALLOWED AS LONG AS THE UNDERLYING <FORTRAN SYSTEM ALLOWS
SUCH EXPRESSIONS TO BE COMPARED WITH AN <.EQ. OR <.NE. OPERATOR. 
^FOR <ALECS, ONLY WORD (16-BIT) EXPRESSIONS ARE ALLOWED.
.TP 13
.S 1
^GENERAL ^FORM:
.S 1
.NOFILL
	^^SELECT ( [EL] )
	.  ( [EL1] ) $1
	.  ( [EL2] ) $2
	.    .        .
	.    .        .
	.    .        .
	.  ( [EL\N] ) $\N
	...FIN\\
.S 1
.TP 11
^EXAMPLE:
.S 1
	^^SELECT (OPCODE(PC))
	.  (JUMP) PC = AD
	.  (ADD)
	.  .  A = A+B
	.  .  PC = PC+1
	.  ...FIN
	.  (SKIP) PC = PC+2
	.  (STOP) CALL STOPCD
	...FIN\\
.S 1
.FILL
^NOTE THAT, AS IN THE CASE OF <CONDITIONAL, AT MOST ONE OF THE $I WILL
BE EXECUTED.
^NOTE TOO THAT THE CATCHALL <OTHERWISE MAY ALSO BE USED IN A <SELECT
.INDEX ^^OTHERWISE\\
STATEMENT.
^THUS, "(^^OTHERWISE)#$\\N" IS EQUIVALENT TO "^^([EL]) $\\N"
WITHIN A "^^SELECT#([EL]\\)" STATEMENT.
^ALSO NOTE THAT THE EXPRESSION [<EL] IS REEVALUATED FOR EACH COMPARISON
IN THE LIST. ^THUS, LENGTHY, TIME CONSUMING, OR IRREPRODUCABLE
EXPRESSIONS SHOULD BE PRECOMPUTED, ASSIGNED TO A VARIABLE, AND THE
VARIABLE USED IN THE SPECIFICATION PORTION OF THE <SELECT STATEMENT.
.HL 2 ^&^L\\OOP ^STRUCTURES\&
.P
.INDEX LOOPS
^THE STRUCTURED STATEMENTS DESCRIBED BELOW ALL HAVE A SCOPE
THAT IS EXECUTED A VARIABLE NUMBER OF TIMES DEPENDING ON
SPECIFIED CONDITIONS.
^OF THE FIVE LOOPS PRESENTED, THE MOST USEFUL ARE THE ^^DO, WHILE,\\
AND ^^REPEAT UNTIL\\ LOOPS.
^TO AVOID CONFUSION, THE ^^REPEAT#WHILE\\ AND ^^UNTIL\\ LOOPS
SHOULD BE IGNORED INITIALLY.
.HL 3 ^&<DO\&
.INDEX ^^DO\\
.P
^DESCRIPTION:
^THE <FLECS <DO LOOP IS FUNCTIONALLY IDENTICAL TO THE
<FORTRAN <DO LOOP;
THE ONLY DIFFERENCES ARE SYNTACTIC.
^IN THE <FLECS <DO LOOP, THE STATEMENT NUMBER IS OMITTED FROM
THE <DO STATEMENT, THE INCREMENTATION PARAMETERS ARE ENCLOSED
IN PARENTHESES, AND THE SCOPE IS INDICATED BY EITHER THE ONE-LINE
OR MULTILINE CONVENTION.
^SINCE THE SEMANTICS OF THE <FORTRAN <DO STATEMENT VARY FROM ONE
<FORTRAN COMPILER TO ANOTHER, A FLOWCHART CANNOT BE GIVEN.
^THE SYMBOL ^I_@ REPRESENTS ANY LEGAL INCREMENTATION SPECIFICATION.
.S 1
.TP 5
.NOFILL
^GENERAL ^FORM:                     ^EQUIVALENT <FORTRAN:
.S 1
####^^DO (I@) $                     DO 30 I@
                                  $
                              30  CONTINUE\\
.S 1
.TP 8
^EXAMPLES:
.S 1
	^^DO (I=1,N) A(I) = 0.0
.S 1
	DO (J=3,K,3)
	.  B(J) = B(J-1)*B(J-2)
	.  C(J) = SIN(B(J))
	...FIN\\
.FILL
.P
^NOTE:  <DO IS NOT SUPPORTED BY <ALECS.
.HL 3 ^&<WHILE\&
.P
.INDEX ^^WHILE\\
^DESCRIPTION: ^THE <WHILE LOOP CAUSES ITS SCOPE TO BE REPEATEDLY
EXECUTED WHILE A SPECIFIED CONDITION IS TRUE.
^THE CONDITION IS CHECKED PRIOR TO THE FIRST EXECUTION OF THE LOOP.
^THUS, IF THE CONDITION IS INITIALLY FALSE, THE SCOPE WILL NOT BE
EXECUTED AT ALL.
.S 1
^GENERAL ^FORM:
.S 1
.NOFILL
	^^WHILE ( [L] ) $
.S 1
.TP 8
E\\XAMPLES:
.S 1
	^^WHILE (X.LT.A(I)) I=I+1
.S 1
	WHILE (P.NE.0)
	.  VAL(P) = VAL(P)+1
	.  P = LINK(P)
	...FIN\\
.FILL
.HL 3 ^&^^REPEAT WHILE\&\\
.P
.INDEX ^^REPEAT WHILE\\
^DESCRIPTION: ^BY USING THE <REPEAT VERB, THE TEST CAN BE LOGICALLY
MOVED TO THE END OF THE LOOP.
^THE ^^REPEAT WHILE\\ LOOP CAUSES ITS SCOPE TO BE REPEATEDLY
EXECUTED WHILE A SPECIFIED CONDITION REMAINS TRUE.
^THE CONDITION IS NOT CHECKED UNTIL AFTER THE FIRST EXECUTION
OF THE LOOP.
^THUS, THE SCOPE WILL ALWAYS BE EXECUTED AT LEAST ONCE, AND THE
CONDITION INDICATES UNDER WHAT CONDITIONS THE SCOPE IS TO BE
REPEATED.
 ^NOTE THAT "^^REPEAT#WHILE([L])\\" IS FUNCTIONALLY EQUIVALENT TO
"^^REPEAT#UNTIL(.NOT.([L]))."\\
.S 1
.TP 3
^GENERAL ^FORM:
.S 1
.NOFILL
	^^REPEAT WHILE ([L]) $\\
.S 1
.TP 10
^EXAMPLES:
.S 1
	^^REPEAT WHILE (N.EQ.M(I)) I = I+1
.S 1
	REPEAT WHILE (LINK(Q).NE.0)
	.  R = LINK(Q)
	.  LINK(Q) = P
	.  P = Q
	.  Q = R
	...FIN\\
.FILL
.HL 3 ^&<UNTIL\&
.P
.INDEX ^^UNTIL\\
^DESCRIPTION:
^THE <UNTIL LOOP CAUSES ITS SCOPE TO BE REPEATEDLY
EXECUTED UNTIL A SPECIFIED CONDITION BECOMES TRUE.
^THE CONDITION IS CHECKED PRIOR TO THE FIRST EXECUTION OF THE SCOPE.
^THUS, IF THE CONDITION IS INITIALLY TRUE, THE SCOPE WILL NOT BE
EXECUTED AT ALL.
^NOTE THAT "^^UNTIL#([L]\\)" IS FUNCTIONALLY EQUIVALENT TO
"^^WHILE#(.NOT.([L]))\\."
.S 1
.TP 3
^GENERAL ^FORM:
.S 1
.NOFILL
	^^UNTIL ( [L] ) $\\
.S 1
.TP 8
^EXAMPLES:
.S 1
	^^UNTIL (X.EQ.A(I)) I = I+1
.S 1
	UNTIL (P.EQ.0)
	.  VAL(P) = VAL(P)+1
	.  P = LINK(P)
	...FIN\\
.FILL
.HL 3 ^&^^REPEAT UNTIL\&\\
.P
.INDEX ^^REPEAT UNTIL\\
^DESCRIPTION:
^BY USING THE <REPEAT VERB, THE TEST CAN BE LOGICALLY MOVED
TO THE END OF THE LOOP.
^THE ^^REPEAT UNTIL\\ LOOP CAUSES ITS SCOPE TO BE REPEATEDLY
EXECUTED UNTIL A SPECIFIED CONDITION BECOMES TRUE.
^THE CONDITION IS NOT CHECKED UNTIL AFTER THE FIRST EXECUTION
OF THE SCOPE.
^THUS, THE SCOPE WILL ALWAYS BE EXECUTED AT LEAST ONCE,
AND THE CONDITION INDICATES UNDER WHAT CONDITIONS THE REPETITION
OF THE SCOPE IS TO BE TERMINATED.
.S 1
.TP 3
^GENERAL ^FORM:
.S 1
.NOFILL
	^^REPEAT UNTIL ( [L] ) $\\
.S 1
^EXAMPLES:
.S 1
	^^REPEAT UNTIL (N.EQ.M(I)) I = I+1
.TP 10
.S 1
	REPEAT UNTIL (LINK(Q).EQ.0)
	.  R = LINK(Q)
	.  LINK(Q) = P
	.  P = Q
	.  Q = R
	...FIN\\
.FILL
.PAGE
.send toc.skip1
.HL 1 ^^INTERNAL PROCEDURES\\
.send toc.skip1
.P
.INDEX INTERNAL PROCEDURES
^IN <FLECS, A SEQUENCE OF STATEMENTS MAY BE DECLARED TO BE
AN ^&INTERNAL PROCEDURE\& AND GIVEN A NAME.
^THE PROCEDURE MAY THEN BE INVOKED FROM ANY POINT IN THE
PROGRAM BY SIMPLY GIVING ITS NAME.
.P
^&^PROCEDURE NAMES\& MAY BE ANY STRING OF LETTERS, DIGITS, AND
.INDEX PROCEDURE NAME
HYPHENS (I.E., MINUS SIGNS) BEGINNING WITH A LETTER AND CONTAINING
AT LEAST ONE HYPHEN.
^INTERNAL BLANKS ARE NOT ALLOWED.
^THE ONLY RESTRICTION ON THE LENGTH OF A NAME IS THAT IT MAY NOT BE
CONTINUED ONTO A SECOND LINE.
^EXAMPLES OF VALID INTERNAL PROCEDURE NAMES:
.S 1
.TP 6
.NOFILL
	^^INITIALIZE-ARRAYS
	GIVE-WARNING
	SORT-INTO-DESCENDING-ORDER
	INITITATE-PHASE-3\\
.P
.FILL
^A ^&PROCEDURE DECLARATION\& CONSISTS OF THE KEYWORD "<TO"
FOLLOWED BY THE PROCEDURE NAME AND ITS SCOPE.
^THE SET OF STATEMENTS COMPOSING THE PROCEDURE IS CALLED ITS SCOPE.
^IF THE SCOPE CONSISTS OF A SINGLE SIMPLE STATEMENT, IT MAY BE
PLACED ON THE SAME LINE AS THE "<TO" AND PROCEDURE NAME. ^OTHERWISE,
THE STATEMENTS OF THE SCOPE ARE PLACED ON THE FOLLOWING LINES AND
TERMINATED WITH A <FIN STATEMENT.
^THESE RULES ARE ANALOGOUS TO THE RULES FOR FORMING THE SCOPE
OF A STUCTURED STATEMENT.
.S 1
.TP 3
^GENERAL FORM OF PROCEDURE DECLARATIONS:
.S 1
.NOFILL
	^^TO\\ PROCEDURE-NAME
.FILL
.S 1
.TP 15
^EXAMPLES OF PROCEDURE DECLARATIONS:
.S 1
.NOFILL
	^^TO RESET-POINTER P = 0
.S 1
	TO DO-NOTHING CONTINUE
.S 1
	TO SUMMARIZE-FILE
	.  INITIALIZE-SUMMARY
	.  OPEN-FILE
	.  REPEAT UNTIL (EOF)
	.  .  ATTEMPT-TO-READ-RECORD
	.  .  WHEN (EOF) CLOSE-FILE
	.  .  ELSE UPDATE-SUMMARY
	.  ...FIN
	.  OUTPUT-SUMMARY
	...FIN\\
.P
.FILL
^AN ^&INTERNAL PROCEDURE REFERENCE\& IS A PROCEDURE NAME
APPEARING WHERE AN EXECUTABLE STATEMENT WOULD BE EXPECTED.
^IN FACT, AN INTERNAL PROCEDURE REFERENCE 
^&IS\& AN EXECUTABLE
SIMPLE STATEMENT AND, THUS, MAY BE USED IN THE SCOPE OF A STRUCTURED
STATEMENT AS IN THE LAST EXAMPLE ABOVE.
^WHEN CONTROL REACHES A PROCEDURE REFERENCE DURING EXECUTION
OF A <FLECS PROGRAM, A RETURN ADDRESS IS SAVED, AND CONTROL IS
TRANSFERRED TO THE FIRST STATEMENT IN THE SCOPE OF THE PROCEDURE.
^WHEN CONTROL REACHES THE END OF THE SCOPE, CONTROL IS TRANSFERRED
BACK TO THE STATEMENT LOGICALLY FOLLOWING THE PROCEDURE REFERENCE.
.P
^A TYPICAL <FLECS PROGRAM OR SUBPROGRAM CONSISTS OF A SEQUENCE OF
<FORTRAN DECLARATIONS (E.G., ^^INTEGER, DIMENSION, COMMON\\, ETC.)
FOLLOWED BY A SEQUENCE OF EXECUTABLE STATEMENTS CALLED THE 
^&BODY\&
OF THE PROGRAM FOLLOWED BY THE <FLECS INTERNAL PROCEDURE DECLARATIONS,
IF ANY, AND FINALLY THE <END STATEMENT.
.P
^HERE IS A COMPLETE (BUT UNINTERESTING) <FLECS PROGRAM THAT
ILLUSTRATES THE PLACEMENT OF THE PROCEDURE DECLARATIONS.
.SKIP 2
.NOFILL
.TEST PAGE 33
00010  ^^C  INTERACTIVE PROGRAM FOR PDP-10 TO COMPUTE X**2.
00020  C  ZERO IS USED TO TERMINATE EXECUTION.
00030
00040		REAL X,XSQ
00050		REPEAT UNTIL (X.EQ.0)
00060		.  GET-A-VALUE-OF-X
00070		.  IF (X.NE.0)
00080		.  .  COMPUTE-RESULT
00090		.  .  TYPE-RESULT
00100		.  ...FIN
00110		...FIN
00120		CALL EXIT
.S 1
	----------------------------------------
.S 1
00130		TO GET-A-VALUE-OF-X
00140		.  TYPE 10
00150	10	.  FORMAT (' X = ',$)
00160		.  ACCEPT 20,X
00170	20	.  FORMAT(F)
00180		...FIN
.S 1
	----------------------------------------
.S 1
00190		TO COMPUTE-RESULT XSQ = X*X
.S 1
	----------------------------------------
.S 1
00200		TO TYPE-RESULT
00210		.  TYPE 30, XSQ
00220	30	.  FORMAT(' X-SQUARED = ',F7.2)
00230		...FIN
00240		END\\
.PAGE
.FILL
^NOTES CONCERNING INTERNAL PROCEDURES:
.LS
.LM +5
.LE;^ALL INTERNAL PROCEDURE DECLARATIONS MUST BE PLACED AT THE
END OF THE PROGRAM JUST PRIOR TO THE <END STATEMENT (.<END IN <ALECS).
^THE APPEARANCE OF THE FIRST "<TO" STATEMENT TERMINATES THE BODY
OF THE PROGRAM.
^THE TRANSLATOR EXPECTS TO SEE NOTHING BUT PROCEDURE
DECLARATIONS FROM THAT POINT ON.
.LE;^THE ORDER OF THE DECLARATIONS IS NOT IMPORTANT.
^ALPHABETICAL BY NAME IS AN EXCELLENT ORDER FOR PROGRAMS WITH A
LARGE NUMBER OF PROCEDURES.
.LE;^PROCEDURE DECLARATIONS MAY NOT BE NESTED.
^IN OTHER WORDS, THE SCOPE OF A PROCEDURE MAY NOT CONTAIN A PROCEDURE
DECLARATION.
^IT MAY, OF COURSE, CONTAIN EXECUTABLE PROCEDURE REFERENCES.
.LE;^ANY PROCEDURE MAY CONTAIN REFERENCES TO ANY OTHER PROCEDURES
EXCLUDING ITSELF.
.LE;^DYNAMIC RECURSION OF PROCEDURE REFERENCING IS NOT PERMITTED.
.LE;^ALL PROGRAM VARIABLES WITHIN A MAIN OR SUBPROGRAM ARE
GLOBAL AND ARE ACCESSIBLE TO THE STATEMENTS IN ALL PROCEDURES
DECLARED WITHIN THAT SAME MAIN PROGRAM OR SUBPROGRAM.
.LE;^THERE IS NO FORMAL MECHANISM FOR DEFINING OR PASSING
PARAMETERS TO AN INTERNAL PROCEDURE.
^WHEN PARAMETER PASSING IS NEEDED, THE <FORTRAN FUNCTION OR
SUBROUTINE SUBPROGRAM MECHANISM MAY BE USED, OR THE PROGRAMMER
MAY INVENT HIS OWN PARAMETER PASSING METHODS USING THE
GLOBAL NATURE OF VARIABLES OVER INTERNAL PROCEDURES.
.LE;^THE <FLECS TRANSLATOR SEPARATES PROCEDURE DECLARATIONS
ON THE LISTING BY DASHED LINES AS SHOWN IN THE PRECEDING EXAMPLE.
.ELS
.LM 5
.PAGE
.send toc.skip1
.HL 1 ^^RESTRICTIONS AND NOTES\\
.send toc.skip1
.INDEX RESTRICTIONS
.P
^IF <FLECS WERE IMPLEMENTED BY A NICE INTELLIGENT COMPILER, THIS
SECTION WOULD BE MUCH SHORTER.
^CURRENTLY, HOWEVER, <FLECS IS IMPLEMENTED BY A STURDY BUT NAIVE
TRANSLATOR.
^THUS, THE <FLECS PROGRAMMER MUST OBSERVE THE FOLLOWING RESTRICTIONS:
.LS
.LM +5
.LE;<FLECS MUST INVENT MANY STATEMENT NUMBERS IN CREATING THE
.INDEX STATEMENT NUMBER
<FORTRAN PROGRAM.
^IT DOES SO BY BEGINNING WITH A LARGE NUMBER (32760 AT <LAMPF) AND
GENERATING SUCCESSIVELY SMALLER NUMBERS AS IT NEEDS THEM.
^DO NOT USE A NUMBER THAT WILL BE GENERATED BY THE TRANSLATOR.
^A GOOD RULE OF THUMB IS TO ^&AVOID USING 5-DIGIT STATEMENT NUMBERS\&.
.LE;^THE <FLECS TRANSLATOR MUST GENERATE INTEGER VARIABLE NAMES.
.INDEX INTEGER VARIABLE
^IT DOES SO BY USING NAMES OF THE FORM "^INNNNN" WHERE NNNNN IS A
5-DIGIT NUMBER RELATED TO A GENERATED STATEMENT NUMBER.
^&^DO NOT USE VARIABLES OF THE FORM ^INNNNN AND AVOID CAUSING THEM
TO BE DECLARED OTHER THAN INTEGER.\&
^FOR EXAMPLE, THE DECLARATION "^^IMPLICIT#REAL#(A-Z)\\" LEADS TO
TROUBLE.  ^TRY "^^IMPLICT#REAL#(A-H,J-Z)"\\ INSTEAD.
.BB
(^NOTE THAT THE <".IMPLICIT <NONE" STATEMENT DESCRIBED IN ^SEC.#9.6 IS
COMPATIBLE WITH THIS RESTRICTION.)
.EB
.LE;^THE TRANSLATOR DOES NOT RECOGNIZE CONTINUATION LINES IN THE SOURCE
.INDEX CONTINUATION LINES
FILE.
^THUS, <FORTRAN STATEMENTS MAY BE CONTINUED, SINCE THE STATEMENT AND ITS
CONTINUATIONS WILL BE PASSED THROUGH THE TRANSLATOR WITHOUT
ALTERATION
(SEE ^SEC.#1.1).
^HOWEVER, ^&DO NOT CONTINUE AN EXTENDED <FLECS STATEMENT WHICH REQUIRES
TRANSLATION\&.
^THE REASONS ONE MIGHT WISH TO CONTINUE A <FLECS STATEMENT ARE: (1) IT
IS A STRUCTURED STATEMENT OR PROCEDURE DECLARATION WITH A ONE-STATEMENT
SCOPE TOO LONG TO FIT ON A LINE, OR (2) IT CONTAINS AN
EXCESSIVELY LONG SPECIFICATION PORTION, OR (3) BOTH THE ABOVE.
^PROBLEM (1) CAN BE AVOIDED BY GOING TO THE MULTILINE FORM.
^FREQUENTLY, PROBLEM (2) CAN BE AVOIDED WHEN THE SPECIFICATION
IS AN EXPRESSION (LOGICAL OR OTHERWISE) BY ASSIGNING THE EXPRESSION TO
A VARIABLE IN A PRECEDING STATEMENT AND THEN USING THE VARIABLE AS THE
SPECIFICATION.
.LE;^&^BLANKS ARE MEANINGFUL SEPARATORS IN <FLECS STATEMENTS;
DON'T PUT THEN IN DUMB PLACES\&
.INDEX BLANKS
LIKE THE MIDDLE OF IDENTIFIERS OR KEY
WORDS, AND ^&DO\& USE THEM TO SEPARATE DISTINCT WORDS LIKE
<REPEAT AND <UNTIL.
.LE;^LET <FLECS INDENT THE LISTING.  ^IF YOU START ALL STATEMENTS IN COLUMN 7,
.INDEX INDENTATION
THE LISTING WILL ALWAYS REVEAL THE TRUE STRUCTURE OF THE PROGRAM
(AS UNDERSTOOD BY THE TRANSLATOR, OF COURSE).
.LE;^AS FAR AS THE TRANSLATOR IS CONCERNED, <FORMAT STATEMENTS ARE
EXECUTABLE <FORTRAN STATEMENTS, SINCE IT DOESN'T RECOGNIZE THEM AS
EXTENDED <FLECS STATEMENTS.
^THUS, ^&PLACE FORMAT STATEMENTS ONLY WHERE AN EXECUTABLE <FORTRAN
STATEMENT WOULD BE ACCEPTABLE\&.
^DON'T PUT THEM BETWEEN THE END OF A <WHEN STATEMENT AND THE
BEGINNING OF AN <ELSE STATEMENT.
^DON'T PUT THEM BETWEEN PROCEDURE DECLARATIONS.
.TP 14
.S 1
.NOFILL
^INCORRECT ^USAGE:########^CORRECTED ^USAGE:
.S 1
####^^WHEN (FLAG) WRITE(3,30)######WHEN (FLAG)
30##FORMAT(7H TITLE:)############.  WRITE(3,30)
####ELSE LINE = LINE+1######30###.  FORMAT(7H TITLE:)
#################################...FIN
#################################ELSE LINE = LINE+1
.S 1
####TO WRITE-HEADER##############TO WRITE-HEADER
####.  PAGE = PAGE+1#############.  PAGE = PAGE+1
####.  WRITE(3,40)H, PAGE########.  WRITE(3,40)H,PAGE
####...FIN###################40##.  FORMAT(70A1,I3)
40##FORMAT(70A1,I3)##############...FIN\\
.FILL
.LE;^THE TRANSLATOR, BEING SIMPLE MINDED, RECOGNIZES EXTENDED <FLECS
STATEMENTS BY THE PROCESS OF SCANNING THE FIRST IDENTIFIER ON THE LINE.
^IF THE IDENTIFIER IS ONE OF THE <FLECS KEYWORDS ^^IF, WHEN, UNLESS,
FIN\\, ETC., THE LINE IS ASSUMED TO BE A <FLECS STATEMENT AND IS TREATED
AS SUCH.
^THUS, ^&THE <FLECS KEYWORDS ARE RESERVED; DO NOT USE THEM AS VARIABLE NAMES\&.
.INDEX KEYWORDS
^IN CASE OF NECESSITY, A VARIABLE NAME--SAY, ^^WHEN\\--MAY BE SLIPPED
PAST THE TRANSLATOR BY EMBEDDING A BLANK WITHIN IT.
^THUS, "<WH#<EN" WILL LOOK LIKE "<WH" FOLLOWED BY <"EN" TO THE
TRANSLATOR WHICH IS BLANK SENSITIVE BUT LIKE "<WHEN" TO THE COMPILER
WHICH IGNORES BLANKS.
.LE;^IN SCANNING A PARENTHESIZED SPECIFICATION, THE TRANSLATOR
.INDEX PARENTHESES
SCANS FROM LEFT TO RIGHT TO FIND THE PARENTHESIS THAT MATCHES THE
INITIAL LEFT PARENTHESIS OF THE SPECIFICATION.
^THE TRANSLATOR, HOWEVER, IS IGNORANT OF <FORTRAN SYNTAX INCLUDING
THE CONCEPT OF ^HOLLERITH CONSTANTS AND WILL TREAT ^HOLLERITH
.INDEX ^HOLLERITH
PARENTHESES AS SYNTACTIC PARENTHESES.
^THUS, ^&AVOID ^HOLLERITH CONSTANTS CONTAINING UNBALANCED PARENTHESES WITHIN SPECIFICATIONS\&.
^IF NECESSARY, ASSIGN SUCH CONSTANTS TO A VARIABLE BY USING <DATA
OR ASSIGNMENT STATEMENTS, AND PLACE THE VARIABLE IN THE SPECIFICATION.
.S 1
.NOFILL
^INCORRECT ^USAGE:##########^CORRECTED ^USAGE:
.S 1
^^IF (J.EQ.'(')###############LP = '('
############################IF (J.EQ.LP)\\
.FILL
.LE;^THE <FLECS TRANSLATOR WILL NOT SUPPLY THE STATEMENTS
NECESSARY TO CAUSE APPROPRIATE TERMINATION OF MAIN PROGRAMS 
AND SUBPROGRAMS.
^THUS, ^&ALWAYS INCLUDE THE APPROPRIATE ^^RETURN, STOP\\,
OR ^^CALL EXIT\\ STATEMENT PRIOR TO THE FIRST INTERNAL PROCEDURE
DECLARATION\&.
^FAILURE TO DO SO WILL RESULT IN CONTROL ENTERING THE SCOPE
OF THE FIRST PROCEDURE AFTER LEAVING THE BODY OF THE PROGRAM.
^DO NOT PLACE SUCH STATEMENTS BETWEEN THE PROCEDURE DECLARATIONS
AND THE <END STATEMENT.
.ELS
.PAGE
.send toc.skip1
.LM 5
.HL 1 ^^ERRORS\\
.send toc.skip1
.P
^THIS SECTION PROVIDES A FRAMEWORK FOR UNDERSTANDING THE ERROR-HANDLING
.INDEX ERRORS
MECHANISMS OF VERSION 22 OF THE <FLECS ^TRANSLATOR.
^THE SYSTEM DESCRIBED BELOW IS AT AN EARLY POINT IN EVOLUTION, BUT
IT HAS PROVED TO BE QUITE WORKABLE.
.P
^THE <FLECS TRANSLATOR EXAMINES A <FLECS PROGRAM  LINE BY LINE.
^AS EACH LINE IS ENCOUNTERED, THE TRANSLATOR FIRST SUBJECTS IT TO A
LIMITED ^&SYNTAX\& ANALYSIS  AND THEN A
^&CONTEXT\& ANALYSIS.
^ERRORS MAY BE DETECTED DURING EITHER OF THESE ANALYSES.
^IT IS ALSO POSSIBLE FOR ERRORS TO GO
^&UNDETECTED\& BY THE
TRANSLATOR.
.HL 2 ^&^S\\YNTAX ^ERRORS\&
.P
.INDEX SYNTAX ERRORS
^WHEN THE TRANSLATOR DETECTS A SYNTAX ERROR,
IT ^&IGNORES\& THE ^&STATEMENT\&.
^ON THE <FLECS LISTING, THE LINE NUMBER OF THE STATEMENT IS PRECEDED
BY AN "<E" TO INDICATE THAT THE STATEMENT HAS BEEN IGNORED.
^THE NATURE OF THE SYNTAX ERROR IS GIVEN IN A MESSAGE ON THE
FOLLOWING LINE.
.P
^THE FACT THAT A STATEMENT HAS BEEN IGNORED MAY, OF COURSE, CAUSE
SOME CONTEXT ERRORS IN LATER STATEMENTS.
^FOR EXAMPLE, THE CONTROL PHRASE "^^WHEN#(X(I).LT.(3+4)\\" HAS
A MISSING RIGHT PARENTHESIS.
^THIS STATEMENT WILL BE IGNORED, CAUSING, AS A MINIMUM, THE FOLLOWING
<ELSE TO BE OUT OF CONTEXT.  ^THE PROGRAMMER SHOULD, OF COURSE,
BE AWARE OF SUCH EFFECTS.
^MORE WILL BE SAID ABOUT THESE EFFECTS BELOW.
.HL 2 ^&^C\\ONTEXT ^ERRORS\&
.INDEX CONTEXT ERRORS
.P
^IF A STATEMENT SUCCESSFULLY PASSES THE SYNTAX ANALYSIS, IT IS CHECKED
TO SEE IF IT IS IN THE APPROPRIATE CONTEXT WITHIN THE PROGRAM.
^FOR EXAMPLE, AN <ELSE MUST APPEAR AFTER A <WHEN AND NOWHERE
ELSE.
^IF AN <ELSE DOES NOT APPEAR AT THE APPROPRIATE POINT
OR IF IT APPEARS AT SOME OTHER POINT, THEN A CONTEXT ERROR
HAS OCCURRED.
^A FREQUENT SOURCE OF CONTEXT ERRORS IN THE INITIAL STAGES OF DEVELOPMENT
OF A PROGRAM COMES FROM MISCOUNTING THE NUMBER OF ^^FIN\\S NEEDED
AT SOME POINT IN THE PROGRAM.
.P
^WITH THE EXCEPTION OF EXCESS ^^FIN\\S THAT DO NOT MATCH ANY
PRECEDING CONTROL PHRASE AND ARE IGNORED,
ALL CONTEXT ERRORS ARE TREATED WITH A UNIFORM
STRATEGY.
^WHEN AN OUT-OF-CONTEXT SOURCE STATEMENT IS
ENCOUNTERED, THE TRANSLATOR GENERATES A "^^STATEMENT(S)#NEEDED"\\
MESSAGE.
^IT THEN INVENTS AND PROCESSES A SEQUENCE OF STATEMENTS THAT, HAD IT
BEEN INCLUDED AT THAT POINT IN THE PROGRAM, WOULD HAVE PLACED THE
ORIGINAL SOURCE STATEMENT IN A CORRECT CONTEXT.
^A MESSAGE IS GIVEN FOR EACH SUCH STATEMENT INVENTED. ^THE
ORIGINAL SOURCE STATEMENT IS THEN PROCESSED IN THE NEWLY CREATED
CONTEXT.
.P
^BY INVENTING STATEMENTS, THE TRANSLATOR IS NOT TRYING TO PATCH UP
THE PROGRAM SO THAT IT WILL RUN CORRECTLY; IT IS SIMPLY TRYING
TO ADJUST THE LOCAL CONTEXT SO THAT THE ORIGINAL SOURCE
STATEMENT AND THE STATEMENTS THAT FOLLOW WILL BE ACCEPTABLE ON
A CONTEXT BASIS.
^AS IN THE CASE OF CONTEXT ERRORS GENERATED BY IGNORING A SYNTACTICALLY
INCORRECT STATEMENT, SUCH AN ADJUSTMENT OF CONTEXT FREQUENTLY
CAUSES FURTHER CONTEXT ERRORS LATER ON.
^THIS IS CALLED ^&PROPAGATION OF CONTEXT ERRORS\&.
.P
^ONE NICE FEATURE OF THE CONTEXT ADJUSTMENT STRATEGY IS THAT CONTEXT
ERRORS CANNOT PROPAGATE PAST A RECOGNIZABLE PROCEDURE DECLARATION.
^THIS IS BECAUSE THE "<TO" DECLARATION IS IN CONTEXT ONLY
AT INDENTATION LEVEL 0.
^THUS, TO PLACE THE "<TO" IN CONTEXT, THE TRANSLATOR MUST INVENT
ENOUGH STATEMENTS TO TEMINATE ALL OPEN CONTROL STRUCTURES
WHICH PRECEDE THE "<TO."##^THE
PROGRAMMER WHO MODULARIZES HIS PROGRAM INTO A COLLECTION
OF RELATIVELY SHORT INTERNAL PROCEDURES LIMITS THE POTENTIAL
FOR PROPAGATION OF CONTEXT ERRORS.
.HL 2 ^&^U\\NDETECTED ^ERRORS\&
.P
^THE <FLECS TRANSLATOR IS IGNORANT OF MOST DETAILS OF
.INDEX UNDETECTED ERRORS
<FORTRAN SYNTAX.
^THUS, MOST <FORTRAN SYNTAX ERRORS WILL BE DETECTED BY THE
<FORTRAN COMPILER RATHER THAN BY THE <FLECS TRANSLATOR.
^FOR <ALECS, <MACRO SYNTAX ERRORS WILL BE DETECTED BY THE ASSEMBLER.
^IN ADDITION, THERE ARE TWO MAJOR CLASSES OF <FLECS ERRORS
THAT WILL BE CAUGHT BY THE COMPILER AND NOT BY THE TRANSLATOR.
.P
^THE FIRST CLASS OF UNDETECTED ERRORS INVOLVES MISSPELLED <FLECS
KEYWORDS.
.INDEX KEYWORDS
^A MISSPELLED KEYWORD WILL NOT BE RECOGNIZED BY THE TRANSLATOR.
^IT WILL ASSUME THE LINE ON WHICH THE WORD OCCURS TO BE A <FORTRAN
STATEMENT AND WILL PASS THE LINE UNALTERED TO THE COMPILER, WHICH WILL
NO DOUBT OBJECT TO IT.
^FOR EXAMPLE, A COMMON ERROR IS SPELLING <UNTIL WITH TWO ^LS.
^SUCH STATEMENTS ARE PASSED TO THE COMPILER, WHICH THEN PRODUCES
AN ERROR MESSAGE.
^THE FACT THAT AN INTENDED CONTROL PHRASE WAS NOT RECOGNIZED
FREQUENTLY CAUSES A LATER CONTEXT ERROR, SINCE A LEVEL OF INDENTATION
WILL NOT BE TRIGGERED.
.P
^THE SECOND CLASS OF UNDETECTED ERRORS INVOLVES UNBALANCED PARENTHESES
.INDEX PARENTHESES
(SEE ALSO ^NOTE 8 IN ^SEC.#6).
^WHEN SCANNING A PARENTHESIZED SPECIFICATION, THE TRANSLATOR LOOKS
FOR A CLOSE PARENTHESIS TO MATCH THE INITIAL OPEN PARENTHESIS THAT
BEGINS THE SPECIFICATION. ^AS SOON AS IT FINDS ONE, IT ASSUMES THAT
THE REMAINDER OF THE LINE IS A SIMPLE <FORTRAN STATEMENT, WHICH IT
PASSES TO THE COMPILER.  ^OF COURSE, THIS ASSUMPTION MAY BE
WRONG.  ^THUS, THE STATEMENT
.TP 9
.S 1
.NOFILL
	^^WHEN (X.LT.A(I)+Z)) X = 0\\
.FILL
.S 1
IS BROKEN INTO
.S 1
.NOFILL
##########KEYWORD###############^^"WHEN"\\
##########SPECIFICATION#########^^"(X.LT.A(I)+Z)\\"
##########<FORTRAN STATEMENT#####^^") X = 0" \\
.S 1
.FILL
^NEEDLESS TO SAY, THE COMPILER WILL OBJECT TO ")#^X#=#0" AS A
STATEMENT.
.P
^PROGRAMMERS ON BATCH-ORIENTED SYSTEMS HAVE LESS DIFFICULTY WITH
UNDETECTED ERRORS DUE TO THE PRACTICE OF RUNNING THE PROGRAM
THROUGH BOTH THE TRANSLATOR AND THE COMPILER EACH TIME A RUN IS
SUBMITTED. ^THE COMPILER ERRORS USUALLY POINT OUT ANY ERRORS 
UNDETECTED BY THE TRANSLATOR.
.P
^PROGRAMMERS ON INTERACTIVE SYSTEMS TEND TO HAVE A BIT MORE
DIFFICULTY, SINCE AN UNDETECTED ERROR IN ONE LINE MAY TRIGGER
A CONTEXT ERROR IN A MUCH LATER LINE.
^NOTICING THE CONTEXT ERROR, THE PROGRAMMER DOES NOT PROCEED
WITH COMPILATION AND HENCE IS NOT WARNED BY THE COMPILER OF THE
GENUINE CAUSE OF THE ERROR.
^ONE INDICATION OF THE TRUE SOURCE OF THE ERROR MAY BE AN
INDENTATION FAILURE AT THE CORRESPONDING POINT IN THE LISTING.
.HL 2 ^&O\\THER ^ERRORS\&
.P
^IF <FLECS OR <ALECS READS AN INPUT LINE LONGER THAN 80 CHARACTERS,
THE WARNING MESAGE
.SKIP 1
#####(^^READ ERROR ON INPUT LINE)\\
.SKIP 1
IS PRODUCED AND THE INPUT IS TRUNCATED TO 80 CHARACTERS.  ^IF THE <FLECS
TRANSLATION PRODUCES A <FORTRAN OUTPUT LINE CONTAINING MORE THAN 72 CHARACTERS,
THE WARNING MESSAGE
.SKIP 1
#####*****^^WARN-INPUT FORCED OUTPUT CONTINUATION LINE\\
.SKIP 1
IS PRODUCED.  ^IN THE FORMER CASE INPUT INFORMATION IS LOST AND IN THE
LATTER CASE <FLECS OCCASIONALLY PRODUCES AN INCORRECT <FORTRAN CONTINUATION
LINE.  ^THUS IF YOU GET ONE OF THESE MESSAGES, IT IS BEST TO SHORTEN THE
INPUT LINE.
.P
^THE TRANSLATOR DETECTS A VARIETY OF OTHER ERRORS, SUCH AS MULTIPLE
DEFINED OR UNDEFINED PROCEDURE REFERENCES. ^THE ERROR MESSAGES
ARE SELF-EXPLANATORY. (^REALLY AND TRULY!)
.PAGE
.send toc.skip1
.HL 1 ^^ALECS - FLECS FOR ASSEMBLY LANGUAGE ROUTINES\\
.send toc.skip1
.INDEX <ALECS
.P
^IF YOU DO NOT WISH TO USE THE <FLECS STRUCTURED STATEMENTS IN ASSEMBLY
LANGUAGE PROGRAMS, YOU MAY SKIP THIS SECTION.
<ALECS HAS NO EFFECT ON THE USE OF <FLECS FOR <FORTRAN ROUTINES.
.P
^THE <FLECS STRUCTURED STATEMENTS AND LISTING FILES ARE
SUFFICIENTLY USEFUL THAT THEY HAVE BEEN IMPLEMENTED FOR <PDP <MACRO-11
AND <VAX-11 <MACRO ASSEMBLY LANGUAGE.
^THE PREPROCESSOR IS NAMED <ALECS (&^ASSEMBLY &^LANGUAGE &^EXTENSIONS AND
&^CONTROL &^STRUCTURES).
<ALECS PROVIDES THE <FLECS CONTROL STRUCTURES FOR USE IN ASSEMBLY LANGUAGE
ALONG WITH A NUMBER OF SPECIAL OPERATORS TO MAKE THEM EASY TO USE.
.HL 2 ^&<ALECS\\ ^OPERATORS\&
.INDEX <ALECS OPERATORS
.P
^THE CONTROL STRUCTURES REQUIRE A SPECIFICATION (SEE ^SEC.#2.0) WITH A
LOGICAL VALUE OF TRUE OR FALSE.
<FORTRAN (AND THUS <FLECS) PROVIDES A NUMBER OF OPERATORS TO MAKE
PRODUCTION OF A LOGICAL VALUE SIMPLE WHEN GIVEN NONLOGICAL VARIABLES
TO BE COMPARED. ^FOR EXAMPLE, IN
.S 1
	<IF(I.GT.J)
.S 1
THE OPERATOR "<.GT." PRODUCES "TRUE" IF ^I HAS A GREATER SIGNED VALUE THAN ^J
AND PRODUCES "FALSE" OTHERWISE.
.P
^IN ORDER TO MAKE THE <ALECS SPECIFICATIONS EASY TO USE, A SET OF OPERATORS
SIMILAR TO THE <FORTRAN OPERATORS HAVE BEEN IMPLEMENTED IN <ALECS.
^NOTE THAT <ALECS CONVERTS THESE OPERATORS TO PROPER ASSEMBLY
LANGUAGE INSTRUCTIONS AND PUTS THEM INTO THE ASSEMBLY LANGUAGE OUTPUT
FILE ALONG WITH OTHER CODE.
^AS A SHORTHAND NOTATION, WE USE "^L" AS ANY GENERAL EXPRESSION HAVING A VALUE OF TRUE OR FALSE.
^FOR THE PURPOSES OF <ALECS, 
.INDEX FALSE
.INDEX TRUE
.SKIP 1
FALSE IS DEFINED AS 0;
.BR
ANY OTHER VALUE IS TRUE.
.SKIP 1
^THE LIST BELOW GIVES THE ALLOWED FORMS FOR ^L.
^ANY OTHER FORMS WILL PRODUCE ^^ALECS\\ ERRORS.
^ALSO NOTE THAT IN THE CURRENT CONTEXT, "LEGAL EXPRESSION" MEANS ANY
EXPRESSION LEGAL IN A <PDP-11 <MACRO-11 <CMP OR <TST INSTRUCTION
OR A <VAX-11 <MACRO ^^CMP\\X OR ^^TST\\X INSTRUCTION.  ^NOTE
ITEMS IN CURLY BRACKETS {} ARE VALID ONLY FOR <VAX-11 <MACRO.
.INDEX {}
.INDEX CURLY BRACKETS
.LS
.LM +5
.TS 23,47
.LE;^L MAY BE ANY LEGAL 16-BIT-WORD EXPRESSION. ^IF BYTE {OR LONGWORD}
ARE USED, THE GENERATED CODE STILL ASSUMES 16-BIT-WORDS, PERHAPS GIVING
EXECUTION-TIME ERRORS.
^THE EXPRESSIONS ARE INTERPRETED AS FALSE IF EQUAL ZERO AND 
TRUE OTHERWISE, E.G.,
.S 1
.NF
	^^IF( V.L(R0) ) CLR R0
	WHEN ( D!F )\\
.FILL
.LE;^L MAY BE A SIMPLE "ARITHMETIC" COMPARISON OF THE FORM ^A:AOP:^B WHERE
^A AND ^B ARE ANY LEGAL SIGNED-WORD EXPRESSIONS AND :AOP: IS ONE OF
:<EQ:, <:NE:, <:LT:, <:GT:, <:LE:, OR <:GE:, E.G.,
.S 1
	^^UNLESS( (R0)+ :EQ: (R1)+ ) CLR (R0)\\
.S 1
^WARNING:  SPACES ARE ILLEGAL BETWEEN PAIRED COLONS!
.LE;^THE OPERATORS IN ITEM 2 MAY BE FORCED TO OTHER THAN SIGNED-WORD BY
APPENDING THE FOLLOWING STRINGS:
.NF
.S 1
__^W -- EVALUATE AS 16-BIT-WORD EXPRESSION <(DEFAULT)
__^B -- EVALUATE AS BYTE EXPRESSION
__^L -- EVALUATE AS 32-BIT-LONGWORD EXPRESSION {<VAX ONLY}
.S 1
__^S -- EVALUATE AS SIGNED EXPRESSION <(DEFAULT)
__^U -- EVALUATE AS UNSIGNED EXPRESSION
.FILL
.S 1
^ONLY ONE OF __^W, {__^L}, OR __^B MAY APPEAR IN ANY ^L.
^ONLY ONE OF __^S AND __^U MAY APPEAR IN ANY ^L.
^HOWEVER, ONE EACH FROM THE TWO GROUPS MAY APPEAR IN AN
^L TOGETHER IN ANY ORDER BUT WITH ONLY ONE UNDERSCORE, E.G.,
.NOFILL
.S 1
	^^IF( A :LE__U: R0)\\	--WORD, UNSIGNED
	^^IF( A :LE__SB: R0 )\\	--BYTE, SIGNED
	^^IF( A :LE__WU: R0 )\\	--WORD, UNSIGNED
.S 1
.FILL
^NOTE THAT __^S AND __^U ARE LEGAL FOR :<EQ: AND <:NE: BUT HAVE NO EFFECT.
.LE;^L MAY BE A CONDITION CODE X=^C, ^V, ^N OR ^Z EXPRESSED AS
.S 1
.NOFILL
	:X.<SET: -->  TRUE IF X BIT SET
	:X.<CLR: -->  TRUE IF X BIT IS CLEAR
.S 1
.FILL
^FOR EXAMPLE,
.S 1
	^^IF(:C.SET:) HALT\\
.LE;^L IS A BITWISE COMPARISON OF TWO EXPRESSIONS IN THE FORMAT
.S 1
.NOFILL
	^^A:SET.IN:B\\ -->  TRUE IF "<BIT <A,B" IS NONZERO
	^^A:CLR.IN:B\\ -->  TRUE IF <"BIT <A,B" IS ZERO
.S 1
.FILL
^NOTE BYTE {OR LONGWORD} MAY BE CHOSEN BY, E.G., :<SET.IN__B:.
^THE __^S AND __^U ARE ALLOWED BUT HAVE NO EFFECT.
.LE;^L MAY BE A SIMPLE "LOGICAL" COMPARISON OF THE FORM ^A:LOP:^B
WHERE ^A AND ^B ARE ANY LEGAL WORD EXPRESSIONS AND :LOP: IS EITHER
:<AND: OR :<IOR:.
^A AND ^B ARE INTERPRETED AS FALSE IF EQUAL TO ZERO AND TRUE OTHERWISE, E.G.,
.S 1
	^^WHILE( A(R3):AND:TIP)\\
.S 1
^NOTE ALL OF THE MODIFIERS IN ITEM 3 ARE ILLEGAL FOR LOP.
.FILL
.LE;^L IS A COMPOUND LOGICAL EXPRESSION OF THE FORM ^LSL:LOP:^LS2 WHERE
^LS IS ANY OF THE ABOVE EXCEPT 6, E.G.,
.S 1
.NF
	^^A:AND:B :IOR: R0\\	#IS ILLEGAL SINCE ^LSL
		#IS A "LOGICAL" 
		#COMPARISON.
	^^:C.SET: :IOR: A:GT__B:B\\	#IS LEGAL.
	^^A:NE__B:B :AND: F:GT__BU:G\\	IS LEGAL.
.S 1
.FILL
^NOTE ALL OF THE MODIFIERS IN ITEM 3 ARE ILLEGAL FOR LOP.
^NOTE PARENTHESES FOR GROUPING ARE ILLEGAL; EVALUATION IS STRICTLY LEFT TO RIGHT.
^SEE ^SEC.#8.3 FOR SOME FORMS THAT ARE ILLEGAL.
.ELS
.LM 5
.HL 2 ^&^^ALECS\\ ^C\\ONTROL ^STRUCTURES\&
.INDEX ^^ALECS\\ CONTROL STRUCTURES
.P
^ALL OF THE CONTROL STRUCTURES LISTED IN ^SEC.#4 OF <FLECS ARE
SUPPORTED IN <ALECS EXCEPT <DO. (^IT IS NOT YET CLEAR IF <DO IS USEFUL IN
ASSEMBLY LANGUAGE OR HOW IT SHOULD BE IMPLEMENTED. ^FOR EXAMPLE, SHOULD
IT BE AN <SOB LOOP?)##^AS IN <FLECS, ASSEMBLY LANGUAGE CODE IN THE
INPUT FILE IS PASSED TO THE OUTPUT FILE.
^ONLY <ALECS CONTROL STRUCTURES ARE PROCESSED.
^REFER TO AN OUTPUT ASSEMBLY LANGUAGE FILE
TO FIND OUT WHAT THE ACTUAL CODE EXPANSIONS FOR EACH CONSTRUCT ARE
(BUT NOTE THE EXPANSIONS MAY CHANGE WITH FUTURE RELEASES OF <ALECS).
^SOME EXAMPLES OF POSSIBLE <ALECS CODE ARE LISTED BELOW:
.S 1
.NF
.TS 15,44
	^^DIR$     _#VREC	; GET A MESSAGE
	WHILE (:C.CLR:)
	.  SELECT (FCT)	; FCT=FUNCTION CODE
	.  .  (_#1) SHOW-PLOT
	.  .  (_#2) ABORT-PLOT
	.  .  (OTHERWISE) MOV _#1,ERR	; ILLEGAL CODE
	.  ...FIN
	.  SDRQ$S _#RSBUF,,,,,_#ERR	; RETURN STATUS
	.  DIR$ _#VREC	; GET NEXT MESSAGE
	...FIN
.S 1
	WHEN (PLTDFN :GE__BU: _#4) MOV _#5,ERR
	ELSE START-PLOT
.S 1
	MOV _#MSG,R1	; ADDR OF BUFFER
	MOV _#LEN,R2	; LENGTH
	MOV _#SAVE,R0	; ADDR OF STORAGE
	UNTIL (R2 :LE: _#0)
	.  MOV (R1)+,(R0)+
	.  DEC R2
	...FIN
.S 1
	IF (TTN :NE__B: PTT(R3))	; NEW TT?
	.  MOVB PPT(R3),TTN	; YES, SAVE _#
	.  MOVB TTN,R0	; SET UP ALUN$
	.  ALUN$S _#LUN,_#"TT,R0	; ASSIGN LUN
	...FIN\\
.FILL
.PAGE
.HL 2 ^&<ALECS ^R\\ESTRICTIONS AND ^NOTES\&
.P
^THE FOLLOWING RESTRICTIONS AND NOTES APPLY TO THE CURRENT
.INDEX RESTRICTIONS
VERSION OF <ALECS:
.LS
.LM +5
.LE;^RESTRICTIONS 4, 5, 7, AND 8 IN ^SEC.#6.0 ALSO APPLY TO <ALECS.
.LE;<ALECS MUST GENERATE A NUMBER OF LABELS. ^IT DOES SO
BY USING SYMBOLS OF THE FORM "^INNNNN:" WHERE NNNNN IS A 5-DIGIT
NUMBER. ^DO NOT USE SUCH LABELS!
.LE;^DO NOT PUT BLANKS INSIDE PAIRED COLONS FOR <ALECS
OPERATORS, AS THIS WILL CAUSE FATAL TRANSLATION ERRORS. ^FOR EXAMPLE,
"^^IF(A:LE#__U:B)\\" IS ILLEGAL, BUT "^^IF(A#:LE__U:#B)\\" IS LEGAL.
.LE;^IN SCANNING SPECIFICATIONS, <ALECS ASSUMES
ANY COLON IS A DELIMITER FOR AN <ALECS OPERATOR. ^THUS,
LITERAL COLONS MUST NOT BE PUT IN <ALECS SPECIFICAIONS.
.S 1
.NF
.TS 23,47
	^INCORRECT ^USAGE:	^CORRECTED ^USAGE:
.S 1
	^^IF(ICHAR:EQ__B:_#':)	COLON=72
		IF(ICHAR:EQ__B:_#COLON)\\
.FILL
.LE;^THE CODE GENERATED BY <ALECS USES BRANCH INSTRUCTIONS
RATHER THAN JUMPS. ^THUS, ASSEMBLY-TIME ERRORS MAY
RESULT FOR LONG SCOPES. ^TO AVOID SUCH PROBLEMS, USE PROCEDURE INVOCATIONS.
^FOR EXAMPLE:
.S 1
.NF
	^^CONDITIONAL
	.  (R0:GT:R1) PROCESS-NORMAL-CASE
	.  (R0:EQ:R1) PROCESS-NULL-CASE
	.  (OTHERWISE) REPORT-ERROR
	...FIN\\
.FILL
.LE;^THE CODE GENERATED BY <ALECS CREATES A LABEL ON ALL <ALECS LINES.
^THUS, LOCAL SYMBOL BLOCKS WILL BE TERMINATED BY <ALECS LINES (UNLESS THE USER
HAS DISABLED LOCAL SYMBOL BLOCKS).
.LE;^LABELS ON <ALECS STATEMENTS WILL CAUSE THE <ALECS PROCESSOR
TO ASSUME THE STATEMENT IS PURE ASSEMBLY LANGUAGE, CAUSING MANY
ASSEMBLY-TIME ERRORS. ^THUS, IF A LABEL IS NECESSARY, PUT IT ON THE LINE
BEFORE THE <ALECS STATEMENT. ^FOR EXAMPLE:
.S 1
.NF
	^^START:
	######WHEN ((R5):LT:_#3)\\
.FILL
.TP 2
.LE;^THE <SELECT STATEMENT ASSUMES ITS ARGUMENTS ARE 16-BIT-WORD
EXPRESSIONS, AND THERE IS NO WAY TO FORCE OTHER TYPES. ^IF
BYTE {OR LONGWORD} ARGUMENTS ARE USED, NEITHER <ALECS NOR
THE ASSEMBLER WILL DETECT AN ERROR; THE CODE WILL SIMPLY EXECUTE WRONG.
^IF TYPES OTHER THAN 16-BIT-WORD ARE NEEDED, USE A <CONDITIONAL
INSTEAD OF A <SELECT.
.LE;^FOR THE LOGICAL OPERATORS :<AND: AND :<IOR:, THE
SECOND CLAUSE MAY OR MAY NOT BE EVALUATED AT EXECUTION TIME DEPENDING
ON THE VALUE OF THE FIRST CLAUSE. ^FOR EXAMPLE, IN:
.S 1
	^^WHEN (I:GT:J#:AND:#I:LT:R0)\\
.S 1
^I WILL NOT BE COMPARED TO ^R0 IF ^I IS LESS THAN OR EQUAL TO ^J.
^THUS, CODE MUST NOT BE WRITTEN THAT DEPENDS ON BOTH CLAUSES BEING EXECUTED.
^THIS HAS ESPECIALLY SERIOUS IMPACT IF THE SECOND CLAUSE
USES AUTOINCREMENT OR DECREMENT MODE OR IF THE FIRST LINE OF THE
SCOPE EXPECTS TO USE CONDITION CODES SET BY THE SECOND CLAUSE.
.LE;^CONDITION CODES TESTED AS THE SECOND CLAUSE OF A LOGICAL
ARE THOSE SET BY THE FIRST CLAUSE! ^FOR EXAMPLE, IN:
.S 1
	^^IF(#R0:GT:R1#:IOR:#:Z.SET:#)\\
.S 1
<:Z.SET: WILL BE TRUE IF AND ONLY IF <R0=R1! ^USE OF SUCH A CONSTRUCT
WILL RESULT IN A FATAL TRANSLATION ERROR.  ^NOTE, HOWEVER,
.S 1
	^^IF(#:Z.SET:#:IOR:#R0:GT:R1#)\\
.S 1
IS LEGAL.
.LE;^A STATEMENT OF THE FORM
.S 1
	^^IF(#B#:AND:#A:GT:C#)\\
.S 1
IS AMBIGUOUS.
^DOES IT MEAN (<B:AND:A):GT:C OR <B:AND:(A:GT:C)?
^SINCE <ALECS CANNOT DETERMINE THE CORRECT GROUPING, THIS
TYPE OF STATEMENT IS DECLARED TO BE A FATAL TRANSLATION ERROR.
^NOTE THAT
.S 1
	^^(#A:GT:C#:AND:#B)\\
.S 1
IS ALSO ILLEGAL.
.LE;^IN GENERAL, AUTOINCREMENT AND AUTODECREMENT MODES SHOULD BE AVOIDED
INSIDE <ALECS SPECIFICATIONS (SEE ITEM 9). ^EXACTLY WHEN AND WHERE THE INCREMENT/DECREMENT OCCURS 
DEPENDS SENSITIVELY ON EXACTLY HOW <ALECS EXPANDS THE SPECIFICATION INTO
ASSEMBLY LANGUAGE CODE. ^SINCE FUTURE  RELEASES MAY MODIFY THE CODE EXPANSION,
THESE MODES ARE UNSAFE FOR USE.
.page
.LE;^BLANKS MAY BE USED OUTSIDE OF <ALECS OPERATORS TO MAKE
THE LISTINGS AND SOURCES MORE READABLE. ^FOR EXAMPLE:
.S 1
	^^WHEN(:C.SET::AND:(R0):GT:2(R3))\\
.S 1
MAY BE IMPROVED GREATLY WITH SPACES:
.S 1
	^^WHEN( :C.SET: :AND: (R0):GT:2(R3) )\\
.LE;^PROCEDURE CALLS ARE IMPLEMENTED VIA A <JSR {<JSB} INSTRUCTION.  ^THUS,
ON ENTRY TO A PROCEDURE, THERE WILL BE ONE {OR MORE} EXTRA WORD ON THE STACK.
^ON EXIT FROM THE PROCEDURE, THE INFORMATION IS REMOVED FROM THE STACK BY AN
<RTS {<RSB}.
.LE;^NEVER <JMP OR <BR OUT OF A PROCEDURE, SINCE THE EXTRA WORD
PUT ON THE STACK (SEE ^ITEM 14) WILL NOT BE REMOVED.
.BB
.LE;^THE ^^.IMPLICIT NONE\\ DIRECTIVE IS NOT IMPLEMENTED IN <ALECS.  ^USING
IT IN <ALECS WILL GIVE AN ASSEMBLER ERROR.
.EB
.ELS
.LM 5
.PAGE
.send toc.skip1
.HL 1 ^^FLECS DIRECTIVES\\
.send toc.skip1
.P
<FLECS/ALECS DIRECTIVES ARE USED TO FORCE THE TRANSLATOR TO TAKE NONSTANDARD
.INDEX ^DIRECTIVES
.INDEX <FLECS ^DIRECTIVES
ACTIONS.
^EXCEPT FOR THE "NO TRANSLATION FLAG," A DIRECTIVE CONSISTS OF A
PERIOD IN COLUMN 7 FOLLOWED BY THE DIRECTIVE NAME AND, IN SOME CASES, A SPACE FOLLOWED
BY PARAMETERS.
^THE DEFINED DIRECTIVES ARE LISTED IN THE FOLLOWING SUBSECTIONS.
.HL 2 ^&^NO ^TRANSLATION ^FLAG\&
.P
^IF A "_#" IS IN COLUMN ONE OF INPUT TO <FLECS/ALECS, THE LINE IS NOT TRANSLATED
.INDEX _#
.INDEX ^NO ^TRANSLATION ^FLAG
BUT IS PASSED ONTO THE <FORTRAN/MACRO FILE (WITH THE "_#" REPLACED BY A
SPACE).  ^THIS WILL BE OF LITTLE USE EXCEPT WHEN YOU INTERMIX <FORTRAN77
CODE WITH <FLECS (E.G., TO FORCE <FLECS TO LEAVE THE <FORTRAN77 <ELSE STATEMENT
ALONE).
.HL 2 ^&<.PAGE ^DIRECTIVE\&
.P
<.PAGE OPERATES LIKE THE <MACRO <.PAGE DIRECTIVE.  ^WHEN THE DIRECTIVE IS
.INDEX <.PAGE
ENCOUNTERED, THE LISTING FILE GOES TO A NEW PAGE, ^&AND\& THE <.PAGE LINE
IS OUTPUT AS A COMMENT LINE.  ^NORMALLY, THE <.PAGE DIRECTIVE HAS NO EFFECT
ON THE <FORTRAN/MACRO OUTPUT FILE.  ^HOWEVER, IF THE /^F^ULL SWITCH IS USED
IN THE <FLECS/ALECS COMMAND LINE (SEE ^SEC.#10), A LINE IS PUT INTO THE
OUTPUT FILE TO FORCE A NEW PAGE IN THE <FORTRAN/MACRO OUTPUT LISTING FILE
(FOR <FLECS, A FORMFEED IS PUT IN THE FILE; FOR <ALECS, <.PAGE IS PUT IN
THE FILE).  ^THE SYNTAX OF <.PAGE IS
.SKIP 1
#####<.PAGE
.SKIP 1
^THE DIRECTIVE MAY APPEAR ANYWHERE IN THE INPUT FILE INCLUDING
BETWEEN PROCEDURE DEFINITIONS.
.HL 2 ^&<.NAME ^DIRECTIVE\&
.P
^THE <.NAME DIRECTIVE MAY BE USED TO PUT A DESCRIPTIVE TITLE INTO THE SECOND
.INDEX <.NAME
LINE OF EACH PAGE HEADER IN THE <FLECS/ALECS LISTING FILE.  
^FOR EXAMPLE, THIS MIGHT
BE USED TO INDICATE WHICH SUBROUTINE IS ON THE PAGE.  ^THE SYNTAX IS
.SKIP 1
#####<.NAME NAME
.SKIP 1
WHERE "NAME" IS A 0-6 CHARACTER <ASCII STRING.  (^IF NO CHARACTERS ARE GIVEN,
THE NAME FIELD IN THE HEADER IS BLANKED OUT.)##^THE
NAME IS USED ON THE NEXT NEW PAGE, SO TO GET THE NAME ON THE "CURRENT"
PAGE, YOU MUST
.SKIP 1
#####<.NAME NAME
.BR
#####<.PAGE
.SKIP 1
^TO GET THE NAME ON THE FIRST PAGE OF OUTPUT, JUST PUTTING THE DIRECTIVE AS
THE FIRST LINE IN THE FILE IS SUFFICIENT (THE <.PAGE IS NOT NECESSARY).
.HL 2 ^&<.INCLUDE ^DIRECTIVE\&
.P
^THIS DIRECTIVE IS INTENDED TO OPERATE MUCH LIKE THE <FORTRAN <INCLUDE STATEMENT.
.INDEX <.INCLUDE
^THE <.INCLUDE DIRECTIVE SPECIFIES THAT THE CONTENTS OF A DESIGNATED FILE ARE
TO BE INCORPORATED IN THE <FLECS/ALECS TRANSLATION DIRECTLY FOLLOWING THE
<.INCLUDE DIRECTIVE.  ^IT HAS NO EFFECT ON PROGRAM EXECUTION EXCEPT
TO DIRECT THE TRANSLATOR TO READ INPUT FROM A FILE.
.P
^THE <.INCLUDE DIRECTIVE HAS THE FOLLOWING SYNTAX:
.SKIP 1
#####<.INCLUDE <FILESPEC[/[-]LIST]
.SKIP 1
WHERE <FILESPEC IS THE NAME OF THE FILE TO BE INCLUDED IN THE TRANSLATION.
^NOTE THAT, UNLIKE THE <FORTRAN <INCLUDE STATEMENT, THE FILE SPECIFIER IS NOT
IN APOSTROPHES.
^THE OPTIONAL </[-]LIST SWITCH MAY BE USED TO FORCE OR PREVENT LISTING OF
THE INCLUDED FILE IN THE <.FLL/.ALL FILE.  ^IF THE SWITCH IS NOT GIVEN,
THE INCLUDED FILE IS LISTED.
.P
^IN THE <FLECS/ALECS LISTING FILES, THE INCLUDED LINES ARE DENOTED BY AN *
.INDEX *
PRECEDING THE LINE NUMBER IN THE LEFTMOST COLUMN.
.P
^WHEN THE TRANSLATOR ENCOUNTERS A <.INCLUDE DIRECTIVE, IT STOPS READING
STATEMENTS FROM THE CURRENT FILE AND READS THE STATEMENTS IN THE INCLUDED FILE.
^WHEN IT REACHES THE END OF THE INCLUDED FILE, THE TRANSLATOR RESUMES TRANSLATION
WITH THE NEXT STATEMENT AFTER THE <.INCLUDE DIRECTIVE.
.P
^A <.INCLUDE DIRECTIVE CAN BE CONTAINED IN AN INCLUDED FILE.  ^HOWEVER, THE
MAXIMUM NESTING DEPTH OF <.INCLUDE STATEMENTS IS THREE.
.P
^AN INCLUDED FILE CAN BEGIN WITH A <FORTRAN CONTINUATION LINE, BUT THIS USE
IS PROBABLY UNWISE.
.P
^THE <.INCLUDE DIRECTIVE CAN APPEAR ANYWHERE THAT A COMMENT LINE CAN APPEAR.
^ANY <FORTRAN/MACRO <FLECS/ALECS CAN APPEAR IN AN INCLUDED FILE.  ^HOWEVER,
THE INCLUDED STATEMENTS, WHEN COMBINED WITH THE OTHER STATEMENTS IN THE INPUT,
MUST SATISFY THE REQUIREMENTS OF <FLECS/ALECS AND <FORTRAN/MACRO (E.G.,
^^WHEN\\S MUST HAVE ^^ELSE\\S, SPECIFICATION STATEMENTS MUST PRECEDE EXECUTABLE
STATEMENTS, ETC.).
.PAGE
.HL 2 ^&^CONDITIONAL ^TRANSLATION ^DIRECTIVES\&
.P
^THESE DIRECTIVES ARE USED TO CONTROL WHAT CODE IS PUT INTO THE OUTPUT
.INDEX ^CONDITIONAL TRANSLATION
.INDEX <.PASSIF
.INDEX <.PASSUNLESS
.INDEX <.PASSEND
<FORTRAN/MACRO FILE.  ^AN EXAMPLE OF THE USE OF THESE DIRECTIVES IS CODE THAT
HAS COMMON SOURCE FOR <VMS/RSX USING <VMS SYSTEM SERVICES AND <RSX EXECUTIVE
DIRECTIVES.  ^ONE MIGHT ATTEMPT TO WRITE SUCH CODE USING <WHEN/ELSE:
.SKIP 1
.NOFILL
###<WHEN (VARIABLE THAT IS <.TRUE. IF UNDER <VMS)
###.   CALL SYSTEM SERVICES
###...<FIN
###<ELSE
###.   CALL EXECUTIVE DIRECTIVES
###...<FIN
.SKIP 1
.FILL
^HOWEVER, THE CODE WOULD NOT COMPILE UNDER <RSX (SYSTEM SERVICE NAMES ARE
ILLEGAL THERE) AND WOULD NOT LINK UNDER <VMS (MISSING EXECUTIVE DIRECTIVE
SUBROUTINES).  ^THE <FLECS/ALECS CONDITIONAL TRANSLATION DIRECTIVES
SOLVE THE PROBLEM AS FOLLOWS:
.SKIP 1
.NOFILL
###<.PASSIF <VMS
###SYSTEM SERVICE CALLS
###<.PASSEND
###<.PASSUNLESS <VMS
###EXECUTIVE DIRECTIVE CALLS
###.PASSEND
.SKIP 1
.FILL
^IF THE SYMBOL <VMS WERE DEFINED FROM THE <FLECS/ALECS COMMAND LINE
(SEE BELOW), ONLY THE CODE INSIDE THE FIRST CLAUSE IS TRANSLATED AND PASSED
TO THE OUTPUT <FORTRAN/MACRO FILE.  ^IF THE SYMBOL IS NOT DEFINED, ONLY CODE
INSIDE THE SECOND CLAUSE IS PASSED TO THE OUTPUT FILE.
.P
^THE SYNTAX FOR THE CONDITIONALS IS
.SKIP 1
.NOFILL
#####<.PASSIF SYMBOL
#####<FLECS/FORTRAN OR <ALECS/MACRO CODE
#####<.PASSEND
.SKIP 1
OR
.SKIP 1
#####<.PASSUNLESS SYMBOL
#####<FLECS/FORTRAN OR <ALECS/MACRO CODE
#####<.PASSEND
.SKIP 1
.FILL
^HERE "SYMBOL" IS AN <ASCII STRING 1-6 CHARACTERS LONG.  ^IN THE FIRST CASE,
THE CODE WILL BE PUT IN THE OUTPUT <FORTRAN/MACRO FILE IF THE SYMBOL IS
DEFINED; IN THE SECOND CASE, THE CODE WILL BE PUT IN THE OUTPUT IF THE SYMBOL
IS NOT DEFINED.
.P
.tp 5
^SYMBOLS ARE DEFINED USING THE /^C^ONDITIONAL SWITCH IN THE <FLECS/ALECS
COMMAND LINE.  ^THE SWITCH MUST BE GIVEN ON THE INPUT SIDE OF THE LINE AND HAS
THE FORMAT
.SKIP 1
#####^^FLE>A,A=A/CO\\:N1:...:NM
.SKIP 1
.TP 5
WHERE THE NI'S ARE 1-6 CHARACTER <ASCII SYMBOLS.  ^IF A SYMBOL IS GIVEN IN
THE COMMAND LINE, THE CORRESPONDING SYMBOL IS DEFINED; IF A SYMBOL IS NOT
GIVEN, THE SYMBOL IS NOT DEFINED,  E.G., FOR
.SKIP 1
#####^^FLE>CALC,CALC=CALC/CO:VMS:NOBOX:ACQUISITION\\
.SKIP 1
<VMS, <NOBOX, AND <ACQUIS ARE DEFINED.  (^LONG NAMES ARE TRUNCATED TO SIX
CHARACTERS.)
.P
^THE NEGATED SWITCH (/-^C^O) IS ILLEGAL.
.P
^ONLY INPUT LINES THAT ARE PASSED ON TO THE <FTN/MAC FILE ARE LISTED IN
THE <FLL/ALL FILE.  ^HOWEVER, ALL ^^.PASS\\X LINES ARE LISTED TO
SHOW WHAT CONDITIONALS ARE BEING USED.  ^NOTE THAT THE LINE NUMBERS IN THE LEFT
COLUMN OF THE <FLL/ALL FILE WILL BE DISCONTINUOUS TO REFLECT THE FACT THAT
LINES IN THE INPUT <FLX/ALX FILE WERE NOT PASSED TO THE <FTN/MAC FILE.
.bb
.HL 2 ^&^^.IMPLICIT NONE\\ ^DIRECTIVE\&
.index <.IMPLICIT <NONE
.UPPER CASE
.P
This FLECS* directive
.footnote
.skip 1
----------
.skip 1
*This directive is not implemented for ALECS.  Use of the directive in
ALECS will give an assemly-time error.
.end footnote
is used in place of the FORTRAN-77 IMPLICIT NONE statement to make any
undeclared variables an error.  (The FORTRAN IMPLICIT NONE statement would
make variables generated by FLECS errors!)  Insert the directive in your
code before any code or variable declarations.
.p
Under VMS the directive generates code like
.skip 1
#####IMPLICIT NONE
.BR
#####INCLUDE '32766.FID/NOLIST'
.SKIP 1
so that any undeclared variable will cause a FORTRAN error.  The FID file
(FLECS Internal Declarations) contains declarations for all variables
generated by FLECS for the routine.  If USER$COM:FLE.COM is used (see
Sec.#10) the FID files are automatically deleted after compilation completes
successfully.
.p
Under RSX FORTRAN-77 the IMPLICIT NONE statement is not supported.  In this
case the directive generates code like
.skip 1
#####IMPLICIT COMPLEX (A-Z)
.BR
#####INCLUDE '32766.FID/NOLIST'
.SKIP 1
so that any undeclared variable will be typed COMPLEX*8.  The FORTRAN
compiler will flag use of such variables an error in some cases;  to
find all such uses, however, you must look in the FORTRAN variable map
for C*8 variables.  If [202,1]FLE.COM is used (see
Sec.#10) the FID files are automatically deleted after compilation completes
successfully.

.LOWER CASE
.eb
.PAGE
.send toc.skip1
.HL 1 ^^PROCEDURE FOR USE\\
.send toc.skip1
.TS 15,44
.P
^UNDER <RSX-11M THE <FLECS AND <ALECS TRANSLATORS MUST BE INSTALLED IN THE
SYSTEM. ^ASSUMING THE
.BB
FILES <FLE.TSK AND <ALE.TSK ARE
.EB
ON <DP1:#UNDER <UIC#<[201,7],
THE PROCEDURE IS:
.NF
.S 1
	^^MCR>HEL SYSTEM/\\password^^
.BB
	MCR>INS DP1:[201,7]FLE/TASK=...FLE
	MCR>INS DP1:[201,7]ALE/TASK=...ALE\\
.EB
.S 1
.FILL
.P
^UNDER <VMS THE SYSTEM MANAGER MUST PUT
.BB
FILES <FLE.EXE AND <ALE.EXE IN DIRECTORY [<SYSEXE] SO THAT THEY MAY
BE INVOKED BY
.SKIP 1
#####^^$ MCR FLE\\ OR
.SKIP
#####^^$ MCR ALE\\
.SKIP
.EB
.P
^TO INVOKE THE <FLECS TRANSLATOR FOR <RSX-11M OR <VMS:
.INDEX ^^FLE\\
.S 1
	^^MCR>FLE OUT/[-]FU,LIST/[-]SP=IN/CO:N1:...:NM\\
.LS
.LM +5
.LE;<OUT IS AN OUTPUT FILE SPECIFIER TO RECEIVE THE
GENERATED <FORTRAN FILE; IF AN EXTENSION IS NOT GIVEN, <FTN IS ASSUMED.
^THE <OUT FILE IS OPTIONAL--IF NOT GIVEN, THE
FILE IS NOT PRODUCED; HOWEVER, THE COMMA MUST BE GIVEN. ^THE /<FU  
SWITCH, IF GIVEN,
PRODUCES A "FULL" OUTPUT--COMMENTS IN THE INPUT FILE ARE PUT IN THE OUTPUT
ALONG WITH <FLECS STRUCTURED STATEMENTS AS COMMENTS. ^IF </-FU IS GIVEN
OR IF THE
SWITCH IS NOT GIVEN, ONLY GENERATED <FORTRAN IS PUT IN <OUT.
.LE;<LIST IS AN OUTPUT FILE SPECIFIER TO RECEIVE THE <FLECS LISTING
FILE; IF AN EXTENSION IS NOT GIVEN, <FLL IS ASSUMED. ^THE <LIST
FILE IS OPTIONAL--IF NOT GIVEN, THE FILE IS NOT PRODUCED (THE COMMA 
SHOULD NOT BE GIVEN IN THIS CASE). ^THE </SP SWITCH IF EXPLICITLY GIVEN OR IF OMITTED 
CAUSES THE <LIST FILE TO BE SPOOLED TO THE LINE PRINTER
AND DELETED. ^IF </-SP IS GIVEN, THE <LIST FILE IS NEITHER PUT ON THE LINE 
PRINTER NOR IS IT DELETED.
.LE;<IN IS AN INPUT FILE SPECIFIER FOR THE <FLECS INPUT; IF AN
EXTENSION IS NOT GIVEN, <FLX IS ASSUMED. ^THIS SPECIFIER MUST BE GIVEN.
^SEE ^SEC.#9 FOR A DESCRIPTION OF THE </CO SWITCH.
.ELS
.LM 5
.P
^TO INVOKE THE <ALECS TRANSLATOR FOR <RSX-11M OR <VMS:
.INDEX ^^ALE\\
.S 1
	^^MCR>ALE#OUT/[-]FU,LIST/[-]SP=IN/CO:N1:...:NM\\
.S 1
^ALL COMMENTS FOR THE <FLECS LINE APPLY EXCEPT THAT THE DEFAULT EXTENSIONS
ARE ^^MAC, ALL\\, AND <ALX, RESPECTIVELY.
.P
.TP 11
^PROBABLY THE SIMPLEST WAY TO USE <FLECS OR <ALECS IS TO CREATE
A COMMAND FILE IN THE FOLLOWING FORM:
.INDEX COMMAND PROCEDURE
.S 1
.NF
	.^^MORE:
	.ASKS NAM GIVE NAME OF FILE
	FLE 'NAM','NAM'/-SP='NAM'
	F77 'NAM','NAM'/-SP='NAM'
	PIP 'NAM'.FLL='NAM'.LST/AP
	PIP 'NAM'.FTN;*,'NAM'.LST;*/DE
	.GOTO MORE\\
.S 1
.FILL
^THE PROCEDURE WILL CONTINUE TO ASK FOR SOURCE FILES UNTIL A <CTRL/Z
IS GIVEN TO THE QUESTION. (^NOTE THAT THE TWO <PIP STEPS MAY BE
REPLACED WITH PROGRAM <AFF FOR <FLECS.)
.P
^STANDARD VERSIONS OF COMMAND FILES ARE AVAILABLE FOR BOTH <RSX-11M AND
<VMS.  ^THE FILES MAY BE FOUND IN DIRECTORY [202,1] FOR <RSX-11M AND
<USER$COM FOR <VMS.  ^THE COMMAND FILES MAY BE USED BY
.SKIP 1
#####@[DIR]^^FLE NAME FORSW FLESW\\
.SKIP 1
#####@[DIR]^^ALE NAME MACSW ALESW\\
.SKIP 1
WHERE
.SKIP 1
<NAME IS THE NAME OF THE <.FLX/.ALX FILE GIVEN WITHOUT A FILE EXTENSION
OR VERSION NUMBER, EG.#<MYFILE OR <DRA0:[A.B.C]SOURCE
.SKIP 1
<FORSW/MACSW IS ANY <FORTRAN/MACRO SWITCHES TO BE USED WHEN THE FILE IS
COMPILED, EG.#</CO:19.  ^IF NO <FORTRAN/MACRO SWITCHES ARE DESIRED, BUT YOU
WILL BE GIVING <FLECS/ALECS SWITCHES, PUT A POUND SIGN (_#) IN THIS
POSITION.
.SKIP 1
<FLESW/ALESW IS ANY <FLECS/ALECS SWITCHES TO BE USED (MAY BE BLANK).
.SKIP 1
^EXAMPLES OF PROPER CALLS TO THE COMMAND PROCEDURES ARE:
.SKIP 1
^^@FLE XYZ /CO:19 /FU\\
.SKIP 1
^^@FLE XYZ _# /FU\\############!^NO <FORTRAN ^SWITCHES
.SKIP 1
^^@FLE XYZ /CO:19\\###########!^NO <FLECS ^SWITCHES
.SKIP 1
^^@FLE XYZ\\##################!^NO SWITCHES
.SKIP 1
^^@FLE\\######################!^FILE WILL PROMPT FOR INFORMATION
.P
<FLECS AND <ALECS "^^EXIT WITH STATUS\\" SO THAT UNDER <RSX-11M THE
SYMBOL _<<EXSTAT> MAY BE CHECKED IN THE COMMAND PROCEDURE TO DETERMINE
IF <FORTRAN, ETC., SHOULD BE CALLED. {^USE SYMBOL <$STATUS IN <VMS.}
.P
^WHEN <FLECS/ALECS IS GIVEN A COMMAND LINE, IT FIRST VERIFIES THE COMMAND LINE
IS CORRECT BEFORE ATTEMPTING TO CARRY OUT THE TRANSLATION.  ^DURING THIS
VERIFICATION, AN ERROR MESSAGE MAY BE OUTPUT DESCRIBING THE ERROR IN THE LINE.
^IN THIS CASE, NO TRANSLATION IS DONE.  ^THE FORM OF THE ERROR MESSAGE IS
.SKIP 1
#####XXX ^^SPECIFIER ERROR--COMMAND IGNORED\\
.SKIP 1
WHERE XXX IS ONE OF THE FOUR STRINGS BELOW:
.LIST
.LM +5
.LE;^^CSI\\--^THE GROSS STRUCTURE OF THE COMMAND LINE IS INCORRECT, E.G.,
THERE ARE TWO EQUAL SIGNS IN THE LINE.
.LE;^^FTN\\--^THE <OUT FILE SPECIFIER FOR THE <FTN FILE IS INCORRECT
(E.G., A FOUR-LETTER
EXTENSION), OR AN ILLEGAL SWITCH HAS BEEN USED (ONLY </FU OR </-FU ARE
ALLOWED WITH THE <FTN FILE), OR THERE IS NO SPACE LEFT ON THE DISK FOR THE FILE.
.LE;^^FLL--T\\HE <LIST FILE SPECIFIER FOR THE <FLL FILE IS INCORRECT,
OR AN ILLEGAL
SWITCH HAS BEEN USED (ONLY </SP OR </-SP ARE ALLOWED WITH THE <FLL FILE),
OR THERE IS NO SPACE LEFT ON THE DISK FOR THE FILE.
.LE;^^FLX--T\\HE <IN FILE SPECIFIER FOR THE <FLX FILE IS INCORRECT,
OR AN ILLEGAL
SWITCH HAS BEEN USED (ONLY </CO IS ALLOWED WITH THE <FLX FILE), OR THE
NAMED FILE DOES NOT EXIST.
.END LIST
.LM 5
.P
.TP 9
^THE <LAMPF VERSION OF <FLECS AND <ALECS HAVE A NONSTANDARD EXTENSION: COMMENTS
.INDEX ^COMMENTS
.INDEX ^IN-LINE COMMENTS
.INDEX COMMENTS IN-LINE
ARE ALLOWED ON STRUCTURED STATEMENT LINES. ^FOR <FLECS, SUCH
COMMENTS MUST BE PRECEDED BY AN EXCLAMATION POINT;
FOR <ALECS, SUCH COMMENTS MUST BE PRECEDED BY A SEMICOLON. ^EXAMPLES:
.S 1
.NF
	^^WHEN(I.GT.J)	! ONLY OCCURS FOR BAD DATA
	REPEAT UNTIL(:C.SET:)	; QUIT ON ERROR
	DO(I=1,NTERM)	! NTERM=POLYNOMIAL DEGREE\\
.S 1
.FILL
.TP 5
^THIS CAPABILITY IS AVAILABLE IN STANDARD <FLECS (IF <FORTRAN ALLOWS
SUCH COMMENTS) AND <ALECS FOR ONE-LINE STRUCTURED STATEMENTS, E.G.,
.S 1
.NF
	^^WHEN (I.GT.J)I=0	! ONLY OCCURS FOR BAD DATA
	REPEAT UNTIL(:C.SET:) DIR$ _#V; QUIT ON ERROR\\
.S 1
.TP 12
.FILL
^THE EXTENSION IS TO PROVIDE THE CAPABILITY FOR THE MULTILINE FORM.
.P
^NOTE THAT THE IN-LINE COMMENT ALLOWS A CONVENIENT WAY OF SORTING
OUT ^^FIN\\S:
.S 1
.TP 7 
.NF
	^^WHILE(I.GT.J)
	.  IF(L)
	.  .  DO(M=1,500)\\
	.  .  .  ETC.
	.  .  ...^^FIN!DO
	.  ...FIN!IF
	...FIN!WHILE
.LM 5
.APPENDIX ^^FLOW CHARTS FOR FLECS STATEMENTS\\
.LM 5
.LM 5
.NF
.S 2
.LM 5
^^LEGEND:
    [L] = L\\OGICAL ^EXPRESSION
     $  = ^STATEMENT(\S)
   [<EL] = ^EXPRESSION
     ^^I@ = DO \\SPECIFICATION
.S 2
^^IF ( [L] ) $#######UNLESS ( [L] ) $######WHEN ( [L] ) $1
                                         ELSE $2
-------------    ------------------     ----------------
  !                 !                     !
 _/ _\   T           _/ _\   F               _/ _\   T
_<[L]>----->$      _<[L]>----->$          _<[L]>---->$1
 _\._/       !       _\._/       !           _\._/       !
  !        !        !        !            !        !
 F!        !       T!        !           F!        !
  !        !        !        !            $2       !
  !--------'        !--------'            !--------'
  !                 !                     !
.S 2
.TEST PAGE 12
  REPEAT UNTIL ( [L] ) $    REPEAT WHILE ( [L] ) $
------------------------    ------------------------
   !                         !
   !_<-----.                  !_<-----.
   !      !                  !      !
   $      !                  $      !
   !      !                  !      !
  _/ _\   ^F !                 _/ _\  T  !
 _<[L]_>----'                _<[L]_>----'
  _\._/                       _\._/
   !                         !
  T!                        F!
.S 2
.TEST PAGE 14
  UNTIL ( [L] ) $     WHILE ( [L] ) $
-----------------   -----------------
      !                   !
      !_<-----.            !_<-----.
      !      !            !      !
   T _/ _\     !         F _/ _\     !
 .--_<[L]>    !       .--_<[L]>    !
 !   _\._/     !       !   _\._/     !
 !    !      !       !    !      !
 !   ^F!      !       !   ^T!      !
 !    '---$--'       !    '---$--'
 !                   !
  ----.               ----.
      !                   !
.S 1
.TP 30
     ^^CONDITIONAL        SELECT ( [EL] )
     .  ( [L1] ) $1     .  ( [EL1] ) $1
     .  ( [L2] ) $2     .  ( [EL2] ) $2
     .      .     .     .       .     .
     .  ( [L\N] ) $\N     .  ( [EL\N] ) $\N
     ...FIN             ...FIN
---------------------  -------------------
        !                  !
       _/ _\                _/ _\
      _/   _\  T           _/[EL]_\   T
     _<[L1] >----->$1-.  _<=[EL1]>----->$1-.
      _\   _/          !   _\   _/           !
       _\._/           !    _\._/            !
       F!            !    F!             !
        !            !     !             !
       _/ _\           !    _/ _\            !
      _/   _\   T      !   _/[EL]_\   T      !
     _<[L2] >----->$2-!  _<=[EL2]>----->$2-!
      _\   _/          !   _\   _/           !
       _\._/           !    _\._/            !
       F!            !    F!             !
        !            !     !             !
        !            !     !             !
       _/ _\           !    _/ _\            !
      _/   _\   T      !   _/[EL]_\   T      !
     _<[L\N] >-----$\N--!  _<=[EL\N]>-----$\N--!
      _\   _/          !   _\   _/           !
       _\._/           !    _\._/            !
       F!            !    F!             !
        !------------'     !-------------'
        !                  !
.S 1
.FILL
N\\OTE:
^^OTHERWISE \\CAN BE USED AS A CATCHALL CONDITION IN
^^CONDITIONAL\\ AND ^^SELECT\\ STATEMENTS.^^
.NF
.TP 10
.S 2
     --------------------------        ---------------------
.S 1
        CARRY-OUT-ACTION                 DO (I@) $
.S 1
        TO CARRY-OUT-ACTION $          ---------------------
.S 1
     --------------------------
.S 1
.FILL
N\\OTE:
^PLACE A ^^RETURN, STOP\\, OR ^^CALL EXIT\\ STATEMENT
AHEAD OF THE FIRST <TO STATEMENT.
.NF
.FILL
.LM 5
.APPENDIX ^^AVAILABLE DOCUMENTATION CONCERNING FLECS\\ (^DECEMBER, 1974)
.LM 5
^BEYER, ^T.: <FLECS ^USERS ^MANUAL (^UNIVERSITY OF ^OREGON ^EDITION)
.S 1
.LEFT MARGIN 12
^CONTAINS A CONCISE DESCRIPTION OF THE <FLECS EXTENSION OF <FORTRAN
AND OF THE DETAILS NECESSARY TO RUNNING A <FLECS PROGRAM ON THE
<PDP-10 OR THE <IBM#S/360 AT ^OREGON.
^THIS IS THE ORIGINAL MANUAL ON WHICH THIS ONE IS BASED.
.S 2
.LEFT MARGIN 5
^BEYER, ^T.: <FLECS: ^SYSTEM ^MODIFICATION ^GUIDE
.S 1
.LEFT MARGIN 12
^CONTAINS INFORMATION OF INTEREST TO ANYONE WHO WISHES TO INSTALL
OR ADAPT THE <FLECS SYSTEM TO A NEW MACHINE OR OPERATING SYSTEM.
^ALSO OF INTEREST TO THOSE WHO WISH TO IMPROVE THE EFFICIENCY
OF THE SYSTEM BY REWRITING PORTIONS OF THE SYSTEM IN ASSEMBLY
LANGUAGE.
.UPPER CASE
.title INDEX
.send toc INDEX
.IF INDEX
.page
.IF TWOCOLIND
.REQUIRE "FLECSUIM.RNX"
.ELSE TWOCOLIND
.PRINT INDEX
.ENDIF TWOCOLIND
.ENDIF INDEX