自学教程：C++ system_error函数代码示例

/* Allocate a block of storage; abort execution if it cannot be done. */static void *allocate_memory (size_t size) {   void *address = malloc(size);   if (address == NULL) {      system_error("memory allocation");   }   return address;}

bool loop_impl::run_once( bool block ){        if (block)        _sem.wait();    else {        if (!_sem.wait(0)) {            return false;        }    }    shared_ptr<task_t> task;    {        concurrency_task_queue::ref ref(_task_queue);        task = ref->front();        ref->pop();    }    if (task->empty()) {        throw system_error(-1, "you do run after ended!");    }    try    {        (*task)();    }    catch (std::exception &e)    {        LOG_ERROR(e.what());    }    return true;}

/// Executes an external binary and replaces the current process.////// This differs from process::exec() in that this function reports errors/// caused by the exec(2) system call to let the caller decide how to handle/// them.////// This function must not use any of the logging features so that the output/// of the subprocess is not "polluted" by our own messages.////// This function must also not affect the global state of the current process/// as otherwise we would not be able to use vfork().  Only state stored in the/// stack can be touched.////// /param program The binary to execute./// /param args The arguments to pass to the binary, without the program name.////// /throw system_error If the exec(2) call fails.voidprocess::exec_unsafe(const fs::path& program, const args_vector& args){    PRE(args.size() < MAX_ARGS);    int original_errno = 0;    try {        const char* argv[MAX_ARGS + 1];        argv[0] = program.c_str();        for (args_vector::size_type i = 0; i < args.size(); i++)            argv[1 + i] = args[i].c_str();        argv[1 + args.size()] = NULL;        const int ret = ::execv(program.c_str(),                                (char* const*)(unsigned long)(const void*)argv);        original_errno = errno;        INV(ret == -1);        std::cerr << "Failed to execute " << program << ": "                  << std::strerror(original_errno) << "/n";    } catch (const std::runtime_error& error) {        std::cerr << "Failed to execute " << program << ": "                  << error.what() << "/n";        std::abort();    } catch (...) {        std::cerr << "Failed to execute " << program << "; got unexpected "            "exception during exec/n";        std::abort();    }    // We must do this here to prevent our exception from being caught by the    // generic handlers above.    INV(original_errno != 0);    throw system_error("Failed to execute " + program.str(), original_errno);}

	TORRENT_DEPRECATED	void set_piece_hashes(create_torrent& t, std::wstring const& p, Fun f)	{		error_code ec;		set_piece_hashes_deprecated(t, p, f, ec);		if (ec) throw system_error(ec);	}

    void parent(pid_t pid, int* cmd_stdout, int* cmd_stderr) {        /* We dont need input descriptors, we'll be only reading from        the child */        close(cmd_stderr[1]);        close(cmd_stdout[1]);        string buf = read_all(cmd_stderr[0]);        buf += read_all(cmd_stdout[0]);        /* We've read it all, not needed any more */        close(cmd_stderr[0]);        close(cmd_stdout[0]);        /* Clean up child's status */        int status;        if(waitpid(pid, &status, 0/*options*/) == -1)            throw system_error("waitpid", errno);#ifdef REPORT_COMPILER_EXIT_STATUS        /* Compiler process reported errors - throw exception */        stringstream exit_info;        if(WIFSIGNALED(status)) {            exit_info << "Compiler exited due to signal "<<                WTERMSIG(status) << endl;        }else if(WIFEXITED(status) && WEXITSTATUS(status) != 0){            exit_info << "Compiler exited normaly with status " <<                WEXITSTATUS(status) << endl;        }        buf.insert(0, exit_info.str() + "/n");#endif        if(!buf.empty()) {            throw compiler_error(buf);        }    }

static int write_galaxy(const char *filename, struct galaxy *g){    FILE *fp;    if ((fp = open_file(filename, FMODE_WB)))    {        struct head H;        H.N_num = host_to_net_int(g->N_num);        H.S_num = host_to_net_int(g->S_num);        if (fwrite(&H, sizeof (struct head), 1, fp) == 1)        {            int i;            for (i = 0; i < g->N_num; ++i)                node_write_bin(g->N + i, fp);            for (i = 0; i < g->S_num; ++i)                star_write_bin(g->S + i, fp);        }        fclose(fp);        return 1;    }    else error("Galaxy file '%s': %s", filename, system_error());    return 0;}

static int parse_galaxy(const char *filename, struct galaxy *g){    FILE *fp;    int i;    if ((fp = open_file(filename, FMODE_RB)))    {        struct head H;        if (fread(&H, sizeof (struct head), 1, fp) == 1)        {            g->magnitude = 1.0;            g->N_num     = ntohl(H.N_num);            g->S_num     = ntohl(H.S_num);            if ((g->N = (struct node *) calloc(g->N_num, sizeof(struct node))))                for (i = 0; i < g->N_num; ++i)                    node_parse_bin(g->N + i, fp);            if ((g->S = (struct star *) calloc(g->S_num, sizeof(struct star))))                for (i = 0; i < g->S_num; ++i)                    star_parse_bin(g->S + i, fp);        }        fclose(fp);        return 1;    }    else error("Galaxy file '%s': %s", filename, system_error());    return 0;}

voidimpl::stream_capture::prepare(void){    if (pipe(m_pipefds) == -1)        throw system_error(IMPL_NAME "::stream_capture::prepare",                           "Failed to create pipe", errno);}

/** * Remove inotify watch */void inotify_watch::remove(bool force) {  if (inotify_rm_watch(m_fd, m_wd) == -1 && !force) {    throw system_error("Failed to remove inotify watch");  }  m_wd = -1;  m_mask = 0;}

// public emergency stopvoid slight_StepperManager::system_emergencystop() {    motor.stop();    motor.disable();    // something went wrong    error_type = ERROR_emergencystop;    system_error();}

  /**   * @copydoc   * data::output::copy_to_destination   */  virtual  void  copy_to_destination (   object_type const* src,   std::size_t src_size  ) final override  {    ::ssize_t swrote;    while (src_size > 0)    {      swrote = ::write(STDOUT_FILENO, src, src_size * sizeof(ObjectT));            if (swrote == 0)      {        throw out_of_space("End of file reached.");      }      else      if (swrote == -1)      {        throw system_error("write");      }      src += static_cast<std::size_t>(swrote);      src_size -= static_cast<std::size_t>(swrote);    }  }

	basic_string< TargetChar > convert( const basic_string< SourceChar > &sourceString,			size_t ( *convertFunction )( TargetChar *dst, const SourceChar **src, size_t len, mbstate_t *state )) {		constexpr auto LENGTH_ERROR = static_cast< size_t >( -1 );		mbstate_t state = mbstate_t();		// Find out how much space we need:		const SourceChar *sourceStringData = sourceString.data();		size_t expectedTargetStringLength = convertFunction( nullptr, &sourceStringData, sourceString.length(), &state );		if ( expectedTargetStringLength == LENGTH_ERROR )			throw make_errno_system_error();		// Convert the string:		basic_string< TargetChar > targetString( expectedTargetStringLength, TargetChar() );		size_t actualTargetStringLength = convertFunction( &targetString[ 0 ], &sourceStringData, sourceString.length(), &state );		if ( actualTargetStringLength == LENGTH_ERROR )			throw make_errno_system_error();		// Could all characters be converted?		if ( expectedTargetStringLength != actualTargetStringLength )			throw system_error( make_error_code( errc::illegal_byte_sequence ));		return targetString;	}

//!//! /brief Configures child process' input streams.//!//! Sets up the current process' input streams to behave according to the//! information in the /a info map.  /a closeflags is modified to reflect//! those descriptors that should not be closed because they where modified//! by the function.//!//! Modifies the current execution environment, so this should only be run//! on the child process after the fork(2) has happened.//!//! /throw system_error If any error occurs during the configuration.//!inlinevoidsetup_input(info_map& info, bool* closeflags, int maxdescs){    for (info_map::iterator iter = info.begin(); iter != info.end(); iter++) {        int d = (*iter).first;        stream_info& si = (*iter).second;        BOOST_ASSERT(d < maxdescs);        closeflags[d] = false;        if (si.m_type == stream_info::use_file) {            int fd = ::open(si.m_file.c_str(), O_RDONLY);            if (fd == -1)                boost::throw_exception                    (system_error("boost::process::detail::setup_input",                                  "open(2) of " + si.m_file + " failed",                                  errno));            if (fd != d) {                file_handle h(fd);                h.posix_remap(d);                h.disown();            }        } else if (si.m_type == stream_info::use_handle) {            if (si.m_handle.get() != d)                si.m_handle.posix_remap(d);        } else if (si.m_type == stream_info::use_pipe) {            si.m_pipe->wend().close();            if (d != si.m_pipe->rend().get())                si.m_pipe->rend().posix_remap(d);        } else            BOOST_ASSERT(si.m_type == stream_info::inherit);    }}

  leptrfind_correct_splitedge(evfptr oldsplitedge,vertype breakpos){  leptr forwardle,backle,oldsplitle;  vertype nearpt;		/* dummy here since we know breakpos */  evfptr splitedge;  Boolean searchforwards = TRUE,searchbackwards = TRUE;  double dummyt;  ;  /* change this call to be pt_near_lineseg_3d and make sure *that* routine */  /* doesn't let t+- tol's to slip through anymore, ok? */  oldsplitle = oldsplitedge->le1;  if (pt_near_lineseg_3d(oldsplitle->facevert->pos,			 oldsplitle->next->facevert->pos,breakpos,nearpt,			 &dummyt,Ptonlinetol))      return(oldsplitle);#ifdef debug  printf("/t/t*** Doing find_correct_splitedge!/n/n");#endif  forwardle = oldsplitle->next;  backle = oldsplitle->prev;  while (searchforwards || searchbackwards)  {    if (searchforwards)    {      if (pt_near_lineseg_3d(forwardle->facevert->pos,			     Twin_le(forwardle)->facevert->pos,			     breakpos,nearpt,&dummyt,Ptonlinetol))	return(forwardle);      else      {	forwardle = forwardle->next;	/* make sure you didn't branch... if you did you're no longer on */	/* the broken up edge. */	if ((forwardle == oldsplitle) || 	    ((Twin_le(Twin_le(forwardle->prev)->prev)) != forwardle))	  searchforwards = FALSE;      }    }    if (searchbackwards)    {      if (pt_near_lineseg_3d(backle->facevert->pos,			     Twin_le(backle)->facevert->pos,			     breakpos,nearpt,&dummyt,Ptonlinetol))	return(backle);      else      {	backle = backle->prev;	/* make sure you didn't branch... if you did you're no longer on */	/* the broken up edge. */	if ((backle == oldsplitle) || 	    ((Twin_le(Twin_le(backle->next)->next)) != backle))	  searchbackwards = FALSE;      }    }  }  system_error("find_correct_splitedge: break edge search failure!!/n");  return 0; 			// We'll never get here... -- LJE}

void thread::detach() {  if (joinable()) {    m_handle = thread_uninitialized;  } else {    throw system_error(make_error_code(errc::invalid_argument),                       "Can not detach an unjoinable thread.");  }}

/* Return the name of group GID. The return value is a buffer * that the caller must deallocate with free. GID must be a * valid group ID. */static char* get_group_name(gid_t gid){    struct group* entry = getgrgid(gid);    if (entry == NULL) {        system_error("getgrgid");    }    return xstrdup(entry->gr_name);}

 void unix_socket::bind(const std::string& sun_path) {     struct sockaddr_un local;     local.sun_family = AF_UNIX;     strncpy(local.sun_path,sun_path.c_str(), UNIX_PATH_MAX);     unlink(local.sun_path);      if(::bind(sockfd, reinterpret_cast<sockaddr*>(&local), sizeof(local)) == -1)         throw system_error("bind",errno); }

 void compiler::process(const string& cpp_path, const string& out_path, const vector<string>& params) {     int cmd_stdout[2];//0-read, 1-write;     int cmd_stderr[2];//0-read, 1-write;     if(pipe(cmd_stdout) == -1 || pipe(cmd_stderr) == -1)             throw system_error("pipe",errno);     pid_t pid = fork();     switch(pid){         case -1:             throw system_error("fork", errno);         case 0: //child             setup_descriptors(cmd_stdout, cmd_stderr);             compiler_main(cpp_path, out_path, params);                         break;         default:             parent(pid, cmd_stdout, cmd_stderr);     } }

/* Return the name of group GID. The return value is a buffer that the * caller must allocate with free. GID must be a valid group ID. */static char* get_group_name (gid_t gid){/*{{{*/    struct group* entry;    entry = getgrgid (gid);    if (entry == NULL)        system_error ("getgrgid");    return xstrdup (entry->gr_name);}/*}}}*/

/* Return the name of user UID. The return value is a buffer that the * caller must allocate with free. UID must be a valid user ID. */static char* get_user_name (uid_t uid){/*{{{*/    struct passwd* entry;    entry = getpwuid (uid);    if (entry == NULL)        system_error ("getpwuid");    return xstrdup (entry->pw_name);}/*}}}*/

void Calculator::calculate_answer() throw(ZeroDivide){  if(expression==NULL) throw system_error("in void Calculator::calculate_answer(): call set_expression(const PreExpression& s, Expression& exp) before calling this metod");  if(has_answer==true) return;  expression->calculate_answer();  expression_history.add(*source,*expression);  has_answer=true;}

	torrent_handle add_magnet_uri(session& ses, std::string const& uri		, add_torrent_params const& p)	{		error_code ec;		torrent_handle ret = add_magnet_uri_deprecated(ses, uri, p, ec);		if (ec) throw system_error(ec);		return ret;	}

/* A核用户数据 */int dump_st_026(void){    char *p;    p = kmalloc(4096, GFP_KERNEL);    memset(p,1,4096);    system_error(0x88,1,2,p,4096);    return 0;}

void buffered_file::close() {  if (!file_)    return;  int result = FMT_SYSTEM(fclose(file_));  file_ = FMT_NULL;  if (result != 0)    FMT_THROW(system_error(errno, "cannot close file"));}

void file::dup2(int fd) {  int result = 0;  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));  if (result == -1) {    FMT_THROW(system_error(errno,      "cannot duplicate file descriptor {} to {}", fd_, fd));  }}

file file::dup(int fd) {  // Don't retry as dup doesn't return EINTR.  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html  int new_fd = FMT_POSIX_CALL(dup(fd));  if (new_fd == -1)    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));  return file(new_fd);}

handle handle::dup() const {  if (!*this) BOOST_THROW_EXCEPTION(handle_is_closed_error());#if defined(BOOST_POSIX_API)  const implementation fd = ::fcntl(**this, F_DUPFD_CLOEXEC, 0);  if (fd < 0)    BOOST_THROW_EXCEPTION(system_error("fcntl")                          << system_error::handle(**this));#elif defined(BOOST_WINDOWS_API)  implementation fd;  if (!::DuplicateHandle(::GetCurrentProcess(), **this, ::GetCurrentProcess(),                         &fd, 0, /* not inheritable */ false,                         DUPLICATE_SAME_ACCESS)) {    BOOST_THROW_EXCEPTION(system_error("DuplicateHandle")                          << system_error::handle(**this));  }#endif  return handle(fd);}

handle handle::dup2(const implementation new_fd) const {  if (!*this) BOOST_THROW_EXCEPTION(handle_is_closed_error());  const implementation fd = ::dup3(**this, new_fd, O_CLOEXEC);  if (fd < 0)    BOOST_THROW_EXCEPTION(system_error("dup3")                          << system_error::handle(**this)                          << system_error::new_handle(new_fd));  return handle(fd);}