home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 264_01 / nrotxt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-12-31  |  9.6 KB  |  690 lines
  1. /*
  2.  *    Text processing portion of NRO word processor
  3.  *
  4.  *    Stephen L. Browning
  5.  *    5723 North Parker Avenue
  6.  *    Indianapolis, Indiana 46220
  7.  */
  8.  
  9. #include <stdio.h>
  10. #include <ctype.h>
  11. #include "nro.h"
  12. #include "nrocom.c"
  13.  
  14. text(p)
  15. char *p;
  16. {
  17.     int i;
  18.     char wrdbuf[MAXLINE];
  19.  
  20.     if (*p == ' ' || *p == '\n' || *p == '\r')
  21.         leadbl(p);
  22.     expesc(p,wrdbuf);
  23.     if (dc.ulval > 0)
  24.     {
  25.         /*
  26.         *    Because of the way underlining is handled,
  27.         *    MAXLINE should be declared to be three times
  28.         *    larger than the longest expected input line
  29.         *    for underlining.  Since many of the character
  30.         *    buffers use this parameter, a lot of memory
  31.         *    can be allocated when it may not really be
  32.         *    needed.  A MAXLINE of 180 would allow about
  33.         *    60 characters in the output line to be
  34.         *    underlined (remember that only alphanumerics
  35.         *    get underlined - no spaces or punctuation).
  36.         */
  37.         underl(p,wrdbuf,MAXLINE);
  38.         --dc.ulval;
  39.     }
  40.     if (dc.cuval > 0)
  41.     {
  42.         underl(p,wrdbuf,MAXLINE);
  43.         --dc.cuval;
  44.     }
  45.     if (dc.boval > 0)
  46.     {
  47.         bold(p,wrdbuf,MAXLINE);
  48.         --dc.boval;
  49.     }
  50.     if (dc.ceval > 0)
  51.     {
  52.         center(p);
  53.         put(p);
  54.         --dc.ceval;
  55.     }
  56.     else if (*p == '\r' || *p == '\n')
  57.         put(p);             /* all blank line */
  58.     else if (dc.fill == NO)
  59.         put(p);                /* unfilled */
  60.     else
  61.     {
  62.         while ((i = getwrd(p,wrdbuf)) > 0)
  63.         {
  64.             putwrd(wrdbuf);
  65.             p += i;
  66.         }
  67.     }
  68. }
  69.  
  70.  
  71. /*
  72.  *    insert bold face text
  73.  */
  74.  
  75. bold(p0,p1,size)
  76. char *p0, *p1;
  77. int size;
  78. {
  79.     int i, j;
  80.  
  81.     j = 0;
  82.     for (i=0; (p0[i] != '\n') && (j < size-1); ++i)
  83.     {
  84.         if (isalpha(p0[i]) || isdigit(p0[i]))
  85.         {
  86.             p1[j++] = p0[i];
  87.             p1[j++] = '\b';
  88.         }
  89.         p1[j++] = p0[i];
  90.     }
  91.     p1[j++] = '\n';
  92.     p1[j] = '\0';
  93.     while (*p1 != '\0')
  94.         *p0++ = *p1++;
  95.     *p0 = '\0';
  96. }
  97.  
  98.  
  99.  
  100.  
  101. /*
  102.  *    center a line by setting tival
  103.  */
  104.  
  105. center(p)
  106. char *p;
  107. {
  108.     dc.tival = max((dc.rmval + dc.tival - width(p)) >> 1,0);
  109. }
  110.  
  111.  
  112. /*
  113.  *    expand title buffer to include character string
  114.  */
  115.  
  116. expand(p0,c,s)
  117. char *p0;
  118. char c;
  119. char *s;
  120. {
  121.     char tmp[MAXLINE];
  122.     char *p, *q, *r;
  123.  
  124.     p = p0;
  125.     q = tmp;
  126.     while (*p != '\0')
  127.     {
  128.         if (*p == c)
  129.         {
  130.             r = s;
  131.             while (*r != '\0')
  132.                 *q++ = *r++;
  133.         }
  134.         else
  135.             *q++ = *p;
  136.         ++p;
  137.     }
  138.     *q = '\0';
  139.     strcpy(p0,tmp);        /* copy it back */
  140. }
  141.  
  142.  
  143. /*
  144.  *    get field from title
  145.  */
  146.  
  147. char *getfield(p,q,delim)
  148. char *p, *q;
  149. char delim;
  150. {
  151.     while (*p != delim && *p != '\r' && *p != '\n' && *p != '\0')
  152.     {
  153.         *q++ = *p++;
  154.     }
  155.     *q = '\0';
  156.     if (*p == delim)
  157.         ++p;
  158.     return(p);
  159. }
  160.  
  161.  
  162.  
  163. /*
  164.  *    get non-blank word from p0 into p1.
  165.  *    return number of characters processed.
  166.  */
  167.  
  168. getwrd(p0,p1)
  169. char *p0,*p1;
  170. {
  171.     int i;
  172.     char *p, c;
  173.  
  174.     i = 0;
  175.     while (*p0 == ' ' || *p0 == '\t')
  176.     {
  177.         ++i;
  178.         ++p0;
  179.     }
  180.     p = p0;
  181.     while (*p0 != ' ' && *p0 != '\0' && *p0 != '\t')
  182.     {
  183.         if(*p0 == '\n' || *p0 == '\r')
  184.             break;
  185.         *p1 = *p0++;
  186.         ++p1;
  187.         ++i;
  188.     }
  189.     c = *(p1-1);
  190.     if(c == '"')
  191.         c = *(p1-2);
  192.     if (c == '?' || c == '!')
  193.     {
  194.         *p1++ = ' ';
  195.         ++i;
  196.     }
  197.     if (c == '.' && (*p0 == '\n' || *p0 == '\r' || islower(*p)))
  198.     {
  199.         *p1++ = ' ';
  200.         ++i;
  201.     }
  202.     *p1 = '\0';
  203.     return(i);
  204. }
  205.  
  206.  
  207. /*
  208.  *    convert integer to decimal ascii string
  209.  */
  210.  
  211. itoda(value,p,size)
  212. int value;
  213. char *p;
  214. int size;
  215. {
  216.     char c[7];
  217.     int i, j, k;
  218.     int aval;
  219.  
  220.     aval = abs(value);
  221.     c[0] = '\0';
  222.     i = 1;
  223.     do
  224.     {
  225.         c[i++] = (aval % 10) + '0';
  226.         aval /= 10;
  227.     } while (aval > 0 && i <= size);
  228.     if(value < 0 && i <= size)
  229.         c[i++] = '-';
  230.     for(j=0; j<i; ++j)
  231.         *p++ = c[i-j-1];
  232.     return(i);
  233. }
  234.  
  235.  
  236. /*
  237.  *    center title text into print buffer
  238.  */
  239.  
  240. justcntr(p,q,limit)
  241. char *p, *q;
  242. int limit[];
  243. {
  244.     int len;
  245.  
  246.     len = width(p);
  247.     q = &q[(limit[RIGHT] + limit[LEFT] - len) >> 1];
  248.     while(*p != '\0')
  249.         *q++ = *p++;
  250. }
  251.  
  252.  
  253.  
  254. /*
  255.  *    left justify title text into print buffer
  256.  */
  257.  
  258. justleft(p,q,limit)
  259. char *p, *q;
  260. int limit;
  261. {
  262.     q = &q[limit];
  263.     while (*p != '\0')
  264.         *q++ = *p++;
  265. }
  266.  
  267.  
  268. /*
  269.  *    right justify title text into print buffer
  270.  */
  271.  
  272. justrite(p,q,limit)
  273. char *p, *q;
  274. int limit;
  275. {
  276.     int len;
  277.  
  278.     len = width(p);
  279.     q = &q[limit - len];
  280.     while(*p != '\0')
  281.         *q++ = *p++;
  282. }
  283.  
  284.  
  285.  
  286.  
  287. /*
  288.  *    delete leading blanks, set tival
  289.  */
  290.  
  291. leadbl(p)
  292. char *p;
  293. {
  294.     int i,j;
  295.  
  296.     brk();
  297.     for (i=0; p[i] == ' '; ++i)
  298.         ;
  299.     if(p[i] != '\n' && p[i] != '\r')
  300.         dc.tival = i;
  301.     for(j=0; p[i] != '\0'; ++j)
  302.         p[j] = p[i++];
  303.     p[j] = '\0';
  304. }
  305. /*
  306.  *    put out page footer
  307.  */
  308.  
  309. pfoot()
  310. {
  311.     if (dc.prflg == TRUE)
  312.     {
  313.         skip(pg.m3val);
  314.         if (pg.m4val > 0)
  315.         {
  316.             if ((pg.curpag % 2) == 0)
  317.             {
  318.                 puttl(pg.efoot,pg.eflim,pg.curpag);
  319.             }
  320.             else
  321.             {
  322.                 puttl(pg.ofoot,pg.oflim,pg.curpag);
  323.             }
  324.             skip(pg.m4val - 1);
  325.         }
  326.     }
  327. }
  328.  
  329.  
  330.  
  331. /*
  332.  *    put out page header
  333.  */
  334.  
  335. phead()
  336. {
  337.     pg.curpag = pg.newpag;
  338.     if(pg.curpag >= pg.frstpg && pg.curpag <= pg.lastpg)
  339.     {
  340.         dc.prflg = TRUE;
  341.     }
  342.     else
  343.     {
  344.         dc.prflg = FALSE;
  345.     }
  346.     ++pg.newpag;
  347.     if(dc.prflg == TRUE)
  348.     {
  349.         if(pg.m1val > 0)
  350.         {
  351.             skip(pg.m1val - 1);
  352.             if((pg.curpag % 2) == 0)
  353.             {
  354.                 puttl(pg.ehead,pg.ehlim,pg.curpag);
  355.             }
  356.             else
  357.             {
  358.                 puttl(pg.ohead,pg.ohlim,pg.curpag);
  359.             }
  360.         }
  361.         skip(pg.m2val);
  362.     }
  363.     /*
  364.     *    initialize lineno for the next page
  365.     */
  366.     pg.lineno = pg.m1val + pg.m2val + 1;
  367. }
  368.  
  369.  
  370. /*
  371.  *    print character with test for printer
  372.  */
  373.  
  374. prchar(c,fp)
  375. char c;
  376. FILE *fp;
  377. {
  378. /*    if (co.lpr == TRUE)
  379.     {
  380.         bdos(5,c);
  381.     }
  382.     else
  383. */    {
  384.         putc(c,fp);
  385.     }
  386. }
  387.  
  388.  
  389.  
  390.  
  391. /*
  392.  *    put out line with proper spacing and indenting
  393.  */
  394.  
  395. put(p)
  396. char *p;
  397. {
  398.     char os[MAXLINE];
  399.     int j;
  400.  
  401.     if (pg.lineno == 0 || pg.lineno > pg.bottom)
  402.     {
  403.         phead();
  404.     }
  405.     if(dc.prflg == TRUE)
  406.     {
  407.         if (!dc.bsflg)
  408.         {
  409.             if (strkovr(p,os) == TRUE)
  410.             {
  411.                 for(j=0; j<pg.offset; ++j)
  412.                     prchar(' ',pout);
  413.                 for(j=0; j<dc.tival; ++j)
  414.                     prchar(' ',pout);
  415.                 putlin(os,pout);
  416.             }
  417.         }
  418.         for(j=0; j<pg.offset; ++j)
  419.             prchar(' ',pout);
  420.         for(j=0; j<dc.tival; ++j)
  421.             prchar(' ',pout);
  422.         putlin(p,pout);
  423.     }
  424.     dc.tival = dc.inval;
  425.     skip(min(dc.lsval-1,pg.bottom-pg.lineno));
  426.     pg.lineno = pg.lineno + dc.lsval;
  427.     if (pg.lineno > pg.bottom)
  428.         pfoot();
  429. }
  430.  
  431.  
  432. /*
  433.  *    output a null terminated string to the file
  434.  *    specified by pbuf.
  435.  */
  436.  
  437. putlin(p,pbuf)
  438. char *p;
  439. struct buf *pbuf;
  440. {
  441.     while (*p != '\0')
  442.         prchar(*p++,pbuf);
  443. }
  444.  
  445.  
  446.  
  447. /*
  448.  *    put out title or footer
  449.  */
  450.  
  451. puttl(p,lim,pgno)
  452. char *p;
  453. int lim[];
  454. int pgno;
  455. {
  456.     int i;
  457.     char pn[8];
  458.     char t[MAXLINE];
  459.     char h[MAXLINE];
  460.     char delim;
  461.  
  462.     itoda(pgno,pn,6);
  463.     for(i=0; i<MAXLINE; ++i)
  464.         h[i] = ' ';
  465.     delim = *p++;
  466.     p = getfield(p,t,delim);
  467.     expand(t,dc.pgchr,pn);
  468.     justleft(t,h,lim[LEFT]);
  469.     p = getfield(p,t,delim);
  470.     expand(t,dc.pgchr,pn);
  471.     justcntr(t,h,lim);
  472.     p = getfield(p,t,delim);
  473.     expand(t,dc.pgchr,pn);
  474.     justrite(t,h,lim[RIGHT]);
  475.     for(i=MAXLINE-4; h[i] == ' '; --i)
  476.         h[i] = '\0';
  477.     h[++i] = '\n';
  478.     h[++i] = '\r';
  479.     h[++i] = '\0';
  480.     if(strlen(h) > 2)
  481.     {
  482.         for(i=0; i<pg.offset; ++i)
  483.             prchar(' ',pout);
  484.     }
  485.     putlin(h,pout);
  486. }
  487.  
  488.  
  489.  
  490. /*
  491.  *    put word in output buffer
  492.  */
  493.  
  494. putwrd(wrdbuf)
  495. char *wrdbuf;
  496. {
  497.     int w;
  498.     int last;
  499.     int llval;
  500.     char *p0, *p1;
  501.     int nextra;
  502.  
  503.     w = width(wrdbuf);
  504.     last = strlen(wrdbuf) + co.outp;
  505.     llval = dc.rmval - dc.tival;
  506.     if(((co.outp > 0) && ((co.outw + w) > llval)) || (last > MAXLINE))
  507.     {
  508.         last -= co.outp;
  509.         if(dc.juval == YES)
  510.         {
  511.             nextra = llval - co.outw + 1;
  512.             /*
  513.             *    Check whether last word was end of
  514.             *    sentence and modify counts so that
  515.             *    it is right justified.
  516.             */
  517.             if (co.outbuf[co.outp-2] == ' ')
  518.             {
  519.                 --co.outp;
  520.                 ++nextra;
  521.             }
  522.             spread(co.outbuf,co.outp-1,nextra,co.outwds);
  523.             if((nextra > 0) && (co.outwds > 1))
  524.             {
  525.                 co.outp += (nextra - 1);
  526.             }
  527.         }
  528.         brk();
  529.     }
  530.     p0 = wrdbuf;
  531.     p1 = co.outbuf + co.outp;
  532.     while(*p0 != '\0')
  533.         *p1++ = *p0++;
  534.     co.outp = last;
  535.     co.outbuf[co.outp++] = ' ';
  536.     co.outw += w + 1;
  537.     ++co.outwds;
  538. }
  539.  
  540.  
  541. /*
  542.  *    skips the number of lines specified by n.
  543.  */
  544.  
  545. skip(n)
  546. int n;
  547. {
  548.     int i;
  549.  
  550.     if (dc.prflg == TRUE && n > 0)
  551.     {
  552.         for(i=0; i<n; ++i)
  553.         {
  554.             prchar('\n',pout);
  555.         }
  556.         prchar('\r',pout);
  557.     }
  558. }
  559.  
  560.  
  561.  
  562. /*
  563.  *    spread words to justify right margin
  564.  */
  565.  
  566. spread(p,outp,nextra,outwds)
  567. char p[];
  568. int outp,nextra,outwds;
  569. {
  570.     int i,j;
  571.     int nb,ne,nholes;
  572.  
  573.     if((nextra <= 0) || (outwds <= 1))
  574.         return;
  575.     dc.sprdir = ~dc.sprdir;
  576.     ne = nextra;
  577.     nholes = outwds - 1;    /* holes between words */
  578.     i = outp - 1;    /* last non-blank character */
  579.     j = min(MAXLINE-3,i+ne); /* leave room for CR, LF, '\0'  */
  580.     while(i < j)
  581.     {
  582.         p[j] = p[i];
  583.         if(p[i] == ' ')
  584.         {
  585.             if(dc.sprdir == 0) nb = (ne - 1)/nholes + 1;
  586.             else nb = ne/nholes;
  587.             ne -= nb;
  588.             --nholes;
  589.             for(; nb>0; --nb)
  590.             {
  591.                 --j;
  592.                 p[j] = ' ';
  593.             }
  594.         }
  595.         --i;
  596.         --j;
  597.     }
  598. }
  599.  
  600.  
  601.  
  602. /*
  603.  *    split overstrikes (backspaces) into seperate buffer
  604.  */
  605.  
  606. strkovr(p,q)
  607. char *p, *q;
  608. {
  609.     char *pp;
  610.     int bsflg;
  611.  
  612.     bsflg = FALSE;
  613.     pp = p;
  614.     while (*p != '\0')
  615.     {
  616.         *q = ' ';
  617.         *pp = *p;
  618.         ++p;
  619.         if (*p == '\b')
  620.         {
  621.             if (*pp >= ' ' && *pp <= '~')
  622.             {
  623.                 bsflg = TRUE;
  624.                 *q = *pp;
  625.                 ++p;
  626.                 *pp = *p;
  627.                 ++p;
  628.             }
  629.         }
  630.         ++q;
  631.         ++pp;
  632.     }
  633.     *q++ = '\r';
  634.     *q = *pp = '\0';
  635.     return(bsflg);
  636. }
  637.  
  638.  
  639.  
  640. /*
  641.  *    underline a line
  642.  */
  643.  
  644. underl(p0,p1,size)
  645. char *p0,*p1;
  646. int size;
  647. {
  648.     int i,j;
  649.  
  650.     j = 0;
  651.     for (i=0; (p0[i] != '\n') && (j < size-1); ++i)
  652.     {
  653.         if (p0[i] >= ' ' && p0[i] <= '~')
  654.         {
  655.             if (isalpha(p0[i]) || isdigit(p0[i]) || dc.cuval > 0)
  656.             {
  657.                 p1[j++] = '_';
  658.                 p1[j++] = '\b';
  659.             }
  660.         }
  661.         p1[j++] = p0[i];
  662.     }
  663.     p1[j++] = '\n';
  664.     p1[j] = '\0';
  665.     while (*p1 != '\0') *p0++ = *p1++;
  666.     *p0 = '\0';
  667. }
  668.  
  669.  
  670. /*
  671.  *    compute width of character string
  672.  */
  673.  
  674. width(s)
  675. char *s;
  676. {
  677.     int w;
  678.  
  679.     w = 0;
  680.     while (*s != '\0')
  681.     {
  682.         if(*s == '\b')
  683.             --w;
  684.         else if(*s != '\n' && *s != '\r')
  685.             ++w;
  686.         ++s;
  687.     }
  688.     return(w);
  689. }
  690.