home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / compiler / small_c / cb / sources / buf.c next >
Encoding:
Text File  |  1985-07-22  |  2.8 KB  |  140 lines
  1.  
  2. /*
  3. ** buf.c -- buffer manipulation functions (memory version)
  4. */
  5.  
  6. int gotline, gotind;
  7. char *bufptr;
  8.  
  9. /*
  10. ** clrbuf -- initialize for new file (stub)
  11. */
  12. clrbuf() {
  13.   return;
  14.   }
  15.  
  16. /*
  17. ** getind -- locate line index in buf
  18. */
  19. getind(ln) int ln; {
  20.   int j;
  21.   if((j=ln-gotline) > 0)
  22.     while(j--) getint(gotind+NEXT, &gotind, INTEGER);
  23.   else if(j < 0)
  24.     while(j++) getint(gotind+PREV, &gotind, INTEGER);
  25.   gotline=ln;
  26.   return gotind;
  27.   }
  28.  
  29. /*
  30. ** getint -- obtain integer or long from buf at offset
  31. */
  32. getint(offset, dest, length) int offset, length; char *dest; {
  33.   bufptr=buf+offset;
  34.   while(length--)  *dest++ = *bufptr++;
  35.   }
  36.  
  37. /*
  38. ** putint -- place integer or long into buf at offset
  39. */
  40. putint(offset, source, length) int offset, length; char *source; {
  41.   bufptr=buf+offset;
  42.   while(length--) *bufptr++ = *source++;
  43.   }
  44.  
  45. /*
  46. ** gettxt -- locate text for line and make available
  47. */
  48. gettxt(line) int line; {
  49.   int i, j, k;
  50.   i=(k=getind(line)) + TEXT;
  51.   j=0;
  52.   while(txt[j++]=buf[i++]);
  53.   return k;
  54.   }
  55.  
  56. /*
  57. ** input -- input text from fd into buf
  58. */
  59. input(fd) int fd; {
  60.   int k3;
  61.   while(YES) {
  62.     if(poll(YES)==ESC) return ERR;
  63.     k3=lastbf;
  64.     if(fgets(buf + (lastbf += TEXT), MAXLINE, fd)) {
  65.       lastbf += trim(buf+lastbf) + 1;
  66.       inlink(k3);
  67.       if((lastbf+MAXLINE) > maxbuf) {
  68.         fputs("memory overflow ", stderr);
  69.         return ERR;
  70.         }
  71.       }
  72.     else break;
  73.     }
  74.   lastbf -= TEXT;
  75.   return OK;
  76.   }
  77.  
  78. /*
  79. ** inject -- put text from lin after curln
  80. */
  81. inject(lin) char lin[]; {
  82.   int i, k3;
  83.   if(*lin==NULL) {
  84.     *lin='\n';
  85.     *(lin+1)=NULL;
  86.     }
  87.   i=0;
  88.   while(lin[i]!=NULL) {
  89.     k3=lastbf;
  90.     lastbf=lastbf+TEXT;
  91.     while(lin[i]!=NULL) {
  92.       if(lin[i]=='\n') {
  93.         ++i;
  94.         break;
  95.         }
  96.       addset(lin[i++], buf, &lastbf, maxbuf);
  97.       }
  98.     if(addset(NULL, buf, &lastbf, maxbuf)==NO) {
  99.       fputs("memory overflow ", stderr);
  100.       return ERR;
  101.       }
  102.     inlink(k3);
  103.     }
  104.   return OK;
  105.   }
  106.  
  107. /*
  108. ** inlink -- link injected line
  109. */
  110. inlink(k3) int k3; {
  111.   int k1, k2;
  112.   k1=getind(curln);
  113.   /** leaves gotline & gotind before affected area **/
  114.   getint(k1+NEXT, &k2, INTEGER);
  115.   relink(k1, k3, k3, k2);
  116.   relink(k3, k2, k1, k3);
  117.   ++curln;
  118.   ++lastln;
  119.   }
  120.  
  121. /*
  122. ** relink -- rewrite two half links
  123. */
  124. relink(a, x, y, b) int a, x, y, b; {
  125.   putint(x+PREV, &a, INTEGER);
  126.   putint(y+NEXT, &b, INTEGER);
  127.   updtflag=YES;
  128.   }
  129.  
  130. /*
  131. ** setbuf -- initialize line storage buffer
  132. */
  133. setbuf() {
  134.   relink(LINE0, LINE0, LINE0, LINE0);
  135.   lastbf=LINE0+TEXT;
  136.   addset(NULL, buf, &lastbf, maxbuf);
  137.   gotline=curln=lastln=0;
  138.   gotind=LINE0;
  139.   }
  140.