billr@saab.CNA.TEK.COM (Bill Randle) (02/24/90)
Submitted-by: Izchak Miller <izchak@linc.cis.upenn.edu>
Posting-number: Volume 9, Issue 27
Archive-name: NetHack3/Patch7aa
Patch-To: NetHack3: Volume 7, Issue 56-93
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 27 (of 30)."
# Contents: others/ovlmgr.asm src/lev_lex.c
# Wrapped by billr@saab on Wed Feb 21 10:04:50 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'others/ovlmgr.asm' -a "${1}" != "-c" ; then
echo shar: Renaming existing file \"'others/ovlmgr.asm'\" to \"'others/ovlmgr.asm.orig'\"
mv -f 'others/ovlmgr.asm' 'others/ovlmgr.asm.orig'
fi
echo shar: Extracting \"'others/ovlmgr.asm'\" \(30539 characters\)
sed "s/^X//" >'others/ovlmgr.asm' <<'END_OF_FILE'
X; SCCS Id: @(#)ovlmgr.asm 3.0.624 90/02/18
X; Copyright (c) Pierre Martineau and Stephen Spackman, 1989, 1990.
X; This product may be freely redistributed. See NetHack license for details.
X
X PAGE 60,132
X TITLE 'Overlay manager for use with Microsoft overlay linker'
X SUBTTL 'Brought to you by Pierre Martineau and Stephen Spackman'
X
X; acknowledgements: - No thanks to Microsoft
X; - alltrsidsctysti!!!
X; - izchak and friends for impetus
X; - us for brilliance
X; - coffee for speed
X; - others as necessary
X
X; assumptions: - all registers are preserved including flags
X; - the stack is preserved
X; - re-entrancy is not rEQUired
X
XDOSALLOC EQU 48h ; memory allocation
XDOSFREE EQU 49h ; free allocated memory
XDOSREALLOC EQU 4ah ; modify memory block
XDOSREAD EQU 3fh ; read bytes from handle
XDOSSEEK EQU 42h ; logical handle seek
XDOSOPEN EQU 3dh ; open handle
XDOSCLOSE EQU 3eh ; close handle
XDOSGETVEC EQU 35h ; get interrupt vector
XDOSSETVEC EQU 25h ; set interrupt vector
XDOSEXEC EQU 4bh ; exec child process
XDOS EQU 21h ; Dos interrupt #
XPRINT EQU 09h ; print string
XTERMINATE EQU 4ch ; terminate process
XCR EQU 0dh
XLF EQU 0ah
XBELL EQU 07h
XFAERIE EQU 0h ; Used for dummy segment allocation
XPARSIZ EQU 10h ; this is the size of a paragraph - this better not change!
X
X; The following EXTRNs are supplied by the linker
X
XEXTRN $$OVLBASE:BYTE ; segment of OVERLAY_AREA
XEXTRN $$MPGSNOVL:BYTE ; ^ to module table
XEXTRN $$MPGSNBASE:WORD ; ^ to module segment fixups
XEXTRN $$INTNO:BYTE ; interrupt number to be used
XEXTRN $$COVL:WORD ; number of physical overlays
XEXTRN $$CGSN:WORD ; number of modules
XEXTRN $$MAIN:FAR ; ^ to function main()
X
XPUBLIC $$OVLINIT ; Our entry point
X ; called by the c startup code
X
Xovlflgrec RECORD running:1=0,locked:1=0,loaded:1=0 ; overlay flags
X
X; This is a dirty hack. What we need is a virtual segment that will be built
X; by the (our) loader in multiple copies, one per overlay. Unfortunately, this
X; doesn't seem to be a sensible idea in the minds of the folks at Microsoft.
X; Declaring this segment AT will ensure that it never appears in the exefile,
X; and ASSUME is dumb enough to be fooled.
X;
X; The reason we want to do this is also not-to-be-tried-at-home: it turns out
X; that we can code a faster interrupt handler if we map overlay numbers to
X; segment values. Normally I would consider this unacceptable programming
X; practise because it is 86-mode specific, but the *need* for this entire
X; programme is 86-mode specific, anyway.
X
Xpspseg SEGMENT PARA AT FAERIE ; dummy segment for psp
X ORG 2ch ; ^ to segment of environmemt in psp
Xpspenv LABEL WORD
Xpspseg ENDS
X
Xovltbl SEGMENT PARA AT FAERIE ; Dummy segment definition for overlay table
X
X; NOTE: This segment definition MUST be exactly 16 bytes long
X
Xovlflg ovlflgrec <0,0,0> ; overlay flags
Xovltblpad1 DB ? ; go ahead, delete me!
Xovlmemblk DW ? ; ^ to allocated memory block
Xovllrudat DD ? ; misc lru data (pseudo time stamp)
Xovlseg DW ? ; ovl segment physical add.
Xovlfiloff DW ? ; ovl file offset in pages (512 bytes)
Xovlsiz DW ? ; ovl size in paragraphs
Xovltblpad DB PARSIZ - ($ - ovlflg) MOD PARSIZ DUP (?) ; pad to 16 bytes
X
XIF1
XIF ($ - ovlflg) GT PARSIZ
X .ERR
X %OUT This segment MUST be no more than 16 bytes, REALLY!!!
XENDIF
XENDIF
X
XOVLSEGSIZ EQU PARSIZ ; this had better be true!!! (16 bytes)
X
Xovltbl ENDS
X
XEXEHDR STRUC ; structure of an EXE header
Xexesign DW 5a4dh ; signature
Xexelstpgesiz DW ? ; last page size (512 byte pages)
Xexesiz DW ? ; total pages (including partial last page)
Xrelocitems DW ? ; number of relocation entries
Xhdrparas DW ? ; number of paragraphs in the header
Xminalloc DW ? ; minimum paragraph allocation
Xmaxalloc DW ? ; maximum patagraph allocation
Xexess DW ? ; initial stack segment
Xexesp DW ? ; initial stack pointer
Xexechksum DW ? ; checksum
Xexeip DW ? ; initial instruction pointer
Xexecs DW ? ; initial code segment
Xreloctbloff DW ? ; offset from beginning of header to relocation table
Xexeovlnum DW ? ; overlay number
XEXEHDR ENDS
X
XMASK_used EQU 1 ; memory block flag
X
XMEMCTLBLK STRUC ; memory block structure
Xmemblkflg DB ? ; flags
Xmemblkpad1 DB ? ; go ahead, delete me!
Xmemblknxt DW ? ; ^ to next block
Xmemblkprv DW ? ; ^ to previous block
Xmemblkovl DW ? ; ^ to overlay occupying this block
Xmemblksiz DW ? ; size in paragraphs
Xmemblkpad DB PARSIZ - memblkpad MOD PARSIZ DUP (?) ; pad to 16 bytes
XMEMCTLBLK ENDS
X
XMEMCTLBLKSIZ EQU TYPE MEMCTLBLK / PARSIZ ; should equal 1 paragraph
X
X;-------------------------------------------------------------------------------
X
Xcode SEGMENT PUBLIC
X
X; NOTE: the following order is optimum for alignement purposes accross the
X; entire INTEL 80x86 family of processors.
X
Xovltim DD ? ; pseudo-lru time variable
Xfarcall DD ? ; internal trampoline.
Xoldvec DD -1 ; saved interrupt vector
Xoldint21 DD -1 ; saved int 21 vector
Xovlexefilhdl DW -1 ; always-open file handle of our .EXE
Xovltblbse DW -1 ; segment of first overlay descriptor
Xovlcnt DW ? ; # overlays
Xmodcnt DW ? ; # of modules
Xovlrootcode DW ? ; logical segment of OVERLAY_AREA
Xovldata DW ? ; logical segment of OVERLAY_END
Xmemblk1st DW ? ; first memory block
Xpspadd DW ? ; our psp address + 10h (for relocations)
Xbxreg DW ? ; temp save area
Xesreg DW ? ; temp save area
Xmoduletbl DD 256 DUP (?) ; module lookup table (256 modules)
Xcurovl DW OFFSET stkframe ; ^ into stack frame
Xstkframe DW 64*3 DUP (?) ; internal stack (64 ovls deep)
Xhdr EXEHDR <> ; EXE header work area
Xintnum DB ? ; overlay interrupt number
X
Xnoroom DB CR,LF,'Not enough memory to run this program. Time to go to the store.',CR,LF,BELL,'$'
Xnocore DB CR,LF,'Your dog eats all your remaining memory! You die.',CR,LF,BELL,'$'
Xnofile DB CR,LF,'The Nymph stole your .EXE file! You die.',CR,LF,BELL,'$'
Xexitmsg DB CR,LF,'$'
X
X;-------------------------------------------------------------------------------
X
X$$OVLINIT PROC FAR ; Init entry point
X
X ASSUME CS:code,DS:pspseg,ES:NOTHING
X
X push ax
X push bx
X push cx
X push dx
X push si
X push di
X push bp
X push ds
X push es ; save the world
X mov ax,ds ; get our psp
X add ax,10h
X mov pspadd,ax ; save it
X mov ds,pspenv ; get environment segment
X mov si,-1
Xenvloop: ; search for end of environment
X inc si
X cmp WORD PTR [si],0
X jnz envloop
X add si,4 ; point to EXE filename
X mov al,0 ; access code
X mov ah,DOSOPEN
X mov dx,si
X int DOS ; open EXE
X jnc dontdie
X mov al,5
X mov dx,OFFSET nofile
X jmp putserr ; cry to the world!
Xdontdie:
X mov ovlexefilhdl,ax ; save handle
X mov ax,SEG $$OVLBASE ; OVERLAY_AREA segment
X mov ovlrootcode,ax
X
X; Now allocate memory
X mov bx,0900h ; allocate memory for malloc()
X mov ah,DOSALLOC
X int DOS
X jnc getmore
X jmp buyram
Xgetmore:
X mov es,ax ; find largest free memory
X mov ah,DOSALLOC
X mov bx,0ffffh ; Everything
X int DOS
X mov ah,DOSALLOC ; allocate our own memory
X int DOS
X jnc gotitall
X jmp buyram
Xgotitall:
X mov ovltblbse,ax ; overlay descriptor table begins at start of memory block
X mov ax,SEG $$COVL ; segment of DGROUP
X mov ds,ax
X mov cx,$$CGSN ; number of modules
X mov modcnt,cx ; save for later use
X mov cx,$$COVL ; number of physical overlays
X mov ovlcnt,cx ; save for later use
X sub bx,cx ; enough mem for ovl tbl?
X jnc memloop
X jmp buyram
Xmemloop:
X push bx
X mov ah,DOSFREE ; free first block for malloc()
X int DOS
X jnc cockadoodledoo
X jmp buyram
Xcockadoodledoo:
X
X ASSUME ES:ovltbl
X
X xor bp,bp
X xor di,di
X xor si,si
Xfilsegtbllpp: ; initialise ovl table
X call gethdr ; get an EXE header
X mov ax,ovltblbse
X add ax,hdr.exeovlnum
X mov es,ax ; ^ to ovl table entry
X xor ax,ax
X mov WORD PTR ovllrudat,ax ; initialise ovl lru
X mov WORD PTR ovllrudat+2,ax
X mov ovlseg,ax ; initialise ovl segment
X mov ovlflg,al ; initialise ovl flags
X mov ax,hdr.exesiz
X shl ax,1
X shl ax,1
X shl ax,1
X shl ax,1
X shl ax,1 ; * 32
X mov dx,hdr.exelstpgesiz
X or dx,dx
X jz emptypage
X shr dx,1
X shr dx,1
X shr dx,1
X shr dx,1 ; / 16
X inc dx
X sub ax,20h
X add ax,dx
Xemptypage:
X mov ovlsiz,ax ; overlay size in paragraphs
X sub ax,hdr.hdrparas ; actual size of code and relocation table
X cmp hdr.exeovlnum,0 ; skip if ovl 0 (root code)
X jz notlargest
X cmp ax,di ; find largest ovl
X jc notlargest
X mov di,ax
X mov si,ovlsiz
Xnotlargest:
X mov ovlfiloff,bp ; initialise ovl file offset
X add bp,hdr.exesiz ; ^ to next overlay
X mov dx,bp
X mov cl,dh
X mov dh,dl
X xor ch,ch
X xor dl,dl
X shl dx,1
X rcl cx,1 ; cx:dx = bp * 512
X mov al,0
X mov ah,DOSSEEK ; seek to next ovl
X int DOS
X mov ax,ovlcnt
X dec ax
X cmp ax,hdr.exeovlnum ; all overlays done?
X jz makmemblk
X jmp filsegtbllpp ; Nope, go for more.
Xmakmemblk:
X push si ; contains largest ovl size in paragraphs
X
X ASSUME ES:nothing ; prepare first two memory blocks
X ; OVERLAY_AREA and allocated memory block
X mov ax,ovlrootcode ; OVERLAY_AREA segment
X mov es,ax
X mov si,ovltblbse
X add si,ovlcnt ; end of ovl table
X mov es:memblkflg,0 ; clear mem flags
X mov es:memblknxt,si ; point to next
X mov es:memblkprv,0 ; set previous to nothing
X mov es:memblksiz,di ; di contains OVERLAY_AREA size in paragraphs
X add di,ax
X mov ovldata,di ; end of OVERLAY_END
X mov es,si ; end of ovl tbl (first memory block in allocated memory)
X mov es:memblkflg,0 ; clear mem flags
X mov es:memblknxt,0 ; set next to nothing
X mov es:memblkprv,ax ; point to previous
X pop si
X pop bx
X mov es:memblksiz,bx ; allocated memory block size less ovl table
X mov memblk1st,ax ; save pointer to first mem block
X mov WORD PTR ovltim,0 ; initialise global lru time stamp
X mov WORD PTR ovltim+2,0
X mov ax,OFFSET stkframe
X mov curovl,ax ; initialise stack frame pointer
X mov di,ax
X mov WORD PTR cs:[di],-1 ; initialise stack frame
X add di,6
X mov ax,ovltblbse
X mov cs:[di],ax
X mov curovl,di
X mov es,ax
X mov es:ovlflg,MASK running OR MASK locked OR MASK loaded ; set flags on ovl 0
X inc si ; largest ovl size + 1 paragraph
X cmp bx,si ; enough memory to alloc largest?
X jnc chgintvec
Xbuyram:
X mov al,5
X mov dx,OFFSET noroom ; free up some TSRs or something
X jmp putserr
Xchgintvec:
X mov ax,SEG $$INTNO
X mov ds,ax
X mov ah,DOSGETVEC
X mov al,$$INTNO ; get int number to use
X mov intnum,al
X int DOS ; get original vector
X mov WORD PTR oldvec,bx ; save original vector
X mov WORD PTR oldvec+2,es
X
X mov ah,DOSGETVEC
X mov al,21h
X int DOS ; get original vector
X mov WORD PTR oldint21,bx ; save original vector
X mov WORD PTR oldint21+2,es
X
X mov ah,DOSSETVEC
X mov al,intnum
X mov bx,cs
X mov ds,bx
X mov dx,OFFSET ovlmgr ; point to ovlmgr
X int DOS ; set vector
X
X mov ah,DOSSETVEC
X mov al,21h
X mov bx,cs
X mov ds,bx
X mov dx,OFFSET int21 ; point to int21
X int DOS ; set vector
X
X mov cx,modcnt ; module count
X mov ax,SEG $$MPGSNBASE
X mov es,ax
X mov ax,cs
X mov ds,ax
X
X ASSUME DS:code
X
X mov bx,OFFSET $$MPGSNBASE ; ^ to linker provided overlay segment fixups
X mov si,OFFSET $$MPGSNOVL ; ^ to linker provided module table
X mov di,OFFSET moduletbl ; ^ to our module table
Xmodloop:
X mov al,es:[si] ; real physical ovl number
X xor ah,ah
X add ax,ovltblbse ; ovlctlseg address
X mov [di],ax ; save in module table
X mov ax,es:[bx] ; get seg fixup
X sub ax,ovlrootcode ; adjust for relative reference
X mov [di+2],ax ; save in module table
X add di,4
X add bx,2
X inc si
X loop modloop
X
X pop es
X pop ds
X pop bp
X pop di
X pop si
X pop dx
X pop cx
X pop bx
X pop ax ; restore the world
X jmp $$MAIN ; And away we go!
X
X$$OVLINIT ENDP
X
X;-------------------------------------------------------------------------------
X
Xovlmgr PROC FAR ; This the it!
X
X ASSUME CS:code,DS:NOTHING,ES:NOTHING
X
X mov bxreg,bx ; preserve bx
X mov esreg,es ; and es
X pop bx ; retrieve caller ip
X pop es ; " " cs
X push ax
X push si
X mov ax,es:[bx+1] ; offset in ovl to call
X mov WORD PTR farcall,ax ; into trampoline
X xor ah,ah
X mov al,es:[bx] ; module # to call
X add bx,3 ; fix return address
X mov si,curovl ; get stack frame pointer
X mov cs:[si+2],es ; save return seg
X mov cs:[si+4],bx ; and return offset
X
X mov bx,ax
X shl bx,1
X shl bx,1 ; * 4 (2 words/entry in module tbl)
X add bx,OFFSET moduletbl
X mov es,cs:[bx] ; ovl tbl entry
X mov ax,cs:[bx+2] ; segment fixup
X mov cs:[si+6],es ; ovl entry into stack frame
X add curovl,6 ; update stack
X
X ASSUME ES:ovltbl
X
X mov si,WORD PTR ovltim ; lru time stamp
X inc si ; time passes!
X mov WORD PTR ovltim,si ; update global clock
X mov WORD PTR ovllrudat,si ; as well as ovl clock
X mov si,WORD PTR ovltim+2 ; high order word
X jz ininc ; dword increment
Xcryupcdon: mov WORD PTR ovllrudat+2,si
X test ovlflg,mask loaded ; ovl loaded?
X jz inload ; load it then.
Xovlloadedupc:
X add ax,ovlseg ; add fixup and segment address
X mov WORD PTR farcall+2,ax ; into trampoline
X mov bx,bxreg ; retore all registers
X mov es,esreg
X pop si
X pop ax
X popf ; don't forget these!
X call DWORD PTR farcall ; and GO
X pushf ; preserve registers again!
X mov esreg,es
X mov bxreg,bx
X mov bx,curovl ; stack frame pointer
X mov es,cs:[bx-6] ; retrieve ovl tbl entry
X push cs:[bx-4] ; set return address
X push cs:[bx-2]
X push cx
X mov cx,WORD PTR ovltim ; do the lru thing again
X inc cx
X mov WORD PTR ovltim,cx
X mov WORD PTR ovllrudat,cx
X mov cx,WORD PTR ovltim+2
X jz outinc
Xcrydncdon: mov WORD PTR ovllrudat+2,cx
X test ovlflg,mask loaded ; ovl loaded?
X jz outload ; better get it before someone notices
Xjmpback:
X sub curovl,6 ; adjust stack
X mov bx,bxreg ; get registers back
X mov es,esreg
X pop cx
X iret ; and GO back
X
Xininc:
X inc si
X mov WORD PTR ovltim+2,si ; update global clock
X jmp cryupcdon
X
Xinload:
X call loadoverlay ; self explanatory
X jmp ovlloadedupc
X
Xoutinc:
X inc cx
X mov WORD PTR ovltim+2,cx
X jmp crydncdon
X
Xoutload:
X call loadoverlay
X jmp jmpback
X
Xovlmgr ENDP
X
X;-------------------------------------------------------------------------------
X
Xloadoverlay PROC NEAR ; load overlay pointed to by es
X
X ASSUME CS:code,DS:NOTHING,ES:ovltbl
X
X push ax
X push bx
X push cx
X push dx
X push si
X push di
X push bp
X push ds
X push es ; just in case
X call setrunning ; set the running flags
X test ovlflg,MASK running ; was it already running?
X jnz fxdadr ; Yup, it's a toughie
X mov ax,ovlsiz ; How much?
X call getpages ; never fail mem alloc, you bet.
X jmp gleaner
Xfxdadr:
X call releasepages ; free memory where this ovl should be loaded
Xgleaner:
X mov ovlmemblk,ax ; memory block to use
X add ax,MEMCTLBLKSIZ ; skip mem ctl blk
X mov ds,ax
X mov dx,ovlfiloff ; where in the file is it?
X mov cl,dh
X mov dh,dl
X xor ch,ch
X xor dl,dl
X shl dx,1
X rcl cx,1 ; cx:dx = dx * 512
X mov ah,DOSSEEK ; lseek to position
X mov al,0
X mov bx,ovlexefilhdl ; never closing handle
X int DOS
X jc burnhead ; oops!
X xor dx,dx
X mov cx,ovlsiz ; number of paragraphs to load
X shl cx,1
X shl cx,1
X shl cx,1
X shl cx,1 ; * 16 = number of bytes
X mov ah,DOSREAD ; prevent random DOS behaviour
X int DOS
X jc burnhead ; double oops!
X call ovlrlc ; perform relocation normally done by DOS EXE loader
X pop es ; retrieve ovl tbl entry
X or ovlflg,MASK loaded ; because it is now
X pop ds
X pop bp
X pop di
X pop si
X pop dx
X pop cx
X pop bx
X pop ax
X ret
X
Xburnhead:
X mov al,5
X mov dx,OFFSET nofile
X jmp putserr
X
Xloadoverlay ENDP
X
X;-------------------------------------------------------------------------------
X
Xovlrlc PROC NEAR ; ds:0 -> the overlay to relocate
X
X ASSUME CS:code,DS:NOTHING,ES:ovltbl
X
X mov cx,ds:relocitems ; roto-count
X mov ax,ds
X add ax,ds:hdrparas ; skip header
X mov ovlseg,ax ; actual code starts here
X mov di,ax
X sub di,ovlrootcode ; segment fixup value
X mov si,ds:reloctbloff ; ^ relocation tbl in header
X jcxz relocdone ; not such a good idea, after all
Xdorelocs: ; labels don't GET comments
X lodsw ; offset into load module
X mov bx,ax
X lodsw ; segment in load module (zero reference)
X add ax,pspadd ; now it is psp relative
X add ax,di ; and now it is relative to the actual load address
X mov es,ax
X mov ax,es:[bx] ; pickup item to relocate
X add ax,pspadd ; make it psp relative
X cmp ax,ovlrootcode ; is it below the OVERLAY_AREA?
X jc reloccomputed ; yup. it's relocated
X cmp ax,ovldata ; is it above OVERLAY_AREA
X jnc reloccomputed ; yup. it's relocated
X add ax,di ; it's in OVERLAY_AREA, this one's ours.
Xreloccomputed:
X mov es:[bx],ax ; RAM it home!?!
X loop dorelocs ; what goes around, comes around.
Xrelocdone: ret
X
Xovlrlc ENDP
X
X;-------------------------------------------------------------------------------
X
Xgetvictim PROC NEAR ; select a victim to discard (and free up some memory)
X
X ASSUME CS:code,DS:ovltbl,ES:NOTHING
X
X push bx
X push cx
X push dx
X push si
X push di
X push bp
X push ds
X mov ds,ovltblbse ; ^ ovl tbl
X xor ax,ax ; will contain the low word of lru
X mov dx,ax ; will contain the high word of lru
X mov bp,ax ; will contain ovl tbl entry
X mov bx,ax ; ovl tbl ptr
X mov cx,ovlcnt
Xfoon1: test ovlflg[bx],MASK loaded
X jz skip1
X test ovlflg[bx],MASK locked
X jnz skip1
X mov si,WORD PTR ovltim
X mov di,WORD PTR ovltim+2
X sub si,WORD PTR ovllrudat[bx]
X sbb di,WORD PTR ovllrudat[bx+2]
X cmp dx,di
X jc better1
X jnz skip1
X cmp ax,si
X jnc skip1
Xbetter1: mov ax,si
X mov dx,di
X mov bp,bx
Xskip1: add bx,OVLSEGSIZ
X loop foon1
X or bp,bp ; were we more successful this time?
X jnz gotvictim ; now we got one.
Xnomoremem:
X mov al,5 ; were really %$# now!
X mov dx,OFFSET nocore
X jmp putserr
Xgotvictim:
X shr bp,1 ; convert offset to segment
X shr bp,1
X shr bp,1
X shr bp,1
X mov ax,ds
X add ax,bp
X pop ds
X pop bp
X pop di
X pop si
X pop dx
X pop cx
X pop bx
X ret
Xgetvictim ENDP
X
X;-------------------------------------------------------------------------------
X
Xsetrunning PROC NEAR ; set running flag on overlays still running
X
X ASSUME CS:code,DS:NOTHING,ES:ovltbl
X
X push es
X mov es,ovltblbse
X mov cx,ovlcnt
X xor bx,bx
Xjim: and ovlflg[bx],NOT MASK running ; start by clearing them all
X add bx,OVLSEGSIZ
X loop jim
X
X ; Now chain down the stack links, setting running flags
X
X mov bx,curovl
X sub bx,6
X jmp jam
Xjamloop:
X mov ds,cs:[bx]
X
X ASSUME DS:ovltbl
X
X or ovlflg,MASK running
X sub bx,6
Xjam:
X cmp WORD PTR cs:[bx],-1 ; end of stack ?
X jnz jamloop
X pop es
X ret
X
Xsetrunning ENDP
X
X;-------------------------------------------------------------------------------
X
Xint21 PROC FAR
X
X; free almost all overlay memory if app. tries to call the DOS exec function.
X
X cmp ah,DOSEXEC
X jz freeall
X cmp ah,TERMINATE
X jz saybyebye
Xnotours:
X jmp cs:oldint21
Xsaybyebye:
X pop ax ; clean up stack
X pop ax
X pop ax
X mov al,0 ; return code 0
X mov dx,OFFSET exitmsg
X jmp putserr
Xfreeall:
X or al,al ; is it load and exec?
X jnz notours
X push ax
X push bx
X push cx
X push dx
X push si
X push di
X push bp
X push es
X push ds ; preserve calling env.
X
X ASSUME CS:code,DS:NOTHING,ES:ovltbl
X
X mov ax,cs:memblk1st ; start de-allocating from first blk
X jmp short lastblk
Xunloadlp:
X mov ds,ax
X cmp ax,cs:ovltblbse ; in alloced area ?
X jc nextmemblk
X test ds:memblkflg,MASK_used ; mem blk used ?
X jz nextmemblk
X mov es,ds:memblkovl
X and ovlflg,NOT MASK loaded ; flag overlay as unloaded
Xnextmemblk:
X mov ax,ds:memblknxt
Xlastblk:
X or ax,ax ; keep going till no more
X jnz unloadlp
X
X mov ax,cs:ovltblbse
X add ax,cs:ovlcnt
X mov es,ax ; ^ to first mem blk in alloced mem
X mov es:memblksiz,2 ; adjust size
X mov es:memblknxt,0 ; no other blocks after this one
X mov es:memblkflg,0 ; not used
X
X mov dx,WORD PTR cs:oldint21
X mov ds,WORD PTR cs:oldint21+2
X mov ah,DOSSETVEC ; put back DOS vector to avoid calling ourselves again!
X mov al,21h
X int DOS
X
X mov dx,WORD PTR cs:oldvec
X mov ds,WORD PTR cs:oldvec+2
X mov ah,DOSSETVEC
X mov al,intnum
X int DOS
X
X mov es,cs:ovltblbse
X mov bx,cs:ovlcnt
X add bx,2 ; re-adjust alloced size
X mov ah,DOSREALLOC
X int DOS
X mov bp,sp
X push [bp+22] ; ensure returned flags are based on user's!
X popf
X pop ds
X pop es
X pop bp
X pop di
X pop si
X pop dx
X pop cx
X pop bx
X pop ax
X
X int DOS ; allow DOS to continue!
X
X push ax
X push bx
X push cx
X push dx
X push si
X push di
X push bp
X push es
X push ds ; preserve calling env.
X mov bp,sp
X pushf
X pop [bp+22] ; fix return flags
X
X; re-allocate our memory after a DOS exec function
X
X call reallocmem
X
X mov ah,DOSGETVEC
X mov al,21h
X int DOS ; get original vector
X mov WORD PTR cs:oldint21,bx ; save original vector
X mov WORD PTR cs:oldint21+2,es
X
X mov ah,DOSSETVEC
X mov al,21h
X mov bx,cs
X mov ds,bx
X mov dx,OFFSET int21 ; point to int21
X int DOS ; set vector
X
X mov ah,DOSGETVEC
X mov al,intnum
X int DOS ; get original vector
X mov WORD PTR cs:oldvec,bx ; save original vector
X mov WORD PTR cs:oldvec+2,es
X
X mov ah,DOSSETVEC
X mov al,intnum
X mov bx,cs
X mov ds,bx
X mov dx,OFFSET ovlmgr ; point to ovlmgr
X int DOS ; set vector
X
X pop ds
X pop es
X pop bp
X pop di
X pop si
X pop dx
X pop cx
X pop bx
X pop ax
X iret
X
Xint21 ENDP
X
X;-------------------------------------------------------------------------------
X
Xreallocmem PROC NEAR
X
X; re-allocate our memory after a DOS exec function
X
X push es
X mov ah,DOSREALLOC
X mov es,cs:ovltblbse ; mem blk handle
X mov bx,0ffffh ; find out how much there is
X int DOS
X mov ah,DOSREALLOC ; re-allocate our own memory
X mov es,cs:ovltblbse
X push bx ; contains largest available blk
X int DOS
X mov ax,cs:ovltblbse
X add ax,cs:ovlcnt
X mov es,ax ; ^ to first mem blk in alloced mem
X pop ax
X sub ax,cs:ovlcnt ; remove ovl tbl size
X mov es:memblksiz,ax ; fix mem blk size
X
X pop es
X ret
X
Xreallocmem ENDP
X
X;-------------------------------------------------------------------------------
X
Xreleasepages PROC NEAR ; Arg in es, result in ax
X
X; release any memory (and overlays) where this overlay should reside
X
X ASSUME ES:ovltbl
X
X mov bx,es:ovlmemblk ; start of memory to release
Xdoitagain:
X mov ax,memblk1st ; first memory blk
X jmp dvart
Xdvartloop:
X mov ds,ax ; memory blk to check
X cmp bx,ax ; does it start below the memory to release?
X jnc dvartsmaller ; yup
X mov dx,bx
X add dx,es:ovlsiz
X add dx,MEMCTLBLKSIZ ; end of memory to release
X cmp ax,dx ; does it start above?
X jnc dvartsilly ; yup
X call killmem ; it's in the way. Zap it.
X jmp chkmemblk
Xdvartsmaller:
X add ax,ds:memblksiz ; end of this memory blk
X cmp bx,ax ; does it end below the memory to release?
X jnc dvartsilly ; yup
X call killmem ; Oh well, zap it too.
Xchkmemblk: ; was that enough?
X mov ax,ds ; recently freed memory blk
X cmp bx,ax ; does it start in the memory to be released?
X jc dvartsilly ; yup, wasn't enough
X mov dx,bx
X add dx,es:ovlsiz
X add dx,MEMCTLBLKSIZ ; end of memory to be released
X add ax,ds:memblksiz ; end of freed memory
X cmp ax,dx ; does it end in the memory to be released?
X jc dvartsilly ; yup, release more
Xdvartgotblk:
X mov ax,ds ; this is it!
X mov cx,bx
X sub cx,ax ; # of paragraphs between start of memory to release and mem blk
X jz nosplit
X call splitblkhigh ; split the block
Xnosplit:
X mov cx,es:ovlsiz
X add cx,MEMCTLBLKSIZ ; paragraphs needed to load ovl
X jmp splitblklow ; split remaining block
Xdvartsilly:
X mov ax,ds:memblknxt
Xdvart:
X or ax,ax ; enf of mem list?
X jz dvartnocore
X jmp dvartloop ; play it again Sam.
Xdvartnocore:
X mov al,5 ; super OOPS!
X mov dx,OFFSET nocore
X jmp putserr
X
Xreleasepages ENDP
X
X;-------------------------------------------------------------------------------
X
Xgetpages PROC NEAR ; get enough memory to load ovl
X
X mov cx,ax
X add cx,MEMCTLBLKSIZ ; total paragraphs needed
X call largestmem ; find largest free blk
X cmp dx,cx ; large enough?
X jnc gotdork ; yup.
Xdorkkill:
X call getvictim ; select a victim to release
X call killovl ; kill the selected victim
X cmp ds:memblksiz,cx ; was it enough?
X jc dorkkill ; nope, select another one
Xgotdork:
X jmp splitblklow ; split the free blk
X
Xgetpages ENDP
X
X;-------------------------------------------------------------------------------
X
Xsplitblklow PROC NEAR
X
X; split a block of memory returning the lower one to be used.
X
X push es
X or ds:memblkflg,MASK_used ; set low block used
X mov ax,ds
X add ax,cx
X mov es,ax ; ^ to upper blk to be created
X mov ax,ds:memblksiz
X sub ax,cx
X cmp ax,1 ; must be at least 1 para remaining to split
X jc noodorksplit ; don't split
X mov ds:memblksiz,cx ; fix blk sizes
X mov es:memblksiz,ax
X mov ax,ds:memblknxt ; fix pointers
X mov es:memblknxt,ax
X mov ds:memblknxt,es
X mov es:memblkprv,ds
X mov es:memblkflg,0 ; set upper to not used
X push ds
X mov ax,es:memblknxt
X or ax,ax
X jz domergelow
X mov ds,ax ; fix blk after upper to point to upper
X mov ds:memblkprv,es
Xdomergelow:
X mov ax,es
X mov ds,ax
X call mergemem ; merge remaining free memory
X pop ds
Xnoodorksplit:
X pop es
X mov ds:memblkovl,es ; fix ptr to ovl
X mov ax,ds ; return lower blk segment
X ret
X
Xsplitblklow ENDP
X
X;-------------------------------------------------------------------------------
X
Xsplitblkhigh PROC NEAR
X
X; split a block of memory returning the upper one to be used.
X
X push es
X mov ax,ds
X add ax,cx
X mov es,ax ; ^ to upper blk to be created
X mov ax,ds:memblksiz
X sub ax,cx ; # of para remaining in upper blk
X mov ds:memblksiz,cx ; fix blk sizes
X mov es:memblksiz,ax
X mov ax,ds:memblknxt ; fix blk pointers
X mov es:memblknxt,ax
X mov ds:memblknxt,es
X mov es:memblkprv,ds
X mov ds:memblkflg,0 ; set lower to not used
X or es:memblkflg,MASK_used ; set upper to used
X mov ax,es:memblknxt
X or ax,ax
X jz domergehigh
X push ds ; fix blk after upper to point to upper
X mov ds,ax
X mov ds:memblkprv,es
X pop ds
Xdomergehigh:
X call mergemem ; merge remaining free memory
Xnodorksplit:
X mov ax,es
X mov ds,ax
X pop es
X mov ds:memblkovl,es ; fix ovl ptr
X mov ax,ds ; return upper blk segment
X ret
X
Xsplitblkhigh ENDP
X
X;-------------------------------------------------------------------------------
X
Xlargestmem PROC NEAR ; returns seg in ax, size in dx; clobbers bx,ds,es
X ; retruns first block that's large enough if possible
X
X mov ax,memblk1st ; first mem blk
X xor dx,dx ; largest size found
X jmp gook
Xgookloop: mov ds,ax
X test ds:memblkflg,MASK_used ; is this blk used?
X jnz gookme ; yup
X cmp ds:memblksiz,cx ; is it large enough?
X jc gookme ; nope
X mov dx,ds:memblksiz ; got one!
X ret
Xgookme:
X mov ax,ds:memblknxt
Xgook: or ax,ax ; end of list?
X jnz gookloop ; around and around
X ret
X
Xlargestmem ENDP
X
X;-------------------------------------------------------------------------------
X
Xkillmem PROC NEAR
X
X test ds:memblkflg,MASK_used ; is it used?
X jz memnotused ; don't kill ovl
X push es
X mov es,ds:memblkovl
X and es:ovlflg,NOT MASK loaded ; zap ovl associated with this blk
X pop es
Xmemnotused:
X jmp mergemem ; merge free memory
X
Xkillmem ENDP
X
X;-------------------------------------------------------------------------------
X
Xkillovl PROC NEAR ; preserves bx
X
X mov ds,ax
X
X ASSUME DS:ovltbl
X
X and ovlflg,NOT MASK loaded ; ovl no longer loaded
X mov ax,ovlmemblk ; get mem blk
X mov ds,ax
X jmp mergemem ; merge free memory
X
Xkillovl ENDP
X
X;-------------------------------------------------------------------------------
X
Xmergemem PROC NEAR
X
X; merge physically adjacent free memory blocks. Preserves es. ds -> a free block.
X
X push es
X and ds:memblkflg,NOT MASK_used ; set current free
X mov ax,ds:memblkprv ; get previous blk
X or ax,ax ; was there a previous blk?
X jz gibber ; nope
X mov es,ax
X test es:memblkflg,MASK_used ; is the previous blk used?
X jnz gibber ; yup
X add ax,es:memblksiz ; end of previous blk
X mov dx,ds
X cmp dx,ax ; physically adjacent?
X jnz gibber ; nope
X mov ax,ds:memblksiz
X add es:memblksiz,ax ; adjust size of new larger blk
X mov ax,ds:memblknxt ; fix pointers
X mov es:memblknxt,ax
X or ax,ax
X jz almostgibber
X mov ds,ax ; fix pointer of next blk
X mov ds:memblkprv,es
Xalmostgibber:
X mov ax,es
X mov ds,ax ; new blk segment
Xgibber:
X mov ax,ds:memblknxt ; get next blk
X or ax,ax ; was there a next blk?
X jz killdone ; nope
X mov es,ax
X test es:memblkflg,MASK_used ; is the nxt blk used?
X jnz killdone ; yup
X mov ax,ds
X add ax,ds:memblksiz ; end of this blk
X mov dx,es
X cmp ax,dx ; physically adjacent?
X jnz killdone ; nope
X mov ax,es:memblksiz
X add ds:memblksiz,ax ; adjust size of new larger blk
X mov ax,es:memblknxt ; fix pointers
X mov ds:memblknxt,ax
X or ax,ax
X jz killdone
X mov es,ax ; fix pointer of blk after nxt
X mov es:memblkprv,ds
Xkilldone:
X and ds:memblkflg,NOT MASK_used ; make sure it's free
X pop es
X ret
X
Xmergemem ENDP
X
X;-------------------------------------------------------------------------------
X
Xgethdr PROC NEAR ; read EXE header from handle
X
X push cx
X mov ax,cs
X mov ds,ax
X mov dx,OFFSET hdr ; a place to put it
X mov bx,ovlexefilhdl ; the file handle
X mov cx,TYPE EXEHDR ; header size in bytes
X mov ah,DOSREAD
X int DOS ; read from file
X jc exegone ; oops
X cmp ax,cx ; got correct number of bytes?
X jnz exegone ; nope
X pop cx
X ret ; Wow, it worked!
Xexegone:
X mov al,5 ; You lose!
X mov dx,OFFSET nofile
X jmp putserr
X
Xgethdr ENDP
X
X;-------------------------------------------------------------------------------
X
Xputserr PROC NEAR
X
X; display error msg, close file, restore int vectors, free mem and return to DOS.
X
X push ax ; keep return code for later
X mov ax,cs
X mov ds,ax
X mov ah,PRINT
X int DOS ; display error msg
X mov dx,WORD PTR oldvec ; get old vector
X cmp dx,-1 ; was it ever replaced?
X jz free21 ; nope
X push ds
X mov ds,WORD PTR oldvec+2
X mov ah,DOSSETVEC ; put it back then.
X mov al,intnum
X int DOS
X pop ds
Xfree21:
X mov dx,WORD PTR oldint21
X cmp dx,-1
X jz freemem
X push ds
X mov ds,WORD PTR oldint21+2
X mov ah,DOSSETVEC ; put it back then.
X mov al,21h
X int DOS
X pop ds
Xfreemem:
X mov ax,ovltblbse ; get memory blk segment
X cmp ax,-1 ; was one ever allocated?
X jz closefile ; nope
X mov es,ax
X mov ah,DOSFREE ; must free it.
X int DOS
Xclosefile:
X mov bx,ovlexefilhdl ; get file handle
X cmp bx,-1 ; was the file ever opened?
X jz byebye ; nope
X mov ah,DOSCLOSE ; close it
X int DOS
Xbyebye:
X pop ax ; return code in al
X mov ah,TERMINATE
X int DOS ; terminate this process
X
Xputserr ENDP
X
Xcode ENDS
X
X END
END_OF_FILE
if test 30539 -ne `wc -c <'others/ovlmgr.asm'`; then
echo shar: \"'others/ovlmgr.asm'\" unpacked with wrong size!
fi
# end of 'others/ovlmgr.asm'
if test -f 'src/lev_lex.c' -a "${1}" != "-c" ; then
echo shar: Renaming existing file \"'src/lev_lex.c'\" to \"'src/lev_lex.c.orig'\"
mv -f 'src/lev_lex.c' 'src/lev_lex.c.orig'
fi
echo shar: Extracting \"'src/lev_lex.c'\" \(21018 characters\)
sed "s/^X//" >'src/lev_lex.c' <<'END_OF_FILE'
X# include "stdio.h"
X# define U(x) x
X# define NLSTATE yyprevious=YYNEWLINE
X# define BEGIN yybgin = yysvec + 1 +
X# define INITIAL 0
X# define YYLERR yysvec
X# define YYSTATE (yyestate-yysvec-1)
X# define YYOPTIM 1
X# define YYLMAX 200
X# define output(c) putc(c,yyout)
X# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
X# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
X# define yymore() (yymorfg=1)
X# define ECHO fprintf(yyout, "%s",yytext)
X# define REJECT { nstr = yyreject(); goto yyfussy;}
Xint yyleng; extern char yytext[];
Xint yymorfg;
Xextern char *yysptr, yysbuf[];
Xint yytchar;
XFILE *yyin ={stdin}, *yyout ={stdout};
Xextern int yylineno;
Xstruct yysvf {
X struct yywork *yystoff;
X struct yysvf *yyother;
X int *yystops;};
Xstruct yysvf *yyestate;
Xextern struct yysvf yysvec[], *yybgin;
X/* SCCS Id: @(#)lev_lex.c 3.0 90/01/04
X/* Copyright (c) 1989 by Jean-Christophe Collet */
X/* NetHack may be freely redistributed. See license for details. */
X
X#define LEV_LEX_C
X
X/* block some unused #defines to avoid overloading some cpp's */
X#define MONDATA_H /* comment this line for pre-compiled headers */
X#define MONFLAG_H /* comment this line for pre-compiled headers */
X
X#include "hack.h"
X#include "lev_comp.h"
X#include "sp_lev.h"
X
X/* Most of these don't exist in flex, yywrap is macro and
X * yyunput is properly declared in flex.skel.
X */
X#ifndef FLEX_SCANNER
Xint FDECL (yyback, (int *, int));
Xint NDECL (yylook);
Xint NDECL (yyinput);
Xint NDECL (yywrap);
Xint NDECL (yylex);
Xint FDECL (yyunput, (int));
Xint FDECL (yyoutput, (int));
X#endif
X
X#ifdef MSDOS
X#undef exit
X#endif
X
X/* this doesn't always get put in lev_comp.h
X * (esp. when using older versions of bison)
X */
X
Xextern YYSTYPE yylval;
X
X#ifdef MACOS
X#undef putchar
X#undef putc
X#undef printf
X#undef Printf
X#define Printf printf
X# ifdef LSC
X#define putc(c,stream) (fputc(c,stream))
X#define putchar(c) (fputc(c,stdout))
X# endif
X#endif
Xint line_number = 1;
X
X/* This is *** UGLY *** but I can't think a better way to do it
X * I really need a huge buffer to scan maps...
X */
X
X#undef YYLMAX
X#define YYLMAX 2048
X
X# define MAPC 2
X# define YYNEWLINE 10
Xyylex(){
Xint nstr; extern int yyprevious;
Xwhile((nstr = yylook()) >= 0)
Xyyfussy: switch(nstr){
Xcase 0:
Xif(yywrap()) return(0); break;
Xcase 1:
X{ line_number++; yymore(); }
Xbreak;
Xcase 2:
X{ BEGIN 0;
X line_number++;
X yytext[yyleng-7] = 0; /* Discard \nENDMAP */
X yylval.map = (char *) alloc(strlen(yytext)+1);
X strcpy(yylval.map, yytext);
X return MAP_ID;
X }
Xbreak;
Xcase 3:
X { line_number++; }
Xbreak;
Xcase 4:
X return MAZE_ID;
Xbreak;
Xcase 5:
X return LEVEL_ID;
Xbreak;
Xcase 6:
Xreturn GEOMETRY_ID;
Xbreak;
Xcase 7:
X { BEGIN MAPC; line_number++; }
Xbreak;
Xcase 8:
X return OBJECT_ID;
Xbreak;
Xcase 9:
X return MONSTER_ID;
Xbreak;
Xcase 10:
X return TRAP_ID;
Xbreak;
Xcase 11:
X return DOOR_ID;
Xbreak;
Xcase 12:
Xreturn DRAWBRIDGE_ID;
Xbreak;
Xcase 13:
Xreturn MAZEWALK_ID;
Xbreak;
Xcase 14:
X return REGION_ID;
Xbreak;
Xcase 15:
Xreturn RANDOM_OBJECTS_ID;
Xbreak;
Xcase 16:
Xreturn RANDOM_MONSTERS_ID;
Xbreak;
Xcase 17:
Xreturn RANDOM_PLACES_ID;
Xbreak;
Xcase 18:
X return ALTAR_ID;
Xbreak;
Xcase 19:
X return LADDER_ID;
Xbreak;
Xcase 20:
Xreturn NON_DIGGABLE_ID;
Xbreak;
Xcase 21:
X return ROOM_ID;
Xbreak;
Xcase 22:
X { yylval.i=D_ISOPEN; return DOOR_STATE; }
Xbreak;
Xcase 23:
X { yylval.i=D_CLOSED; return DOOR_STATE; }
Xbreak;
Xcase 24:
X { yylval.i=D_LOCKED; return DOOR_STATE; }
Xbreak;
Xcase 25:
X { yylval.i=D_NODOOR; return DOOR_STATE; }
Xbreak;
Xcase 26:
X { yylval.i=D_BROKEN; return DOOR_STATE; }
Xbreak;
Xcase 27:
X { yylval.i=W_NORTH; return DIRECTION; }
Xbreak;
Xcase 28:
X { yylval.i=W_EAST; return DIRECTION; }
Xbreak;
Xcase 29:
X { yylval.i=W_SOUTH; return DIRECTION; }
Xbreak;
Xcase 30:
X { yylval.i=W_WEST; return DIRECTION; }
Xbreak;
Xcase 31:
X { yylval.i = -1; return RANDOM_TYPE; }
Xbreak;
Xcase 32:
X return O_REGISTER;
Xbreak;
Xcase 33:
X return M_REGISTER;
Xbreak;
Xcase 34:
X return P_REGISTER;
Xbreak;
Xcase 35:
X return A_REGISTER;
Xbreak;
Xcase 36:
X { yylval.i=1; return LEFT_OR_RIGHT; }
Xbreak;
Xcase 37:
X { yylval.i=3; return LEFT_OR_RIGHT; }
Xbreak;
Xcase 38:
X { yylval.i=2; return CENTER; }
Xbreak;
Xcase 39:
X { yylval.i=1; return TOP_OR_BOT; }
Xbreak;
Xcase 40:
X { yylval.i=3; return TOP_OR_BOT; }
Xbreak;
Xcase 41:
X { yylval.i=1; return LIGHT_STATE; }
Xbreak;
Xcase 42:
X { yylval.i=0; return LIGHT_STATE; }
Xbreak;
Xcase 43:
X { yylval.i=A_LAW; return ALIGNMENT; }
Xbreak;
Xcase 44:
X { yylval.i=A_NEUTRAL; return ALIGNMENT; }
Xbreak;
Xcase 45:
X { yylval.i=A_CHAOS; return ALIGNMENT; }
Xbreak;
Xcase 46:
X { yylval.i=1; return ALTAR_TYPE; }
Xbreak;
Xcase 47:
X { yylval.i=0; return ALTAR_TYPE; }
Xbreak;
Xcase 48:
X { yylval.i=1; return UP_OR_DOWN; }
Xbreak;
Xcase 49:
X { yylval.i=0; return UP_OR_DOWN; }
Xbreak;
Xcase 50:
X { yylval.i=atoi(yytext); return INTEGER; }
Xbreak;
Xcase 51:
X{ yytext[yyleng-1] = 0; /* Discard the trailing \" */
X yylval.map = (char *) alloc(strlen(yytext+1)+1);
X strcpy(yylval.map, yytext+1); /* Discard the first \" */
X return STRING; }
Xbreak;
Xcase 52:
X { line_number++; }
Xbreak;
Xcase 53:
X ;
Xbreak;
Xcase 54:
X { yylval.i = yytext[1]; return CHAR; }
Xbreak;
Xcase 55:
X { return yytext[0]; }
Xbreak;
Xcase -1:
Xbreak;
Xdefault:
Xfprintf(yyout,"bad switch yylook %d",nstr);
X} return(0); }
X/* end of yylex */
X#ifdef AMIGA
Xlong *alloc(n)
X unsigned n;
X{
X return ((long *)malloc (n));
X}
X#endif
Xint yyvstop[] ={
X0,
X
X55,
X0,
X
X53,
X55,
X0,
X
X52,
X0,
X
X55,
X0,
X
X55,
X0,
X
X50,
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X1,
X52,
X0,
X
X53,
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X55,
X0,
X
X53,
X0,
X
X51,
X0,
X
X50,
X0,
X
X48,
X0,
X
X3,
X0,
X
X1,
X0,
X
X53,
X0,
X
X1,
X3,
X0,
X
X54,
X0,
X
X43,
X0,
X
X41,
X0,
X
X39,
X0,
X
X11,
X0,
X
X4,
X0,
X
X21,
X0,
X
X10,
X0,
X
X49,
X0,
X
X28,
X0,
X
X36,
X0,
X
X22,
X0,
X
X30,
X0,
X
X7,
X0,
X
X18,
X0,
X
X5,
X0,
X
X35,
X0,
X
X47,
X0,
X
X45,
X0,
X
X27,
X0,
X
X34,
X0,
X
X37,
X0,
X
X29,
X0,
X
X42,
X0,
X
X19,
X0,
X
X8,
X0,
X
X14,
X0,
X
X40,
X0,
X
X26,
X0,
X
X38,
X0,
X
X23,
X0,
X
X24,
X0,
X
X25,
X0,
X
X32,
X0,
X
X31,
X0,
X
X46,
X0,
X
X9,
X0,
X
X33,
X0,
X
X44,
X0,
X
X2,
X0,
X
X6,
X0,
X
X13,
X0,
X
X12,
X0,
X
X20,
X0,
X
X17,
X0,
X
X15,
X0,
X
X16,
X0,
X0};
X# define YYTYPE int
Xstruct yywork { YYTYPE verify, advance; } yycrank[] ={
X0,0, 0,0, 1,5, 0,0,
X0,0, 0,0, 0,0, 0,0,
X8,43, 0,0, 1,6, 1,7,
X9,45, 0,0, 6,42, 0,0,
X8,43, 8,43, 0,0, 0,0,
X9,45, 9,0, 41,94, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 1,6, 0,0, 1,8,
X1,5, 6,42, 0,0, 8,43,
X1,9, 8,44, 8,43, 9,45,
X41,95, 9,45, 9,45, 41,95,
X45,96, 1,10, 0,0, 0,0,
X0,0, 0,0, 0,0, 8,43,
X0,0, 0,0, 0,0, 9,45,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 1,11, 14,51,
X15,53, 1,12, 13,50, 14,52,
X1,13, 17,56, 36,89, 49,99,
X51,101, 1,14, 1,15, 1,16,
X1,17, 11,47, 15,54, 1,18,
X12,48, 1,19, 16,55, 12,49,
X2,5, 18,57, 19,60, 40,93,
X47,97, 18,58, 48,98, 50,100,
X2,6, 2,7, 1,20, 1,21,
X1,22, 1,23, 1,24, 18,59,
X24,68, 34,86, 52,102, 53,103,
X54,104, 1,25, 1,26, 1,27,
X1,28, 1,29, 20,61, 1,30,
X1,31, 1,32, 1,33, 2,6,
X1,34, 2,8, 2,35, 23,67,
X21,62, 26,73, 2,9, 21,63,
X29,78, 32,83, 2,5, 55,105,
X2,5, 2,5, 28,76, 2,10,
X10,46, 10,46, 10,46, 10,46,
X10,46, 10,46, 10,46, 10,46,
X10,46, 10,46, 22,64, 27,74,
X28,77, 22,65, 56,106, 30,79,
X2,11, 22,66, 31,81, 2,12,
X57,107, 27,75, 2,13, 30,80,
X58,108, 31,82, 2,5, 2,14,
X2,36, 2,16, 2,17, 59,109,
X25,69, 2,18, 2,5, 2,19,
X25,70, 33,84, 60,110, 33,85,
X25,71, 62,113, 61,111, 2,5,
X63,114, 64,115, 25,72, 65,116,
X2,20, 2,21, 2,22, 2,23,
X2,24, 61,112, 66,117, 3,37,
X67,118, 68,119, 69,120, 2,25,
X2,26, 2,27, 2,28, 2,29,
X35,87, 2,30, 2,31, 2,32,
X2,33, 70,121, 2,34, 71,122,
X35,87, 35,88, 2,5, 2,5,
X2,5, 3,38, 72,123, 73,124,
X3,39, 74,125, 75,126, 76,128,
X3,9, 77,129, 78,130, 79,131,
X80,132, 81,133, 82,134, 83,135,
X84,136, 86,137, 89,138, 35,87,
X75,127, 35,87, 35,87, 93,139,
X97,140, 98,141, 99,142, 95,94,
X89,103, 100,143, 101,144, 102,145,
X103,146, 104,147, 3,11, 35,87,
X105,148, 3,12, 3,40, 106,149,
X3,13, 107,150, 108,151, 109,152,
X110,153, 3,14, 3,15, 3,16,
X3,17, 95,95, 111,154, 3,18,
X95,95, 3,19, 112,155, 113,156,
X114,157, 115,158, 116,159, 117,160,
X118,161, 119,162, 121,163, 123,164,
X124,165, 4,37, 3,20, 3,21,
X3,22, 3,23, 3,24, 125,166,
X126,167, 127,168, 128,169, 129,170,
X130,171, 3,25, 3,26, 3,27,
X3,28, 3,29, 131,172, 3,30,
X3,31, 3,32, 3,33, 4,38,
X3,34, 132,173, 4,41, 133,174,
X134,175, 136,176, 4,9, 137,177,
X138,178, 139,179, 4,39, 140,180,
X4,39, 4,39, 142,181, 143,182,
X144,183, 145,184, 146,185, 147,186,
X148,187, 149,188, 150,189, 151,190,
X154,191, 155,192, 156,193, 157,194,
X158,195, 159,196, 160,197, 164,198,
X4,11, 165,199, 166,200, 4,12,
X4,40, 167,201, 4,13, 168,202,
X169,203, 171,204, 4,39, 4,14,
X4,36, 4,16, 4,17, 172,205,
X173,206, 4,18, 4,39, 4,19,
X174,207, 175,208, 176,209, 179,210,
X181,211, 182,212, 183,213, 4,39,
X185,214, 186,215, 38,42, 38,90,
X4,20, 4,21, 4,22, 4,23,
X4,24, 187,216, 188,217, 189,218,
X190,219, 193,220, 194,221, 4,25,
X4,26, 4,27, 4,28, 4,29,
X195,222, 4,30, 4,31, 4,32,
X4,33, 38,91, 4,34, 39,90,
X38,92, 197,223, 4,39, 4,39,
X4,39, 198,224, 199,225, 200,226,
X38,92, 201,227, 38,92, 38,92,
X203,228, 205,229, 207,230, 210,231,
X211,232, 212,233, 214,234, 215,235,
X216,236, 39,92, 218,237, 225,238,
X39,92, 226,239, 231,240, 232,241,
X233,242, 234,243, 236,244, 241,248,
X39,92, 244,249, 39,92, 39,92,
X237,245, 245,250, 237,246, 237,247,
X38,92, 246,251, 247,252, 248,253,
X249,254, 250,255, 251,256, 252,257,
X38,92, 254,258, 255,259, 256,260,
X257,261, 258,262, 259,263, 260,264,
X261,265, 38,92, 263,266, 264,267,
X265,268, 266,269, 267,270, 269,271,
X39,92, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X39,92, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 39,92, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X38,92, 38,92, 38,92, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X39,92, 39,92, 39,92, 0,0,
X0,0};
Xstruct yysvf yysvec[] ={
X0, 0, 0,
Xyycrank+-1, 0, 0,
Xyycrank+-87, 0, 0,
Xyycrank+-181, yysvec+1, 0,
Xyycrank+-267, yysvec+2, 0,
Xyycrank+0, 0, yyvstop+1,
Xyycrank+5, 0, yyvstop+3,
Xyycrank+0, 0, yyvstop+6,
Xyycrank+-7, 0, yyvstop+8,
Xyycrank+-11, 0, yyvstop+10,
Xyycrank+88, 0, yyvstop+12,
Xyycrank+5, 0, yyvstop+15,
Xyycrank+5, 0, yyvstop+17,
Xyycrank+1, 0, yyvstop+19,
Xyycrank+2, 0, yyvstop+21,
Xyycrank+3, 0, yyvstop+23,
Xyycrank+7, 0, yyvstop+25,
Xyycrank+7, 0, yyvstop+27,
Xyycrank+24, 0, yyvstop+29,
Xyycrank+8, 0, yyvstop+31,
Xyycrank+6, 0, yyvstop+33,
Xyycrank+13, 0, yyvstop+35,
Xyycrank+45, 0, yyvstop+37,
Xyycrank+12, 0, yyvstop+39,
Xyycrank+7, 0, yyvstop+41,
Xyycrank+71, 0, yyvstop+43,
Xyycrank+14, 0, yyvstop+45,
Xyycrank+46, 0, yyvstop+47,
Xyycrank+36, 0, yyvstop+49,
Xyycrank+20, 0, yyvstop+51,
Xyycrank+54, 0, yyvstop+53,
Xyycrank+50, 0, yyvstop+55,
Xyycrank+18, 0, yyvstop+57,
Xyycrank+63, 0, yyvstop+59,
Xyycrank+4, 0, yyvstop+61,
Xyycrank+-199, 0, yyvstop+63,
Xyycrank+9, yysvec+15, yyvstop+65,
Xyycrank+0, 0, yyvstop+67,
Xyycrank+353, 0, yyvstop+70,
Xyycrank+377, 0, yyvstop+73,
Xyycrank+13, 0, yyvstop+75,
Xyycrank+-12, yysvec+35, yyvstop+77,
Xyycrank+0, yysvec+6, yyvstop+79,
Xyycrank+0, yysvec+8, 0,
Xyycrank+0, 0, yyvstop+81,
Xyycrank+9, 0, 0,
Xyycrank+0, yysvec+10, yyvstop+83,
Xyycrank+8, 0, 0,
Xyycrank+15, 0, 0,
Xyycrank+10, 0, 0,
Xyycrank+16, 0, 0,
Xyycrank+8, 0, 0,
Xyycrank+20, 0, 0,
Xyycrank+17, 0, 0,
Xyycrank+30, 0, 0,
Xyycrank+53, 0, 0,
Xyycrank+76, 0, 0,
Xyycrank+78, 0, 0,
Xyycrank+89, 0, 0,
Xyycrank+88, 0, 0,
Xyycrank+109, 0, 0,
Xyycrank+73, 0, 0,
Xyycrank+61, 0, 0,
Xyycrank+69, 0, 0,
Xyycrank+71, 0, 0,
Xyycrank+86, 0, 0,
Xyycrank+79, 0, 0,
Xyycrank+73, 0, 0,
Xyycrank+78, 0, 0,
Xyycrank+75, 0, 0,
Xyycrank+103, 0, 0,
Xyycrank+91, 0, 0,
Xyycrank+115, 0, 0,
Xyycrank+105, 0, 0,
Xyycrank+100, 0, 0,
Xyycrank+118, 0, 0,
Xyycrank+113, 0, 0,
Xyycrank+120, 0, 0,
Xyycrank+125, 0, 0,
Xyycrank+113, 0, 0,
Xyycrank+121, 0, 0,
Xyycrank+111, 0, 0,
Xyycrank+109, 0, 0,
Xyycrank+115, 0, 0,
Xyycrank+120, 0, 0,
Xyycrank+0, 0, yyvstop+85,
Xyycrank+114, 0, 0,
Xyycrank+0, yysvec+35, 0,
Xyycrank+0, 0, yyvstop+87,
Xyycrank+150, 0, 0,
Xyycrank+0, 0, yyvstop+89,
Xyycrank+0, yysvec+38, yyvstop+91,
Xyycrank+0, yysvec+39, 0,
Xyycrank+167, 0, 0,
Xyycrank+0, 0, yyvstop+93,
Xyycrank+-229, yysvec+35, 0,
Xyycrank+0, 0, yyvstop+96,
Xyycrank+171, 0, 0,
Xyycrank+155, 0, 0,
Xyycrank+151, 0, 0,
Xyycrank+164, 0, 0,
Xyycrank+174, 0, 0,
Xyycrank+174, 0, 0,
Xyycrank+175, 0, 0,
Xyycrank+162, 0, 0,
Xyycrank+153, 0, 0,
Xyycrank+182, 0, 0,
Xyycrank+185, 0, 0,
Xyycrank+181, 0, 0,
Xyycrank+178, 0, 0,
Xyycrank+176, 0, 0,
Xyycrank+159, 0, 0,
Xyycrank+169, 0, 0,
Xyycrank+151, 0, 0,
Xyycrank+161, 0, 0,
Xyycrank+153, 0, 0,
Xyycrank+159, 0, 0,
Xyycrank+156, 0, 0,
Xyycrank+162, 0, 0,
Xyycrank+157, 0, 0,
Xyycrank+0, 0, yyvstop+98,
Xyycrank+158, 0, 0,
Xyycrank+0, 0, yyvstop+100,
Xyycrank+168, 0, 0,
Xyycrank+161, 0, 0,
Xyycrank+167, 0, 0,
Xyycrank+173, 0, 0,
Xyycrank+169, 0, 0,
Xyycrank+185, 0, 0,
Xyycrank+177, 0, 0,
Xyycrank+189, 0, 0,
Xyycrank+194, 0, 0,
Xyycrank+197, 0, 0,
Xyycrank+198, 0, 0,
Xyycrank+188, 0, 0,
Xyycrank+0, 0, yyvstop+102,
Xyycrank+200, 0, 0,
Xyycrank+191, 0, 0,
Xyycrank+298, 0, 0,
Xyycrank+232, 0, 0,
Xyycrank+229, 0, 0,
Xyycrank+0, 0, yyvstop+104,
Xyycrank+248, 0, 0,
Xyycrank+246, 0, 0,
Xyycrank+247, 0, 0,
Xyycrank+241, 0, 0,
Xyycrank+231, 0, yyvstop+106,
Xyycrank+235, 0, 0,
Xyycrank+252, 0, 0,
Xyycrank+254, 0, 0,
Xyycrank+243, 0, 0,
Xyycrank+244, 0, 0,
Xyycrank+0, 0, yyvstop+108,
Xyycrank+0, 0, yyvstop+110,
Xyycrank+214, 0, 0,
Xyycrank+211, 0, 0,
Xyycrank+215, 0, 0,
Xyycrank+226, 0, 0,
Xyycrank+227, 0, 0,
Xyycrank+214, 0, 0,
Xyycrank+229, 0, 0,
Xyycrank+0, 0, yyvstop+112,
Xyycrank+0, 0, yyvstop+114,
Xyycrank+0, 0, yyvstop+116,
Xyycrank+230, 0, 0,
Xyycrank+217, 0, 0,
Xyycrank+220, 0, 0,
Xyycrank+226, 0, 0,
Xyycrank+235, 0, 0,
Xyycrank+241, 0, 0,
Xyycrank+0, 0, yyvstop+118,
Xyycrank+240, 0, 0,
Xyycrank+236, 0, 0,
Xyycrank+232, 0, 0,
Xyycrank+242, 0, 0,
Xyycrank+249, 0, 0,
Xyycrank+238, 0, 0,
Xyycrank+0, 0, yyvstop+120,
Xyycrank+0, 0, yyvstop+122,
Xyycrank+290, 0, 0,
Xyycrank+0, 0, yyvstop+124,
Xyycrank+274, 0, 0,
Xyycrank+273, 0, 0,
Xyycrank+276, 0, 0,
Xyycrank+0, 0, yyvstop+126,
Xyycrank+295, 0, 0,
Xyycrank+292, 0, 0,
Xyycrank+296, 0, 0,
Xyycrank+286, 0, 0,
Xyycrank+294, 0, 0,
Xyycrank+294, 0, 0,
Xyycrank+0, 0, yyvstop+128,
Xyycrank+0, 0, yyvstop+130,
Xyycrank+264, 0, 0,
Xyycrank+264, 0, 0,
Xyycrank+266, 0, 0,
Xyycrank+0, 0, yyvstop+132,
Xyycrank+289, 0, 0,
Xyycrank+293, 0, 0,
Xyycrank+293, 0, 0,
Xyycrank+298, 0, 0,
Xyycrank+283, 0, 0,
Xyycrank+0, 0, yyvstop+134,
Xyycrank+284, 0, 0,
Xyycrank+0, 0, yyvstop+136,
Xyycrank+292, 0, 0,
Xyycrank+0, 0, yyvstop+138,
Xyycrank+301, 0, 0,
Xyycrank+0, 0, yyvstop+140,
Xyycrank+0, 0, yyvstop+142,
Xyycrank+323, 0, 0,
Xyycrank+331, 0, 0,
Xyycrank+323, 0, 0,
Xyycrank+0, 0, yyvstop+144,
Xyycrank+330, 0, 0,
Xyycrank+325, 0, 0,
Xyycrank+337, 0, 0,
Xyycrank+0, 0, yyvstop+146,
Xyycrank+315, 0, 0,
Xyycrank+0, 0, yyvstop+148,
Xyycrank+0, 0, yyvstop+150,
Xyycrank+0, 0, yyvstop+152,
Xyycrank+0, 0, yyvstop+154,
Xyycrank+0, 0, yyvstop+156,
Xyycrank+0, 0, yyvstop+158,
Xyycrank+297, 0, 0,
Xyycrank+305, 0, 0,
Xyycrank+0, 0, yyvstop+160,
Xyycrank+0, 0, yyvstop+162,
Xyycrank+0, 0, yyvstop+164,
Xyycrank+0, 0, yyvstop+166,
Xyycrank+404, 0, 0,
Xyycrank+347, 0, 0,
Xyycrank+327, 0, 0,
Xyycrank+342, 0, 0,
Xyycrank+0, 0, yyvstop+168,
Xyycrank+347, 0, 0,
Xyycrank+347, 0, 0,
Xyycrank+0, 0, yyvstop+170,
Xyycrank+0, 0, yyvstop+172,
Xyycrank+0, 0, yyvstop+174,
Xyycrank+348, 0, 0,
Xyycrank+0, 0, yyvstop+176,
Xyycrank+0, 0, yyvstop+178,
Xyycrank+356, 0, 0,
Xyycrank+346, 0, 0,
Xyycrank+363, 0, 0,
Xyycrank+354, 0, 0,
Xyycrank+362, 0, 0,
Xyycrank+366, 0, 0,
Xyycrank+355, 0, 0,
Xyycrank+360, 0, 0,
Xyycrank+370, 0, 0,
Xyycrank+0, 0, yyvstop+180,
Xyycrank+361, 0, 0,
Xyycrank+355, 0, 0,
Xyycrank+370, 0, 0,
Xyycrank+373, 0, 0,
Xyycrank+372, 0, 0,
Xyycrank+358, 0, 0,
Xyycrank+376, 0, 0,
Xyycrank+375, 0, 0,
Xyycrank+0, 0, yyvstop+182,
Xyycrank+377, 0, 0,
Xyycrank+363, 0, 0,
Xyycrank+365, 0, 0,
Xyycrank+367, 0, 0,
Xyycrank+367, 0, 0,
Xyycrank+0, 0, yyvstop+184,
Xyycrank+368, 0, 0,
Xyycrank+0, 0, yyvstop+186,
Xyycrank+0, 0, yyvstop+188,
X0, 0, 0};
Xstruct yywork *yytop = yycrank+502;
Xstruct yysvf *yybgin = yysvec+1;
Xchar yymatch[] ={
X00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X040 ,01 ,'"' ,'#' ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,'#' ,01 ,'#' ,'#' ,01 ,
X'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
X'0' ,'0' ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,'#' ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,'#' ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,'#' ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,'#' ,'#' ,'#' ,01 ,01 ,
X0};
Xchar yyextra[] ={
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0};
X/* ncform 4.1 83/08/11 */
X
Xint yylineno =1;
X# define YYU(x) x
X# define NLSTATE yyprevious=YYNEWLINE
Xchar yytext[YYLMAX];
Xstruct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
Xchar yysbuf[YYLMAX];
Xchar *yysptr = yysbuf;
Xint *yyfnd;
Xextern struct yysvf *yyestate;
Xint yyprevious = YYNEWLINE;
Xyylook(){
X register struct yysvf *yystate, **lsp;
X register struct yywork *yyt;
X struct yysvf *yyz;
X int yych;
X struct yywork *yyr;
X# ifdef LEXDEBUG
X int debug;
X# endif
X char *yylastch;
X /* start off machines */
X# ifdef LEXDEBUG
X debug = 0;
X# endif
X if (!yymorfg)
X yylastch = yytext;
X else {
X yymorfg=0;
X yylastch = yytext+yyleng;
X }
X for(;;){
X lsp = yylstate;
X yyestate = yystate = yybgin;
X if (yyprevious==YYNEWLINE) yystate++;
X for (;;){
X# ifdef LEXDEBUG
X if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
X# endif
X yyt = yystate->yystoff;
X if(yyt == yycrank){ /* may not be any transitions */
X yyz = yystate->yyother;
X if(yyz == 0)break;
X if(yyz->yystoff == yycrank)break;
X }
X *yylastch++ = yych = input();
X tryagain:
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"char ");
X allprint(yych);
X putchar('\n');
X }
X# endif
X yyr = yyt;
X if ( (int)yyt > (int)yycrank){
X yyt = yyr + yych;
X if (yyt <= yytop && yyt->verify+yysvec == yystate){
X if(yyt->advance+yysvec == YYLERR) /* error transitions */
X {unput(*--yylastch);break;}
X *lsp++ = yystate = yyt->advance+yysvec;
X goto contin;
X }
X }
X# ifdef YYOPTIM
X else if((int)yyt < (int)yycrank) { /* r < yycrank */
X yyt = yyr = yycrank+(yycrank-yyt);
X# ifdef LEXDEBUG
X if(debug)fprintf(yyout,"compressed state\n");
X# endif
X yyt = yyt + yych;
X if(yyt <= yytop && yyt->verify+yysvec == yystate){
X if(yyt->advance+yysvec == YYLERR) /* error transitions */
X {unput(*--yylastch);break;}
X *lsp++ = yystate = yyt->advance+yysvec;
X goto contin;
X }
X yyt = yyr + YYU(yymatch[yych]);
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"try fall back character ");
X allprint(YYU(yymatch[yych]));
X putchar('\n');
X }
X# endif
X if(yyt <= yytop && yyt->verify+yysvec == yystate){
X if(yyt->advance+yysvec == YYLERR) /* error transition */
X {unput(*--yylastch);break;}
X *lsp++ = yystate = yyt->advance+yysvec;
X goto contin;
X }
X }
X if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
X# ifdef LEXDEBUG
X if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
X# endif
X goto tryagain;
X }
X# endif
X else
X {unput(*--yylastch);break;}
X contin:
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"state %d char ",yystate-yysvec-1);
X allprint(yych);
X putchar('\n');
X }
X# endif
X ;
X }
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
X allprint(yych);
X putchar('\n');
X }
X# endif
X while (lsp-- > yylstate){
X *yylastch-- = 0;
X if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
X yyolsp = lsp;
X if(yyextra[*yyfnd]){ /* must backup */
X while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
X lsp--;
X unput(*yylastch--);
X }
X }
X yyprevious = YYU(*yylastch);
X yylsp = lsp;
X yyleng = yylastch-yytext+1;
X yytext[yyleng] = 0;
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"\nmatch ");
X sprint(yytext);
X fprintf(yyout," action %d\n",*yyfnd);
X }
X# endif
X return(*yyfnd++);
X }
X unput(*yylastch);
X }
X if (yytext[0] == 0 /* && feof(yyin) */)
X {
X yysptr=yysbuf;
X return(0);
X }
X yyprevious = yytext[0] = input();
X if (yyprevious>0)
X output(yyprevious);
X yylastch=yytext;
X# ifdef LEXDEBUG
X if(debug)putchar('\n');
X# endif
X }
X }
Xyyback(p, m)
X int *p;
X{
Xif (p==0) return(0);
Xwhile (*p)
X {
X if (*p++ == m)
X return(1);
X }
Xreturn(0);
X}
X /* the following are only used in the lex library */
Xyyinput(){
X return(input());
X }
Xyyoutput(c)
X int c; {
X output(c);
X }
Xyyunput(c)
X int c; {
X unput(c);
X }
END_OF_FILE
if test 21018 -ne `wc -c <'src/lev_lex.c'`; then
echo shar: \"'src/lev_lex.c'\" unpacked with wrong size!
fi
# end of 'src/lev_lex.c'
echo shar: End of archive 27 \(of 30\).
cp /dev/null ark27isdone
MISSING=""
for I in 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 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 30 archives.
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0