home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / assemblr / library / asm_kit / vw_to_ws.asm < prev    next >
Assembly Source File  |  1984-03-04  |  16KB  |  440 lines
  1.         NAME    VWTOWS
  2.         PAGE    55,132
  3.         TITLE   'VWTOWS --- FILTER VW TEXT FILE FOR WORDSTAR'
  4.  
  5. ;
  6. ; VWTOWS -- CONVERT VOLKSWRITER FILE TO WORDSTAR DOCUMENT FILE.
  7. ; EXTRA SEQUENTIAL SPACES ARE CONVERTED TO "SOFT SPACES".
  8. ; PARAGRAPH MARKERS ARE CONVERTED TO "HARD CARRIAGE RETURNS".
  9. ; NORMAL CR'S ARE CONVERTED TO "SOFT CARRIAGE RETURNS".
  10. ; ALL OTHER CONTROL CHARACTERS EXCEPT FOR LINE FEEDS AND FORM
  11. ; FEEDS ARE DISCARDED.
  12.  
  13. ; VERSION 1.0    10 DEC 83
  14. ;
  15. ; COPYRIGHT (C) 1983 BY RAY DUNCAN
  16.  
  17. CR      EQU     0DH             ;ASCII CARRIAGE RETURN
  18. LF      EQU     0AH             ;ASCII LINE FEED
  19. FF      EQU     0CH             ;ASCII FORM FEED
  20. EOF     EQU     01AH            ;END OF FILE MARKER
  21. TAB     EQU     09H             ;ASCII TAB CHARACTER
  22.  
  23. COMMAND EQU     80H             ;BUFFER FOR COMMAND TAIL
  24.  
  25. BLKSIZE EQU     1024            ;BLOCKING/DEBLOCKING SIZE
  26.  
  27.  
  28. CSEG    SEGMENT PARA PUBLIC 'CODE'
  29.  
  30.         ASSUME  CS:CSEG,DS:DATA,ES:DATA,SS:STACK
  31.  
  32.  
  33. CLEAN   PROC    FAR             ;ENTRY POINT FROM PC-DOS
  34.  
  35.         PUSH    DS              ;SAVE DS:0000 FOR FINAL
  36.         XOR     AX,AX           ;RETURN TO PC-DOS
  37.         PUSH    AX
  38.         MOV     AX,DATA         ;MAKE OUR DATA SEGMENT
  39.         MOV     ES,AX           ;ADDRESSABLE VIA ES REGISTER
  40.         CALL    INFILE          ;GET PATH AND FILE SPEC.
  41.                                 ;FOR INPUT FILE
  42.         MOV     AX,ES           ;SET DS=ES FOR REMAINDER
  43.         MOV     DS,AX           ;OF PROGRAM
  44.         JNC     CLEAN1          ;JUMP, GOT ACCEPTABLE NAME
  45.         MOV     DX,OFFSET MSG4  ;MISSING OR ILLEGAL FILESPEC,
  46.         JMP     CLEAN9          ;PRINT ERROR MESSAGE AND EXIT.
  47.  
  48. CLEAN1: CALL    OUTFILE         ;SET UP OUTPUT FILE NAME
  49.         CALL    OPEN_INPUT      ;NOW TRY TO OPEN INPUT FILE
  50.         JNC     CLEAN2          ;JUMP,OPENED INPUT OK
  51.         MOV     DX,OFFSET MSG1  ;OPEN OF INPUT FILE FAILED,
  52.         JMP     CLEAN9          ;PRINT ERROR MSG AND EXIT.
  53.  
  54. CLEAN2:
  55.         CALL    OPEN_OUTPUT     ;TRY TO OPEN OUTPUT FILE.
  56.         JNC     CLEAN25         ;JUMP,OPENED OK
  57.         MOV     DX,OFFSET MSG2  ;OPEN OF OUTPUT FILE FAILED,
  58.         JMP     CLEAN9          ;PRINT ERROR MESSAGE AND EXIT.
  59.  
  60. CLEAN25:                        ;ALL FILES OPENED SUCCESSFULLY,
  61.         CALL    SIGN_ON         ;PRINT SIGN-ON MESSAGE AND
  62.         CALL    INIT_BUFFS      ;SET UP BUFFERS.
  63.  
  64. CLEAN3:                         ;NOW FILTER THE FILE.
  65.         CALL    GET_CHAR        ;READ 1 CHARACTER FROM INPUT.
  66.         AND     AL,07FH         ;STRIP OFF THE HIGH BIT
  67.         CMP     AL,20H          ;IS IT A CONTROL CODE OR SPACE?
  68.         JA      CLEAN4          ;NO,WRITE IT TO NEW FILE
  69.         JNE     CLEAN32         ;JUMP IF NOT A SPACE CODE
  70.         MOV     AH,PREV_CHAR    ;CHECK IF LAST CHAR WAS A SPACE
  71.         AND     AH,7FH
  72.         CMP     AH,20H
  73.         JNE     CLEAN4          ;NO,WRITE NORMAL SPACE
  74.         OR      AL,80H          ;YES, CONVERT THIS SPACE TO "SOFT"
  75.         JMP     CLEAN4          ;AND WRITE IT TO THE FILE
  76. CLEAN32:                        ;IT IS CONTROL CODE,
  77.         CMP     AL,EOF          ;IS IT END OF FILE MARKER?
  78.         JE      CLEAN6          ;YES,JUMP TO CLOSE FILES.
  79.  
  80.         CMP     AL,14H          ;IS IT VW PARAGRAPH MARKER?
  81.         JNE     CLEAN33         ;NO,JUMP
  82.         CALL    GET_CHAR        ;DISCARD FOLLOWING CR-LF
  83.         CALL    GET_CHAR
  84.         MOV     AL,CR           ;CONVERT IT TO "HARD" RETURN
  85.         CALL    PUT_CHAR        ;AND LINE FEED SEQUENCE.
  86.         MOV     AL,LF
  87.         JMP     CLEAN35         ;AND WRITE IT TO FILE.
  88. CLEAN33:
  89.         CMP     AL,TAB          ;IS IT A TAB COMMAND?
  90.         JZ      CLEAN5          ;YES,JUMP TO SPECIAL PROCESSING.
  91.         CMP     AL,CR           ;IF CARRIAGE RETURN AND THE LINE IS
  92.         JNE     CLEAN34         ;NOT EMPTY, CONVERT IT TO "SOFT RETURN"
  93.         MOV     BX,COLUMN
  94.         OR      BX,BX
  95.         JZ      CLEAN35
  96.         OR      AL,80H          ;AND WRITE IT TO FILE
  97.         JMP     CLEAN35
  98. CLEAN34:
  99.         CMP     AL,LF           ;IF LINE FEED WRITE IT TO FILE,
  100.         JNE     CLEAN3          ;OTHERWISE DISCARD CONTROL CODE.
  101. CLEAN35:                        ;IF IT IS ONE OF THOSE THREE,
  102.         MOV     COLUMN,0        ;INCIDENTALLY INITIALIZE
  103.         JMP     CLEAN45         ;COLUMN COUNT FOR TAB PROCESSOR.
  104.  
  105. CLEAN4:                         ;COUNT ALPHANUMERIC CHARS. SENT.
  106.         INC     COLUMN
  107.  
  108. CLEAN45:                        ;WRITE THIS CHARACTER TO
  109.         CALL    PUT_CHAR        ;OUTPUT FILE,
  110.         JNC     CLEAN3          ;IF CY NOT SET, WRITE WAS
  111.                                 ;OK SO GO GET NEXT CHAR.
  112. CLEAN47:
  113.         CALL    CLOSE_INPUT     ;IF CY SET, DISK IS FULL
  114.         CALL    CLOSE_OUTPUT    ;SO CLOSE FILES AND EXIT
  115.         MOV     DX,OFFSET MSG5  ;WITH ERROR MESSAGE.
  116.         JMP     CLEAN9
  117.  
  118. CLEAN5:                         ;PROCESS TAB CHARACTER
  119.         MOV     AX,COLUMN       ;LET DX:AX=COLUMN COUNT
  120.         CWD
  121.         MOV     CX,8            ;DIVIDE IT BY EIGHT...
  122.         IDIV    CX
  123.         SUB     CX,DX           ;REMAINDER IS IN DX.
  124.         ADD     COLUMN,CX       ;UPDATE COLUMN POINTER.
  125. CLEAN55:                        ;8 MINUS THE REMAINDER
  126.         PUSH    CX              ;GIVES US THE NUMBER OF
  127.         MOV     AL,20H          ;SPACES TO SEND OUT TO
  128.         CALL    PUT_CHAR        ;MOVE TO THE NEXT TAB POSITION
  129.         POP     CX              ;RESTORE SPACE COUNT
  130.         JC      CLEAN47         ;JUMP IF DISK IS FULL
  131.         LOOP    CLEAN55
  132.         JMP     CLEAN3          ;GET NEXT CHARACTER
  133.  
  134. CLEAN6:                         ;END OF FILE DETECTED,
  135.         CALL    PUT_CHAR        ;WRITE END-OF-FILE MARKER,
  136.         JC      CLEAN47         ;JUMP IF DISK WAS FULL
  137.         CALL    FLUSH_BUFFS     ;WRITE REMAINING DATA TO DISK
  138.         JC      CLEAN47         ;IF CY SET,DISK WAS FULL
  139.                                 ;OTHERWISE FILE WAS WRITTEN OK
  140.         CALL    CLOSE_INPUT     ;CLOSE INPUT AND OUTPUT
  141.         CALL    CLOSE_OUTPUT    ;FILES.
  142.         MOV     DX,OFFSET MSG3  ;ADDR OF SUCCESS MESSAGE,
  143.  
  144. CLEAN9:                         ;PRINT MESSAGE AND RETURN
  145.         MOV     AH,9            ;CONTROL TO PC-DOS
  146.         INT     21H
  147.         RET
  148.  
  149. CLEAN   ENDP
  150.  
  151.  
  152. INFILE  PROC    NEAR            ;PROCESS NAME OF INPUT FILE
  153.                                 ;DS:SI <- ADDR COMMAND LINE
  154.         MOV     SI,OFFSET COMMAND
  155.                                 ;ES:DI <- ADDR FILESPEC BUFFER
  156.         MOV     DI,OFFSET INPUT_NAME
  157.         CLD
  158.         LODSB                   ;ANY COMMAND LINE PRESENT?
  159.         OR      AL,AL           ;RETURN ERROR STATUS IF NOT.
  160.         JZ      INFILE4
  161. INFILE1:                        ;SCAN OVER LEADING BLANKS
  162.         LODSB                   ;TO FILE NAME
  163.         CMP     AL,CR           ;IF WE HIT CARRIAGE RETURN
  164.         JZ      INFILE4         ;FILENAME IS MISSING.
  165.         CMP     AL,20H          ;IS THIS A BLANK?
  166.         JZ      INFILE1         ;IF SO KEEP SCANNING.
  167.  
  168. INFILE2:                        ;FOUND FIRST CHAR OF NAME,
  169.         STOSB                   ;MOVE LAST CHAR. TO OUTPUT
  170.                                 ;FILE NAME BUFFER.
  171.         LODSB                   ;CHECK NEXT CHARACTER, FOUND
  172.         CMP     AL,CR           ;CARRIAGE RETURN YET?
  173.         JE      INFILE3         ;YES,EXIT WITH SUCCESS CODE
  174.         CMP     AL,20H          ;IS THIS A BLANK?
  175.         JNE     INFILE2         ;IF NOT KEEP MOVING CHARS.
  176.  
  177. INFILE3:                        ;EXIT WITH CARRY =0
  178.         CLC                     ;FOR SUCCESS FLAG
  179.         RET
  180.  
  181. INFILE4:                        ;EXIT WITH CARRY =1
  182.         STC                     ;FOR ERROR FLAG
  183.         RET
  184. INFILE  ENDP
  185.  
  186. OUTFILE PROC    NEAR            ;SET UP PATH AND FILE
  187.         CLD                     ;NAME FOR OUTPUT FILE.
  188.         MOV     CX,64           ;LENGTH TO MOVE
  189.         MOV     SI,OFFSET INPUT_NAME  ;SOURCE ADDR
  190.         MOV     DI,OFFSET OUTPUT_NAME ;DEST ADDR
  191.         REP MOVSB               ;TRANSFER THE STRING
  192.         MOV     DI,OFFSET OUTPUT_NAME
  193. OUTFILE1:                       ;SCAN STRING LOOKING FOR
  194.         MOV     AL,[DI]         ;"." MARKING START OF EXTENSION
  195.         OR      AL,AL           ;OR ZERO BYTE MARKING NAME END.
  196.         JZ      OUTFILE2        ;IF EITHER IS FOUND,JUMP.
  197.         CMP     AL,'.'
  198.         JE      OUTFILE2        ;BUMP STRING POINTER, LOOP
  199.         INC     DI              ;IF NEITHER '.' OR ZERO FOUND.
  200.         JMP     OUTFILE1
  201. OUTFILE2:                       ;FOUND ZERO OR '.',FORCE THE
  202.                                 ;EXTENSION OF OUTPUT FILE TO '.WS'
  203.         MOV     SI,OFFSET OUTFILE_EXT
  204.         MOV     CX,4
  205.         REP MOVSB
  206.         RET                     ;BACK TO CALLER
  207. OUTFILE ENDP
  208.  
  209. OPEN_INPUT PROC NEAR            ;OPEN INPUT FILE
  210.                                 ;DS:DX=ADDR FILENAME
  211.         MOV     DX,OFFSET INPUT_NAME
  212.         MOV     AL,0            ;AL=0 FOR READ ONLY
  213.         MOV     AH,3DH          ;FUNCTION 3DH=OPEN
  214.         INT     21H             ;HANDLE RETURNED IN AX,
  215.         MOV     INPUT_HANDLE,AX ;SAVE IT FOR LATER.
  216.         RET                     ;CY IS SET IF ERROR
  217. OPEN_INPUT ENDP
  218.  
  219. OPEN_OUTPUT PROC NEAR           ;OPEN OUTPUT FILE
  220.                                 ;DS:DX=ADDR FILENAME
  221.         MOV     DX,OFFSET OUTPUT_NAME
  222.         MOV     AL,1            ;AL=1 FOR WRITE ONLY
  223.         MOV     AH,3CH          ;FUNCTION 3CH=MAKE OR
  224.         INT     21H             ;TRUNCATE EXISTING FILE
  225.                                 ;HANDLE RETURNED IN AX
  226.         MOV     OUTPUT_HANDLE,AX;SAVE IT FOR LATER.
  227.         RET                     ;RETURN CY=TRUE IF ERROR
  228. OPEN_OUTPUT ENDP
  229.  
  230. CLOSE_INPUT PROC NEAR           ;CLOSE INPUT FILE
  231.         MOV     BX,INPUT_HANDLE ;BX=HANDLE
  232.         MOV     AH,3EH
  233.         INT     21H
  234.         RET
  235. CLOSE_INPUT ENDP
  236.  
  237. CLOSE_OUTPUT PROC NEAR          ;CLOSE OUTPUT FILE
  238.         MOV     BX,OUTPUT_HANDLE;BX=HANDLE
  239.         MOV     AH,3EH
  240.         INT     21H
  241.         RET
  242. CLOSE_OUTPUT ENDP
  243.  
  244. GET_CHAR PROC   NEAR            ;GET ONE CHARACTER FROM INPUT BUFFER
  245.         MOV     BX,INPUT_PTR
  246.         CMP     BX,BLKSIZE
  247.         JNE     GET_CHAR1
  248.         CALL    READ_BLOCK
  249.         MOV     BX,0
  250. GET_CHAR1:
  251.         MOV     AL,[INPUT_BUFFER+BX]
  252.         INC     BX
  253.         MOV     INPUT_PTR,BX
  254.         RET
  255. GET_CHAR ENDP
  256.  
  257. PUT_CHAR PROC   NEAR            ;PUT ONE CHARACTER INTO OUTPUT BUFFER
  258.         MOV     PREV_CHAR,AL    ;SAVE COPY OF MOST RECENT OUTPUT
  259.         MOV     BX,OUTPUT_PTR
  260.         MOV     [OUTPUT_BUFFER+BX],AL
  261.         INC     BX
  262.         MOV     OUTPUT_PTR,BX
  263.         CMP     BX,BLKSIZE      ;BUFFER FULL YET?
  264.         JNE     PUT_CHAR1       ;NO,JUMP
  265.         CALL    WRITE_BLOCK     ;YES,WRITE THE BLOCK
  266.         RET                     ;RETURN CY AS STATUS CODE
  267. PUT_CHAR1:
  268.         CLC                     ;RETURN CY CLEAR FOR OK STATUS
  269.         RET
  270. PUT_CHAR ENDP
  271.  
  272. READ_BLOCK PROC NEAR
  273.         MOV     BX,INPUT_HANDLE ;READ FIRST BLOCK OF INPUT
  274.         MOV     CX,BLKSIZE
  275.         MOV     DX,OFFSET INPUT_BUFFER
  276.         MOV     AH,3FH
  277.         INT     21H
  278.         JNC     READ_BLOCK1     ;JUMP IF NO ERROR STATUS
  279.         MOV     AX,0            ;SIMULATE A ZERO LENGTH READ IF ERROR
  280. READ_BLOCK1:
  281.         CMP     AX,BLKSIZE      ;WAS FULL BUFFER READ IN?
  282.         JE      READ_BLOCK2     ;YES,JUMP
  283.         MOV     BX,AX           ;NO, STORE END-OF-FILE MARK
  284.         MOV     BYTE PTR [INPUT_BUFFER+BX],EOF
  285. READ_BLOCK2:
  286.         XOR     AX,AX           ;INITIALIZE INPUT BUFFER POINTER
  287.         MOV     INPUT_PTR,AX
  288.         RET
  289. READ_BLOCK ENDP
  290.  
  291. WRITE_BLOCK PROC NEAR           ;WRITE BLOCKED OUTPUT (BLKSIZE BYTES)
  292.         MOV     DX,OFFSET OUTPUT_BUFFER
  293.         MOV     CX,BLKSIZE
  294.         MOV     BX,OUTPUT_HANDLE
  295.         MOV     AH,40H
  296.         INT     21H
  297.         XOR     BX,BX           ;INITIALIZE POINTER TO BLOCKING BUFFER
  298.         MOV     OUTPUT_PTR,BX
  299.         CMP     AX,BLKSIZE      ;WAS CORRECT LENGTH WRITTEN?
  300.         JNE     WRITE_BLOCK1    ;NO,DISK MUST BE FULL
  301.         CLC                     ;YES,RETURN CY=0 INDICATING ALL OK
  302.         RET
  303. WRITE_BLOCK1:                   ;DISK IS FULL, RETURN CY =1
  304.         STC                     ;AS ERROR CODE
  305.         RET
  306. WRITE_BLOCK ENDP
  307.  
  308. INIT_BUFFS PROC NEAR
  309.         CALL    READ_BLOCK      ;READ 1ST BLOCK OF INPUT
  310.         XOR     AX,AX           ;INITIALIZE POINTER TO OUTPUT
  311.         MOV     OUTPUT_PTR,AX   ;OUTPUT BLOCKING BUFFER
  312.         RET
  313. INIT_BUFFS ENDP
  314.  
  315. FLUSH_BUFFS PROC NEAR           ;WRITE ANY DATA IN OUTPUT BUFFER TO DISK
  316.         MOV     CX,OUTPUT_PTR
  317.         OR      CX,CX
  318.         JZ      FLUSH_BUFFS1    ;JUMP,BUFFER IS EMPTY
  319.         MOV     BX,OUTPUT_HANDLE
  320.         MOV     DX,OFFSET OUTPUT_BUFFER
  321.         MOV     AH,40H
  322.         INT     21H
  323.         CMP     AX,OUTPUT_PTR   ;WAS WRITE SUCCESSFUL?
  324.         JNZ     FLUSH_BUFFS2    ;NO,JUMP
  325. FLUSH_BUFFS1:                   ;SUCCESSFUL DISK WRITE,
  326.         CLC                     ;RETURN CY=0 FOR
  327.         RET                     ;SUCCESS FLAG
  328. FLUSH_BUFFS2:                   ;DISK WAS FULL SO WRITE FAILED,
  329.         STC                     ;RETURN CY=1 AS ERROR FLAG
  330.         RET
  331. FLUSH_BUFFS ENDP
  332.  
  333. SIGN_ON PROC    NEAR            ;PRINT SIGN-ON MESSAGE
  334.         MOV     DX,OFFSET MSG6  ;TITLE...
  335.         MOV     AH,9
  336.         INT     21H
  337.         MOV     DX,OFFSET MSG7  ;INPUT FILE:
  338.         MOV     AH,9
  339.         INT     21H
  340.         MOV     DX,OFFSET INPUT_NAME
  341.         CALL    PASCIIZ
  342.         MOV     DX,OFFSET MSG8  ;OUTPUT FILE:
  343.         MOV     AH,9
  344.         INT     21H
  345.         MOV     DX,OFFSET OUTPUT_NAME
  346.         CALL    PASCIIZ
  347.         MOV     DX,OFFSET MSG9
  348.         MOV     AH,9
  349.         INT     21H
  350.         RET
  351. SIGN_ON ENDP
  352.  
  353. PASCIIZ PROC    NEAR            ;CALL DX=OFFSET OF ASCIIZ STRING
  354.         MOV     BX,DX           ;WHICH WILL BE PRINTED ON STANDARD OUTPUT
  355. PASCIIZ1:
  356.         MOV     DL,[BX]
  357.         OR      DL,DL
  358.         JZ      PASCIIZ9
  359.         CMP     DL,'A'
  360.         JB      PASCIIZ2
  361.         CMP     DL,'Z'
  362.         JA      PASCIIZ2
  363.         OR      DL,20H
  364. PASCIIZ2:
  365.         MOV     AH,2
  366.         INT     21H
  367.         INC     BX
  368.         JMP     PASCIIZ1
  369. PASCIIZ9:
  370.         RET
  371. PASCIIZ ENDP
  372.  
  373. CSEG    ENDS
  374.  
  375.  
  376. DATA    SEGMENT PARA PUBLIC 'DATA'
  377.  
  378. INPUT_NAME      DB      64 DUP (0)      ;BUFFER FOR INPUT FILESPEC
  379. OUTPUT_NAME     DB      64 DUP (0)      ;BUFFER FOR OUTPUT FILESPEC
  380.  
  381. INPUT_HANDLE    DW      0               ;TOKEN RETURNED BY PCDOS
  382. OUTPUT_HANDLE   DW      0               ;TOKEN RETURNED BY PCDOS
  383.  
  384. INPUT_PTR       DW      0               ;POINTER TO INPUT BLOCKING BUFFER
  385. OUTPUT_PTR      DW      0               ;POINTER TO OUTPUT BLOCKING BUFFER
  386.  
  387. OUTFILE_EXT     DB      '.WS',0         ;EXTENSION FOR FILTERED FILE
  388.  
  389. COLUMN          DW      0               ;COLUMN COUNT FOR TAB PROCESSING
  390.  
  391. PREV_CHAR       DB      0               ;LAST CHARACTER WRITTEN TO OUTPUT
  392.  
  393. MSG1            DB      CR,LF
  394.                 DB      'CANNOT FIND INPUT FILE.'
  395.                 DB      CR,LF,'$'
  396.  
  397. MSG2            DB      CR,LF
  398.                 DB      'FAILED TO OPEN OUTPUT FILE.'
  399.                 DB      CR,LF,'$'
  400.  
  401. MSG3            DB      CR,LF
  402.                 DB      'FILE PROCESSING COMPLETED'
  403.                 DB      CR,LF,'$'
  404.  
  405. MSG4            DB      CR,LF
  406.                 DB      'MISSING FILE NAME.'
  407.                 DB      CR,LF,'$'
  408.  
  409. MSG5            DB      CR,LF
  410.                 DB      'DISK IS FULL.'
  411.                 DB      CR,LF,'$'
  412.  
  413. MSG6            DB      CR,LF
  414.                 DB      'CONVERT VOLKSWRITER FILE TO WORDSTAR DOCUMENT'
  415.                 DB      CR,LF
  416.                 DB      'COPYRIGHT (C) 1983 LABORATORY MICROSYSTEMS INC.'
  417.                 DB      CR,LF,'$'
  418.  
  419. MSG7            DB      CR,LF,'INPUT FILE:   $'
  420.  
  421. MSG8            DB      CR,LF,'OUTPUT FILE:  $'
  422.  
  423. MSG9            DB      CR,LF,'$'
  424.  
  425.  
  426. INPUT_BUFFER    DB      BLKSIZE DUP (?) ;BUFFER FOR DEBLOCKING OF DATA
  427.                                         ;FROM INPUT FILE
  428.  
  429. OUTPUT_BUFFER   DB      BLKSIZE DUP (?) ;BUFFER FOR BLOCKING OF DATA
  430.                                         ;SENT TO OUTPUT FILE
  431.  
  432. DATA    ENDS
  433.  
  434.  
  435. STACK   SEGMENT PARA STACK 'STACK'
  436.         DB      64 DUP (?)
  437. STACK   ENDS
  438.  
  439.         END     CLEAN
  440.