home *** CD-ROM | disk | FTP | other *** search
/ World of Shareware - Software Farm 2 / wosw_2.zip / wosw_2 / QBAS / QBLIST.ZIP / QBLIST.LST < prev    next >
File List  |  1992-01-20  |  21KB  |  650 lines
  1.  
  2.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   1
  3.                             PROGLIST.BAS (Main Module) Page   1
  4.          --------------------------------------------------------------------------------
  5.  
  6.          DECLARE SUB ListFunc ()
  7.          DECLARE FUNCTION test! ()
  8.          DECLARE SUB ListSubs ()
  9.          DECLARE SUB FunctionList ()
  10.          DECLARE SUB WriteLine ()
  11.          DECLARE SUB SplitLine ()
  12.          DECLARE FUNCTION TEST1$ ()
  13.          DECLARE FUNCTION TEST2% ()
  14.          DECLARE FUNCTION TESTA! ()
  15.          DECLARE SUB MainRoutine ()
  16.          DECLARE SUB EojRoutine ()
  17.          DECLARE SUB EndOfList ()
  18.          DECLARE SUB MainModuleList ()
  19.          DECLARE SUB SubRoutineList ()
  20.          DECLARE SUB CompleteList ()
  21.          DECLARE SUB WaitforAnswer (A$)
  22.          DECLARE SUB ScreenTitle ()
  23.          DECLARE SUB SubTitle ()
  24.          DECLARE SUB MainModule ()
  25.          DECLARE SUB ProgramTitle ()
  26.          DECLARE SUB OpenFiles ()
  27.          
  28.          COMMON SHARED Line$, FileName$, SubName$, Today$, TheTime$, FullPageCount
  29.          COMMON SHARED subPageCount, LineCount, SubRoutineType, SubType$, Line1$, Line2$
  30.          
  31.          
  32.          REM **********************************
  33.          REM * Set Printer To 12 CPI at 8 LPI *
  34.          REM **********************************
  35.          
  36.          ON ERROR GOTO ErrorHandler
  37.          
  38.          Today$ = DATE$
  39.          TheTime$ = TIME$
  40.          
  41.          Redo:
  42.          
  43.          CALL MainRoutine
  44.          
  45.          ErrorHandler:
  46.          SOUND 1000, 2
  47.          PRINT
  48.          ErrorCode = ERR
  49.          PRINT "ERROR CODE = "; ErrorCode
  50.          SELECT CASE ErrorCode
  51.           CASE 64
  52.            PRINT "Bad File Name ==> "; FileName$; " <=="
  53.            INPUT "Please Press Any Key To Continue"; A$
  54.            RESUME Redo
  55.           CASE 53
  56.            PRINT "File Not Found ==> "; FileName$; " <=="
  57.            INPUT "Please Press Any Key To Continue"; A$
  58.            RESUME Redo
  59.          END SELECT
  60.          
  61.          END
  62.          
  63.  
  64.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   2
  65.                             CompleteList (Sub Routine) Page   1
  66.          --------------------------------------------------------------------------------
  67.  
  68.          SUB CompleteList
  69.          
  70.          START$ = "Y"
  71.          
  72.          DO
  73.           LINE INPUT #1, Line$
  74.            IF LEFT$(Line$, 4) = "SUB " THEN
  75.              NamePosition = 5
  76.              GOSUB GetSubName
  77.              CALL ProgramTitle
  78.              subPageCount = 1
  79.              SubRoutineType = 2
  80.              CALL SubTitle
  81.              START$ = "N"
  82.            ELSEIF LEFT$(Line$, 8) = "FUNCTION" THEN
  83.              NamePosition = 10
  84.              GOSUB GetSubName
  85.              CALL ProgramTitle
  86.              subPageCount = 1
  87.              SubRoutineType = 3
  88.              CALL SubTitle
  89.              START$ = "N"
  90.            ELSEIF (LEFT$(Line$, 4) <> "SUB " OR LEFT$(Line$, 8) <> "FUNCTION") AND
  91.    <<*>>  START$ = "Y" THEN
  92.               subPageCount = 1
  93.               CALL ProgramTitle
  94.               SubName$ = FileName$
  95.               SubRoutineType = 1
  96.               CALL SubTitle
  97.               START$ = "N"
  98.            END IF
  99.          START$ = "N"
  100.          CALL WriteLine
  101.          LOOP WHILE NOT EOF(1)
  102.          
  103.          PRINT #2, CHR$(12)
  104.          CLOSE #1, #2
  105.          CALL EndOfList
  106.          CALL MainRoutine
  107.          
  108.          GetSubName:
  109.            
  110.          SpacePos = INSTR(NamePosition, Line$, " ")
  111.           IF SpacePos = 0 THEN
  112.              SpacePos = LEN(Line$)
  113.              SpacePos = SpacePos - (NamePosition - 1)
  114.              SubName$ = MID$(Line$, NamePosition, SpacePos)
  115.           ELSEIF SpacePos > 0 AND NamePosition = 5 THEN
  116.              SpacePos = SpacePos - 4
  117.              SubName$ = MID$(Line$, 5, SpacePos - 1)
  118.           ELSEIF SpacePos > 0 AND NamePosition = 10 THEN
  119.              SpacePos = SpacePos - 9
  120.              SubName$ = MID$(Line$, 10, SpacePos - 1)
  121.           END IF
  122.          RETURN
  123.          
  124.          END SUB
  125.          
  126.  
  127.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   3
  128.                             EndOfList (Sub Routine) Page   1
  129.          --------------------------------------------------------------------------------
  130.  
  131.          SUB EndOfList
  132.          
  133.          LOCATE 20, 12, 0
  134.          PRINT "===> End Of List, Please Press Any Key To Continue <==="
  135.          SOUND 1000, 2
  136.          CALL WaitforAnswer(A$)
  137.          
  138.          END SUB
  139.          
  140.  
  141.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   4
  142.                             EojRoutine (Sub Routine) Page   1
  143.          --------------------------------------------------------------------------------
  144.  
  145.          SUB EojRoutine
  146.          
  147.          CLOSE #1, #2
  148.          CLS
  149.          SYSTEM
  150.          
  151.          END SUB
  152.          
  153.  
  154.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   5
  155.                             FunctionList (Sub Routine) Page   1
  156.          --------------------------------------------------------------------------------
  157.  
  158.          SUB FunctionList
  159.          
  160.          StartFunc:
  161.          CALL ScreenTitle
  162.          DO
  163.          LOCATE 6, 1
  164.          PRINT "Please Enter Function To List"
  165.          PRINT "(L)ist To List Functions"
  166.          INPUT "Or (Q)uit to End ==> "; FuncTofind$
  167.          LOOP WHILE FuncTofind$ = ""
  168.          IF UCASE$(FuncTofind$) = "QUIT" OR UCASE$(FuncTofind$) = "Q" THEN
  169.           CALL EndOfList
  170.           CALL MainRoutine
  171.          END IF
  172.          IF UCASE$(FuncTofind$) = "LIST" OR UCASE$(FuncTofind$) = "L" THEN
  173.           CALL ListFunc
  174.           CALL EndOfList
  175.           CALL MainRoutine
  176.          END IF
  177.          
  178.          LineCount = 4
  179.          FoundFunc$ = "N"
  180.          
  181.          FindFunc:
  182.          DO
  183.             LINE INPUT #1, Line$
  184.             IF LEFT$(Line$, 8) = "FUNCTION" THEN GOSUB FoundFunc
  185.          LOOP UNTIL EOF(1) OR FoundFunc$ = "Y"
  186.          
  187.          IF FoundFunc$ = "Y" THEN
  188.            PRINT #2, CHR$(12)
  189.            CLOSE #1, #2
  190.            CALL EndOfList
  191.            CALL MainRoutine
  192.          END IF
  193.          
  194.          IF FoundFunc$ = "N" THEN
  195.            PRINT TAB(10); "===> FUNCTION "; UCASE$(FuncTofind$); " Not Found <==="
  196.            SOUND 1000, 2
  197.            PRINT "Please Press Any Key To Continue"
  198.            CALL WaitforAnswer(A$)
  199.            CLOSE #1, #2
  200.            CALL OpenFiles
  201.            GOTO StartFunc
  202.          END IF
  203.          
  204.          FoundFunc:
  205.            SpacePos = INSTR(10, Line$, " ")
  206.            IF SpacePos = 0 THEN
  207.               SpacePos = LEN(Line$)
  208.               SpacePos = SpacePos - 9
  209.               FuncName$ = MID$(Line$, 10, SpacePos)
  210.            ELSEIF SpacePos > 0 THEN
  211.               SpacePos = SpacePos - 9
  212.               FuncName$ = MID$(Line$, 10, SpacePos - 1)
  213.            END IF
  214.            IF UCASE$(FuncName$) = UCASE$(FuncTofind$) THEN
  215.              CALL ProgramTitle
  216.              SubRoutineType = 3
  217.              SubName$ = FuncName$
  218.              CALL SubTitle
  219.              FoundFunc$ = "Y"
  220.              GOSUB PrintFunc
  221.            END IF
  222.          RETURN
  223.          
  224.          PrintFunc:
  225.            DO
  226.              CALL WriteLine
  227.              LINE INPUT #1, Line$
  228.            LOOP UNTIL LEFT$(Line$, 4) = "SUB " OR LEFT$(Line$, 8) = "FUNCTION" OR EOF(1)
  229.          RETURN
  230.          
  231.          END SUB
  232.          
  233.  
  234.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   6
  235.                             ListFunc (Sub Routine) Page   1
  236.          --------------------------------------------------------------------------------
  237.  
  238.          SUB ListFunc
  239.          
  240.          X = 1
  241.          GOSUB FuncHeading
  242.          FuncFound$ = "N"
  243.          
  244.          DO
  245.            LINE INPUT #1, Line$
  246.            IF LEFT$(Line$, 8) = "FUNCTION" THEN
  247.              GOSUB ListFunc
  248.              FuncFound$ = "Y"
  249.            END IF
  250.          LOOP WHILE NOT EOF(1)
  251.          
  252.          IF FuncFound$ = "N" THEN PRINT TAB(31); "No Functions Found"
  253.          CALL EndOfList
  254.          CLOSE #1
  255.          OPEN FileName$ FOR INPUT AS #1
  256.          CALL FunctionList
  257.          
  258.          ListFunc:
  259.            SpacePos = INSTR(10, Line$, " ")
  260.            IF SpacePos = 0 THEN
  261.               SpacePos = LEN(Line$)
  262.               SpacePos = SpacePos - 9
  263.               FuncName$ = MID$(Line$, 10, SpacePos)
  264.            ELSEIF SpacePos > 0 THEN
  265.                   SpacePos = SpacePos - 9
  266.                   FuncName$ = MID$(Line$, 10, SpacePos - 1)
  267.            END IF
  268.          PRINT FuncName$
  269.          X = X + 1
  270.          IF X > 10 THEN
  271.            CALL EndOfList
  272.            GOSUB FuncHeading
  273.            X = 1
  274.          END IF
  275.          RETURN
  276.          
  277.          FuncHeading:
  278.            CALL ScreenTitle
  279.            PRINT TAB(31); "List Of Functions"
  280.            PRINT TAB(31); "-----------------"
  281.          RETURN
  282.          
  283.          END SUB
  284.          
  285.  
  286.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   7
  287.                             ListSubs (Sub Routine) Page   1
  288.          --------------------------------------------------------------------------------
  289.  
  290.          SUB ListSubs
  291.          
  292.          X = 1
  293.          GOSUB SubHeading
  294.          SubFound$ = "N"
  295.          
  296.          DO
  297.            LINE INPUT #1, Line$
  298.            IF LEFT$(Line$, 4) = "SUB " THEN
  299.              GOSUB ListSub
  300.              SubFound$ = "Y"
  301.            END IF
  302.          LOOP WHILE NOT EOF(1)
  303.          
  304.          IF SubFound$ = "N" THEN PRINT TAB(30); "No SubRoutines Found"
  305.          CALL EndOfList
  306.          CLOSE #1
  307.          OPEN FileName$ FOR INPUT AS #1
  308.          CALL SubRoutineList
  309.          
  310.          ListSub:
  311.            SpacePos = INSTR(5, Line$, " ")
  312.            IF SpacePos = 0 THEN
  313.               SpacePos = LEN(Line$)
  314.               SpacePos = SpacePos - 4
  315.               SubName$ = MID$(Line$, 5, SpacePos)
  316.            ELSEIF SpacePos > 0 THEN
  317.                   SpacePos = SpacePos - 4
  318.                   SubName$ = MID$(Line$, 5, SpacePos - 1)
  319.            END IF
  320.          PRINT SubName$
  321.          X = X + 1
  322.          IF X > 10 THEN
  323.            CALL EndOfList
  324.            GOSUB SubHeading
  325.            X = 1
  326.          END IF
  327.          RETURN
  328.          
  329.          SubHeading:
  330.            CALL ScreenTitle
  331.            PRINT TAB(30); "List Of SubRoutines"
  332.            PRINT TAB(30); "-------------------"
  333.          RETURN
  334.          
  335.          END SUB
  336.          
  337.  
  338.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   8
  339.                             MainModuleList (Sub Routine) Page   1
  340.          --------------------------------------------------------------------------------
  341.  
  342.          SUB MainModuleList
  343.          
  344.          LineCount = 4
  345.          START$ = "Y"
  346.          SubName$ = FileName$
  347.          CALL ProgramTitle
  348.          SubRoutineType = 1
  349.          CALL SubTitle
  350.          
  351.          DO
  352.           LINE INPUT #1, Line$
  353.            IF LEFT$(Line$, 4) = "SUB " AND (START$ = "Y" OR START$ = "N") THEN
  354.              IF LEFT$(Line$, 8) = "FUNCTION" AND (START$ = "Y" OR START$ = "N") THEN
  355.                PRINT #2, TAB(10); "No Main Module"
  356.                CLOSE #1
  357.                CALL EndOfList
  358.                CALL MainRoutine
  359.              END IF
  360.            END IF
  361.          START$ = "N"
  362.          IF LEFT$(Line$, 4) = "SUB " OR LEFT$(Line$, 8) = "FUNCTION" THEN EXIT DO
  363.           CALL WriteLine
  364.          LOOP WHILE NOT EOF(1)
  365.          
  366.          PRINT #2, CHR$(12)
  367.          CLOSE #1, #2
  368.          CALL EndOfList
  369.          CALL MainRoutine
  370.          
  371.          END SUB
  372.          
  373.  
  374.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page   9
  375.                             MainRoutine (Sub Routine) Page   1
  376.          --------------------------------------------------------------------------------
  377.  
  378.          SUB MainRoutine
  379.          
  380.          FullPageCount = 1
  381.          subPageCount = 1
  382.          LineCount = 4
  383.          
  384.          CALL ScreenTitle
  385.          DO
  386.          LOCATE 6, 1
  387.          PRINT "Please Enter Program To List"
  388.          INPUT "Or (Q)uit To End ==> "; FileName$
  389.          LOOP WHILE FileName$ = ""
  390.          IF UCASE$(FileName$) = "QUIT" OR UCASE$(FileName$) = "Q" THEN CALL EojRoutine
  391.          FileName$ = UCASE$(FileName$ + ".BAS")
  392.          
  393.          CALL OpenFiles
  394.          
  395.          DO
  396.          CALL ScreenTitle
  397.          PRINT TAB(22); "(1) Complete": PRINT ""
  398.          PRINT TAB(22); "(2) Main Moudule": PRINT
  399.          PRINT TAB(22); "(3) SubRoutine": PRINT
  400.          PRINT TAB(22); "(4) Function": PRINT
  401.          PRINT TAB(22); "(5) Quit"
  402.          Retry:
  403.          LOCATE 16, 1
  404.          PRINT "Please Enter Type Of Listing You Want ==> "
  405.          LOCATE 16, 43, 1
  406.          CALL WaitforAnswer(A$)
  407.          Answer = VAL(A$)
  408.          LOCATE 16, 43, 1
  409.          PRINT A$
  410.          SELECT CASE Answer
  411.           CASE IS = 1
  412.             LOCATE 17, 1
  413.             PRINT "                          "
  414.             CALL CompleteList
  415.             CALL EndOfList
  416.           CASE IS = 2
  417.             LOCATE 17, 1
  418.             PRINT "                          "
  419.             CALL MainModuleList
  420.             CALL EndOfList
  421.           CASE IS = 3
  422.             CALL SubRoutineList
  423.             CALL EndOfList
  424.           CASE IS = 4
  425.             CALL FunctionList
  426.             CALL EndOfList
  427.           CASE IS = 5
  428.             CALL EojRoutine
  429.           CASE ELSE
  430.             LOCATE 17, 1
  431.             SOUND 1000, 2
  432.             PRINT "==> Invalid Selection <=="
  433.             GOTO Retry
  434.          END SELECT
  435.          LOOP
  436.          
  437.          END SUB
  438.          
  439.  
  440.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  10
  441.                             OpenFiles (Sub Routine) Page   1
  442.          --------------------------------------------------------------------------------
  443.  
  444.          SUB OpenFiles
  445.          
  446.          OPEN FileName$ FOR INPUT AS #1
  447.          DotPos = INSTR(FileName$, ".")
  448.          OutName$ = LEFT$(FileName$, DotPos - 1)
  449.          OutName$ = OutName$ + ".LST"
  450.          OPEN OutName$ FOR OUTPUT AS #2
  451.          
  452.          END SUB
  453.          
  454.  
  455.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  11
  456.                             ProgramTitle (Sub Routine) Page   1
  457.          --------------------------------------------------------------------------------
  458.  
  459.          SUB ProgramTitle
  460.          
  461.          PRINT #2, CHR$(12)
  462.          PRINT #2, TAB(10); "Program Listing Of "; FileName$;
  463.          PRINT #2, " As Of "; Today$; " At "; TheTime$;
  464.          PRINT #2, "            Page "; USING "###"; FullPageCount
  465.          FullPageCount = FullPageCount + 1
  466.          
  467.          END SUB
  468.          
  469.  
  470.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  12
  471.                             ScreenTitle (Sub Routine) Page   1
  472.          --------------------------------------------------------------------------------
  473.  
  474.          SUB ScreenTitle
  475.          
  476.          CLS
  477.          COLOR 15, 1
  478.          PRINT "DATE = "; DATE$;
  479.          LOCATE 1, 66
  480.          PRINT "TIME = "; TIME$
  481.          PRINT
  482.          PRINT TAB(22); "Qbasic Or QuickBasic Program Lister"
  483.          PRINT TAB(22); "-----------------------------------"
  484.          
  485.          END SUB
  486.          
  487.  
  488.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  13
  489.                             SplitLine (Sub Routine) Page   1
  490.          --------------------------------------------------------------------------------
  491.  
  492.          SUB SplitLine
  493.          
  494.          LineLen = LEN(Line$)
  495.          LinePos = 0
  496.          LastBlank = 1
  497.          
  498.          DO WHILE LastBlank <> 0
  499.          IF LastBlank <> 0 THEN SaveLastBlank = LastBlank
  500.          LastBlank = INSTR(LastBlank + 1, Line$, " ")
  501.          IF LastBlank >= 80 THEN EXIT DO ELSE LinePos = LastBlank
  502.          LOOP
  503.          
  504.          IF LastBlank = 0 THEN LinePos = SaveLastBlank
  505.          IF SaveLastBlank = 4 THEN LinePos = 80
  506.          Line1$ = MID$(Line$, 1, LinePos - 1)
  507.          Line2$ = MID$(Line$, LinePos + 1, LineLen)
  508.          
  509.          END SUB
  510.          
  511.  
  512.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  14
  513.                             SubRoutineList (Sub Routine) Page   1
  514.          --------------------------------------------------------------------------------
  515.  
  516.          SUB SubRoutineList
  517.          
  518.          StartSub:
  519.          CALL ScreenTitle
  520.          DO
  521.          LOCATE 6, 1
  522.          PRINT "Please Enter SubRoutine To List"
  523.          PRINT "(L)ist To List SubRoutines"
  524.          INPUT "Or (Q)uit to End ==> "; SubToFind$
  525.          LOOP WHILE SubToFind$ = ""
  526.          IF UCASE$(SubToFind$) = "QUIT" OR UCASE$(SubToFind$) = "Q" THEN
  527.           CLOSE #1, #2
  528.           CALL EndOfList
  529.           CALL MainRoutine
  530.          END IF
  531.          IF UCASE$(SubToFind$) = "LIST" OR UCASE$(SubToFind$) = "L" THEN
  532.           CALL ListSubs
  533.          END IF
  534.          
  535.          LineCount = 4
  536.          FoundSub$ = "N"
  537.          
  538.          FindSub:
  539.          DO
  540.             LINE INPUT #1, Line$
  541.             IF LEFT$(Line$, 4) = "SUB " THEN GOSUB FoundSub
  542.          LOOP UNTIL EOF(1) OR FoundSub$ = "Y"
  543.          
  544.          IF FoundSub$ = "Y" THEN
  545.            PRINT #2, CHR$(12)
  546.            CLOSE #1, #2
  547.            CALL EndOfList
  548.            CALL MainRoutine
  549.          END IF
  550.          
  551.          IF FoundSub$ = "N" THEN
  552.            PRINT TAB(10); "===> Sub Routine "; UCASE$(SubToFind$); " Not Found <==="
  553.            SOUND 1000, 2
  554.            PRINT "Please Press Any Key To Continue"
  555.            CALL WaitforAnswer(A$)
  556.            CLOSE #1, #2
  557.            CALL OpenFiles
  558.            GOTO StartSub
  559.          END IF
  560.          
  561.          FoundSub:
  562.            SpacePos = INSTR(5, Line$, " ")
  563.            IF SpacePos = 0 THEN
  564.               SpacePos = LEN(Line$)
  565.               SpacePos = SpacePos - 4
  566.               SubName$ = MID$(Line$, 5, SpacePos)
  567.            ELSEIF SpacePos > 0 THEN
  568.               SpacePos = SpacePos - 4
  569.               SubName$ = MID$(Line$, 5, SpacePos - 1)
  570.            END IF
  571.            IF UCASE$(SubName$) = UCASE$(SubToFind$) THEN
  572.              CALL ProgramTitle
  573.              SubRoutineType = 2
  574.              CALL SubTitle
  575.              FoundSub$ = "Y"
  576.              GOSUB PrintSub
  577.            END IF
  578.          RETURN
  579.          
  580.          PrintSub:
  581.            DO
  582.              CALL WriteLine
  583.              LINE INPUT #1, Line$
  584.            LOOP UNTIL LEFT$(Line$, 4) = "SUB " OR LEFT$(Line$, 8) = "FUNCTION" OR EOF(1)
  585.          RETURN
  586.          
  587.          END SUB
  588.          
  589.  
  590.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  15
  591.                             SubTitle (Sub Routine) Page   1
  592.          --------------------------------------------------------------------------------
  593.  
  594.          SUB SubTitle
  595.          
  596.          IF SubRoutineType = 1 THEN SubType$ = "Main Module"
  597.          IF SubRoutineType = 2 THEN SubType$ = "Sub Routine"
  598.          IF SubRoutineType = 3 THEN SubType$ = "Function"
  599.          
  600.          PRINT #2, TAB(29); SubName$; " ("; SubType$; ")";
  601.          PRINT #2, " Page "; USING "###"; subPageCount
  602.          PRINT #2, TAB(10); STRING$(80, 45)
  603.          PRINT #2,
  604.          subPageCount = subPageCount + 1
  605.          LineCount = 4
  606.          
  607.          END SUB
  608.          
  609.  
  610.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  16
  611.                             WaitforAnswer (Sub Routine) Page   1
  612.          --------------------------------------------------------------------------------
  613.  
  614.          SUB WaitforAnswer (A$)
  615.          
  616.          Answer$ = ""
  617.          A$ = ""
  618.           DO
  619.             A$ = UCASE$(INKEY$)
  620.           LOOP WHILE A$ = ""
  621.          
  622.          END SUB
  623.          
  624.  
  625.          Program Listing Of PROGLIST.BAS As Of 01-20-1992 At 11:20:27            Page  17
  626.                             WriteLine (Sub Routine) Page   1
  627.          --------------------------------------------------------------------------------
  628.  
  629.          SUB WriteLine
  630.           
  631.          IF LEN(Line$) > 80 THEN
  632.             CALL SplitLine
  633.             PRINT #2, TAB(10); Line1$
  634.             PRINT #2, TAB(4); "<<*>>  ";
  635.             PRINT #2, Line2$
  636.             LineCount = LineCount + 2
  637.          END IF
  638.          IF LEN(Line$) <= 80 THEN
  639.             PRINT #2, TAB(10); Line$
  640.             LineCount = LineCount + 1
  641.          END IF
  642.          IF LineCount = 82 THEN
  643.             CALL ProgramTitle
  644.             CALL SubTitle
  645.          END IF
  646.          
  647.          END SUB
  648.          
  649.  
  650.