SUBROUTINE DOWNLOAD.PROCESS(OUTPUT.REC.CTR, BREAK.LEVEL, BY.EXP.VALUE.CTR, BY.EXP.SUBVALUE.CTR)
*
* INFO/BASIC SUBROUTINE
* 11/27/90
* DWS
* TITLE ----- DOWNLOAD.PROCESS
*
*
* PURPOSE: CREATE THE DOWNLOAD OUTPUT / HEADING, DETAIL & FOOTING RECORDS
*
*
*************************************************************************
* Stamped: p43 rotmand, /usr/local/download, user #1026, 06 May 08, 11:55AM.
* Version 7.30
*
*
*

      $INCLUDE I_DOWNLOAD_MAX_COMMON
      $INCLUDE I_DOWNLOAD_MAIN_COMMON
      $INCLUDE I_DOWNLOAD_DATA_COMMON
      $INCLUDE I_DOWNLOAD_WP_COMMON
      $INCLUDE I_DOWNLOAD_OUT_REC_COMMON
      $INCLUDE I_DOWNLOAD_WHEN_COMMON
      $INCLUDE I_DBF_HEADER


      DEBUG1OR2
      CRT 'INSIDE DOWNLOAD.PROCESS'
      END
*
* MAIN CONTROL
*
      GOSUB BUILD.DETAIL.LINES
      GOSUB PRINT.DETAIL.LINES
      RETURN


*
*
* BUILD DETAIL LINES
* Many of these routines were re-written as part of version 6.00.
* While the logic in the various routines is nearly identical,
* the routines are being left separate to allow for performance
* reasons and to allow for future customization according to
* the particular output file format being processed.
*
BUILD.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside DOWNLOAD.PROCESS, producing output record type ':OUTPUT.REC.CTR
      END
      DETAIL.LINES = ''
      BEGIN CASE
         CASE DLMAIN.FORMAT = 'FIXED' OR DLMAIN.FORMAT = 'DBF'
            GOSUB BUILD.FIXED.DETAIL.LINES
            IF DLMAIN.FORMAT = 'FIXED' AND DLMAIN.RECORD.LENGTH # '' THEN
               GOSUB DO.RECORD.LENGTH
            END
         CASE DLMAIN.FORMAT = 'HTML'
            GOSUB BUILD.HTML.DETAIL.LINES
         CASE DLMAIN.FORMAT = 'XML'
            GOSUB BUILD.XML.DETAIL.LINES
            IF OUTPUT.REC.CTR # DLMAIN.HEADING.OUT.REC THEN
               X.TEMP = '<'
               X.LIT.DICT.EVAL = DL.OUTR.XML.FILE.NAME
               GOSUB GET.LIT.DICT.EVAL
               X.SAVE.XML.FILE.NAME = X.LIT.DICT.EVAL.VALUE
               IF X.SAVE.XML.FILE.NAME EQ NULL.CODE THEN
                  DETAIL.LINES = DETAIL.LINES[2,LEN(DETAIL.LINES)]
               END ELSE
                  X.TEMP := X.LIT.DICT.EVAL.VALUE
                  X.TEMP := XML.ATTRIBUTE.TEXT
                  IF DL.OUTR.XML.FILE.ATTRIBUTE # '' THEN
                     X.LIT.DICT.EVAL = DL.OUTR.XML.FILE.ATTRIBUTE
                     GOSUB GET.LIT.DICT.EVAL
                     IF X.LIT.DICT.EVAL.VALUE NE '' THEN
                        X.TEMP := ' ':X.LIT.DICT.EVAL.VALUE
                     END
                  END
                  IF DETAIL.LINES = '' THEN
                     X.TEMP := ' />'
                     DETAIL.LINES = X.TEMP
                  END ELSE
                     X.TEMP := '>'
                     DETAIL.LINES = X.TEMP:DETAIL.LINES
                     DETAIL.LINES := @FM:'</':X.SAVE.XML.FILE.NAME:'>'
                  END
               END
            END
         CASE DLMAIN.FORMAT = 'QUOTE' OR DLMAIN.FORMAT = 'COMMA' OR DLMAIN.FORMAT = 'TAB'
            GOSUB BUILD.COMMA.QUOTE.DETAIL.LINES
         CASE DLMAIN.FORMAT = 'WP50' OR DLMAIN.FORMAT = 'WP51'
            GOSUB BUILD.WORDPERFECT.DETAIL.LINES
         CASE DLMAIN.FORMAT = 'DIF'
            GOSUB BUILD.DIF.DETAIL.LINES
      END CASE
      IF DLMAIN.UPCASE THEN
         GOSUB DO.UPCASE
      END
      RETURN



*
* CHANGE RECORD TO UPPER CASE
*
DO.UPCASE: 
      DEBUG6
      CRT 'GOSUB DO.UPCASE '
      END
      DETAIL.LINES = OCONV(DETAIL.LINES,'MCU')
      RETURN


*
* REMOVE PUNCTUATION (EG, FOR US POSTAL SERVICE)
*
DO.REMOVE.PUNCTUATION: 
      DEBUG6
      CRT 'GOSUB DO.REMOVE.PUNCTUATION '
      END
      X.CHARACTERS.TO.REMOVE = '"':"'":',.;`'
      CONVERT X.CHARACTERS.TO.REMOVE TO '' IN DATA.FIELD
      RETURN



*
* MAKE ALL RECORDS FIXED LENGTH
*
DO.RECORD.LENGTH: 
      DEBUG6
      CRT 'GOSUB DO.RECORD.LENGTH '
      END
      RECORD.FMT = DLMAIN.RECORD.LENGTH:'L'
      NUM.DETAIL.LINES = COUNT(DETAIL.LINES,@FM) + 1
      FOR LINE.CTR=1 TO NUM.DETAIL.LINES
         DETAIL.LINES<LINE.CTR> = (DETAIL.LINES<LINE.CTR>:SPACE(DLMAIN.RECORD.LENGTH))[1,DLMAIN.RECORD.LENGTH]
      NEXT LINE.CTR
      RETURN

*
*
* BUILD COMMA.QUOTE DETAIL LINES
*
BUILD.COMMA.QUOTE.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside BUILD.COMMA.QUOTE.DETAIL.LINES'
      END
      X.CQ.SEP = CHAR(251)
      XL.BUILD.DATA.FIELD.CTR = ''
      FOR FIELD.CTR = 1 TO DL.OUTR.NUM.OUT.FIELDS(OUTPUT.REC.CTR)
         BUILD.DATA.VALUE.CTR = 0
         GOSUB LOAD.FIELD.VALUES
         IF OUT.TYPE # 'SUP' THEN
            GOSUB GET.DATA.FIELD
            IF BY.EXP.FIELD # '' AND PART.OF.ASSOC.VALUE THEN
               GOSUB CHECK.BY.EXP
               IF BY.EXP.OKAY THEN
                  IF NUM.SUBVALUES.VALUE = '' THEN
                     BUILD.DATA.VALUE.CTR = 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.COMMA.QUOTE.DATA.SUBVALUE
                  END ELSE
                     DATA.VALUE = DATA.SUBVALUE
                     GOSUB BUILD.COMMA.QUOTE.DATA.VALUE
                  END
               END
            END ELSE
               NUM.DATA.VALUES = COUNT(DATA.FIELD,@VM) + 1
               DONE.VALUES = FALSE
               BUILD.DATA.VALUE.CTR = 0
               IF NUM.VALUES.VALUE = 'LAST' THEN
                  X.START.VALUE = NUM.DATA.VALUES
                  IF X.START.VALUE LT 1 THEN
                     X.START.VALUE = 1
                  END
               END ELSE
                  X.START.VALUE = 1
               END
               FOR VALUE.CTR = X.START.VALUE TO NUM.DATA.VALUES UNTIL DONE.VALUES
                  DATA.VALUE = DATA.FIELD<1,VALUE.CTR>
                  GOSUB BUILD.COMMA.QUOTE.DATA.VALUE
                  IF USE.DATA.VALUE THEN
                     IF NUM.VALUES.VALUE # 'ALL' THEN
                        IF NUM.VALUES.VALUE = 'LAST' THEN
                           DONE.VALUES = TRUE
                        END ELSE
                           IF BUILD.DATA.VALUE.CTR >= NUM.VALUES.VALUE THEN
                              DONE.VALUES = TRUE
                           END
                        END
                     END
                  END
               NEXT VALUE.CTR
               IF (NUM.VALUES.VALUE NE 'ALL') AND (NUM.VALUES.VALUE NE 'LAST') THEN
                  X.START = BUILD.DATA.VALUE.CTR + 1
                  FOR VALUE.CTR = X.START TO NUM.VALUES.VALUE
                     DATA.SUBVALUE = ''
                     BUILD.DATA.VALUE.CTR += 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.COMMA.QUOTE.DATA.SUBVALUE
                  NEXT VALUE.CTR
               END
            END
         END
      NEXT FIELD.CTR
      DETAIL.LINES = CHANGE(DETAIL.LINES,X.CQ.SEP,DLMAIN.COMMA)
      RETURN


BUILD.COMMA.QUOTE.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.COMMA.QUOTE.DATA.VALUE '
      CRT 'DATA.VALUE ':DATA.VALUE
      END
      NUM.DATA.SUBVALUES = COUNT(DATA.VALUE,@SM) + 1
      BUILD.DATA.SUBVALUE.CTR = 0
      DONE.SUBVALUES = FALSE
      USE.DATA.VALUE = FALSE
      IF NUM.SUBVALUES.VALUE = 'LAST' THEN
         X.START.SUBVALUE = NUM.DATA.SUBVALUES
         IF X.START.SUBVALUE LT 1 THEN
            X.START.SUBVALUE = 1
         END
      END ELSE
         X.START.SUBVALUE = 1
      END
      FOR SUBVALUE.CTR=X.START.SUBVALUE TO NUM.DATA.SUBVALUES UNTIL DONE.SUBVALUES
         USE.DATA.SUBVALUE = TRUE
         IF PART.OF.ASSOC.VALUE AND WHEN.FIELD.LIST # '' THEN
            USE.DATA.SUBVALUE = WHEN.RESULT.LIST<VALUE.CTR,SUBVALUE.CTR>
         END
         IF USE.DATA.SUBVALUE THEN
            IF USE.DATA.VALUE THEN
               X.BUILDING.DATA.VALUE = FALSE
               X.BUILDING.DATA.SUBVALUE = TRUE
            END ELSE
               BUILD.DATA.VALUE.CTR += 1
               X.BUILDING.DATA.VALUE = TRUE
               X.BUILDING.DATA.SUBVALUE = FALSE
            END
            USE.DATA.VALUE = TRUE
            DATA.SUBVALUE = DATA.VALUE<1,1,SUBVALUE.CTR>
            BUILD.DATA.SUBVALUE.CTR += 1
            GOSUB BUILD.COMMA.QUOTE.DATA.SUBVALUE
            IF (NUM.SUBVALUES.VALUE NE 'ALL') THEN
               IF NUM.SUBVALUES.VALUE = 'LAST' THEN
                  DONE.SUBVALUES = TRUE
               END ELSE
                  IF BUILD.DATA.SUBVALUE.CTR >= NUM.SUBVALUES.VALUE THEN
                     DONE.SUBVALUES = TRUE
                  END
               END
            END
         END
      NEXT SUBVALUE.CTR
      IF (NUM.SUBVALUES.VALUE NE 'ALL') AND (NUM.SUBVALUES.VALUE NE 'LAST') THEN
         X.START = BUILD.DATA.SUBVALUE.CTR + 1
         FOR SUBVALUE.CTR = X.START TO NUM.SUBVALUES.VALUE
            DATA.SUBVALUE = ''
            BUILD.DATA.SUBVALUE.CTR += 1
            X.BUILDING.DATA.VALUE = FALSE
            X.BUILDING.DATA.SUBVALUE = TRUE
            GOSUB BUILD.COMMA.QUOTE.DATA.SUBVALUE
         NEXT SUBVALUE.CTR
      END
      RETURN


