🚀 go-pugleaf

icking@gmdzi.gmd.de (Werner Icking) writes:

[text deleted]

You have taken a simple example:

>R0        EQU   0
>HWORD     DS    H
>          LH    R0,HWORD
>          $IF   ZERO
>          LTR   R0,R0
>          $THEN

And coded it using another method:

>R0       #EQUR  0
>HWORD    DS     H
>         IF     HWORD,EQ,0,THEN

Try THIS one, which is slightly more difficult:

           $IF   NOT-EQUAL           if does not begin with
             CLI   0(R2),X'40'         a blank
           $AND  NOT-EQUAL           nor
             CLI   0(R2),X'05'         a tab
           $AND  POS                 and
             MVI   PROCESS,0           (header start so clear flag)
             BAL   R14,TESTHDR         this is a header we process
           $THEN ,                   then
             MVI   PROCESS,1           process this header
           $END  ,

Then this one which is more difficult yet:

           $IF   ON                  if
             TM    PROCESS,1           this header is being processed
           $AND  HIGH                and
             STM   R2,R3,ORIGREC       save original address and length
             BAL   R14,FIXIT           processing causes
             CL    R3,=F'80'           an overflow
           $AND  HIGH                and
             BAL   R14,SQUEEZE         squeezing will not fix
             CL    R3,=F'80'           the overflow
           $THEN ,                   then
             LM    R2,R3,ORIGREC       restore original
           $END  ,

And then this one which is starting to really get hard:

         $IF   POS                 if (the following test is positive)
                                                                 SPACE
           $IF   ZERO                if
             TM    8(R5),B'10000000'   upper-right value is positive
           $THEN ,                   then
             LCDR  FPR2,FPR4           test lower-left for negative
           $ELSE ,                   else
             LTDR  FPR2,FPR4           test lower-left for positive
           $END  ,
                                                                 SPACE
         $OR   POS                 or (the following test is positive)
                                                                 SPACE
           $IF   ZERO                if
             TM    0(R5),B'10000000'   upper-left value is positive
           $THEN ,                   then
             LCDR  FPR2,FPR0           test lower-right for negative
           $ELSE ,                   else
             LTDR  FPR2,FPR0           test lower-right for positive
           $END  ,
                                                                 SPACE
         $THEN ,                   then
           EX    *-*,PLOTOI(R7)      OI 0(R6),B'one bit'
         $END  ,

And finally this one which also looks rather hard:

         $IF   EQUAL               if
           CLI   0(R10),X'FF'        there are no arguments
         $OR   NOT-CC0             or
           $IF   EQUAL               ( if                             )
             CLI   8(R10),X'FF'      (   there was just one argument  )
           $OR   ZERO                ( or                             )
             LM    R2,R3,8(R10)      (   (get position argument)      )
             LTR   R2,R2             (   the pos argument was omitted )
           $OR   NOT-CC0             ( or                             )
             DECINT ,                (   >>> the number cannot convert)
           $THEN ,                   ( then                           )
             LA    R1,1              (   assume position to be 1      )
           $END  ,                   ( endif                          )
           LM    R2,R3,0(R10)        ( get address, length of list    )
           BAL   R14,FINDELEM        >>> the element cannot be found
         $THEN ,                   then
           SLR   R3,R3               use a null element
         $END  ,                   endif

>We started this type of programming in the late 60-th -- and stopped it
>some years ago. If anybody is interested I will look for a description
>and the corresponding macro-library.

I'd like to see the description.  I'd suggest posting it.

What is the difference between these methods?  Well obviously a lot of
detail difference.  I don't know for sure what Werner's method really is,
but it looks syntactically like one I read about in an assembler text.
Unfortunately the one in that text had limitations that restricted the
scope of what kinds of conditions could be tested, and had an even more
primitive looping macro setup that required things be expressed in terms
of BXH/BXLE conditions only.  I did not include any loops in the examples
above, but I can include them.  BTW, the "DECINT" in example 4 above is a
macro that calls a subroutine that is generated elsewhere by the same macro,
OR generates inline code in place, depending on the setting of a global
variable by one of yet other macros (INLINE, INTORG, EXTABS, etc.).
--
 /***************************************************************************\
/ Phil Howard -- KA9WGN -- phil@ux1.cso.uiuc.edu   |  Guns don't aim guns at  \
\ Lietuva laisva -- Brivu Latviju -- Eesti vabaks  |  people; CRIMINALS do!!  /
 \***************************************************************************/