X-Git-Url: http://git.tdb.fi/?p=libs%2Fdatafile.git;a=blobdiff_plain;f=source%2Fbinaryparser.cpp;h=4ed2877a4424c2389c890473a0e71918418516ba;hp=d2fca32ef3a2155eb78eec3034e67649336c3c0f;hb=ed78b585cfc4ecb44972e346857e887b183fd7a7;hpb=35d0da96bad97214376f18d15078e6d731e6f219 diff --git a/source/binaryparser.cpp b/source/binaryparser.cpp index d2fca32..4ed2877 100644 --- a/source/binaryparser.cpp +++ b/source/binaryparser.cpp @@ -1,8 +1,13 @@ +#include #include #include #include +#include "argumentstore.h" #include "binaryparser.h" +#include "binfloat.h" +#include "except.h" #include "input.h" +#include "loaderaction.h" using namespace std; @@ -11,59 +16,38 @@ namespace DataFile { BinaryParser::BinaryParser(Input &i, const string &s): ParserMode(i, s), - first(true) + float_precision(32), + cur_info(0) { - dict[1] = DictEntry("__kwd", "iss"); - dict[2] = DictEntry("__str", "is"); + dict[-1] = StatementInfo("__kwd", "iss"); + dict[-2] = StatementInfo("__str", "is"); + dict[-3] = StatementInfo("__flt", "i"); } Statement BinaryParser::parse() { - while(1) + const StatementKey *key; + if(cur_info) { - Statement st = parse_statement(); - if(st.keyword=="__kwd") - { - if(st.args.size()!=3) - throw_at(TypeError("Keyword definition must have three arguments"), src); - - const unsigned id = st.args[0].get(); - const string &kw = st.args[1].get(); - const string &args = st.args[2].get(); - dict[id] = DictEntry(kw, args); - } - else if(st.keyword=="__str") - { - if(st.args.size()!=2) - throw_at(TypeError("String definition must have two arguments"), src); - - const unsigned id = st.args[0].get(); - strings[id] = st.args[1].get(); - } - else - return st; + key = &cur_info->key; + cur_info = 0; } -} - -Statement BinaryParser::parse_statement() -{ - while(first && in.peek()=='\n') - in.get(); - first = false; - - unsigned id = parse_int(); - if(!in) - return Statement(); + else + { + int id = parse_int(); + if(!in) + return Statement(); - const DictEntry &de = get_item(dict, id); + key = &get_item(dict, id).key; + } Statement result; - result.keyword = de.keyword; + result.keyword = key->keyword; result.source = src; - for(unsigned j = 0; jsignature.size(); ++j) { - switch(de.args[j]) + switch(key->signature[j]) { case IntType::signature: result.args.push_back(parse_int()); @@ -78,23 +62,124 @@ Statement BinaryParser::parse_statement() result.args.push_back(parse_bool()); break; case SymbolType::signature: - result.args.push_back(Symbol(parse_enum())); + result.args.push_back(parse_symbol()); break; } } + unsigned upper_nsub = (sub_remaining.empty() ? 0 : sub_remaining.back()); + unsigned nsub = parse_int(); for(unsigned j = 0; j0) + sub_remaining.back() = upper_nsub-1; + result.valid = true; return result; } -long long BinaryParser::parse_int() +void BinaryParser::process_control_statement(const Statement &st) +{ + if(st.keyword=="__kwd") + { + int id = st.args[0].get(); + if(id<=0) + throw bad_definition("__kwd"); + + const string &kw = st.args[1].get(); + const string &args = st.args[2].get(); + for(string::const_iterator i=args.begin(); i!=args.end(); ++i) + for(unsigned j=0; valid_signatures[j]!=*i; ++j) + if(!valid_signatures[j]) + throw bad_definition("__kwd"); + + dict[id] = StatementInfo(kw, args); + } + else if(st.keyword=="__str") + { + int id = st.args[0].get(); + if(id<=0) + throw bad_definition("__str"); + + strings[id] = st.args[1].get(); + } + else if(st.keyword=="__flt") + float_precision = st.args[0].get(); +} + +const StatementKey *BinaryParser::peek(unsigned level) +{ + if(level>sub_remaining.size()) + throw nesting_error("bad level"); + while(level0; ) + parse(); + sub_remaining.pop_back(); + cur_info = 0; + } + + if(!sub_remaining.empty() && sub_remaining.back()==0) + { + // No more substatements on this level + cur_info = 0; + return 0; + } + + if(cur_info) + return &cur_info->key; + + int id = parse_int(); + if(!in) + return 0; + + cur_info = &get_item(dict, id); + return &cur_info->key; +} + +bool BinaryParser::parse_and_load(unsigned level, Loader &ldr, const LoaderAction &act) { - long long result = 0; + if(!cur_info && !peek(level)) + return false; + + ArgumentStore args(*cur_info); + for(unsigned i=0; ikey.signature.size(); ++i) + switch(cur_info->key.signature[i]) + { + case IntType::signature: + args.set(i, parse_int()); + break; + case FloatType::signature: + args.set(i, parse_float()); + break; + case BoolType::signature: + args.set(i, parse_bool()); + break; + case StringType::signature: + args.set(i, parse_string()); + break; + case SymbolType::signature: + args.set(i, parse_symbol()); + break; + } + + if(!sub_remaining.empty()) + --sub_remaining.back(); + sub_remaining.push_back(parse_int()); + cur_info = 0; + + act.execute(ldr, args); + + return true; +} + +IntType::Store BinaryParser::parse_int() +{ + IntType::Store result = 0; unsigned bits = 0; while(in) @@ -108,37 +193,63 @@ long long BinaryParser::parse_int() break; } - const long long mask = 1LL<<(bits-1); + const IntType::Store mask = 1LL<<(bits-1); result = (result^mask)-mask; return result; } -float BinaryParser::parse_float() +FloatType::Store BinaryParser::parse_float() { - union + UInt64 encoded = 0; + for(unsigned i=0; i::is_iec559) + return bf.compose_iec559(); + else + { + /* Put the float together with arithmetic since we don't know its + internal layout */ + FloatType::Store f = 0; + if(bf.infinity) + { + if(numeric_limits::has_infinity) + f = numeric_limits::infinity(); + else + f = numeric_limits::max(); + } + else + { + for(unsigned i=0; i<64; ++i) + { + f /= 2; + if(bf.mantissa&1) + f += 1; + bf.mantissa >>= 1; + } + for(int i=0; ibf.exponent; --i) + f /= 2; + } + if(bf.sign) + f = -f; + return f; + } } -bool BinaryParser::parse_bool() +BoolType::Store BinaryParser::parse_bool() { return in.get(); } -string BinaryParser::parse_string() +StringType::Store BinaryParser::parse_string() { int len = parse_int(); if(len>=0) @@ -153,7 +264,7 @@ string BinaryParser::parse_string() return get_item(strings, -len); } -string BinaryParser::parse_enum() +SymbolType::Store BinaryParser::parse_symbol() { return get_item(strings, parse_int()); }