VS & OpenGL program: Access violation reading location 0x00000000.

//
// ShaderSetup.cpp
//
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
//#include <OPENGL/gl.h>
#include <GL/glew.h>
#include <GL/glut.h>
 
char *textFileRead(char *fn) {
 
 
	FILE *fp;
	char *content = NULL;
 
	int count=0;
 
	if (fn != NULL) {
		fp = fopen(fn,"rt");
 
		if (fp != NULL) {
      
      fseek(fp, 0, SEEK_END);
      count = ftell(fp);
      rewind(fp);
 
			if (count > 0) {
				content = (char *)malloc(sizeof(char) * (count+1));
				count = fread(content,sizeof(char),count,fp);
				content[count] = '\0';
			}
			fclose(fp);
		}
	}
	else {
		fprintf (stderr, "Error reading %s\n", fn);
	}
	return content;
}
 
int textFileWrite(char *fn, char *s) {
 
	FILE *fp;
	int status = 0;
 
	if (fn != NULL) {
		fp = fopen(fn,"w");
 
		if (fp != NULL) {
			
			if (fwrite(s,sizeof(char),strlen(s),fp) == strlen(s))
				status = 1;
			fclose(fp);
		}
	}
	return(status);
}
 
 
 
 
void printShaderInfoLog(GLuint obj)
{
    GLint infologLength = 0;
    GLsizei charsWritten  = 0;
    char *infoLog;
 
	glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength);
 
    if (infologLength > 0)
    {
        infoLog = (char *)malloc(infologLength);
        glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
		printf("%s\n",infoLog);
        free(infoLog);
    }
}
 
void printProgramInfoLog(GLuint obj)
{
    GLint infologLength = 0;
    GLsizei charsWritten  = 0;
    char *infoLog;
 
	glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);
 
    if (infologLength > 0)
    {
        infoLog = (char *)malloc(infologLength);
        glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
		printf("%s\n",infoLog);
        free(infoLog);
    }
}
 
 
/**
 * Auxillary function to set up a GLSL shader program.  requires the name of a vertex program and a fragment
 * program.  Returns a handle to the created GLSL program
 *
 * vert - Name of source file for vertex program
 * frag - Name of source file for fragment program
 */
 
GLuint setUpAShader (char *vert, char *frag)
{
	// Read in shader source
	char *vs = "";
	char *fs = "";
	
	// Create the shader 
	GLuint the_vert = glCreateShader(GL_VERTEX_SHADER);
	GLuint the_frag = glCreateShader(GL_FRAGMENT_SHADER);
	
	// Read in shader source
	vs = textFileRead(vert);
	if (!vs) {
		fprintf (stderr, "Error reading vertex shader file %s\n", vert);
		return 0;
	}
	fs = textFileRead(frag);
	if (!fs) {
		fprintf (stderr, "Error reading fragment shader file %s\n", frag);
		return 0;
	}
 
	const char * vv = vs;
	const char * ff = fs;
 
	glShaderSource(the_vert, 1, &vv,NULL);
	glShaderSource(the_frag, 1, &ff,NULL);
 
	free(vs);free(fs);
	
	// Compile the shader
	glCompileShader(the_vert);
	glCompileShader(the_frag);
	printShaderInfoLog(the_vert);
	printShaderInfoLog(the_frag);
	
	// Create the program -- attaching your shaders
	GLuint the_program = glCreateProgram();
	glAttachShader(the_program, the_vert);
	glAttachShader(the_program, the_frag);
	printProgramInfoLog(the_program);
	
	// Link the program
	glLinkProgram(the_program);
	printProgramInfoLog(the_program);
	
	return the_program;
 
}
 
 
//
// lab1.cpp
//
 
#include <math.h>
#include <assert.h>
 
//#include <GLUT/glut.h>
#include <GL/glew.h>
#include <GL/glut.h>
 
#include "ShaderSetup.h"
 
#include <stdio.h>
 
#define bool int
#define false 0
#define true 1
 
int currentX;		// Current location of X
int	currentY;		// Current location of Y
int startX;			// Starting location of X
int	startY;			// Starting location of Y
int windowHeight;		// Current height of window
int windowWidth;		// Current width of window
 
float 	angle 		= 0.0; 
float	axis[3];
float 	lastPosition[3]	= { 0.0F, 0.0F, 0.0F };
float	trans[3];
 
bool 	redrawContinue 	= false;
bool    trackballMove 	= false;
bool 	trackingMouse 	= false;
 
