Personal tools
You are here: Home Projects SETL LITTLE Source code GRM: Grammars for SYN and LITTLE.
Document Actions

GRM: Grammars for SYN and LITTLE.

by Paul McJones last modified 2021-03-17 19:58

GRM: Grammars for SYN and LITTLE. By Edith Deak and David Shields.

       1 .=member intro
       2 /*
       3
       4  $$          $$$$$$$$$$  $$$$$$$$$$  $$$$$$$$$$  $$          $$$$$$$$$$
       5  $$          $$$$$$$$$$  $$$$$$$$$$  $$$$$$$$$$  $$          $$$$$$$$$$
       6  $$              $$          $$          $$      $$          $$
       7  $$              $$          $$          $$      $$          $$
       8  $$              $$          $$          $$      $$          $$$$$$
       9  $$              $$          $$          $$      $$          $$$$$$
      10  $$              $$          $$          $$      $$          $$
      11  $$              $$          $$          $$      $$          $$
      12  $$$$$$$$$$  $$$$$$$$$$      $$          $$      $$$$$$$$$$  $$$$$$$$$$
      13  $$$$$$$$$$  $$$$$$$$$$      $$          $$      $$$$$$$$$$  $$$$$$$$$$
      14
      15
      16                      $$$$$$$$   $$$$$$$$$   $$      $$
      17                     $$$$$$$$$$  $$$$$$$$$$  $$$$  $$$$
      18                     $$          $$      $$  $$ $$$$ $$
      19                     $$          $$      $$  $$  $$  $$
      20                     $$   $$$$$  $$$$$$$$$$  $$  $$  $$
      21                     $$   $$$$$  $$$$$$$$$   $$      $$
      22                     $$      $$  $$   $$     $$      $$
      23                     $$      $$  $$    $$    $$      $$
      24                     $$$$$$$$$$  $$     $$   $$      $$
      25                      $$$$$$$$   $$      $$  $$      $$
      26
      27
      28                 syntax generator for the little system
      29
      30
      31                                   by
      32
      33                               edith deak
      34                             david shields
      35
      36
      37          this software is part of the little programming system
      38
      39              direct inquiries, comments and criticisms to
      40
      41                       little project coordinator
      42                      computer science department
      43               courant institute of mathematical sciences
      44                           251 mercer street
      45                       new york, new york  10012
      46                                u. s. a.
      47
      48
      49
      50 this file contains the grammars for syn and little
      51 and the pt-- macro definitions required for the syn 'asm' option.
      52 */
      53
      54 deck (upd member) names are
      55
      56 syngrmr   syn grammar
      57 ltlgrmr   little grammar
      58 pt10      macros for s10
      59 pt32      macros for s32
      60 pt37      macros for s37
      61 pt66      macros for s66
       1 .=member mods
       2 $ --- all mods are to include self description after mods.2 ---
       3
       4 $    (none)    d. shields          19-nov-79           level 79323
       5 $
       6 $    this file was formerly part of the syn program file, but has been
       7 $    made into a separate file, to avoid confusion that resulted from
       8 $    attempts to compile all of prior syn file.
       9
       1 .=member syngrmr
       2      $   syn grammar in syn grammar format.
       3      +*  goto = - go to ** $ for actions which are just jumps.
       4        +*  q3(a,b,c) = a b c  **
       5        +*  macdef(text) = q3(+,*text*,*)  **
       6        +*  macdrop(mname) = macdef(mname=)  **
       7
       8      +*  defc(nam) =    $ define constant identifier
       9          macdef(nam = zzyz) **
      10 .=zzyorg z
      11
      12 $ l e x i c a l   c o d e s
      13
      14 $ lexical codes for the lexical classes of the self-defining
      15 $ grammar which drives this program.
      16
      17      defc(lexc_name)
      18      defc(lexc_string)     $ quoted string
      19      defc(lexc_int)        $ integer
      20      defc(lexc_nonslash)    $ not a slash '/'
      21      defc(lexc_noneq)    $ not an '='
      22      defc(lexc_brlitdir)   $ pseudo token for direct item.
      23
      24      +*  lexc_max = lexc_noneq **
      25
      26      $   literal codes used to parse grammar.
      27 .=zzyorg  zzyz
      28      defc(lc_ltsym)     $ '<'
      29      defc(lc_gtsym)     $ '>'
      30      defc(lc_eqsym)     $ '='
      31      defc(lc_divide)     $ '/'
      32      defc(lc_times)     $ '*'
      33      defc(lc_lparen)     $ '('
      34      defc(lc_rparen)     $ ')'
      35      defc(lc_minus)     $ '-'
      36      defc(lc_plus)     $ '+'
      37      defc(lc_set)     $ 'set'
      38      defc(lc_comma)     $ '
      39      defc(lc_ok)     $ 'ok'
      40      defc(lc_b)     $ 'b'
      41      defc(lc_option)     $ 'option'
      42      defc(lc_litmap)     $ 'litmap'
      43      defc(lc_lexmap)     $ 'lexmap'
      44      defc(lc_epc)     $ 5q'epc'
      45      defc(lc_mode)     $ 6q'mode'
      46      defc(lc_end)     $ 'end'
      47      defc(lc_op1)   $ 'op1'
      48      defc(lc_op2)   $ 'op2'
      49      defc(lc_op3)   $ 'op3'
      50      defc(lc_op4)   $ 'op4'
      51      defc(lc_op5)   $ 'op5'
      52
      53      lexmap
      54          'name' = lexc_name
      55          'string' = lexc_string
      56          'int' = lexc_int
      57          'nonslash' = lexc_nonslash
      58          'noneq' = lexc_noneq
      59          'brlitdir' = lexc_brlitdir
      60
      61      +* deflit(a,b) = a = b **
      62      litmap
      63      deflit('<'         , lc_ltsym)
      64      deflit('>'         , lc_gtsym)
      65      deflit('='         , lc_eqsym)
      66      deflit('/'         , lc_divide)
      67      deflit('*'         , lc_times)
      68      deflit('('         , lc_lparen)
      69      deflit(')'         , lc_rparen)
      70      deflit('-'         , lc_minus)
      71      deflit('+'         , lc_plus)
      72      deflit('set'       , lc_set)
      73      deflit(','         , lc_comma)
      74      deflit('ok'        , lc_ok)
      75      deflit('b'         , lc_b)
      76      deflit('option'    , lc_option)
      77      deflit('litmap'    , lc_litmap)
      78      deflit('lexmap'    , lc_lexmap)
      79      deflit(5q'epc'    , lc_epc)
      80      deflit(6q'mode'    , lc_mode)
      81      deflit('end'       , lc_end)
      82
      83
      84 
      85      =      +clauses /
      86
      87 
      88      =   'end' (synexit(0))  /  -
      89
      90      =    +clauses  /  -1
      91
      92
      93 
      94      =   '<' <*name> '>' (gnam) 
      95        /  -2  -3      -4
      96
      97 
      98      =   '='   /  -b -5
      99
     100 
     101      =   (gdir)  '/' (goto g_alt)  (galt)
     102        /                     -6
     103
     104 
     105      =   <*string> (glit)  /  -
     106
     107      $   if the direct part is not a string, it must begin with one
     108      $   several literals.  rather than testing for each literal in
     109      $   turn, the grammar uses a pseudo lexical type, brlitdir.
     110      =   <*brlitdir>   +dirlt  +dirlp  +dirmi  +dirpl  +dirst
     111                      +dirok  +dirop
     112        /  -b
     113
     114    $ here after seeing < starting direct item.
     115      =    '*' <*name> '>' (glex)
     116        /   -   -7     -8
     117
     118      =   <*name> '*' '>' (goto g_sev)
     119        /  -9      -   -10
     120
     121      $   here after seeing '<*name'.
     122      =   '>' (goto g_sub)  /  -11
     123
     124   $ here after seeing '(' in direct item.
     125      =   (gact) ')'
     126        /         -12
     127
     128   $ here after '-' starting direct item.
     129      =   <*name> (goto g_jif)  /  -
     130
     131      =   <*int> (goto g_err)  /  -22
     132
     133   $ here after '+' starts direct item.
     134      =   <*name> (goto g_jmp)  /  -13
     135
     136    $ here when 'set' starts direct item.
     137      =   '(' <*int> (goto g_saveint) ',' <*int> ')' (gset)
     138        /  -14 -15                     -16 -17    -18
     139
     140   $ here when 'ok' direct item.
     141      =   (goto g_ok)  /
     142
     143    $ here when 'op1' - 'op5' starts direct item.
     144      =   '(' <*int> ')' (goto g_opn)
     145        /  -19 -20    -21
     146
     147
     148 
     149      =   '-' 'b'(goto g_bak)
     150        /  -b  -
     151
     152          $   have just seen '-'.
     153      =   <*int> (goto g_err)
     154        /  -
     155
     156      =   <*name>  (goto g_jmp)  /  -
     157
     158      =   (goto g_next) ok  /
     159
     160 
     161      =   'option'   /  -
     162
     163      =   'lexmap' set(3, 1)   /  -
     164
     165      =   'litmap' set(4, 1)   /  -b
     166
     167
     168 
     169      =   6q'mode' '=' <*int> (goto g_mode)
     170        /  -        -23 -24
     171
     172      =   5q'epc' '=' <*int> (goto g_epc)
     173        /  -b       -23 -24
     174
     175 
     176      =   <*string> '=' <*int> (goto g_lexmap)
     177        /  -b      -23  -24
     178
     179 
     180      =   <*string> '=' <*int> (goto g_litmap)
     181        /  -b      -23  -24
     182
     183      $   error section.     report error.  then continue by skipping to
     184      $   the start of a clause.  do this by skipping to a slash, then
     185      $   skipping to the equal symbol which begins next alternate, then
     186      $   absorbing one or more definers.
     187
     188 
     189      =    '/'   +clauses
     190        /              -b
     191
     192 
     193      =   <*nonslash>  /  -b
     194
     195 
     196      =   <*noneq>  /  -b
     197
     198 end
       1 .=member ltlgrmr
       2      $   little grammar in syn grammar format.
       3  /*   l i t t l e    g r a m m a r    */
       4      +* yes = 1 **  +* no = 0 **
       5
       6      +*  q3(a, b, c) = a b c **
       7      +*  macdef(text) = q3(+, *text*, *) **
       8      +*  macdrop(name) = macdef(name=) **
       9
      10      +*  defc(nam) = $ define constant.
      11          macdef(nam = zzyz) **
      12
      13      $   lexical map.
      14
      15 .=zzyorg z
      16      defc(lexc_name)
      17      defc(lexc_contok)
      18      defc(lexc_cfi)
      19      defc(lexc_dfi)
      20      defc(lexc_filekwd)
      21      defc(lexc_statwd)
      22      defc(lexc_dbugtok)
      23      defc(lexc_ertok)
      24      defc(lexc_exprtok1)
      25      defc(lexc_exprtok2)
      26      defc(lexc_termtok1)
      27      defc(lexc_termtok2)
      28      defc(lexc_cargstk)
      29      defc(lexc_binop)
      30      defc(lexc_unop)
      31
      32      lexmap
      33
      34      'name'      = lexc_name
      35      'contok'    = lexc_contok
      36      'cfi'       = lexc_cfi
      37      'dfi'       = lexc_dfi
      38      'filekwd'   = lexc_filekwd
      39      'statwd'    = lexc_statwd
      40      'dbugtok'   = lexc_dbugtok
      41      'ertok'     = lexc_ertok
      42      'exprtok1'  = lexc_exprtok1
      43      'exprtok2'  = lexc_exprtok2
      44      'termtok1'  = lexc_termtok1
      45      'termtok2'  = lexc_termtok2
      46      'cargstk'   = lexc_cargstk
      47      'binop'     = lexc_binop
      48      'unop'      = lexc_unop
      49
      50
      51      $   literal map.
      52
      53 .=zzyorg z
      54      +*  lc_semicolon=  10 **
      55      +*  lc_goin     =  18 **  $ 'in', not '.in.'
      56      +*  lc_go       =  23 **
      57      +*  lc_cont     =  24 **
      58      +*  lc_quit     =  25 **
      59      +*  lc_to       =  32 **
      60      +*  lc_eqsym    =  46 **  $ =
      61      +*  lc_ltsym    =  47 **  $ <
      62      +*  lc_minus    =  51 **  $ -
      63      +*  lc_divide   =  53 **   $ /
      64      +*  lc_lparen   =  67 **  $ (
      65      +*  lc_rparen   =  68 **  $ )
      66      +*  lc_comma    =  69 **
      67      +*  lc_colon    =  70 **
      68      +*  lc_then     =  71 **
      69      +*  lc_by       =  72 **
      70      +*  lc_index    =  73 **
      71      +*  lc_flow     =  74 **
      72      +*  lc_stores   =  75 **
      73      +*  lc_entry    =  76 **
      74      +*  lc_limit    =  92 **
      75
      76      litmap
      77
      78      ';'           = lc_semicolon
      79      'in'          = lc_goin
      80      'go'          = lc_go
      81      'cont'        = lc_cont
      82      'quit'        = lc_quit
      83      'to'          = lc_to
      84      '='           = lc_eqsym
      85      '<'           = lc_ltsym
      86      '-'           = lc_minus
      87      '/'           = lc_divide
      88      '('           = lc_lparen
      89      ')'           = lc_rparen
      90      ','           = lc_comma
      91      ':'           = lc_colon
      92      'then'        = lc_then
      93      'by'          = lc_by
      94      'index'       = lc_index
      95      'flow'        = lc_flow
      96      'stores'      = lc_stores
      97      'entry'       = lc_entry
      98      'limit'       = lc_limit
      99
     100  $   macros used to write actions.
     101
     102      +*  az = 3 **
     103      +*  fc = 4 **
     104      +*  an = 5 **
     105      +*  tm = 6 **
     106      +*  ax = 7 **
     107
     108      +*  goto = - go to **
     109      +*  cl(proc, i) = op1(i) (proc(pi)) **
     110
     111      +*  brlit(i) = op2(i) **
     112      +*  genop(i) = op3(i) **
     113      +*  xbeg = op4(0) **  $ begin expression.
     114      +*  xfin = op5(0) **  $ finish expression.
     115
     116
     117
     118 /*               branch on literal                                   */
     119 /* action brlit examines the next literal and branches to one
     120  of the following go to's according to the literal's entry in table
     121  'littab'.  note that the first go to in the series is
     122  executed if the literal has no entry in the table. */
     123
     124 /* branch on literal for non-simple statements follows:   */
     125 
     126      =   brlit(1) +simps +ifs  +whils +untls +dos
     127          +ends +elses +sizes +dimss +datas
     128         +statme +nmsets +aces  +reals +elseifs
     129          +subrst +fnctst +label +progst /
     130
     131      = cl(gensub, 5) <*name> +subr / -79
     132
     133 
     134      =   cl(gensub, no) <*name> +subr / -88
     135 
     136      =   cl(gensub, yes) <*name> +subr / -58
     137 
     138      =   cl(gensub, 2) '(' <*name>  ')'
     139                    cl(gensub, 3) +rest
     140        /                -   -89               -23
     141
     142      =   cl(gensub, 4) +rest /
     143
     144 
     145      =   <*name> '('  ')' cl(gengosl,1) '/' +statme
     146        /  -20      -   -17    -18              -19
     147
     148      =   cl(gengol,28) '/' +statme
     149        /               -19
     150
     151 
     152      =   ',' <*name>
     153        /  -b  -78
     154
     155 
     156      =   cl(genif,1)  'then' cl(genif,2) +statme
     157        /             -74     -
     158
     159      =   'quit' cl(genif,10) +rest
     160        /  -
     161
     162      =   'cont' cl(genif,11) +rest  /  -
     163
     164      =   'go' 'to' <*name> '('  ')' <*cargstk> ';' cl(genif,9)
     165                                 +statme
     166        /  -    -66  -67  -ifgolc  -64 -65  -ifgospc  -ifgospc
     167
     168      =   cl(genif,3)  cl(genif,4) +rest  /  -16
     169
     170
     171    = cl(genif,6) +rest /
     172
     173  = cl(genif,3) 'in'  'to'  cl(gengosl,3)
     174                                                             cl(genif,4)
     175           /              -60    -62   -61   -63
     176
     177 
     178      =   cl(genwhil,1)  cl(genwhil,2) +rest  /  -100
     179
     180    = cl(genuntl,1)  cl(genuntl,2) +rest / -91
     181
     182 
     183      =   cl(gendo,1) <*name> '='  'to'  'by'  +rest
     184        /             -47     -44 -45    -43  -46    -    -48
     185      =    cl(gendo,2)  +rest /
     186 
     187      =   '-'  cl(gendo,3)
     188        /  -   -b
     189      =    cl(gendo,4)  /  -b
     190
     191     = (genend)  +rest  /
     192
     193    = cl(genif,5)  +statme  /
     194
     195 
     196      =   cl(genif,7)  'then' cl(genif,8) +statme
     197        /             -50     -49
     198
     199 
     200      =    +rest  /  -86
     201
     202 
     203      =   <*name> '('  ')' (gensiz)
     204        /  -b  -85  -84  -87
     205
     206 
     207      =  ','   /  -b  -86
     208
     209 
     210      =   +rest  / -41
     211    = <*name> '('  ')' (gendim) /
     212             -b -40  -39  -42
     213
     214 
     215      =  ','   / -b  -41
     216
     217    = <*name> '('  ')' cl(gendat,1) +datrest /
     218             -34  -  -35  -36
     219      =   cl(gendat,2)  +datrest   /
     220  = '='    cl(gendat,4) ':' +datas /
     221             -32  -33  -rest
     222   =  '('  ')' cl(gendat,3) /
     223             -b -  -37  -38
     224      =  ok  /
     225  = ','   /  -b -51
     226
     227   = <*name> (genns)  +rest  /  -77
     228
     229     = <*name>    (genacc)  +rest  /  -24
     230
     231    = <*name>  (genreal)  +rest  /  -82
     232  = ',' <*name>  (genreal)  /  -b  -82
     233
     234    =  +rest  /  -16
     235
     236 /* branch on  literal for simple statements:                         */
     237   = brlit(2) +asgn +calls +gobys +rets
     238             +gotos  +conts
     239             +quits +flexts +elexts  +slexts +chlexts +gets
     240             +puts +files  +frwnd +lenexts +reads +writes
     241                             +checkd +ncheckd
     242             +traced  +ntraced  +assertd +debugd/
     243
     244    = <*name> '('  ')' cl(gencall,2) /
     245             -28  -  -29  -30
     246      =  ok  cl(gencall,1)  /
     247    = ','  / -b -51
     248
     249    = '('  ')' +lablist / - -68 -69
     250        =  <*name> +lablist / -72
     251  = '(' <*name>  ')' (gengoby) /
     252             -71  -70  -73
     253
     254     = (genret) ok /
     255
     256
     257    = 'to'  <*name> '('  ')' 'in'
     258                             'to'    cl(gengosl,3)   /
     259             -66   -67      -  -64    -65  -gosl
     260                            -62 -61 -63
     261      =  ok cl(gengol,29)   /
     262
     263     = set(tm,1) (goto checkcexp) ok cl(gengosl,2)   /
     264
     265    = cl(gencont,0)   ok  /
     266
     267    = (genquit)  ok   /
     268
     269   = set(ax, 2)  +lexts /
     270   = set(ax, 3)  +lexts  /
     271   = set(ax, 4)  +lexts  /
     272  = set(ax, 5)  ','    /
     273             -103  -102  -94  -92
     274
     275    =  ','  ','   /
     276             -103 -102 -103 -102 -94  -92
     277     =  set(ax,6)    / -94  -92
     278     =  set(ax, 1) +asgn2  /  -14
     279   = <*name> '('  ')' set(an, 1) /
     280             -b      -   -99   -98
     281      =  ok  set(an, 0)  /
     282    = '='  (genasin(pr(ax), pr(an)))  /
     283              -b   -93
     284
     285     =  cl(geniost, 1)         /
     286                                -b     -59
     287     = cl(geniost, 2)         /
     288                              -b       -80
     289      =  cl(geniost, 11)   (geniotr)
     290              / -81              -7
     291     =  cl(geniost, 12)   (geniotr)
     292              / -101              -7
     293
     294    =   cl(geniost, 3)  / -
     295      =  ok cl(geniost, 4)  /
     296
     297    =  'to'  cl(genioit,2) /
     298               -b     -    -95
     299      =  ok cl(genioit,1)  /
     300
     301   = ','   /-b  -7
     302
     303    = cl(geniost, 6)    /
     304                              -b
     305   =   / -
     306      =      (geniotr)     /
     307             -b                   -6
     308
     309  = ':'   / -b -7
     310
     311
     312
     313 
     314      = ',' <*cfi> '('   ')' cl(gencfi,1) /
     315          -b  -4     -  -9 -12
     316      =  ok cl(gencfi,0)  /
     317
     318 
     319      = ',' <*dfi> '('   ')' cl(gendfi,1) /
     320          -b  -5     -  -9          -12
     321      =  ok cl(gendfi,0)  /
     322
     323
     324
     325
     326    =  cl(geniost, 7)     (genfile) /
     327             -52           -10
     328
     329  = <*filekwd> '='   cl(geniost, 8)  / -b -26 -27
     330
     331  = ','   / -b  -10
     332
     333      =  cl(geniost, 9) / -83
     334
     335      $   run-time monitoring dictions
     336
     337
     338   = set(fc,1)  +chek  /
     339  = set(fc,2)  +chek  /
     340     = 'index' <*name>  (gentrace(pr(fc),8)) /
     341             -31    -
     342      =  ok  (gentrace(pr(fc),7))   /
     343
     344 
     345      =   set(fc,yes)  +trac  /
     346 
     347      =   set(fc,no)  +trac  /
     348 
     349      =    <*name>   (gentrace(pr(fc), pr(az)+1))
     350        /  -90    -
     351
     352      =   ok  (gentrace(pr(fc),pr(az)))  /
     353
     354 
     355      =   'flow'   set(az,1)  /  -
     356      =   'stores' set(az,3)  /  -
     357      =   'entry'  set(az,5)  /  -b
     358
     359 
     360      =   cl(gensert,0)    cl(gensert,1)  /  -25
     361
     362 
     363      =   (gendebug(0,no))   (gendebug(0,yes))
     364        /                   -11
     365 
     366      =   ','   / -b  -11
     367
     368 
     369      =   'limit' '='  (gendebug(1,yes))
     370        /  -       -75 -76
     371
     372      =   <*dbugtok> (gendebug(dparm, dval))
     373        /  -b
     374
     375    $ here to check for semicolon terminating
     376          $ statement, and then go parse next statement.
     377      = ';' +statme / -13
     378
     379      $   expression section.
     380
     381
     382      $   the parsing of expressions is handled by using an operator
     383      $   precedence type parsing scheme.  the grammar for expresssions
     384      $   is thus very simple except for the cases of one-token terms or
     385      $   expressions added for effiency.
     386
     387 
     388      =   <*exprtok1> <*exprtok2> xbeg 
     389                                                 xfin
     390        /  -           -namelp
     391      =   xbeg    xfin  / -
     392          =   xfin   /
     393
     394       =    set(tm,0) (goto checkcexp)  / -b
     395       =    set(tm,1) (goto checkcexp)  / -b
     396
     397  $ here after 'name(' begins expression.
     398      =     ')'  cl(gencall,3)  <*exprtok2> xbeg
     399                              xfin
     400        /  -96             -97                   -
     401      =   (-keeptok = yes)  /
     402      =     /  -
     403      =   <*unop>     genop(2) /
     404             -b  -15
     405
     406  = <*binop>     genop(1)  / -b  -8
     407
     408 /*   a term is an extractor, a constant, an expression enclosed in
     409      parentheses, a name, or a name followed by a parenthesized
     410      list of expressions.
     411 */
     412 
     413      =   <*termtok1>  <*termtok2> +termlp +fexp +eexp +sexp +chexp
     414            +pexp +termfs
     415        / -b           -b
     416
     417  $ here after 'filestat', to complete filestat term.
     418      =   '('  ',' <*statwd> ')' cl(geniost,10)
     419        /  -56 -54    -53 -55       -57
     420
     421  $ here after 'name (' term.
     422      =     ')' cl(gencall,3)
     423        /  -96             -97
     424
     425
     426     = set(az,2)  cl(genextr,26)  / -b
     427     = set(az,3)  cl(genextr,37)  / -b
     428     = set(az,4)   cl(genextr,38)  / -b
     429    = set(az,5)  ','  cl(genextr,1) / -3 -2 -1
     430      =  ','  ','    /
     431             -3 -2 -3 -2 -1
     432
     433     =  ')' /  -21  -22
     434
     435      $   error section.  report error, skip just to next statement
     436      $   and then try to parse statement.
     437
     438       =  (ermet) +erskip /
     439
     440  =  <*ertok> +erskip  /  -rest
     441
     442 end $ of the little grammar.
       1 .=member pt10
       2        universal  synmac
       3; universal file for assembling pt assembler text when
       4; asm= option of syn used.
       5; author  d. shields  (nyu-cims)  13-apr-79
       6        define ptbeg
       7<       radix   10
       8        title   ptinit
       9        twoseg
      10        entry   ptinit
      11        reloc ^o 400000
      12ptinit: popj    15,
      13        reloc   0
      14        intern  nsptab
      15nsptab:         >
      16        define  ptval(val)
      17<       exp     val>
      18        define  ptend
      19<       end>
       1 .=member pt32
       2        .macro  ptbeg   n
       3        .psect  ptinit,pic,usr,con,rel,lcl,shr,exe,rd,nowrt,quad
       4        .entry  ptinit,0
       5        ret
       6        .psect  nsptab,pic,usr,ovr,rel,lcl,noshr,noexe,rd,wrt,quad
       7x=.
       8        .blkl   n+1
       9.=x+4  ; account for initial word in nameset
      10        .endm
      11        .macro  ptval   n
      12        .long   n
      13        .endm
      14        .macro  ptend
      15;
      16        .endm
       1 .=member pt37
       2         macro
       3         ptbeg &n
       4ptinit   csect
       5         br    14
       6nsptab   csect
       7         ds    f
       8         mend
       9         macro
      10         ptval &n
      11         dc    a(&n)
      12         mend
      13         macro
      14         ptend
      15.*
      16         mend
       1 .=member pt47
       2         macro
       3         ptbeg &n
       4ptinit   csect
       5         br    14
       6nsptab   csect
       7         ds    f
       8         mend
       9         macro
      10         ptval &n
      11         dc    a(&n)
      12         mend
      13         macro
      14         ptend
      15.*
      16         mend
       1 .=member pt66
       2        ident   syntext
       3 syntext title    syntext - systems txt for syn assembly text
       4* systext file to assemble syn pt macros for s66 (cdc 6600)
       5* author  d. shields  (nyu-cims)  13-apr-79
       6        stext
       7 ptbeg  macro   dim
       8        entry   ptinit
       9 ptinit jp      *+1s17
      10        eq      ptinit
      11        use     /nsptab/
      12        bss     2    dummy words for nameset origin
      13        endm
      14 ptval  macro   n
      15        data    n
      16        endm
      17 ptend  macro
      18        use     *
      19        endm
      20        end
« August 2022 »
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31
 

Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: