{

string commandLine;

for (const string& s : programArgs)

{

const bool bad = s. empty ()

|| contains (s, ' ')

|| contains (s, '|')

|| contains (s, ';')

|| contains (s, '#')

|| contains (s, '*')

|| contains (s, '?')

|| contains (s, '$')

|| contains (s, '(')

|| contains (s, ')')

|| contains (s, '<')

|| contains (s, '>')

|| contains (s, '~')

|| contains (s, '\'')

|| contains (s, '"')

|| contains (s, '\\');

if (! commandLine. empty ())

commandLine += ' ';

if (bad)

commandLine += shellQuote (s);

else

commandLine += s;

}

return commandLine;

int fd2)

{

struct stat stat1;

struct stat stat2;

fstat (fd1, & stat1);

fstat (fd2, & stat2);

return stat1. st_ino == stat2. st_ino;

{

#ifdef __APPLE__

int count = 0;

/*const*/ size_t count_len = sizeof(count);

sysctlbyname ("hw.logicalcpu", &count, &count_len, nullptr, 0);

ASSERT (count >= 0);

return (size_t) count;

#else

LineInput f ("/proc/cpuinfo");

size_t n = 0;

while (f. nextLine ())

if (isLeft (f. line, "processor"))

n++;

return n;

#endif

{

signal (SIGSEGV, SIG_DFL);

errorExit ("Segmentation fault", true);

{

signal (SIGPIPE, SIG_DFL);

if (sigpipe)

exit (0);

exit (1);

{

MODULE_INIT

#ifndef _MSC_VER

signal (SIGSEGV, segmFaultHandler);

signal (SIGPIPE, sigpipe_handler);

#endif

#ifdef _MSC_VER

#pragma warning (disable : 4127)

#endif

static_assert (numeric_limits<char>::is_signed, "char is signed");

static_assert (sizeof (long) >= 4);

#ifdef _MSC_VER

#pragma warning (default : 4127)

#endif

static_assert (SIZE_MAX == std::numeric_limits<size_t>::max ());

static_assert (sizeof (size_t) == 8);

return true;

bool segmFault)

{

beep ();

ostream* os = logPtr ? logPtr : & cerr;

// time ??

#ifndef _MSC_VER

const string hostname (getEnv ("HOSTNAME"));

const string shell (getEnv ("SHELL"));

const string pwd (getEnv ("PWD"));

const string path (getEnv ("PATH"));

#endif

if (contains (msg, error_caption)) // msg already is the result of errorExit()

*os << endl << msg << endl;

else

{

*os << endl;

{

const OColor oc (*os, Color::red, true, true);

*os << error_caption;

}

*os << endl

<< msg << endl << endl

#ifndef _MSC_VER

<< "HOSTNAME: " << nvl (hostname, "?") << endl

<< "SHELL: " << nvl (shell, "?") << endl

<< "PWD: " << nvl (pwd, "?") << endl

<< "PATH: " << nvl (path, "?") << endl

#endif

<< "Progam name: " << programName << endl

<< "Command line: " << getCommandLine () << endl;

}

//system (("env >> " + logFName). c_str ());

os->flush ();

if (cxml)

cxml->print (string (error_caption) + ": " + msg);

if (segmFault)

abort ();

exit (1);

{

if (! uncaught_exceptions ())

errorExit (msg. c_str ());

{

#ifdef _MSC_VER

return "Stack trace is not implemented";

#else

string s;

constexpr size_t size = 100; // PAR

void* buffer [size];

const int nptrs = backtrace (buffer, size); // This function must be the first one

if (nptrs <= 1)

errorExit (("backtrace size is " + to_string (nptrs)). c_str ());

char** strings = backtrace_symbols (buffer, nptrs);

if (strings /*&& ! which ("addr2line"). empty ()*/)

{

FOR_START /*FOR_REV_END*/ (int, i, 1, nptrs) // From top to bottom of the stack

s += string (strings [i]) + "\n";

s += "Use: addr2line -f -C -e " + programArgs [0] + " -a <address>";

//free (strings);

}

else

s = "Cannot get stack trace";

return s;

#endif

{

#ifdef _MSC_VER

return false;

#else

if (& os == & cout)

return ! isatty (fileno (stdout));

if (& os == & cerr)

return ! isatty (fileno (stderr));

if (& os == & clog)

return ! isatty (fileno (stderr));

return false;

#endif

{

const timespec request = {0, nanoSec};

timespec remaining;

EXEC_ASSERT (! nanosleep (& request, & remaining));

{

if (getEnv ("SHLVL") != "1")

return;

constexpr char c = '\x07';

if (! isRedirected (cerr))

cerr << c;

else if (! isRedirected (cout))

cout << c;

{

if (! on ())

return;

if (started ())

throw runtime_error (FUNC "Chronometer \"" + name + "\" is not stopped");

startTime = clock ();

{

if (! on ())

return;

if (! started ())

throw runtime_error (FUNC "Chronometer \"" + name + "\" is not started");

time += clock () - startTime;

startTime = noclock;

{

if (! on ())

return;

os << "CHRON: " << name << ": ";

const ONumber onm (os, 2, false);

os << (double) time / CLOCKS_PER_SEC << " sec." << endl;

ostream &os_arg,

bool addNewLine_arg,

bool active_arg)

: name (name_arg)

, os (os_arg)

, addNewLine (addNewLine_arg)

, active (active_arg)

, start (active_arg ? time (nullptr) : 0)

{

if (! b)

return sizeof (uchar);

const uint u = b;

size_t i = 0;

uint mask = 1;

while (! contains (u, mask))

{

i++;

mask <<= 1;

}

return i;

{

const uint u = numeric_limits<uint>::max () - (uchar) first;

size_t len = 0;

uint mask = 0x80;

while (! contains (u, mask))

{

len++;

mask >>= 1;

}

return len;

size_t b)

{

if (! b)

return 1;

if (b == 1)

return a;

const size_t half = b / 2;

const size_t res = powInt_ (a, half);

return res * res * (divisible (b, 2) ? 1 : a);

size_t b)

{

if (a)

if (a == 1)

return 1;

else

return powInt_ (a, b);

else

if (b)

return 0;

else

throw runtime_error (FUNC "powInt: 0^0");

{

time_t rawtime;

time (& rawtime);

const tm* x = localtime (& rawtime);

return padNatural (x->tm_year + 1900, 4)

+ "-" + padNatural (x->tm_mon + 1, 2)

+ "-" + padNatural (x->tm_mday, 2)

+ " " + padNatural (x->tm_hour, 2)

+ ":" + padNatural (x->tm_min, 2)

+ ":" + padNatural (x->tm_sec, 2);

{

string s;

switch (c)

{

case 7: s = "BEL"; break;

case 8: s = "BS"; break;

case 9: s = "TAB"; break;

case 10: s = "LF"; break;

case 12: s = "FF"; break;

case 13: s = "CR"; break;

case 27: s = "ESC"; break;

case 32: s = "SPACE"; break;

default: s = "x" + uchar2hex ((uchar) c);

}

return "<" + s + ">";

const string &prefix)

{

if (! isLeft (s, prefix))

return false;

s. erase (0, prefix. size ());

return true;

const string &suffix)

{

if (! isRight (s, suffix))

return false;

s. erase (s. size () - suffix. size ());

return true;

{

for (;;)

{

trimTrailing (s);

if (s. empty ())

break;

const size_t pos = s. size () - 1;

if ( isAlpha (s [pos])

|| isDigit (s [pos])

)

break;

s. erase (pos);

}

const string &tailStart)

{

if (tailStart. empty ())

return false;

const size_t pos = s. find (tailStart);

const bool trimmed = (pos != string::npos);

if (trimmed)

s. erase (pos);

return trimmed;

{

trim (s);

replace (s, '\t', ' ');

replace (s, ',', ' ');

replaceStr (s, " ", " ");

replace (s, ' ', ',');

size_t size,

ebool right,

char space)

{

if (s. size () >= size)

return s. substr (0, size);

string sp;

while (sp. size () + s. size () < size)

sp += space;

switch (right)

{

case efalse: return s + sp;

case etrue: return sp + s;

case enull:

{

const size_t half = sp. size () / 2;

return sp. substr (0, half) + s + sp. substr (0, sp. size () - half);

}

}

NEVER_CALL;

{

if (name. empty ())

return false;

if (name. front () == ' ')

return false;

if (name. back () == ' ')

return false;

for (const char c : name)

if (! printable (c))

return false;

return true;

bool dashInName)

{

if (name. empty ())

return false;

if (isDigit (name [0]))

return false;

if (dashInName && name [0] == '-')

return false;

for (const char c : name)

if (! isLetter (c) && (! dashInName || c != '-'))

return false;

return true;

bool leadingZeroAllowed)

{

if (name. empty ())

return false;

for (const char c : name)

if (! isDigit (c))

return false;

if (name. size () == 1)

return true;

if (! leadingZeroAllowed && name [0] == '0')

return false;

return true;

{

for (const char c : s)

if (! isSpace (c))

return false;

return true;

bool &hasPoint,

streamsize &decimals)

{

strUpper (numberS);

const size_t ePos = numberS. find ('E');

const size_t pointPos = numberS. find ('.');

hasPoint = (pointPos != string::npos);

decimals = 0;

if (ePos == string::npos)

{

if (hasPoint)

decimals = (streamoff) (numberS. size () - (pointPos + 1));

}

else

{

ASSERT (ePos != pointPos);

if (hasPoint && ePos < pointPos)

hasPoint = false;

if (hasPoint)

decimals = (streamoff) (ePos - (pointPos + 1));

}

return ePos != string::npos;

{

for (char& c : s)

c = toUpper (c);

{

for (char& c : s)

c = toLower (c);

{

for (const char c : s)

if (! isUpper (c))

return false;

return true;

{

for (const char c : s)

if (! isLower (c))

return false;

return true;

const string &charSet,

ebool uppercase)

{

FFOR (size_t, i, s. size ())

{

char c = s [i];

switch (uppercase)

{

case efalse: c = toLower (c); break;

case etrue: c = toUpper (c); break;

case enull: break;

}

if (! charInSet (c, charSet))

return i;

}

return no_index;

const string &charSet)

{

size_t n = 0;

for (const char c : s)

if (charInSet (c, charSet))

n++;

return n;

const string &charSet)

{

FOR_REV (size_t, i, s. size ())

if (charInSet (s [i], charSet))

s. erase (i, 1);

{

size_t i = 0;

for (; i < s. size () && isSpace (s [i]); i++)

;

s. erase (0, i);

{

size_t i = s. size ();

while (i)

if (isSpace (s [i - 1]))

i--;

else

break;

s. erase (i);

char c)

{

size_t i = 0;

for (; i < s. size () && s [i] == c; i++)

;

s. erase (0, i);

char c)

{

size_t i = s. size ();

while (i)

if (s [i - 1] == c)

i--;

else

break;

s. erase (i);

const string& needle)

{

size_t pos = string::npos;

for (;;)

{

pos = hay. find (needle, pos == string::npos ? 0 : pos + 1);

if (pos == string::npos)

break;

const size_t pos1 = pos + needle. size ();

if ( (pos == 0 || ! isLetter (hay [pos - 1]))

&& (pos1 == hay. size () || ! isLetter (hay [pos1]))

)

break;

}

return pos;

const string &needle,

StringMatch::Type type)

{

switch (type)

{

case StringMatch::part: return contains (hay, needle);

case StringMatch::word: return containsWord (hay, needle) != string::npos;

case StringMatch::whole: return hay == needle;

}

NEVER_CALL;

char from,

char to)

{

for (char& c : s)

if (c == from)

c = to;

const string &fromAnyChars,

char to)

{

for (char& c : s)

if (charInSet (c, fromAnyChars))

c = to;

const string &from,

const string &to)

{

ASSERT (! from. empty ());

if (from == to)

return;

const bool inside = contains (to, from);

size_t start = 0;

for (;;)

{

const size_t pos = s. find (from, start);

if (pos == string::npos)

break;

s. replace (pos, from. size (), to);

start = pos + (inside ? to. size () : 0);

}

char quote)

{

string s1 (s);

replaceStr (s1, "\\", "\\\\");

const char slashQuote [] = {'\\', quote, '\0'};

replaceStr (s1, string (1, quote), slashQuote);

return quote + s1 + quote;

{

string r;

for (const char c : s)

if (c == '\n')

r += "\\n";

else

{

if (charInSet (c, "\"\'\\"))

r += '\\';

r += c;

}

return r;

{

string s1;

do

{

s1 = s;

replaceStr (s, " ", " ");

}

while (s1 != s);