CL_XMLTokenizer::CL_XMLTokenizer(CL_IODevice &input) : impl(new CL_XMLTokenizer_Generic)
{
impl->input = input;
impl->size = input.get_size();
impl->pos = 0;
CL_DataBuffer buffer(impl->size);
input.receive(buffer.get_data(), buffer.get_size(), true);
CL_StringHelp::BOMType bom_type = CL_StringHelp::detect_bom(buffer.get_data(), buffer.get_size());
switch (bom_type)
{
default:
case CL_StringHelp::bom_none:
impl->data = CL_StringHelp::utf8_to_text(CL_StringRef8(buffer.get_data(), buffer.get_size(), false));
break;
case CL_StringHelp::bom_utf32_be:
case CL_StringHelp::bom_utf32_le:
throw CL_Exception("UTF-16 XML files not supported yet");
break;
case CL_StringHelp::bom_utf16_be:
case CL_StringHelp::bom_utf16_le:
throw CL_Exception("UTF-32 XML files not supported yet");
break;
case CL_StringHelp::bom_utf8:
impl->data = CL_StringHelp::utf8_to_text(CL_StringRef8(buffer.get_data()+3, buffer.get_size()-3, false));
break;
}
}
void CL_ZipFileHeader::load(CL_IODevice &input)
{
signature = input.read_int32();
if (signature != 0x02014b50)
{
throw CL_Exception("Incorrect File Header signature");
}
version_made_by = input.read_int16();
version_needed_to_extract = input.read_int16();
general_purpose_bit_flag = input.read_int16();
compression_method = input.read_int16();
last_mod_file_time = input.read_int16();
last_mod_file_date = input.read_int16();
crc32 = input.read_uint32();
compressed_size = input.read_int32();
uncompressed_size = input.read_int32();
file_name_length = input.read_int16();
extra_field_length = input.read_int16();
file_comment_length = input.read_int16();
disk_number_start = input.read_int16();
internal_file_attributes = input.read_int16();
external_file_attributes = input.read_int32();
relative_offset_of_local_header = input.read_int32();
filename.resize(file_name_length);
char *str1 = new char[file_name_length];
char *str2 = new char[extra_field_length];
char *str3 = new char[file_comment_length];
try
{
input.read(str1, file_name_length);
input.read(str2, extra_field_length);
input.read(str3, file_comment_length);
if (general_purpose_bit_flag & CL_ZIP_USE_UTF8)
{
filename = CL_StringHelp::utf8_to_text(CL_StringRef8(str1, file_name_length, false));
file_comment = CL_StringHelp::utf8_to_text(CL_StringRef8(str3, file_comment_length, false));
}
else
{
filename = CL_StringHelp::cp437_to_text(CL_StringRef8(str1, file_name_length, false));
file_comment = CL_StringHelp::cp437_to_text(CL_StringRef8(str3, file_comment_length, false));
}
extra_field = CL_DataBuffer(str2, extra_field_length);
delete[] str1;
delete[] str2;
delete[] str3;
}
catch (...)
{
delete[] str1;
delete[] str2;
delete[] str3;
throw;
}
}
CL_StringRef8 CL_StringData8::substr(size_type pos, size_type n) const
{
const char *d = data_ptr;
if (pos == npos || pos > data_length)
return CL_StringRef8(d + data_length, 0, false);
if (n == npos || n > data_length-pos)
n = data_length - pos;
return CL_StringRef8(d + pos, n, false);
}
void CL_OpenGLProgramObjectProvider::fetch_uniforms() const
{
if (!cached_uniforms.empty())
return;
CL_OpenGL::set_active();
GLint count = 0;
glGetProgramiv(handle, GL_ACTIVE_UNIFORMS, &count);
GLint name_size = 0;
glGetProgramiv(handle, GL_ACTIVE_UNIFORM_MAX_LENGTH, &name_size);
GLchar *name = new GLchar[name_size+1];
name[name_size] = 0;
for (int i=0; i<count; i++)
{
GLsizei length = 0;
GLint size = 0;
GLenum type = 0;
name[0] = 0;
glGetActiveUniform(handle, i, name_size, &length, &size, &type, name);
CL_String uniform_name = CL_StringHelp::local8_to_text(CL_StringRef8(name, length, false));
int loc = glGetUniformLocation(handle, CL_StringHelp::text_to_local8(name).c_str());
CL_ProgramUniform uniform(uniform_name, size, type, loc);
cached_uniforms.push_back(uniform);
}
delete[] name;
};
CL_String8 &CL_String8::assign(const char *s)
{
size_type length = CL_StringRef8(s).length();
if (this->data_capacity >= length)
{
memmove(this->data_ptr, s, sizeof(char) * length);
resize(length);
}
else
{
resize(length);
memcpy(this->data_ptr, s, sizeof(char) * length);
}
return *this;
}
CL_String CL_OpenGLProgramObjectProvider::get_info_log() const
{
throw_if_disposed();
CL_OpenGL::set_active();
CL_String result;
GLsizei buffer_size = 16*1024;
while (buffer_size < 2*1024*1024)
{
GLchar *info_log = new GLchar[buffer_size];
GLsizei length = 0;
glGetProgramInfoLog(handle, buffer_size, &length, info_log);
if (length < buffer_size-1)
result = CL_StringHelp::local8_to_text(CL_StringRef8(info_log, length, false));
delete[] info_log;
if (length < buffer_size-1)
break;
buffer_size *= 2;
}
return result;
}
CL_String8 &CL_String8::replace(size_type pos, size_type n, const char *s)
{
return replace(pos, n, s, CL_StringRef8(s).length());
}
CL_String8 &CL_String8::insert(size_type pos, const char *s)
{
return insert(pos, s, CL_StringRef8(s).length());
}
CL_String8::operator CL_StringRef8() const
{
return CL_StringRef8(c_str(), length(), true);
}
CL_StringData8::operator CL_StringRef8() const
{
return CL_StringRef8(data(), length(), false);
}
