Thread: Segmentation fault (core dumped)

I tried to run my program:

$ cat pointers_array.txt | ./pointers_array

and got this error:

Segmentation fault (core dumped)

I think that means there is a null pointer that is being used somewhere. This is my program:

Code:

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

#define MAXLINES 5000   /* max #lines to be sorted */
#define MAXLEN 1000     /* max length of any input line */
#define ALLOCSIZE 10000 /* size of available space */

char *lineptr[MAXLINES];          /* pointers to text lines */
static char allocbuf[ALLOCSIZE];  /* storage for alloc */
static char *allocp = allocbuf;   /* next free position */

int  my_getline(char *, int);
char *my_alloc(int);
int readlines(char *lineptr[], int nlines);
void writelines(char *lineptr[], int nlines);
void my_strcpy(char *s, char *t);
void my_qsort(char *v[], int left, int right);
void my_swap(char *v[], int i, int j);

/* sort input lines */
main()
{
    int nlines;        /* number of input lines read */
    if ((nlines = readlines(lineptr, MAXLINES)) >= 0) {
        my_qsort(lineptr, 0, nlines-1);
        writelines(lineptr, nlines);
        return 0;
    } else {
        printf("error: input too big to sort\n");
        return 1;
    }
}

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

    while ((len = my_getline(line, MAXLEN)) > 0)
        if (nlines >= maxlines || (p = my_alloc(len) == NULL))
           return -1;
        else {
            line[len-1] = '\0'; /* delete newline */
            my_strcpy(p, line);
            lineptr[nlines++] = p;
        }
    return nlines;
}

/* writelines: write output lines */
void writelines(char *lineptr[], int nlines)
{
    int i;

    for (i = 0; i < nlines; i++)
        printf("%s\n", lineptr[i]);
}

/* getline: get line into s, return length */
int my_getline(char *s, int lim)
{
    char *p;
    int c;

    p = s;
    while (--lim > 0 && (c = getchar()) != EOF && c != '\n')
        *p++ = c;
    if (c == '\n')
        *p++ = c;
    *p = '\0';
    return (int)(p - s);
}

char *my_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;
}
 
void my_strcpy(char *s, char *t) { 
    while (*s++ = *t++) 
        ; 
}

/* qsort: sort v[left]...v[right] into increasing order */ 
void my_qsort(char *v[], int left, int right) 
{ 
    int i, last; 
    
    if (left >= right)  /* do nothing if array contains */ 
        return;            /* fewer than two elements */
        
    my_swap(v, left, (left + right)/2);
    last = left;                        
    for (i = left+1; i <= right; i++) 
        if (strcmp(v[i], v[left]) < 0) 
            my_swap(v, ++last, i); 
            
    my_swap(v, left, last); 
    my_qsort(v, left, last-1);
    my_qsort(v, last+1, right);
}

/* swap: interchange v[i] and v[j] */ 
void my_swap(char *v[], int i, int j) 
{ 
    char *temp; 
    
    temp = v[i]; 
    v[i] = v[j]; 
    v[j] = temp;
}

I'm thinking the issue is on this line:

Code:

 (p = my_alloc(len) == NULL)

Now I took that example from the book. basically when my_alloc is called, let's say we pass in the integer 10, since the first line is 10 characters. Furst time my_alloc is called, allocbuf is pointing to the first position of the allocbuf char array. We use pointer arithmetic to move the pointer to 10000 position of char array. And first time this function called, allocp will also be pointing to the first position. So the difference of "allocbuf + ALLOCSIZE - allocp" will definitely be greater than n (10 characters). Therefore, that if block executes. We increment the allocp pointer 10 places. Then we return 0 since we allocated 10 memory spaces and we want to return the first spot. So next we evaluate my_alloc(len) == NULL, and since it's char 0 and not NULL, that comparison operator should return 0 and we assign that to p pointer. So then we copy the line to the p pointer starting at position 0. Everything seems legal here. I'm not sure why I am getting segmentation fault error.

I figured it out. It needed to be:

(p = my_alloc(len)) == NULL) because we need to assign the position that alloc gives us to the pointer, not the boolean value of comparison operator,.

Originally Posted by johnmerlino

I figured it out. It needed to be:

(p = my_alloc(len)) == NULL) because we need to assign the position that alloc gives us to the pointer, not the boolean value of comparison operator,.

I like how you found the bug and also why it was a bug.