ssize_t
Reader::_parse ( const string& line )
{
//PWTRACE("input line(%zu): <%s>", line.size(), line.c_str());
if ( not m_status.empty() )
{
auto& top(m_status.top());
if ( top.node.isBulkString() )
{
return _parseBulkString2(line);
}
}
if ( line.size() < 2 ) RETURN_READER_ERROR("invalid line");
ValueType c(static_cast<ValueType>(line[0]));
switch(c)
{
case ValueType::INTEGER: return _parseInteger(line);
case ValueType::SIMPLE_STRING: return _parseSimpleString(line);
case ValueType::ERROR: return _parseError(line);
case ValueType::BULK_STRING: return _parseBulkString(line);
case ValueType::ARRAY: return _parseArray(line);
}// switch
RETURN_READER_ERROR("invalid identifier");
}
int _parse(LPCWSTR jstr,int pos,int maxlen,Json* jv){
int i = pos;
for(;(uint)i<(uint)maxlen;i++){
if(_isSpaceChar(jstr[i])){
continue;
}else if(jstr[i]=='{'){
jv->_type = json_object;
jv->_objectValue = new ObjectLink<Json::DICTION>;
i = _parseObject(jstr,i+1,maxlen,jv->_objectValue);
}else if(jstr[i]=='['){
jv->_type = json_array;
jv->_arrayValue = new ObjectLink<Json>;
i = _parseArray(jstr,i+1,maxlen,jv->_arrayValue);
}else if(jstr[i]=='\"'){
jv->_type = json_string;
jv->_strValue = new String;
i = _parseString(jstr,i+1,maxlen,jv->_strValue);
}else if(jstr[i]=='\''){
jv->_type = json_binary;
jv->_binaryValue = new Memory<char>;
i = _parseBinary(jstr,i+1,maxlen,jv->_binaryValue);
}else{
int nextPos = _getNextWord(jstr,i,maxlen);
if(_isTrue(jstr,i,nextPos)){
jv->_type = json_boolean;
jv->_boolValue = true;
}else if(_isFalse(jstr,i,nextPos)){
jv->_type = json_boolean;
jv->_boolValue = false;
}else if(_isNull(jstr,i,nextPos)){
}else if(_isDouble(jstr,i,nextPos,jv->_doubleValue)){
jv->_type = json_double;
}else if(_isInteger(jstr,i,nextPos,jv->_intValue)){
jv->_type = json_integer;
}else
return -1;
i = nextPos;
}
break;
}
return i;
}
int _parseAll(LPCWSTR jstr,int pos,int maxlen,Json* jv){
while(_isSpaceChar(jstr[pos])){
pos++;
if(pos==maxlen) return -1;
}
if(jstr[pos]=='\"'){
jv->_type = json_string;
jv->_strValue = new String;
pos = _parseString(jstr,pos+1,maxlen,jv->_strValue);
}else if(jstr[pos]=='\''){
jv->_type = json_binary;
jv->_binaryValue = new Memory<char>;
pos = _parseBinary(jstr,pos+1,maxlen,jv->_binaryValue);
}else if(jstr[pos]=='['){
jv->_type = json_array;
jv->_arrayValue = new ObjectLink<Json>;
pos = _parseArray(jstr,pos+1,maxlen,jv->_arrayValue);
}else if(jstr[pos]=='{'){
jv->_type = json_object;
jv->_objectValue = new ObjectLink<Json::DICTION>;
pos = _parseObject(jstr,pos+1,maxlen,jv->_objectValue);
}else{
int nextPos = _getNextWord(jstr,pos,maxlen);
if(_isTrue(jstr,pos,nextPos)){
jv->_type = json_boolean;
jv->_boolValue = true;
}else if(_isFalse(jstr,pos,nextPos)){
jv->_type = json_boolean;
jv->_boolValue = false;
}else if(_isNull(jstr,pos,nextPos)){
//jv本来就是 null 。
}else if(_isInteger(jstr,pos,nextPos,jv->_intValue)){
jv->_type = json_integer;
}else if(_isDouble(jstr,pos,nextPos,jv->_doubleValue)){
jv->_type = json_double;
}else return -1;
pos = nextPos;
}
return pos;
}
JValue* Parser::_parseValue() {
switch(_cur_token.type()) {
case TT_STRING:
return _parseString();
case TT_INTEGER:
return _parseInt();
case TT_REAL:
return _parseReal();
case TT_TRUE:
return _parseTrue();
case TT_FALSE:
return _parseFalse();
case TT_NULL:
return _parseNull();
case TT_ARRAY_OPEN_BRACE:
return _parseArray();
case TT_OBJECT_OPEN_BRACE:
return _parseObject();
default:
_err = _instream->error();
return NULL;
}
}
ir::Type* TypeParser::_parseType()
{
std::string nextToken = _lexer->peek();
ir::Type* type = nullptr;
if(isFunction(nextToken))
{
type = _parseFunction();
}
else if(isStructure(nextToken))
{
type = _parseStructure();
}
else if(isPrimitive(_compiler, nextToken))
{
type = _parsePrimitive();
nextToken = _lexer->peek();
if(isFunction(nextToken))
{
type = _parseFunction(type);
}
}
else if(isArray(nextToken))
{
type = _parseArray();
}
else if(isVariadic(nextToken))
{
_lexer->scan("...");
type = *_compiler->getOrInsertType(ir::VariadicType(_compiler));
}
else if(isTypeAlias(nextToken))
{
type = _parseTypeAlias();
}
else if(isOpaqueType(nextToken))
{
_lexer->scan("opaque");
type = *_compiler->getOrInsertType(ir::OpaqueType(_compiler));
}
nextToken = _lexer->peek();
while(isPointer(nextToken))
{
_lexer->scan("*");
type = *_compiler->getOrInsertType(ir::PointerType(_compiler, type));
nextToken = _lexer->peek();
}
if(type == nullptr)
{
throw std::runtime_error("Failed to parse type.");
}
hydrazine::log("TypeParser::Parser") << "Parsed type " << type->name
<< ".\n";
return type;
}
