home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_100 / 103_01 / edit2.c < prev    next >
Text File  |  1985-03-10  |  9KB  |  466 lines
  1. /*    Hello!  This is the second half of the editor just like mom used
  2.     to make (oops...) I mean, just like the QED editor.  This is the
  3.     line storage system.
  4. */
  5.  
  6. #include "edit.inc"
  7.  
  8. init_buffer()
  9.     {
  10.     int i;
  11.     parsels[0].type = EOF;
  12.     for (i=0; i<NO_MEMORIES; i++)
  13.         {
  14.         memory[i].used = NO;
  15.         memory[i].lru = i;
  16.         }
  17.     temp_used = NO;
  18.     unlink(TEMP_FILE);
  19.     dot = dollar = 0;
  20.     }
  21.  
  22. insert_line(n, line)
  23.     int n;
  24.     char line[];
  25.     {
  26.     int b, t, tot_len, w;
  27.     char *p, *q, *x, *v;
  28.     if (parsels[0].type == EOF)
  29.         {
  30.         parsels[1].type = EOF;
  31.         parsels[0].type = IN_MEM;
  32.         parsels[0].where = 0;
  33.         parsels[0].line_no = 1;
  34.         memory[0].used = YES;
  35.         memory[0].parsel_no = 0;
  36.         }
  37.     for (b=1; parsels[b].type != EOF; b++)
  38.         if (parsels[b].line_no >= n)
  39.             break;
  40.     b--;
  41.     t = swap_in(b);
  42.     p = memory[t].buffer;
  43.     tot_len = strlen(p) + strlen(line);
  44.     if (tot_len >= BUFF_SIZE)
  45.         split = tot_len/2;
  46.     else
  47.         split = 0;
  48.     line_split = parsels[b].line_no-1;
  49.     split_at = b+1;
  50.     q = temp3_buff;
  51.     for (w=n-parsels[b].line_no; w; w--)
  52.         for (;;)
  53.             if (save(&q, *p++) == LF)
  54.                 break;
  55.     for (x=line; *x; x++)
  56.         save(&q, *x);
  57.     save(&q, LF);
  58.     while (save(&q, *p++))
  59.         ;
  60.     x = temp3_buff;
  61.     v = memory[t].buffer;
  62.     while (*v++ = *x++)
  63.         ;
  64.     for (w=b+1; parsels[w].type != EOF; w++)
  65.         parsels[w].line_no++;
  66.     dollar++;
  67.     modified_file = YES;
  68.     if (n <= number1)
  69.         number1++;
  70.     if (n <= number2)
  71.         number2++;
  72.     if (n <= number3)
  73.         number3++;
  74.     }
  75.  
  76. char save(p, n)
  77.     char **p, n;
  78.     {
  79.     int t1, i;
  80.     *(*p)++ = n;
  81.     if (n==LF)
  82.         line_split++;
  83.     if (NOT --split)
  84.         {
  85.         **p = EOL;
  86.         t1 = swap_new();
  87.         for (i=NO_PARSELS-2; i>=split_at; i--)
  88.             {
  89.             parsels[i+1].type = parsels[i].type;
  90.             parsels[i+1].where = parsels[i].where;
  91.             parsels[i+1].line_no = parsels[i].line_no;
  92.             }
  93.         for (i=0; i<NO_MEMORIES; i++)
  94.             if (memory[i].parsel_no >= split_at)
  95.                 memory[i].parsel_no++;
  96.         parsels[split_at].type = IN_MEM;
  97.         parsels[split_at].where = t1;
  98.         parsels[split_at].line_no = line_split;
  99.         memory[t1].parsel_no = split_at;
  100.         *p = memory[t1].buffer;
  101.         }
  102.     return(n);
  103.     }
  104.  
  105. /*    This will delete a line */
  106. delete_line(n)
  107.     int n;
  108.     {
  109.     int b, t, u, c;
  110.     char *p, *q;
  111.     for (b=1; parsels[b].type != EOF; b++)
  112.         if (parsels[b].line_no > n)
  113.             break;
  114.     b--;
  115.     if (b AND parsels[b].line_no == n)
  116.         {
  117.         t = swap_in(b-1);
  118.         p = memory[t].buffer;
  119.         for (u=n-parsels[b-1].line_no; u; u--)
  120.             for (;;)
  121.                 if (*p++ == LF)
  122.                     break;
  123.         *p = 0;
  124.         }
  125.     t = swap_in(b);
  126.     p = memory[t].buffer;
  127.     for (u=n-parsels[b].line_no; u; u--)
  128.         for (;;)
  129.             if (*p++ == LF)
  130.                 break;
  131.     for (q=p; *q++ != LF;)
  132.         ;
  133.     while (*p++ = *q++)
  134.         ;
  135.     for (c=b+1; parsels[c].type != EOF; c++)
  136.         parsels[c].line_no--;
  137.     if (parsels[b+1].type != EOF)
  138.         combine(b);
  139.     if (b)
  140.         combine(b-1);
  141.     dollar--;
  142.     modified_file = YES;
  143.     if (number1 >= n)
  144.         number1--;
  145.     if (number2 >= n)
  146.         number2--;
  147.     if (number3 >= n)
  148.         number3--;
  149.     }
  150.  
  151. /*    This will combine two parsels into one */
  152. combine(a)
  153.     int a;
  154.     {
  155.     int t1, t2, c1, c2, i;
  156.     char *p, *q;
  157.     t1 = swap_in(a);
  158.     t2 = swap_in(a+1);
  159.     c1 = strlen(memory[t1].buffer);
  160.     c2 = strlen(memory[t2].buffer);
  161.     if (c1+c2 > BUFF_SIZE)
  162.         return;
  163.     p = memory[t1].buffer + c1;
  164.     q = memory[t2].buffer;
  165.     while (*p++ = *q++)
  166.         ;
  167.     for (i=a+1; parsels[i-1].type != EOF; i++)
  168.         {
  169.         parsels[i].type = parsels[i+1].type;
  170.         parsels[i].where = parsels[i+1].where;
  171.         parsels[i].line_no = parsels[i+1].line_no;
  172.         }
  173.     for (i=0; i<NO_MEMORIES; i++)
  174.         if (memory[i].parsel_no > a+1)
  175.             memory[i].parsel_no--;
  176.     memory[t2].used = NO;
  177.     }
  178.  
  179. /*    This will read a line */
  180. read_line(n, line)
  181.     int n;
  182.     char line[];
  183.     {
  184.     int b, c, u, t;
  185.     char *p;
  186.     for (b=1; parsels[b].type!=EOF; b++)
  187.         if (parsels[b].line_no > n)
  188.             break;
  189.     b--;
  190.     c = 0;
  191.     if (b AND parsels[b].line_no==n)
  192.         {
  193.         t = swap_in(b-1);
  194.         p = memory[t].buffer;
  195.         for (u=n-parsels[b-1].line_no; u; u--)
  196.             for (;;)
  197.                 if (*p++ == LF)
  198.                     break;
  199.         for (; *p; p++)
  200.             line[c++] = *p;
  201.         }
  202.     t = swap_in(b);
  203.     p = memory[t].buffer;
  204.     for (u = n-parsels[b].line_no; u; u--)
  205.         for (;;)
  206.             if (*p++ == LF)
  207.                 break;
  208.     for (; *p != LF; p++)
  209.         line[c++] = *p;
  210.     line[c] = EOL;
  211.     }
  212.  
  213. /*    This function will garentee a parsel in swapped in */
  214. int swap_in(par)
  215.     int par;
  216.     {
  217.     int t, n;
  218.     if (parsels[par].type == IN_MEM)
  219.         {
  220.         t = parsels[par].where;
  221.         do_lru(t);
  222.         return t;
  223.         }
  224.     t = swap_new();
  225.     do_lru(t);
  226.     memory[t].parsel_no = par;
  227.     seek(temp_used, READ_SIZE*parsels[par].where, 0);
  228.     read(temp_used, memory[t].buffer, READ_SIZE);
  229.     parsels[par].type = IN_MEM;
  230.     parsels[par].where = t;
  231.     return t;
  232.     }
  233.  
  234. /*    This is create a new what_ever */
  235. int swap_new()
  236.     {
  237.     int i;
  238.     for (i=0; i<NO_MEMORIES; i++)
  239.         if (memory[i].used == NO)
  240.             goto out_of_loop;
  241.     i = swap_out();
  242. out_of_loop:
  243.     memory[i].used = YES;
  244.     do_lru(i);
  245.     return(i);
  246.     }
  247.  
  248. int swap_out()
  249.     {
  250.     int t, i, n, j;
  251.     if (NOT temp_used)
  252.         if ((temp_used = temp_open()) == ERROR)
  253.             {
  254.             temp_used = NO;
  255.             printf("Temp file error...\007\n");
  256.             exit(NO);
  257.             }
  258.     t = 0;
  259.     for (i=1; i<NO_MEMORIES; i++)
  260.         if (memory[i].lru > memory[t].lru)
  261.             t = i;
  262.     n = memory[t].parsel_no;
  263.     for (i=0;; i++)
  264.         {
  265.         for (j=0; parsels[j].type != EOF; j++)
  266.             if (parsels[j].type == IN_TEMP_FILE AND parsels[j].where == i)
  267.                 goto comp_exit;
  268.         break;
  269. comp_exit:;
  270.         }
  271.     seek(temp_used, READ_SIZE*i, 0);
  272.     if (write(temp_used, memory[t].buffer, READ_SIZE) != READ_SIZE)
  273.         {
  274.         printf("Temp file error\007\n");
  275.         exit(NO);
  276.         }
  277.     memory[t].used = NO;
  278.     parsels[n].type = IN_TEMP_FILE;
  279.     parsels[n].where = i;
  280.     return(t);
  281.     }
  282.  
  283. /*    This will make n the most recently used memory block */
  284. do_lru(n)
  285.     int n;
  286.     {
  287.     int i;
  288.     for (i=0; i<NO_MEMORIES; i++)
  289.         if (memory[i].lru < memory[n].lru)
  290.             memory[i].lru++;
  291.     memory[n].lru = 0;
  292.     }
  293.  
  294. /*    This will (try to) open the temp file */
  295. int temp_open()
  296.     {
  297.     int fd;
  298.     fd = creat(TEMP_FILE);
  299.     if (fd == ERROR)
  300.         return(fd);
  301.     close(fd);
  302.     fd = open(TEMP_FILE, 2);
  303.     return(fd);
  304.     }
  305.  
  306. /*    This will read a file */
  307. read_file(file_name)
  308.     char file_name[];
  309.     {
  310.     int fd, lines, t, p, i, j;
  311.     char *q;
  312.     BOOL end_file;
  313.     modified_file = NO;
  314.     strcpy(deflt_file, file_name);
  315.     if ((fd = open(file_name, 0)) == ERROR)
  316.         {
  317.         printf("\007??\n");
  318.         return;
  319.         }
  320.     if (temp_used)
  321.         close(temp_used);
  322.     init_buffer();
  323.     lines = 1;
  324.     end_file = NO;
  325.     for (p=0;; p++)
  326.         {
  327.         if (p < NO_MEMORIES)
  328.             {
  329.             q = memory[p].buffer;
  330.             memory[p].buffer[BUFF_SIZE] = EOL;
  331.             memory[p].used = YES;
  332.             memory[p].parsel_no = p;
  333.             parsels[p].type = IN_MEM;
  334.             parsels[p].where = p;
  335.             }
  336.         else
  337.             {
  338.             q = temp3_buff;
  339.             parsels[p].type = IN_TEMP_FILE;
  340.             parsels[p].where = p-NO_MEMORIES;
  341.             }
  342.         q[BUFF_SIZE] = EOL;
  343.         parsels[p].line_no = lines;
  344.         i = read(fd, q, READ_SIZE);
  345.         if (i < READ_SIZE)
  346.             q[i*CPM_SIZE] = CNTRL_Z;
  347.         for (i=j=0; j<=BUFF_SIZE; j++)
  348.             if (q[j] == CNTRL_Z)
  349.                 {
  350.                 q[i++] = EOL;
  351.                 end_file = YES;
  352.                 }
  353.             else if (q[j] != CR)
  354.                 q[i++] = q[j];
  355.         if (p==NO_MEMORIES)
  356.             {
  357.             temp_used = temp_open();
  358.             if (temp_used == ERROR)
  359.                 {
  360.                 printf("Error with temp file\007\n");
  361.                 init_buffer();
  362.                 return;
  363.                 }
  364.             }
  365.         if (p>=NO_MEMORIES)
  366.             {
  367.             if (write(temp_used, temp3_buff, READ_SIZE)!=READ_SIZE)
  368.                 {
  369.                 printf("Error with temp file\007\n");
  370.                 init_buffer();
  371.                 return;
  372.                 }
  373.             }
  374.         for (t=0; t<BUFF_SIZE; t++)
  375.             {
  376.             if (q[t] == LF)
  377.                 {
  378.                 lines++;
  379.                 dot = 1;
  380.                 dollar++;
  381.                 }
  382.             else if (q[t] == EOL)
  383.                 if (end_file)
  384.                     goto end_of_file;
  385.                 else
  386.                     break;
  387.             }
  388.         }
  389. end_of_file: close(fd);
  390.         parsels[p+1].type = EOF;
  391.     }
  392.  
  393. /*    This will write the file */
  394. #define OOPS {printf("Write error...\007\n"); return;}
  395. write_file(file_name)
  396.     char *file_name;
  397.     {
  398.     int count, k, l, i, t;
  399.     char c;
  400.     printf("%s\n", file_name);
  401.     modified_file = NO;
  402.     strcpy(deflt_file, file_name);
  403.     if ((filed = creat(file_name)) == ERROR)
  404.         {
  405.         printf("\007??\n");
  406.         return;
  407.         }
  408.     count = 1;
  409.     k = 1;
  410.     l = 0;
  411.     if (dollar)
  412.         t = swap_in(0);
  413.     i = 0;
  414.     while (count <= dollar)
  415.         {
  416.         c = memory[t].buffer[l++];
  417.         if (c == EOL)
  418.             {
  419.             t = swap_in(k++);
  420.             l = 0;
  421.             continue;
  422.             }
  423.         if (c == LF)
  424.             {
  425.             if (write_save(CR, &i))
  426.                 OOPS;
  427.             count++;
  428.             }
  429.         if (write_save(c, &i))
  430.             OOPS;
  431.         }
  432.     if (write_save(CNTRL_Z, &i))
  433.         OOPS;
  434.     if (write_flush(i))
  435.         OOPS;
  436.     close(filed);
  437.     }
  438.  
  439. BOOL write_save(c, i)
  440.     char c;
  441.     int *i;
  442.     {
  443.     temp4_buff[(*i)++] = c;
  444.     if (*i == CPM_SIZE)
  445.         {
  446.         if (write(filed, temp4_buff, 1) != 1)
  447.             return(YES);
  448.         *i = 0;
  449.         }
  450.     return(NO);
  451.     }
  452.  
  453. BOOL write_flush(i)
  454.     int i;
  455.     {
  456.     if (write(filed, temp4_buff, 1) != 1)
  457.         return(YES);
  458.     return(NO);
  459.     }
  460. return(NO);
  461.     }
  462.  
  463. BOOL write_flush(i)
  464.     int i;
  465.     {
  466.     if (write(filed, temp4_buff, 1) != 1)