*
*
* BUILD COMMA.QUOTE DATA.SUBVALUE
*
BUILD.COMMA.QUOTE.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.COMMA.QUOTE.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      GOSUB CONV.DATA.SUBVALUE
      IF FMT.VALUE THEN
         GOSUB FMT.DATA.SUBVALUE
      END
      GOSUB LENGTH.DATA.SUBVALUE

      IF NUMERIC.FLAG AND DLMAIN.FORMAT = 'COMMA' THEN
         W.DETAIL.ITEM = DATA.SUBVALUE
      END ELSE
         DATA.SUBVALUE = CHANGE(DATA.SUBVALUE,DLMAIN.QUOTE,'')
         W.DETAIL.ITEM = DLMAIN.QUOTE:DATA.SUBVALUE:DLMAIN.QUOTE
      END

      BUILD.DATA.FIELD.CTR = XL.BUILD.DATA.FIELD.CTR<1,LINE.VALUE>
      BUILD.DATA.LINE.ADJUST = 0
      BEGIN CASE
         CASE MV.ORIENTATION.VALUE = 'VERTICAL'
            IF BUILD.DATA.VALUE.CTR LT 2 THEN
               BUILD.DATA.FIELD.CTR += 1
            END
            BUILD.DATA.LINE.ADJUST = BUILD.DATA.VALUE.CTR - 1
         CASE (X.BUILDING.DATA.VALUE) AND (BUILD.DATA.VALUE.CTR GT 1) AND (VALUE.SEPARATOR.SET.VALUE)
            NULL
         CASE (X.BUILDING.DATA.SUBVALUE) AND (BUILD.DATA.SUBVALUE.CTR GT 1) AND (SUBVALUE.SEPARATOR.SET.VALUE)
            NULL
         CASE 1
            BUILD.DATA.FIELD.CTR += 1
      END CASE
      XL.BUILD.DATA.FIELD.CTR<1,LINE.VALUE> = BUILD.DATA.FIELD.CTR

      BUILD.DATA.LINE.VALUE = LINE.VALUE + BUILD.DATA.LINE.ADJUST
      OLD.DETAIL.LINE = DETAIL.LINES<BUILD.DATA.LINE.VALUE>
      X.NUM.OLD.FIELD = DCOUNT(OLD.DETAIL.LINE,X.CQ.SEP)
      IF X.NUM.OLD.FIELD LT (BUILD.DATA.FIELD.CTR) AND (BUILD.DATA.FIELD.CTR GT 1) THEN
         LOOP
            OLD.DETAIL.LINE := X.CQ.SEP
         UNTIL (DCOUNT(OLD.DETAIL.LINE,X.CQ.SEP) GE (BUILD.DATA.FIELD.CTR))
         REPEAT
      END
      OLD.DETAIL.ITEM = FIELD(OLD.DETAIL.LINE,X.CQ.SEP,BUILD.DATA.FIELD.CTR,1)
      X.NEED.CHANGE = @FALSE
      BEGIN CASE
         CASE (X.BUILDING.DATA.SUBVALUE) AND (BUILD.DATA.SUBVALUE.CTR GT 1) AND (SUBVALUE.SEPARATOR.SET.VALUE)
            X.DELIM = SUBVALUE.SEPARATOR.VALUE
            X.NEED.CHANGE = @TRUE
         CASE (X.BUILDING.DATA.VALUE) AND (BUILD.DATA.VALUE.CTR GT 1) AND (VALUE.SEPARATOR.SET.VALUE)
            X.DELIM = VALUE.SEPARATOR.VALUE
            X.NEED.CHANGE = @TRUE
         CASE 1
            X.DELIM = ''
      END CASE
      W.DETAIL.ITEM = OLD.DETAIL.ITEM:X.DELIM:W.DETAIL.ITEM
      IF X.NEED.CHANGE THEN
         X.TEMP = W.DETAIL.ITEM[1+LEN(DLMAIN.QUOTE),LEN(W.DETAIL.ITEM)]
         X.TEMP = CHANGE(X.TEMP,DLMAIN.QUOTE:X.DELIM:DLMAIN.QUOTE,X.DELIM)
         W.DETAIL.ITEM = W.DETAIL.ITEM[1,LEN(DLMAIN.QUOTE)]:X.TEMP
      END
      W.DETAIL.LINE = OLD.DETAIL.LINE
      NUM.EXISTING = DCOUNT(W.DETAIL.LINE,X.CQ.SEP)
      BEGIN CASE
         CASE BUILD.DATA.FIELD.CTR EQ 1
            IF NUM.EXISTING GT 1 THEN
               W.DETAIL.LINE = W.DETAIL.ITEM:X.CQ.SEP:FIELD(W.DETAIL.LINE,X.CQ.SEP,2,NUM.EXISTING)
            END ELSE
               W.DETAIL.LINE = W.DETAIL.ITEM
            END
         CASE (BUILD.DATA.FIELD.CTR EQ NUM.EXISTING)
            W.DETAIL.LINE = FIELD(W.DETAIL.LINE,X.CQ.SEP,1,BUILD.DATA.FIELD.CTR-1):X.CQ.SEP:W.DETAIL.ITEM
         CASE 1
            X.FIRST.PART = FIELD(W.DETAIL.LINE,X.CQ.SEP,1,BUILD.DATA.FIELD.CTR-1)
            X.SECOND.PART = FIELD(W.DETAIL.LINE,X.CQ.SEP,BUILD.DATA.FIELD.CTR,NUM.EXISTING)
            W.DETAIL.LINE = X.FIRST.PART:X.CQ.SEP:W.DETAIL.ITEM:X.CQ.SEP:X.SECOND.PART
      END CASE
      DETAIL.LINES<BUILD.DATA.LINE.VALUE> = W.DETAIL.LINE
      RETURN


BUILD.HTML.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside BUILD.HTML.DETAIL.LINES'
      END
      HTML.ROW.VALUE = DL.OUTR.HTML.ROW.LIST(OUTPUT.REC.CTR)
      X.LIT.DICT.EVAL = HTML.ROW.VALUE
      GOSUB GET.LIT.DICT.EVAL
      IF X.LIT.DICT.EVAL.VALUE = '' THEN
         DETAIL.LINES<-1> = '<tr>'
      END ELSE
         DETAIL.LINES<-1> = '<tr ':X.LIT.DICT.EVAL.VALUE:'>'
      END
      IF OUTPUT.REC.CTR EQ DLMAIN.HEADING.OUT.REC THEN
         X.CELL.TAG = 'th'
      END ELSE
         X.CELL.TAG = 'td'
      END
      XL.BUILD.DATA.FIELD.CTR = ''
      FOR FIELD.CTR = 1 TO DL.OUTR.NUM.OUT.FIELDS(OUTPUT.REC.CTR)
         BUILD.DATA.VALUE.CTR = 0
         GOSUB LOAD.FIELD.VALUES
         IF OUT.TYPE # 'SUP' THEN
            X.LIT.DICT.EVAL = HTML.CELL.VALUE
            GOSUB GET.LIT.DICT.EVAL
            IF X.LIT.DICT.EVAL.VALUE = '' THEN
               DETAIL.LINES := '<':X.CELL.TAG:'>'
            END ELSE
               DETAIL.LINES := '<':X.CELL.TAG:' ':X.LIT.DICT.EVAL.VALUE:'>'
            END
            X.LIT.DICT.EVAL = HTML.START.VALUE
            GOSUB GET.LIT.DICT.EVAL
            DETAIL.LINES := X.LIT.DICT.EVAL.VALUE
            GOSUB GET.DATA.FIELD
            IF BY.EXP.FIELD # '' AND PART.OF.ASSOC.VALUE THEN
               GOSUB CHECK.BY.EXP
               IF BY.EXP.OKAY THEN
                  BUILD.DATA.VALUE.CTR = 1
                  BUILD.DATA.SUBVALUE.CTR = 1
                  X.BUILDING.DATA.VALUE = TRUE
                  X.BUILDING.DATA.SUBVALUE = FALSE
                  GOSUB BUILD.HTML.DATA.SUBVALUE
               END
            END ELSE
               NUM.DATA.VALUES = COUNT(DATA.FIELD,@VM) + 1
               DONE.VALUES = FALSE
               BUILD.DATA.VALUE.CTR = 0
               IF NUM.VALUES.VALUE = 'LAST' THEN
                  X.START.VALUE = NUM.DATA.VALUES
                  IF X.START.VALUE LT 1 THEN
                     X.START.VALUE = 1
                  END
               END ELSE
                  X.START.VALUE = 1
               END
               FOR VALUE.CTR = X.START.VALUE TO NUM.DATA.VALUES UNTIL DONE.VALUES
                  DATA.VALUE = DATA.FIELD<1,VALUE.CTR>
                  GOSUB BUILD.HTML.DATA.VALUE
                  IF USE.DATA.VALUE THEN
                     IF NUM.VALUES.VALUE # 'ALL' THEN
                        IF NUM.VALUES.VALUE = 'LAST' THEN
                           DONE.VALUES = TRUE
                        END ELSE
                           IF BUILD.DATA.VALUE.CTR >= NUM.VALUES.VALUE THEN
                              DONE.VALUES = TRUE
                           END
                        END
                     END
                  END
               NEXT VALUE.CTR
               IF (NUM.VALUES.VALUE NE 'ALL') AND (NUM.VALUES.VALUE NE 'LAST') THEN
                  X.START = BUILD.DATA.VALUE.CTR + 1
                  FOR VALUE.CTR = X.START TO NUM.VALUES.VALUE
                     DATA.SUBVALUE = ''
                     BUILD.DATA.VALUE.CTR += 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.HTML.DATA.SUBVALUE
                  NEXT VALUE.CTR
               END
            END
            X.LIT.DICT.EVAL = HTML.END.VALUE
            GOSUB GET.LIT.DICT.EVAL
            DETAIL.LINES := X.LIT.DICT.EVAL.VALUE
            DETAIL.LINES := '</':X.CELL.TAG:'>'
         END
      NEXT FIELD.CTR
      DETAIL.LINES<-1> = '</tr>'
      RETURN


