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

struct student {
        int             roll_num;
        char            *name;
        struct student  *next;
}       *head,          // Pointer to first element in the linked list.
        *temp;          // When creating the linked list, a pointer to current
                        // element in the linked list; when deleting the linked
                        // list, a pointer to the next element in the list.

        // Note that both head and temp are initialzed to NULL pointers because
        // they are declared globally; not on the stack in main().

        // Note also that no linked list elements have been allocated yet (we
        // have allocated two pointers to structures, but no structures);
        // space for structures will be allocated as needed as lines are read
        // from the input file.

int main(int argc, char *argv[]) {
        char            buffer[120];    // input buffer
        FILE            *fptr;          // input stream pointer
        size_t          len;            // length of name
        char            *p;             // pointer to name in buffer[]

        fptr = fopen("INFILE.txt", "r");
        if(fptr == NULL) {
                fprintf(stderr, "%s: fopen(INFILE.txt) failed.\n", argv[0]);
                exit(1);
        }

        // Read input file into a linked list...
        // Note that fgets() reads no more than one line (up to a given number
        // of bytes)from a file; fread() reads a given number of bytes without
        // regard to line boundaries.
        while(fgets(buffer, sizeof(buffer), fptr)) {
                // XXX Should verify that fgets() returned a complete line.
//yifangt                printf("Read input line: %s", buffer);

                // Allocate space for this element of the linked list.
                // Note that using calloc() instead of malloc() initializes
                // temp->next (in the newly allocated structure) to a NULL
                // pointer.  (It also fills any space between structure
                // elements (if there is any) to null bytes.  This isn't
                // important for this example, but can be important if
                // structures are to be examined in a core dump or compared.)
                if(head == NULL)
                        // Create 1st element in the linked list.
                        temp = head = calloc(1, sizeof(struct student));
                else    // Add new element to the end of the linked list.  Note
                        // that the temp->next in the next statement is in the
                        // previous element in the linked list and then temp is
                        // set to a pointer to the (new) current element.
                        temp = temp->next = calloc(1, sizeof(struct student));
                if(temp == NULL) {
                        fprintf(stderr,
                                "%s: calloc() for linked list element failed.\n",
                                argv[0]);
                        exit(2);
                }
                printf("%d bytes allocated at %p for linked list element\n",
                        (int)sizeof(struct student), temp);

                // Convert numeric string at start of buffer to int.
                temp->roll_num = atoi(buffer);

                // skip over number and 1st space to find start of name.
                // XXX Should check for string overflow for badly formed input.
                for(p = buffer; *p++ != ' ';);

                // Allocate space and copy name.  Note that strlen() will
                // include space for the trailing newline character but not for
                // the terminating null byte.  But, we'll replace the newline
                // with a null byte before we copy the name from buffer[] to
                // the space we allocated for name in this linked list element.
                len = strlen(p);
                if((temp->name = malloc(len)) == NULL) {
                        fprintf(stderr, "%s: malloc(%d) for name failed.\n", argv[0], (int)len);
                        exit(3);
                }
                // Change trailing newline to string terminator.
                *(p + len - 1) = '\0';
                // Copy name into allocated space.  Note that len includes the
                // null byte that termiantes the string.
                strncpy(temp->name, p, len);
        printf("%d bytes allocated at %p for name %s\n\n", (int)len,
                        temp->name, temp->name);
        }

        // To get to here, we either hit EOF or detected an I/O error.
        if(ferror(fptr)) {
                fprintf(stderr, "%s: I/O error reading input.\n", argv[0]);
                exit(4);
        }
        fclose(fptr);
       printf("End-of-file found on input.\n");

        // We have now completed reading the input into a linked list.  Note
        // that temp->next (the pointer to the next element in the last element
        // in the linked list) is a NULL pointer.

        // Writing a linked list to a file doesn't make any sense.  The pointers
        // in the structures have no meaning in a file and won't be valid if
        // read back into another process.

        // For this example, we'll just print the data from the linked list and
        // free the space reserved for the elements after each element is
        // printed.  Obviously, we could reformat the data and save it in a file
        // but for this demo, showing what we have in the linked list seems more
        // important.

        printf("\nPrinting list element located at %p:\n", head);
        while(head) {
                printf("roll_num: %d\tname: %s\n", head->roll_num, head->name);
//yifangt        printf("Freeing name (%p) and list element (%p) space.\n",
        //                head->name, head);
                free(head->name);
                // Note that we can't reference head->next after we free head,
                // so we need to save the pointer to the next element before we
                // free the current element.
                temp = head->next;
                free(head->next);
                head = temp;
                // Note that head now points to the 1st remaining element of
                // the linked list again, if there are any elements left.  It is
                // a NULL pointer if no elements remain in the list.
        }

        // We have now freed all of the space we allocated for the linked list
        // elements and the space we allocated for the names associated with
        // each element in the linked list.
        return(0);
}