bool parse(const char * const name, __Matrix &matrix) { std::vector<double> row; matrix.clear(); if (_fd == nullptr) _fd = fopen(name, "r"); if (_fd == nullptr) return false; next(); while (!eof()) { _buffer.clear(); parseNumber(); if (_buffer.size() > 0) { row.push_back(atof(_buffer.c_str())); } if (isEndOfLine()) { skipEndOfLine(); matrix.push_back(row); row.clear(); } } if (row.size() > 0) matrix.push_back(row); fclose(_fd); _fd = nullptr; return true; }
std::vector<std::vector<Type>> parse(const char * const name) { std::vector<std::vector<Type>> matrix; matrix.clear(); std::vector<Type> row; if (_fd == nullptr) _fd = fopen(name, "r"); if (_fd == nullptr) return matrix; next(); while (!eof()) { _buffer.clear(); parseNumber(); if (_buffer.size() > 0) { row.push_back(atof(_buffer.c_str())); } if (isEndOfLine()) { skipEndOfLine(); matrix.push_back(row); row.clear(); } } if (row.size() > 0) matrix.push_back(row); fclose(_fd); _fd = nullptr; return matrix; }
static int drainWhitespace(FILE *f, int c) { if (c == 0) c = getc(f); while (c > 0 && (c == '#' || c == ' ' || c == '\t')) { if (c == '#') { skipEndOfLine(f, c); c = '\n'; break; } c = getc(f); } return (c > 0) ? c : 0; }
void parseGoal(B& in, S& solver) { skipWhitespace(in); if (!skipText(in, "min:")) return; // No goal specified. If file is syntactically correct, no characters will have been consumed (expecting integer). vec<Lit> ps; vec<Int> Cs; vec<char> tmp; skipWhitespace(in); if (*in == ';'){ ++in; skipLine(in); }else{ parseExpr(in, solver, ps, Cs, tmp); skipWhitespace(in); if (!skipText(in, ";")) throw xstrdup("Expecting ';' after goal function."); } skipEndOfLine(in); solver.addGoal(ps, Cs); }
bool parseConstrs(B& in, S& solver) { vec<Lit> ps; vec<Int> Cs; vec<char> tmp; int ineq; Int rhs; while (*in != EOF){ parseExpr(in, solver, ps, Cs, tmp); ineq = parseInequality(in); rhs = parseInt(in); skipWhitespace(in); if (!skipText(in, ";")) throw xstrdup("Expecting ';' after constraint."); skipEndOfLine(in); if (!solver.addConstr(ps, Cs, rhs, ineq)) return false; ps.clear(); Cs.clear(); } return true; }
/** gcc-7 generates wrong code with optimization level greater than 1. * See tests: dbms/src/IO/tests/write_int.cpp * and dbms/tests/queries/0_stateless/00898_parsing_bad_diagnostic_message.sh * This is compiler bug. The bug does not present in gcc-8 and clang-8. * Nevertheless, we don't need high optimization of this function. */ bool OPTIMIZE(1) CSVRowInputStream::parseRowAndPrintDiagnosticInfo(MutableColumns & columns, WriteBuffer & out, size_t max_length_of_column_name, size_t max_length_of_data_type_name) { const char delimiter = format_settings.csv.delimiter; for (size_t input_position = 0; input_position < column_indexes_for_input_fields.size(); ++input_position) { if (input_position == 0 && istr.eof()) { out << "<End of stream>\n"; return false; } if (column_indexes_for_input_fields[input_position].has_value()) { const auto & column_index = *column_indexes_for_input_fields[input_position]; const auto & current_column_type = data_types[column_index]; out << "Column " << input_position << ", " << std::string((input_position < 10 ? 2 : input_position < 100 ? 1 : 0), ' ') << "name: " << header.safeGetByPosition(column_index).name << ", " << std::string(max_length_of_column_name - header.safeGetByPosition(column_index).name.size(), ' ') << "type: " << current_column_type->getName() << ", " << std::string(max_length_of_data_type_name - current_column_type->getName().size(), ' '); BufferBase::Position prev_position = istr.position(); BufferBase::Position curr_position = istr.position(); std::exception_ptr exception; try { skipWhitespacesAndTabs(istr); prev_position = istr.position(); current_column_type->deserializeAsTextCSV(*columns[column_index], istr, format_settings); curr_position = istr.position(); skipWhitespacesAndTabs(istr); } catch (...) { exception = std::current_exception(); } if (curr_position < prev_position) throw Exception("Logical error: parsing is non-deterministic.", ErrorCodes::LOGICAL_ERROR); if (isNumber(current_column_type) || isDateOrDateTime(current_column_type)) { /// An empty string instead of a value. if (curr_position == prev_position) { out << "ERROR: text "; verbosePrintString(prev_position, std::min(prev_position + 10, istr.buffer().end()), out); out << " is not like " << current_column_type->getName() << "\n"; return false; } } out << "parsed text: "; verbosePrintString(prev_position, curr_position, out); if (exception) { if (current_column_type->getName() == "DateTime") out << "ERROR: DateTime must be in YYYY-MM-DD hh:mm:ss or NNNNNNNNNN (unix timestamp, exactly 10 digits) format.\n"; else if (current_column_type->getName() == "Date") out << "ERROR: Date must be in YYYY-MM-DD format.\n"; else out << "ERROR\n"; return false; } out << "\n"; if (current_column_type->haveMaximumSizeOfValue()) { if (*curr_position != '\n' && *curr_position != '\r' && *curr_position != delimiter) { out << "ERROR: garbage after " << current_column_type->getName() << ": "; verbosePrintString(curr_position, std::min(curr_position + 10, istr.buffer().end()), out); out << "\n"; if (current_column_type->getName() == "DateTime") out << "ERROR: DateTime must be in YYYY-MM-DD hh:mm:ss or NNNNNNNNNN (unix timestamp, exactly 10 digits) format.\n"; else if (current_column_type->getName() == "Date") out << "ERROR: Date must be in YYYY-MM-DD format.\n"; return false; } } } else { static const String skipped_column_str = "<SKIPPED COLUMN>"; out << "Column " << input_position << ", " << std::string((input_position < 10 ? 2 : input_position < 100 ? 1 : 0), ' ') << "name: " << skipped_column_str << ", " << std::string(max_length_of_column_name - skipped_column_str.length(), ' ') << "type: " << skipped_column_str << ", " << std::string(max_length_of_data_type_name - skipped_column_str.length(), ' '); String tmp; readCSVString(tmp, istr, format_settings.csv); } /// Delimiters if (input_position + 1 == column_indexes_for_input_fields.size()) { if (istr.eof()) return false; /// we support the extra delimiter at the end of the line if (*istr.position() == delimiter) { ++istr.position(); if (istr.eof()) break; } if (!istr.eof() && *istr.position() != '\n' && *istr.position() != '\r') { out << "ERROR: There is no line feed. "; verbosePrintString(istr.position(), istr.position() + 1, out); out << " found instead.\n" " It's like your file has more columns than expected.\n" "And if your file have right number of columns, maybe it have unquoted string value with comma.\n"; return false; } skipEndOfLine(istr); } else { try { assertChar(delimiter, istr); } catch (const DB::Exception &) { if (*istr.position() == '\n' || *istr.position() == '\r') { out << "ERROR: Line feed found where delimiter (" << delimiter << ") is expected." " It's like your file has less columns than expected.\n" "And if your file have right number of columns, maybe it have unescaped quotes in values.\n"; } else { out << "ERROR: There is no delimiter (" << delimiter << "). "; verbosePrintString(istr.position(), istr.position() + 1, out); out << " found instead.\n"; } return false; } } } return true; }