# ratmod.rfr - rt-11 version of the ratfor translator - modified routines. ######################################################################## # # This is a modified version of a program from Software Tools, Brian W. # Kernighan and P.J. Plauger, (Addison-Wesley, 1976) which was originally # obtained from Bell Laboratories. # ######################################################################## include ratdef define(commonblocks,ratcom) # ratfor - main program for Ratfor program ratfor call initio call parse call closo call exit end # synerr - report Ratfor syntax error subroutine synerr(msg) character msg(MAXLINE) integer itoc integer i include commonblocks # include cline call remark("error at line.") i = 1 repeat { call outnum(linect(i)) i = i+1 } until (i > level) call outch (COLON) call outch (CR) call outch (NEWLINE) type 10,(linect(i),i=1,level) 10 format (5i7, ':') call remark(msg) return end # remark - print warning message. # G. M. Selzer 5-MAR-80 subroutine remark (buf) byte buf(ARB) integer*2 i, length, wbuf(60) for (length=1; buf(length)^=0; length=length+1) wbuf(length) = buf(length) wbuf(length) = EOS call outstr(wbuf) length = length-1 type 10, (buf(i), i=1, length) 10 format (' ',80a1) return end # putch - output a single character. # G. M. Selzer subroutine putch (c) character c integer wcnt include commonblocks # include coutln if (obufp >= obuff+osize) { # output a buffer. wcnt = osize/2 ostat = iwritw(wcnt,obuf(obuff),oblk,ochan) if (ostat <= -1) call ferror("putch: write err") obufp = obuff oblk = oblk+ostat/256 } obuf(obufp) = c obufp = obufp+1 return end # parse - parse Ratfor source program subroutine parse include ratstk character lexstr(MAXTOK) integer lex integer lab, labval(MAXSTACK), lextyp(MAXSTACK), token call initkw # install keywords in table sp = 1 lextyp(1) = EOF for (token = lex(lexstr); token ^= EOF; token = lex(lexstr)) { if (token == LEXIF) call ifcode(lab) else if (token == LEXDO) call docode(lab) else if (token == LEXWHILE) call whilec(lab) else if (token == LEXFOR) call forcod(lab) else if (token == LEXREPEAT) call repcod(lab) else if (token == LEXDIGITS) call labelc(lexstr) else if (token == LEXELSE) { if (lextyp(sp) == LEXIF) call elseif(labval(sp)) else call synerr("illegal else.") } if (token==LEXIF | token==LEXELSE | token==LEXWHILE | token==LEXFOR | token==LEXREPEAT | token==LEXDO | token==LEXDIGITS | token==LBRACE) { sp = sp + 1 # beginning of statement if (sp > MAXSTACK) call error("stack overflow in parser.") lextyp(sp) = token # stack type and value labval(sp) = lab } else { # end of statement - prepare to unstack if (token == RBRACE) { if (lextyp(sp) == LBRACE) sp = sp - 1 else call synerr("illegal right brace.") } else if (token == LEXOTHER) call otherc(lexstr) else if (token == LEXBREAK | token == LEXNEXT) call brknxt(sp, lextyp, labval, token) token = lex(lexstr) # peek at next token call pbstr(lexstr) call unstak(sp, lextyp, labval, token) } } if (sp ^= 1) call synerr("unexpected EOF.") return end # outtab - get past column 6 subroutine outtab include commonblocks # include coutln include ratstk if (outp < 7) { # start of line call outch (TAB) outp = 6 for (i=2; i<=sp; i=i+1) { call outch (BLANK) call outch (BLANK) call outch (BLANK) } } else { outp = outp +8 call outch (TAB) } return end # outstr - output string subroutine outstr(str) character c, str(ARB) integer i, j, k for (i = 1; str(i) ^= EOS; i = i + 1) { c = str(i) if (c ^= SQUOTE & c ^= DQUOTE) call outch(c) else { i = i + 1 for (j = i; str(j) ^= c; j = j + 1) # find end ; call outnum(j-i) if (str(j+1) == LETR) { # radix-50 string. call outch (LETR) k = j+1 } else { call outch (LETH) k = j } for ( ; i < j; i = i + 1) call outch(str(i)) i = k } } return end # outdon - finish off an output line subroutine outdon include commonblocks # include coutln call putch(CR) call putch(NEWLINE) outp = 0 return end # outch - put one character into output buffer subroutine outch(c) character c integer i include commonblocks # include coutln if (outp >= 72) { # continuation card call outdon call putch (TAB) call putch (STAR) outp = 6 } outp = outp + 1 if (c == BACKSLASH) # marker for octal number. c = DQUOTE call putch(c) return end # openo - open output file. # G.M. Selzer 20-Feb-80 subroutine openo(dblk, length) integer*2 dblk(4), length, i include commonblocks # include coutln ochan = igetc() if (ochan <= -1) call ferror("openo: igetc err") i = ienter(ochan, dblk, length) if (i < 0) call ferror("openo: ienter err") return end # openio - open a file for processing. # G. M. Selzer 14-Feb-80 integer function openio (name) character name(MAXNAME) byte bname(MAXNAME) integer*2 chan, i, wcnt, blkn integer*2 filspc(39), deftyp(4) integer*2 r50rfi,device data deftyp/4*"RFR"r/ data r50rfi /"RFI"r/ include commonblocks # include ciobuf # include cline chan = igetc() if (chan <= -1) call ferror ("openio: igetc err") for (i=1; name(i)^=EOS; i=i+1) # convert i*2 -> b. bname(i) = name(i) bname(i) = 0 if (level > 0) deftyp (1) = r50rfi i = icsi(filspc,deftyp,bname,,0) if (i ^= 0) call ferror("openio: icsi err") if (level == 0) # set default input device. device = filspc(16) else filspc(16) = device call r50asc (12, filspc(16), bname) type 10, (bname(i), i=1,12) 10 format(' file being opened: ',3a1,':',6a1,'.',3a1) i = lookup (chan, filspc(16)) if (i<=0) call ferror ("openio: lookup err") inbufb = inbufb + 2*insize inbuff(level+1) = inbufb inbufe(level+1) = inbufb+insize inbufp(level+1) = inbufb+insize wcnt = insize/2 blkn = 0 instat(level+1) = iread(wcnt,inbuf(inbufe(level+1)),blkn,chan) blk(level+1) = 0 openio = chan return end # look - locate name, extract definition from table integer function look(name, defn) character defn(MAXDEF), name(MAXTOK) integer i, j, k include commonblocks # include clook for (i = lastp; i > 0; i = i - 1) { j = namptr(i) for (k = 1; name(k) == table(j) & name(k) ^= EOS; k = k + 1) j = j + 1 if (name(k) == table(j)) { # got one call scopy(table, j+1, defn, 1) look = YES return } } look = NO return end # initio - set up for syslib io. # G. M. Selzer subroutine initio integer*2 name(30), openio integer*2 filspc(39), deftyp(4), ier, i, pos1 byte cstrng(81), prompt(2) equivalence (cstrng, inbuf(1)), (filspc,obuf(83)), (name, obuf(171)) data deftyp /"RFR"r, "FOR"r, "LST"r, "DAT"r/ data prompt /'*', 128/ include commonblocks # include cline # include ciobuf insize = 512 inbufb = 1-2*insize repeat { call gtlin (cstrng,prompt) if (cstrng(1) == 0) { type 20 20 format (" ratfor v01.00 "/) } } until (cstrng(1) ^= 0) for (i=1; cstrng(i)^=0; i=i+1) name(i) = cstrng(i) name(i) = EOS pos1 = index(name,"=")+1 level = 0 infile(1) = openio(name(pos1)) level = 1 osize = 512 obuff = 1 obufp = 1 oblk = 0 ier = icsi(filspc,deftyp,cstrng,,0) if(ier ^= 0) call ferror("initio: ill icsi command string") call openo (filspc(1), filspc(5)) return end # gtok - get token for Ratfor character function gtok(lexstr, toksiz, fd) character ngetch, type integer fd, i, toksiz character c, lexstr(toksiz) include commonblocks # include cline while (ngetch(c, fd) ^= EOF) if (c ^= BLANK & c ^= TAB) break call putbak(c) for (i = 1; i < toksiz-1; i = i + 1) { gtok = type(ngetch(lexstr(i), fd)) if (gtok ^= LETTER & gtok ^= DIGIT) break } if (i >= toksiz-1) call synerr("token too long.") if (i > 1) { # some alpha seen call putbak(lexstr(i)) # went one too far lexstr(i) = EOS gtok = ALPHA } else if (lexstr(1) == DOLLAR) { # allow $( and $) for { and } if (ngetch(lexstr(2), fd) == LPAREN) { lexstr(1) = LBRACE gtok = LBRACE } else if (lexstr(2) == RPAREN) { lexstr(1) = RBRACE gtok = RBRACE } else call putbak(lexstr(2)) } else if (lexstr(1) == SQUOTE | lexstr(1) == DQUOTE) { for (i = 2; ngetch(lexstr(i), fd) ^= lexstr(1); i = i + 1) if (lexstr(i) == NEWLINE | i >= toksiz-1) { call synerr("missing quote.") lexstr(i) = lexstr(1) call putbak(NEWLINE) break } i = i+1 If (ngetch(lexstr(i),fd) == BIGR) lexstr(i) = LETR if (lexstr(i) ^= LETR) { # rad-50 string ? call putbak (lexstr(i)) i = i-1 } } else if (lexstr(1) == SHARP) { # strip comments while (ngetch(lexstr(1), fd) ^= NEWLINE) ; gtok = NEWLINE } else if (lexstr(1) == GREATER | lexstr(1) == LESS | lexstr(1) == NOT | lexstr(1) == EQUALS | lexstr(1) == AMPER | lexstr(1) == BAR) call relate(lexstr, i, fd) lexstr(i+1) = EOS if (lexstr(1) == NEWLINE) linect(level) = linect(level) + 1 return end # gettok - get token. handles file inclusion and line numbers character function gettok(token, toksiz) integer equal, openio integer junk, toksiz character deftok character name(MAXNAME), token(toksiz) include commonblocks # include cline # string incl "include" integer incl(8) data incl(1) /LETI/ data incl(2) /LETN/ data incl(3) /LETC/ data incl(4) /LETL/ data incl(5) /LETU/ data incl(6) /LETD/ data incl(7) /LETE/ data incl(8) /EOS/ for ( ; level > 0; level = level - 1) { for (gettok = deftok(token, toksiz, infile(level)); gettok ^= EOF; gettok = deftok(token, toksiz, infile(level))) { if (equal(token, incl) == NO) return junk = deftok(name, MAXNAME, infile(level)) if (level >= NFILES) call ferror("includes nested too deeply.") else { infile(level+1) = openio(name) linect(level+1) = 1 level = level + 1 } } if (level > 1) call closio(infile(level)) } gettok = EOF return end # getch - get character from file. # G.M. Selzer 14-Feb-80. character function getch (c, f) character c integer wcnt, blkn, chan, itemp include commonblocks # include cline # include ciobuf # type *,"level,inbufp,inbuff,inbufe", # level,inbufp(level),inbuff(level),inbufe(level) # type *,"instat,insize,infile,blk", # instat(level),insize,infile(level),blk(level) # type 9999,(inbuf(iii),iii=inbufp(level),inbufp(level)+5) # 9999 format (50x,10a1) repeat { if (inbufp(level)>=inbuff(level)+insize) { # get another buf. wcnt = insize/2 chan = infile(level) i = iwait (chan) # wait for outstanding read # to complete. if (i ^= 0) call ferror ("getch: wait err") if (instat(level) <= -2) call ferror ("getch: read err") if (instat(level) == -1) { c = EOF getch = EOF return } if (instat(level) < wcnt) inbuf(inbufe(level)+2*instat(level)) = EOF itemp = inbuff(level) #switch buffer pointers. inbuff(level) = inbufe(level) inbufe(level) = itemp inbufp(level) = inbuff(level) blk(level) = blk(level)+instat(level)/256 blkn = blk(level) instat(level) = iread(wcnt,inbuf(inbufe(level)),blkn, chan) } getch = inbuf(inbufp(level)) inbufp(level) = inbufp(level)+1 } until (getch==EOF | (getch^=0 & getch^=CR)) getch = intran(getch) c = getch return end # ferror - report fatal error and trigger traceback. # G.M. Selzer 14-Feb-80 subroutine ferror (msg) integer*2 length byte msg(81) length = len(msg) type 10, (msg(i),i=1,length) 10 format (' ',80a1) # type 20 # 20 format (' Traceback follows: ') # r = r / 0. # trigger fortran traceback. call exit return end # deftok - get token; process macro calls and invocations character function deftok(token, toksiz, fd) character gtok integer fd, toksiz character defn(MAXDEF), t, token(toksiz) integer look for (t=gtok(token, toksiz, fd); t^=EOF; t=gtok(token, toksiz, fd)) { if (t ^= ALPHA) # non-alpha break if (look(token, defn) == NO) # undefined break if (defn(1) == DEFTYPE) { # get definition call getdef(token, toksiz, defn, MAXDEF, fd) call instal(token, defn) } else call pbstr(defn) # push replacement onto input } deftok = t if (deftok == ALPHA) # convert to single case call fold(token) return end # closo - closo output file. # G. M. Selzer 20-Feb-80 subroutine closo integer ptr, wcnt include commonblocks # include coutln if (obufp ^= obuff+osize-1) # flush output buffer. for (ptr = obuff+osize-1; ptr >= obufp; ptr = ptr-1) # zero out rest of buffer. obuf(ptr) = 0 wcnt = osize/2 ostat = iwritw(wcnt,obuf(obuff),oblk,ochan) if (ostat <= -1) call ferror("closo: write err") call closec (ochan) call ifreec (ochan) return end # closio - close input file. # G. M. Selzer 14-Feb-80. subroutine closio (fd) integer fd include commonblocks # include cline call closec (fd) call ifreec(fd) inbufb = inbufb - 2*insize return end # block data - initialize global variables block data include commonblocks # include coutln # include cline # include cdefio # include cfor # include clook # include ckeywd # include cchar # output character pointer: data outp /0/ # file control: data linect(1) /1/ # pushback buffer pointer: data bp /0/ # depth of for stack: data fordep /0/ # pointers for table lookup code: data lastp /0/ data lastt /0/ # keywords: data sdo(1), sdo(2), sdo(3) /LETD, LETO, EOS/ data vdo(1), vdo(2) /LEXDO, EOS/ data sif(1), sif(2), sif(3) /LETI, LETF, EOS/ data vif(1), vif(2) /LEXIF, EOS/ data selse(1), selse(2), selse(3), selse(4), selse(5) /LETE, LETL, LETS, LETE, EOS/ data velse(1), velse(2) /LEXELSE, EOS/ data swhile(1), swhile(2), swhile(3), swhile(4), swhile(5), swhile(6) /LETW, LETH, LETI, LETL, LETE, EOS/ data vwhile(1), vwhile(2) /LEXWHILE, EOS/ data sbreak(1), sbreak(2), sbreak(3), sbreak(4), sbreak(5), sbreak(6) /LETB, LETR, LETE, LETA, LETK, EOS/ data vbreak(1), vbreak(2) /LEXBREAK, EOS/ data snext(1), snext(2), snext(3), snext(4), snext(5) /LETN, LETE, LETX, LETT, EOS/ data vnext(1), vnext(2) /LEXNEXT, EOS/ data sfor(1), sfor(2), sfor(3), sfor(4) /LETF, LETO, LETR, EOS/ data vfor(1), vfor(2) /LEXFOR, EOS/ data srept(1), srept(2), srept(3), srept(4), srept(5), srept(6), srept(7) /LETR, LETE, LETP, LETE, LETA, LETT, EOS/ data vrept(1), vrept(2) /LEXREPEAT, EOS/ data suntil(1), suntil(2), suntil(3), suntil(4), suntil(5), suntil(6) /LETU, LETN, LETT, LETI, LETL, EOS/ data vuntil(1), vuntil(2) /LEXUNTIL, EOS/ # character set definitions: data extblk /' '/, intblk /BLANK/ data extdig(1) /'0'/, intdig(1) /DIG0/ data extdig(2) /'1'/, intdig(2) /DIG1/ data extdig(3) /'2'/, intdig(3) /DIG2/ data extdig(4) /'3'/, intdig(4) /DIG3/ data extdig(5) /'4'/, intdig(5) /DIG4/ data extdig(6) /'5'/, intdig(6) /DIG5/ data extdig(7) /'6'/, intdig(7) /DIG6/ data extdig(8) /'7'/, intdig(8) /DIG7/ data extdig(9) /'8'/, intdig(9) /DIG8/ data extdig(10) /'9'/, intdig(10) /DIG9/ # normal case of letters data extlet(1) /'a'/, intlet(1) /LETA/ data extlet(2) /'b'/, intlet(2) /LETB/ data extlet(3) /'c'/, intlet(3) /LETC/ data extlet(4) /'d'/, intlet(4) /LETD/ data extlet(5) /'e'/, intlet(5) /LETE/ data extlet(6) /'f'/, intlet(6) /LETF/ data extlet(7) /'g'/, intlet(7) /LETG/ data extlet(8) /'h'/, intlet(8) /LETH/ data extlet(9) /'i'/, intlet(9) /LETI/ data extlet(10) /'j'/, intlet(10) /LETJ/ data extlet(11) /'k'/, intlet(11) /LETK/ data extlet(12) /'l'/, intlet(12) /LETL/ data extlet(13) /'m'/, intlet(13) /LETM/ data extlet(14) /'n'/, intlet(14) /LETN/ data extlet(15) /'o'/, intlet(15) /LETO/ data extlet(16) /'p'/, intlet(16) /LETP/ data extlet(17) /'q'/, intlet(17) /LETQ/ data extlet(18) /'r'/, intlet(18) /LETR/ data extlet(19) /'s'/, intlet(19) /LETS/ data extlet(20) /'t'/, intlet(20) /LETT/ data extlet(21) /'u'/, intlet(21) /LETU/ data extlet(22) /'v'/, intlet(22) /LETV/ data extlet(23) /'w'/, intlet(23) /LETW/ data extlet(24) /'x'/, intlet(24) /LETX/ data extlet(25) /'y'/, intlet(25) /LETY/ data extlet(26) /'z'/, intlet(26) /LETZ/ # upper case of letters data extbig(1) /'A'/, intbig(1) /BIGA/ data extbig(2) /'B'/, intbig(2) /BIGB/ data extbig(3) /'C'/, intbig(3) /BIGC/ data extbig(4) /'D'/, intbig(4) /BIGD/ data extbig(5) /'E'/, intbig(5) /BIGE/ data extbig(6) /'F'/, intbig(6) /BIGF/ data extbig(7) /'G'/, intbig(7) /BIGG/ data extbig(8) /'H'/, intbig(8) /BIGH/ data extbig(9) /'I'/, intbig(9) /BIGI/ data extbig(10) /'J'/, intbig(10) /BIGJ/ data extbig(11) /'K'/, intbig(11) /BIGK/ data extbig(12) /'L'/, intbig(12) /BIGL/ data extbig(13) /'M'/, intbig(13) /BIGM/ data extbig(14) /'N'/, intbig(14) /BIGN/ data extbig(15) /'O'/, intbig(15) /BIGO/ data extbig(16) /'P'/, intbig(16) /BIGP/ data extbig(17) /'Q'/, intbig(17) /BIGQ/ data extbig(18) /'R'/, intbig(18) /BIGR/ data extbig(19) /'S'/, intbig(19) /BIGS/ data extbig(20) /'T'/, intbig(20) /BIGT/ data extbig(21) /'U'/, intbig(21) /BIGU/ data extbig(22) /'V'/, intbig(22) /BIGV/ data extbig(23) /'W'/, intbig(23) /BIGW/ data extbig(24) /'X'/, intbig(24) /BIGX/ data extbig(25) /'Y'/, intbig(25) /BIGY/ data extbig(26) /'Z'/, intbig(26) /BIGZ/ # special characters. some of these may # change for your machine data extchr(1) /'!'/, intchr(1) /NOT/ # use exclam for not-sign data extchr(2) /'"'/, intchr(2) /DQUOTE/ data extchr(3) /"#"/, intchr(3) /SHARP/ data extchr(4) /'$'/, intchr(4) /DOLLAR/ data extchr(5) /'%'/, intchr(5) /PERCENT/ data extchr(6) /'&'/, intchr(6) /AMPER/ data extchr(7) /"'"/, intchr(7) /SQUOTE/ data extchr(8) /'('/, intchr(8) /LPAREN/ data extchr(9) /')'/, intchr(9) /RPAREN/ data extchr(10) /'*'/, intchr(10) /STAR/ data extchr(11) /'+'/, intchr(11) /PLUS/ data extchr(12) /','/, intchr(12) /COMMA/ data extchr(13) /'-'/, intchr(13) /MINUS/ data extchr(14) /'.'/, intchr(14) /PERIOD/ data extchr(15) /'/'/, intchr(15) /SLASH/ data extchr(16) /':'/, intchr(16) /COLON/ data extchr(17) /';'/, intchr(17) /SEMICOL/ data extchr(18) /'<'/, intchr(18) /LESS/ data extchr(19) /'='/, intchr(19) /EQUALS/ data extchr(20) /'>'/, intchr(20) /GREATER/ data extchr(21) /'?'/, intchr(21) /QMARK/ data extchr(22) /'@'/, intchr(22) /ATSIGN/ data extchr(23) /'['/, intchr(23) /LBRACK/ data extchr(24) /'\'/, intchr(24) /BACKSLASH/ data extchr(25) /']'/, intchr(25) /RBRACK/ data extchr(26) /'_'/, intchr(26) /UNDERLINE/ data extchr(27) /'{'/, intchr(27) /LBRACE/ data extchr(28) /'|'/, intchr(28) /BAR/ data extchr(29) /'}'/, intchr(29) /RBRACE/ data extchr(32) /'^'/, intchr(32) /NOT/ # use caret for not-sign data extchr(33) /'~'/, intchr(33) /NOT/ # use tilde for not-sign data extchr(31) /' '/, intchr(31) /TAB/ data extchr(30) /1H /, intchr(30) /BACKSPACE/ # NCHARS is last subscript in this array # intran is the input translation table. Input translation is performed # by using input characters as indices into this table. data intran(1) /1/ data intran(2) /2/ data intran(3) /3/ data intran(4) /4/ data intran(5) /5/ data intran(6) /6/ data intran(7) /7/ data intran(8) /8/ data intran(9) /9/ data intran(10) /10/ data intran(11) /11/ data intran(12) /12/ data intran(13) /13/ data intran(14) /14/ data intran(15) /15/ data intran(16) /16/ data intran(17) /17/ data intran(18) /18/ data intran(19) /19/ data intran(20) /20/ data intran(21) /21/ data intran(22) /22/ data intran(23) /23/ data intran(24) /24/ data intran(25) /25/ data intran(26) /26/ data intran(27) /27/ data intran(28) /28/ data intran(29) /29/ data intran(30) /30/ data intran(31) /31/ data intran(32) /32/ data intran(33) /33/ data intran(34) /34/ data intran(35) /35/ data intran(36) /36/ data intran(37) /37/ data intran(38) /38/ data intran(39) /39/ data intran(40) /40/ data intran(41) /41/ data intran(42) /42/ data intran(43) /43/ data intran(44) /44/ data intran(45) /45/ data intran(46) /46/ data intran(47) /47/ data intran(48) /48/ data intran(49) /49/ data intran(50) /50/ data intran(51) /51/ data intran(52) /52/ data intran(53) /53/ data intran(54) /54/ data intran(55) /55/ data intran(56) /56/ data intran(57) /57/ data intran(58) /58/ data intran(59) /59/ data intran(60) /60/ data intran(61) /61/ data intran(62) /62/ data intran(63) /63/ data intran(64) /64/ data intran(65) /65/ data intran(66) /66/ data intran(67) /67/ data intran(68) /68/ data intran(69) /69/ data intran(70) /70/ data intran(71) /71/ data intran(72) /72/ data intran(73) /73/ data intran(74) /74/ data intran(75) /75/ data intran(76) /76/ data intran(77) /77/ data intran(78) /78/ data intran(79) /79/ data intran(80) /80/ data intran(81) /81/ data intran(82) /82/ data intran(83) /83/ data intran(84) /84/ data intran(85) /85/ data intran(86) /86/ data intran(87) /87/ data intran(88) /88/ data intran(89) /89/ data intran(90) /90/ data intran(91) /91/ data intran(92) /92/ data intran(93) /93/ data intran(94) /33/ # caret -> "BANG" data intran(95) /95/ data intran(96) /96/ # data intran(97) /65/ # translate lower case to upper case. # data intran(98) /66/ # data intran(99) /67/ # data intran(100) /68/ # data intran(101) /69/ # data intran(102) /70/ # data intran(103) /71/ # data intran(104) /72/ # data intran(105) /73/ # data intran(106) /74/ # data intran(107) /75/ # data intran(108) /76/ # data intran(109) /77/ # data intran(110) /78/ # data intran(111) /79/ # data intran(112) /80/ # data intran(113) /81/ # data intran(114) /82/ # data intran(115) /83/ # data intran(116) /84/ # data intran(117) /85/ # data intran(118) /86/ # data intran(119) /87/ # data intran(120) /88/ # data intran(121) /89/ # data intran(122) /90/ data intran(97) /97/ # don't translate lower to upper case.DK:A.TMP data intran(98) /98/ data intran(99) /99/ data intran(100) /100/ data intran(101) /101/ data intran(102) /102/ data intran(103) /103/ data intran(104) /104/ data intran(105) /105/ data intran(106) /106/ data intran(107) /107/ data intran(108) /108/ data intran(109) /109/ data intran(110) /110/ data intran(111) /111/ data intran(112) /112/ data intran(113) /113/ data intran(114) /114/ data intran(115) /115/ data intran(116) /116/ data intran(117) /117/ data intran(118) /118/ data intran(119) /119/ data intran(120) /120/ data intran(121) /121/ data intran(122) /122/ data intran(123) /123/ data intran(124) /124/ data intran(125) /125/ data intran(126) /126/ data intran(127) /127/ end