static void
read_utf8_char4 (st_parameter_dt *dtp, void *p, int len, int width)
{
gfc_char4_t *dest;
int nbytes;
int i, j;
len = (width < len) ? len : width;
dest = (gfc_char4_t *) p;
/* Proceed with decoding one character at a time. */
for (j = 0; j < len; j++, dest++)
{
*dest = read_utf8 (dtp, &nbytes);
/* Check for a short read and if so, break out. */
if (nbytes == 0)
break;
}
/* If there was a short read, pad the remaining characters. */
for (i = j; i < len; i++)
*dest++ = (gfc_char4_t) ' ';
return;
}
int main(int argc, char * argv[])
{
if (argc < 3) {
printf("usage: %s [-s] [iterations] input_file\n", basename(argv[0]));
printf("\n -s = sort by position\n Use - as input_file to read from stdin\n");
return 0;
}
int iterations = atoi(argv[argc-2]);
bool sort = (argc > 2 && strcmp(argv[1], "-s") == 0);
FILE *stream = (strcmp(argv[argc-1], "-") == 0) ? stdin : fopen(argv[argc-1], "r");
char *md_source = read_utf8(stream);
double starttime = get_time();
int i;
for (i = 0; i < iterations; i++)
{
pmh_element **result;
pmh_markdown_to_elements(md_source, pmh_EXT_NONE, &result);
if (sort)
pmh_sort_elements_by_pos(result);
}
double endtime = get_time();
printf("%f\n", (endtime-starttime));
return(0);
}
/* skip entries until found search or dict end. skipped does not include the found key */
bool TorrentBase::try_next_dict_entry(BufferString search, BufferString prev, bool &error, BufferString *skipped) {
size_t start = m_buffer.pos();
error = true;
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict, found eof");
BufferString cur;
while (m_buffer.m_data[m_buffer.pos()] != 'e') {
size_t curpos = m_buffer.pos();;
if (!read_utf8(cur)) return errorcontext("parsing dict key failed");
if (cur <= prev) return seterror("(previous) dict entries in wrong order");
if (cur == search) {
error = false;
if (0 != skipped) *skipped = BufferString(m_buffer.data() + start, curpos - start);
return true;
}
if (cur > search) {
m_buffer.m_pos = curpos;
error = false;
if (0 != skipped) *skipped = BufferString(m_buffer.data() + start, m_buffer.pos() - start);
return false;
}
prev = cur;
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict value, found eof");
if (!skip_value()) return errorcontext("parsing dict value failed");
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict entry or 'e', found eof");
}
/* dict end found, don't skip the 'e' */
error = false;
if (0 != skipped) *skipped = BufferString(m_buffer.data() + start, m_buffer.pos() - start);
return false;
}
static void
read_utf8_char1 (st_parameter_dt *dtp, char *p, int len, size_t width)
{
gfc_char4_t c;
char *dest;
size_t nbytes;
int i, j;
len = ((int) width < len) ? len : (int) width;
dest = (char *) p;
/* Proceed with decoding one character at a time. */
for (j = 0; j < len; j++, dest++)
{
c = read_utf8 (dtp, &nbytes);
/* Check for a short read and if so, break out. */
if (nbytes == 0)
break;
*dest = c > 255 ? '?' : (uchar) c;
}
/* If there was a short read, pad the remaining characters. */
for (i = j; i < len; i++)
*dest++ = ' ';
return;
}
bool TorrentBase::parse_announce_list() {
std::string s;
if (m_buffer.eof()) return seterror("expected announce-list, found eof");
if (!m_buffer.isNext('l')) {
if (!read_utf8(s)) return errorcontext("expected announce-list, neither list nor string found");
std::cerr << "broken Announce-list, found single string" << std::endl;
t_announce_list.push_back(std::vector<std::string>());
t_announce_list.back().push_back(s);
} else {
bool warned1 = false;
m_buffer.next();
while (!m_buffer.eof() && !m_buffer.isNext('e')) {
if (!m_buffer.isNext('l')) {
if (!read_utf8(s)) return errorcontext("expected announce-list list, neither list nor string found");
if (!warned1) {
std::cerr << "broken announce-list, found string in list, should be in separate list" << std::endl;
warned1 = true;
}
if (t_announce_list.empty()) t_announce_list.push_back(std::vector<std::string>());
t_announce_list.back().push_back(s);
} else {
t_announce_list.push_back(std::vector<std::string>());
m_buffer.next();
while (!m_buffer.eof() && !m_buffer.isNext('e')) {
if (!read_utf8(s)) return errorcontext("expected announce-list list entry");
t_announce_list.back().push_back(s);
}
if (!m_buffer.isNext('e')) return seterror("expected announce-list list, found eof");
m_buffer.next();
}
}
if (!m_buffer.isNext('e')) return seterror("expected announce-list lists, found eof");
m_buffer.next();
}
return true;
}
bool TorrentBase::skip_dict() {
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict, found eof");
if (m_buffer.m_data[m_buffer.pos()] != 'd') return seterror("expected 'd' for dict");
m_buffer.next();
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict entry or 'e', found eof");
BufferString last, cur;
while (m_buffer.m_data[m_buffer.pos()] != 'e') {
if (!read_utf8(cur)) return errorcontext("parsing dict key failed");
if (cur <= last) return seterror("(previous) dict entries in wrong order");
last = cur;
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict value, found eof");
if (!skip_value()) return errorcontext("parsing dict value failed");
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict entry or 'e', found eof");
}
m_buffer.next();
return true;
}
/* skip entries until dict end */
bool TorrentBase::goto_dict_end(BufferString prev, BufferString *skipped) {
size_t start = m_buffer.pos();
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict entry or 'e', found eof");
BufferString cur;
while (m_buffer.m_data[m_buffer.pos()] != 'e') {
if (!read_utf8(cur)) return errorcontext("parsing dict key failed");
if (cur <= prev) {
std::cerr << "dict entries wrong order: '" << cur << "' <= '" << prev << "'\n";
}
if (cur <= prev) return seterror("(previous) dict entries in wrong order");
prev = cur;
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict value, found eof");
if (!skip_value()) return errorcontext("parsing dict value failed");
if (m_buffer.pos() >= m_buffer.m_len) return seterror("expected dict entry or 'e', found eof");
}
m_buffer.next();
if (0 != skipped) *skipped = BufferString(m_buffer.data() + start, m_buffer.pos() - start);
return true;
}
flac_status
flacdec_read_frame_header(BitstreamReader *bitstream,
struct flac_STREAMINFO *streaminfo,
struct flac_frame_header *header)
{
unsigned block_size_bits;
unsigned sample_rate_bits;
uint8_t crc8 = 0;
br_add_callback(bitstream, (bs_callback_f)flac_crc8, &crc8);
/*read and verify sync code*/
if (bitstream->read(bitstream, 14) != 0x3FFE) {
return ERR_INVALID_SYNC_CODE;
}
/*read and verify reserved bit*/
if (bitstream->read(bitstream, 1) != 0) {
return ERR_INVALID_RESERVED_BIT;
}
header->blocking_strategy = bitstream->read(bitstream, 1);
block_size_bits = bitstream->read(bitstream, 4);
sample_rate_bits = bitstream->read(bitstream, 4);
header->channel_assignment = bitstream->read(bitstream, 4);
switch (header->channel_assignment) {
case 0x8:
case 0x9:
case 0xA:
header->channel_count = 2;
break;
default:
header->channel_count = header->channel_assignment + 1;
break;
}
switch (bitstream->read(bitstream, 3)) {
case 0:
header->bits_per_sample = streaminfo->bits_per_sample; break;
case 1:
header->bits_per_sample = 8; break;
case 2:
header->bits_per_sample = 12; break;
case 4:
header->bits_per_sample = 16; break;
case 5:
header->bits_per_sample = 20; break;
case 6:
header->bits_per_sample = 24; break;
default:
return ERR_INVALID_BITS_PER_SAMPLE;
}
bitstream->read(bitstream, 1); /*padding*/
header->frame_number = read_utf8(bitstream);
switch (block_size_bits) {
case 0x0: header->block_size = streaminfo->maximum_block_size; break;
case 0x1: header->block_size = 192; break;
case 0x2: header->block_size = 576; break;
case 0x3: header->block_size = 1152; break;
case 0x4: header->block_size = 2304; break;
case 0x5: header->block_size = 4608; break;
case 0x6: header->block_size = bitstream->read(bitstream, 8) + 1; break;
case 0x7: header->block_size = bitstream->read(bitstream, 16) + 1; break;
case 0x8: header->block_size = 256; break;
case 0x9: header->block_size = 512; break;
case 0xA: header->block_size = 1024; break;
case 0xB: header->block_size = 2048; break;
case 0xC: header->block_size = 4096; break;
case 0xD: header->block_size = 8192; break;
case 0xE: header->block_size = 16384; break;
case 0xF: header->block_size = 32768; break;
}
switch (sample_rate_bits) {
case 0x0: header->sample_rate = streaminfo->sample_rate; break;
case 0x1: header->sample_rate = 88200; break;
case 0x2: header->sample_rate = 176400; break;
case 0x3: header->sample_rate = 192000; break;
case 0x4: header->sample_rate = 8000; break;
case 0x5: header->sample_rate = 16000; break;
case 0x6: header->sample_rate = 22050; break;
case 0x7: header->sample_rate = 24000; break;
case 0x8: header->sample_rate = 32000; break;
case 0x9: header->sample_rate = 44100; break;
case 0xA: header->sample_rate = 48000; break;
case 0xB: header->sample_rate = 96000; break;
case 0xC: header->sample_rate = bitstream->read(bitstream, 8) * 1000; break;
case 0xD: header->sample_rate = bitstream->read(bitstream, 16); break;
case 0xE: header->sample_rate = bitstream->read(bitstream, 16) * 10; break;
case 0xF:
return ERR_INVALID_SAMPLE_RATE;
}
/*check for valid CRC-8 value*/
bitstream->read(bitstream, 8);
br_pop_callback(bitstream, NULL);
if (crc8 != 0)
return ERR_INVALID_FRAME_CRC;
/*Once we've read everything,
ensure the values are compatible with STREAMINFO.*/
if (streaminfo->sample_rate != header->sample_rate) {
return ERR_SAMPLE_RATE_MISMATCH;
}
if (streaminfo->channels != header->channel_count) {
return ERR_CHANNEL_COUNT_MISMATCH;
}
if (streaminfo->bits_per_sample != header->bits_per_sample) {
return ERR_BITS_PER_SAMPLE_MISMATCH;
}
if (header->block_size > streaminfo->maximum_block_size) {
return ERR_MAXIMUM_BLOCK_SIZE_EXCEEDED;
}
return OK;
}
u8int read_constant_pool(FILE* f, u16int *i, u16int *cpcount, cp_info** cpinfo)
{
u16int *j= (u16int*) malloc(sizeof(u16int));
s32int* integer, *i2;
u8int *raw = malloc(4), *raw2 = malloc(8);
cp_info* info;
debugmsg("Constant pool: \n");
for(*i=0;*i < ((*cpcount)-1); (*i)++)
{
info = (cp_info*) malloc(sizeof(cp_info));
memset(info, 0, sizeof(cp_info));
info->tag = fgetc(f);
switch(info->tag)
{
case CONSTANT_Class:
{
read_class(f, j, info);
debugmsg("#%d Class #%d\n", (*i)+1, MAKE_U16( ((CONSTANT_Class_info*) info->data)->name_index ));
break;
}
case CONSTANT_Fieldref:
{
read_fieldref(f, j, info);
debugmsg("#%d Fieldref #%d.#%d\n", (*i)+1,
MAKE_U16( ((CONSTANT_Fieldref_info*)info->data)->class_index ),
MAKE_U16( ((CONSTANT_Fieldref_info*)info->data)->name_and_type_index ));
break;
}
case CONSTANT_Methodref:
{
read_methodref(f, j, info);
debugmsg("#%d Methodref #%d.#%d\n", (*i)+1,
MAKE_U16( ((CONSTANT_Methodref_info*)info->data)->class_index ),
MAKE_U16( ((CONSTANT_Methodref_info*)info->data)->name_and_type_index ));
break;
}
case CONSTANT_InterfaceMethodref:
{
read_interfacemethodref(f, j, info);
debugmsg("#%d InterfaceMethodref #%d.#%d\n", (*i)+1,
MAKE_U16( ((CONSTANT_InterfaceMethodref_info*)info->data)->class_index ),
MAKE_U16( ((CONSTANT_InterfaceMethodref_info*)info->data)->name_and_type_index ));
break;
}
case CONSTANT_String:
{
read_string(f, j, info);
debugmsg("#%d String #%d\n", (*i)+1, MAKE_U16( ((CONSTANT_String_info*)info->data)->string_index));
break;
}
case CONSTANT_Integer:
{
read_integer(f, j, info);
MAKE_S32(raw, ((CONSTANT_Integer_info*)info->data)->bytes);
integer = (s32int*) raw;
debugmsg("#%d Integer %d\n", (*i) + 1, *integer);
break;
}
case CONSTANT_Float:
{
read_float(f, j, info);
COPY_FLOAT(raw, ((CONSTANT_Float_info*)info->data)->bytes);
debugmsg("#%d Float %f\n", (*i)+1, *((float32*) raw));
break;
}
case CONSTANT_Long:
{
read_long(f, j, info);
MAKE_S64(raw2, ((CONSTANT_Long_info*)info->data)->high_bytes );
debugmsg("#%d Long %ld\n", (*i)+1, *( (s64int*) raw2));
cpinfo[(*i)++] = NULL;
break;
}
case CONSTANT_Double:
{
read_double(f, j, info);
COPY_DOUBLE(raw2, ((CONSTANT_Double_info*) info->data)->high_bytes);
debugmsg("#%d Double %f\n", (*i)+1, *( (float64*) raw2));
cpinfo[(*i)++] = NULL;
break;
}
case CONSTANT_NameAndType:
{
read_nameandtype(f, j, info);
debugmsg("#%d NameAndType #%d.#%d\n", (*i)+1, MAKE_U16( ((CONSTANT_NameAndType_info*) info->data)->name_index) , MAKE_U16(((CONSTANT_NameAndType_info*) info->data)->descriptor_index ) );
break;
}
case CONSTANT_Utf8:
{
read_utf8(f, j, info);
debugmsg("#%d Utf8 %s\n", (*i)+1, utf8_to_cstring(((CONSTANT_Utf8_info*) info->data)->bytes));
break;
}
case CONSTANT_MethodHandle:
{
read_methodhandle(f, j, info);
debugmsg("#%d MethodHandle Kind:%d #%d\n", *(i)+1, ((CONSTANT_MethodHandle_info*) info->data)->reference_kind, MAKE_U16(((CONSTANT_MethodHandle_info*) info->data)->reference_index));
break;
}
case CONSTANT_MethodType:
{
read_methodtype(f, j, info);
debugmsg("#%d MethodType #%d\n", *(i)+1, MAKE_U16(((CONSTANT_MethodType_info*) info->data)->descriptor_index));
break;
}
case CONSTANT_InvokeDynamic:
{
read_invokedynamic(f,j,info);
debugmsg("#%d InvokeDynamic #%d.#%d\n", *(i)+1, MAKE_U16(((CONSTANT_InvokeDynamic_info*) info->data)->bootstrap_method_attr_index),
MAKE_U16(((CONSTANT_InvokeDynamic_info*) info->data)->name_and_type_index));
break;
}
default: {
debugerr("Unrecognized tag: %02X!\n", info->tag);
free(info);
return 0;
}
}
cpinfo[(*i)] = info;
}
debugmsg("Done reading Constant Pool\n");
free(j);
free(raw);
free(raw2);
return 1;
}
bool TorrentBase::read_info_utf8(std::string &str) {
return m_check_info_utf8 ? read_utf8(str) : read_string(str);
}
bool TorrentBase::skip_utf8() {
BufferString tmp;
return read_utf8(tmp);
}
