home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 214_01 / xshowfns.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  15.4 KB  |  937 lines
  1. /*XSHOWFNS.C   VERS:- 01.00  DATE:- 09/26/86  TIME:- 09:37:48 PM */
  2. /*
  3. %CC1 $1.C 
  4. %CLINK XSHOWR XSHOWFNS WILDEXP -F CHARFUN STRFUN -S -E5500
  5. */
  6. /* 
  7. Description:
  8.  
  9. Functions for XSHOWR.C
  10.  
  11.  
  12. By J.A. Rupley, Tucson, Arizona
  13. Coded for BDS C compiler, version 1.50a
  14. */
  15.  
  16. #include <bdscio.h>
  17.  
  18. #include <xshow.h>
  19.  
  20.  
  21.         /*page eject*/
  22.  
  23. int down_block()
  24. {
  25.     gotop_display(0);
  26.     backup(2);
  27.     if (disp_pntr > mid_addr)
  28.         disp_pntr = mid_addr;
  29.     else
  30.     {
  31.         if (prev_block())
  32.         {
  33.             disp_pntr = start_addr;
  34.             return -1;
  35.         }
  36.         else
  37.             disp_pntr++;
  38.     }
  39.     disp_skip(0);
  40.     return 0;
  41. }
  42.  
  43.  
  44. int up_block()
  45. {
  46.     gotop_display(0);
  47.     if (disp_pntr < mid_addr && end_addr > mid_addr)
  48.         disp_pntr = mid_addr;
  49.     else
  50.         if (next_block())
  51.         {
  52.             while (!disp_skip(0))
  53.                 ;
  54.             if (backup(TLENGTH))
  55.                 disp_pntr = start_addr;
  56.             return -1;
  57.         }
  58.     disp_skip(0);
  59.     return 0;
  60. }
  61.  
  62.  
  63.         /*page eject*/
  64.  
  65. int gotop_display(display)
  66. int display;
  67. {
  68.     if (!top_flag)
  69.         backup(TLENGTH);
  70.     if (display)
  71.         return disp_screen();
  72.     top_flag = 1;
  73.     return 0;
  74. }
  75.  
  76.  
  77. int gobot_display(display)
  78. int display;
  79. {
  80.     int temp;
  81.  
  82.     if (top_flag)
  83.     {
  84.         temp = TLENGTH;
  85.         while (temp--)
  86.             disp_skip(0);
  87.     }
  88.     if (display)
  89.         return disp_screen();
  90.     top_flag = 0;
  91.     return 0;
  92. }
  93.  
  94.  
  95. int disp_screen()
  96. {
  97.     int i, temp;
  98.  
  99.     CLEAR;
  100.     for (temp = -TLENGTH; temp; temp++)
  101.         if (disp_skip(1))
  102.             break;
  103.     CUR_BOTTOM;
  104.     top_flag = 0;
  105.     return temp;
  106. }
  107.  
  108.  
  109. int backup(lines)
  110. int lines;
  111. {
  112.     char c;
  113.  
  114.     lines++;
  115.     while (lines--)
  116.     {
  117.         c = 0;
  118.         while (c != '\n')
  119.         {
  120.             c = (*disp_pntr & 0x7f);
  121.             if (pntr_change(-1))
  122.                 return -1;
  123.         }
  124.     }
  125.     disp_skip(0);
  126.     return 0;
  127. }
  128.  
  129.  
  130. int disp_skip(display)
  131. int display;
  132. {
  133.     int charcount;
  134.     int temp;
  135.     char c;
  136.  
  137.     c = charcount = 0;
  138.     while (c != '\n')
  139.     {
  140.         if ((c = (*disp_pntr & 0x7f)) >= 0x20)
  141.         {
  142.             if (display && ++charcount > tabcount
  143.                 && charcount <= (tabcount + TWIDTH))
  144.                 b_putchar(c);
  145.         }
  146.         else
  147.             {
  148.             switch (c)
  149.             {
  150.             case CPMEOF :
  151.                 return -1;
  152.             case '\n' :
  153.                 if (display)
  154.                     b_putchar('\n');
  155.             case '\r' :
  156.                 charcount = 0;
  157.                 if (display)
  158.                     b_putchar('\r');
  159.                 break;
  160.             case '\t' :
  161.                 if (display)
  162.                 {
  163.                     temp = (TAB_SPACES - charcount % TAB_SPACES);
  164.                     while (temp--)
  165.                         if (++charcount > tabcount && charcount <= (tabcount + TWIDTH))
  166.                             b_putchar(SPACE);
  167.                 }
  168.                 break;
  169.             default :
  170.                 if (display && ++charcount > tabcount
  171.                     && charcount <= (tabcount + TWIDTH - 1))
  172.                 {
  173.                     b_putchar('^');
  174.                     ++charcount;
  175.                     b_putchar(c += 0x40);
  176.                 }
  177.             }
  178.         }
  179.         if (pntr_change(1))
  180.             return -1;
  181.     }
  182.     return 0;
  183. }
  184.  
  185.  
  186.         /*page eject*/
  187.  
  188. int load_buffer()
  189. {
  190.     int temp;
  191.  
  192.     seek(fd, 0, 0);
  193.     if ((temp = read(fd, start_addr, NSECS * 2)) == ERROR)
  194.         error("Read error in load_buffer().");
  195.  
  196.     start_flag = 1;
  197.     disp_pntr = start_addr;
  198.     disp_sec = temp;
  199.     end_set(temp);
  200.     return 0;
  201. }
  202.  
  203.  
  204. int next_block()
  205. {
  206.     int temp;
  207.  
  208.     if (end_flag)
  209.         return -1;
  210.  
  211.     movmem(mid_addr, start_addr, NSECS * SECSIZ);
  212.  
  213.     seek(fd, disp_sec, 0);
  214.     if ((temp = read(fd, mid_addr, NSECS)) == ERROR)
  215.         error("Read error in next_block().");
  216.  
  217.     start_flag = 0;
  218.     disp_pntr = mid_addr;
  219.     disp_sec += temp;
  220.     end_set(temp + NSECS);
  221.     return 0;
  222. }
  223.  
  224.  
  225. int prev_block()
  226. {
  227.     int temp;
  228.  
  229.     if (start_flag)
  230.         return -1;
  231.  
  232.     if ((temp = disp_sec % NSECS) == 0)
  233.         temp = NSECS * 3;
  234.     else
  235.         temp += NSECS * 2;
  236.  
  237.     if (temp >= disp_sec)
  238.     {
  239.         load_buffer();
  240.         disp_pntr = mid_addr - 1;
  241.         return 0;
  242.     }
  243.  
  244.     movmem(start_addr, mid_addr, NSECS * SECSIZ);
  245.  
  246.     seek(fd, (disp_sec -= temp), 0);
  247.     if ((read(fd, start_addr, NSECS)) == ERROR)
  248.         error("Read error in prev_block().");
  249.  
  250.     start_flag = 0;
  251.     disp_sec += 2 * NSECS;
  252.     disp_pntr = mid_addr - 1;
  253.     end_set(2 * NSECS);
  254.     return 0;
  255. }
  256.  
  257.  
  258. void end_set(offset)
  259. int offset;
  260. {
  261.     char *temp_pntr;
  262.  
  263.     end_addr = start_addr + offset * SECSIZ;
  264.     *end_addr = CPMEOF;
  265.  
  266.     if (disp_sec != end_sec)
  267.         end_flag = 0;
  268.     else
  269.         {
  270.         if (offset)
  271.             temp_pntr = end_addr - SECSIZ;
  272.         else
  273.             temp_pntr = start_addr;
  274.         while (*temp_pntr != CPMEOF)
  275.             temp_pntr++;
  276.         if (*--temp_pntr != '\n')
  277.         {
  278.             *++temp_pntr = '\n';
  279.             *++temp_pntr = CPMEOF;
  280.             end_addr = temp_pntr;
  281.         }
  282.         end_flag = 1;
  283.     }
  284. }
  285.  
  286.  
  287.         /* page eject*/
  288.  
  289. int change_load(n)
  290. int n;
  291. {
  292.     int temp;
  293.  
  294.     end_flag = 0;
  295.  
  296.     if ((n < 0) && ((temp = disp_sec % NSECS) != 0))
  297.     {
  298.         temp = disp_sec - temp;
  299.         n++;
  300.     }
  301.     else
  302.         temp = disp_sec;
  303.  
  304.     if ((temp += n * NSECS) >= end_sec)
  305.     {
  306.         if ((end_sec % NSECS) == 0)
  307.             disp_sec = end_sec - NSECS * 2;
  308.         else
  309.             disp_sec = end_sec - NSECS - end_sec % NSECS;
  310.         if (disp_sec <= 0)
  311.             load_buffer();
  312.         else
  313.         {
  314.             seek(fd, disp_sec, 0);
  315.             next_block();
  316.             next_block();
  317.             disp_skip(0);
  318.             if ((temp - end_sec) < NSECS)
  319.                 return 1;
  320.         }
  321.         while (!up_block())
  322.             ;
  323.         return 1;
  324.     }
  325.     else
  326.         if ((temp -= 2 * NSECS) >= NSECS)
  327.     {
  328.         seek(fd, (disp_sec = temp), 0);
  329.         next_block();
  330.         next_block();
  331.     }
  332.     else
  333.     {
  334.         load_buffer();
  335.         if (temp < 0)
  336.             return -1;
  337.         else
  338.             disp_pntr = mid_addr;
  339.     }
  340.     disp_skip(0);
  341.     return 0;
  342. }
  343.  
  344.  
  345.         /* page eject*/
  346.  
  347. int read_pattern()
  348. {
  349.     int i;
  350.     char *tt;
  351.  
  352.     CUR_UP;
  353.     CUR_UP;
  354.     CUR_UP;
  355.     CUR_UP;
  356.     ERA_EOP;
  357.     printf("\n:::Old decoded pattern: %s", pattern);
  358.     printf("\n:::Old input string...: %s", old_pattern);
  359.     printf("\n:::Enter string + -cr-: ");
  360.     if (strlen(gets(input_pattern)))
  361.     {
  362.         strcpy(old_pattern, input_pattern);
  363.         upper_case = 0;
  364.         if (!pat_decode(input_pattern, pattern))
  365.             return -1;
  366.         for (tt = pattern; upper_case && *tt; tt++)
  367.             *tt = toupper(*tt);
  368.     }
  369.     else
  370.     {
  371.         printf("\n\nDo you want to abort?  Y / (N = any other char):");
  372.         if (toupper(b_getchar()) == 'Y')
  373.             return -1;
  374.     }
  375.     return 0;
  376. }
  377.  
  378.  
  379. void srch_display()
  380. {
  381.     p_srch1 = f_pntr;
  382.     p_srch2 = n_pntr;
  383.     backup(10);
  384.     if (disp_sec < f_sec)
  385.     {
  386.         p_srch1 += NSECS * SECSIZ;
  387.         p_srch2 += NSECS * SECSIZ;
  388.     }
  389.     srch_out = 2;
  390.     REV_ON;
  391.     disp_screen();
  392.     srch_out = 0;
  393.     REV_OFF;
  394. }
  395.  
  396.  
  397. int pat_decode(pat, str)
  398. char *pat;
  399. char *str;
  400. {
  401.     int c;
  402.     char *bad;
  403.  
  404.     j = i = 0;
  405.     while (c = pat[i++])
  406.     {
  407.         if (c == '!')
  408.         {
  409.             for (c = pat[i++], bad = "*?!"; *bad; bad++)
  410.                 if (*bad == c)
  411.                     error("Bad pattern after !.");
  412.             decode(c, pat, str, 1);
  413.         }
  414.         else
  415.             decode(c, pat, str, 0);
  416.     }
  417.     str[j] = 0;
  418.     return j;
  419. }
  420.  
  421.  
  422. void decode(c, pat, str, not_flag)
  423. int c, not_flag;
  424. char *pat, *str;
  425. {
  426.     switch (c)
  427.     {
  428.     case '$' :
  429.         upper_case = TRUE;
  430.         break;
  431.     case '*' :
  432.         str[j++] = SKIPANY;
  433.         break;
  434.     case '?' :
  435.         str[j++] = SKIPONE;
  436.         break;
  437.     case '@' :
  438.         str[j++] = ANYALPHA;
  439.         break;
  440.     case '#' :
  441.         str[j++] = ANYNUMBER;
  442.         break;
  443.     case '^' :
  444.         c = pat[i++];
  445.         if (c > 0x7f || c <= 0x40)
  446.             error("Illegal ^ character.");
  447.         str[j++] = toupper(c) - 0x40;
  448.         break;
  449.     case '\\' :
  450.         c = pat[i++];
  451.         if (c == 0)
  452.             error("\\ requires character.");
  453.         switch (toupper(c))
  454.         {
  455.         case 'N' :
  456.             c = '\n';
  457.             break;
  458.         case 'F' :
  459.             c = '\f';
  460.             break;
  461.         case 'R' :
  462.             c = '\r';
  463.             break;
  464.         case 'T' :
  465.             c = '\t';
  466.             break;
  467.         case 'B' :
  468.             c = '\b';
  469.             break;
  470.         }
  471.     default :
  472.         str[j++] = c;
  473.     }
  474.     if (not_flag)
  475.         str[j - 1] |= 0x80;
  476. }
  477.  
  478.  
  479. void set_srch(to, from)
  480. int to, from;
  481. {
  482.     char *temp_pntr;
  483.     int temp_sec;
  484.  
  485.     switch (from)
  486.     {
  487.     case SRCH_CHAR :
  488.         temp_sec = disp_sec;
  489.         temp_pntr = disp_pntr;
  490.         break;
  491.     case FIRST :
  492.         temp_sec = f_sec;
  493.         temp_pntr = f_pntr;
  494.         break;
  495.     case NEXT :
  496.         temp_sec = n_sec;
  497.         temp_pntr = n_pntr;
  498.         break;
  499.     }
  500.  
  501.     switch (to)
  502.     {
  503.     case SRCH_CHAR :
  504.         disp_sec = temp_sec;
  505.         change_load(0);
  506.         disp_pntr = temp_pntr;
  507.         break;
  508.     case FIRST :
  509.         f_sec = temp_sec;
  510.         f_pntr = temp_pntr;
  511.         break;
  512.     case NEXT :
  513.         n_sec = temp_sec;
  514.         n_pntr = temp_pntr;
  515.         break;
  516.     }
  517. }
  518.  
  519.  
  520.         /* page eject*/
  521.  
  522. int find()
  523. {
  524.     int temp;
  525.  
  526.     i = 0;
  527.     j = 0;
  528.     set_srch(SRCH_CHAR, FIRST);
  529.     temp = PAUSE_COUNT * 1000;
  530.  
  531.     switch (setjmp(jbufsrch))
  532.     {
  533.     case NOTFOUND :
  534.         return NOTFOUND;
  535.     case FOUND :
  536.         set_srch(NEXT, SRCH_CHAR);
  537.         return FOUND;
  538.     }
  539.  
  540. loop :
  541.     if (!temp--)
  542.     {
  543.         if (KBHIT)
  544.         {
  545.             return NOTFOUND;
  546.         }
  547.         temp = PAUSE_COUNT * 1000;
  548.         printf("\rSearching......");
  549.     }
  550.  
  551.     switch (search(*disp_pntr & 0x7f))
  552.     {
  553.     case NOTFOUND :
  554.     case NOTMATCH :
  555.         i = 0;
  556.         j = 0;
  557.         if (disp_pntr > f_pntr)
  558.         {
  559.             disp_pntr = ++f_pntr;
  560.             goto loop;
  561.         }
  562.         else
  563.         {
  564.             if (disp_sec != f_sec)
  565.             {
  566.                 disp_sec = f_sec;
  567.                 change_load(0);
  568.             }
  569.             disp_pntr = f_pntr;
  570.             if (pntr_change(1))
  571.                 return NOTFOUND;
  572.             f_sec = disp_sec;
  573.             f_pntr = disp_pntr;
  574.             if (*disp_pntr == 0x1a)
  575.                 return NOTFOUND;
  576.             goto loop;
  577.         }
  578.     case MATCH :
  579.         j++;
  580.         if (!i++)
  581.         {
  582.             f_sec = disp_sec;
  583.             f_pntr = disp_pntr;
  584.         }
  585.         if (pntr_change(1))
  586.             return NOTFOUND;
  587.         if (!pattern[i])
  588.             longjmp(jbufsrch, FOUND);
  589.         if (*disp_pntr == 0x1a)
  590.             return NOTFOUND;
  591.         goto loop;
  592.     }
  593. }
  594.  
  595.  
  596. int pntr_change(direction)
  597. int direction;
  598. {
  599.     if (direction > 0)
  600.     {
  601.         if (++disp_pntr >= end_addr)
  602.         {
  603.             if (next_block())
  604.             {
  605.                 disp_pntr--;
  606.                 return -1;
  607.             }
  608.         }
  609.     }
  610.     else
  611.         {
  612.         if (--disp_pntr < start_addr)
  613.             if (prev_block())
  614.             {
  615.                 disp_pntr++;
  616.                 return -1;
  617.             }
  618.     }
  619.     return 0;
  620. }
  621.  
  622.  
  623.         /*page eject*/
  624.  
  625. int search(c)
  626. int c;
  627. {
  628.     int tempx, isave;
  629.     char *temp;
  630.  
  631.     if (j > 2 * MAXLINE)
  632.         return NOTFOUND;
  633.     if (pattern[i] & 0x80)
  634.         switch (pattern[i])
  635.         {
  636.         case ANYALPHA | 0x80 :
  637.             if (!isalpha(c))
  638.                 return MATCH;
  639.             else
  640.                 return NOTMATCH;
  641.         case ANYNUMBER | 0x80 :
  642.             if (!isdigit(c))
  643.                 return MATCH;
  644.             else
  645.                 return NOTMATCH;
  646.         case SKIPANY :
  647.             if (!pattern[++i])
  648.                 longjmp(jbufsrch, FOUND);
  649.             isave = i;
  650. loop :
  651.             i = isave;
  652. loop2 :
  653.             switch (search(*disp_pntr & 0x7f))
  654.             {
  655.             case MATCH :
  656.                 j++;
  657.                 if (!pattern[++i])
  658.                 {
  659.                     i--;
  660.                     return MATCH;
  661.                 }
  662.                 if (pntr_change(1))
  663.                     longjmp(jbufsrch, NOTFOUND);
  664.                 if (c == 0x1a)
  665.                     longjmp(jbufsrch, NOTFOUND);
  666.                 goto loop2;
  667.             case NOTMATCH :
  668.                 j++;
  669.                 if (pntr_change(1))
  670.                     longjmp(jbufsrch, NOTFOUND);
  671.                 if (c == 0x1a)
  672.                 {
  673.                     j--;
  674.                     if (pntr_change(-1))
  675.                         longjmp(jbufsrch, NOTFOUND);
  676.                     return NOTMATCH;
  677.                 }
  678.                 goto loop;
  679.             case NOTFOUND :
  680.                 return NOTFOUND;
  681.             }
  682.         case SKIPONE :
  683.             i++;
  684.             j++;
  685.             if (pntr_change(1))
  686.                 longjmp(jbufsrch, NOTFOUND);
  687.             if (c == 0x1a)
  688.                 longjmp(jbufsrch, NOTFOUND);
  689.             switch (search(*disp_pntr & 0x7f))
  690.             {
  691.             case MATCH :
  692.                 return MATCH;
  693.             case NOTMATCH :
  694.                 j--;
  695.                 if (pntr_change(-1))
  696.                     longjmp(jbufsrch, NOTFOUND);
  697.                 return NOTMATCH;
  698.             case NOTFOUND :
  699.                 return NOTFOUND;
  700.             }
  701.         default :
  702.             if (upper_case && (c >= 'a')
  703.                 && (c <= 'z'))
  704.                 if ((pattern[i] & 0x7f) != (c - 0x20))
  705.                     return MATCH;
  706.             else
  707.                 return NOTMATCH;
  708.             else
  709.                 if ((pattern[i] & 0x7f) != c )
  710.                 return MATCH;
  711.             else
  712.                 return NOTMATCH;
  713.         }
  714.     else
  715.         switch (pattern[i])
  716.     {
  717.     case 0 :
  718.         longjmp(jbufsrch, FOUND);
  719.     case ANYALPHA :
  720.         if (isalpha(c))
  721.             return MATCH;
  722.         else
  723.             return NOTMATCH;
  724.     case ANYNUMBER :
  725.         if (isdigit(c))
  726.             return MATCH;
  727.         else
  728.             return NOTMATCH;
  729.     default :
  730.         if (upper_case && (c >= 'a')
  731.             && (c <= 'z'))
  732.             if (pattern[i] == (c - 0x20))
  733.                 return MATCH;
  734.         else
  735.             return NOTMATCH;
  736.         else
  737.             if (pattern[i] == c)
  738.             return MATCH;
  739.         else
  740.             return NOTMATCH;
  741.     }
  742. }
  743.  
  744.  
  745.         /* page eject */
  746.  
  747. int bad_type(name)
  748. char *name;
  749. {
  750.     char *ss, *tt, *bad;
  751.  
  752.     bad = ".COM.OBJ.BAD.LOG.SYS.OV?.SEN.REL.CRL.LBR.ARC.NDX.DBF.ZIP.ZBA.HEX.DIC.IO .?Q*.";
  753.  
  754.     for (; *name; name++)
  755.         if (*name == '.')
  756.             break;
  757.     for (; *bad; bad++)
  758.         if (*bad == *name)
  759.             for (ss = bad, tt = name;; ss++, tt++)
  760.             {
  761.                 while (*tt == ' ')
  762.                     tt++;
  763.                 while (*ss == ' ')
  764.                     ss++;
  765.                 if (!*tt)
  766.                 {
  767.                     if ((*ss == '.') || (*ss == '*'))
  768.                         return -1;
  769.                     else
  770.                         break;
  771.                 }
  772.                 if ((*ss == '?') || (*ss == '*'))
  773.                     continue;
  774.                 if (*ss != *tt)
  775.                     break;
  776.             }
  777.     return 0;
  778. }
  779.  
  780.  
  781. void error(format)
  782. char *format;
  783. {
  784.     void b_putchar();
  785.  
  786.     CLEAR;
  787.     printf("\n\nXSHOW: ");
  788.     _spr(&format, &b_putchar);
  789.     CUR_BOTTOM;
  790.     longjmp(jbuf, 1);
  791. }
  792.  
  793.  
  794. void printf(format)
  795. char *format;
  796. {
  797.     void b_putchar();
  798.     _spr(&format, &b_putchar);        /* use "_spr" to form the output */
  799. }
  800.  
  801.  
  802. int string_compare(s, t)
  803. char **s, **t;
  804. {
  805.     char *s1, *t1;
  806.  
  807.     for (s1 = *s, t1 = *t; *s1; s1++, t1++)
  808.         if (*t1 != *s1)
  809.             return (*s1 - *t1);
  810.     return 0;
  811. }
  812.  
  813.  
  814. void b_putchar(cc)
  815. int cc;
  816. {
  817.     if (srch_out)
  818.     {
  819.         if (disp_pntr < p_srch1)
  820.         {
  821.             REV_ON;
  822.         }
  823.         else
  824.             if (disp_pntr >= p_srch2 
  825.                 && ((f_sec == n_sec) || (disp_sec == n_sec)))
  826.             {
  827.                 srch_out = 0;
  828.                 REV_ON;
  829.             }
  830.             else
  831.             {
  832.                 REV_OFF;
  833.             }
  834.     }
  835.     if (cc == '\n')
  836.         BIOS_OUTPUT('\r');
  837.     BIOS_OUTPUT(cc);
  838.     if (t || KBHIT)
  839.     {
  840.         if ((t = b_getchar()) == CNTRL_C)
  841.             exit();
  842.         else
  843.             if (t == CNTRL_S)
  844.             {
  845.                 t = 0;
  846.                 while (KBHIT)
  847.                     ;
  848.                 if ((t = b_getchar()) == CNTRL_S)
  849.                     t = 0;
  850.             }
  851.     }
  852. }
  853.  
  854. int b_getchar()
  855. {
  856.     int temp;
  857.  
  858.     if (!t)
  859.         temp = BIOS_INPUT;
  860.     else
  861.     {
  862.         temp = t;
  863.         t = 0;
  864.     }
  865.     return temp;
  866. }
  867.  
  868.  
  869. int wait_count()
  870. {
  871.     int count;
  872.  
  873.     for (count = PAUSE_COUNT * 3300; count; count--)
  874.         if (t || KBHIT)
  875.             break;
  876.     CUR_BOTTOM;
  877.     ERA_EOL;
  878.     return count;
  879. }
  880.  
  881.  
  882. void delay_mess(format)
  883. char *format;
  884. {
  885.     void b_putchar();
  886.  
  887.     if (wait_count())
  888.         return;
  889.     CUR_UP;
  890.     ERA_EOL;
  891.     _spr(&format, &b_putchar);
  892. }
  893.  
  894.  
  895. void pause_mess()
  896. {
  897.     if (wait_count())
  898.         return;
  899.     printf(":::block= %d+%d/%d+%d pntr= %x  file(%d)= %s -- Instruction??",
  900.     disp_sec / NSECS, disp_sec % NSECS, end_sec / NSECS, end_sec % NSECS, (disp_pntr - start_addr), x, file);
  901.     while (!(t || KBHIT))
  902.         ;
  903. }
  904.  
  905.  
  906. void help_mess()
  907. {
  908.     CLEAR;
  909.  
  910.     printf("USAGE:   XSHOW    [d?:]afn.aft1  [[!][du:]afn.aft2  ..etc..]\n");
  911.     printf(" Wild chars; !=NOT operator; multiple files (white space for sepn); du: & d?:.\n");
  912.     printf("\n");
  913.     printf("Instructions:   H (also QH and KH) =  display this help message\n");
  914.     printf("\n");
  915.     printf("D  =  + line               QP  =  set display at previous position    \n");
  916.     printf("S  =  - line               \n");
  917.     printf("C  =  + screen             QC  =  set display at end of file                 \n");
  918.     printf("R  =  - screen             QR  =  set display at start of file               \n");
  919.     printf("X  =  + block              QXn =  + n blocks        |* block = 2K characters *|\n");
  920.     printf("E  =  - block              QEn =  - n blocks        |* use -cr- to terminate *|\n");
  921.     printf("F  =  tab forward                                   |* an  <n> or <s>  entry *|\n");
  922.     printf("A  =  tab backward         QFs =  search for pattern <s>  (-L- for disp + cont)\n");
  923.     printf("L  =  repeat command       QQ  =  continous repeat   (1=fast, 9=slow, 0=freeze)\n");
  924.     printf("\n");
  925.     printf("KX  =  exit to CPM\n");
  926.     printf("KB  =  enter previous file          KNn =  enter file n of file_list         \n");
  927.     printf("KK  =  enter next file              KO  =  display file_list, with ordinals  \n");
  928.     printf("\n");
  929.     printf("           meta characters allowed in search string <s>:\n");
  930.     printf("^=>ctrl char follows   \\=>C-constant or literal ($,*,etc)   !=>not next char\n");
  931.     printf("@=any alpha    #=any digit    *=any string    ?=any char    $=>no case test");
  932.  
  933.     pause_mess();
  934. }
  935.  
  936.  
  937.