geometry shader falsely interpreted as vertex shader

Question

I'm trying to get my simple geometry shader to work. But I have some weird error messages. It seems like opengl thinks that my geometry shader is my vertex shader.
This is the error message:

0<10> : error C7575: OpenGL does not allow input blocks in vertex shaders

But my vertex shader has no input block.

Here my vertex shader

#version 430 

in vec4 s_vPosition;
in vec4 s_vColor;
uniform mat4 mF; //final matrix = mP*mV*mDneu*mM

out VS_OUT
{
    vec4 color;     //sent color out to next stage
} vs_out;

void main (void) {
    vs_out.color = s_vColor;
    gl_Position = mF*s_vPosition;
}

geometryShader

#version 430 

layout(triangles) in;
layout(triangle_strip) out;
layout(max_vertices = 3) out;

in VS_OUT
{
    vec4 color;
} gs_in[];

out GS_OUT 
{
    vec4 color;
} gs_out;

 void main(void)
{
   for(int i = 0; i < gl_in.length(); i++)
  {
    gl_Position = gl_in[i].gl_Position;

    gs_out.color = gs_in[i].color;
    EmitVertex();
  }
  EndPrimitive();
}

and fragmentShader

#version 430                                                  

in GS_OUT                                             
{                                                     
    vec4 color;                                       
} fs_in;                                              

out vec4 fColor;

void main(void)                                       
{                                                    
    fColor.r = abs(fs_in.color.r);
    fColor.g = abs(fs_in.color.g);
    fColor.b = abs(fs_in.color.b);
    fColor.a = 1.0f;                              
}

When I run the program the geometry shader fails to compile. Only when I get rid of the input block it compiles.

I also recognized, that the functions...

// Find the position of the variables in the shader
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
colorID = glGetAttribLocation(shaderProgramID, "s_vColor");
cout <<"positionID: "<< (int)positionID << endl;
cout <<"colorID   : "<< (int)colorID << endl;

...returned 0 and 1 (for positionID and colorID) when the geometry shader was not included and 0 and -1 when it was included in the shader program. So I think there is somthing going wrong but I don't have a idea what it could be.
Please help :)

I don't know if it is helpful but here're the code for making the shaders.

First I get the shader code form the text file. Then I call the functions to make the shaders and the shaderProgram.

// Make a shader
    char* vertexShaderSourceCode = readFile("vertexShader.vsh");
    char* geometryShaderSourceCode = readFile("geometryShader.gsh");
    char* fragmentShaderSourceCode = readFile("fragmentShader.fsh");
    GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode);
    GLuint geometryShaderID = makeVertexShader(geometryShaderSourceCode);
    GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode);
    shaderProgramID = makeShaderProgram(vertShaderID, geometryShaderID, fragShaderID);

Here are the functions for making the shaders.

static char* readFile(const char* filename) {
    // Open the file
    FILE* fp = fopen(filename, "r");
    // Move the file pointer to the end of the file and determing the length
    fseek(fp, 0, SEEK_END);
    long file_length = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    char* contents = new char[file_length + 1];
    // zero out memory
    for (int i = 0; i < file_length + 1; i++) {
        contents[i] = 0;
    }
    // Here's the actual read
    fread(contents, 1, file_length, fp);
    // This is how you denote the end of a string in C
    contents[file_length + 1] = '\0';
    fclose(fp);
    return contents;
}

bool compiledStatus(GLint shaderID){
    GLint compiled = 0;
    glGetShaderiv(shaderID, GL_COMPILE_STATUS, &compiled);
    if (compiled) {
        return true;
    }
    else {
        GLint logLength;
        glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &logLength);
        char* msgBuffer = new char[logLength];
        glGetShaderInfoLog(shaderID, logLength, NULL, msgBuffer);
        printf("%s\n", msgBuffer);
        delete (msgBuffer);
        return false;
    }
}

GLuint makeVertexShader(const char* shaderSource) {
    GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShaderID, 1, (const GLchar**)&shaderSource, NULL);
    glCompileShader(vertexShaderID);
    bool compiledCorrectly = compiledStatus(vertexShaderID);
    if (compiledCorrectly) {
        return vertexShaderID;
    }
    return -1;
}

GLuint makeGeometryShader(const char* shaderSource){
    GLuint geometryShaderID = glCreateShader(GL_GEOMETRY_SHADER);
    glShaderSource(geometryShaderID, 1, (const GLchar**)&shaderSource, NULL);
    glCompileShader(geometryShaderID);
    bool compiledCorrectly = compiledStatus(geometryShaderID);
    if (compiledCorrectly) {
        return geometryShaderID;
    }
    return -1;
}

GLuint makeFragmentShader(const char* shaderSource) {
    GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShaderID, 1, (const GLchar**)&shaderSource, NULL);
    glCompileShader(fragmentShaderID);
    bool compiledCorrectly = compiledStatus(fragmentShaderID);
    if (compiledCorrectly) {
        return fragmentShaderID;
    }
    return -1;
}

GLuint makeShaderProgram(GLuint vertexShaderID, GLuint geometryShaderID, GLuint fragmentShaderID) {
    GLuint shaderID = glCreateProgram();
    glAttachShader(shaderID, vertexShaderID);
    glAttachShader(shaderID, geometryShaderID);
    glAttachShader(shaderID, fragmentShaderID);
    glLinkProgram(shaderID);
    return shaderID;
}

Answer 1

GLuint geometryShaderID = makeVertexShader(geometryShaderSourceCode); ??