Expression *parseTerm(FILE *source, Expression *lvalue)
{
Token token = scanner(source);
Expression *expr;
int i ;
switch (token.type){
case PlusOp:
case MinusOp:
case Alphabet:
case PrintOp:
for (i = strlen(token.tok) - 1; i >= 0; i--) {
ungetc(token.tok[i], source);
}
return lvalue;
case MulOp:
expr = (Expression *)malloc( sizeof(Expression) );
(expr->v).type = MulNode;
(expr->v).val.op = Mul;
expr->leftOperand = lvalue;
expr->rightOperand = parseValue(source);
return parseTerm(source, expr);
case DivOp:
expr = (Expression *)malloc( sizeof(Expression) );
(expr->v).type = DivNode;
(expr->v).val.op = Div;
expr->leftOperand = lvalue;
expr->rightOperand = parseValue(source);
return parseTerm(source, expr);
default:
printf("In function parseTerm\n");
printf("Syntax Error: Expect a numeric value or an identifier %s\n", token.tok);
exit(1);
}
}
void parseGroup(filesystem::InputStream &stream, int flags)
{
std::string currentLine;
std::string nextLine;
readLine(stream, currentLine);
if(!currentLine.empty() && currentLine[0] == '}')
return;
while(readLine(stream, nextLine))
{
if(nextLine[0] == '{')
{
parseSubGroup(stream, currentLine, flags);
currentLine = "";
continue;
}
parseValue(currentLine, flags);
if(nextLine[0] == '}')
return;
currentLine.swap(nextLine);
}
parseValue(currentLine, flags);
}
Expression *parseExpression( FILE *source, Expression *lvalue )//changed
{
Token token = scanner(source);
Expression *expr;
switch(token.type){
case PlusOp:
expr = (Expression *)malloc( sizeof(Expression) );
(expr->v).type = PlusNode;
(expr->v).val.op = Plus;
expr->leftOperand = lvalue;
expr->rightOperand = parseValue(source);
return parseExpressionTail(source, expr);
case MinusOp:
expr = (Expression *)malloc( sizeof(Expression) );
(expr->v).type = MinusNode;
(expr->v).val.op = Minus;
expr->leftOperand = lvalue;
expr->rightOperand = parseValue(source);
return parseExpressionTail(source, expr);
case Alphabet:
case PrintOp:
ungetstring(token.tok, source);
//ungetc(token.tok[0], source);
return NULL;
case EOFsymbol:
return NULL;
default:
printf("Syntax Error: Expect a numeric value or an identifier %s\n", token.tok);
exit(1);
}
}
Expression *parseTerm(FILE *source, Expression *lvalue)
{
Token token = scanner(source);
Expression *expr;
switch(token.type){
case MulOp:
expr = (Expression *)malloc( sizeof(Expression) );
(expr->v).type = MulNode;
(expr->v).val.op = Mul;
expr->leftOperand = lvalue;
expr->rightOperand = parseValue(source);
return parseTermTail(source, expr);
case DivOp:
expr = (Expression *)malloc( sizeof(Expression) );
(expr->v).type = DivNode;
(expr->v).val.op = Div;
expr->leftOperand = lvalue;
expr->rightOperand = parseValue(source);
return parseTermTail(source, expr);
case Alphabet:
case PrintOp:
case PlusOp:
case MinusOp:
ungetToken(token);
return lvalue;
case EOFsymbol:
return lvalue;
default:
printf("Syntax Error:(parseTerm) Expect a numeric value or an identifier %s\n", token.tok);
exit(1);
}
}
//-------------------------------------------------------
void coTParser::parseEnumeration()
{
parseValue();
while( m_currentToken.m_type == coTLexer::EToken_COMMA)
{
consumeToken();
parseValue();
}
}
CrontabSelector::CrontabSelector(
const dynamic &d,
int64_t min_val,
int64_t max_val,
function<int64_t(const string& lc_str)> str_to_value
) : start_(min_val),
end_(max_val),
period_(1),
minVal_(min_val),
maxVal_(max_val) {
switch (d.type()) {
case dynamic::Type::INT64:
case dynamic::Type::STRING:
sortedValues_.emplace_back(parseValue(d, str_to_value));
break;
case dynamic::Type::ARRAY:
for (const auto& val : d) {
sortedValues_.emplace_back(parseValue(val, str_to_value));
}
// If somebody specifies [] for a selector, we have to silently
// accept it, since PHP's JSON library can morph {} into [], and {}
// must mean "default selector accepting all values."
break;
case dynamic::Type::OBJECT:
for (const auto& pair : d.items()) {
// Interval is first so that it doesn't accept strings like "jan"
if (pair.first == "period") {
period_ = pair.second.asInt();
if (period_ < 1 || period_ >= maxVal_ - minVal_) {
throw runtime_error(format(
"period not in [1, {}]: {}", maxVal_ - minVal_, period_
).str());
}
continue;
}
// For start & end, we are happy to accept string names
auto val = parseValue(pair.second, str_to_value);
if (pair.first == "start") {
start_ = val;
} else if (pair.first == "end") {
end_ = val;
} else {
throw runtime_error(format("Unknown key: {}", pair.first).str());
}
}
// If we got an empty object, no problem -- this selector will
// follow the default of "match everything".
break;
default:
throw runtime_error(format(
"Bad type for crontab selector: {}", d.typeName()
).str());
}
sort(sortedValues_.begin(), sortedValues_.end());
}
// Build an object from the text.
const char*
aJsonClass::parseObject(aJsonObject *item, const char *value)
{
aJsonObject *child;
if (*value != '{')
return NULL; // not an object!
item->type = aJson_Object;
value = skip(value + 1);
if (*value == '}')
return value + 1; // empty array.
item->child = child = newItem();
if (!item->child)
return NULL;
value = skip(parseString(child, skip(value)));
if (!value)
return NULL;
child->name = child->value.valuestring;
child->value.valuestring = NULL;
if (*value != ':')
return NULL; // fail!
value = skip(parseValue(child, skip(value + 1))); // skip any spacing, get the value.
if (!value)
return NULL;
while (*value == ',')
{
aJsonObject *new_item;
if (!(new_item = newItem()))
return NULL; // memory fail
child->next = new_item;
new_item->prev = child;
child = new_item;
value = skip(parseString(child, skip(value + 1)));
if (!value)
return NULL;
child->name = child->value.valuestring;
child->value.valuestring = NULL;
if (*value != ':')
return NULL; // fail!
value = skip(parseValue(child, skip(value + 1))); // skip any spacing, get the value.
if (!value)
return NULL;
}
if (*value == '}')
return value + 1; // end of array
return NULL; // malformed.
}
/* parse the audit record and create libee structure
*/
static rsRetVal
audit_parse(uchar *buf, struct json_object **jsonRoot)
{
struct json_object *json;
struct json_object *jval;
char name[1024];
char val[1024];
DEFiRet;
*jsonRoot = json_object_new_object();
if(*jsonRoot == NULL) {
ABORT_FINALIZE(RS_RET_ERR);
}
json = json_object_new_object();
json_object_object_add(*jsonRoot, "data", json);
while(*buf) {
CHKiRet(parseName(&buf, name, sizeof(name)));
if(*buf != '=') {
ABORT_FINALIZE(RS_RET_ERR);
}
++buf;
CHKiRet(parseValue(&buf, val, sizeof(val)));
jval = json_object_new_string(val);
json_object_object_add(json, name, jval);
}
finalize_it:
RETiRet;
}
//-------------------------------------------------------
void coTParser::parseProperty()
{
coASSERT(m_currentToken.m_type == coTLexer::EToken_IDENTIFIER);
coTSemanticAnalyzer::Property prop;
prop.m_name = m_currentToken;
consumeToken();
if (m_currentToken.m_type != coTLexer::EToken_COLON)
{
prop.m_type.clear();
}
else
{
prop.m_type = m_currentToken;
consumeToken();
}
m_semanticAnalyzer->onProperty(prop);
switch (m_currentToken.m_type)
{
case coTLexer::EToken_EQUAL:
{
consumeToken();
parseValue();
}
break;
case coTLexer::EToken_LBRACE:
{
parsePropertyBlock();
}
break;
default:
{
coFAIL();
}
}
}
bool CSSParser::parseColor(RGBA32& color, const String& string, bool strict)
{
if (string.isEmpty())
return false;
// First try creating a color specified by name, rgba(), rgb() or "#" syntax.
if (CSSPropertyParser::fastParseColor(color, string, strict))
return true;
// In case the fast-path parser didn't understand the color, try the full parser.
RefPtrWillBeRawPtr<MutableStylePropertySet> stylePropertySet = MutableStylePropertySet::create();
// FIXME: The old CSS parser is only working in strict mode ignoring the strict parameter.
// It needs to be investigated why.
if (!parseValue(stylePropertySet.get(), CSSPropertyColor, string, false, strictCSSParserContext()))
return false;
RefPtrWillBeRawPtr<CSSValue> value = stylePropertySet->getPropertyCSSValue(CSSPropertyColor);
if (!value || !value->isPrimitiveValue())
return false;
CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value.get());
if (!primitiveValue->isRGBColor())
return false;
color = primitiveValue->getRGBA32Value();
return true;
}
inline static JSONPair parseMember(const char* string)
{
int stringLength = strlen(string) + 1;
char* memberString = new char[stringLength];
memcpy(memberString, string, stringLength);
memberString[stringLength - 1] = '\0';
char* key = "";
JSONValue value;
//We can't parse the member just yet, we need to know its type
std::vector<std::string> split = StringUtils::splitOnce(memberString, ":");
if (split.size() == 2)
{
const char* memberKeyString = split[0].c_str();
const char* memberValueString = split[1].c_str();
int keyStringLen = strlen(memberKeyString);
value = parseValue(memberValueString);
key = new char[keyStringLen];
memcpy(key, memberKeyString, keyStringLen);
key[keyStringLen - 1] = '\0';
}
delete[] memberString;
return JSONPair(key, value);
}
void JsonParser::parseArray( JsonScanner & scanner, std::vector<JsonValue *> * values ) {
static std::string name( "" );
JsonToken token;
try {
token = scanner.getNextToken();
}
catch ( const std::exception & e ) {
throw;
}
JsonValue * value;
try {
value = parseValue( scanner, token, name );
} catch( const std::exception & e ) {
throw;
}
values->push_back( value );
try {
token = scanner.getNextToken();
} catch( const std::exception & e ) {
throw;
}
if( token.getType() == JsonTypes::COMMA ) {
try {
parseArray( scanner, values );
} catch( std::exception & e ) {
throw;
}
} else if ( token.getType() == JsonTypes::CLOSE_BRACKET ) {
} else {
throw ArrayParsingException();
}
}
Declaration* CssParser::parseDeclaration () {
Declaration* declaration = NULL;
TokenList property;
if (!parseProperty(&property))
return NULL;
skipWhitespace();
declaration = new Declaration(property.toString());
if (tokenizer->getTokenType() != Token::COLON) {
throw new ParseException(tokenizer->getToken()->str,
"colon following property(':')");
}
tokenizer->readNextToken();
skipWhitespace();
TokenList* value = parseValue();
if (value == NULL) {
throw new ParseException(tokenizer->getToken()->str,
"value for property");
}
declaration->setValue(value);
return declaration;
}
Expression *parsePreTerm(FILE *source)
{
Expression *v = parseValue(source);
Expression *term = parseTerm(source, v);
return term;
}
bool LessParser::parseVariable (TokenList &value) {
if (tokenizer->getTokenType() != Token::COLON)
return false;
tokenizer->readNextToken();
skipWhitespace();
if (parseValue(value) == false || value.size() == 0) {
throw new ParseException(tokenizer->getToken(),
"value for variable",
tokenizer->getLineNumber(),
tokenizer->getColumn(),
tokenizer->getSource());
}
if (tokenizer->getTokenType() != Token::DELIMITER) {
throw new ParseException(tokenizer->getToken(),
"delimiter (';') at end of @-rule",
tokenizer->getLineNumber(),
tokenizer->getColumn(),
tokenizer->getSource());
}
tokenizer->readNextToken();
skipWhitespace();
return true;
}
void XmlRpc::parseCall(const QByteArray& call, QByteArray& function, QList<QVariant>& args)
{
QDomDocument doc;
QDomElement root;
QString msg;
QList<QVariant> values;
if(!doc.setContent(call, false, &msg))
throw RuntimeException(msg);
root = doc.documentElement();
if(root.tagName() != "methodCall")
throw RuntimeException(QObject::tr("Not a XML-RPC call"));
QDomElement methodName = root.firstChildElement("methodName");
if(methodName.isNull())
throw RuntimeException(QObject::tr("Not a valid XML-RPC call"));
function = methodName.firstChild().toText().data().toAscii();
QDomElement e = root.firstChildElement("params");
if(!e.isNull())
{
QDomElement p = e.firstChildElement("param");
while(!p.isNull())
{
QDomElement value = p.firstChildElement("value");
if(value.isNull())
throw RuntimeException(QObject::tr("Invalid XML-RPC call"));
args << parseValue(value);
p = p.nextSiblingElement("param");
}
}
}
const wchar_t* TcJSONObject::fromObject(const QString&, const wchar_t* ptr)
{
ptr = skip(ptr);
if (*ptr == L'{')
{
setType(vtfObject);
do
{
ptr = skip(++ptr);
QString Key;
ptr = skip(parseKey(Key, ptr));
if (*ptr == L':')
{
ptr = skip(++ptr);
ptr = parseValue(Key, ptr);
}
ptr = skip(ptr);
} while (ptr && *ptr && *ptr == ',');
if (ptr && *ptr == L'}')
{
ptr = skip(++ptr);
}
else
{
ptr = 0;
}
}
return ptr;
}
UnprocessedStatement* LessParser::parseRulesetStatement (LessRuleset &ruleset) {
UnprocessedStatement* statement;
Selector tokens;
size_t property_i;
while (parseProperty(tokens) || parsePropertyVariable(tokens)) {}
property_i = tokens.size();
parseWhitespace(tokens);
parseSelector(tokens);
tokens.trim();
if (tokens.empty())
return NULL;
statement = ruleset.createUnprocessedStatement();
statement->getTokens()->swap(tokens);
statement->property_i = property_i;
if (tokenizer->getTokenType() == Token::BRACKET_OPEN)
return statement;
parseValue(*statement->getTokens());
if (tokenizer->getTokenType() == Token::DELIMITER) {
tokenizer->readNextToken();
skipWhitespace();
}
return statement;
}
QPair<QStringRef,QStringRef> QDeclarativeStyledTextPrivate::parseAttribute(const QChar *&ch, const QString &textIn)
{
skipSpace(ch);
int attrStart = ch - textIn.constData();
int attrLength = 0;
while (!ch->isNull()) {
if (*ch == greaterThan) {
break;
} else if (*ch == equals) {
++ch;
if (*ch != singleQuote && *ch != doubleQuote) {
while (*ch != greaterThan && !ch->isNull())
++ch;
break;
}
++ch;
if (!attrLength)
break;
QStringRef attr(&textIn, attrStart, attrLength);
QStringRef val = parseValue(ch, textIn);
if (!val.isEmpty())
return QPair<QStringRef,QStringRef>(attr,val);
break;
} else {
++attrLength;
}
++ch;
}
return QPair<QStringRef,QStringRef>();
}
MVJSONNode* MVJSONReader::parse(string text)
{
string s = trim(text);
if (s.length() < 2) return NULL;
// object
if ((s[0] == '{') && (s[s.length() - 1] == '}'))
{
// erase last and first symbols
s.erase(0, 1);
s.erase(s.length() - 1, 1);
vector<string> parts;
splitList(s, parts);
MVJSONNode* node = new MVJSONNode();
for (int i = 0; i < parts.size(); i++)
node->values.push_back(parseValue(parts.at(i), false));
return node;
}
return NULL;
}
Statement parseStatement( FILE *source, Token token )
{
Token next_token;
Expression *value, *term,*expr;
switch(token.type){
case Alphabet:
next_token = scanner(source);
if(next_token.type == AssignmentOp){
value = parseValue(source);
term = parseTerm(source, value);
expr = parseExpression(source, term);
return makeAssignmentNode(token.tok, value, expr);
}
else{
printf("Syntax Error: Expect an assignment op %s\n", next_token.tok);
exit(1);
}
case PrintOp:
next_token = scanner(source);
if(next_token.type == Alphabet)
return makePrintNode(next_token.tok);
else{
printf("Syntax Error: Expect an identifier %s\n", next_token.tok);
exit(1);
}
break;
default:
printf("Syntax Error: Expect a statement %s\n", token.tok);
exit(1);
}
}
MVJSONValue* MVJSONReader::parseValue(string text, bool hasNoName)
{
string key;
string s;
splitInHalf(text, ":", key, s);
key = trim(key);
s = trim(s);
if (key.length() > 2)
{
// strip "
key.erase(0, 1);
key.erase(key.length() - 1, 1);
}
if (hasNoName)
{
s = text;
key = "";
}
if (s == "false") // bool
return new MVJSONValue(key, false);
if (s == "true") // bool
return new MVJSONValue(key, true);
if (s == "null") // null
return new MVJSONValue(key, MVJSON_TYPE_NULL);
char first = s[0];
if (first == '"') // string
return new MVJSONValue(key, s.substr(1, s.length() - 2));
if (first == '{') // object
return new MVJSONValue(key, parse(s));
if (first == '[') // array
{
s.erase(0, 1);
s.erase(s.length() - 1, 1);
vector<string> parts;
splitList(s, parts);
MVJSONValue* val = new MVJSONValue(key, MVJSON_TYPE_ARRAY);
for (int i = 0; i < parts.size(); i++)
val->arrayValue.push_back(parseValue(parts.at(i), true));
return val;
}
// else its number!
if (s.find(".") == string::npos)
return new MVJSONValue(key, stringToInt(s));
else
return new MVJSONValue(key, stringToDouble(s));
}
int
Options::handleFixed( SimpleArg &arg, int & /*argno*/ )
{
if ( ST_CMD == m_state ) {
if ( !lookupCommand( arg ) ) {
fprintf(stderr, "Invalid command '%s'\n", arg.Arg() );
printf("%s", m_usage);
m_state = ST_NONE;
return -1;
}
if ( CMD_LIST == m_command ) {
m_state = ST_NONE;
return 1;
}
else if ( CMD_DUMP == m_command ) {
m_field = lookupField( "all" );
if ( NULL == m_field ) {
assert( 0 );
}
}
m_state = ST_FILE;
}
else if ( ST_FILE == m_state ) {
m_file = arg.Arg();
m_state = ST_FIELD;
}
else if ( ST_FIELD == m_state ) {
m_field = lookupField( arg );
if ( NULL == m_field ) {
fprintf(stderr, "Invalid field '%s'\n", arg.Arg() );
printf("%s", m_usage);
m_state = ST_NONE;
return -1;
}
if ( 0 == m_field->m_max_values ) {
m_state = ST_NONE;
return 1;
}
m_state = ST_VALUES;
}
else if ( ( ST_VALUES == m_state ) &&
( m_field ) &&
( m_num_values < m_field->m_max_values ) ) {
if ( !parseValue( arg ) ) {
fprintf(stderr, "Invalid value for %s: '%s'\n",
m_field->m_name, arg.Arg() );
return -1;
}
m_num_values++;
}
else {
fprintf(stderr, "Unexpected arg '%s'\n", arg.Arg() );
return -1;
}
return 0;
}
QVariant XmlRpc::parseResponse(const QByteArray& response)
{
QDomDocument doc;
QDomElement root;
QString msg;
bool bFault;
if(!doc.setContent(response, false, &msg))
throw RuntimeException(msg);
root = doc.documentElement();
if(root.tagName() != "methodResponse")
throw RuntimeException(QObject::tr("Not a XML-RPC response"));
QDomElement e = root.firstChildElement();
if(e.tagName() == "fault")
bFault = true;
else if(e.tagName() == "params")
bFault = false;
else
throw RuntimeException(QObject::tr("Not a XML-RPC response"));
if(!bFault)
{
QDomElement p = e.firstChildElement("param");
if(p.isNull())
return QVariant();
QDomElement value = p.firstChildElement("value");
if(value.isNull())
throw RuntimeException(QObject::tr("Invalid XML-RPC response"));
return parseValue(value);
}
else
{
QDomElement value = e.firstChildElement("value");
if(value.isNull())
throw RuntimeException(QObject::tr("Server is indicating an unknown failure"));
QMap<QString, QVariant> v = parseValue(value).toMap();
throw RuntimeException(QString("%1 %2").arg(v["faultCode"].toString()).arg(v["faultString"].toString()));
}
}
// Build an array from input text.
int
aJsonClass::parseArray(aJsonObject *item, FILE* stream, char** filter)
{
int in = fgetc(stream);
if (in != '[')
{
return EOF; // not an array!
}
item->type = aJson_Array;
skip(stream);
in = fgetc(stream);
//check for empty array
if (in == ']')
{
return 0; // empty array.
}
//now put back the last character
ungetc(in, stream);
aJsonObject *child;
char first = -1;
while ((first) || (in == ','))
{
aJsonObject *new_item = newItem();
if (new_item == NULL)
{
return EOF; // memory fail
}
if (first)
{
item->child = new_item;
first = 0;
}
else
{
child->next = new_item;
new_item->prev = child;
}
child = new_item;
skip(stream);
if (parseValue(child, stream, filter))
{
return EOF;
}
skip(stream);
in = fgetc(stream);
}
if (in == ']')
{
return 0; // end of array
}
else
{
return EOF; // malformed.
}
}
bool parseObject(File& file, Object& out_obj)
{
file.str++; // consume '{'
skipWhitespaces(file);
while(*file.str != '}')
{
std::string key;
uint32_t key_line_num = file.current_line_num;
if(!parseIdentifier(file, key))
{
std::cout << "Line " << key_line_num << ": Error parsing identifier!\n";
return false;
}
else if(key.empty())
{
std::cout << "Line " << key_line_num << ": Identifier can't be an empty string!\n";
return false;
}
if(out_obj[key] != nullptr)
{
std::cout << "Line " << key_line_num << ": Key '" << key << "' already exists!\n";
return false;
}
skipWhitespaces(file);
if(*file.str != '=')
{
std::cout << "Line " << file.current_line_num << ": Expected '=' not found!\n";
return false;
}
file.str++; //consume '='
skipWhitespaces(file);
Value value;
if(!parseValue(file, value))
return false;
out_obj.insert(std::move(key), std::move(value), key_line_num);
skipWhitespaces(file);
}
//consume '}'
file.str++;
return true;
}
boost::shared_ptr<CSMFilter::Node> CSMFilter::Parser::parseImp (bool allowEmpty, bool ignoreOneShot)
{
if (Token token = getNextToken())
{
if (token==Token (Token::Type_OneShot))
token = getNextToken();
if (token)
switch (token.mType)
{
case Token::Type_Keyword_True:
return boost::shared_ptr<CSMFilter::Node> (new BooleanNode (true));
case Token::Type_Keyword_False:
return boost::shared_ptr<CSMFilter::Node> (new BooleanNode (false));
case Token::Type_Keyword_And:
case Token::Type_Keyword_Or:
return parseNAry (token);
case Token::Type_Keyword_Not:
{
boost::shared_ptr<CSMFilter::Node> node = parseImp();
if (mError)
return boost::shared_ptr<Node>();
return boost::shared_ptr<CSMFilter::Node> (new NotNode (node));
}
case Token::Type_Keyword_Text:
return parseText();
case Token::Type_Keyword_Value:
return parseValue();
case Token::Type_EOS:
if (!allowEmpty)
error();
return boost::shared_ptr<Node>();
default:
error();
}
}
return boost::shared_ptr<Node>();
}
bool CommandAttribute::check(const char *data)
{
StringTokenizer st(data);
string name = st.next();
string val = parseValue( string(data) );
if(name.empty() || ( val.empty() && m_type != AttributeType::NONE ) )
return false;
//check if the attribute hasn't already been processed
if (m_dirty)
return false;
//check name
if(strcmp(name.c_str(), m_name) != 0)
return false;
//check attribute type
switch(m_type)
{
case AttributeType::INTEGER:
if(val.find_first_not_of("-1234567890") != string::npos)
return false;
break;
case AttributeType::FLOAT:
if(val.find_first_not_of("-1234567890.") != string::npos)
return false;
break;
case AttributeType::STRING:
{
bool containsNumbers = (val.find_first_of("-1234567890.") != string::npos);
bool containsNonNumbers = (val.find_first_not_of("-1234567890.<>\"") != string::npos);
if(containsNumbers && !containsNonNumbers)
return false;
break;
}
case AttributeType::VEC3F:
{
size_t xpos = val.find_first_of('x');
if(xpos == string::npos)
return false;
size_t ypos = val.find_first_of('y');
if(ypos == string::npos)
return false;
size_t zpos = val.find_first_of('z');
if(zpos == string::npos)
return false;
break;
}
}
return true;
}
InputMatrix::InputMatrix(std::istream& input)
{
START_COLLECT_TIME(readingInput, Counters::ReadingInput);
input >> _rowsCount;
input >> _qColsCount;
_qMatrix = new int[_rowsCount * _qColsCount];
_qMinimum = new int[_qColsCount];
_qMaximum = new int[_qColsCount];
for(auto j=0; j<_qColsCount; ++j) {
_qMinimum[j] = DASH;
_qMaximum[j] = DASH;
}
for(auto i=0; i<_rowsCount; ++i) {
for(auto j=0; j<_qColsCount; ++j) {
auto value = parseValue(input);
setFeature(i, j, value);
if (value != DASH) {
if (_qMinimum[j] == DASH || value < _qMinimum[j])
_qMinimum[j] = value;
if (_qMaximum[j] == DASH || _qMaximum[j] < value)
_qMaximum[j] = value;
}
}
}
input >> _rColsCount;
_rMatrix = new int[_rowsCount * _rColsCount];
for(auto i=0; i<_rowsCount; ++i) {
for(auto j=0; j<_rColsCount; ++j) {
setImage(i, j, parseValue(input));
}
}
_r2Matrix = new int[_rowsCount];
STOP_COLLECT_TIME(readingInput);
START_COLLECT_TIME(preparingInput, Counters::PreparingInput);
calcR2Matrix();
sortMatrix();
calcR2Indexes();
STOP_COLLECT_TIME(preparingInput);
}
CCObject *CCJson::parseObject(Json *pJson) {
CCDictionary *root = CCDictionary::create();
for (Json *item = pJson; item; item = item->next) {
CCObject *value = parseValue(item);
if (value) {
root->setObject(value, item->name);
}
}
return root;
}