BUILD.HTML.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.HTML.DATA.VALUE '
      CRT 'DATA.VALUE: ':DATA.VALUE
      END
      NUM.DATA.SUBVALUES = COUNT(DATA.VALUE,@SM) + 1
      BUILD.DATA.SUBVALUE.CTR = 0
      DONE.SUBVALUES = FALSE
      USE.DATA.VALUE = FALSE
      IF NUM.SUBVALUES.VALUE = 'LAST' THEN
         X.START.SUBVALUE = NUM.DATA.SUBVALUES
         IF X.START.SUBVALUE LT 1 THEN
            X.START.SUBVALUE = 1
         END
      END ELSE
         X.START.SUBVALUE = 1
      END
      FOR SUBVALUE.CTR=X.START.SUBVALUE TO NUM.DATA.SUBVALUES UNTIL DONE.SUBVALUES
         USE.DATA.SUBVALUE = TRUE
         IF PART.OF.ASSOC.VALUE AND WHEN.FIELD.LIST # '' THEN
            USE.DATA.SUBVALUE = WHEN.RESULT.LIST<VALUE.CTR,SUBVALUE.CTR>
         END
         IF USE.DATA.SUBVALUE THEN
            IF USE.DATA.VALUE THEN
               X.BUILDING.DATA.VALUE = FALSE
               X.BUILDING.DATA.SUBVALUE = TRUE
            END ELSE
               BUILD.DATA.VALUE.CTR += 1
               X.BUILDING.DATA.VALUE = TRUE
               X.BUILDING.DATA.SUBVALUE = FALSE
            END
            USE.DATA.VALUE = TRUE
            DATA.SUBVALUE = DATA.VALUE<1,1,SUBVALUE.CTR>
            BUILD.DATA.SUBVALUE.CTR += 1
            GOSUB BUILD.HTML.DATA.SUBVALUE
            IF (NUM.SUBVALUES.VALUE NE 'ALL') THEN
               IF NUM.SUBVALUES.VALUE = 'LAST' THEN
                  DONE.SUBVALUES = TRUE
               END ELSE
                  IF BUILD.DATA.SUBVALUE.CTR >= NUM.SUBVALUES.VALUE THEN
                     DONE.SUBVALUES = TRUE
                  END
               END
            END
         END
      NEXT SUBVALUE.CTR
      IF (NUM.SUBVALUES.VALUE NE 'ALL') AND (NUM.SUBVALUES.VALUE NE 'LAST') THEN
         X.START = BUILD.DATA.SUBVALUE.CTR + 1
         FOR SUBVALUE.CTR = X.START TO NUM.SUBVALUES.VALUE
            DATA.SUBVALUE = ''
            BUILD.DATA.SUBVALUE.CTR += 1
            X.BUILDING.DATA.VALUE = FALSE
            X.BUILDING.DATA.SUBVALUE = TRUE
            GOSUB BUILD.HTML.DATA.SUBVALUE
         NEXT SUBVALUE.CTR
      END
      RETURN
*
*
* BUILD HTML DATA.SUBVALUE
*
BUILD.HTML.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.HTML.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      GOSUB CONV.DATA.SUBVALUE
      IF FMT.VALUE THEN
         GOSUB FMT.DATA.SUBVALUE
      END
      GOSUB LENGTH.DATA.SUBVALUE

      BEGIN CASE
         CASE (MV.ORIENTATION.VALUE = 'VERTICAL') AND ((BUILD.DATA.VALUE.CTR GT 1) OR (BUILD.DATA.SUBVALUE.CTR GT 1))
            DETAIL.LINES := '<br/>'
         CASE (SUBVALUE.SEPARATOR.SET.VALUE) AND (BUILD.DATA.SUBVALUE.CTR GT 1)
            DETAIL.LINES := SUBVALUE.SEPARATOR.VALUE
         CASE (VALUE.SEPARATOR.SET.VALUE) AND (BUILD.DATA.VALUE.CTR GT 1)
            DETAIL.LINES := VALUE.SEPARATOR.VALUE
         CASE (BUILD.DATA.VALUE.CTR GT 1) OR (BUILD.DATA.SUBVALUE.CTR GT 1)
            DETAIL.LINES := '&nbsp;'
         CASE 1
      END CASE
      IF DATA.SUBVALUE = '' THEN
         DETAIL.LINES := '&nbsp;'
      END ELSE
         DETAIL.LINES := DATA.SUBVALUE
      END
      RETURN


BUILD.XML.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside BUILD.XML.DETAIL.LINES'
      END
      XML.ATTRIBUTE.TEXT = ''
      NUM.FIELDS = 0
      X.HAVE.XML.GROUP = FALSE
      X.HAVE.XML.ASSOC = FALSE
      X.LAST.GROUP.NAME = ''
      X.LAST.ASSOC.NAME = ''
      FOR FIELD.CTR=1 TO DL.OUTR.NUM.OUT.FIELDS(OUTPUT.REC.CTR)
         BUILD.DATA.VALUE.CTR = 0
         GOSUB LOAD.FIELD.VALUES
         IF OUT.TYPE # 'SUP' THEN
            IF SM.VALUE = 'M' THEN
               IF X.HAVE.XML.GROUP THEN
* HAVE XML GROUP
                  IF X.LAST.GROUP.NAME = DL.OUTR.XML.GROUP.NAME THEN
                     IF X.HAVE.XML.ASSOC THEN
                        IF X.LAST.ASSOC.NAME = DL.OUTR.XML.ASSOC.NAME THEN
                           NULL
                        END ELSE
                           GOSUB BUILD.XML.ASSOC.END
                           IF DL.OUTR.XML.ASSOC.NAME NE '' THEN
                              GOSUB BUILD.XML.ASSOC.START
                           END
                        END
                     END ELSE
                        IF X.HAVE.XML.ASSOC THEN
                           GOSUB BUILD.XML.ASSOC.END
                        END
                        GOSUB BUILD.XML.GROUP.END
                        IF DL.OUTR.XML.GROUP.NAME NE '' THEN
                           GOSUB BUILD.XML.GROUP.START
                        END
                        IF DL.OUTR.XML.ASSOC.NAME NE '' THEN
                           GOSUB BUILD.XML.ASSOC.START
                        END
                     END
                  END
               END ELSE
* DO NOT HAVE XML GROUP
                  IF X.HAVE.XML.ASSOC THEN
                     IF X.LAST.ASSOC.NAME = DL.OUTR.XML.ASSOC.NAME THEN
                        NULL
                     END ELSE
                        GOSUB BUILD.XML.ASSOC.END
                        IF DL.OUTR.XML.GROUP.NAME NE '' THEN
                           GOSUB BUILD.XML.GROUP.START
                        END
                        IF DL.OUTR.XML.ASSOC.NAME NE '' THEN
                           GOSUB BUILD.XML.ASSOC.START
                        END
                     END
                  END ELSE
                     IF DL.OUTR.XML.GROUP.NAME NE '' THEN
                        GOSUB BUILD.XML.GROUP.START
                     END
                     IF DL.OUTR.XML.ASSOC.NAME NE '' THEN
                        GOSUB BUILD.XML.ASSOC.START
                     END
                  END
               END
            END ELSE
               IF X.HAVE.XML.ASSOC THEN
                  GOSUB BUILD.XML.ASSOC.END
               END
               IF X.HAVE.XML.GROUP THEN
                  GOSUB BUILD.XML.GROUP.END
               END
            END
            GOSUB GET.DATA.FIELD
            IF BY.EXP.FIELD # '' AND PART.OF.ASSOC.VALUE THEN
               GOSUB CHECK.BY.EXP
               IF BY.EXP.OKAY THEN
                  IF NUM.SUBVALUES.VALUE = '' THEN
                     BUILD.DATA.VALUE.CTR = 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.XML.DATA.SUBVALUE
                  END ELSE
                     DATA.VALUE = DATA.SUBVALUE
                     GOSUB BUILD.XML.DATA.VALUE
                  END
               END
            END ELSE
               NUM.DATA.VALUES = COUNT(DATA.FIELD,@VM) + 1
               DONE.VALUES = FALSE
               BUILD.DATA.VALUE.CTR = 0
               IF NUM.VALUES.VALUE = 'LAST' THEN
                  X.START.VALUE = NUM.DATA.VALUES
                  IF X.START.VALUE LT 1 THEN
                     X.START.VALUE = 1
                  END
               END ELSE
                  X.START.VALUE = 1
               END
               FOR VALUE.CTR = X.START.VALUE TO NUM.DATA.VALUES UNTIL DONE.VALUES
                  DATA.VALUE = DATA.FIELD<1,VALUE.CTR>
                  GOSUB BUILD.XML.DATA.VALUE
                  IF USE.DATA.VALUE THEN
                     IF NUM.VALUES.VALUE = 'LAST' THEN
                        DONE.VALUES = TRUE
                     END ELSE
                        IF BUILD.DATA.VALUE.CTR >= NUM.VALUES.VALUE THEN
                           DONE.VALUES = TRUE
                        END
                     END
                  END
               NEXT VALUE.CTR
               IF (NUM.VALUES.VALUE NE 'ALL') AND (NUM.VALUES.VALUE NE 'LAST') THEN
                  X.START = BUILD.DATA.VALUE.CTR + 1
                  FOR VALUE.CTR = X.START TO NUM.VALUES.VALUE
                     DATA.SUBVALUE = ''
                     BUILD.DATA.VALUE.CTR += 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.XML.DATA.SUBVALUE
                  NEXT VALUE.CTR
               END
            END
         END
      NEXT FIELD.CTR
      IF X.HAVE.XML.ASSOC THEN
         GOSUB BUILD.XML.ASSOC.END
      END
      IF X.HAVE.XML.GROUP THEN
         GOSUB BUILD.XML.GROUP.END
      END
      RETURN


