bool FileHelper::load_file_house_back(const string pcap_file, list< uint64_t>& stamps){
string file_path = pcap_file + "_houseback.txt";
fstream in_file(file_path);
if (!in_file.good()) {
cout << "file house back empty :" << file_path << endl;
return false;
}
int pointcount = 0;
double tempTime = 0.0;
string str_line;
vector< string> arr_strs;
uint64_t stamp = 0;
int frame = 0;
while (!in_file.eof()) {
getline(in_file, str_line, '\n');
if(in_file.fail())
{
in_file.clear(in_file.rdstate() & ~(ifstream::failbit));
}
stringstream stream;
stream << str_line;
stream >> stamp;
if (stamp != 0) {
stamps.push_back(stamp);
}
}
in_file.close();
return true;
}
bool FileHelper::load_file_glass(const string pcap_file,
map< uint64_t, uint64_t>& intensity){
string file_path = pcap_file + "_glass.txt";
fstream in_file(file_path);
if (!in_file.good()) {
cout << "file house back empty :" << file_path << endl;
return false;
}
int pointcount = 0;
double tempTime = 0.0;
string str_line;
vector< string> arr_strs;
uint64_t stamp = 0;
int frame = 0;
while (!in_file.eof()) {
getline(in_file, str_line, '\n');
if(in_file.fail())
{
in_file.clear(in_file.rdstate() & ~(ifstream::failbit));
}
arr_strs = StringHelper::split(std::string(str_line), " ");
if (arr_strs.size() == 2) {
stringstream stream;
stream << arr_strs[0];
stream >> stamp;
if (stamp != 0) {
stream.clear();
stream << arr_strs[1];
stream >> intensity[stamp];
}
}
void
Printer::initUserSections(const char* name)
{
user_sections_.clear();
std::ifstream in_file(name);
if(!in_file) {
return;
}
std::string section;
std::string section_name;
std::string line;
while(std::getline(in_file, line)) {
if(!line.compare( 0, 29, "// BEGIN USER INSERT SECTION " )) {
section_name = line.substr( 29 );
while(std::getline( in_file, line )) {
if(!line.compare( 0, 27, "// END USER INSERT SECTION " )) {
user_sections_[section_name] = section;
section = "";
break;
}
section.append(line);
section.append("\n");
}
}
}
in_file.close();
}
void read_files(Model *m, const std::vector<std::string>& files,
std::vector<std::string>& pdb_file_names,
std::vector<std::string>& dat_files,
std::vector<IMP::Particles>& particles_vec,
Profiles& exp_profiles, bool residue_level,
bool heavy_atoms_only, int multi_model_pdb,
bool explicit_water, float max_q, int units) {
for (unsigned int i = 0; i < files.size(); i++) {
// check if file exists
std::ifstream in_file(files[i].c_str());
if (!in_file) {
IMP_WARN("Can't open file " << files[i] << std::endl);
return;
}
// 1. try as pdb
try {
read_pdb(m, files[i], pdb_file_names, particles_vec, residue_level,
heavy_atoms_only, multi_model_pdb, explicit_water);
}
catch (const IMP::ValueException &e) { // not a pdb file
// 2. try as a dat profile file
IMP_NEW(Profile, profile, (files[i], false, max_q, units));
if (profile->size() == 0) {
IMP_WARN("can't parse input file " << files[i] << std::endl);
return;
} else {
dat_files.push_back(files[i]);
exp_profiles.push_back(profile);
IMP_LOG_TERSE("Profile read from file " << files[i]
<< " size = " << profile->size() << std::endl);
}
}
}
}
int main(int argc, char** argv) {
if( argc < 2) {
std::cerr << std::endl << "\tUsage is: " << argv[0] << " <text_file_with_values>" << std::endl;
} else {
std::string input_file = argv[1];
std::cout << std::endl << "Processing file: " << input_file << std::endl;
std::ifstream in_file(input_file.c_str());
std::string line = "";
std::vector<gpr_fit_values> data;
if(in_file) {
std::cout << "Checking Data string: " << std::endl;
while(getline(in_file,line)) {
if(line[0] == '#') continue;
gpr_fit_values data_temp;
std::stringstream ss;
ss.str(line.c_str());
ss >> data_temp.index >> data_temp.arm >> data_temp.charge
>> data_temp.dw23_bin_center >> data_temp.wness_bin_center
>> data_temp.value >> data_temp.uncertainty;
std::cout << "\t" << data_temp.GetDataString() << std::endl;
data.push_back(data_temp);
}
std::cout << " Lines successfully extracted: " << data.size() << std::endl;
std::cout << " Done." << std::endl;
} else {
std::cerr << std::endl << "Badly formatted input file string, or problem opening file." << std::endl;
}
}
void SegmentationDataLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
SegmentationDataParameter data_param = this->layer_param_.segmentation_data_param();
const string source = data_param.source();
const bool shuffle = data_param.shuffle();
const int batch_size = data_param.batch_size();
const bool has_manipulation_data = data_param.has_manipulation_data();
for(int i = 0; i < data_param.mean_value_size(); ++i){
mean_values_.push_back(data_param.mean_value(i));
}
string image_path;
string gt_image_path;
float mp_x;
float mp_y;
LOG(INFO) << "Opening file " << source;
std::ifstream in_file(source.c_str());
if(has_manipulation_data){
while(in_file >> image_path >> gt_image_path >> mp_x >> mp_y){
ImagePair pair;
pair.image = image_path;
pair.gt_image = gt_image_path;
pair.mp_x = mp_x;
pair.mp_y = mp_y;
image_pairs_.push_back(pair);
}
}else{
void fillUnmatchedChunkData(vector<bool> indexes, vector<Chunk> chunkHead, string path, queue<chunkdat> *unmatchedChunks){
ifstream in_file(path.c_str(),std::ifstream::binary);
DeltaHandler deltahandler;
int beforeEncode=0,afterencode=0;
for(int y=0;y<indexes.size();y++){
chunkdat ch_data;
if(!indexes[y]){
Bytef sourceblock[1024*65]={0};
int value = y;
in_file.seekg(chunkHead[value].getOffset(),in_file.beg);
in_file.read((char *)sourceblock,chunkHead[value].getLength());
Bytef* deltachunk;
unsigned long int deltasize=0;
deltahandler.getDeltaBlock(sourceblock,chunkHead[value].getLength(),&deltachunk,&deltasize);
beforeEncode+=chunkHead[value].getLength();
afterencode+=deltasize;
ch_data.chunk_size=deltasize;
memcpy(ch_data.data,reinterpret_cast<char *>(deltachunk),deltasize);
unmatchedChunks->push(ch_data);
deltachunk=NULL;
}
}
in_file.close();
cout<<"Total size before delta encode:"<<beforeEncode<<endl;
cout<<"Total size after delta encode:"<<afterencode<<endl;
}
std::string Message::message_string (int n) const
{
// Output string stream where we will put the text of the message
std::ostringstream oss;
std::ifstream in_file(_file_path.c_str());
std::string line;
if ( in_file.is_open() )
{
// Counter to keep track of how many lines we already got
int counter(0);
/* Put each line of the file in the output stream
* until counter = n or we are at the end of the file */
while ( (!(counter == n)) && (!in_file.eof()) )
{
getline(in_file, line);
oss << line << std::endl;
counter++;
}
in_file.close();
// Return the actual string of the oss
return oss.str(); // Return the actual string of the oss
}
else
throw std::runtime_error("unable to open message: " + _file_path);
}
void convert_matrices(const std::string &in, const std::string &out) {
std::ifstream in_file(in);
// TODO check if in file exists
std::ofstream out_file(out, std::ofstream::trunc);
std::string line;
int line_num = 0;
while (std::getline(in_file, line)) {
std::istringstream line_stream(line);
std::stringstream output_stream;
out_file << line_num << ' ';
++line_num;
bool c;
int c_num = 0;
int matches = 0;
while (line_stream >> c) {
if (c) {
++matches;
output_stream << ' ' << c_num;
}
++c_num;
}
// construct line
out_file << matches << output_stream.str() << std::endl;
}
in_file.close();
out_file.close();
}
base::OptionalError read_file( boost::string_ref path, base::data_t & buffer, bool append_buffer ) {
std::ifstream in_file( path.to_string( ), std::ifstream::ate | std::ifstream::binary );
if( !in_file ) {
auto result = base::create_optional_error( "Could not open file" );
result->add( "where", "read_file#open" );
return result;
}
auto fsize = in_file.tellg( );
if( fsize < 0 ) {
auto result = base::create_optional_error( "Error reading file length" );
result->add( "where", "read_file#tellg" );
return result;
}
if( !in_file.seekg( 0 ) ) {
auto result = base::create_optional_error( "Error reseting file position to beginning" );
result->add( "where", "read_file#seekg" );
return result;
}
size_t first_pos = append_buffer ? buffer.size( ) : 0;
buffer.resize( first_pos + static_cast<size_t>(fsize) );
if( !in_file.read( buffer.data( ) + first_pos, fsize ) ) {
auto result = base::create_optional_error( "Error reading file" );
result->add( "where", "read_file#read" );
return result;
}
return base::create_optional_error( );
}
void
Formula::InitFromFile( const char *filename )
{
assert( filename != nullptr );
/** open file **/
std::ifstream in_file( filename, std::ifstream::in );
if( in_file.is_open() )
{
/*
std::stringstream ss;
std::string line;
while( in_file.good() )
{
std::getline( in_file, line );
ss << line;
}
in_file.close();
*/
load( in_file );
in_file.close();
}
else
{
/* couldn't open file!! */
std::cerr << "Failed to open file \"" << filename << "\", exiting!!\n";
exit( EXIT_FAILURE );
}
}
IMPINTEGRATIVEDOCKING_BEGIN_INTERNAL_NAMESPACE
void ResidueContent::read_content_file(const std::string& file_name) {
std::ifstream in_file(file_name.c_str());
if (!in_file) {
IMP_THROW("Can't open file " << file_name, IMP::IOException);
}
std::string line;
while (!in_file.eof()) {
getline(in_file, line);
boost::trim(line); // remove all spaces
// skip comments
if (line[0] == '#' || line[0] == '\0') continue;
std::vector<std::string> split_results;
boost::split(split_results, line, boost::is_any_of("\t "),
boost::token_compress_on);
if (split_results.size() != 2) continue;
int counter = atoi(split_results[1].c_str());
IMP::atom::ResidueType residue_type =
IMP::atom::ResidueType(split_results[0]);
residue_content_[residue_type] = counter;
}
in_file.close();
}
int main(int argc, char* argv[])
{
// Open the input file and read a polygon.
const char* filename = (argc > 1) ? argv[1] : "tight.dat";
std::ifstream in_file(filename);
if (! in_file.is_open()) {
std::cerr << "Failed to open the input file." << std::endl;
return -1;
}
// Read the input polygon.
Linear_polygon P;
in_file >> P;
in_file.close();
std::cout << "Read an input polygon with " << P.size() << " vertices."
<< std::endl;
// Approximate the offset polygon.
std::list<Polygon_2> inset_polygons;
boost::timer timer;
approximated_inset_2(P, 1, 0.00001, std::back_inserter(inset_polygons));
double secs = timer.elapsed();
std::list<Polygon_2>::iterator it;
std::cout << "The inset comprises " << inset_polygons.size()
<< " polygon(s)." << std::endl;
for (it = inset_polygons.begin(); it != inset_polygons.end(); ++it)
std::cout << " Polygon with " << it->size() << " vertices." << std::endl;
std::cout << "Inset computation took " << secs << " seconds." << std::endl;
return 0;
}
void PSLang::Driver::compile(const std::string& filename,
const std::string& outputFile) {
if (_isVerbose) {
std::cout << "Compilation started!" << std::endl << "Input file: "
<< filename << std::endl << "Output file: " << outputFile
<< std::endl;
}
std::ifstream in_file(filename);
if (!in_file.good())
exit(EXIT_FAILURE);
scanner = std::unique_ptr<PSLang::Scanner>(new PSLang::Scanner(&in_file));
parser = std::unique_ptr<PSLang::Parser>(
new PSLang::Parser((*scanner) /* scanner */, (*this) /* driver */));
if (parser->parse() == FAIL) {
std::cerr << "Parse failed!!\n";
}
CodeGenBase* codeGenerator;
if(llvmMode)
{
codeGenerator = new CodeGenLLVM(outputFile);
}
else
{
codeGenerator = new CodeGen(outputFile);
}
codeGenerator->generateCode(*programBlock);
if (_isVerbose) {
std::cout << "Compilation ended successfully!" << std::endl;
}
}
int main(int argc, char ** argv) {
try {
using float_t = double;
using size_type = std::uint32_t;
if (4 != argc)
throw std::invalid_argument("usage: simplify <<t> | -p> <in_file> <out_file>");
// read the flow complex from file
auto fc = FC::flow_complex<float_t, size_type>(42, 42); // dummy
{
auto in_filename = argv[2];
std::ifstream in_file(in_filename);
in_file >> fc;
}
char const* action = argv[1];
if (std::string(action) == "-p") {
char const* out_filename = argv[3];
std::ofstream out_file(out_filename);
print_histogram(out_file, std::move(fc));
} else {
// simplify
float_t const t = std::atof(argv[1]);
if (t < 1)
throw std::invalid_argument("prerequisite: t >= 1");
fc = simplify(std::move(fc), t);
// write result flow complex to file
char const* out_filename = argv[3];
std::ofstream out_file(out_filename);
out_file << fc;
}
} catch (std::exception & e) {
std::cerr << e.what() << std::endl;
std::exit(EXIT_FAILURE);
}
std::exit(EXIT_SUCCESS);
}
PBM_Image::PBM_Image(const std::string &file_name)
{
std::ifstream in_file(file_name.c_str());
std::string line;
// get P1
std::getline( in_file, line );
// get comment (temp, works only for one comment, e.g. generated with GIMP)
std::getline( in_file, line );
// get size of the image
in_file >> _w >> _h;
// initialize matrix
_inner_matrix = new unsigned int*[_h];
for (unsigned int i=0; i<_h; ++i)
{
_inner_matrix[i] = new unsigned int[_w];
}
unsigned int count = 0;
while (in_file.good())
{
char c = in_file.get();
if (c == '1' || c == '0')
{
_inner_matrix[count/_w][count%_w] = c - '0';
++count;
}
}
}
void ObjectWriter::CopyFile(std::string in, std::string out){
std::ifstream in_file(in.c_str(), std::fstream::binary);
std::ofstream out_file(out.c_str(), std::fstream::trunc|std::fstream::binary);
out_file << in_file.rdbuf();
in_file.close();
out_file.close();
}
void writeSourceFile(std::ofstream & out_file, std::string & filename, const char * dirname, const char * alignment)
{
std::string fullpath(dirname);
fullpath += "/";
fullpath += alignment;
fullpath += "/";
fullpath += filename;
std::ifstream in_file(fullpath.c_str());
std::string tmp;
if (in_file.is_open())
{
//write variable declaration:
out_file << "const char * const " << dirname << "_" << alignment << "_" << filename.substr(0, filename.size()-3) << " = " << std::endl;
//write source string:
while (getline(in_file, tmp, '\n'))
{
if (tmp.size() > 0)
{
//out_file << "\"" << tmp.replace(tmp.end()-1, tmp.end(), "\\n\"") << std::endl;
if ( *(tmp.end()-1) == '\r') //Windows line delimiter, \r\n
out_file << "\"" << tmp.replace(tmp.end()-1, tmp.end(), "\\n\"") << std::endl;
else //Unix line delimiter \n
out_file << "\"" << tmp.append("\\n\"") << std::endl;
}
}
out_file << "; //" << dirname << "_" << alignment << "_" << filename.substr(0, filename.size()-3) << std::endl << std::endl;
}
else
std::cerr << "Failed to open file " << filename << std::endl;
}
vector<chunkdat> unmatchedChunkData(vector<bool> indexes,vector<Chunk> chunkdetails,string path){
vector<chunkdat> chunkData;
DeltaHandler deltahandler;
ifstream in_file(path.c_str(),std::ifstream::binary);
int beforeEncode=0,afterencode=0;
for(int y=0;y<indexes.size();y++){
chunkdat ch_data;
if(!indexes[y]){
Bytef *sourceblock=(Bytef*) malloc(1024*1024*sizeof(Byte));
int value = y;
in_file.seekg(chunkdetails[value].getOffset(),in_file.beg);
in_file.read((char *)sourceblock,chunkdetails[value].getLength());
Bytef* deltachunk=(Bytef*) malloc(1024*1024*sizeof(Byte));
unsigned long int deltasize;
deltahandler.getDeltaBlock(sourceblock,chunkdetails[value].getLength(),&deltachunk,&deltasize);
cout<<"Size before delta encode: "<<chunkdetails[value].getLength()<<" and size after: "<<deltasize<<endl;
beforeEncode+=chunkdetails[value].getLength();
afterencode+=deltasize;
ch_data.chunk_size=deltasize;
memcpy(ch_data.data,reinterpret_cast<char *>(deltachunk),deltasize);
cout<<"Reading chunk No: "<<value+1<<endl;
chunkData.push_back(ch_data);
free(sourceblock);
free(deltachunk);
}
}
cout<<"Total chunk size before encode:"<<beforeEncode<<endl;
cout<<"Total chunk size after encode:"<<afterencode<<endl;
in_file.close();
return chunkData;
}
unsigned long Message::size () const
{
unsigned long begin, end;
std::ifstream in_file(_file_path.c_str());
if ( in_file.is_open() )
{
// Get position of the get pointer
begin = in_file.tellg();
// Set the postion of the get pointer to the end of the file
in_file.seekg(0, std::ios::end);
// Get the position of the get pointer
end = in_file.tellg();
in_file.close();
unsigned long bits(end - begin);
if ( bits == 0 )
return bits;
else
// We get the size size of the file by substracting end from begin
return ceil(bits / 8);
}
else
throw std::runtime_error("unable to open message: " + _file_path);
}
// 从硬盘读取文件到内存，再进行ini解析
// 处理好文件句柄打开而未关闭
bool INIParser::Parse(const std::string& ini_file_path)
{
ifstream in_file(ini_file_path.c_str());
if(NULL == in_file)
{
fprintf(stderr, "INIParser::Parse read_filepath_error=[%s] error!!", ini_file_path.c_str());
in_file.close();
return false;
}
in_file.seekg(0, ios::end);
size_t len_of_file = in_file.tellg();
if(len_of_file < 0)
{
fprintf(stderr, "INIParser::Parse read_filelen error!!");
in_file.close();
return false;
}
char* buffer = new char [len_of_file + 1];
in_file.seekg(0, ios::beg);
in_file.read(buffer, len_of_file);
buffer[len_of_file] = '\0';
in_file.close();
return Parse(buffer, len_of_file);
}
void WAS::WAS_Driver::parse(const char *const filename, int debug_level, int trace_level_) {
assert(filename != nullptr);
std::ifstream in_file(filename);
if (!in_file.good())
exit(EXIT_FAILURE);
delete (scanner);
try {
scanner = new WAS::WAS_Scanner(&in_file);
} catch (std::bad_alloc &ba) {
std::cerr << "Failed to allocate scanner: (" << ba.what()
<< "), exiting!!\n";
exit(EXIT_FAILURE);
}
delete parser;
try {
parser = new WAS::WAS_Parser(*scanner, *this);
parser->set_debug_level(debug_level);
trace_level = trace_level_;
} catch (std::bad_alloc &ba) {
std::cerr << "Failed to allocate parser: (" << ba.what()
<< "), exiting!!\n";
exit(EXIT_FAILURE);
}
const int accept(0);
if (parser->parse() != accept) {
std::cerr << "Parse failed!!\n";
exit(EXIT_FAILURE);
}
}
int main(int argc, char** argv) {
std::ifstream in_file(argv[1]);
std::string input((std::istreambuf_iterator<char_type>(in_file)), std::istreambuf_iterator<char_type>());
std::transform(input.begin(), input.end(), input.begin(), caesar_cipher(std::atoi(argv[2])));
std::ofstream out_file("caesar_cipher.txt");
std::cout << input << std::endl;
out_file << input;
}
void MakeHistogram(const std::string& file) {
std::ifstream in_file(file.c_str());
TH1F* h = new TH1F("h","title",100,-300,300);
float zvtx = 0;
while(in_file >> zvtx){
h->Fill(zvtx);
}
h->Draw();
}
void handle_reg(std::string& task)
{
if(in_file(task.c_str()))
{
//std::cout<<dirname(task.c_str())<<std::endl;
std::cout<<basename(task.c_str())<<std::endl;
}
mod_unfinished();
}
void Generator::load_all_fonts(char* file){
ifstream in_file(file);
string files;
fonts_name.clear();
while (in_file >> files){
fonts_name.push_back(files);
}
in_file.close();
}
bool
StyleFile::load (const char *filename)
{
clear ();
setup_default_entries ();
m_filename = filename;
std::ifstream in_file (filename);
if (!in_file)
return false;
clear ();
m_sections.push_back (StyleLines ());
StyleLines *section = &m_sections[0];
unsigned int section_id = 0;
char buf[MAX_LINE_LENGTH];
do {
in_file.getline (buf, MAX_LINE_LENGTH);
if (in_file.eof ())
break;
std::string dest = buf;
StyleLine line (this, dest);
StyleLineType type = line.get_type ();
if (type == FCITX_ANTHY_STYLE_LINE_SECTION) {
m_sections.push_back (StyleLines ());
section = &m_sections.back();
section_id++;
}
section->push_back (line);
if (section_id == 0) {
std::string key;
line.get_key (key);
if (key == "FormatVersion") {
line.get_value (m_format_version);
} else if (key == "Title") {
line.get_value (m_title);
} else if (key == "Version") {
line.get_value (m_version);
}
}
} while (!in_file.eof ());
in_file.close ();
m_filename = filename;
return true;
}
void MyWindow::open_linear_polygon_file()
{
QString s = QFileDialog::getOpenFileName(file_name,
QString::null,
this,
"open file dialog",
"Choose a file" );
if (s==QString::null)
return;
file_name=s;
std::ifstream in_file(s.ascii());
if (!in_file.is_open())
{
QMessageBox::warning( widget,"Open","Can't open file");
return ;
}
CGAL::Bbox_2 box = CGAL::Bbox_2 (widget->x_min(), widget->y_min(),
widget->x_max(), widget->y_max());
QCursor old = widget->cursor();
widget->setCursor(Qt::WaitCursor);
widget->lock();
widget->clear_history();
Linear_polygon_2 pgn;
in_file >> pgn;
if (pgn.is_empty())
{
widget->unlock();
widget->setCursor(old);
return;
}
if (pgn.orientation() != CGAL::COUNTERCLOCKWISE)
pgn.reverse_orientation();
const Polygon_2& circ_pgn = linear_2_circ(pgn);
if (red_active)
red_set.join(circ_pgn);
else
blue_set.join(circ_pgn);
box = box + circ_pgn.bbox();
widget->set_window(box.xmin(),
box.xmax(),
box.ymin(),
box.ymax());
widget->unlock();
newtoolbar->reset();
something_changed();
widget->setCursor(old);
}
int main (int argc, char *argv[])
{
// Get the name of the input file from the command line, or use the default
// fan_grids.dat file if no command-line parameters are given.
const char * filename = (argc > 1) ? argv[1] : "fan_grids.dat";
// Open the input file.
std::ifstream in_file (filename);
if (! in_file.is_open()) {
std::cerr << "Failed to open " << filename << " ..." << std::endl;
return (1);
}
// Read the segments from the file.
// The input file format should be (all coordinate values are integers):
// <n> // number of segments.
// <sx_1> <sy_1> <tx_1> <ty_1> // source and target of segment #1.
// <sx_2> <sy_2> <tx_2> <ty_2> // source and target of segment #2.
// : : : :
// <sx_n> <sy_n> <tx_n> <ty_n> // source and target of segment #n.
std::list<Segment_2> segments;
unsigned int n;
in_file >> n;
unsigned int i;
for (i = 0; i < n; ++i) {
int sx, sy, tx, ty;
in_file >> sx >> sy >> tx >> ty;
segments.push_back (Segment_2 (Point_2 (Number_type(sx), Number_type(sy)),
Point_2 (Number_type(tx), Number_type(ty))));
}
in_file.close();
// Construct the arrangement by aggregately inserting all segments.
Arrangement_2 arr;
CGAL::Timer timer;
std::cout << "Performing aggregated insertion of "
<< n << " segments." << std::endl;
timer.start();
insert (arr, segments.begin(), segments.end());
timer.stop();
// Print the arrangement dimensions.
std::cout << "V = " << arr.number_of_vertices()
<< ", E = " << arr.number_of_edges()
<< ", F = " << arr.number_of_faces() << std::endl;
std::cout << "Construction took " << timer.time()
<< " seconds." << std::endl;
return 0;
}
int Parser::Driver::parse(const char *filename, Parser::CompilationUnit*& module) {
std::ifstream in_file(filename);
scanner = new Parser::FlexScanner(&in_file);
parser = new Parser::BisonParser(*scanner, *this, module);
/* Returns 1 if parsing went OK. */
return !parser->parse();
}
