Reverse printing many files. At once.

Hello everyone, this is an extention of previous posting,

The study note of k&R pg 108-110.   I introduced the multiple files reading/writing by additional

   firstwd.c    (<- to capture the filename in "header.txt")
   header.txt  (<-  in here, a list of filenames)

The main codes are previsouly posted and again here,
   1.   PRO145.c
   2.   getline.c
   3.   readlines.c
   4.   writelines.c
   5.   alloc.c

Compiled altogether.

   sample file = "AL-LIB1.TXT", "CA-LIB3.TXT"
   Should write files in "Result" folder, the same name.

It compiles well, and reverse only the first filename in "header.txt" list, namely, AL-LIB1.TXT (20KB).   The error said,

   error: input too big to sort

This suggests that I need to use set MEMORY FREE to have another file.    Such as afree(), free().    I tried a few times, but I can't figure it out.    Please help !!!   Thank you !!!   By the way, afree() in the text is

void afree(char *p)
{
   if (p >= allocbuf && p <allocbuf + ALLOCSIZE)
          allocp = p;
}

I didn't use this at all, because I don't know how and where to use this.    The rest of below (.c) are compiled all together.



===========================
/* firstwd.c */
/* Recyclable Object.        */

#include <ctype.h>

extern char *firstwd (char *to, char *from)
{
   while (isspace(*from) && *from!='\0') ++from;
   while (!isspace(*from) && *from!='\0') *to++ = *from++;
   *to = '\0';
   return (from);
}

===   file "Header.txt"  ==========
AL-LIB1R.TXT
CA-LIB3R.TXT




================
/* PRO145.C */
/* Store lines into *lineptr, and print them Upside-down       */
/* Origirnally << Line Sorting by using lineptr (line pointer) */
/* K&R pg 107, 5.6 */
/* I don't understand details.  I just copied from the text.   */
/* And it just works fine.                                     */


#include <stdio.h>
#include <string.h>
#include <alloc.h>
#define MAXLINES 5000   /* max #lines to be sorted */

char *lineptr[MAXLINES];  /* pointers to text lines */
FILE *infp, *outfp;

char openingFile [64];
char openedFN    [64];
char writingFile [64];

int readlines(FILE *infp, char *lineptr[], int nlines);
void writelines(FILE *outfp, char *lineptr[], int nlines);
extern char *firstwd (char *to, char *from);


int main(void)
{

   FILE *infpFN;
   infpFN=fopen ("HEADER.TXT", "r");


   while( (fgets(openingFile, 64, infpFN))!=NULL )
   {
         int nlines;   /* number of input lines read */
         nlines=0;

         firstwd (openedFN, &openingFile[0]);   /* This firstwd() is important to capture the filename */
         infp=fopen ( openedFN, "r");
         sprintf(writingFile, "RESULT\\%s", openedFN);
         outfp=fopen( writingFile, "w");

         if ((nlines=readlines(infp, lineptr, MAXLINES)) >= 0) {
                  writelines(outfp, lineptr, nlines);
                  return 0;
         } else {
                  printf("error: input too big to sort\n");
                  return 1;
         }   /* Closing IF-ELSE loop */
   }       /* Closing WHILE loop <- One-by-One file */
   return 0;
}          /* Closing main() */


=============
/* readlines.c */
/* "readlines.c" is a subroutine, not the main PRO145.c,   */
/*     but almost the main part in this program.           */
/* K&R, pg 109 */

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXLEN 1000   /* max length of any input line */
int getline(FILE *infp, char *, int);
char *alloc(int);

/* readline: read input lines */
int readlines(FILE *infp, char *lineptr[], int maxlines)
{
   int len, nlines;
   char *p, line[MAXLEN];

   nlines = 0;
   while ( (len=getline(infp, line, MAXLEN)) > 0)
   {
        if ( nlines >= maxlines || (p = alloc(len))==NULL ) {
             return -1;
        } else {
             line[len-1] = '\0'; /* delete newline */
             strcpy(p, line);
             lineptr[nlines++] = p;
        }
   }
   printf("No of lines : %d\n\n", nlines);    /* DEBUG */
   return nlines;
}


================
/* getline.c : read a line into s, return length */
/* K & R, page 29 */

#include<stdio.h>

int getline(FILE *infp, char s[], int lim)
{
   int c, i;

   for (i=0; i<lim-1 && (c=getc(infp))!=EOF && c!='\n'; ++i)
        s[i] = c;
   if (c== '\n') {
        s[i] = c;
        ++i;
   }
   s[i] = '\0';
   return i;
}


===============
/* writelines.c :  reverse writing output lines */

#include<stdio.h>
#include<alloc.h>

void writelines (FILE *outfp, char *lineptr[], int nlines)
{
   int i;

   for ( i = (nlines-1); i > -1; i--)     /* Reverse Print */
   {
        fprintf(outfp, "%s\n", lineptr[i]);
   }
}


==================
/* alloc:  Allocate Size */

#define ALLOCSIZE 30000   /* size of available space, 19K O.K. */

static char allocbuf[ALLOCSIZE];  /* storage for alloc */
static char *allocp = allocbuf;   /* next free position */

char *alloc(int n)   /* return pointer to n characters */
{
   if (allocbuf + ALLOCSIZE - allocp >= n) {    /* it fits */
        allocp += n;
        return allocp -n;  /* old p */
   } else       /* not enough room */
        return 0;
}


=================

END