BUILD.XML.GROUP.START: 
      DEBUG6
      CRT 'GOSUB BUILD.XML.GROUP.START '
      CRT 'DL.OUTR.XML.GROUP.NAME: ':DL.OUTR.XML.GROUP.NAME
      CRT 'DL.OUTR.XML.GROUP.ATTRIBUTE: ':DL.OUTR.XML.GROUP.ATTRIBUTE
      END
      IF NOT(DL.OUTR.XML.GROUP.NAME) THEN
         X.HAVE.XML.GROUP = FALSE
         RETURN
      END
      X.HAVE.XML.GROUP = TRUE
      X.LAST.GROUP.NAME = DL.OUTR.XML.GROUP.NAME
      IF DL.OUTR.XML.GROUP.ATTRIBUTE THEN
         DETAIL.LINES := @FM:SPACE(DLMAIN.FIELD.GAP):'<':X.LAST.GROUP.NAME:' ':DL.OUTR.XML.GROUP.ATTRIBUTE:'>'
      END ELSE
         DETAIL.LINES := @FM:SPACE(DLMAIN.FIELD.GAP):'<':X.LAST.GROUP.NAME:'>'
      END
      RETURN


BUILD.XML.GROUP.END: 
      DEBUG6
      CRT 'GOSUB BUILD.XML.GROUP.END '
      END
      IF NOT(X.HAVE.XML.GROUP) THEN
         RETURN
      END
      DETAIL.LINES := @FM:SPACE(DLMAIN.FIELD.GAP):'</':X.LAST.GROUP.NAME:'>'
      X.HAVE.XML.GROUP = FALSE
      X.LAST.GROUP.NAME = ''
      RETURN


BUILD.XML.ASSOC.START: 
      DEBUG6
      CRT 'GOSUB BUILD.XML.ASSOC.START '
      CRT 'DL.OUTR.XML.ASSOC.NAME: ':DL.OUTR.XML.ASSOC.NAME
      END
      X.HAVE.XML.ASSOC = TRUE
      X.LAST.ASSOC.NAME = DL.OUTR.XML.ASSOC.NAME
      XL.ASSOC.FIELD = ''
      XL.ASSOC.VALUE = ''
      XL.ATTRIBUTE.VALUE = ''
      XL.SUBASSOC.FIELD = ''
      X.XML.NUM.VALUES.VALUE = NUM.VALUES.VALUE
      X.XML.NUM.ASSOC.COLLECTED = 0
      RETURN


