DataMuseum.dk

top - metrics - download

    Length: 19200 (0x4b00)
    Types: TextFileVerbose
    Names: »lmitxt00a«

└─⟦2c55ea56f⟧ Bits:30001844 SW-save af projekt 1000, Alarm-system
    └─⟦093e2ad1c⟧ 
        └─⟦this⟧ »lmitxt00a« 

TextFileVerbose

;;
;; lmitxt00a
;;
;; description of the microprogram assembler.
;;
;;
;; this description describes the function of the microprogram
;; assembler in terms of the binary output produced. this description
;; should therefore only be read together with a reference manual
;; describing the meaning of the microinstruction word.
;;
;; the syntax is described in a modified backus-naur form. for
;; convenience comments, which describe (some of) the binary output
;; produced by the syntactical structure, are introduced in the
;; syntax description as follows:
;;           / <value> pos <position in the microinstruction word> /
;;
;; the parenthesis:
;;   ( <choice 1> ! <choice 2> ! - - - ! <choice n> ) '<from>,<to>'
;; means picking a number from <from> thru <to> of choices. if <to>
;; is written as an asterisk, it means that you may pick up to any
;; number of choices. if '<from>,<to>' is omitted, then you must pick
;; just one choice.
;;
;; the parenthesis:
;;   ( <choice 1> !! <choice 2> !! - - - !! <choice n> ) '<from>,<to>)'
;; has the same meaning as the above parenthesis, except that no choice
;; may be picked more than once.
.p ;;
;; syntax description:
;;
;; <micro program> ::= ( <input line> <line termination> )'0,*'
;;
;; <line termination> ::=
;;       ( ; <any string not containing <newline> or <endmedium> > !
;;         ;;<any string not containing <newline> or <endmedium> > !
;;         <empty> )
;;       ( <newline> ! <endmedium> )
;;
;; <newline> ::= <the ascii newline character>
;; <endmedium> ::= <the ascii endmedium character>
;;
;; <input line> ::=
;;       ( . loc  !
;;         . loc <expression> !
;;         . k = <expression> !
;;         . list on !
;;         . list off !
;;         . print on !
;;         . print off !
;;         . instruction (<instrcode>)'0,1' , (<map1>)'0,1' , (<map2>)'0,1' !
;;         . p !
;;         . m <any string not containing <line termination> >  !
;;         . <regname> = <expression> !
;;         <constname> = <expression> !
;;         <constname> : !
;;         . mapk <expression>
;;         . addr <expression>
;;         . addr <expression> , <repetitions>
;;         <empty line> !
;;         <instruction line> )
.p ;;
;; <instrcode> ::= <expression>
;; <map1> ::= <expression>
;; <map2> ::= <expression>
;;
;; <repetitions> ::= <expression>
;;
;; <regname> ::= <letter> ( <letter or digit> )'0,11'
;; <constname> ::= <letter> ( <letter or digit> )'0,11'
;;
;; <expression> ::=
;;       ( + ! - ! <empty> ) ( <hexconstant> ! <constname> )
;;       ( ( + ! - ) ( <hexconstant> ! <constname> ) )'0,*'
;;
;; <hexconstant> ::= <digit> ( <digit> ! a ! b ! c ! d ! e ! f )'0,*'
;;
;; <empty line> ::= <empty>
;;
;; <instruction line> ::=
;;         <bus, alu part> / pos 8-25, 27-37, 43, 45-46, 49-59 /
;;         <do functions>, / pos 26, 39-42, 44, 48 /
;;         <sequence part>, / pos 0-7, 38, 47 /
;;         <address>       / pos 49-59 /
;;
;; <address> ::= <expression>
;;
;; <do functions> ::=
;;       ( h  / 0 pos 26 /  !!
;;         w  / 1 pos 40 /  !!
;;         b  / 0 pos 41 /  !!
;;         r  / 0 pos 48 /  !!
;;         s  / 0 pos 42 /  !!
;;         i  / 0 pos 39 /  !!
;;         u  / 0 pos 44 /  )'0,7'
.p ;;
;; <bus, alu part> ::=
;;         <bus dest>                / pos 27-31, 35-37, 43, 45, 46, 58-59 /
;;         <bus source>              / pos 16-18, 29-34, 49-59 /
;;         <alu dest>                / pos 16-18 /
;;         <carry control>           / pos 27-28, 43 /
;;         <alu function and source> / pos 8-15, 19-25, 29-34, 49-59 /
;;
;; <bus dest> ::=
;;       ( ir :=      / 0 pos 45 /  !!
;;         rc :=      / 0 pos 46 /  !!
;;         c  :=      / 3 pos 27-28, 0 pos 43 /  !!
;;         <data1> := / pos 27-31, 35-37, 58-59 /  )'0,4'
;;
;; <bus source> ::=
;;       ( <a>,     / 2 pos 16-18; 5 pos 32-34 /  !
;;         <data2>, / pos 29-34, 49-59 /  !
;;         <empty>  )
;;
;; <alu dest> ::=
;;       ( <b> :=   / 2,3 pos 16-18 /  !
;;         q :=     / 0 pos 16-18 /  !
;;         <b> :>>  / 4 pos 16-18 /  !
;;         <b> :=>  / 5 pos 16-18 /  !
;;         <b> :<<  / 6 pos 16-18 /  !
;;         <b> :=<  / 7 pos 16-18 /  !
;;         <empty>  / 1 pos 16-18 /  )
;;
;; <carry control> ::=
;;       ( c :     / 2 pos 27-28; 0 pos 43 /  !
;;         c <     / 1 pos 27-28; 0 pos 43 /  !
;;         c >     / 0 pos 27-28; 0 pos 43 /  !
;;         <empty>  )
;;
;; <alu function and source> ::=
;;       ( <x> <op> <y> / pos 8-15, 19-25, 29-34, 49-59 /  !
;;         <x> / 0 pos 19-21, 22; 2,3,4,7 pos 23-25; pos 8-15, 29-34, 49-59 /  !
;;         <empty>      / 4 pos 19-21; 0 pos 22; 4 pos 23-25 /  )
.p ;;
;; <x> ::= <am2901 slice operand>
;; <y> ::= <am2901 slice operand>
;;
;; <am2901 slice operand> ::=
;;       ( <a> ! <b> ! q ! <empty> ! <data2> )
;;
;; <a> ::= <regname>  / pos 8-11 /
;; <b> ::= <regname>  / pos 12-15 /
;;
;; <data1> ::=
;;       ( bus     / 0 pos 35-37 /  !
;;         bd      / 4 pos 35-37 /  !
;;         <wreg1> / 2 pos 35-37; pos 27-31, 58-59 /  !
;;         cd      / 6 pos 35-37 /  !
;;         bf      / 1 pos 35-37; 0 pos 31 /  !
;;         bfm     / 1 pos 35-37; 1 pos 31 /  !
;;         led     / 5 pos 35-37 /  !
;;         ba      / 3 pos 35-37 /  !
;;         ra      / 7 pos 35-37 /  )
;;
;; <data2> ::=
;;       ( bd      / 4 pos 32-34 /  !
;;         <wreg2> / 2 pos 32-34; pos 29-31, 58-59 /  !
;;         cd      / 6 pos 32-34 /  !
;;         swp     / 1 pos 32-34 /  !
;;         ccr     / 7 pos 32-34 /  !
;;         int     / 0 pos 32-34 /  !
;;         const   / 3 pos 32-34 /  !
;;         <hexconstant> / 3 pos 32-34; pos 49-59 /  !
;;         <constname>   / 3 pos 32-34; pos 49-59 /  )
.p ;;
;; <wreg1> ::=
;;       ( rm ! rmw ! rmx ! rmc ! rm0 ! rm1 ! rm2 ! rm3 !
;;         ro ! row ! rox ! roc ! ro0 ! ro1 ! ro2 ! ro3 !
;;         rz ! rzw ! rzx ! rzc ! rz0 ! rz1 ! rz2 ! rz3 !
;;         zm ! zmw ! zmx ! zmc ! zm0 ! zm1 ! zm2 ! zm3 !
;;         zo ! zow ! zox ! zoc ! zo0 ! zo1 ! zo2 ! zo3 !
;;         zz ! zzw ! zzx ! zzc ! zz0 ! zz1 ! zz2 ! zz3 !
;;         <wreg 1 or 2>  )
;;
;; <wreg2> ::= <wreg 1 or 2>
;;
;; <wreg 1 or 2> ::=
;;       ( rd ! rdw ! rdx ! rdc ! rd0 ! rd1 ! rd2 ! rd3 !
;;         zd ! zdw ! zdx ! zdc ! zd0 ! zd1 ! zd2 ! zd3 )
;;
;; <op> ::=
;;       ( +    / 0 pos 19-21; 0 pos 22 /  !
;;         ++   / 0 pos 19-21; 1 pos 22 /  !
;;         -    / 1 or 2 pos 19-21; 1 pos 22 /  !
;;         --   / 1 or 2 pos 19-21; 0 pos 22 /  !
;;         ior  / 3 pos 19-21; 0 pos 22 /  !
;;         and  / 4 pos 19-21; 0 pos 22 /  !
;;         clr  / 5 pos 19-21; 0 pos 22 /  !
;;         xor  / 6 pos 19-21; 0 pos 22 /  !
;;         equ  / 7 pos 19-21; 0 pos 22 /  )
.p ;;
;; <sequence part> ::=
;;         <next>           / pos 0-3, 4-7 /
;;         ( not    )'0,1'  / 1 pos 38 /
;;         ( <cond> )'0,1'  / pos 4-7, 47 /
;;
;; <next> ::=
;;       ( jz               / 0 pos 0-3 /  !
;;         cjs              / 1 pos 0-3 /  !
;;         jmap <map-cond>  / 2 pos 0-3; pos 4-7 /  !
;;         cjp              / 3 pos 0-3 /  !
;;         push             / 4 pos 0-3 /  !
;;         jsrp             / 5 pos 0-3 /  !
;;         cjv <vect-cond>  / 6 pos 0-3; pos 4-7 /  !
;;         jrp              / 7 pos 0-3 /  !
;;         rfct             / 8 pos 0-3 /  !
;;         rpct             / 9 pos 0-3 /  !
;;         crtn             / 10 pos 0-3 /  !
;;         cjpp             / 11 pos 0-3 /  !
;;         ldct             / 12 pos 0-3 /  !
;;         loop             / 13 pos 0-3 /  !
;;         cont             / 14 pos 0-3 /  !
;;         twb              / 15 pos 0-3 /  !
;;         <empty>          / 14 pos 0-3 /  )
;;
;; <map-cond> ::=
;;       ( <hexconstant>  / pos 4-7 /  !
;;         <constname>    / pos 4-7 /  )
;;
;; <vect-cond> ::=
;;       ( <hexconstant>  / pos 4-7 /  !
;;         <constname>    / pos 4-7 /  )
.p ;;
;; <cond> ::=
;;       ( b0   / 0 pos 4-7; 0 pos 47 /  !
;;         i10  / 1 pos 4-7; 0 pos 47 /  !
;;         st2  / 2 pos 4-7; 0 pos 47 /  !
;;         st3  / 3 pos 4-7; 0 pos 47 /  !
;;         st4  / 4 pos 4-7; 0 pos 47 /  !
;;         st5  / 5 pos 4-7; 0 pos 47 /  !
;;         c7   / 6 pos 4-7; 0 pos 47 /  !
;;         st7  / 7 pos 4-7; 0 pos 47 /  !
;;         zro  / 8 pos 4-7; 0 pos 47 /  !
;;         ovf  / 9 pos 4-7; 0 pos 47 /  !
;;         pty  / 10 pos 4-7; 0 pos 47 /  !
;;         acy  / 11 pos 4-7; 0 pos 47 /  !
;;         b15  / 12 pos 4-7; 0 pos 47 /  !
;;         cry  / 13 pos 4-7; 0 pos 47 /  !
;;         cr   / 14 pos 4-7; 0 pos 47 /  !
;;         b1   / 15 pos 4-7; 0 pos 47 /  )
.p ;;
;; lexical analysis:
;;
;; spaces are delimiters between items and are here blind.
;; commas are likewise delimiters between different fields in the
;; <instruction line>. commas are often not necessary at all, and more
;; than one comma are considered as a single comma. however, if the
;; <bus source> is not empty, then exactly one comma must seperate the
;; "bus part" from the "alu part" in the <bus, alu part>.
;;
;; the characters "*" and "!" will switch from skip-mode to read-mode
;; and vice versa. each line starts in read-mode. if a line ends in
;; skip-mode, then the newline character is also skipped. the characters
;; "*" and "!" are blind in the comments. this convention implies, that
;; the list output from the assembler may be used as input to the
;; assembler later on, and it will be completely equivalent to the original
;; input, even if some error-messages were produced. the assembler may
;; in this way be used as a formatting program.
;;
;; form-feeds are converted into blind characters in the input. form-feeds
;; may be forced into the output by the ".p" directive. this directive
;; is only active if actually listed in the output. the form-feed and
;; the head-line produced in this way will be skipped during a subsequent
;; reading of the output.
;;
;; the input ends when an endmedium character is read, even if it is read
;; during skip-mode.
;;
;; please note that <constname> and <regname> must not be named like any
;; of the reserved words in the syntax diagrams.
;;
;; all capital letters in the input will be converted into small letters.
.p ;;
;; description of the directives and comments:
;;
;; . loc <expression>
;; . loc
;;          an empty expression corresponds to an expression with the
;;          value zero. the load address will be increased by 0 thru 3
;;          until (load address modulo 4) = (expression modulo 4). the
;;          expression must be defined in pass1 of the assembler.
;;
;; k = <expression>
;;          will set the load address to the value obtained by the
;;          expression. the expression must be defined in pass1 of the
;;          assembler. the starting value of the load address is always
;;          zero.
;;
;; . list on
;;          will turn on listing of all input lines using a standard
;;          format.
;;
;; . list off
;;          will turn off listing. only errormessages and lines
;;          starting with ". m" will be listed.
;;
;; . print on
;;          will turn on debug printing of the binary output.
;;
;; . print off
;;          turns off the debug printing.
;;
;; . instruction (<instrcode>)'0,1' , (<map1>)'0,1' , (<map2>)'0,1'
;;          defines the entries in the instruction maps for the
;;          instruction with code <instrcode>. if (<instrcode>)'0,1'
;;          is empty then the default value for all non-explicitly
;;          defined entries is defined. if (<map1>)'0,1' and/or
;;          (<map2>)'0,1' is/are empty then the load address will
;;          be used instead of (<map1>)'0,1' and/or (<map2>)'0,1'.
;;          the commas are not needed if all succeding expressions are
;;          empty. map1 corresponds to "jmap 8". map2 corresponds to
;;          "jmap not 8".
.p ;;
;; . <regname> = <expression>
;;          defines the <regname> to be a name for an am2901 slice
;;          register. the value of the expression must be in the
;;          range 0 thru 0f. it defines the number of the am2901
;;          slice register.
;;
;; . p
;;          causes a form feed to be printed after this line. it
;;          is only active when the ". p" directive is actually
;;          listed.
;;
;; . m <any string not containing <line termination> >
;;          this line works as a comment. furthermore it will be
;;          listed as a message. the ". m" will be listed in character
;;          position 1, but the rest of the line is listed exactly
;;          as it is written.
;;
;; <empty line>
;;          has no effect, except during listing.
;;
;; ; <any string not containing <line termination> >
;; ;; <any string not containing <line termination> >
;;          these comments are printed if listing is on. they are
;;          otherwise blind. a comment starting with a double semicolon
;;          will (if possible) be listed, starting nearly at the left
;;          margin of the line. a comment starting with a single
;;          semicolon will be listed to the right of the instruction
;;          lines.
;;
;; <constname> :
;;          the name <constname> is defined to be the name of a constant.
;;          it will get the value of the current load address.
;;
;; <constname> = <expression>
;;          the name <constname> is defined to be the name of a constant.
;;          it will get the value of the <expression>. the <expression>
;;          is not required to be defined until pass2.
.p ;;
;; . mapk <expression>
;;          the mapk variable is set equal to the <expression> (modulo
;;          1024). this variable is used by ". addr ---".
;;
;; . addr <expression>
;; . addr <expression> , <repetitions>
;;          if <repetitions> is absent, then a value 1 is assumed. the
;;          maptable with index "mapk" is set equal to the <expression>,
;;          and mapk is increased (modulo 1024) by 1. if <repetitions>
;;          is present, then the above is performed <repetitions> times. 
;;
;; unless the contrary is explicitly stated, the expressions need not be
;; defined during the first pass. they must, however, be definable during
;; two sequential forward passes.
.p ;;
;; explanation of the <instruction line> :
;;
;; the instruction line contains four fields:
;;     1. bus, alu part
;;     2. do functions
;;     3. sequence part
;;     4. address part
;;
;; do functions:
;;          this field represents the do-function bits.
;;
;; sequence part:
;;          this field defines the sequencing through the microprogram.
;;          it defines the bits: 0-7, 38, 47 in the microinstruction word.
;;          there is a test in the microprogram assembler, which ensures
;;          that this field is consistently built up. for instance a
;;          condition is only allowed where relevant to the "next" code.
;;
;; address part:
;;          this field corresponds to the "next microaddress" field (bit
;;          49-59) in the microinstruction word. however, these bits are
;;          also used by the <bus, alu part> when producing dataconstants
;;          and sometimes during addressing the working register array.
;;          this double usage may give rise to the errormessage "constant
;;          conflicts".
;;
;; bus, alu part:
;;          this field defines the actions taking place on the bus and in
;;          the am2901 slice. it defines the bits 8-25, 27-37, 43, 45-46
;;          in the microinstruction word. also bits 49-59 may be defined
;;          by this field.
.p ;;
;; explanation of the bus, alu part:
;;
;;          this field is very complex, and it is necessary to have a deep
;;          knowledge to the am2901 slice and to the bus and register
;;          structure in order to understand this field. the field may be
;;          divided into a bus-part and an alu-part. two separate
;;          datatransfers may occur at any time in these two systems, or
;;          a common one may occur. tests are made to ensure that the bus
;;          is not used twice for the same bus, alu part. if the "bus
;;          source" subfield is empty, then the bus will take its input
;;          from the alu. the "alu dest" subfield defines if and where 
;;          the result in the alu should be stored within the alu. the
;;          "carry control" field together with "c:=" defines if and how
;;          the carry flip-flop should be updated:
;;                    c:= carry updated with bus bit 15
;;                    c:  carry updated with alu carry output
;;                    c<  carry updated with left shift output
;;                    c>  carry updated with right shift output
;;          please note that "c<" is only allowed together with the
;;          "alu dest": "<b> :=<" and "<b> :<<". likewise "c>" is only
;;          allowed together with "<b> :=>" and "<b> :>>".
;;
;;          the alu function and source defines the alu function in the
;;          alu. the function must be legal according to the function of
;;          the am2901 slice. the sequence of the operands does not refer
;;          to the "a-input" and the "b-input" in the slice. this means
;;          that the sequence of the operands is irrelevant for commuting
;;          functions. please note that "<x> clr <y>" logically means:
;;          ( -, <y> ) and <x>. "<x> ++ <b>" means <x> + <y> + 1.
;;          "<x> -- <y>" means <x> - <y> - 1. all other alu functions
;;          are selfexplanatory. registernames denoted by <a> and <b> refer
;;          to the a and b register selecter in the am2901 slice.
.p ;;
;;          an empty "alu function and source" denotes the zero-result
;;          produced by an "and" function and a "0,a" alu source. empty
;;          operands are interpreted as zero operands. if the "alu
;;          function and source" field simply contains one operand, then
;;          the alu source will be "0,q", "0,b", "0,a", or "d,0", and the
;;          alu function will be "+".
;;
;;          the "wreg1" and "wreg2" registers specify the working
;;          register array. a lot of different names are reserved for
;;          addressing the working register array, cf. the syntax diagrams.
;;          the second letter specifies the "carry control field":
;;               d: 0 pos 27-28: wreg bit 15 := bus bit 15
;;               m: 1 pos 27-28: wreg bit 15 := carry flip flop
;;               o: 2 pos 27-28: wreg bit 15 := one
;;               z: 3 pos 27-28: wreg bit 15 := zero
;;          the first and the third letter specify the "wreg-control" field
;;          as follows:
;;               r-<empty>:    7 pos 29-31
;;               z-<empty>:    6 pos 29-31
;;               r-w:          1 pos 29-31
;;               z-w:          0 pos 29-31
;;               r-x:          3 pos 29-31
;;               z-x:          2 pos 29-31
;;               r-c,0,1,2,3:  5 pos 29-31
;;               z-c,0,1,2,3:  4 pos 29-31
;;          the third digit 0, 1, 2, and 3 as a side effect sets the last
;;          two bits of the "next address" field to the specified value.
.p ;;
«eof»