n Oct 8, 6:05m, Victor Bazarov < XXXX@XXXXX.COM > wrote:
Signals are normative. There is lots of informative left out of the
> logarithm of a negative value or you never hang onto a dangling pointer.>
> A test for greater than 0 is so much quicker than setting everythin>
> up for stack unwinding..>
> But you don't have to listen to me. f you see how Microsoft Structure>
> Exceptions can be brought into the language and implemented everywher>
> the C++ compilers can exist, do write it up. am sure folks i>
> comp.std.c++ will read your proposal with the same attention they giv>
> every proposal>
> Please remove capital 'A's when replying by e-mai>
> I do not respond to top-posted replies, please don't ask
It seems reasonable as a pattern to encapsulate generic exception
handling in the C++ towards that it is instrumentable generally.
Here are some of my ideas from the other day about cwd: current
working directory. When considering how to handle the exceptions
generally, catch the signals and throw them back to the functions
maybe having each function register itself as the signal handler, in
the generic exception handling logic.
Also I am thinking some about "generic return types" and also
generifed return types in terms of considering what C++ can do for me.
To truncate the file specifications might be great, with the automatic
matching of the free input component.
static cwd here
put static functions on cwd, then use here for the file functions,
std::string directory; // this is the current working directory
use the inline functions, anonymous functions, to, defer
initialization of the carry-over variable
if there's no initial match, it's set to zero
here, the point is to collect several modes of the strings, basically
having the modes saved in the static variables
so, the path comes in, is it a delta off of the working directory, or
absolute / rooted?
basically for the path root, there is either the working directory as
the root or the path contains its own root (which might include
volume, host, etcetera, which would have static process events on
events with those).
So, I want to get the path, and compare it to the working directory.
If it's relative the working directory, then truncate it's initial
matching segments, the parameter, for later calls using the same
Then set up mode arrays, with this path construction and validation
generally throughout with public APIs.
So, the mode strings should be any number of matching initial segments
Then, among those are to be the collapse and the matching of the
segments / strings.
Make the path components, similar to the path segments, with getting
out the names.
So, to match the working directory, it's towards where the actual
parameters can be reduced, until, they have to be assembled already to
access the device or so, here relative to particular points they have
more direct addressing which carries down to all the functions
underneath, where for example there is a static main process working
directory object that the static function members initialize to.
Then, it is more about instrumenting the function with automatically
recognizing its input types, memoizing its inputs, than it is about
particularly the working directory as a process