Undefined reference while using gcc

Question

Trying to compile this code and keep getting "undefined reference to..." compiler errors. I'm not sure what's going on. I was told you don't need to include a reference to a ".c" file as long as you reference its ".h" file.

My terminal command: gcc Main.c semaphore.o -L. -lst -o test

/tmp/ccGSIjXz.o: In function `main':
HW3.c:(.text+0x15): undefined reference to `init_buffer'
HW3.c:(.text+0x26): undefined reference to `init_buffer'
HW3.c:(.text+0x37): undefined reference to `init_buffer'
/tmp/ccGSIjXz.o: In function `Thread1':
HW3.c:(.text+0x159): undefined reference to `c_deposit'
/tmp/ccGSIjXz.o: In function `Thread2':
HW3.c:(.text+0x18c): undefined reference to `c_remove'
HW3.c:(.text+0x1b9): undefined reference to `c_deposit'
/tmp/ccGSIjXz.o: In function `Thread3':
HW3.c:(.text+0x1e8): undefined reference to `c_remove'
HW3.c:(.text+0x206): undefined reference to `c_remove'
HW3.c:(.text+0x21a): undefined reference to `c_remove'
HW3.c:(.text+0x238): undefined reference to `c_deposit'
HW3.c:(.text+0x252): undefined reference to `c_deposit'
/tmp/ccGSIjXz.o: In function `Thread4':
HW3.c:(.text+0x28c): undefined reference to `c_remove'
collect2: ld returned 1 exit status

Here's the code:

Main.c:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "st.h"
#include "buffer.h"

#define MAX_CHARS 81
#define BUFF_SIZE 12
#define NULL_CHAR
typedef struct {
}ThreadInit;

static buffer *buffer1;
static buffer *buffer2;
static buffer *buffer3;

void *Thread1();
void *Thread2();
void *Thread3();
void *Thread4();

int main(int argc, char const *argv[])
{
    buffer1=init_buffer(BUFF_SIZE);
    buffer2=init_buffer(BUFF_SIZE);
    buffer3=init_buffer(BUFF_SIZE);

    ThreadInit thread1={};
    ThreadInit thread2={};
    ThreadInit thread3={};
    ThreadInit thread4={};

    if (st_thread_create(Thread1(), &thread1, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 1");
        exit(EXIT_FAILURE);
    }

    if (st_thread_create(Thread2(), &thread2, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 2");
        exit(EXIT_FAILURE);
    }
    if (st_thread_create(Thread3(), &thread3, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 3");
        exit(EXIT_FAILURE);
    }
    if (st_thread_create(Thread4(), &thread4, 0, 0) == NULL) {
        perror("st_thread_create failed for thread 4");
        exit(EXIT_FAILURE);
    }


    return 0;
}
void *Thread1()
{
    int c;
    while (1)
    {
        c=fgetc(stdin);
        c_deposit(buffer1,c);
        if(c==EOF)
        {
            break;
        }
    }
    st_thread_exit(NULL);
    return NULL;
}
void *Thread2(void *state)
{
    int c;
    while(1)
    {

        c=c_remove(buffer1);
        if(c==EOF)
        {
            break;
        }
        if(c=='\n')
        {
            c=' ';
        }
        c_deposit(buffer2,c);
    }
    st_thread_exit(NULL);
    return NULL;

}
void *Thread3(void *state)
{
    int c;
    while(1)
    {
        c=c_remove(buffer2);
        if(c==EOF)
        {
            break;
        }
        if(c=='*' && c_remove(buffer2)=='*')
        {
            c_remove(buffer2);
            c='^';
            c_deposit(buffer3,c);
        }
        else
        {
            c_deposit(buffer3,c);
        }
    }
    st_thread_exit(NULL);
    return NULL;
}
void *Thread4(void *state)
{
    int counter=0;
    int c;
    char output[MAX_CHARS];
    output[MAX_CHARS-1]='\0';
    while(1)
    {
        c=c_remove(buffer3);
        if(c==EOF)
        {
            break;
        }
        else
        {
            output[counter]=c;
            if(counter==80)
            {
                printf("%s",output);
                counter=-1;
                memset(output,'\0',BUFF_SIZE);
            }
            counter++;
        }
    }
    st_thread_exit(NULL);
    return NULL;
}

Buffer.c:

#include <stdio.h>
#include <stdlib.h>
#include "semaphore.h"
#include "buffer.h"

buffer *init_buffer(int size)
{

    buffer *new_Buffer;
    new_Buffer=malloc((sizeof(buffer)));

    createSem(new_Buffer->emptyBuffer, size);
    new_Buffer->emptyBuffer=malloc(sizeof(semaphore));

    createSem(new_Buffer->fullBuffer, 0);
    new_Buffer->fullBuffer=malloc(sizeof(semaphore));

    new_Buffer->chars=malloc(sizeof(char)*size);

    new_Buffer->size=size;

    new_Buffer->nextIn=0;
    new_Buffer->nextOut=0;

    return new_Buffer;
}

void c_deposit(buffer *buffer, char c)
{
    down(buffer->emptyBuffer);
    buffer->chars[buffer->nextIn]=c;
    buffer->nextIn=(buffer->nextIn+1)%buffer->size;
    up(buffer->fullBuffer);
}
int c_remove(buffer *buffer)
{
    int c;
    down(buffer->fullBuffer);
    c=buffer->chars[buffer->nextOut];
    buffer->nextOut=(buffer->nextOut+1)%buffer->size;
    up(buffer->emptyBuffer);
    return c;
}

buffer.h:

#include <stdio.h>
#include "semaphore.h"

typedef struct{
    semaphore emptyBuffer;
    semaphore fullBuffer;
    int nextIn;
    int nextOut;
    int size;
    char *chars;
}buffer;

void c_deposit(buffer *buffer, char c);
int c_remove(buffer *buffer);
buffer *init_buffer(int size);

Answer 1

Change

gcc Main.c semaphore.o -L. -lst -o test

To

gcc Main.c semaphore.o buffer.c -L. -lst -o test

Answer 2

I was told you don't need to include a reference to a ".c" file as long as you reference its ".h" file.

This is incorrect. Every .c source file needs to be compiled to a .o object file. The object files are then linked together to form the final binary. You can let gcc do this for you by simply specifying all of your .c files on your gcc command line.

The only thing #include "buffer.h" does, is copy the contents of that .h file into the current .c file. You do this so the .c file knows about all of the types referenced, and the prototypes of the functions you'll be calling, (so it can generate the correct code for the call).

In this case, you simple need to add buffer.c to your gcc command line.

Answer 3

try

gcc Main.c buffer.c semaphore.o -L. -lst -o test

you might want to add a prototype for init_buffer to buffer.h:

buffer *init_buffer(int size);