char *maybe_temp_file(const void *ctx, const char *extension, bool keep,
const char *srcname)
{
unsigned baselen;
char *f, *suffix = talloc_strdup(ctx, "");
struct stat st;
unsigned int count = 0;
srcname = talloc_basename(ctx, srcname);
if (strrchr(srcname, '.'))
baselen = strrchr(srcname, '.') - srcname;
else
baselen = strlen(srcname);
do {
f = talloc_asprintf(ctx, "%s/%.*s%s%s",
temp_dir(ctx),
baselen, srcname,
suffix, extension);
talloc_free(suffix);
suffix = talloc_asprintf(ctx, "-%u", ++count);
} while (lstat(f, &st) == 0);
if (tools_verbose)
printf("Creating %sfile %s\n", keep ? "" : "temporary ", f);
if (!keep)
talloc_set_destructor(f, unlink_file_destructor);
talloc_free(suffix);
return f;
}
int main( int argc, char** argv, char** envp )
{
try
{
//steemit::chain::database db;
steemit::chain::block_log log;
fc::temp_directory temp_dir( "." );
//db.open( temp_dir );
log.open( temp_dir.path() / "log" );
idump( (log.head() ) );
steemit::protocol::signed_block b1;
b1.witness = "alice";
b1.previous = steemit::protocol::block_id_type();
log.append( b1 );
log.flush();
idump( (b1) );
idump( ( log.head() ) );
idump( (fc::raw::pack_size(b1)) );
steemit::protocol::signed_block b2;
b2.witness = "bob";
b2.previous = b1.id();
log.append( b2 );
log.flush();
idump( (b2) );
idump( (log.head() ) );
idump( (fc::raw::pack_size(b2)) );
auto r1 = log.read_block( 0 );
idump( (r1) );
idump( (fc::raw::pack_size(r1.first)) );
auto r2 = log.read_block( r1.second );
idump( (r2) );
idump( (fc::raw::pack_size(r2.first)) );
idump( (log.read_head()) );
idump( (fc::raw::pack_size(log.read_head())));
auto r3 = log.read_block( r2.second );
idump( (r3) );
}
catch ( const std::exception& e )
{
edump( ( std::string( e.what() ) ) );
}
return 0;
}
int make_linked_temp_file (std::string& dest, const char* tmpdir, const char* prefix)
{
if (!prefix) prefix = DEFAULT_TEMP_FILE_PREFIX;
std::string dirname (temp_dir (tmpdir));
std::string templ = join_path (dirname.c_str (), prefix, NULL);
templ += TEMP_FILE_TEMPL_SUFFIX;
MemWrapper <char> buffer (templ.size () + 1);
strcpy (buffer, templ.c_str ());
int fhandle = mkstemp (buffer);
dest = buffer;
return fhandle;
}
std::string make_temp_fname (const char* tmpdir, const char* prefix)
{
// if directory not passed in, guess one
std::string tn = temp_dir (tmpdir);;
// if prefix not passed in, use default
if (!prefix) prefix = DEFAULT_TEMP_FILE_PREFIX;
// get temp directory listing
StrVec dircontent = listdir (tn);
// find all entries matching prefix and having numeric postfix, get list of numbers
UintSet postfixes;
unsigned prefix_len = prefix ? strlen (prefix) : 0;
for (StrVec::iterator ii = dircontent.begin (); ii != dircontent.end (); ii ++)
{
// check if prefix matches
if (prefix_len && (ii->substr (0, prefix_len) != prefix))
continue;
// check if postfix is numeric and get the number
unsigned number = 0;
std::string::iterator sitr;
for (sitr = ii->begin () + prefix_len; sitr != ii->end (); sitr ++)
{
number *= 10;
if (!isdigit (*sitr))
break;
else
number += *sitr - '0';
}
if (sitr != ii->end ())
continue;
// store number to postfixes set
postfixes.insert (number);
}
// now retrieve the numbers using first gap
// make a set for quick presence check
unsigned prev = 0;
for (UintSet::iterator nitr = postfixes.begin (); nitr != postfixes.end (); nitr ++)
if (prev + 1 < *nitr)
break; // found the gap in sequence
else
prev = *nitr;
if (prev == std::numeric_limits<unsigned>::max ()) // just for sanity :)
ers << "No more temp file names available for prefix " << (prefix ? prefix : "") << " in directory " << tn << Throw;
// prev + 1 is the right number
std::ostringstream name (tn, std::ios::out | std::ios::app);
name << PATH_SEPARATOR;
if (prefix) name << prefix;
name << prev + 1;
return name.str ();
}
//----------------------------------------------------------------------
void AtvUsbCreatorLinux::extract_bootefi(){
emit status("Extracting boot.efi ...");
emit progress(0);
emit maxprogress(100);
QDir temp_dir(QDir::tempPath() + QDir::separator() + "atvusb-creatorExtractTemp");
if(!temp_dir.exists())
if(!temp_dir.mkpath(temp_dir.absolutePath())){
emit status(QString("Could not create tempdir %1").arg(temp_dir.absolutePath()));
return;
}
emit status(temp_dir.absolutePath());
int exit_code = QProcess::execute("dmg2img ", QStringList() << m_dmg_path);
if(exit_code){
emit status("Ouch, could not convert dmg2img");
temp_dir.rmpath ( temp_dir.absolutePath() );
return;
}
QString img_path = m_dmg_path;
img_path[img_path.count() -1]='g';
img_path[img_path.count() -2]='m';
img_path[img_path.count() -3]='i';
emit status(m_dmg_path);
emit status(img_path);
emit progress(33);
exit_code = QProcess::execute("mount -t hfsplus -o loop ", QStringList() << img_path << temp_dir.absolutePath());
if(exit_code){
emit status("Ouch, could not mount dmg2img'ed image");
temp_dir.rmpath ( temp_dir.absolutePath() );
return;
}
QString bootefi_src = temp_dir.absolutePath() + QDir::separator() + "System" + QDir::separator() + " Library" + QDir::separator() + "CoreServices" + QDir::separator() + "boot.efi";
if(!QFile::copy(bootefi_src, m_bootefi_path)){
emit status(QString("Ouch, could not copy %1 to %2").arg(bootefi_src).arg(m_bootefi_path));
}
emit progress(66);
exit_code = QProcess::execute("umount", QStringList() << m_tmp_folder);
if(exit_code){
emit status(QString("Could not umount %1").arg(m_tmp_folder));
}
emit progress(100);
temp_dir.rmpath ( temp_dir.absolutePath() );
}
/**
* we will store the temporary files in [tmp_directory]/graphlab/[procid]
* This searches in graphlab's temp directory for unused temporary files
* (what procids no longer exist) and deletes them.
*/
EXPORT void reap_unused_temp_files() {
// loop through all the subdirectories in get_graphlab_temp_directory()
// and unlink if the pid does not exist
size_t temp_dir_size = num_temp_directories();
for (size_t idx = 0; idx < temp_dir_size; ++idx) {
try {
fs::path temp_dir(get_graphlab_temp_directory(idx));
auto diriter = fs::directory_iterator(temp_dir);
auto enditer = fs::directory_iterator();
while(diriter != enditer) {
auto path = diriter->path();
if (fs::is_directory(path)) {
try {
long pid = std::stol(path.filename().string());
if(!is_process_running(pid)) {
// PID no longer exists.
// delete it
logstream(LOG_EMPH) << "Deleting orphaned temp directory found in "
<< path.string() << std::endl;
delete_proc_directory(path);
}
} catch (...) {
// empty catch. if the path does not parse as an
// integer, ignore it.
logstream(LOG_WARNING)
<< "Unexpcted file in GraphLab's temp directory: " << path
<< std::endl;
}
}
++diriter;
}
} catch (...) {
// Failures are ok. we just stop.
}
}
}
/** \brief location if temp directoty , os specific with appended file/path
*
* Shortcut method for Qt's storageLocation()
* \return Absolute path with appended paths.
*/
QString MainObject::temp_dir(QString append_path){
return temp_dir().append(append_path);
}
/// does it.
int gcc_modet::doit()
{
if(cmdline.isset('?') ||
cmdline.isset("help"))
{
help();
return EX_OK;
}
native_tool_name=
act_as_ld ?
linker_name(cmdline, base_name) :
compiler_name(cmdline, base_name);
unsigned int verbosity=1;
bool act_as_bcc=
base_name=="bcc" ||
base_name.find("goto-bcc")!=std::string::npos;
if((cmdline.isset('v') && cmdline.have_infile_arg()) ||
(cmdline.isset("version") && !produce_hybrid_binary))
{
// "-v" a) prints the version and b) increases verbosity.
// Compilation continues, don't exit!
if(act_as_ld)
std::cout << "GNU ld version 2.16.91 20050610 (goto-cc " CBMC_VERSION
<< ")\n";
else if(act_as_bcc)
std::cout << "bcc: version 0.16.17 (goto-cc " CBMC_VERSION ")\n";
else
std::cout << "gcc version 3.4.4 (goto-cc " CBMC_VERSION ")\n";
}
if(cmdline.isset("version"))
{
if(produce_hybrid_binary)
return run_gcc();
std::cout << '\n' <<
"Copyright (C) 2006-2014 Daniel Kroening, Christoph Wintersteiger\n" <<
"CBMC version: " CBMC_VERSION << '\n' <<
"Architecture: " << config.this_architecture() << '\n' <<
"OS: " << config.this_operating_system() << '\n';
return EX_OK; // Exit!
}
if(cmdline.isset("dumpversion"))
{
if(produce_hybrid_binary)
return run_gcc();
std::cout << "3.4.4\n";
return EX_OK;
}
if(cmdline.isset("Wall") || cmdline.isset("Wextra"))
verbosity=2;
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2unsigned(cmdline.get_value("verbosity"));
gcc_message_handler.set_verbosity(verbosity);
if(act_as_ld)
{
if(produce_hybrid_binary)
debug() << "LD mode (hybrid)" << eom;
else
debug() << "LD mode" << eom;
}
else if(act_as_bcc)
{
if(produce_hybrid_binary)
debug() << "BCC mode (hybrid)" << eom;
else
debug() << "BCC mode" << eom;
}
else
{
if(produce_hybrid_binary)
debug() << "GCC mode (hybrid)" << eom;
else
debug() << "GCC mode" << eom;
}
// In gcc mode, we have just pass on to gcc to handle the following:
// * if -M or -MM is given, we do dependencies only
// * preprocessing (-E)
// * no input files given
if(act_as_ld)
{
}
else if(cmdline.isset('M') ||
cmdline.isset("MM") ||
cmdline.isset('E') ||
!cmdline.have_infile_arg())
return run_gcc(); // exit!
// get configuration
config.set(cmdline);
// Intel-specific
// in GCC, m16 is 32-bit (!), as documented here:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59672
if(cmdline.isset("m16") ||
cmdline.isset("m32") || cmdline.isset("mx32"))
{
config.ansi_c.arch="i386";
config.ansi_c.set_arch_spec_i386();
}
else if(cmdline.isset("m64"))
{
config.ansi_c.arch="x86_64";
config.ansi_c.set_arch_spec_x86_64();
}
// ARM-specific
if(cmdline.isset("mbig-endian") || cmdline.isset("mbig"))
config.ansi_c.endianness=configt::ansi_ct::endiannesst::IS_BIG_ENDIAN;
else if(cmdline.isset("little-endian") || cmdline.isset("mlittle"))
config.ansi_c.endianness=configt::ansi_ct::endiannesst::IS_LITTLE_ENDIAN;
if(cmdline.isset("mthumb") || cmdline.isset("mthumb-interwork"))
config.ansi_c.set_arch_spec_arm("armhf");
// -mcpu sets both the arch and tune, but should only be used if
// neither -march nor -mtune are passed on the command line.
std::string target_cpu=
cmdline.isset("march") ? cmdline.get_value("march") :
cmdline.isset("mtune") ? cmdline.get_value("mtune") :
cmdline.isset("mcpu") ? cmdline.get_value("mcpu") : "";
if(target_cpu!="")
{
// Work out what CPROVER architecture we should target.
for(auto &pair : arch_map)
for(auto &processor : pair.second)
if(processor==target_cpu)
{
if(pair.first.find("mips")==std::string::npos)
config.set_arch(pair.first);
else
{
// Targeting a MIPS processor. MIPS is special; we also need
// to know the endianness. -EB (big-endian) is the default.
if(cmdline.isset("EL"))
{
if(pair.first=="mips32o")
config.set_arch("mipsel");
else if(pair.first=="mips32n")
config.set_arch("mipsn32el");
else
config.set_arch("mips64el");
}
else
{
if(pair.first=="mips32o")
config.set_arch("mips");
else if(pair.first=="mips32n")
config.set_arch("mipsn32");
else
config.set_arch("mips64");
}
}
}
}
// -fshort-wchar makes wchar_t "short unsigned int"
if(cmdline.isset("fshort-wchar"))
{
config.ansi_c.wchar_t_width=config.ansi_c.short_int_width;
config.ansi_c.wchar_t_is_unsigned=true;
}
// -fsingle-precision-constant makes floating-point constants "float"
// instead of double
if(cmdline.isset("-fsingle-precision-constant"))
config.ansi_c.single_precision_constant=true;
// -fshort-double makes double the same as float
if(cmdline.isset("fshort-double"))
config.ansi_c.double_width=config.ansi_c.single_width;
// determine actions to be undertaken
compilet compiler(cmdline,
gcc_message_handler,
cmdline.isset("Werror") &&
cmdline.isset("Wextra") &&
!cmdline.isset("Wno-error"));
if(act_as_ld)
compiler.mode=compilet::LINK_LIBRARY;
else if(cmdline.isset('S'))
compiler.mode=compilet::ASSEMBLE_ONLY;
else if(cmdline.isset('c'))
compiler.mode=compilet::COMPILE_ONLY;
else if(cmdline.isset('E'))
{
compiler.mode=compilet::PREPROCESS_ONLY;
UNREACHABLE;
}
else if(cmdline.isset("shared") ||
cmdline.isset('r')) // really not well documented
compiler.mode=compilet::COMPILE_LINK;
else
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
switch(compiler.mode)
{
case compilet::LINK_LIBRARY:
debug() << "Linking a library only" << eom; break;
case compilet::COMPILE_ONLY:
debug() << "Compiling only" << eom; break;
case compilet::ASSEMBLE_ONLY:
debug() << "Assembling only" << eom; break;
case compilet::PREPROCESS_ONLY:
debug() << "Preprocessing only" << eom; break;
case compilet::COMPILE_LINK:
debug() << "Compiling and linking a library" << eom; break;
case compilet::COMPILE_LINK_EXECUTABLE:
debug() << "Compiling and linking an executable" << eom; break;
}
if(cmdline.isset("i386-win32") ||
cmdline.isset("winx64"))
{
// We may wish to reconsider the below.
config.ansi_c.mode=configt::ansi_ct::flavourt::VISUAL_STUDIO;
debug() << "Enabling Visual Studio syntax" << eom;
}
else if(config.this_operating_system()=="macos")
config.ansi_c.mode=configt::ansi_ct::flavourt::APPLE;
else
config.ansi_c.mode=configt::ansi_ct::flavourt::GCC;
if(compiler.mode==compilet::ASSEMBLE_ONLY)
compiler.object_file_extension="s";
else
compiler.object_file_extension="o";
if(cmdline.isset("std"))
{
std::string std_string=cmdline.get_value("std");
if(std_string=="gnu89" || std_string=="c89")
config.ansi_c.set_c89();
if(std_string=="gnu99" || std_string=="c99" || std_string=="iso9899:1999" ||
std_string=="gnu9x" || std_string=="c9x" || std_string=="iso9899:199x")
config.ansi_c.set_c99();
if(std_string=="gnu11" || std_string=="c11" ||
std_string=="gnu1x" || std_string=="c1x")
config.ansi_c.set_c11();
if(std_string=="c++11" || std_string=="c++1x" ||
std_string=="gnu++11" || std_string=="gnu++1x" ||
std_string=="c++1y" ||
std_string=="gnu++1y")
config.cpp.set_cpp11();
if(std_string=="gnu++14" || std_string=="c++14")
config.cpp.set_cpp14();
}
// gcc's default is 32 bits for wchar_t
if(cmdline.isset("short-wchar"))
config.ansi_c.wchar_t_width=16;
// gcc's default is 64 bits for double
if(cmdline.isset("short-double"))
config.ansi_c.double_width=32;
// gcc's default is signed chars on most architectures
if(cmdline.isset("funsigned-char"))
config.ansi_c.char_is_unsigned=true;
if(cmdline.isset("fsigned-char"))
config.ansi_c.char_is_unsigned=false;
if(cmdline.isset('U'))
config.ansi_c.undefines=cmdline.get_values('U');
if(cmdline.isset("undef"))
config.ansi_c.preprocessor_options.push_back("-undef");
if(cmdline.isset("nostdinc"))
config.ansi_c.preprocessor_options.push_back("-nostdinc");
if(cmdline.isset('L'))
compiler.library_paths=cmdline.get_values('L');
// Don't add the system paths!
if(cmdline.isset('l'))
compiler.libraries=cmdline.get_values('l');
if(cmdline.isset("static"))
compiler.libraries.push_back("c");
if(cmdline.isset("pthread"))
compiler.libraries.push_back("pthread");
if(cmdline.isset('o'))
{
// given gcc -o file1 -o file2,
// gcc will output to file2, not file1
compiler.output_file_object=cmdline.get_values('o').back();
compiler.output_file_executable=cmdline.get_values('o').back();
}
else
{
compiler.output_file_object="";
compiler.output_file_executable="a.out";
}
// We now iterate over any input files
temp_dirt temp_dir("goto-cc-XXXXXX");
{
std::string language;
for(goto_cc_cmdlinet::parsed_argvt::iterator
arg_it=cmdline.parsed_argv.begin();
arg_it!=cmdline.parsed_argv.end();
arg_it++)
{
if(arg_it->is_infile_name)
{
// do any preprocessing needed
if(language=="cpp-output" || language=="c++-cpp-output")
{
compiler.add_input_file(arg_it->arg);
}
else if(language=="c" || language=="c++" ||
(language=="" && needs_preprocessing(arg_it->arg)))
{
std::string new_suffix;
if(language=="c")
new_suffix=".i";
else if(language=="c++")
new_suffix=".ii";
else
new_suffix=has_suffix(arg_it->arg, ".c")?".i":".ii";
std::string new_name=
get_base_name(arg_it->arg, true)+new_suffix;
std::string dest=temp_dir(new_name);
int exit_code=
preprocess(language, arg_it->arg, dest, act_as_bcc);
if(exit_code!=0)
{
error() << "preprocessing has failed" << eom;
return exit_code;
}
compiler.add_input_file(dest);
}
else
compiler.add_input_file(arg_it->arg);
}
else if(arg_it->arg=="-x")
{
arg_it++;
if(arg_it!=cmdline.parsed_argv.end())
{
language=arg_it->arg;
if(language=="none")
language="";
}
}
else if(has_prefix(arg_it->arg, "-x"))
{
language=std::string(arg_it->arg, 2, std::string::npos);
if(language=="none")
language="";
}
}
}
// Revert to gcc in case there is no source to compile
// and no binary to link.
if(compiler.source_files.empty() &&
compiler.object_files.empty())
return run_gcc(); // exit!
if(compiler.mode==compilet::ASSEMBLE_ONLY)
return asm_output(act_as_bcc, compiler.source_files);
// do all the rest
if(compiler.doit())
return 1; // GCC exit code for all kinds of errors
// We can generate hybrid ELF and Mach-O binaries
// containing both executable machine code and the goto-binary.
if(produce_hybrid_binary && !act_as_bcc)
return gcc_hybrid_binary();
return EX_OK;
}
/// does it.
int as_modet::doit()
{
if(cmdline.isset('?') ||
cmdline.isset("help"))
{
help();
return EX_OK;
}
unsigned int verbosity=1;
bool act_as_as86=
base_name=="as86" ||
base_name.find("goto-as86")!=std::string::npos;
if((cmdline.isset('v') && act_as_as86) ||
cmdline.isset("version"))
{
if(act_as_as86)
status() << "as86 version: 0.16.17 (goto-cc " CBMC_VERSION ")"
<< eom;
else
status() << "GNU assembler version 2.20.51.0.7 20100318"
<< " (goto-cc " CBMC_VERSION ")" << eom;
status() << '\n' <<
"Copyright (C) 2006-2014 Daniel Kroening, Christoph Wintersteiger\n" <<
"CBMC version: " CBMC_VERSION << '\n' <<
"Architecture: " << config.this_architecture() << '\n' <<
"OS: " << config.this_operating_system() << eom;
return EX_OK; // Exit!
}
if(cmdline.isset("w-") || cmdline.isset("warn"))
verbosity=2;
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2unsigned(cmdline.get_value("verbosity"));
message_handler.set_verbosity(verbosity);
if(act_as_as86)
{
if(produce_hybrid_binary)
debug() << "AS86 mode (hybrid)" << eom;
else
debug() << "AS86 mode" << eom;
}
else
{
if(produce_hybrid_binary)
debug() << "AS mode (hybrid)" << eom;
else
debug() << "AS mode" << eom;
}
// get configuration
config.set(cmdline);
// determine actions to be undertaken
compilet compiler(cmdline, message_handler, cmdline.isset("fatal-warnings"));
if(cmdline.isset('b')) // as86 only
{
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
debug() << "Compiling and linking an executable" << eom;
}
else
{
compiler.mode=compilet::COMPILE_LINK;
debug() << "Compiling and linking a library" << eom;
}
config.ansi_c.mode=configt::ansi_ct::flavourt::GCC;
compiler.object_file_extension="o";
if(cmdline.isset('o'))
{
compiler.output_file_object=cmdline.get_value('o');
compiler.output_file_executable=cmdline.get_value('o');
}
else if(cmdline.isset('b')) // as86 only
{
compiler.output_file_object=cmdline.get_value('b');
compiler.output_file_executable=cmdline.get_value('b');
}
else
{
compiler.output_file_object="a.out";
compiler.output_file_executable="a.out";
}
// We now iterate over any input files
temp_dirt temp_dir("goto-cc-XXXXXX");
for(goto_cc_cmdlinet::parsed_argvt::iterator
arg_it=cmdline.parsed_argv.begin();
arg_it!=cmdline.parsed_argv.end();
arg_it++)
{
if(!arg_it->is_infile_name)
continue;
// extract the preprocessed source from the file
std::string infile=arg_it->arg=="-"?cmdline.stdin_file:arg_it->arg;
std::ifstream is(infile);
if(!is.is_open())
{
error() << "Failed to open input source " << infile << eom;
return 1;
}
// there could be multiple source files in case GCC's --combine
// was used
unsigned outputs=0;
std::string line;
std::ofstream os;
std::string dest;
const std::string comment2=act_as_as86 ? "::" : "##";
// search for comment2 GOTO-CC
// strip comment2 from all subsequent lines
while(std::getline(is, line))
{
if(line==comment2+" GOTO-CC")
{
if(outputs>0)
{
assert(!dest.empty());
compiler.add_input_file(dest);
os.close();
}
++outputs;
std::string new_name=
get_base_name(infile, true)+"_"+
std::to_string(outputs)+".i";
dest=temp_dir(new_name);
os.open(dest);
if(!os.is_open())
{
error() << "Failed to tmp output file " << dest << eom;
return 1;
}
continue;
}
else if(outputs==0)
continue;
if(line.size()>2)
os << line.substr(2) << '\n';
}
if(outputs>0)
{
assert(!dest.empty());
compiler.add_input_file(dest);
}
else
warning() << "No GOTO-CC section found in " << arg_it->arg << eom;
}
// Revert to as in case there is no source to compile
if(compiler.source_files.empty())
return run_as(); // exit!
// do all the rest
if(compiler.doit())
return 1; // GCC exit code for all kinds of errors
// We can generate hybrid ELF and Mach-O binaries
// containing both executable machine code and the goto-binary.
if(produce_hybrid_binary)
return as_hybrid_binary();
return EX_OK;
}