// Scene will mimic the basic scene used in RenderMan exercises
//  Vertices and colors for drawing the objects in the scene
GLfloat WallColors[][3] = {
    { 1.0, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, { 1.0, 0.0, 0.0 }, 
    { 1.0, 0.0, 0.0 }
};
 
GLfloat WallVertices[][3] = {
    { -5.0,  5.0,  0.0 }, {  5.0, 5.0,  0.0 }, { 5.0,  -5.0,  0.0 }, 
    { -5.0,  -5.0,  0.0 }
};
 
GLfloat FloorColors[][3] = {
    { 1.0, 1.0, 0.5 }, { 1.0, 1.0, 0.5 }, { 1.0, 1.0, 0.5 }, 
    { 1.0, 1.0, 0.5 }
};
 
GLfloat FloorVertices[][3] = {
    { -5.0, -5.0,  5.0 }, {  5.0, -5.0,  5.0 }, { 5.0,  -5.0,  -5.0 }, 
    { -5.0, -5.0, -5.0 }
};
 
GLUquadricObj *sphere = NULL;
 
 
/*
 *  The function draws your scene.  It will also apply the shader and attach it to
 *  correct primitive.  For sake of the example, the shader will be applied to the
 *  wall.
 */
 
void drawscene( void ) {
 
	// draw your floor
	/*
	GLuint brickProgram = setUpAShader("brick2.vert","brick2.frag");
		glUseProgram( brickProgram );	
	GLint brickLocation = glGetUniformLocation(brickProgram, "BrickColor");
	glUniform3f(brickLocation, 1.0, 1.0, 0.0);
	*/
 
	glBegin( GL_POLYGON );
      glColor3fv(  FloorColors[0]   );
      glVertex3fv( FloorVertices[0] );
 
      glColor3fv(  FloorColors[1]   );
      glVertex3fv( FloorVertices[1] );
 
      glColor3fv(  FloorColors[2]   );
      glVertex3fv( FloorVertices[2] );
 
      glColor3fv(  FloorColors[3]   );
      glVertex3fv( FloorVertices[3] );
	glEnd( );
	
 
 
	// draw the wall -- don't forget to assign your texture coords
	/*
	glUseProgram( setUpAShader("wood2.vert","wood2.frag") );	
	*/
	glBegin( GL_POLYGON );
      glColor3fv(  WallColors[0]   );
	  glTexCoord2f (0.0, 0.0);
      glVertex3fv( WallVertices[0] );
 
      glColor3fv(  WallColors[1]   );
	  glTexCoord2f (0.0, 1.0);
      glVertex3fv( WallVertices[1] );
 
      glColor3fv(  WallColors[2]   );
	  glTexCoord2f (1.0, 1.0);
      glVertex3fv( WallVertices[2] );
 
      glColor3fv(  WallColors[3]   );
	  glTexCoord2f (1.0, 0.0);
      glVertex3fv( WallVertices[3] );
	glEnd( );
	
	// draw the sphere	
	glUseProgram( setUpAShader("C:\Users\Korax\Desktop\Expert_Problem\plastic.vert","C:\Users\Korax\Desktop\Expert_Problem\plastic.frag") );	
	
	if (!sphere) {
		sphere = gluNewQuadric();
		gluQuadricDrawStyle(sphere, GLU_FILL);
	}
	glPushMatrix();
		glTranslatef (0.0, 0.0, -2.0);
		glColor3f (0.0, 0.0, 1.0);
		gluSphere (sphere,2,100, 100);
	glPopMatrix();
	
	
}
 
 
 
/*
 * Display callback function - used for redisplay as well
 */
 
void display( void ) {
 
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    // View transform 
    if ( trackballMove ) {
 
        glRotatef( angle, axis[0], axis[1], axis[2] );
 
    }
    drawscene();
 
    glutSwapBuffers();
}
 
 
 
/*
 * Callback function for screen window resizing/reshaping
 */
 
void myReshape( int width, int height ) {
 
    glViewport( 0, 0, width, height );
    windowWidth = width;
    windowHeight = height;
 
}
 
 
/*
 * Main routine - GLUT setup and initialization
 */
 
int main( int argc, char **argv ) {
 
	// Initialize GLUT
    glutInit( &argc, argv );
 
    // Enable double buffering and depth buffering
	glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
	glutInitWindowSize( 500, 500 );
	glutCreateWindow( argv[0] );
 
	// Callback functions are specified 
	glutReshapeFunc( myReshape );
	glutDisplayFunc( display );
 
	// enable depth testing
	glEnable( GL_DEPTH_TEST ); 
	glEnable (GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 
	// Camera stuff - matrix initialization
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity( );
	gluPerspective (45, 1.0, 1.0, 100.0);
 
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity( );
	gluLookAt (0.0, 15.0, -15.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
	
	// enter your display loop.
	glutMainLoop();
	
	return 0;
}