Trailing-Edge
-
PDP-10 Archives
-
CFS_TSU04_19910205_1of1
-
update/ihssrc/ibmmac.mac
There are 9 other files named ibmmac.mac in the archive. Click here to see a list.
; IBMMAC - IBMSPL specific macros and definitions
;
;
; COPYRIGHT (c) 1979, 1980, 1981, 1982
; DIGITAL EQUIPMENT CORPORATION
;
; This software is furnished under a license and may be used
; and copied only in accordance with the terms of such license
; and with the inclusion of the above copyright notice. This
; software or any other copies thereof may not be provided or
; otherwise made available to any other person. No title to
; and ownership of the software is hereby transferred.
;
; The information in this software is subject to change
; without notice and should not be construed as a commitment
; by DIGITAL EQUIPMENT CORPORATION.
;
; DIGITAL assumes no responsibility for the use or reliability
; of its software on equipment which is not supplied by
; DIGITAL.
;
SUBTTL IBMMAC Version
UNIVERSAL IBMMAC
SEARCH GLXMAC
IMCVER==1 ; Major version number
IMCMIN==0 ; Minor version number
IMCEDT==30 ; Edit number
IMCWHO==0 ; Who edited last (0=DEC)
%%.IMC=:<VRSN. (IMC)>
SUBTTL Revision history
COMMENT &
Edit Date Who What
1-16 27-Apr-79 K. Reti Initial program development
17 4-May-79 KR Move NULL to IBMMAC, add REGS to it
20 15-May-79 KR Add NOTRACE support to NULL
comment some early macros
21 15-May-79 KR make pattern matching macros more defensive
about negative remaining counts (happens, but
I don't know why yet)
22 19-May-79 KR Don't preserve as many AC's on patterns (try
to lessen overhead
23 19-May-79 KR Undo edit 22 -- it didn't work
24 19-May-79 KR change version numbering symbol to not conflict
with GLXMAC's MACEDT
25 4-Jun-79 KR Add symbol for structure block value (.IBMST)
26 15-Jun-79 KR Add version number cracking macro
27 1-Nov-79 SMJ Heave subroutine documention macros and version
macros, replace version macros with something
more efficient.
30 6-Oct-80 KR Add PEND macro to match end of character string.
&
SUBTTL DYNAMIC DATA STRUCTURE MACROS
COMMENT &
The following macros allow easy definition of indexed data structures; they
are used in IBMSPL to define the format of the line blocks, the task blocks, the
active task list entries, and the port list entries. The fields within a block
are identified by a common prefix, e.g. T.ACS, T.ATE (from the task block). The
body of the symbol is limited to three characters by the fact that the structure
definition macros in GLXMAC generate their "structure" macro by appending a
character to the end of the symbol (surely the worst way for creating ambiguity!)
The definition of a block has two parts -- a start (DATAST macro) and one or
more entries ($ and $. macros). The DATAST macro specifies the prefix
to use on all entries that follow as well as an index register (which
is presumed to point to the beginning of the block).
The $ and $. macros generate symbols of the following forms:
prfx.body which is the structure definition symbol (see DEFSTR or
MSKSTR in GLXMAC); as such, its value is the mask of the
position of this element within a word.
prfx.body% which is the structure macro (again see DEFSTR or MSKSTR)
and contains the positioning information (including the
index register). Because the index register is included,
LOAD and STORE (and other structure-invoking macros) should
leave their position fields blank, e.g. LOAD S1,,T.FOO.
prfx%body is a macro containing "merely offset(index reg)", so
that instructions which do not have structure manipulating
equivalents can be coded without reference to the
index register, e.g. IMUL S1,T%FOO.
prfx$body is a symbol containing just the word offset of this
particular entry based on the index register; this is
useful if you are using another register to do the
indexing; it can be used with the prfx.body mask in
structure references the hard way (i.e. by hand) for
example LOAD S1,T$FOO(P1),QQ where QQ was previously
equated to T.FOO. [The more obvious construct
LOAD S1,T$FOO(P1),T.FOO doesn't work because, since
T.FOO% exists, the structure macro appends the supplied
position info (T$FOO(P1)) to the stored position info
(T$FOO(R1)) with a "+" to achieve an undesired result.]
The $ and $. macros are identical except that $. entries merely redefine
previous $ entries; thus a fullword can be given a name, and then the two
halfwords comprising it can likewise be named. Unfortunately, only one level
of subsetting exists at the moment.
&
DEFINE DATAST(PRE,IDX)<
DEFINE $ (NAM,SIZ,CNT,LVL) <
$$ PRE,NAM,\..WD,IDX,\..BT,SIZ,CNT,LVL
>;end DEFINE $
DEFINE $$. (NAM,SIZ,OB,OW,BT,WD,CNT) <
$$$. PRE,NAM,OB,OW,BT,WD,IDX,SIZ,CNT
>;end DEFINE $$.
DEFINE $$$$ (NAM,BIT,SIZ,WRD) <
$$$$$ PRE,NAM,BIT,SIZ,IDX,WRD
>;end DEFINE $$$$
..WD==0
..BT==-1
>;end DEFINE DATAST
DEFINE $$ (P,N,W,I,B,S,C,L) <
..TM==0
IFB <S>,<
IFB <N>,<
IFGE ..BT,<
..WD==..WD+1
..BT==-1
>;end IFN ..BT
..TM==1
>;end IFB N
>;end IFB S
IFE ..TM,<
..CT==1
IFNB <C>,<..CT==C>
..SZ=^D36
IFNB <S>,<..SZ==S>
..OB==..BT
..OW==..WD
REPEAT ..CT,<
..BT=..BT+..SZ
IFG <..BT-^D35>,<
..WD=..WD+1
..BT=..SZ-1
>;end IFG <..BT-^D35>
IFNB <N>,<
IFE ..TM,<
$$$$ N,\..BT,\..SZ,\..WD
..RX==10
RADIX ^D10
DEFSTR (P'.'N,P'$'N'('I),\..BT,\..SZ)
RADIX ..RX
>;end IFE ..TM
..TM==..TM+1
>;End IFNB N
IFNB <L>,<$$$ L,\..OB,\..OW,\..BT,\..WD>
>;End Repeat ..CT
>;End IFE ..TM
>;End DEFINE $$
DEFINE $$$ (L,OB,OW,BT,WD) <
DEFINE $. (NAM,SIZ,CNT) <
$$. NAM,SIZ,OB,OW,BT,WD,CNT
>;end DEFINE $.
..BT1==OB
..WD1==OW
>;end DEFINE $$$
DEFINE $$$. (P,N,OB,OW,B,W,I,S,C) <
..TM1==0
IFB <S>,<
IFB <N>,<
..WD1==..WD1+1
IFG <..WD1-W>,<PRINTX ?Sublevel overflowed top for P'.'N>
..BT1==0
IFE <..WD1-W>,<
IFG <..BT1-B>,<PRINTX ?Sublevel overflowed top bits for P'.'N>
>;end IFE <..WD1-W>
..TM1==1
>;end IFB,<N>
>;end IFB,<S>
IFE ..TM1,<
..CT1==1
..SZ1==^D36
IFNB <C>,<..CT1==C>
IFNB <S>,<..SZ1==S>
REPEAT ..CT1,<
..BT1==..BT1+..SZ1
IFG <..BT1-^D35>,<
..WD1==..WD1+1
IFG <..WD1-W>,<PRINTX ?Sub level overflows top for P'.'N>
..BT1==..SZ1-1
IFE <..WD1-W>,<
IFG <..BT1-B>,<PRINTX ?Sub level overflows top bits for P'.'N>
>;end IFE <..WD1-W>
>;end IFG <..BT1-^D35>
IFNB <N>,<
IFE ..TM1,<
$$$$ N,\..BT1,\..SZ1,\..WD1
..RX==10
RADIX ^D10
DEFSTR (P'.'N,P'$'N'('I),\..BT1,\..SZ1)
RADIX ..RX
>;end IFE ..TM1
..TM1==..TM1+1
>;end IFNB <N>
>;end REPEAT ..CT1
>;end IFE ..TM1
>;end DEFINE $$$.
DEFINE $$$$$ (P,N,B,S,I,W) <
P'$'N=='W
DEFINE P'%'N<P'$'N('I')>
>;end DEFINE $$$$$
SUBTTL STRUCTURE SKIP MACROS
DEFINE .SKP (CND,AC,Y,STR,%NO) <
CAIA
JRST %NO
LOAD .SAC,Y,STR
IFNB <AC>,<
SKIP'CND AC,.SAC
>;end IFNB <AC>
IFB <AC>,<
SKIP'CND .SAC
>;end IFB <AC>
%NO:
>;end DEFINE .SKP
DEFINE .SKPGN (CND) <
IRP CND,<
DEFINE SKP'CND (AC,Y,STR) <
.SKP (CND,AC,Y,STR)
>;end DEFINE SKP'CND
>;end IRP CND
>;end DEFINE .SKPGN
.SKPGN <E,N,L,LE,G,GE>
SUBTTL Miscellaneous Macros
; Macro to make a cross reference entry
DEFINE REF(ARG) <
IRP ARG,<
..RF==ARG
>;end IRP ARG
PURGE ..RF
>;end DEFINE REF
COMMENT &
In the following macros T1 generally holds the displacement (in bytes)
within the string of where to start matching; T2 holds number of characters
left in string (from T1); T3 holds, when calling a pattern, the number
of characters that the pattern must match (minimum) to succeed and P4
holds the address of the start of the string (off which T1 is the displacement).
The macro PAT defines a "pattern", which is really a subroutine which returns
true or false (and as a side-effect stores some values of what matched what) based
on whether the pattern matches the string pointed to by T2 and P4. Its single
argument is a list of pattern "elements". The first element must be either
PBEG or PFLT, for an anchored or non-anchored (floating) pattern match, respectively.
Successive elements can be any combination of the following:
PEX This is an element that causes an exact match of a pattern
PARB This is an element that causes any number of occurences of a pattern
to match
PSPN This is an element which matches as many characters as possible from a
string (in any order). Note this does not work on patterns at the moment
POR This is an element which matches any of a list of patterns.
There are also several macros to make primitive patterns which can be the
arguments to some of the "pattern elements" listed above:
PCHR Makes a pattern that matches 1 character (the argument is the character)
PSTR Makes a pattern that matches a character string (the argument is the
address of a word whose LH=length of string, and RH=address of string)
&
DEFINE PAT (LIST) <
ZZZ==ZZZ+1
ZZ==0
$SAVE <T4,P1,P2,P3,P4,S1,S2,P-1> ;;save registers we need
PUSH P,T1 ;;save start position for success
MOVE P-1,P ;;save current position of stack
PATGO INIT ;;go to the first pattern
POP P,T1 ;;clean up stack
JRST .RETF ;;if we get here, we have failed
IRP LIST < ;;generate all the elements
PAT. LIST
>;;end IRP LIST
PATTG ;;generate tag for last PATGO
MOVE P,P-1 ;;restore stack
MOVE T3,T1 ;;get current position
POP P,T1 ;;restore original position
SUB T3,T1 ;;subtract start to get chars matched
ADD T2,T3 ;;fix count remaining also
JRST .RETT ;;and indicate success
>;end DEFINE PAT
DEFINE PATGO (SPEC) < ;;macro to go to next pattern element
PATGO. \ZZ,\ZZZ,SPEC ;;generate call to ..Pn
>;end DEFINE PATGO
DEFINE PATGO. (PNUM,NUM,SPEC) < ;;macro to PUSHJ to next pattern element
IFB <SPEC>,<
PUSHJ P,.PSTR2 ;;update pointers
>;END IFB <SPEC>
IFNB <SPEC>,<
PUSHJ P,.PSTR3
>;END IFNB <SPEC>
PUSHJ P,%'PNUM'P'NUM ;;call next element
>;end DEFINE PATGO.
DEFINE PAT. (ENTRY) < ;;macro to build body of pattern element
PAT.. ENTRY
>;end DEFINE PAT.
DEFINE PAT.. (TYPE,ARG) < ;;macro to generate call to element
PATTG
TYPE ARG
>;end PAT.
DEFINE PATTG < ;;defines label of current element and increments counter (so PATGO will go to next)
PATTG. \ZZ,\ZZZ
ZZ==ZZ+1
>;end DEFINE PATTG
DEFINE PATTG. (PNUM,NUM) < ;;actually build the tag
%'PNUM'P'NUM:
>;end DEFINE PATTG.
DEFINE PBEG (A) < ;;Anchored match beginning element
PATGO ;;go to first pattern
$RET ;;if we get here, we're not going to match
>;end PBEG
DEFINE PFLT (A) < ;;Unanchored match beginning element
PATGO ;;go to first pattern
QQ==. ;;save address right after last PUSHJ to next pattern
SOS T2 ;;if we fail, decrement count remaining
JUMPLE T2,.RETF ;;if we are all done, return failure
AOS T1 ;;increment starting position
IFDEF FTDEBUG <
SKIPG T1 ;;make sure position is positive
HALT ;;error if not
>;end IFDEF FTDEBUG
JRST QQ-1 ;;else try again at next character position
>;end DEFINE PFLT
DEFINE PEX (A,VAL) < ;;Exact match of pattern element
$SAVE <T1,T2,P3> ;;save registers we need
MOVE P3,T3 ;;save must match count
SETZ T3, ;;clear must match for this call
PUSHJ P,A ;;call pattern
JUMPF .RET ;;if it fails, propagate failure
CAMGE T3,P3 ;;did we match enough?
$RET ;;no, propagate error
PVALSV VAL ;;yes, store value info if necessary
; ADD T1,T3 ;;otherwise bump starting point
; SUB T2,T3 ;;and decrement count remaining
PATGO ;;and go to next element
$RET ;;propagate failure
>;end DEFINE PEX
DEFINE PSTR (A) < ;;make a pattern to match a string
$SAVE <P1,P2,P3,T4> ;;save registers
MOVE P2,A ;;copy address of string pointer
HLRZ P3,P2 ;;get length into P3
CAMLE T3,P3 ;;is must match greater than length?
JRST .RETF ;;yes, too bad
MOVE T4,P3 ;;copy length again
HRLI P2,440700 ;;make P2 a byte pointer to string
PUSHJ P,.PSTR0 ;;setup byte pointer to test string
ILDB S1,P1 ;;get character from test string
ILDB S2,P2 ;;and one from constant string
CAME S1,S2 ;;skip if they are equal
JRST .RETF ;;failure if not
SOJG P3,.-4 ;;loop over all characters of constant string
MOVE T3,T4 ;;copy how many we matched
JRST .RETT ;;and return success
>;end DEFINE PSTR
DEFINE PCHR (A) < ;;make pattern to match a character
CAILE T3,1 ;;do we have to match more than 1
JRST .RETF ;;yes, too bad
$SAVE <P1,T4> ;;save registers
PUSHJ P,.PSTR0 ;;set up byte pointer to source
ILDB S1,P1 ;;get current character
CAIE S1,"A" ;;is it ours?
JRST .RETF ;;no, fail
MOVEI T3,1 ;;yes, we matched 1
JRST .RETT ;;return success
>;end DEFINE PCHR
DEFINE PARB (A,B<0>,C<-1>,VAL) < ;;arbitrary number of occurences of a pattern
$SAVE <T1,T2,P4> ;;save registers
MOVEI T3,B ;;get minimum to match
QQ==0
IFNB <VAL>,<QQ==PVALSZ>
JUMPE T3,.+3+QQ ;;if we don't have to, don't try
PUSHJ P,A ;;try to match some
JUMPF .RET ;;propagate failure if cannot
PVALSV VAL ;;store value if necessary
; ADD T1,T3 ;;new start
; SUB T2,T3 ;; and count
PUSH P,T1
PUSH P,T2
PUSH P,T3
PATGO
POP P,T3
POP P,T2
POP P,T1
AOS T3
QQ==0
IFG C,<
QQ==2
CAILE T3,C
$RET>
CAMLE T3,T2
$RET
JRST .-<15+QQ>
>;end DEFINE PARB
DEFINE PSPN (A,B<-1>,VAL) < ;;maximum number of characters selected from set
CAMLE T3,T2 ;;must we match more than left in string?
JRST .RETF ;;yes, fail
$SAVE <T1,T2,P1,P2,P3,T4> ;;save some registers
PUSHJ P,.PSTR0 ;;set up input byte pointer
SETZ T4, ;;initialize counter
MOVE P2,A ;;get address of string and length
HLRZ P3,P2 ;;copy length to P3
HRLI P2,440700 ;;make into byte pointer
PUSH P,P3 ;;save count
PUSH P,P2 ;;save byte pointer
QQ==0 ;;how much the next two instructions add
;; if not included
IFG B,< CAIL T4,B ;;have we reached upper limit?
JRST .+10 ;;yes, don't add any more
QQ==2> ;;how much these instructions add if included
ILDB S1,P1 ;;get byte from string
MOVE P2,0(P) ;;get initial byte pointer for span characters
MOVE P3,-1(P) ;;get count of span characters
ILDB S2,P2 ;;get a span character
CAMN S1,S2 ;;see if this character fits
AOJA T4,.-<5+QQ> ;;yes, increment count and get another string character
SOJG P3,.-3 ;;no, get another span character
POP P,S1
POP P,S1
SKIPE T4 ;;if none, fail
CAMGE T4,T3 ;;was number we got less than desired?
JRST .RETF ;;yes, fail
MOVE T3,T4 ;;no, get number we matched
PVALSV VAL ;;save value matched
; ADD T1,T3 ;;update start by length
; SUB T2,T3 ;;calculate new length
PATGO ;;go to next element
JRST .RET ;;if it fails, propagate failure
>;end DEFINE PSPN
DEFINE POR (A,B,VAL) < ;;match any of a set of patterns
$SAVE <P1,P2,P3,S1> ;;save some registers ?? S1 only to test
IFNB <B>,<SETOM B> ;;if index given, set to -1
MOVE P3,T3 ;;copy must match
DMOVE P1,T1 ;; as well as start and length
IRP A,< DMOVE T1,P1 ;;for each pattern, start at beginning
MOVE T3,P3 ;; with appropriate length
PUSHJ P,A ;;test that pattern
IFNB <B>,<AOS B> ;;keep track of index
QQ==0 ;;assume no extra code
IFNB <VAL>,<QQ==PVALSZ> ;;if extra code included, count it
JUMPF .+3+QQ ;;if it failed, go to next pattern
PVALSV VAL ;;save value that matched
; ADD T1,T3 ;;update start
; SUB T2,T3 ;; and length remaining
PATGO ;;go to next pattern
>;end IRP A
JRST .RETF ;;if we get here, fail
>;end DEFINE POR
DEFINE PEND <
JUMPN T2,.RETF
PATGO
>;end DEFINE PEND
DEFINE PVALSV (ARG) < ;;macro to save matched string address
PVALSZ==2 ;;words of code generated by this macro
IFNB <ARG>,<
HRLM T3,ARG ;;save length in LH
HRRM T1,ARG ;; and address in RH
>;end IFNB <ARG>
>;end DEFINE PVALSV
SUBTTL . REGS -- standard register names macro
DEFINE REGS <
DEFINE R(N) < ;;Macro to generate R0,R1,...
R'N==N
>;end DEFINE R
..==0 ;Counter
REPEAT 20,<
R \.. ;generate register name
..==..+1
>;end REPEAT 20
>;end DEFINE REGS
SUBTTL . Global Symbols
.IBMST==400000 ;code to identify structure block in
; queue info file
END