Annotation of researchv10no/cmd/monk/o.db/attrib, revision 1.1.1.1

1.1       root        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: |attribute(page.offset; init 0;
                     29: $ [
                     30: .po$
                     31: .nrO \n(.o
                     32: .nrO0 \n(.o
                     33: ])
                     34: 
                     35: |attribute(line.length; init 6i;
                     36: $ [
                     37: .ll$
                     38: .lt$
                     39: .nrW \n(.lu
                     40: ])
                     41: 
                     42: |attribute(page.length; init 11i;
                     43: $ [
                     44: .pl$
                     45: ])
                     46: 
                     47: |attribute(spacing; init off;
                     48: on [
                     49: .rs
                     50: ]      off [
                     51: .ns
                     52: ])
                     53: 
                     54: |attribute(new.page; nostack;
                     55: [
                     56: .bp
                     57: ]      odd [
                     58: .bp
                     59: .af;P \gP
                     60: .afP 1
                     61: .nr;P \nP
                     62: .afP \g(;P
                     63: .af;P 1
                     64: .if!\n(;P%2 \{\
                     65: .rs
                     66: .bp\}
                     67: .rr;P
                     68: ]      even [
                     69: .bp
                     70: .af;P \gP
                     71: .afP 1
                     72: .nr;P \nP
                     73: .afP \g(;P
                     74: .af;P 1
                     75: .if\n(;P%2 \{\
                     76: .rs
                     77: .bp\}
                     78: .rr;P
                     79: ])
                     80: 
                     81: |attribute(line.spacing; stack, init 1;
                     82: $ [
                     83: .ls$
                     84: ])
                     85: 
                     86: |attribute(blank.lines; nostack;
                     87: $ [
                     88: .sp$
                     89: .ti\n(.iu
                     90: ]      [
                     91: .sp1
                     92: .ti\n(.iu
                     93: ])
                     94: 
                     95: |attribute(minimum.lines; nostack;
                     96: $ [
                     97: .br
                     98: .ie!'\n(.z'' \{\
                     99: .if!'\n(.z'\*(}D' .rr :D :E
                    100: .nr;4 $v
                    101: .if!(\n(.d=\n(:D) .nr :E 0
                    102: .nr;4 -\n(:Eu
                    103: .if\n(;4 \{\
                    104: .sp\n(;4u
                    105: .nr:E +\n(;4u \}
                    106: .rm;4
                    107: .ds}D \n(.z
                    108: .nr:D \n(.d \}
                    109: .el\{\
                    110: .rr:D :E
                    111: .nr;4 $v
                    112: .if!(\n(nl=\n(:N) .nr :B 0
                    113: .nr;4 -\n(:Bu
                    114: .if\n(;4 \{\
                    115: .sp\n(;4u
                    116: .nr:B +\n(;4u \}
                    117: .rm;4
                    118: .nr:N \n(nl \}
                    119: .ti\n(.iu
                    120: ]      [
                    121: .br
                    122: .ie!'\n(.z'' \{\
                    123: .if!'\n(.z'\*(}D' .rr :D :E
                    124: .nr;4 1v
                    125: .if!(\n(.d=\n(:D) .nr :E 0
                    126: .nr;4 -\n(:Eu
                    127: .if\n(;4 \{\
                    128: .sp\n(;4u
                    129: .nr:E +\n(;4u \}
                    130: .rm;4
                    131: .ds}D \n(.z
                    132: .nr:D \n(.d \}
                    133: .el\{\
                    134: .rr:D :E
                    135: .nr;4 1v
                    136: .if!(\n(nl=\n(:N) .nr :B 0
                    137: .nr;4 -\n(:Bu
                    138: .if\n(;4 \{\
                    139: .sp\n(;4u
                    140: .nr:B +\n(;4u \}
                    141: .rm;4
                    142: .nr:N \n(nl \}
                    143: .ti\n(.iu
                    144: ])
                    145: 
                    146: |attribute(horizontal.motion; nostack;
                    147: $ [\h'$']
                    148: number $$. [\h'\n$$.']
                    149: number $number.register [\h'\n($number.register'])
                    150: 
                    151: |attribute(vertical.motion; nostack;
                    152: $ [\v'$']
                    153: number $$. [\v'\n$$.']
                    154: number $number.register [\v'\n($number.register'])
                    155: 
                    156: |attribute(concatenate; nostack;
                    157: [\&\c
                    158: ])
                    159: 
                    160: |attribute(new.line; nostack;
                    161: [
                    162: .br
                    163: ])
                    164: 
                    165: |attribute(indent; stack, default 0;
                    166: $ [
                    167: .in$
                    168: ])
                    169: 
                    170: |attribute(indent.line; nostack;
                    171: $ [
                    172: .ti$
                    173: ]
                    174: number $$. [
                    175: .ti\n$$.u
                    176: ]
                    177: number $number.register [
                    178: .ti\n($number.registeru
                    179: ])
                    180: 
                    181: |attribute(fill; stack, init on;
                    182: on [
                    183: 'fi
                    184: ]      off [
                    185: 'nf
                    186: ])
                    187: 
                    188: |attribute(adjust; stack, init both;
                    189: right [
                    190: .adr
                    191: ]      left [
                    192: .adl
                    193: ]      both [
                    194: .adb
                    195: ]      on [
                    196: .ad
                    197: ]      off [
                    198: .na
                    199: ])
                    200: 
                    201: |attribute(title; nostack;
                    202: $left $center $right [
                    203: .tl\(ts$left\(ts$center\(ts$right\(ts
                    204: ]      $$. [
                    205: .tl\*$$.
                    206: ]      $$.. [
                    207: .tl\*($$..
                    208: ]      $ [
                    209: .tl$
                    210: ])
                    211: 
                    212: |attribute(center; stack, default off;
                    213: on [
                    214: .ce9999
                    215: ]      off [
                    216: .ce0
                    217: ])
                    218: 
                    219: |attribute(center.block; stack, default off;
                    220: on [
                    221: .nr:Y 0
                    222: .br
                    223: .di:1
                    224: ]      off [
                    225: .br
                    226: .di
                    227: .nr;q \n(.u
                    228: .nf
                    229: .nr;L \n(.L
                    230: .ls1
                    231: .nr;i \n(.i
                    232: .if\n(dl>\n(:Y .nr :Y \n(dl
                    233: .if\n(:Y<\n(.l .in (\n(.lu-\n(:Yu)/2u
                    234: .:1
                    235: .if\n(;q .fi
                    236: .ls\n(;L
                    237: .in\n(;iu
                    238: .rr;L ;i ;q
                    239: .rm:1
                    240: ])
                    241: 
                    242: |attribute(text; nostack;
                    243: $ [$]
                    244: roman $ [\f1\&$\fP\&]
                    245: italics $ [\f2\&$\fP\&]
                    246: bold $ [\f3\&$\fP\&]
                    247: bolditalics $ [\f4\&$\fP\&]
                    248: cw $ [\f(CW\&$\fP\&])
                    249: 
                    250: |attribute(error; nostack;
                    251: number $* $$. [
                    252: .tm"__FILE__":__LINE__: $* \n$$.
                    253: ]      number $* $number.register [
                    254: .tm"__FILE__":__LINE__: $* \n($number.register
                    255: ]      string $* $$. [
                    256: .tm"__FILE__":__LINE__: $* \n$$.
                    257: ]      string $* $string.register [
                    258: .tm"__FILE__":__LINE__: $* \n($string.register
                    259: ]      $* [
                    260: .tm"__FILE__":__LINE__: $*
                    261: ])
                    262: 
                    263: |attribute(here; stack, default off;
                    264: on [
                    265: .if\n(:y .tm "__FILE__":__LINE__: Here's and/or Around's can not be nested
                    266: .nr:y 1
                    267: .br
                    268: .di:0
                    269: ]      off [
                    270: .br
                    271: .di
                    272: .nr:d 1
                    273: .if(\n(dn>=\n(.t)&((\n(dn<(\n(.p-\n(:r-\n(:m)):\
                    274: (\n(nl>(\n(.p-\n(:r-\n(:o/2u+\n(:r)))\
                    275: .ne\n(.tu+1v
                    276: .nr;q \n(.u
                    277: .nf
                    278: .nr;L \n(.L
                    279: .ls1
                    280: .nr;i \n(.i
                    281: .in0
                    282: .rs
                    283: .:0
                    284: .nr:d 0
                    285: .if\n(;q .fi
                    286: .ls\n(;L
                    287: .in\n(;iu
                    288: .nr:y 0
                    289: .rr;L ;i ;q
                    290: .rm:0
                    291: ])
                    292: 
                    293: |attribute(around; stack, default off;
                    294: on [
                    295: .if\n(:y .tm "__FILE__":__LINE__: Here's and/or Around's can not be nested
                    296: .nr:y 1
                    297: .nr;s \n(.s
                    298: .nr;f \n(.f
                    299: .nr;u \n(.u
                    300: .nr;j \n(.j
                    301: .nr;v \n(.v
                    302: .nr;L \n(.L
                    303: .nr;l \n(.l
                    304: .nr;i \n(.i
                    305: .ev1
                    306: .ps\n(;s
                    307: .vs\n(;sp+2p
                    308: .ft\n(;f
                    309: .nf
                    310: .if\n(;u .fi
                    311: .ad\n(;j
                    312: .vs\n(;vu
                    313: .ls\n(;L
                    314: .ll\n(;lu
                    315: .in\n(;iu
                    316: .ti\n(;iu
                    317: .hy14
                    318: .lt\n(;lu
                    319: |ifvalue around_width full [
                    320: .if\n(:C \{\
                    321: .ll\n(W0u
                    322: .lt\n(W0u \}
                    323: ]
                    324: .di:0
                    325: ]      off [
                    326: .br
                    327: .di
                    328: |ifvalue around_width full [
                    329: .if\n(:C \{\
                    330: .ll\nWu
                    331: .lt\nWu \}
                    332: ]
                    333: .ev
                    334: .nr:z \n(:z%26+1
                    335: .if\n(:z-\n(:w=0 .tm "__FILE__":__LINE__: too many floating displays
                    336: .af;w a
                    337: .nr;w \n(:z
                    338: .rn:0 ?\n(;w
                    339: .nr!\n(;w 0
                    340: |ifvalue around_width full [
                    341: .nr!\n(;w 1
                    342: ]
                    343: |ifnotvalue around_width full [
                    344: .if!\n(:C .nr !\n(;w 1
                    345: ]
                    346: .nr|\n(;w \n(dn
                    347: .if(((\n(:z-\n(:w=1):(\n(:z+26-\n(:w=1))&((\n(!\n(;w=1)&(\n(:C<2))&\
                    348: ((\n(dn<\n(.t):((\n(dn>(\n(.p-\n(:r-\n(:m))&\
                    349: (\n(nl<=(\n(.p-\n(:r-\n(:o/2u+\n(:r))))) .)z
                    350: .nr:y 0
                    351: .rr;L ;f ;i ;j ;l ;s ;u ;v ;w
                    352: ])
                    353: 
                    354: |attribute(around_placement; nostack;
                    355: [
                    356: .)w
                    357: ])
                    358: 
                    359: |attribute(footnote; stack, default off;
                    360: on [
                    361: .if\n(:x .tm "__FILE__":__LINE__: Footnotes can not be nested
                    362: .nr:x 1
                    363: .nr;s \n(.s
                    364: .nr;f \n(.f
                    365: .nr;u \n(.u
                    366: .nr;j \n(.j
                    367: .nr;v \n(.v
                    368: .nr;L \n(.L
                    369: .nr;l \n(.l
                    370: .ev1
                    371: .ps\n(;s
                    372: .vs\n(;sp+2p
                    373: .ft\n(;f
                    374: .nf
                    375: .if\n(;u .fi
                    376: .ad\n(;j
                    377: .vs\n(;vu
                    378: .ls\n(;L
                    379: .ll\n(;lu
                    380: .in0
                    381: .ti0
                    382: .hy14
                    383: .lt\n(;lu
                    384: |ifvalue footnote_width full [
                    385: .if\n(:C \{\
                    386: .ll\n(W0u
                    387: .lt\n(W0u \}
                    388: ]
                    389: .da:F
                    390: .ie!\n(:q \{\
                    391: .nr;o \n(.o
                    392: .po0
                    393: .ps10
                    394: .vs12p
                    395: .ft1
                    396: .ie\n(.A=0 \l'72p'
                    397: .el __________
                    398: .ft
                    399: .vs
                    400: .ps
                    401: .po\n(;ou \}
                    402: .el.sp 1
                    403: ]      off [
                    404: .br
                    405: .da
                    406: |ifvalue footnote_width full [
                    407: .if\n(:C \{\
                    408: .ll\nWu
                    409: .lt\nWu \}
                    410: .nr:v 1
                    411: ]
                    412: |ifnotvalue footnote_width full [
                    413: .if!\n(:C .nr :v 1
                    414: ]
                    415: .ev
                    416: .nr:x 0
                    417: .if!\n(:o-\n(:m \{\
                    418: .nr:o +\n(:Vu-1u
                    419: .nrdn +\n(:V-\n(.v \}
                    420: .nr:q +\n(dnu
                    421: .nr:o +\n(dnu
                    422: .if!\n(.pu-\n(nlu-.5p-\n(:ou .nr :o \n(.pu-\n(nlu-.5p
                    423: .if!\n(:ou-\n(:mu .nr :o \n(:mu
                    424: .if\n(:C>1&\n(:v .nr :o \n(:mu
                    425: .ch)f -\n(:ou
                    426: .rr;L ;f ;j ;l ;o ;s ;u ;v
                    427: ])
                    428: 
                    429: |attribute(size; stack, default 10;
                    430: $ [|ifvalue inline on [\s$\&]|ifvalue inline off [
                    431: .ps$
                    432: ]])
                    433: 
                    434: |attribute(space; stack, init 12;
                    435: $ [
                    436: .vs$
                    437: ])
                    438: 
                    439: |attribute(SPACE; nostack;
                    440: [
                    441: .vs\n(.sp+2p
                    442: ])
                    443: 
                    444: |attribute(font; stack, default roman;
                    445: roman [|ifvalue inline on [\&\f1\&]|ifvalue inline off [
                    446: .ft1
                    447: ]]     italics [|ifvalue inline on [\&\f2\&]|ifvalue inline off [
                    448: .ft2
                    449: ]]     bold [|ifvalue inline on [\&\f3\&]|ifvalue inline off [
                    450: .ft3
                    451: ]]     bolditalics [|ifvalue inline on [\&\f4\&]|ifvalue inline off [
                    452: .ft4
                    453: ]]     cw [|ifvalue inline on [\&\f(CW\&]|ifvalue inline off [
                    454: .ftCW
                    455: ]])
                    456: 
                    457: |attribute(font.family; stack, default times;
                    458: times [
                    459: .fp1 R
                    460: .fp2 I
                    461: .fp3 B
                    462: .fp4 BI
                    463: ]      palatino [
                    464: .fp1 PA
                    465: .fp2 PI
                    466: .fp3 PB
                    467: .fp4 PX
                    468: ]      bembo [
                    469: .fp1 B1
                    470: .fp2 B2
                    471: .fp3 B3
                    472: .fp4 B4
                    473: ]      optima [
                    474: .fp1 O1
                    475: .fp2 O2
                    476: .fp3 O3
                    477: .fp4 O4
                    478: ]      souvenir [
                    479: .fp1 SV
                    480: .fp2 SI
                    481: .fp3 SB
                    482: .fp4 SX
                    483: ]      helvetica [
                    484: .fp1 H
                    485: .fp2 HI
                    486: .fp3 HB
                    487: .fp4 HX
                    488: ]      cw [
                    489: .fp1 CW
                    490: .fp2 I
                    491: .fp3 B
                    492: .fp4 BI
                    493: ]      gothic [
                    494: .fp1 C
                    495: .fp2 CX
                    496: .fp3 TB
                    497: .fp4 TX
                    498: ]      condensed [
                    499: .fp1 Hcond
                    500: .fp2 HcondI
                    501: .fp3 HcondB
                    502: .fp4 HlightI
                    503: ]      narrow [
                    504: .fp1 Hr
                    505: .fp2 Hi
                    506: .fp3 Hb
                    507: .fp4 Hx
                    508: ])
                    509: 
                    510: |attribute(if; nostack;
                    511: $test [
                    512: .if$test \
                    513: ]      begin $test [
                    514: .if$test \{\
                    515: ]      end [\}\c
                    516: ]      else $test [
                    517: .ie$test \
                    518: ]      else begin $test [
                    519: .ie$test \{\
                    520: ]      else [
                    521: .el\
                    522: ]      else begin [
                    523: .el\{\
                    524: ])
                    525: 
                    526: |attribute(tab; nostack;
                    527: [\&    ])
                    528: 
                    529: |attribute(leader; nostack;
                    530: [\&&])
                    531: 
                    532: |attribute(thick.line; nostack;
                    533: $ [
                    534: .ps24
                    535: \l'$'
                    536: .ps
                    537: ]      [
                    538: .ps24
                    539: \l'\n(.lu'
                    540: .ps
                    541: ])
                    542: 
                    543: |attribute(line; nostack;
                    544: $ [\l'$']
                    545: [\l'\n(.lu'])
                    546: 
                    547: |attribute(box; nostack;
                    548: x [\s12\o'\(mu\(sq'\s0]
                    549: empty [\s12\(sq\s0]
                    550: [\(sq])
                    551: 
                    552: |attribute(underline; stack, default off;
                    553: on [\kx]
                    554: off [\l'|\nxu\(ul'])
                    555: 
                    556: |attribute(hyphenate; stack, init on;
                    557: on [
                    558: .hy14
                    559: ]      off [
                    560: .nh
                    561: ])
                    562: 
                    563: |attribute(case; stack, init any;
                    564: upper [
                    565: ]      lower [
                    566: ]      capitalize [
                    567: ]      any [
                    568: ])
                    569: 
                    570: |attribute(tab.stops; nostack;
                    571: $* [
                    572: .ta$*
                    573: ]      [
                    574: .ta.5i 1.0i 1.5i 2.0i 2.5i 3.0i 3.5i 4.0i 4.5i 5.0i 5.5i 6.0i 6.5i 7.0i 7.5i
                    575: ])
                    576: 
                    577: |attribute(set; nostack;
                    578: $* $number [
                    579: |for i in $* {
                    580: .nr$i $number
                    581: }]     string $* $string [
                    582: |for i in $* {
                    583: .ds$i $string
                    584: }])
                    585: 
                    586: |attribute(store; nostack;
                    587: $* $$. [
                    588: |for i in $* {
                    589: .nr$i \n$$.
                    590: }]     $* $number.register [
                    591: |for i in $* {
                    592: .nr$i \n($number.register
                    593: }]     string $* $$. [
                    594: |for i in $* {
                    595: .ds$i \*$$.
                    596: }]     string $* $string.register [
                    597: |for i in $* {
                    598: .ds$i \*($string.register
                    599: }]     number.from.string $* $$. [
                    600: |for i in $* {
                    601: .nr$i \*$$.
                    602: }]     number.from.string $* $string.register [
                    603: |for i in $* {
                    604: .nr$i \*($string.register
                    605: }]     string.from.number $* $$. [
                    606: |for i in $* {
                    607: .ds$i \n$$.
                    608: }]     string.from.number $* $number.register [
                    609: |for i in $* {
                    610: .ds$i \n($number.register
                    611: }]     width $* $$. [
                    612: |for i in $* {
                    613: .nr$i \w'\*$$.'
                    614: }]     width $* $number.register [
                    615: |for i in $* {
                    616: .nr$i \w'\*($number.register'
                    617: }]     indent $* [
                    618: |for i in $* {
                    619: .nr$i \n(.i
                    620: }]     linelength $* [
                    621: |for i in $* {
                    622: .nr$i \n(.l
                    623: }]     pagewidth $* [
                    624: |for i in $* {
                    625: .nr$i \nWu
                    626: }]     totrap $* [
                    627: |for i in $* {
                    628: .nr$i \n(.t
                    629: }]     pageoffset $* [
                    630: |for i in $* {
                    631: .nr$i \n(.o
                    632: }]     diversionheight $* [
                    633: |for i in $* {
                    634: .nr$i \n(dn
                    635: }])
                    636: 
                    637: |attribute(clear; nostack;
                    638: $* [
                    639: |for i in $* {
                    640: .nr$i 0
                    641: }]     string $* [
                    642: .rm$*
                    643: ])
                    644: 
                    645: |attribute(rename; nostack;
                    646: $from $to [
                    647: .rn$from $to
                    648: ])
                    649: 
                    650: |attribute(add; nostack;
                    651: $result $$. $* [
                    652: .nr$result \n$$.
                    653: |for i in $* {
                    654: .nr$result +\n($i
                    655: }]     $result $operand $* [
                    656: .nr$result \n($operand
                    657: |for i in $* {
                    658: .nr$result +\n($i
                    659: }]     $result $$. [
                    660: .nr$result +\n$$.
                    661: ]      $result $operand [
                    662: .nr$result +\n($operand
                    663: ]      constant $result $constant $* [
                    664: .nr$result $constant
                    665: |for i in $* {
                    666: .nr$result +$i
                    667: }]     constant $result $constant [
                    668: .nr$result +$constant
                    669: ]      string $string $text [
                    670: .as$string $text
                    671: ]      string.from.number $string $$. [
                    672: .as$string \n$$.
                    673: ]      string.from.number $string $number.register [
                    674: .as$string \n($number.register
                    675: ]      string.from.string $string $$. [
                    676: .as$string \*$$.
                    677: ]      string.from.string $string $string.register [
                    678: .as$string \*($string.register
                    679: ])
                    680: 
                    681: |attribute(sub; nostack;
                    682: $result $$. $* [
                    683: .nr$result \n$$.
                    684: |for i in $* {
                    685: .nr$result -\n($i
                    686: }]     $result $operand $* [
                    687: .nr$result \n($operand
                    688: |for i in $* {
                    689: .nr$result -\n($i
                    690: }]     $result $$. [
                    691: .nr$result -\n$$.
                    692: ]      $result $operand [
                    693: .nr$result -\n($operand
                    694: ]      constant $result $constant $* [
                    695: .nr$result $constant
                    696: |for i in $* {
                    697: .nr$result -$i
                    698: }]     constant $result $constant [
                    699: .nr$result -$constant
                    700: ])
                    701: 
                    702: |attribute(incr; nostack;
                    703: $* [
                    704: |for i in $* {
                    705: .nr$i +1
                    706: }])
                    707: 
                    708: |attribute(decr; nostack;
                    709: $* [
                    710: |for i in $* {
                    711: .nr$i -1
                    712: }])
                    713: 
                    714: |attribute(protect; nostack;
                    715: $ [
                    716: .ne$
                    717: ]      [
                    718: .ne3
                    719: ])
                    720: 
                    721: |attribute(warn.orphan; nostack;
                    722: $ [
                    723: ]      [
                    724: ])
                    725: 
                    726: |attribute(column; nostack;
                    727: $column $width $offset [
                    728: .if\n(:c<$column .nr :c $column
                    729: .nrW$column $width
                    730: .nrO$column $offset
                    731: ]      width $width [
                    732: .nrW\n(:c $width
                    733: ]      offset $offset [
                    734: .nrO\n(:c $offset
                    735: ]      next [
                    736: .nr:c +1
                    737: ]      clear   [
                    738: .rr:c
                    739: ]      new [
                    740: .ie!\n(:C .tm "__FILE__":__LINE__: not in multi-column mode
                    741: .el\{\
                    742: .br
                    743: .ne\n(.tu+1v \}
                    744: ]      new $ [
                    745: .ie!\n(:C .tm "__FILE__":__LINE__: not in multi-column mode
                    746: .el\{\
                    747: .br
                    748: .ne\n(.tu+1v
                    749: .nr;d \n(.lu-\n(W\n(:Cu
                    750: .nr:C $
                    751: .nrO \n(O$u
                    752: .po\nOu
                    753: .nrW \n(W$u+\n(;du
                    754: .ll\nWu
                    755: .lt\nWu
                    756: .rr;d \}
                    757: ]      old $ [
                    758: .ie!\n(:C .tm "__FILE__":__LINE__: not in multi-column mode
                    759: .el\{\
                    760: .br
                    761: .if\n(nl>\n(U\n(:C \
                    762: .mkU\n(:C
                    763: .nr;d \n(.lu-\n(W\n(:Cu
                    764: .nr:C $
                    765: .nrO \n(O$u
                    766: .po\nOu
                    767: .nrW \n(W$u+\n(;du
                    768: .ll\nWu
                    769: .lt\nWu
                    770: .rs
                    771: .ie\n(U$ .sp |\n(U$u
                    772: .el.sp |\n(U0u
                    773: .ns
                    774: .rr;d \}
                    775: ]      on [
                    776: .ie\n(:C .tm "__FILE__":__LINE__: already in multi-column mode
                    777: .el\{\
                    778: .br
                    779: .nr:C 1
                    780: .nrW \n(W1u
                    781: .ll\nWu
                    782: .lt\nWu
                    783: .nrO \n(O1u
                    784: .po\nOu
                    785: .mkU0
                    786: .ns
                    787: .rrU1 U2 U3 U4 U5 U6 U7 U8 U9
                    788: .rr;d \}
                    789: ]      off [
                    790: .ie!\n(:C .tm "__FILE__":__LINE__: already in full page mode
                    791: .el\{\
                    792: .br
                    793: .if\n(nl>\n(U\n(:C \
                    794: .mkU\n(:C
                    795: .nr;d \n(.lu-\n(W\n(:Cu
                    796: .nr:C 0
                    797: .nrO \n(O0u
                    798: .po\nOu
                    799: .nrW \n(W0u+\n(;du
                    800: .ll\nWu
                    801: .lt\nWu
                    802: .rs
                    803: .sp|\n(U0u
                    804: .if\n(nl<\n(U1 \
                    805: .sp|\n(U1u
                    806: .if\n(nl<\n(U2 \
                    807: .sp|\n(U2u
                    808: .if\n(nl<\n(U3 \
                    809: .sp|\n(U3u
                    810: .if\n(nl<\n(U4 \
                    811: .sp|\n(U4u
                    812: .if\n(nl<\n(U5 \
                    813: .sp|\n(U5u
                    814: .if\n(nl<\n(U6 \
                    815: .sp|\n(U6u
                    816: .if\n(nl<\n(U7 \
                    817: .sp|\n(U7u
                    818: .if\n(nl<\n(U8 \
                    819: .sp|\n(U8u
                    820: .if\n(nl<\n(U9 \
                    821: .sp|\n(U9u
                    822: .ti\n(.iu
                    823: .rrU1 U2 U3 U4 U5 U6 U7 U8 U9
                    824: .ns
                    825: .rr;d \}
                    826: ]      2 [
                    827: .ie\n(:C .tm "__FILE__":__LINE__: already in multi-column mode
                    828: .el\{\
                    829: .br
                    830: .nr:C 1
                    831: .nrW0 \nW
                    832: .nrW \n(.lu*8u/17u
                    833: .nrW1 \nW
                    834: .nrW2 \nW
                    835: .nrO0 \n(.ou
                    836: .nrO1 \n(.ou
                    837: .nrO2 \n(.lu*9u/17u+\n(.ou
                    838: .ll\nWu
                    839: .lt\nWu
                    840: .nr:c 2
                    841: .mkU0
                    842: .ns
                    843: .rrU1 U2 \}
                    844: ])
                    845: 
                    846: |attribute(divert.string; stack, default off;
                    847: $string.name [
                    848: .ds$string.name ]
                    849: off [
                    850: ])
                    851: 
                    852: |attribute(divert.number; stack, default off;
                    853: $number.name [
                    854: .nr$number.name ]
                    855: off [
                    856: ])
                    857: 
                    858: |attribute(divert.output; stack, default off;
                    859: on $string.name [
                    860: .nr;s \n(.s
                    861: .nr;f \n(.f
                    862: .nr;u \n(.u
                    863: .nr;j \n(.j
                    864: .nr;v \n(.v
                    865: .nr;L \n(.L
                    866: .nr;l \n(.l
                    867: .ev1
                    868: .ps\n(;s
                    869: .vs\n(;sp+2p
                    870: .ft\n(;f
                    871: .nf
                    872: .if\n(;u .fi
                    873: .ad\n(;j
                    874: .vs\n(;vu
                    875: .ls\n(;L
                    876: .ll\n(;lu
                    877: .in0
                    878: .ti0
                    879: .hy14
                    880: .lt\n(;lu
                    881: .di$string.name
                    882: ]      off [
                    883: .br
                    884: .di
                    885: .ev
                    886: .rr;L ;f ;j ;l ;o ;s ;u ;v
                    887: ])
                    888: 
                    889: |attribute(divert.input; stack, default off;
                    890: on $string.name [
                    891: .eo
                    892: .de$string.name\(ts\(ts
                    893: ]      off [
                    894: .\(ts\(ts
                    895: .ec
                    896: ])
                    897: 
                    898: |attribute(append.output; stack, default off;
                    899: on $string.name [
                    900: .nr;s \n(.s
                    901: .nr;f \n(.f
                    902: .nr;u \n(.u
                    903: .nr;j \n(.j
                    904: .nr;v \n(.v
                    905: .nr;L \n(.L
                    906: .nr;l \n(.l
                    907: .ev1
                    908: .ps\n(;s
                    909: .vs\n(;sp+2p
                    910: .ft\n(;f
                    911: .nf
                    912: .if\n(;u .fi
                    913: .ad\n(;j
                    914: .vs\n(;vu
                    915: .ls\n(;L
                    916: .ll\n(;lu
                    917: .in0
                    918: .ti0
                    919: .hy14
                    920: .lt\n(;lu
                    921: .da$string.name
                    922: ]      off [
                    923: .br
                    924: .da
                    925: .ev
                    926: .rr;L ;f ;j ;l ;o ;s ;u ;v
                    927: ])
                    928: 
                    929: |attribute(append.input; stack, default off;
                    930: on $string.name [
                    931: .eo
                    932: .am$string.name\(ts\(ts
                    933: ]      off [
                    934: .\(ts\(ts
                    935: .ec
                    936: ])
                    937: 
                    938: |attribute(invoke; nostack;
                    939: on $offset $what  [
                    940: .wh15i $what
                    941: .ch$what \n(nlu+$offset
                    942: ]      on number $$. $what  [
                    943: .wh15i $what
                    944: .ch$what \n(nlu+\n$$.u
                    945: ]      on number $number.register $what  [
                    946: .wh15i $what
                    947: .ch$what \(nlu+\n($number.registeru
                    948: ]      at constant $constant $what [
                    949: .wh15i $what
                    950: .ch$what $constant
                    951: ]      at number $$. $what [
                    952: .wh15i $what
                    953: .ch$what \n$$.u
                    954: ]      at number $number.register $what [
                    955: .wh15i $what
                    956: .ch$what \n($number.registeru
                    957: ]      end [
                    958: .br
                    959: .di
                    960: ]      off $what [
                    961: .ch$what
                    962: ])
                    963: 
                    964: |attribute(remember; nostack;
                    965: $ [
                    966: .mk$
                    967: ])
                    968: 
                    969: |attribute(return; nostack;
                    970: $$. [
                    971: .sp|\n$$.u
                    972: .ti\n(.iu
                    973: ]      $ [
                    974: .sp|\n($u
                    975: .ti\n(.iu
                    976: ])
                    977: 
                    978: |attribute(goto; nostack;
                    979: $ [
                    980: .sp|$
                    981: .ti\n(.iu
                    982: ])
                    983: 
                    984: |attribute(string; nostack;
                    985: $$. [\*$$.]
                    986: $string.register [\*($string.register]
                    987: roman $$. [\f1\&\*$$.\fP\&]
                    988: italics $$. [\f2\&\*$$.\fP\&]
                    989: bold $$. [\f3\&\*$$.\fP\&]
                    990: bolditalics $$. [\f4\&\*$$.\fP\&]
                    991: cw $$. [\f(CW\&\*$$.\fP\&]
                    992: roman $string.register [\f1\&\*($string.register\fP\&]
                    993: italics $string.register [\f2\&\*($string.register\fP\&]
                    994: bold $string.register [\f3\&\*($string.register\fP\&]
                    995: bolditalics $string.register [\f4\&\*($string.register\fP\&]
                    996: cw $string.register [\f(CW\&\*($string.register\fP\&])
                    997: 
                    998: |attribute(macro; nostack;
                    999: $ [
                   1000: .$
                   1001: ])
                   1002: 
                   1003: |attribute(number; nostack;
                   1004: $$. [\n$$.]
                   1005: $number.register [\n($number.register]
                   1006: ++ $$. [\n+$$.]
                   1007: ++ $number.register [\n+($number.register]
                   1008: format $* $format [
                   1009: |for i in $* {
                   1010: .af$i $format
                   1011: }]
                   1012: incr $* $incr [
                   1013: |for i in $* {
                   1014: .nr$i +0 $incr
                   1015: }]
                   1016: format.from.string $* $$. [
                   1017: |for i in $* {
                   1018: .af$i \*$$.
                   1019: }]
                   1020: incr $* $incr [
                   1021: |for i in $* {
                   1022: .nr$i +0 $incr
                   1023: }]
                   1024: format.from.string $* $format [
                   1025: |for i in $* {
                   1026: .af$i \*($format
                   1027: }]
                   1028: incr $* $incr [
                   1029: |for i in $* {
                   1030: .nr$i +0 $incr
                   1031: }])
                   1032: 
                   1033: |attribute(list.pre; stack, default;
                   1034: [
                   1035: .rml2
                   1036: ]
                   1037: $pre [
                   1038: .dsl2 $pre
                   1039: ])
                   1040: 
                   1041: |attribute(list.format; stack, default;
                   1042: [
                   1043: .rml3
                   1044: ]
                   1045: $format [
                   1046: .dsl3 $format
                   1047: ])
                   1048: 
                   1049: |attribute(list.post; stack, default;
                   1050: [
                   1051: .rml4
                   1052: ]
                   1053: $post [
                   1054: .dsl4 $post
                   1055: ])
                   1056: 
                   1057: |attribute(list.indent; stack, default;
                   1058: [
                   1059: .rml5
                   1060: ]
                   1061: $indent [
                   1062: .dsl5 $indent
                   1063: ])
                   1064: 
                   1065: |attribute(list; nostack;
                   1066: off [
                   1067: .)C ;i l1 \*(l1
                   1068: .in\n(;iu
                   1069: .)C l0 l0 \*(l0
                   1070: .rm;i
                   1071: ]      on [
                   1072: .dsl1 \n(.i \*(l1
                   1073: .in+\w'\*(l5'u
                   1074: .afl0 0
                   1075: .dsl0 \n(l0 \*(l0
                   1076: .nrl0 0 1
                   1077: ])
                   1078: 
                   1079: |attribute(file.information; nostack;
                   1080: [
                   1081: .lf__LINE__ __FILE__
                   1082: ])
                   1083: 
                   1084: |attribute(reference.style; nostack;
                   1085: acm [|reference_style(acm)
                   1086: ]      apa [|reference_style(apa)
                   1087: ]      att [|reference_style(att)
                   1088: ]      ieee [|reference_style(ieee)
                   1089: ]      lsa [|reference_style(lsa)
                   1090: ]      pami [|reference_style(pami)
                   1091: ]      spectrum [|reference_style(spectrum)
                   1092: ])
                   1093: 
                   1094: |attribute(reference.option; nostack;
                   1095: tm [|reference_style(same tm)
                   1096: ]      rp [|reference_style(same rp)
                   1097: ]      nroff [|reference_style(same nroff)
                   1098: ]      troff [|reference_style(same troff)
                   1099: ]      sort [|reference_style(same sort)
                   1100: ]      sequence [|reference_style(same sequence)
                   1101: ]      a [|reference_style(same a)
                   1102: ]      d [|reference_style(same d)
                   1103: ]      t [|reference_style(same t)
                   1104: ]      ad [|reference_style(same ad)
                   1105: ]      at [|reference_style(same at)
                   1106: ]      da [|reference_style(same da)
                   1107: ]      dt [|reference_style(same dt)
                   1108: ]      ta [|reference_style(same ta)
                   1109: ]      td [|reference_style(same td)
                   1110: ]      adt [|reference_style(same adt)
                   1111: ]      atd [|reference_style(same atd)
                   1112: ]      dat [|reference_style(same dat)
                   1113: ]      dta [|reference_style(same dta)
                   1114: ]      tad [|reference_style(same tad)
                   1115: ]      tda [|reference_style(same tda)
                   1116: ])
                   1117: 
                   1118: |attribute(reference; stack, default off;
                   1119: database [|reference_database<]
                   1120: [|reference_include<]
                   1121: list [|reference_list<]
                   1122: on [|reference<]
                   1123: off [>])
                   1124: 
                   1125: |attribute(reference.placement; nostack;
                   1126: [|reference_placement
                   1127: ])
                   1128: 
                   1129: |attribute(table; stack, default off;
                   1130: on [
                   1131: .TS
                   1132: ]      off [
                   1133: .TE
                   1134: ])
                   1135: 
                   1136: |attribute(ipa; stack, default off;
                   1137: on [@ipa(]
                   1138: off [)])
                   1139: 
                   1140: |attribute(picture; stack, default off;
                   1141: on [
                   1142: .PS
                   1143: ]      off [
                   1144: .PE
                   1145: ])
                   1146: 
                   1147: |attribute(ped; stack, default off;
                   1148: on [
                   1149: .GS
                   1150: ]      off[
                   1151: .GE
                   1152: ])
                   1153: 
                   1154: |attribute(ideal; stack, default off;
                   1155: on [
                   1156: .IS
                   1157: ]      off[
                   1158: .IE
                   1159: ])
                   1160: 
                   1161: |attribute(equation; stack, default off;
                   1162: on [
                   1163: .br
                   1164: .di:4
                   1165: .EQ
                   1166: ]      off [
                   1167: .EN
                   1168: .br
                   1169: .di
                   1170: .rm:4
                   1171: |ifvalue center.block on [
                   1172: .if\w@\*(10\*(ES@ \{\
                   1173: .if\n(:Y<\w@\*(10@ .nr :Y \w@\*(10@
                   1174: \!\*(10\h'\\n(.lu-\w@\*(10\*(ES@u-\\n(.iu'\*(ES
                   1175: .rr:D :E \}]
                   1176: |ifvalue center on [
                   1177: .if\w@\*(10\*(ES@ .tl \(ts\(ts\*(10\(ts\*(ES\(ts]
                   1178: |ifnotvalue center.block on [ |ifnotvalue center on [
                   1179: .if\w@\*(10\*(ES@ \{\
                   1180: .pc
                   1181: .tl\(ts\h'\n(.iu'\*(10\(ts\(ts\*(ES\(ts
                   1182: .pc% \}]]
                   1183: .rm10
                   1184: ])
                   1185: 
                   1186: |attribute(inline.equation; stack, default off;
                   1187: on []
                   1188: off [])
                   1189: 
                   1190: |attribute(graph; stack, default off;
                   1191: on [
                   1192: .G1
                   1193: ]      off [
                   1194: .G2
                   1195: ])
                   1196: 
                   1197: |attribute(bargraph; stack, default off;
                   1198: on [
                   1199: .B1
                   1200: ]      off [
                   1201: .B0
                   1202: ])
                   1203: 
                   1204: |attribute(computeroutput; stack, default off;
                   1205: on [
                   1206: .CW
                   1207: ]      off [
                   1208: .CN
                   1209: ])
                   1210: 
                   1211: |attribute(citation; nostack;
                   1212: save on [
                   1213: .CD "]
                   1214: save off string $$. [" "\*$$."
                   1215: ]      save off string $string.register [" "\*($string.register"
                   1216: ]      save off number $$. [" "\n$$."
                   1217: ]      save off number $number.register [" "\n($number.register"
                   1218: ]      save string $name $$. [\&\c
                   1219: .CD "$name" "\*$$."
                   1220: ]      save string $name $string.register [\&\c
                   1221: .CD "$name" "\*($string.register"
                   1222: ]      save number $name $$. [\&\c
                   1223: .CD "$name" "\n$$."
                   1224: ]      save number $name $number.register [\&\c
                   1225: .CD "$name" "\n($number.register"
                   1226: ]      remember on [\&\c
                   1227: .CU "]
                   1228: remember off ["]
                   1229: remember string $name [\&\c
                   1230: .CU "$name"])
                   1231: 
                   1232: |attribute(index; stack, default off;
                   1233: on [\&\c
                   1234: .tmix: ]
                   1235: off [  \nP
                   1236: \&])
                   1237: 
                   1238: |attribute(contents; nostack;
                   1239: $category $level $sequence $text [
                   1240: .tm.TC $category       $level  \*($sequence    \*($text        \nP
                   1241: ])
                   1242: 
                   1243: |attribute(white.text; nostack;
                   1244: $text [|ifvalue verbatim off []|ifvalue verbatim on [$text]])
                   1245: 
                   1246: |attribute(nl.paragraph; nostack;
                   1247: [|ifvalue verbatim on [
                   1248: ]|ifvalue verbatim off []])
                   1249: 
                   1250: |attribute(format.type; stack, init none;
                   1251: model [
                   1252: .dsf0 model
                   1253: ]      acm [
                   1254: .dsf0 acm
                   1255: ]      none [
                   1256: .dsf0 none
                   1257: ])
                   1258: 
                   1259: |attribute(list.type; stack, default none;
                   1260: fixed []
                   1261: calculated []
                   1262: none [])
                   1263: 
                   1264: |attribute(list.spacing; stack, default off;
                   1265: off []
                   1266: on [])
                   1267: 
                   1268: |attribute(verbatim; stack, default off;
                   1269: off []
                   1270: on [])
                   1271: 
                   1272: |attribute(draft; stack, default off;
                   1273: off []
                   1274: on [])
                   1275: 
                   1276: |attribute(sectioning; stack, default bysection;
                   1277: bysection []
                   1278: bychapter []
                   1279: byappendix [])
                   1280: 
                   1281: |attribute(globalparagraph.style; stack, default flushed;
                   1282: indented []
                   1283: numbered []
                   1284: flushed [])
                   1285: 
                   1286: |attribute(localparagraph.style; stack, default flushed;
                   1287: indented []
                   1288: numbered []
                   1289: flushed [])
                   1290: 
                   1291: |attribute(inline; stack, default on;
                   1292: off []
                   1293: on [])
                   1294: 
                   1295: |attribute(footnote_width; stack, default normal;
                   1296: narrow []
                   1297: full []
                   1298: normal[])
                   1299: 
                   1300: |attribute(around_width; stack, default normal;
                   1301: narrow []
                   1302: full []
                   1303: normal[])
                   1304: 
                   1305: |attribute(sawreference; stack, default off;
                   1306: off []
                   1307: on [])
                   1308: 
                   1309: |attribute(sawabstract; stack, default off;
                   1310: off []
                   1311: on [])
                   1312: 
                   1313: |attribute(sawkeywords; stack, default off;
                   1314: off []
                   1315: on [])
                   1316: 
                   1317: |attribute(sawoverflow; stack, default off;
                   1318: off []
                   1319: on [])
                   1320: 
                   1321: |attribute(sawtitlebox; stack, default off;
                   1322: off []
                   1323: on [])
                   1324: 
                   1325: |attribute(sawendnote; stack, default off;
                   1326: off []
                   1327: on [])

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.