BUILD.XML.ASSOC.END: 
      DEBUG6
      CRT 'GOSUB BUILD.XML.ASSOC.END '
      END
      NUM.XL.ASSOC.FIELD = COUNT(XL.ASSOC.FIELD,@VM) + (XL.ASSOC.FIELD#'')
      FOR WHICH.VALUE = 1 TO X.XML.NUM.ASSOC.COLLECTED
         X.ATTRIBUTE.VALUE = XL.ATTRIBUTE.VALUE<1,WHICH.VALUE>
         X.GAP = DLMAIN.FIELD.GAP
         IF X.HAVE.XML.GROUP THEN
            X.GAP += DLMAIN.FIELD.GAP
         END
         DETAIL.LINES := @FM:SPACE(X.GAP):'<':X.LAST.ASSOC.NAME
         IF X.ATTRIBUTE.VALUE NE '' THEN
            DETAIL.LINES := X.ATTRIBUTE.VALUE
         END
         DETAIL.LINES := '>'
         FOR WHICH.XL.ASSOC.FIELD = 1 TO NUM.XL.ASSOC.FIELD
            X.ASSOC.FIELD = XL.ASSOC.FIELD<1,WHICH.XL.ASSOC.FIELD>
            X.SUBASSOC.FIELD = XL.SUBASSOC.FIELD<WHICH.XL.ASSOC.FIELD,WHICH.VALUE>
            X.GAP = 2 * DLMAIN.FIELD.GAP
            IF X.HAVE.XML.GROUP THEN
               X.GAP += DLMAIN.FIELD.GAP
            END
            IF X.SUBASSOC.FIELD = '' THEN
               Y.GAP = X.GAP
            END ELSE
               DETAIL.LINES := @FM:SPACE(X.GAP):'<':X.SUBASSOC.FIELD:'>'
               Y.GAP = X.GAP + DLMAIN.FIELD.GAP
            END
            X.VALUE = XL.ASSOC.VALUE<WHICH.XL.ASSOC.FIELD,WHICH.VALUE>
            NUM.X.VALUE = COUNT(X.VALUE,@SM) + 1
            FOR WHICH.X.VALUE = 1 TO NUM.X.VALUE
               DETAIL.LINES := @FM:SPACE(Y.GAP):'<':X.ASSOC.FIELD:'>'
               DETAIL.LINES := X.VALUE<1,1,WHICH.X.VALUE>
               DETAIL.LINES := '</':X.ASSOC.FIELD:'>'
            NEXT WHICH.X.VALUE
            IF X.SUBASSOC.FIELD # '' THEN
               DETAIL.LINES := @FM:SPACE(X.GAP):'</':X.SUBASSOC.FIELD:'>'
            END
         NEXT WHICH.XL.ASSOC.FIELD
         X.GAP = DLMAIN.FIELD.GAP
         IF X.HAVE.XML.GROUP THEN
            X.GAP += DLMAIN.FIELD.GAP
         END
         DETAIL.LINES := @FM:SPACE(X.GAP):'</':X.LAST.ASSOC.NAME:'>'
      NEXT WHICH.VALUE
      X.HAVE.XML.ASSOC = FALSE
      RETURN


BUILD.XML.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.XML.DATA.VALUE '
      CRT 'DATA.VALUE: ':DATA.VALUE
      END
      NUM.DATA.SUBVALUES = COUNT(DATA.VALUE,@SM) + 1
      BUILD.DATA.SUBVALUE.CTR = 0
      DONE.SUBVALUES = FALSE
      USE.DATA.VALUE = FALSE
      IF NUM.SUBVALUES.VALUE = 'LAST' THEN
         X.START.SUBVALUE = NUM.DATA.SUBVALUES
         IF X.START.SUBVALUE LT 1 THEN
            X.START.SUBVALUE = 1
         END
      END ELSE
         X.START.SUBVALUE = 1
      END
      FOR SUBVALUE.CTR=X.START.SUBVALUE TO NUM.DATA.SUBVALUES UNTIL DONE.SUBVALUES
         USE.DATA.SUBVALUE = TRUE
         IF PART.OF.ASSOC.VALUE AND WHEN.FIELD.LIST # '' THEN
            USE.DATA.SUBVALUE = WHEN.RESULT.LIST<VALUE.CTR,SUBVALUE.CTR>
         END
         IF USE.DATA.SUBVALUE THEN
            IF USE.DATA.VALUE THEN
               X.BUILDING.DATA.VALUE = FALSE
               X.BUILDING.DATA.SUBVALUE = TRUE
            END ELSE
               BUILD.DATA.VALUE.CTR += 1
               X.BUILDING.DATA.VALUE = TRUE
               X.BUILDING.DATA.SUBVALUE = FALSE
            END
            USE.DATA.VALUE = TRUE
            DATA.SUBVALUE = DATA.VALUE<1,1,SUBVALUE.CTR>
            BUILD.DATA.SUBVALUE.CTR += 1
            GOSUB BUILD.XML.DATA.SUBVALUE
            IF (NUM.SUBVALUES.VALUE NE 'ALL') THEN
               IF NUM.SUBVALUES.VALUE = 'LAST' THEN
                  DONE.SUBVALUES = TRUE
               END ELSE
                  IF BUILD.DATA.SUBVALUE.CTR >= NUM.SUBVALUES.VALUE THEN
                     DONE.SUBVALUES = TRUE
                  END
               END
            END
         END
      NEXT SUBVALUE.CTR
      IF (NUM.SUBVALUES.VALUE NE 'ALL') AND (NUM.SUBVALUES.VALUE NE 'LAST') THEN
         X.START = BUILD.DATA.SUBVALUE.CTR + 1
         FOR SUBVALUE.CTR = X.START TO NUM.SUBVALUES.VALUE
            DATA.SUBVALUE = ''
            BUILD.DATA.SUBVALUE.CTR += 1
            X.BUILDING.DATA.VALUE = FALSE
            X.BUILDING.DATA.SUBVALUE = TRUE
            GOSUB BUILD.XML.DATA.SUBVALUE
         NEXT SUBVALUE.CTR
      END
      RETURN
*
*
* BUILD XML DATA.SUBVALUE
*
BUILD.XML.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.XML.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      GOSUB CONV.DATA.SUBVALUE
      IF FMT.VALUE THEN
         GOSUB FMT.DATA.SUBVALUE
      END
      GOSUB LENGTH.DATA.SUBVALUE
      IF NOT(DL.OUTR.XML.ALLOW.CHARACTERS) THEN
         GOSUB FORMAT.XML.DATA.SUBVALUE
      END

      IF X.HAVE.XML.ASSOC THEN
         IF (DL.OUTR.XML.ATTRIBUTE EQ '') OR NOT(DL.OUTR.XML.ATTRIBUTE) THEN
            LOCATE DL.OUTR.XML.NAME IN XL.ASSOC.FIELD<1,1> SETTING X.POS ELSE
               X.POS = COUNT(XL.ASSOC.FIELD,@VM) + (XL.ASSOC.FIELD#'') + 1
               XL.ASSOC.FIELD<1,X.POS> = DL.OUTR.XML.NAME
            END
            Y.POS = BUILD.DATA.VALUE.CTR
            BEGIN CASE
               CASE (X.BUILDING.DATA.SUBVALUE) AND (BUILD.DATA.SUBVALUE.CTR GT 1) AND (SUBVALUE.SEPARATOR.SET.VALUE)
                  X.TEMP = XL.ASSOC.VALUE<X.POS,Y.POS>
                  X.TEMP := SUBVALUE.SEPARATOR.VALUE:DATA.SUBVALUE
                  XL.ASSOC.VALUE<X.POS,Y.POS> = X.TEMP
               CASE (X.BUILDING.DATA.SUBVALUE) AND (BUILD.DATA.SUBVALUE.CTR GT 1)
                  X.TEMP = XL.ASSOC.VALUE<X.POS,Y.POS>
                  X.TEMP := @SM:DATA.SUBVALUE
                  XL.ASSOC.VALUE<X.POS,Y.POS> = X.TEMP
                  XL.SUBASSOC.FIELD<X.POS,Y.POS> = DL.OUTR.XML.SUBASSOC.NAME
               CASE 1
                  XL.ASSOC.VALUE<X.POS,Y.POS> = DATA.SUBVALUE
            END CASE
         END ELSE
            X.TEMP = DATA.SUBVALUE
            CONVERT '"<>' TO '' IN X.TEMP
            XL.ATTRIBUTE.VALUE<1,BUILD.DATA.VALUE.CTR> := ' ':DL.OUTR.XML.NAME:'="':X.TEMP:'"'
         END
         X.XML.NUM.ASSOC.COLLECTED = BUILD.DATA.VALUE.CTR
      END ELSE
         BEGIN CASE
            CASE OUTPUT.REC.CTR = DLMAIN.HEADING.OUT.REC
               IF DETAIL.LINES = '' THEN
                  DETAIL.LINES = DATA.SUBVALUE
               END ELSE
                  DETAIL.LINES := @FM:DATA.SUBVALUE
               END
            CASE DL.OUTR.XML.ATTRIBUTE = TRUE
               CONVERT '"<>' TO '' IN DATA.SUBVALUE
               XML.ATTRIBUTE.TEXT := ' ':DL.OUTR.XML.NAME:'="':DATA.SUBVALUE:'"'
            CASE 1
               X.GAP = DLMAIN.FIELD.GAP
               IF X.HAVE.XML.GROUP THEN
                  X.GAP += DLMAIN.FIELD.GAP
               END
               DETAIL.LINES := @FM:SPACE(X.GAP):'<':DL.OUTR.XML.NAME:'>'
               DETAIL.LINES := DATA.SUBVALUE
               DETAIL.LINES := '</':DL.OUTR.XML.NAME:'>'
         END CASE
      END
      RETURN


FORMAT.XML.DATA.SUBVALUE: 
      FOR WHICH.DLMAIN.XML.ILLEGAL.CHARS = 1 TO DLMAIN.NUM.XML.ILLEGAL.CHARS
         X.XML.ILLEGAL.CHARS = DLMAIN.XML.ILLEGAL.CHARS<1,WHICH.DLMAIN.XML.ILLEGAL.CHARS>
         X.XML.REPLACEMENT = DLMAIN.XML.REPLACEMENT<1,WHICH.DLMAIN.XML.ILLEGAL.CHARS>
         DATA.SUBVALUE = CHANGE(DATA.SUBVALUE,X.XML.ILLEGAL.CHARS,X.XML.REPLACEMENT)
      NEXT WHICH.DLMAIN.XML.ILLEGAL.CHARS
      RETURN


LOAD.FIELD.VALUES: 
      DEBUG6
      CRT 'GOSUB LOAD.FIELD.VALUES '
      END
      OUT.FIELD.NAME = DL.OUTR.FIELD.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      OUT.TYPE = DL.OUTR.TYPE.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      OUT.PREFIX = DL.OUTR.PREFIX.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      LINE.VALUE = DL.OUTR.LINE.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      LENGTH.VALUE = DL.OUTR.LENGTH.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      BEG.COL.VALUE = DL.OUTR.BEG.COL.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      END.COL.VALUE = DL.OUTR.END.COL.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      FMT.VALUE = DL.OUTR.FMT.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      FIELD.FMT = DL.OUTR.FIELD.FMT.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      CONV.VALUE = DL.OUTR.CONV.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      SM.VALUE = DL.OUTR.SM.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      HTML.START.VALUE = DL.OUTR.HTML.START.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      HTML.END.VALUE = DL.OUTR.HTML.END.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      HTML.CELL.VALUE = DL.OUTR.HTML.CELL.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.NAME = DL.OUTR.XML.NAME.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.GROUP.NAME = DL.OUTR.XML.GROUP.NAME.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.GROUP.ATTRIBUTE = DL.OUTR.XML.GROUP.ATTRIBUTE.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.ASSOC.NAME = DL.OUTR.XML.ASSOC.NAME.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.SUBASSOC.NAME = DL.OUTR.XML.SUBASSOC.NAME.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.ALLOW.CHARACTERS = DL.OUTR.XML.ALLOW.CHARACTERS.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DL.OUTR.XML.ATTRIBUTE = DL.OUTR.XML.ATTRIBUTE.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      FIELD.CONV = DL.OUTR.FIELD.CONV.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      NUM.VALUES.VALUE = DL.OUTR.NUM.VALUES.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      NUM.SUBVALUES.VALUE = DL.OUTR.NUM.SUBVALUES.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      MV.ORIENTATION.VALUE = DL.OUTR.MV.ORIENTATION.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      VALUE.SEPARATOR.VALUE = DL.OUTR.VALUE.SEPARATOR.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      VALUE.SEPARATOR.SET.VALUE = DL.OUTR.VALUE.SEPARATOR.SET(OUTPUT.REC.CTR)<FIELD.CTR>
      SUBVALUE.SEPARATOR.VALUE = DL.OUTR.SUBVALUE.SEPARATOR.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      SUBVALUE.SEPARATOR.SET.VALUE = DL.OUTR.SUBVALUE.SEPARATOR.SET(OUTPUT.REC.CTR)<FIELD.CTR>
      PART.OF.ASSOC.VALUE = DL.OUTR.PART.OF.ASSOC.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      OUT.CTR = DL.OUTR.CTR.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      NUMERIC.FLAG = DL.OUTR.NUMERIC.FLAG.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      DEFAULT.VALUE = DL.OUTR.DEFAULT.VALUE.LIST(OUTPUT.REC.CTR)<FIELD.CTR>
      RETURN


CHECK.BY.EXP: 
      DEBUG6
      CRT 'GOSUB CHECK.BY.EXP '
      END
      BY.EXP.OKAY = FALSE
      IF SELECT.LIST.IS.BY.EXP THEN
         BEGIN CASE
            CASE INDEX(OUT.FIELD.NAME,DL.DATA.SECONDARY.FIELD.FLAG,1) GT 0
               DATA.SUBVALUE = DATA.FIELD
            CASE WHEN.RESULT.LIST<BY.EXP.VALUE.CTR,BY.EXP.SUBVALUE.CTR> OR WHEN.FIELD.LIST = ''
               IF HAVE.GROUPED.FIELD THEN
                  DATA.SUBVALUE = DATA.FIELD
               END ELSE
                  IF NUM.SUBVALUES.VALUE # '' THEN
                     DATA.SUBVALUE = DATA.FIELD<1,BY.EXP.VALUE.CTR>
                  END ELSE
                     DATA.SUBVALUE = DATA.FIELD<1,BY.EXP.VALUE.CTR,BY.EXP.SUBVALUE.CTR>
                  END
               END
            CASE 1
               DATA.SUBVALUE = ''
         END CASE
         BY.EXP.OKAY = TRUE
      END ELSE
         IF WHEN.RESULT.LIST<BY.EXP.VALUE.CTR,BY.EXP.SUBVALUE.CTR> OR WHEN.FIELD.LIST = '' THEN
            IF HAVE.GROUPED.FIELD THEN
               DATA.SUBVALUE = DATA.FIELD
            END ELSE
               DATA.SUBVALUE = DATA.FIELD<1,BY.EXP.VALUE.CTR,BY.EXP.SUBVALUE.CTR>
            END
            BY.EXP.OKAY = TRUE
         END
      END
      RETURN


*
*
* BUILD DIF DETAIL LINES
*
BUILD.DIF.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside BUILD.DIF.DETAIL.LINES'
      END
      TUPLE.LIST = ''
      GOSUB BUILD.DIF.TUPLE.LIST
      CONVERT @VM:@SM TO @FM:@VM IN TUPLE.LIST
      NUM.TUPLE.LIST = COUNT(TUPLE.LIST,@FM) + 1
      FOR TUPLE.CTR=1 TO NUM.TUPLE.LIST
         TUPLE = TUPLE.LIST<TUPLE.CTR>
         NUM.ITEMS = COUNT(TUPLE,@VM) + (TUPLE # '')
         DETAIL.LINES := 'BOT':@FM
         FOR ITEM.CTR=1 TO NUM.ITEMS
            TUPLE.ITEM = TUPLE<1,ITEM.CTR>
            TUPLE.TYPE = FIELD(TUPLE.ITEM,',',1,1)
            TUPLE.VALUE = FIELD(TUPLE.ITEM,',',2,99999)
            BEGIN CASE
               CASE TUPLE.TYPE = 'V'
                  BEGIN CASE
                     CASE TUPLE.VALUE = ''
                        DETAIL.LINES := '0,0':@FM
                        DETAIL.LINES := '""':@FM
                     CASE NUM(TUPLE.VALUE)
                        DETAIL.LINES := '0,':TUPLE.VALUE:@FM
                        DETAIL.LINES := 'V':@FM
                     CASE 1
                        DETAIL.LINES := '1,0':@FM
                        DETAIL.LINES := TUPLE.VALUE:@FM
                  END CASE
               CASE TUPLE.TYPE = 'L'
                  DETAIL.LINES := '1,0':@FM
                  DETAIL.LINES := TUPLE.VALUE:@FM
               CASE 1
                  DETAIL.LINES := '0,0':@FM
                  DETAIL.LINES := '""':@FM
            END CASE
         NEXT ITEM.CTR
         DETAIL.LINES := '-1,0'
         IF TUPLE.CTR < NUM.TUPLE.LIST THEN
            DETAIL.LINES := @FM
         END
      NEXT TUPLE.CTR
      RETURN



*
*
* BUILD DIF DETAIL ITEMS
*
BUILD.DIF.TUPLE.LIST: 
      DEBUG6
      CRT 'GOSUB BUILD.DIF.TUPLE.LIST '
      END
      FOR FIELD.CTR=1 TO DL.OUTR.NUM.OUT.FIELDS(OUTPUT.REC.CTR)
         GOSUB LOAD.FIELD.VALUES
         IF OUT.TYPE # 'SUP' THEN
            GOSUB GET.DATA.FIELD
            IF BY.EXP.FIELD # '' AND PART.OF.ASSOC.VALUE THEN
               GOSUB CHECK.BY.EXP
               IF BY.EXP.OKAY THEN
                  BUILD.DATA.VALUE.CTR = 1
                  BUILD.DATA.SUBVALUE.CTR = 0
                  GOSUB BUILD.DIF.DATA.SUBVALUE
               END
            END ELSE
               NUM.DATA.VALUES = COUNT(DATA.FIELD,@VM) + 1
               NUM.DATA.VALUES.USED = 0
               BUILD.DATA.VALUE.CTR = 1
               DONE.VALUES = FALSE
               IF NUM.VALUES.VALUE = 'LAST' THEN
                  X.START.VALUE = NUM.DATA.VALUES
                  IF X.START.VALUE LT 1 THEN
                     X.START.VALUE = 1
                  END
               END ELSE
                  X.START.VALUE = 1
               END
               FOR VALUE.CTR = X.START.VALUE TO NUM.DATA.VALUES UNTIL DONE.VALUES
                  DATA.VALUE = DATA.FIELD<1,VALUE.CTR>
                  NUM.DATA.SUBVALUES = COUNT(DATA.VALUE,@SM) + 1
                  NUM.DATA.SUBVALUES.USED = 0
                  DONE.SUBVALUES = FALSE
                  USE.DATA.VALUE = FALSE
                  BUILD.DATA.SUBVALUE.CTR = 0
                  IF NUM.SUBVALUES.VALUE = 'LAST' THEN
                     X.START.SUBVALUE = NUM.DATA.SUBVALUES
                     IF X.START.SUBVALUE LT 1 THEN
                        X.START.SUBVALUE = 1
                     END
                  END ELSE
                     X.START.SUBVALUE = 1
                  END
                  FOR SUBVALUE.CTR=X.START.SUBVALUE TO NUM.DATA.SUBVALUES UNTIL DONE.SUBVALUES
                     USE.DATA.SUBVALUE = TRUE
                     IF PART.OF.ASSOC.VALUE AND WHEN.FIELD.LIST # '' THEN
                        USE.DATA.SUBVALUE = WHEN.RESULT.LIST<VALUE.CTR,SUBVALUE.CTR>
                     END
                     IF USE.DATA.SUBVALUE THEN
                        USE.DATA.VALUE = TRUE
                        DATA.SUBVALUE = DATA.VALUE<1,1,SUBVALUE.CTR>
                        NUM.DATA.SUBVALUES.USED += 1
                        GOSUB BUILD.DIF.DATA.SUBVALUE
                        IF (NUM.SUBVALUES.VALUE NE 'ALL') THEN
                           IF NUM.SUBVALUES.VALUE = 'LAST' THEN
                              DONE.SUBVALUES = TRUE
                           END ELSE
                              IF NUM.DATA.SUBVALUES.USED >= NUM.SUBVALUES.VALUE THEN
                                 DONE.SUBVALUES = TRUE
                              END
                           END
                        END
                     END
                  NEXT SUBVALUE.CTR
                  IF (NUM.SUBVALUES.VALUE NE 'ALL') AND (NUM.SUBVALUES.VALUE NE 'LAST') THEN
                     FOR SUBVALUE.CTR=(NUM.DATA.SUBVALUES.USED+1) TO NUM.SUBVALUES.VALUE
                        DATA.SUBVALUE = ''
                        GOSUB BUILD.DIF.DATA.SUBVALUE
                     NEXT SUBVALUE.CTR
                  END
                  IF USE.DATA.VALUE THEN
                     NUM.DATA.VALUES.USED += 1
                     IF MV.ORIENTATION.VALUE = 'VERTICAL' THEN
                        BUILD.DATA.VALUE.CTR += 1
                     END
                     IF NUM.VALUES.VALUE = 'LAST' THEN
                        DONE.VALUES = TRUE
                     END ELSE
                        IF NUM.DATA.VALUES.USED >= NUM.VALUES.VALUE THEN
                           DONE.VALUES = TRUE
                        END
                     END
                  END
               NEXT VALUE.CTR
               IF (NUM.VALUES.VALUE NE 'ALL') AND (NUM.VALUES.VALUE NE 'LAST') THEN
                  FOR VALUE.CTR=(NUM.DATA.VALUES.USED+1) TO NUM.VALUES.VALUE
                     DATA.SUBVALUE = ''
                     GOSUB BUILD.DIF.DATA.SUBVALUE
                  NEXT VALUE.CTR
               END
            END
         END
*
      NEXT FIELD.CTR
      RETURN


*
*
* BUILD DIF DATA.SUBVALUE
*
BUILD.DIF.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.DIF.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      IF MV.ORIENTATION.VALUE = 'VERTICAL' THEN
         BUILD.DATA.VALUE.CTR += 1
      END ELSE
         BUILD.DATA.VALUE.CTR = 1
      END
      GOSUB CONV.DATA.SUBVALUE
      IF FMT.VALUE THEN
         GOSUB FMT.DATA.SUBVALUE
      END
      GOSUB LENGTH.DATA.SUBVALUE
      TUPLE = TUPLE.LIST<LINE.VALUE,BUILD.DATA.VALUE.CTR>
      IF NUMERIC.FLAG THEN
         TUPLE.ITEM = 'V,':DATA.SUBVALUE
      END ELSE
         TUPLE.ITEM = 'L,':DLMAIN.QUOTE:DATA.SUBVALUE:DLMAIN.QUOTE
      END
      IF BUILD.DATA.VALUE.CTR = 1 THEN
         IF MV.ORIENTATION.VALUE = 'VERTICAL' THEN
            NUM.ITEMS = COUNT(TUPLE,@SM) + (TUPLE # '')
            BUILD.DATA.SUBVALUE.CTR = NUM.ITEMS + 1
         END ELSE
            BUILD.DATA.SUBVALUE.CTR = -1
         END
      END
      TUPLE<1,1,BUILD.DATA.SUBVALUE.CTR> = TUPLE.ITEM
      TUPLE.LIST<LINE.VALUE,BUILD.DATA.VALUE.CTR> = TUPLE
      RETURN


*
*
* DO FMT ON DATA.VALUE
*
FMT.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB FMT.DATA.VALUE '
      CRT 'FMT.VALUE: ':FMT.VALUE
      END
      BEGIN CASE
         CASE FMT.VALUE = NULL.CODE
            NULL
         CASE FMT.VALUE
            DATA.VALUE = FMT(DATA.VALUE, FMT.VALUE)
            DATA.VALUE = FIELD(DATA.VALUE,@TM,1,1)
         CASE FIELD.FMT
            DATA.VALUE = FMT(DATA.VALUE, FIELD.FMT)
            DATA.VALUE = FIELD(DATA.VALUE,@TM,1,1)
      END CASE
      RETURN

*
*
* DO A CONV ON DATA.VALUE
*
CONV.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB CONV.DATA.VALUE '
      CRT 'CONV.VALUE: ':CONV.VALUE
      END
      BEGIN CASE
         CASE CONV.VALUE = NULL.CODE
            NULL
         CASE FIELD.CONV = 'DBF.DATE'
            DATA.VALUE = OCONV(DATA.VALUE,'D4/[YMD]')
            CONVERT '/' TO '' IN DATA.VALUE
         CASE CONV.VALUE
            DATA.VALUE = OCONV(DATA.VALUE, CONV.VALUE)
         CASE FIELD.CONV
            DATA.VALUE = OCONV(DATA.VALUE, FIELD.CONV)
      END CASE
      RETURN

*
*
* TAKE A MAXIMUM LENGTH ON DATA.VALUE
*
*
LENGTH.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB LENGTH.DATA.VALUE '
      END
      IF LENGTH.VALUE THEN
         DATA.VALUE = DATA.VALUE[1,LENGTH.VALUE]
      END
      RETURN


*
*
* DO FMT ON DATA.SUBVALUE
*
FMT.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB FMT.DATA.SUBVALUE '
      CRT 'FMT.VALUE: ':FMT.VALUE
      END
      BEGIN CASE
         CASE FMT.VALUE = NULL.CODE
            NULL
         CASE FMT.VALUE
            DATA.SUBVALUE = FMT(DATA.SUBVALUE, FMT.VALUE)
            DATA.SUBVALUE = FIELD(DATA.SUBVALUE,@TM,1,1)
         CASE FIELD.FMT
            DATA.SUBVALUE = FMT(DATA.SUBVALUE, FIELD.FMT)
            DATA.SUBVALUE = FIELD(DATA.SUBVALUE,@TM,1,1)
      END CASE
      RETURN

*
*
* DO A CONV ON DATA.SUBVALUE
*
CONV.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB CONV.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      BEGIN CASE
         CASE CONV.VALUE = NULL.CODE
            NULL
         CASE FIELD.CONV = 'DBF.DATE'
            DATA.SUBVALUE = OCONV(DATA.SUBVALUE,'D4/[YMD]')
            CONVERT '/' TO '' IN DATA.SUBVALUE
         CASE CONV.VALUE
            DATA.SUBVALUE = OCONV(DATA.SUBVALUE, CONV.VALUE)
         CASE FIELD.CONV
            DATA.SUBVALUE = OCONV(DATA.SUBVALUE, FIELD.CONV)
      END CASE
      RETURN

*
*
* TAKE A MAXIMUM LENGTH ON DATA.VALUE
*
*
LENGTH.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB LENGTH.DATA.SUBVALUE '
      END
      IF LENGTH.VALUE THEN
         DATA.SUBVALUE = DATA.SUBVALUE[1,LENGTH.VALUE]
      END
      RETURN


*
*
* BUILD FIXED DETAIL LINES
*
BUILD.FIXED.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside BUILD.FIXED.DETAIL.LINES'
      END
      FOR FIELD.CTR=1 TO DL.OUTR.NUM.OUT.FIELDS(OUTPUT.REC.CTR)
         GOSUB LOAD.FIELD.VALUES
         IF OUT.TYPE # 'SUP' THEN
            GOSUB GET.DATA.FIELD
            IF BY.EXP.FIELD # '' AND PART.OF.ASSOC.VALUE THEN
               GOSUB CHECK.BY.EXP
               IF BY.EXP.OKAY THEN
                  BUILD.DATA.VALUE.CTR = 1
                  BUILD.DATA.SUBVALUE.CTR = 0
                  GOSUB BUILD.FIXED.DATA.SUBVALUE
               END
            END ELSE
               NUM.DATA.VALUES = COUNT(DATA.FIELD,@VM) + 1
               NUM.DATA.VALUES.USED = 0
               BUILD.DATA.VALUE.CTR = 1
               DONE.VALUES = FALSE
               FOR VALUE.CTR=1 TO NUM.DATA.VALUES UNTIL DONE.VALUES
                  DATA.VALUE = DATA.FIELD<1,VALUE.CTR>
                  NUM.DATA.SUBVALUES = COUNT(DATA.VALUE,@SM) + 1
                  NUM.DATA.SUBVALUES.USED = 0
                  DONE.SUBVALUES = FALSE
                  USE.DATA.VALUE = FALSE
                  BUILD.DATA.SUBVALUE.CTR = 0
                  FOR SUBVALUE.CTR=1 TO NUM.DATA.SUBVALUES UNTIL DONE.SUBVALUES
                     USE.DATA.SUBVALUE = TRUE
                     IF PART.OF.ASSOC.VALUE AND WHEN.FIELD.LIST # '' THEN
                        USE.DATA.SUBVALUE = WHEN.RESULT.LIST<VALUE.CTR,SUBVALUE.CTR>
                     END
                     IF USE.DATA.SUBVALUE THEN
                        USE.DATA.VALUE = TRUE
                        DATA.SUBVALUE = DATA.VALUE<1,1,SUBVALUE.CTR>
                        NUM.DATA.SUBVALUES.USED += 1
                        GOSUB BUILD.FIXED.DATA.SUBVALUE
                        IF MV.ORIENTATION.VALUE = 'HORIZONTAL' THEN
                           BEG.COL.VALUE += LENGTH.VALUE
                        END
                        IF NUM.SUBVALUES.VALUE # 'ALL' THEN
                           IF NUM.DATA.SUBVALUES.USED >= NUM.SUBVALUES.VALUE THEN
                              DONE.SUBVALUES = TRUE
                           END
                        END
                     END
                  NEXT SUBVALUE.CTR
                  IF NUM.SUBVALUES.VALUE # 'ALL' THEN
                     BUILD.DATA.SUBVALUE.CTR = 0
                     FOR SUBVALUE.CTR=(NUM.DATA.SUBVALUES.USED+1) TO NUM.SUBVALUES.VALUE
                        DATA.SUBVALUE = ''
                        GOSUB BUILD.FIXED.DATA.SUBVALUE
                        IF MV.ORIENTATION.VALUE = 'HORIZONTAL' THEN
                           BEG.COL.VALUE += LENGTH.VALUE
                        END
                     NEXT SUBVALUE.CTR
                  END
                  IF USE.DATA.VALUE THEN
                     NUM.DATA.VALUES.USED += 1
                     IF MV.ORIENTATION.VALUE = 'VERTICAL' THEN
                        BUILD.DATA.VALUE.CTR += 1
                     END
                     IF NUM.VALUES.VALUE # 'ALL' THEN
                        IF NUM.DATA.VALUES.USED >= NUM.VALUES.VALUE THEN
                           DONE.VALUES = TRUE
                        END
                     END
                  END
               NEXT VALUE.CTR
               IF NUM.VALUES.VALUE # 'ALL' THEN
                  FOR VALUE.CTR=(NUM.DATA.VALUES.USED+1) TO NUM.VALUES.VALUE
                     DATA.SUBVALUE = ''
                     BUILD.DATA.SUBVALUE.CTR = 0
                     GOSUB BUILD.FIXED.DATA.SUBVALUE
                     IF MV.ORIENTATION.VALUE = 'HORIZONTAL' THEN
                        BEG.COL.VALUE += LENGTH.VALUE
                     END
                  NEXT VALUE.CTR
               END
            END
         END
*
      NEXT FIELD.CTR
      RETURN


*
*
* BUILD FIXED DATA.SUBVALUE
*
BUILD.FIXED.DATA.SUBVALUE: 
      IF LENGTH.VALUE LT 1 THEN
         LENGTH.VALUE = LEN(DATA.SUBVALUE)
      END
      DEBUG6
      CRT 'GOSUB BUILD.FIXED.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      IF MV.ORIENTATION.VALUE = 'VERTICAL' THEN
         BUILD.DATA.SUBVALUE.CTR += 1
      END ELSE
         BUILD.DATA.SUBVALUE.CTR = 1
      END
      GOSUB CONV.DATA.SUBVALUE
      GOSUB FMT.DATA.SUBVALUE
      GOSUB LENGTH.DATA.SUBVALUE
*
      BUILD.DATA.LINE.VALUE = LINE.VALUE + BUILD.DATA.VALUE.CTR  - 1
      W.DETAIL.LINE = DETAIL.LINES<BUILD.DATA.LINE.VALUE,BUILD.DATA.SUBVALUE.CTR>
      LEN.WDL = LEN(W.DETAIL.LINE)
      IF LEN.WDL > END.COL.VALUE THEN
         W.DETAIL.LINE[BEG.COL.VALUE,LENGTH.VALUE] = DATA.SUBVALUE
      END ELSE
         PART.ONE.LEN = BEG.COL.VALUE - 1
         IF PART.ONE.LEN > 0 THEN
            W.DETAIL.LINE = (W.DETAIL.LINE:SPACE(PART.ONE.LEN))[1,PART.ONE.LEN]
         END ELSE
            W.DETAIL.LINE = ''
         END
         W.DETAIL.LINE := (DATA.SUBVALUE:SPACE(LENGTH.VALUE))[1,LENGTH.VALUE]
      END
      DETAIL.LINES<BUILD.DATA.LINE.VALUE,BUILD.DATA.SUBVALUE.CTR> = W.DETAIL.LINE
      RETURN


*
*
* BUILD WORDPERFECT DETAIL LINES
*
BUILD.WORDPERFECT.DETAIL.LINES: 
      DEBUG5OR6
      CRT 'Inside BUILD.WORDPERFECT.DETAIL.LINES'
      END
      DETAIL.LINES = ''
      FOR FIELD.CTR=1 TO DL.OUTR.NUM.OUT.FIELDS(OUTPUT.REC.CTR)
         BUILD.DATA.VALUE.CTR = 0
         GOSUB LOAD.FIELD.VALUES
         IF OUT.TYPE # 'SUP' THEN
            GOSUB GET.DATA.FIELD
            IF BY.EXP.FIELD # '' AND PART.OF.ASSOC.VALUE THEN
               GOSUB CHECK.BY.EXP
               IF BY.EXP.OKAY THEN
                  IF NUM.SUBVALUES.VALUE = '' THEN
                     BUILD.DATA.VALUE.CTR = 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.WORDPERFECT.DATA.SUBVALUE
                  END ELSE
                     DATA.VALUE = DATA.SUBVALUE
                     GOSUB BUILD.WORDPERFECT.DATA.VALUE
                  END
               END
            END ELSE
               NUM.DATA.VALUES = COUNT(DATA.FIELD,@VM) + 1
               DONE.VALUES = FALSE
               BUILD.DATA.VALUE.CTR = 0
               IF NUM.VALUES.VALUE = 'LAST' THEN
                  X.START.VALUE = NUM.DATA.VALUES
                  IF X.START.VALUE LT 1 THEN
                     X.START.VALUE = 1
                  END
               END ELSE
                  X.START.VALUE = 1
               END
               FOR VALUE.CTR = X.START.VALUE TO NUM.DATA.VALUES UNTIL DONE.VALUES
                  DATA.VALUE = DATA.FIELD<1,VALUE.CTR>
                  GOSUB BUILD.WORDPERFECT.DATA.VALUE
                  IF USE.DATA.VALUE THEN
                     IF NUM.VALUES.VALUE = 'LAST' THEN
                        DONE.VALUES = TRUE
                     END ELSE
                        IF BUILD.DATA.VALUE.CTR >= NUM.VALUES.VALUE THEN
                           DONE.VALUES = TRUE
                        END
                     END
                  END
               NEXT VALUE.CTR
               IF (NUM.VALUES.VALUE NE 'ALL') AND (NUM.VALUES.VALUE NE 'LAST') THEN
                  X.START = BUILD.DATA.VALUE.CTR + 1
                  FOR VALUE.CTR = X.START TO NUM.VALUES.VALUE
                     DATA.SUBVALUE = ''
                     BUILD.DATA.VALUE.CTR += 1
                     BUILD.DATA.SUBVALUE.CTR = 1
                     X.BUILDING.DATA.VALUE = TRUE
                     X.BUILDING.DATA.SUBVALUE = FALSE
                     GOSUB BUILD.WORDPERFECT.DATA.SUBVALUE
                  NEXT VALUE.CTR
               END
            END
         END
         DETAIL.LINES := K.WORDPERFECT.FIELD.SEP
      NEXT FIELD.CTR
      DETAIL.LINES := K.WORDPERFECT.END.RECORD
      RETURN


BUILD.WORDPERFECT.DATA.VALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.WORDPERFECT.DATA.VALUE '
      CRT 'DATA.VALUE: ':DATA.VALUE
      END
      NUM.DATA.SUBVALUES = COUNT(DATA.VALUE,@SM) + 1
      BUILD.DATA.SUBVALUE.CTR = 0
      DONE.SUBVALUES = FALSE
      USE.DATA.VALUE = FALSE
      IF NUM.SUBVALUES.VALUE = 'LAST' THEN
         X.START.SUBVALUE = NUM.DATA.SUBVALUES
         IF X.START.SUBVALUE LT 1 THEN
            X.START.SUBVALUE = 1
         END
      END ELSE
         X.START.SUBVALUE = 1
      END
      FOR SUBVALUE.CTR=X.START.SUBVALUE TO NUM.DATA.SUBVALUES UNTIL DONE.SUBVALUES
         USE.DATA.SUBVALUE = TRUE
         IF PART.OF.ASSOC.VALUE AND WHEN.FIELD.LIST # '' THEN
            USE.DATA.SUBVALUE = WHEN.RESULT.LIST<VALUE.CTR,SUBVALUE.CTR>
         END
         IF USE.DATA.SUBVALUE THEN
            IF USE.DATA.VALUE THEN
               X.BUILDING.DATA.VALUE = FALSE
               X.BUILDING.DATA.SUBVALUE = TRUE
            END ELSE
               BUILD.DATA.VALUE.CTR += 1
               X.BUILDING.DATA.VALUE = TRUE
               X.BUILDING.DATA.SUBVALUE = FALSE
            END
            USE.DATA.VALUE = TRUE
            DATA.SUBVALUE = DATA.VALUE<1,1,SUBVALUE.CTR>
            BUILD.DATA.SUBVALUE.CTR += 1
            GOSUB BUILD.WORDPERFECT.DATA.SUBVALUE
            IF (NUM.SUBVALUES.VALUE NE 'ALL') THEN
               IF NUM.SUBVALUES.VALUE = 'LAST' THEN
                  DONE.SUBVALUES = TRUE
               END ELSE
                  IF BUILD.DATA.SUBVALUE.CTR >= NUM.SUBVALUES.VALUE THEN
                     DONE.SUBVALUES = TRUE
                  END
               END
            END
         END
      NEXT SUBVALUE.CTR
      IF (NUM.SUBVALUES.VALUE NE 'ALL') AND (NUM.SUBVALUES.VALUE NE 'LAST') THEN
         X.START = BUILD.DATA.SUBVALUE.CTR + 1
         FOR SUBVALUE.CTR = X.START TO NUM.SUBVALUES.VALUE
            DATA.SUBVALUE = ''
            BUILD.DATA.SUBVALUE.CTR += 1
            X.BUILDING.DATA.VALUE = FALSE
            X.BUILDING.DATA.SUBVALUE = TRUE
            GOSUB BUILD.WORDPERFECT.DATA.SUBVALUE
         NEXT SUBVALUE.CTR
      END
      RETURN
*
*
* BUILD WORDPERFECT DATA.SUBVALUE
*
BUILD.WORDPERFECT.DATA.SUBVALUE: 
      DEBUG6
      CRT 'GOSUB BUILD.WORDPERFECT.DATA.SUBVALUE '
      CRT 'DATA.SUBVALUE: ':DATA.SUBVALUE
      END
      GOSUB CONV.DATA.SUBVALUE
      IF FMT.VALUE THEN
         GOSUB FMT.DATA.SUBVALUE
      END
      GOSUB LENGTH.DATA.SUBVALUE
      BEGIN CASE
         CASE (X.BUILDING.DATA.SUBVALUE) AND (BUILD.DATA.SUBVALUE.CTR GT 1) AND (SUBVALUE.SEPARATOR.SET.VALUE)
            X.DELIM = SUBVALUE.SEPARATOR.VALUE
         CASE (X.BUILDING.DATA.VALUE) AND (BUILD.DATA.VALUE.CTR GT 1) AND (VALUE.SEPARATOR.SET.VALUE)
            X.DELIM = VALUE.SEPARATOR.VALUE
         CASE 1
            X.DELIM = K.WORDPERFECT.DATA.SEP
      END CASE
      IF (BUILD.DATA.VALUE.CTR LT 2) AND (BUILD.DATA.SUBVALUE.CTR LT 2) THEN
         DETAIL.LINES := DATA.SUBVALUE
      END ELSE
         DETAIL.LINES := X.DELIM:DATA.SUBVALUE
      END
      RETURN


*
*
* GET DATA.FIELD VALUE
*
GET.DATA.FIELD: 
      DEBUG6
      CRT 'GOSUB GET.DATA.FIELD '
      CRT 'OUT.PREFIX: ':OUT.PREFIX
      CRT 'OUT.TYPE: ':OUT.TYPE
      END
      HAVE.GROUPED.FIELD = @FALSE
      BEGIN CASE
         CASE OUT.PREFIX = 'TOTAL' AND BREAK.LEVEL > 0
            HAVE.GROUPED.FIELD = @TRUE
            DATA.FIELD = DATA.TOTAL(BREAK.LEVEL)<OUT.CTR> + 0
         CASE OUT.PREFIX = 'MIN' AND BREAK.LEVEL > 0
            HAVE.GROUPED.FIELD = @TRUE
            DATA.FIELD = DATA.MIN(BREAK.LEVEL)<OUT.CTR>
         CASE OUT.PREFIX = 'MAX' AND BREAK.LEVEL > 0
            HAVE.GROUPED.FIELD = @TRUE
            DATA.FIELD = DATA.MAX(BREAK.LEVEL)<OUT.CTR>
         CASE OUT.PREFIX = 'AVERAGE' AND BREAK.LEVEL > 0
            HAVE.GROUPED.FIELD = @TRUE
            T.COUNT = DATA.COUNT(BREAK.LEVEL)<OUT.CTR> + 0
            T.TOTAL = DATA.TOTAL(BREAK.LEVEL)<OUT.CTR>
            IF T.COUNT # 0 THEN
               DATA.FIELD = T.TOTAL / T.COUNT
            END ELSE
               DATA.FIELD = ''
            END
         CASE OUT.TYPE = 'FIELD'
            FIELD.IS.LESSER.BREAK = FALSE
            IF (OUTPUT.REC.CTR # DL.OUTR.DETAIL.OUT.REC) OR (BREAK.LEVEL > 1) THEN
               FOR CHECK.CTR=(BREAK.LEVEL+1) TO DLMAIN.NUM.BREAK.FIELDS
                  IF DLMAIN.BREAK.DICT.CTR.LIST<CHECK.CTR> = OUT.CTR THEN
                     FIELD.IS.LESSER.BREAK = TRUE
                  END
               NEXT CHECK.CTR
            END
            IF FIELD.IS.LESSER.BREAK THEN
               DATA.FIELD = ''
            END ELSE
               DATA.FIELD = DL.DATA.DATA.ITEMS(OUT.CTR)
               IF DATA.FIELD = '' THEN
                  DATA.FIELD = DEFAULT.VALUE
               END
            END
         CASE OUT.TYPE = 'SUBR'
            DATA.FIELD = SUBR.RET.VALUES(OUT.CTR)
            IF DATA.FIELD = '' THEN
               DATA.FIELD = DEFAULT.VALUE
            END
         CASE OUT.TYPE = 'LITERAL'
            DATA.FIELD = DLMAIN.LITERAL.VALUES(OUT.CTR)
            BEGIN CASE
               CASE DATA.FIELD = '%%@COUNTER%%'
                  DATA.FIELD = DLMAIN.RECORD.CTR
               CASE 1
            END CASE
            GOSUB PROCESS.LITERAL.DATA
         CASE OUT.TYPE = 'EVAL'
            X.EVAL.FORMULA = DLMAIN.EVAL.FORMULAE(OUT.CTR)
            GOSUB PROCESS.EVAL.FORMULA
            DATA.FIELD = X.EVAL.RESULTS
         CASE OUT.TYPE = 'SUP'
            NULL
         CASE 1
            DATA.FIELD = '** Unknown OUT.TYPE "':OUT.TYPE:'" for "':DL.OUTR.FIELD.LIST(OUTPUT.REC.CTR)<FIELD.CTR>:'"'
      END CASE
      DEBUG6
      CRT 'Fetched data field ':DATA.FIELD
      END
      IF DLMAIN.REMOVE.PUNCTUATION THEN
         GOSUB DO.REMOVE.PUNCTUATION
      END
      RETURN



PROCESS.LITERAL.DATA: 
      DEBUG6
      CRT 'GOSUB PROCESS.LITERAL.DATA '
      END
      ORIG.DATA.FIELD = DATA.FIELD
      DATA.FIELD = ''
      NUM.DATA.FIELD.FIELDS = COUNT(ORIG.DATA.FIELD,"'") + 1
      QUOTE.START = 2
      FOR WHICH.DATA.FIELD = 1 TO NUM.DATA.FIELD.FIELDS
         DATA.FIELD.OPTIONS = FIELD(ORIG.DATA.FIELD,"'",WHICH.DATA.FIELD,1)
         IF WHICH.DATA.FIELD = QUOTE.START THEN
            GOSUB PROCESS.DATA.FIELD.OPTIONS
            QUOTE.START += 2
         END ELSE
            DATA.FIELD := DATA.FIELD.OPTIONS
         END
      NEXT WHICH.DATA.FIELD
      RETURN


PROCESS.DATA.FIELD.OPTIONS: 
      DEBUG6
      CRT 'GOSUB PROCESS.DATA.FIELD.OPTIONS '
      END
      NUM.DATA.FIELD.OPTIONS = LEN(DATA.FIELD.OPTIONS)
      FOR WHICH.DATA.FIELD.OPTION = 1 TO NUM.DATA.FIELD.OPTIONS
         DATA.FIELD.OPTION = DATA.FIELD.OPTIONS[WHICH.DATA.FIELD.OPTION,1]
         BEGIN CASE
            CASE DATA.FIELD.OPTION = 'D'
               DATA.FIELD := OCONV(DATE(),'D2-')
            CASE DATA.FIELD.OPTION = 'T'
               DATA.FIELD := OCONV(TIME(),'MTHS'):'  ':OCONV(DATE(),'D2-')
            CASE DATA.FIELD.OPTION = 'P'
               DATA.FIELD := CHAR(12)
            CASE 1
               DATA.FIELD := DATA.FIELD.OPTION
         END CASE
      NEXT WHICH.DATA.FIELD.OPTION
      RETURN


PROCESS.EVAL.FORMULA: 
      DEBUG6
      CRT 'GOSUB PROCESS.EVAL.FORMULA '
      END
      X.COMMAND = 'SELECT'
      X.COMMAND :=' ':DLMAIN.INFO.FILE.NAME.PART.2(PRIMARY.FILE.NUM)
      X.COMMAND := ' "':DLMAIN.RECORD.ID:'"'
      IF INDEX(X.EVAL.FORMULA,'"',1) GT 0 THEN
         X.COMMAND := " SAVING EVAL '": X.EVAL.FORMULA:"'"
      END ELSE
         X.COMMAND := ' SAVING EVAL "':X.EVAL.FORMULA:'"'
      END
      X.COMMAND := ' TO ':DLMAIN.EVAL.UNIT
      DEBUG6
      CRT 'EVAL command is ':X.COMMAND
      END
      EXECUTE X.COMMAND CAPTURING XL.COMMAND.OUTPUT
      DEBUG6
      CRT 'EVAL command output is ':XL.COMMAND.OUTPUT
      END
      READNEXT XL.RESULTS FROM DLMAIN.EVAL.UNIT ELSE
         XL.RESULTS = ''
      END
      DEBUG6
      CRT 'EVAL command results are ':XL.RESULTS
      END
      X.EVAL.RESULTS = XL.RESULTS
      RETURN



*
*
*
PRINT.DETAIL.LINES: 
      DEBUG6
      CRT 'GOSUB PRINT.DETAIL.LINES '
      END
      LOOP
         REMOVE PRINT.LINE FROM DETAIL.LINES SETTING DETAIL.LINES.DELIM
         PRINT.LINE := DLMAIN.EOR
         BEGIN CASE
            CASE DLMAIN.PRINT.METHOD = 'CRT'
               CRT PRINT.LINE
            CASE DLMAIN.PRINT.METHOD = 'WRITE.OP.SYS'
               FLUSH.BUFFER = FALSE
               CALL DOWNLOAD.OP.SYS.WRITE(PRINT.LINE, FLUSH.BUFFER)
            CASE 1
               GOSUB DO.WRITESEQ
         END CASE
      UNTIL DETAIL.LINES.DELIM = 0
      REPEAT
      RETURN


*
*
* USE 'WRITESEQ' TO WRITE A LINE
*
DO.WRITESEQ: 
      DEBUG6
      CRT 'GOSUB DO.WRITESEQ '
      END
      WRITESEQ PRINT.LINE APPEND TO DLMAIN.F.OUTPUT.FILE ELSE
         DLMAIN.ERRMSG<-1> = 'Can not write to "':DLMAIN.OUTPUT.FILE.NAME:'" "':DLMAIN.OUTPUT.RECORD.NAME:'" for record "':DLMAIN.RECORD.ID:'"'
         DLMAIN.FATAL.ERROR = TRUE
      END
      RETURN


GET.LIT.DICT.EVAL: 
      DEBUG6
      CRT 'GOSUB GET.LIT.DICT.EVAL '
      END
      IF X.LIT.DICT.EVAL = '' THEN
         X.LIT.DICT.EVAL.VALUE = ''
      END ELSE
         X.FIRST.PART = FIELD(X.LIT.DICT.EVAL,@VM,1,1)
         X.SECOND.PART = FIELD(X.LIT.DICT.EVAL,@VM,2,1)
         BEGIN CASE
            CASE (X.FIRST.PART = '$$EVAL') AND (X.SECOND.PART NE '')
               X.EVAL.FORMULA = DLMAIN.EVAL.FORMULAE(X.SECOND.PART)
               GOSUB PROCESS.EVAL.FORMULA
               X.LIT.DICT.EVAL.VALUE = X.EVAL.RESULTS
            CASE (X.FIRST.PART = '$$DICT') AND (X.SECOND.PART NE '')
               X.DICT.NUMBER = X.SECOND.PART
               X.LIT.DICT.EVAL.VALUE = DL.DATA.NEW.DATA.ITEMS(X.DICT.NUMBER)
            CASE 1
               X.LIT.DICT.EVAL.VALUE = X.LIT.DICT.EVAL
         END CASE
      END
      RETURN

   END