title: Why would i be getting 4 instances of "undefined reference to `gluErrorString@4'"
body: <p>heres my code. an opengl4.0 tutorial:</p>
  
  <pre><code>#include &lt;stdlib.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;string.h&gt;
  #define GLEW_STATIC
  #include "GL/glew.h"
  #include &lt;GL/freeglut.h&gt;
  #define WINDOW_TITLE_PREFIX "Chapter 2"
  
  int CurrentWidth = 800,
      CurrentHeight = 600,
      WindowHandle = 0;
  
  unsigned FrameCount = 0;
  GLuint
      VertexShaderId,
      FragmentShaderId,
      ProgramId,
      VaoId,
      VboId,
      ColorBufferId;
  
  const GLchar* VertexShader =
  {
      "#version 400\n"\
      "layout(location=0) in vec4 in_Position;\n"\
      "layout(location=1) in vec4 in_Color;\n"\
      "out vec4 ex_Color;\n"\
  
      "void main(void)\n"\
      "{\n"\
      "   gl_Position = in_Position;\n"\
      "   ex_Color = in_Color;\n"\
      "}\n"
  };
  
  const GLchar* FragmentShader =
  {
      "#version 400\n"\
  
      "in vec4 ex_Color;\n"\
      "out vec4 out_Color;\n"\
  
      "void main(void)\n"\
      "{\n"\
      "   out_Color = ex_Color;\n"\
      "}\n"
  };
  
  void Initialize(int, char*[]);
  void InitWindow(int argc, char* argv[]);
  void ResizeFunction(int, int);
  void RenderFunction(void);
  void TimerFunction(int);
  void IdleFunction(void);
  void Cleanup(void);
  void CreateVBO(void);
  void DestroyVBO(void);
  void CreateShaders(void);
  void DestroyShaders(void);
  
  int main(int argc, char* argv[])
  {
      Initialize(argc, argv);
  
      glutMainLoop();
  
      exit(EXIT_SUCCESS);
  }
  
  void Initialize(int argc, char* argv[])
  {
      GLenum GlewInitResult;
      InitWindow(argc, argv);
  
  
  
      GlewInitResult = glewInit();
      if (GLEW_OK != GlewInitResult) {
          fprintf(
              stderr,
              "ERROR: %s\n",
              glewGetErrorString(GlewInitResult)
          );
          exit(EXIT_FAILURE);
      }
  
      fprintf(
          stdout,
          "INFO: OpenGL Version: %s\n",
          glGetString(GL_VERSION)
      );
  
      CreateShaders();
      CreateVBO();
      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  }
  
  void InitWindow(int argc, char* argv[])
  {
      glutInit(&amp;argc, argv);
      glutInitContextVersion(4, 0);
      glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
      glutInitContextProfile(GLUT_CORE_PROFILE);
  
      glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,GLUT_ACTION_GLUTMAINLOOP_RETURNS);
  
      glutInitWindowSize(CurrentWidth, CurrentHeight);
  
      glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
  
      WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX);
  
      if(WindowHandle &lt; 1) {
          fprintf(
              stderr,
              "ERROR: Could not create a new rendering window.\n"
          );
          exit(EXIT_FAILURE);
      }
  
      glutReshapeFunc(ResizeFunction);
      glutDisplayFunc(RenderFunction);
      glutIdleFunc(IdleFunction);
      glutTimerFunc(0, TimerFunction, 0);
      glutCloseFunc(Cleanup);
  
  }
  
  void ResizeFunction(int Width, int Height)
  {
      CurrentWidth = Width;
      CurrentHeight = Height;
      glViewport(0, 0, CurrentWidth, CurrentHeight);
  }
  
  void RenderFunction(void)
  {
      ++FrameCount;
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glDrawArrays(GL_TRIANGLES, 0, 3);
  
      glutSwapBuffers();
      glutPostRedisplay();
  }
  
  void IdleFunction(void)
  {
      glutPostRedisplay();
  }
  
  void TimerFunction(int Value)
  {
      if (0 != Value) {
          char* TempString = (char*)
              malloc(512 + strlen(WINDOW_TITLE_PREFIX));
  
          sprintf(
              TempString,
              "%s: %d Frames Per Second @ %d x %d",
              WINDOW_TITLE_PREFIX,
              FrameCount * 10,
              CurrentWidth,
              CurrentHeight
          );
  
          glutSetWindowTitle(TempString);
          free(TempString);
      }
  
      FrameCount = 0;
      glutTimerFunc(100, TimerFunction, 1);
  }
  
  void Cleanup(void)
  {
      DestroyShaders();
      DestroyVBO();
  }
  
  void CreateVBO(void)
  {
      GLfloat Vertices[] = {
          -0.8f, -0.8f, 0.0f, 1.0f,
           0.0f,  0.8f, 0.0f, 1.0f,
           0.8f, -0.8f, 0.0f, 1.0f
      };
  
      GLfloat Colors[] = {
          1.0f, 0.0f, 0.0f, 1.0f,
          0.0f, 1.0f, 0.0f, 1.0f,
          0.0f, 0.0f, 1.0f, 1.0f
      };
  
      GLenum ErrorCheckValue = glGetError();
  
      glGenVertexArrays(1, &amp;VaoId);
      glBindVertexArray(VaoId);
  
      glGenBuffers(1, &amp;VboId);
      glBindBuffer(GL_ARRAY_BUFFER, VboId);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
      glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(0);
  
      glGenBuffers(1, &amp;ColorBufferId);
      glBindBuffer(GL_ARRAY_BUFFER, ColorBufferId);
      glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);
      glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(1);
  
      ErrorCheckValue = glGetError();
  
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not create a VBO: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
   }
  
   void DestroyVBO(void)
  {
      GLenum ErrorCheckValue = glGetError();
  
      glDisableVertexAttribArray(1);
      glDisableVertexAttribArray(0);
  
      glBindBuffer(GL_ARRAY_BUFFER, 0);
  
      glDeleteBuffers(1, &amp;ColorBufferId);
      glDeleteBuffers(1, &amp;VboId);
  
      glBindVertexArray(0);
      glDeleteVertexArrays(1, &amp;VaoId);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not destroy the VBO: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  
  void CreateShaders(void)
  {
      GLenum ErrorCheckValue = glGetError();
  
      VertexShaderId = glCreateShader(GL_VERTEX_SHADER);
      glShaderSource(VertexShaderId, 1, &amp;VertexShader, NULL);
      glCompileShader(VertexShaderId);
  
      FragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
      glShaderSource(FragmentShaderId, 1, &amp;FragmentShader, NULL);
      glCompileShader(FragmentShaderId);
  
      ProgramId = glCreateProgram();
          glAttachShader(ProgramId, VertexShaderId);
          glAttachShader(ProgramId, FragmentShaderId);
      glLinkProgram(ProgramId);
      glUseProgram(ProgramId);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not create the shaders: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  
  void DestroyShaders(void)
  {
      GLenum ErrorCheckValue = glGetError();
  
      glUseProgram(0);
  
      glDetachShader(ProgramId, VertexShaderId);
      glDetachShader(ProgramId, FragmentShaderId);
  
      glDeleteShader(FragmentShaderId);
      glDeleteShader(VertexShaderId);
  
      glDeleteProgram(ProgramId);
  
      ErrorCheckValue = glGetError();
      if (ErrorCheckValue != GL_NO_ERROR)
      {
          fprintf(
              stderr,
              "ERROR: Could not destroy the shaders: %s \n",
              gluErrorString(ErrorCheckValue)
          );
  
          exit(-1);
      }
  }
  </code></pre>
  
  <p>its the full code to what i have in code blocks using mingw that is running on windows 7 x64. its chapter 2 of openglbook.com. its supposed to implement im implementing glew32s, freeglut and opengl in the project link settings (not compiler) and in that order. </p>
  
  <p>i hear running dynamically is better but i get a bunch of undefined glew command errors if i go dynamic. so i had to setup the "#define glew_static" with glew32s in the linker. </p>
  
  <p>what could be causing this?</p>
  
  <pre><code>-------------- Build: Debug in 40 (compiler: GNU GCC Compiler)---------------
  
  mingw32-g++.exe -Wall  -g    -ID:\backup\funstuff\programming\freeglut\include  -c D:\backup\funstuff\programming\40\main.cpp -o obj\Debug\main.o
  mingw32-g++.exe  -o bin\Debug\40.exe obj\Debug\main.o    -lglew32s -lfreeglut -lopengl32 
  Warning: .drectve `/DEFAULTLIB:"LIBCMT" /DEFAULTLIB:"OLDNAMES" ' unrecognized
  obj\Debug\main.o: In function `Z9CreateVBOv':
  D:/backup/funstuff/programming/40/main.cpp:219: undefined reference to `gluErrorString@4'
  obj\Debug\main.o: In function `Z10DestroyVBOv':
  D:/backup/funstuff/programming/40/main.cpp:247: undefined reference to `gluErrorString@4'
  obj\Debug\main.o: In function `Z13CreateShadersv':
  D:/backup/funstuff/programming/40/main.cpp:278: undefined reference to `gluErrorString@4'
  obj\Debug\main.o: In function `Z14DestroyShadersv':
  D:/backup/funstuff/programming/40/main.cpp:305: undefined reference to `gluErrorString@4'
  collect2.exe: error: ld returned 1 exit status
  Process terminated with status 1 (0 minutes, 1 seconds)
  4 errors, 1 warnings (0 minutes, 1 seconds)
  </code></pre>
  
  <p><em><strong></em>*</strong><em>edit</em><strong><em>*</em></strong></p>
  
  <p>I've downloaded wsys and installed mingw to a seperate directory and recompiled glew-1.9.0 and replaced the dll and libs. Still the same error, however without the ~~~~~~~~~~~>Warning: .drectve `/DEFAULTLIB:"LIBCMT" /DEFAULTLIB:"OLDNAMES" ' unrecognized&lt;~~~~~~~ warning. </p>
  
  <p>Which btw, was only present because the compiled DLL and libs from glews website were done on VisualC. </p>