Esempi in C++ (Cpp) per MemoryMapFile

Esempio n. 1

File: memory_mapped_input_buffer.cpp Progetto: bobot/CVC4.old-svn

pANTLR3_INPUT_STREAM MemoryMappedInputBufferNew(const std::string& filename) {
  // Pointer to the input stream we are going to create
  //
  pANTLR3_INPUT_STREAM input;
  ANTLR3_UINT32 status;

  // Allocate memory for the input stream structure
  //
  input = (pANTLR3_INPUT_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_INPUT_STREAM));

  if(input == NULL) {
    return NULL;
  }

  // Structure was allocated correctly, now we can read the file.
  //
  status = MemoryMapFile(input, filename);

  // Call the common 8 bit ASCII input stream handler
  // Initializer type thingy doobry function.
  //
#ifdef CVC4_ANTLR3_OLD_INPUT_STREAM
  antlr3AsciiSetupStream(input, ANTLR3_CHARSTREAM);
#else /* CVC4_ANTLR3_OLD_INPUT_STREAM */
  antlr38BitSetupStream(input);
#endif /* CVC4_ANTLR3_OLD_INPUT_STREAM */

  // Now we can set up the file name
  //
  input->istream->streamName
      = input->strFactory->newStr(input->strFactory,
                                  (uint8_t*) filename.c_str());
  input->fileName = input->istream->streamName;
  input->free = UnmapFile;

  if(status != ANTLR3_SUCCESS) {
    input->close(input);
    return NULL;
  }

  return input;
}

Esempio n. 2

File: GL.cpp Progetto: Christof-Sigel/TA_SDL

internal ShaderProgram * LoadShaderProgram( const char * VertexShaderFileName, const char * PixelShaderFileName, ShaderGroup * ShaderGroup)
{
    ShaderProgram * Shader = &ShaderGroup->Shaders[ShaderGroup->NumberOfShaders++];
    *Shader = {};

    strncpy(Shader->PixelFileName, PixelShaderFileName, MAX_SHADER_FILENAME);
    strncpy(Shader->VertexFileName, VertexShaderFileName, MAX_SHADER_FILENAME);

    if(ShaderGroup->NumberOfShaders+1>= MAX_SHADER_NUMBER)
    {
        LogError("Not enough shaders allocated, failed to load shader program for %s, %s", VertexShaderFileName, PixelShaderFileName);
        return &NullShader;
    }
    MemoryMappedFile VertexShaderFile=MemoryMapFile(VertexShaderFileName);
    if(!VertexShaderFile.MMapBuffer)
    {
        LogError("Failed to load vertex shader file %s",VertexShaderFileName);
        return &NullShader;
    }

    MemoryMappedFile PixelShaderFile=MemoryMapFile(PixelShaderFileName);
    if(!PixelShaderFile.MMapBuffer)
    {
        UnMapFile(PixelShaderFile);
        LogError("Failed to load pixel shader file %s",PixelShaderFileName);
        return &NullShader;
    }

    Shader->ProgramID = glCreateProgram();
    GLenum ErrorValue = glGetError();
    if(ErrorValue!=GL_NO_ERROR)
    {
        LogError("OpenGL error in CreateProgram for %s,%s : %s", VertexShaderFileName,PixelShaderFileName,gluErrorString(ErrorValue));
        Shader->ProgramID=0;
        UnMapFile(VertexShaderFile);
        UnMapFile(PixelShaderFile);
        return &NullShader;
    }
    Shader->VertexFileModifiedTime = VertexShaderFile.ModifiedTime;
    Shader->PixelFileModifiedTime = PixelShaderFile.ModifiedTime;

    Shader->VertexID = LoadShader(GL_VERTEX_SHADER,VertexShaderFile,VertexShaderFileName);
    glAttachShader(Shader->ProgramID,Shader->VertexID);

    Shader->PixelID = LoadShader(GL_FRAGMENT_SHADER,PixelShaderFile,PixelShaderFileName);
    glAttachShader(Shader->ProgramID,Shader->PixelID);

    UnMapFile(VertexShaderFile);
    UnMapFile(PixelShaderFile);

    ErrorValue = glGetError();
    if(ErrorValue!=GL_NO_ERROR)
    {
        LogError("OpenGL error in shader loading for %s,%s : %s", VertexShaderFileName,PixelShaderFileName,gluErrorString(ErrorValue));
        Shader->ProgramID=Shader->VertexID = Shader->PixelID = 0;
        return &NullShader;
    }

    if(!Shader->PixelID || !Shader->VertexID)
    {
        UnloadShaderProgram(Shader);
        Shader->ProgramID=Shader->VertexID = Shader->PixelID = 0;
        return &NullShader;
    }
    glLinkProgram(Shader->ProgramID);
    glUseProgram(Shader->ProgramID);

    return Shader;
}