/* Memory allocation and freeing - demo of principles

In this example, I'm going to read a file of records .. an unknown number
of records, each of an unknown length, and store them in data structures
that are just big enough to hold them.

The alternatives is to allow enough memory for the biggest possible lines
and the biggest possible number of lines. But that would be very
wasteful of memory and place an arbitary limit on the application!
The only limit is 256v characters per line in the input buffer */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MAXLINELEN 257

/* Data is at http://www.wellho.net/data/railstats.xyz */

int main() {

        char **mydata = NULL ;
        int nread = 0;
        int k;
        char *itsat;

        char myreadbuffer[MAXLINELEN];

        FILE * infile;
        infile = fopen("railstats.xyz","r");

        while (fgets(myreadbuffer,MAXLINELEN-1,infile)) {
                /* Add a check for line length == MAXLINELEN-1 ?? */
                /* Just in case any individual lines hit the limit */

/* Clever bit - allocate just enough heap memory for the line read! */
                itsat = calloc(sizeof(char), strlen(myreadbuffer) + 1);

/* Very Clever bit - EXTEND the mydata 'array' so that it can hold an extra
pointer to the memory just allocated above */
                mydata = realloc(mydata,(nread+1) * sizeof(char *));

/* And store the address of the string (got in the clever bit) into the
newly extended location, building into an array of pointers to strings,
with each element dynamically extending. Two alternative syntaxes are
shown here - I have commented one of them out, but you can use either! */
                *(mydata+nread) = itsat;
                /* mydata[nread] = itsat; */

/* Finally, copy the string that has been read into the buffer into the newly
allocated memory. You may be told strncpy is safer */
                strcpy(itsat,myreadbuffer);

/* And in C, you need to keep note of how long arrays are / how much data you
have in them. This csn be done by holding a special (cardinal) value at the end
which is what is done with strings (it's a \0 character), or by keeping a
separate counter variable which is what I have done here */
                nread++;

        }

/* For demonstration - print out all the data from the complete structure */

#ifdef DEMO

        for (k=0; k<nread; k++) {
                printf("%s",mydata[k]);
        }
#endif

/* What would we do with our data? Perhaps report on all stations which has between 220
and 370 passengers in a the final year of our data (that's the last column), outputting
their industry standard 3 letter code (the second data column). Data tab delimited. */

        for (k=0; k<nread; k++) {
                char *sep1;
                char tlc[4],spcount[10];
                int pcount;

                sep1 = strchr(mydata[k],'\t');
                strncpy(tlc,sep1+1,3);
                tlc[3] = '\0';

                sep1 = strrchr(mydata[k],'\t');
                strncpy(spcount,sep1+1,9);
                pcount = atoi(spcount);

                if (pcount == 0) continue; /* Skip over NULL entries */
                if (pcount < 220 || pcount > 370) continue; /* Just print out in a range */

                printf("code, count %s %d\n",tlc,pcount);

        }

/* If this is long running, release the memory when no longer neededed */

        for (k=0; k<nread; k++) {
                free(mydata[k]);
        }
        free(mydata); /* Don't forget the outer array too! */

}

/* Here is some sample output

munchkin:xc grahamellis$ g++ -o transport transport.cpp
transport.cpp: In function ‘int main()’:
transport.cpp:38: warning: deprecated conversion from string constant to ‘char*’
transport.cpp:39: warning: deprecated conversion from string constant to ‘char*’
munchkin:xc grahamellis$ ./transport
building Swindon
building Cheltenham Spa
using
can take 581 to Swindon
using
can take 105 to Cheltenham
munchkin:xc grahamellis$

*/