bool Data::loadFromFileOther(std::ifstream& input_file, std::string header_line, char seperator) {
// Read header
std::string header_token;
std::stringstream header_line_stream(header_line);
while (getline(header_line_stream, header_token, seperator)) {
variable_names.push_back(header_token);
}
num_cols = variable_names.size();
num_cols_no_sparse = num_cols;
// Read body
reserveMemory();
bool error = false;
std::string line;
size_t row = 0;
while (getline(input_file, line)) {
std::string token_string;
double token;
std::stringstream line_stream(line);
size_t column = 0;
while (getline(line_stream, token_string, seperator)) {
std::stringstream token_stream(token_string);
token_stream >> token;
set(column, row, token, error);
++column;
}
++row;
}
num_rows = row;
return error;
}
bool Option<T>::ProcessTokens(std::list<std::string> &tokens) {
assert(0 == name_.compare(tokens.front()) && "option name is mismatched");
if (2 > tokens.size()) {
error() << "error: invalid option: \'" << name_ << '\'' << std::endl;
return false;
}
is_set_ = true;
tokens.pop_front();
while (!tokens.empty()) {
std::istringstream token_stream(tokens.front());
if (!token_stream.good()) {
error() << "error: invalid option: \'" << name_ << '\'' << std::endl;
return false;
}
T value;
token_stream >> value;
values_.push_back(value);
tokens.pop_front();
}
return true;
}
bool ValueOption<T>::ProcessTokens(std::list<std::string> &tokens) {
assert(0 == name_.compare(tokens.front()) && "option name is mismatched");
if (2 != tokens.size()) {
error() << "error: invalid option: \'" << name_ << '\'' << std::endl;
return false;
}
is_set_ = true;
tokens.pop_front();
std::istringstream token_stream(tokens.front());
if (!token_stream.good()) {
error() << "error: invalid option: \'" << name_ << '\'' << std::endl;
return false;
}
token_stream >> value_;
tokens.pop_front();
return true;
}
int
main(int argc, char* argv[])
{
// initialize the environment
SuifEnv* suif_env = new SuifEnv;
suif_env->init();
init_ex5(suif_env);
// transform the input arguments into a stream of input tokens
TokenStream token_stream(argc, argv);
// execute the Module "ex5"
ModuleSubSystem* mSubSystem = suif_env->get_module_subsystem();
mSubSystem->execute("ex5", &token_stream);
delete suif_env;
return 0;
}
int main( int argc, char* argv[] ) {
// initialize the environment
SuifEnv* suif = new SuifEnv;
suif->init();
// import and initialize the necessary libraries
suif->require_module("ion");
suif->require_module("bit_vector");
// transform the input arguments into a stream of
// input tokens
TokenStream token_stream( argc, argv );
// execute the Module "execute"
ModuleSubSystem* mSubSystem = suif->get_module_subsystem();
mSubSystem -> execute( "execute", &token_stream );
delete suif;
return 0;
}
parser(token_list & tl) : tokens(token_stream(tl))
{}
Element Parser::Parse(std::istream& in)
{
std::vector<Element> lexed_elements;
LexResult lex_result(Lex(in, lexed_elements));
strine::Element element;
if (lex_result.Success())
{
TokenStream token_stream(lexed_elements);
strine::Imperative imperative;
while(token_stream.HasTokens())
{
bool success = ParseAny( token_stream, element );
if (false == success)
{
Element token = token_stream.NextToken();
SourceLocation const& location = token.GetSourceLocation();
std::stringstream ss;
ss << "parser("
<< location.GetRow()
<< "): Unrecognized start \""
<< token.ToString()
<< "\"";
Error error(ss.str());
error.SetRow(location.GetRow());
error.SetColumn(location.GetColumn());
// Okay, not sure if I want to mess with this yet.
// This means that we received some un-intelligeable code.
return error;
}
else if (token_stream.HasTokens())
{
// If we have more tokens, then we start doing something
// fun, like putting into an imperative.
imperative.Add(element);
}
else
{
if (imperative.NumberOfElements() > 0)
{
imperative.Add(element);
}
}
}
if (imperative.NumberOfElements() > 0)
{
// Set the element to be returned to this imperative
// element.
element = imperative;
}
}
return element;
}
