Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss

My C++ Coding Standards ( apologies to Bjarne Stroustrup ).

405 views
Skip to first unread message

Jeff-Relf.Me

unread,
Dec 23, 2016, 8:06:58 PM12/23/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
My C++ Coding Standards ( apologies to Bjarne Stroustrup ):

1. If everything ( but the top node ) were local,
then you'd be spending all your time traversing trees,
like an ant, instead of doing real work.

So use Global Variables/Functions early and often.
This, the common way, is ambiguous:

if ( HandleEvents(1) ) ...

Instead, use globals (below), like this:

WaitForClick = 1, HandleEvents(); if ( Click ) ...

Globals:

int WaitForClick, Click ;

void HandleEvents() { MSG Msg ;
GetMsg: PeekMessage( &Msg, 0, 0, 0, PM_REMOVE );
Click = Msg.message == WM_LBUTTONDOWN ;
// Handle system events, like WM_NCACTIVATE... Blah Blah.

// When WaitForClick == 1, Exit if-and-only-if there's a Click:
if ( Click || !WaitForClick ) { WaitForClick = 0 ; return ; }

// Draw Stuff... Blah Blah.
goto GetMsg ; }

2. InLine Conditionals ( Bool ? True() : False() ) are nice and concise.
For example:

inline int TheSmaller( int X, int Y ) { return X < Y ? X : Y ; }

#define FlagTheNym /* 'V' is for Visitor. */ \
Nym.Trusted ? 'T' : Nym.Dropped ? 'D' : Nym.Kid ? 'K' : Nym.Adult ? 'A' : 'V'

3. Simplify Odd system calls, like this:

wchar aString[999];
Str( aString, L"A 32 bit, unsigned Random Integer: %I64d", Rand32 );

Globals:

typedef wchar_t wchar ;
unsigned int uiRand ;
#define Rand32 ( rand_s( &uiRand ), uiRand ) // Seeding is implicit.
#define Str swprintf // Print to a Unicode string, "printf" style.

4. A variable's declared type isn't always appropriate; so Type Cast.

#define szStr (int)wcslen // Return the length of a Unicode string.

#define Zero( X ) memset( & X, 0, sizeof X ) // Implicit cast to (void*).

Zero( aStruct );

5. Create fewer/larger functions.
Put everything in a single, large .CPP file -- don't create .H files.

6. Local, ShortTerm variables are nice. Like:

wchar _T[999], *P = _T ;

Loop(3) { _Loop(4) P += Str( P, L"( %d, %d )%s", J, JJ, J == eJ ? L"\n" : L" " ); }

printf( _T );

Globals:

#define Loop( N ) int eJ = ( N ) - 1, J = -1 ; while ( ++J <= eJ )
#define _Loop( N ) int JJ = J, eJ = ( N ) - 1, J = -1 ; while ( ++J <= eJ )
#define Str swprintf
typedef wchar_t wchar ;

Output:

( 0, 0 ) ( 1, 0 ) ( 2, 0 ) ( 3, 0 )
( 0, 1 ) ( 1, 1 ) ( 2, 1 ) ( 3, 1 )
( 0, 2 ) ( 1, 2 ) ( 2, 2 ) ( 3, 2 )

See X.CPP in "Jeff-Relf.Me/X.ZIP".

Paavo Helde

unread,
Dec 24, 2016, 4:00:20 AM12/24/16
to
Nice. One suggestion: you should consider adding templates into your
toolkit. A creative mix of macros and templates makes the code even more
impenetrable. Your _Loop macros could be probably upgraded to use
recursive templates instead of boring while cycles, for example!



Peter Köhlmann

unread,
Dec 24, 2016, 4:40:50 AM12/24/16
to
wrote:

> My C++ Coding Standards ( apologies to Bjarne Stroustrup ):
>

Yes, we know. Shitty beyond belief

Jeff-Relf.Me

unread,
Dec 26, 2016, 3:36:39 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
You ( Paavo Helde ) replied ( to me ):
> > 6. Local, ShortTerm variables are nice.  Like:
> >
> >       wchar _T[999], *P = _T ;
> >
> >       Loop(3) { _Loop(4) P += Str( P, L"( %d, %d )%s", J, JJ, J == eJ ? L"\n" :  L" " );  }
> >
> >       printf( _T );
> >
> >       Globals:
> >
> >         #define   Loop( N )  int         eJ = ( N ) - 1, J = -1 ; while ( ++J <= eJ )
> >         #define  _Loop( N )  int JJ = J, eJ = ( N ) - 1, J = -1 ; while ( ++J <= eJ )
> >         #define  Str  swprintf
> >         typedef  wchar_t  wchar ;
> >
> >       Output:
> >
> >         ( 0, 0 ) ( 1, 0 ) ( 2, 0 ) ( 3, 0 )
> >         ( 0, 1 ) ( 1, 1 ) ( 2, 1 ) ( 3, 1 )
> >         ( 0, 2 ) ( 1, 2 ) ( 2, 2 ) ( 3, 2 )
> >
> > See X.CPP in "Jeff-Relf.Me/X.ZIP".
> 
> A creative mix of macros and templates makes the code even more 
> impenetrable. Your _Loop macros could be probably upgraded to use 
> recursive templates instead of boring while cycles, for example!

while() and "Loop(3) { _Loop(4)..." aren't "impenetrable", last I checked.

Paavo Helde

unread,
Dec 26, 2016, 4:17:54 PM12/26/16
to
I guess this is something we can disagree on.

_Loop(4) however is just undefined behavior, one is not allowed to use
such identifiers.

PS. I am currently in the process of refactoring some code from a
previous coworker who liked macros and templates very much. This task
has been postponed for 10 years because the code is so intractable. I'm
pretty sure this coworker thought that he wrote the best code and
followed the best coding conventions.



Öö Tiib

unread,
Dec 26, 2016, 4:24:46 PM12/26/16
to
Huh? Even name of that _Loop is illegal both by C++ (17.4.3.1.2) and C
(7.1.3) standards. When noobs use reserved names then behavior of
program is undefined.


Jeff-Relf.Me

unread,
Dec 26, 2016, 4:51:38 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
You ( Paavo Helde ) replied ( to me ):
> > while() and "Loop(3) { _Loop(4)..." aren't "impenetrable", last I checked.
> 
> I guess this is something we can disagree on.
> 
> _Loop(4) however is just undefined behavior, one is not allowed to use 
> such identifiers.

Macros are _good_, you should use them.
Who wouldn't prefer Loop(4) over "for( i=0; I <= 3; i++ )" ?
You must be prejudiced; afraid of change.

> PS. I am currently in the process of refactoring some code from a 
> previous coworker who liked macros and templates very much. This task 
> has been postponed for 10 years because the code is so intractable. I'm 
> pretty sure this coworker thought that he wrote the best code and 
> followed the best coding conventions.

Refactoring is good, God's speed.
A complete ReWrite is even better, if you can.

Jeff-Relf.Me

unread,
Dec 26, 2016, 4:54:44 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
You ( Öö Tiib ) replied ( to me ):
> > while() and "Loop(3) { _Loop(4)..." aren't "impenetrable", last I checked.
> 
> Huh? Even name of that _Loop is illegal both by C++ (17.4.3.1.2) and C
> (7.1.3) standards. When noobs use reserved names then behavior of
> program is undefined.

Local definitions override previous ones.

Underscores are too useful to not use.

"Standards" are like assholes, everyone's got one.

Öö Tiib

unread,
Dec 26, 2016, 5:27:40 PM12/26/16
to
I am not sure what standards you talk about. I meant ISO standards of
those two languages. Definitions of how the compilers of those languages
should be implemented.

Now if you violate the standards as user of compiler then standard-
conforming compiler may (but likely won't) yes rip you second asshole.

Paavo Helde

unread,
Dec 26, 2016, 6:17:46 PM12/26/16
to
On 26.12.2016 23:51, Jeff-Relf.Me wrote:
> You ( Paavo Helde ) replied ( to me ):
>> > while() and "Loop(3) { _Loop(4)..." aren't "impenetrable", last I checked.
>>
>> I guess this is something we can disagree on.
>>
>> _Loop(4) however is just undefined behavior, one is not allowed to use
>> such identifiers.
>
> Macros are _good_, you should use them.
> Who wouldn't prefer Loop(4) over "for( i=0; I <= 3; i++ )" ?

I started to write down a 10-bullet answer for that question, but then I
realized that you must be just trolling as nobody can't be that stupid.

> You must be prejudiced; afraid of change.

I have changed away from C and macro madness and have no plans to go
back, thank you.


Rick C. Hodgin

unread,
Dec 26, 2016, 6:26:43 PM12/26/16
to
On Monday, December 26, 2016 at 6:17:46 PM UTC-5, Paavo Helde wrote:
> I have changed away from C and macro madness and have no plans to go
> back, thank you.

I believe in macros (and Crystal Light ... because I believe in me).

I have created a full pre-processor language in CAlive that is a
complete subset of the language, such that things are exposed through
arrays and indices (when reference), such as "filename.ext[200]" to
reference the 200th line of the file filename.ext. The on-disk file
isn't changed, but in memory it is changed. You can insert lines,
replace anything, etc. Full editing is available through the macro
language, and there is also an ability to write out a hard commit to
disk so that a section between a starting marker and ending marker is
physically updated on disk.

[singing] "If I ever the time ... to complete this language of mine ...
then maybe I can make it sing ... and become a real, yes a
real thing."

But, we shall see, Paavo. We shall see.

Best regards,
Rick C. Hodgin

Ian Collins

unread,
Dec 26, 2016, 6:34:57 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
On 12/27/16 10:54 AM, Jeff-Relf.Me wrote:
> You ( Öö Tiib ) replied ( to me ):

>> Huh? Even name of that _Loop is illegal both by C++ (17.4.3.1.2) and C
>> (7.1.3) standards. When noobs use reserved names then behavior of
>> program is undefined.
>
> Local definitions override previous ones.
>
> Underscores are too useful to not use.
>
> "Standards" are like assholes, everyone's got one.

Only Americans...

--
Ian

Jeff-Relf.Me

unread,
Dec 26, 2016, 8:31:17 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
You ( Öö Tiib ) replied ( to me ):
> > Local definitions override previous ones.
> > Underscores are too useful to not use.
> > "Standards" are like assholes, everyone's got one.
> 
> I am not sure what standards you're talking about.
> I meant the ISO standards of those two languages. 

I use Visaul Studio 2015, exclusively;
so my code conforms to its standards,
C++11, C++14 and C++17 ( anticipated ).
 
> Now if you violate the standards as user of compiler then standard-
> conforming compiler may (but likely won't) rip you second asshole.

_Underscores have never been -- and could never be -- a problem.
If I had to rename some variables/funcs/macros, I would,
_No _Big _Deal; meanwhile, they're _Useful.

Are you _Really worried about compilers "ripping you a new one" ? !
How old are you ?  I started coding in _1976, when I was _16.
Ever since _1981, it has paid my rent.

woodb...@gmail.com

unread,
Dec 26, 2016, 8:41:30 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
On Saturday, December 24, 2016 at 3:40:50 AM UTC-6, Peter Köhlmann wrote:

Please don't swear here.


Brian
Ebenezer Enterprises
http://webEbenezer.net

Jeff-Relf.Me

unread,
Dec 26, 2016, 8:46:00 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
You ( Paavo Helde ) replied ( to me ):
> > Macros are _good_, you should use them.
> > Who wouldn't prefer Loop(4) over "for( i=0; I <= 3; i++ )" ?
> 
> I started to write down a 10-bullet answer for that question, but then I 
> realized that you must be just trolling as nobody can't be that stupid.

Sure, I wrote thousands of lines of C++, just to troll you; to wit:

  http://Jeff-Relf.Me/cStyle.HTMScreenshot>

> > You must be prejudiced; afraid of change.
> 
> I have changed away from C and macro madness 
> and have no plans to go back, thank you.

From C to what, PHP ?

My professional C++ code gets input from, and outputs to Excel 2016.

PHP could use #define, seriously.

Ian Collins

unread,
Dec 26, 2016, 9:28:56 PM12/26/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
On 12/27/16 02:41 PM, woodb...@gmail.com wrote:
> On Saturday, December 24, 2016 at 3:40:50 AM UTC-6, Peter Köhlmann wrote:
>
> Please don't swear here.

He didn't.

--
Ian

jonkalb

unread,
Dec 27, 2016, 2:24:12 AM12/27/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
On Friday, December 23, 2016 at 5:06:58 PM UTC-8, Jeff-Relf.Me wrote:
> My C++ Coding Standards ( apologies to Bjarne Stroustrup ):

I think you need to apologize to more than Bjarne. You should apologize to WG21 and to the entire C++ coding community.

When I first saw your coding guidelines I honestly thought you had your tongue in your cheek and were writing one of those lists where instead of giving good advice you deliberately give bad advice to dramatize common mistakes and show people what to avoid.

It is only after reading your responses to the comments here that I realized that you were sincere in your recommendations.

Jeff, I'm really happy that writing code this way has put food on your table since 1981. My guess is that, since you happen to be exactly my age, it is too late for you to learn "new tricks" so you'll almost certainly just run out the clock on your career writing code like this.

But I beg of you, two things. One is that you never ask me to review or any way work with any code you've ever written and the second is that you never share your coding standards or other coding advise with anyone else in the C++ community. Ever.

Thanks ever so much.

Jon

Paavo Helde

unread,
Dec 27, 2016, 3:01:51 AM12/27/16
to
On 27.12.2016 3:45, Jeff-Relf.Me wrote:
> You ( Paavo Helde ) replied ( to me ):
>> > Macros are _good_, you should use them.
>> > Who wouldn't prefer Loop(4) over "for( i=0; I <= 3; i++ )" ?
>>
>> I started to write down a 10-bullet answer for that question, but then I
>> realized that you must be just trolling as nobody can't be that stupid.
>
> Sure, I wrote thousands of lines of C++, just to troll you; to wit:
>
> http://Jeff-Relf.Me/cStyle.HTM
> <Screenshot <http://Jeff-Relf.Me/Visual-Studio-2015.PNG>>
>
>> > You must be prejudiced; afraid of change.
>>
>> I have changed away from C and macro madness
>> and have no plans to go back, thank you.
>
> From C to what, PHP ?

If you haven't figured out in 40 years that C and C++ are different
languages, then I guess it's too late for you now.

> My professional C++ code gets input from, and outputs to Excel 2016.

What C++ code? What you have posted online so far is bad C, with fixed
size arrays and unsafe sprintf() variants.

>
> PHP could use #define, seriously.

PHP is not written in C++.

Paavo Helde

unread,
Dec 27, 2016, 6:25:15 AM12/27/16
to
On 27.12.2016 3:31, Jeff-Relf.Me wrote:
> You ( Öö Tiib ) replied ( to me ):
>> > Local definitions override previous ones.
>> > Underscores are too useful to not use.
>> > "Standards" are like assholes, everyone's got one.
>>
>> I am not sure what standards you're talking about.
>> I meant the ISO standards of those two languages.
>
> I use Visaul Studio 2015, exclusively;
> so my code conforms to its standards,
> C++11, C++14 and C++17 ( anticipated ).
>
>> Now if you violate the standards as user of compiler then standard-
>> conforming compiler may (but likely won't) rip you second asshole.
>
> _Underscores have never been -- and could never be -- a problem.
> If I had to rename some variables/funcs/macros, I would,
> _No _Big _Deal; meanwhile, they're _Useful.

Of course they are no problem for you. They are a problem for another
guy or gal who includes your headers in good faith, together with some
standard includes, and then cannot understand why the code fails
compiling deep inside the standard headers. There would be no indication
that the actual problem is in your header.

Been there, done that (long time ago). It took me half a day to figure
out why the code stopped compiling after adding an innocent #include
<string> line, with mysterious error messages from deep inside system
headers. It came out that somebody had defined a macro named _B in some
header included by a header included by a header.

Öö Tiib

unread,
Dec 27, 2016, 8:58:23 AM12/27/16
to
On Tuesday, 27 December 2016 03:31:17 UTC+2, Jeff-Relf.Me wrote:
> You ( Öö Tiib ) replied ( to me ):
> > > Local definitions override previous ones.
> > > Underscores are too useful to not use.
> > > "Standards" are like assholes, everyone's got one.
> >
> > I am not sure what standards you're talking about.
> > I meant the ISO standards of those two languages.
>
> I use Visaul Studio 2015, exclusively;
> so my code conforms to its standards,
> C++11, C++14 and C++17 ( anticipated ).

Playing daff? I keep telling you that _Loop is reserved name
that programmers should not use by every of these
standards.

>
> > Now if you violate the standards as user of compiler then standard-
> > conforming compiler may (but likely won't) rip you second asshole.
>
> _Underscores have never been -- and could never be -- a problem.
> If I had to rename some variables/funcs/macros, I would,
> _No _Big _Deal; meanwhile, they're _Useful.

All code (so also every construct with defects in it) can be easily
edited and modified. That does not make written undefined
behavior or other bugs not a problem. In my experience about 80%
effort goes into fixing bugs anyway so making more deliberately
is irrational, unless that is meant as sabotage. Especially when that
underscore there gives no benefits whatsoever.

>
> Are you _Really worried about compilers "ripping you a new one" ? !
> How old are you ? I started coding in _1976, when I was _16.
> Ever since _1981, it has paid my rent.

Can't you read? I wrote that those likely won't manifest. Only
sometimes waste time pointlessly. Why to make such defects
knowingly?

Jeff-Relf.Me

unread,
Dec 27, 2016, 12:10:47 PM12/27/16
to
Why this is marked as abuse? It has been marked as abuse.
Report not abuse
You ( Jon Kalb ) replied ( to me ):
> > My C++ Coding Standards ( apologies to Bjarne Stroustrup ):
> 
> I'm really happy that writing code this way
> has put food on your table since 1981. 

It pays my rent; -- food is free for the asking.
Here in Seattle, by the University of Washington, rent is pricey.

> My guess is that, since you happen to be exactly my age,
> it is too late for you to learn "new tricks" so you'll almost certainly
> just run out the clock on your career writing code like this.

Yes because it has, and continues be, the best way.
I'd refine it, if you could offer something better;
sadly, you can't.

> never ask me to review, or work with, code you've written. 

I'm a big boy, I don't need your charity.
Note:  WhenAndOnlyWhen debugging, 
       does lots of comments and WhiteSpace make sense.

> never share your coding standards, or other coding advise,
> with anyone else in the C++ community.  Ever.

Your request has been denied, silly boy.
You could/should learn from this:

  My C++ Coding Style
  http://Jeff-Relf.Me/cStyle.HTM

Jeff-Relf.Me

unread,
Dec 27, 2016, 1:38:52 PM12/27/16
to
You ( Paavo Helde ) replied ( to me ):
> > My professional C++ code gets input from, and outputs to Excel 2016.
> 
> What C++ code? What you have posted online so far is bad C,
> with fixed size arrays and unsafe sprintf() variants.

Life isn't safe; the more you do, the less safe it is.
C++ has #define; use it.

woodb...@gmail.com

unread,
Dec 27, 2016, 1:55:00 PM12/27/16
to
On Tuesday, December 27, 2016 at 1:24:12 AM UTC-6, jonkalb wrote:
> On Friday, December 23, 2016 at 5:06:58 PM UTC-8, Jeff-Relf.Me wrote:
> > My C++ Coding Standards ( apologies to Bjarne Stroustrup ):
>
> I think you need to apologize to more than Bjarne. You should apologize to WG21 and to the entire C++ coding community.
>
> When I first saw your coding guidelines I honestly thought you had your tongue in your cheek and were writing one of those lists where instead of giving good advice you deliberately give bad advice to dramatize common mistakes and show people what to avoid.
>
> It is only after reading your responses to the comments here that I realized that you were sincere in your recommendations.
>
> Jeff, I'm really happy that writing code this way has put food on your table since 1981. My guess is that, since you happen to be exactly my age, it is too late for you to learn "new tricks" so you'll almost certainly just run out the clock on your career writing code like this.
>

I don't think that's too old to learn new tricks.

> But I beg of you, two things. One is that you never ask me to review or any way work with any code you've ever written and the second is that you never share your coding standards or other coding advise with anyone else in the C++ community. Ever.
>

I tend to agree with what he wrote about using fewer/bigger
functions. I used to have more functions in this program:

https://github.com/woodbrian/onwards/blob/master/cmwAmbassador.cc

The size of the text segment was reduced by getting rid of
some of the functions. That was the case with a number of
popular compilers. And the number of lines of code was also
reduced. So I went with it as both of those are important
to me.

He also wrote about global functions. It seems to me there's
been a move toward free functions over the past decade or so
that may be similar to what he means. Free functions aren't
necessarily global, but they are closer to global than member
functions in my opinion.

I considered his "Loop" macros and searched through my code
for places where I could use something like that. I only
found a handful of places. I don't plan on using that.


Brian
Ebenezer Enterprises - I'm glad to hear that Israel is curbing
relations with Senegal, New Zealand, Britain, France, Russia,
China, Japan, Ukraine, Angola, Egypt, Uruguay and Spain due to
their anti-semitism. I've been reducing what I buy from China
and will continue to buy American and Taiwanese products instead.

http://webEbenezer.net

Jeff-Relf.Me

unread,
Dec 27, 2016, 1:56:19 PM12/27/16
to
You ( Paavo Helde ) replied ( to me ):
> > _Underscores have never been -- and could never be -- a problem.
> > If I had to rename some variables/funcs/macros, I would,
> > _No _Big _Deal; meanwhile, they're _Useful.
> 
> It took me half a day to figure out why the code stopped _compiling 
> after adding an innocent #include <string> line, 
> with mysterious error messages from deep inside system headers. 
> 
> It came out that somebody had defined a macro named _B 
> in some header included by a header included by a header.

Compiling C++ is trivial, always.
Testing your code can be problematic, sure;
but _not compiling, _never.

As I said ( in " http://Jeff-Relf.Me/cStyle.HTM " ):
 
   Put everything in a single, large .CPP file;
   -- don't create .H files.

Paavo Helde

unread,
Dec 27, 2016, 2:38:20 PM12/27/16
to
On 27.12.2016 20:56, Jeff-Relf.Me wrote:
> You ( Paavo Helde ) replied ( to me ):
>> > _Underscores have never been -- and could never be -- a problem.
>> > If I had to rename some variables/funcs/macros, I would,
>> > _No _Big _Deal; meanwhile, they're _Useful.
>>
>> It took me half a day to figure out why the code stopped _compiling
>> after adding an innocent #include <string> line,
>> with mysterious error messages from deep inside system headers.
>>
>> It came out that somebody had defined a macro named _B
>> in some header included by a header included by a header.
>
> Compiling C++ is trivial, always.
> Testing your code can be problematic, sure;
> but _not compiling, _never.

I am pretty sure you are the first one coming up with such a claim in
this group. We should give you a medal or something.

> As I said ( in " http://Jeff-Relf.Me/cStyle.HTM " ):
>
> Put everything in a single, large .CPP file;
> -- don't create .H files.

And with what editor I would edit that million-line file?

At least I would have lots of free days when the next one-line change is
compiling ;-)

Jeff-Relf.Me

unread,
Dec 27, 2016, 2:56:35 PM12/27/16
to
You ( Paavo Helde ) replied ( to me ):
> > Compiling C++ is trivial, always.
> > Testing your code can be problematic, sure;
> > but _not compiling, _never.
> 
> I am pretty sure you are the first one coming up with such 
> a claim in this group. We should give you a medal or something.

I'm just relating my experience ( 40+ years ), that's all.

> >     Put everything in a single, large .CPP file;
> >     -- don't create .H files.
> 
> And with what editor I would edit that million-line file?
> At least I would have lots of free days when the next one-line 
> change is compiling ;-)

My 2 MegaByte .CPP files compile in no time.
How big are yours ( in MegaBytes, not lines ) ?

I'm running an i7-5775c with a TeraBye SSD.
16 gigs of 1.9 gigaHz RAM.  ArmMounted 4k IPS monitor.

Mr Flibble

unread,
Dec 27, 2016, 3:01:23 PM12/27/16
to
Don't feed the troll.

/Flibble


Jeff-Relf.Me

unread,
Dec 27, 2016, 3:16:38 PM12/27/16
to
You ( Öö Tiib ) replied ( to me ):
> > I use Visaul Studio 2015, exclusively;
> > so my code conforms to its standards,
> > C++11, C++14 and C++17 ( anticipated ).
> 
> Playing daff? I keep telling you that _Loop is reserved name
> that programmers should not use by every of these standards.

_Loop() works fine; I don't use "concurrent_vector.h";
even if I did, my local definition OverRides it.
I could change the name, of course.  I don't create .H files.
 
> > Are you _Really worried about compilers "ripping you a new one" ? !
> 
> Can't you read? I wrote that those likely won't manifest. Only
> sometimes waste time pointlessly. Why to make such defects knowingly?

Sorry, but I only see the upside ( readablity ).

There are tons of macros/funcs/vars from outside libraries;
OverRiding them ( with local definitions ) does happen, rarely,
but it has little to do with underscores.

Paavo Helde

unread,
Dec 27, 2016, 3:21:01 PM12/27/16
to
Come on, he is almost as funny as you! Though your insights into maths
are hilarious, he probably cannot beat you in that area ;-)


Paavo Helde

unread,
Dec 27, 2016, 5:02:33 PM12/27/16
to
On 27.12.2016 21:56, Jeff-Relf.Me wrote:
> You ( Paavo Helde ) replied ( to me ):
>> > Compiling C++ is trivial, always.
>> > Testing your code can be problematic, sure;
>> > but _not compiling, _never.
>>
>> I am pretty sure you are the first one coming up with such
>> a claim in this group. We should give you a medal or something.
>
> I'm just relating my experience ( 40+ years ), that's all.
>
>> > Put everything in a single, large .CPP file;
>> > -- don't create .H files.
>>
>> And with what editor I would edit that million-line file?
>> At least I would have lots of free days when the next one-line
>> change is compiling ;-)
>
> My 2 MegaByte .CPP files compile in no time.
> How big are yours ( in MegaBytes, not lines ) ?

This is because your CPP file is a renamed .c file with with no usage of
C++ features and not including any standard headers (because STL wasn't
around in 1976 I guess, it was started only in 1979). As a result, most
of your file is a poor reimplementation of standard STL utilities and
could be compressed 20x when rewritten in proper C++.

As to answer your question, the current source code written by our group
for our product is 33 MB / 748308 lines. It recompiles in ca 20 minutes
thanks to SSD disks. The recompile of the whole workspace with
third-party libraries (another 600 MB of C and C++ code) takes about 2
hours. But I'm sure that if this 33 MB is put into a single file then
the recompilation times would become infinite because the compilers
would choke and hang on it.

So, keep up the good work in turning the clock back. I would like to
have back the sixties with happy hippies and no concerns, can you make that?

Vir Campestris

unread,
Dec 27, 2016, 5:14:39 PM12/27/16
to
On 27/12/2016 20:16, Jeff-Relf.Me wrote:
> _Loop() works fine; I don't use "concurrent_vector.h";
> even if I did, my local definition OverRides it.
> I could change the name, of course. I don't create .H files.

The point is that _you_ are forbidden to use a name like that. They are
reserved for the compiler, and the next release of the compiler is quite
entitled to #define it to something that causes really weird errors.

And please don't post those funny font settings.

Andy

Ian Collins

unread,
Dec 27, 2016, 5:26:43 PM12/27/16
to
On 12/28/16 07:54 AM, woodb...@gmail.com wrote:

> Ebenezer Enterprises - I'm glad to hear that Israel is curbing
> relations with Senegal, New Zealand, Britain, France, Russia,
> China, Japan, Ukraine, Angola, Egypt, Uruguay and Spain due to
> their anti-semitism.

Fuckwit.

--
Ian

Jeff-Relf.Me

unread,
Dec 27, 2016, 5:58:14 PM12/27/16
to
Speaking of me, You ( Brian Wood ) wrote:
> I considered his "Loop" macros and searched through 
> my code for places where I could use something like that.
> I only found a handful of places.  I don't plan on using that.

True, it's not used often;
but it's a quicker to type " Loop(4) " 
than " for ( i = 0; I <= 3; i++ ) ".

Modifying a large block of text is another trick I use.

Output:

  When I slept ( 111 rows, 232 columns )
  ScreenShot.

From X.CPP in " http://Jeff-Relf.Me/X.ZIP ":
//  Warning: these lines are _long, 238 columns.

void SleepPat() { LnP _Out =
L"                                                                                                                                                                                                                                  | Turn\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 1 AM\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 2   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 3   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 4   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 5   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 6   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 7   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 8   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 9   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 10  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 11  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"................................................................................................................................................................................................................................. | Noon\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 1 PM\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 2   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 3   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 4   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 5   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 6   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 7   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 8   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 9   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 10  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 11  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"-------------------------------------------------------------------------- Xxx  5,   2:43 P, 2015  -->  Yyy  9,   6: 9 A, 2016 -------------------------------------------------------------------------------------------------- |     \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                  | Turn\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 1 AM\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 2   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 3   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 4   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 5   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 6   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 7   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 8   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 9   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 10  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 11  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"................................................................................................................................................................................................................................. | Noon\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 1 PM\n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 2   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 3   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 4   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 5   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 6   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 7   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 8   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 9   \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 10  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"                                                                                                                                                                                                                                  | 11  \n"
L"                                                                                                                                                                                                                                  |     \n"
L"--------------------------------------------------------------------------                         -->                         -------------------------------------------------------------------------------------------------- |     \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
L"                                                                                                                                                                                                                                        \n"
;  const int DateB = 75, DateE = 104, Rows = 48, TopLns = 54, LnLen = 233, Cols = LnLen - 9, Hrs = 48, Turn = 0 * 2 ;  wchar Hex ;  int Top, Bot, Dur, DateLine, DateLine2, DateLen, Col, Col2, Row, H, M ;  
   float  fDur ;  LnA  LL ;  LnP FileNam, Date, First, Last, First2, Last2, Tok, Out ;

  if ( FileNam = L"SleepLog.TXT", Diff_Load = 1, !Load_File( FileNam ) ) { Sh( L"-- Can't read <%s>.", FileNam ); return;  }
  Top = 1, Bot = DateLine = DateLine2 = 0, Col = Col2 = Cols, Out = _B_Sh, strCpy( Out, _Out ), First = _T, Last = _T + 88, First2 = _T + 200, Last2 = _T + 288, *Last = 0, *Last2 = 0 ;
  { LoopXx( Ln, fpLines ) { if ( LL = PP + 3, LL >= EE || !Eq( B + 19, L"offline:" ) ) continue;

      B = *LL, Date = B += 12 - B[-1];  if ( Top ) strCpy( !*Last ? Last : First, Date );  if ( Bot ) strCpy( !*Last2 ? Last2 : First2, Date );

      Date += 4, P = Date += *Date == 32 ;  To32;  DateLen = P - Date, *P++ = 0, P++ ;  To!32;
      Tok = P ;  While( Ch != ':' );  *P++ = 0;  H = AtoI( Tok );  To!32;  Tok = P ;  
      if ( isDigit( *Tok ) ) { To32;  *P++ = 0;  }  M = AtoI( Tok );  if ( *P == 'P' ) H += 12 ;
      //  strCpy( P, L": 2 P  " );  5:   P   6:18 P

      M = M/15, Row = Turn + 2*H + ( !M ? 0 : M == 3 ? 2 : 1 ), Row %= Hrs ;
      fDur = AtoF( LL[-1] ), Dur = Round( fDur ), Hex = Dur > 9 ? 'A' + Dur - 10 : '0' + Dur ;
      if ( Top ) { { Loop( Round( 2*fDur ) + 1 ) Out[ ( Row + J )%Hrs * LnLen + Col ] = Hex ;  }
        wmemmove( Out + ( 49 + DateLine )*LnLen + Col, Date, DateLen ), DateLine++, DateLine %= 4 ;  } 

      if ( Bot ) { { Loop( Round( 2*fDur ) + 1 ) Out[ ( ( Row + J )%Hrs + TopLns ) * LnLen + Col2 ] = Hex ;  }
        wmemmove( Out + ( 49 + DateLine2 + TopLns )*LnLen + Col2, Date, DateLen ), DateLine2++, DateLine2 %= 4 ;  } 

      if ( Bot && !--Col2 ) break ;  if ( Top && !--Col ) Top = 0 ;  if ( Col == 40 ) Bot = 1 ;  } }

  if ( !*Last ) { Sh( L"-- <%s> has no SleepLog info.", FileNam ); return;  }    BoReport ;   

  First[6] = Last[6] = ',', First[7] = Last[7] = 32, First[22] = Last[22] = 0 ;  First2[6] = Last2[6] = ',', First2[7] = Last2[7] = 32, First2[22] = Last2[22] = 0 ; 
  wmemmove( Out + Rows*LnLen + DateB, First, 22 ), wmemmove( Out + Rows*LnLen + DateE, Last, 22 );
  if ( *Last2 ) wmemmove( Out + ( Rows + TopLns )*LnLen + DateB, First2, 22 ), wmemmove( Out + ( Rows + TopLns )*LnLen + DateE, Last2, 22 );

  Sh( L"%s\n%s\n%s", RptHdr, L"'C' (Hex) means my monitor was off for 12 hours, starting at the yAxis time, on the xAxis Date.\n", Out );
  if ( SaveReport( L"SleepPat.HTM", Replace ) ) TopReport;  }

Jeff-Relf.Me

unread,
Dec 27, 2016, 7:16:33 PM12/27/16
to
You ( Paavo Helde ) replied ( to me ):
> > My 2 MegaByte .CPP files compile in no time.
> > How big are yours ( in MegaBytes, not lines ) ?
> 
> most of your file is a poor reimplementation of standard STL utilities
> and could be compressed 20x when rewritten in proper C++.

No, it doesn't take much to implement STL-like dynamic arrays.

  template < typename TyT, typename TyA, typename TyP >
  TyP & Inc( TyT  & Xx, int N );

I prefer my own stuff; easier to modify; to wit:

  My Diff looks like <This>.
  [ Red is the old stuff, Green is new ]

> As to answer your question, the current source code written 
> by our group for our product is 33 MB / 748,308 lines. 
> It recompiles in ca 20 minutes thanks to SSD disks.

What does it do ?

You could condense it down into fewer, larger, .CPP files;
or not... it's up to you and yours, of course.

Jeff-Relf.Me

unread,
Dec 27, 2016, 7:32:13 PM12/27/16
to
You ( Andy ) replied ( to me ):
> > _Loop() works fine; I don't use "concurrent_vector.h";
> > even if I did, my local definition OverRides it.
> > I could change the name, of course.  I don't create .H files.
> 
> The point is that _you_ are forbidden to use a name like that.

I'm sorry if _you_ can't but I sure as hell can/do.

> They are reserved for the compiler, 
> and the next release of the compiler is quite entitled to 
> #define it to something that causes really weird errors.

My " _Loop( N ) " OverRides that; so no problem.

> And please don't post those funny font settings.

The "OCR A" font ( Optical Character Recognition ) 
is best because each glyph is distinct, unique.

Mozilla FireFox and ThunderBird add other fonts to it,
as needed, depending on the glyph.

Personally, I use "OCR A", "MS Mincho", "Segoe UI Symbol", 
"DejaVu LGC Sans Mono" and "nSimSun" -- all "Console" fonts, 
MonoSpaced ( some are double wide ).  Depends on the glyph.

ScreenShot: http://Jeff-Relf.Me/X.PNG

Ian Collins

unread,
Dec 27, 2016, 8:11:55 PM12/27/16
to
On 12/28/16 01:16 PM, Jeff-Relf.Me wrote:
> You ( Paavo Helde ) replied ( to me ):
>> > My 2 MegaByte .CPP files compile in no time.
>> > How big are yours ( in MegaBytes, not lines ) ?
>>
>> most of your file is a poor reimplementation of standard STL utilities
>> and could be compressed 20x when rewritten in proper C++.
>
> No, it doesn't take much to implement STL-like dynamic arrays.
>
> template < typename TyT, typename TyA, typename TyP >
> TyP & Inc( TyT & Xx, int N );
>
> I prefer my own stuff; easier to modify; to wit:
>
> My Diff looks like <This <http://Jeff-Relf.Me/Diff.PNG>>.
> [ Red is the old stuff, Green is new ]
>
>> As to answer your question, the current source code written
>> by our group for our product is 33 MB / 748,308 lines.
>> It recompiles in ca 20 minutes thanks to SSD disks.
>
> What does it do ?
>
> You could condense it down into fewer, larger, .CPP files;
> or not... it's up to you and yours, of course.

Fewer, larger .cpp files has always been a pain for readers, on modern
multi-core systems it's the best way to ruin build times.

--
Ian

Jeff-Relf.Me

unread,
Dec 27, 2016, 8:23:01 PM12/27/16
to
You ( Ian Collins ) replied ( to me ):
> > You could condense it down into fewer, larger, .CPP files;
> > or not... it's up to you and yours, of course.
> 
> Fewer, larger .cpp files has always been a pain for readers, 
> on modern multi-core systems it's the best way to ruin build times.

For me, compile time is barely noticeable.
What are you compiling, and how long does it take ? !

I'm running a Core i7-5775c with a TeraBye SSD.
16 gigs of 1.9 gigaHz RAM.  ArmMounted 4k IPS monitor.

Ian Collins

unread,
Dec 27, 2016, 9:34:46 PM12/27/16
to
On 12/28/16 02:22 PM, Jeff-Relf.Me wrote:
> You ( Ian Collins ) replied ( to me ):
>> > You could condense it down into fewer, larger, .CPP files;
>> > or not... it's up to you and yours, of course.
>>
>> Fewer, larger .cpp files has always been a pain for readers,
>> on modern multi-core systems it's the best way to ruin build times.
>
> For me, compile time is barely noticeable.
> What are you compiling, and how long does it take ? !

A large control application along with about 50 other developers. A
single target build takes several minutes on a 32 core machine.

Not only would fewer, larger files be a nightmare to edit and build, we
would have way too many merges to ever get anything done.

--
Ian

Jeff-Relf.Me

unread,
Dec 27, 2016, 9:54:04 PM12/27/16
to
You ( Ian Collins ) replied ( to me ):
> > For me, compile time is barely noticeable.
> > What are you compiling, and how long does it take ? !
> 
> A large control application along with about 50 other developers. 
> A single target build takes several minutes on a 32 core machine.

What's being controlled, a robot ?

What OS are you running on this "32 core machine",
and how many people access it ?

> Not only would fewer, larger files be a nightmare to edit
> and build, we would have way too many _merges to ever get anything done.

I can't imagine what it's like to work with "50 other developers",
all working on the same bit of code... are you Linus Torvalds ?

Ian Collins

unread,
Dec 27, 2016, 10:14:21 PM12/27/16
to
Please stop changing the subject....

On 12/28/16 03:53 PM, Jeff-Relf.Me wrote:
> You ( Ian Collins ) replied ( to me ):
>> > For me, compile time is barely noticeable.
>> > What are you compiling, and how long does it take ? !
>>
>> A large control application along with about 50 other developers.
>> A single target build takes several minutes on a 32 core machine.
>
> What's being controlled, a robot ?

Heavy machinery.

> What OS are you running on this "32 core machine",
> and how many people access it ?

Some Linux, some Windows. All virtual machines on SmartOS hypervisors.

>> Not only would fewer, larger files be a nightmare to edit
>> and build, we would have way too many _merges to ever get anything done.
>
> I can't imagine what it's like to work with "50 other developers",
> all working on the same bit of code...

That how most of us work...

> are you Linus Torvalds ?

Don't be silly, he works with scores of developers...

--
Ian

Jeff-Relf.Me

unread,
Dec 27, 2016, 11:10:07 PM12/27/16
to
You ( Ian Collins ) replied ( to me ):
> > What's being controlled, a robot ?
> 
> Heavy machinery.
> 
> > What OS are you running on this "32 core machine",
> > and how many people access it ?
> 
> Some Linux, some Windows.  
> All virtual machines on SmartOS hypervisors.

Compile time isn't the bottle neck then
because, to run, you have to wait on 50+ people, 
running various _guest operating systems ( on the _host ),
controlling the (slow?) "heavy machinery".

Checking code in and out limits the size of the .CPP file,
not compile time; whatever the limitations, still:

  Fewer, Larger, .CPP files are better.

> Please stop changing the subject....

The _Default "Subject:" line is neither mandatory or desirable.

Quoting 
" rfc1036: Standard for Interchange of USENET Messages "
https://www.w3.org/Protocols/rfc1036/rfc1036.html#z4
<<

  The "Subject" line ( formerly "Title" ) 
  tells what the message is about.

  It __Should be suggestive enough of the contents of the message
  to enable a reader to make a decision whether to read 
  the message BASED ON THE SUBJECT ALONE. 

  If the message is submitted in response to another message 
  ( e.g., is a follow-up ) the _Default subject should 
  begin with the four characters "Re:", and the 
  "References" line is required.  >>

Like it or not, the subject has changed;
no longer are we talking about the original post,
" Technical challenge for DFS "; 
-- we're not even in the original NewsGroup.

This Thread, from Parent to Child:

    Incubus│incubus9536612  f55d5858-3f4b-4644...@googlegroups.com
            JeffRelf  Jeff-R...@Dec.17--0.34P.Seattle.2016
          MichaelMoroney  o394s3$e6h$3...@pcls7.std.com
        JeffRelf  Jeff-R...@Dec.19--10.56A.Seattle.2016
      MichaelMoroney  o3b89q$nfe$1...@pcls7.std.com
    JeffRelf  Jeff-R...@Dec.20--6.06A.Seattle.2016
            MichaelMoroney  o3bhcr$d8m$1...@pcls7.std.com
          JeffRelf  Jeff-R...@Dec.20--9.59A.Seattle.2016
        MichaelMoroney  o3ceg5$9d8$1...@pcls7.std.com
      JeffRelf  Jeff-R...@Dec.20--4.15P.Seattle.2016
    MrDFS  o3d28c$7c2$1...@dont-email.me
            JeffRelf  Jeff-R...@Dec.21--2.55A.Seattle.2016
          MichaelMoroney  o3fgrl$6eb$1...@pcls7.std.com
        JeffRelf  Jeff-R...@Dec.22--2.36A.Seattle.2016
      MichaelMoroney  o3hg73$k8h$1...@pcls7.std.com
    MrChrisV  jtaq5cd44la7u24la...@4ax.com
            flatfish+++│flatfish  ec4r1j...@mid.individual.net
          MichaelMoroney  o3jiu8$v4p$2...@pcls7.std.com
        JeffRelf  Jeff-R...@Dec.23--8.52A.Seattle.2016
      MichaelMoroney  o3jsu7$he6$1...@pcls7.std.com
    MrChrisV  mbuq5cpls71t5eoq0...@4ax.com
            PeterKöhlmann  o3jveq$ll6$2...@dont-email.me
          MichaelGlasser  D482D7F6.85EDE%use...@gallopinginsanity.com
        PeterKöhlmann  o3k5gr$c3c$1...@dont-email.me
      JeffRelf  Jeff-R...@Dec.23--5.06P.Seattle.2016
    Paavo_Helde│myfirstname@osa_  i5Wdne2lmpeKpMPF...@giganews.com
            JeffRelf  Jeff-R...@Dec.26--0.36P.Seattle.2016
          Öö_Tiib│ootiib@hotΞee  c9d1a189-8c1f-45ef...@googlegroups.com
        JeffRelf  Jeff-R...@Dec.26--1.54P.Seattle.2016
      Öö_Tiib│ootiib@hotΞee  63c6380a-a9cb-488a...@googlegroups.com
    JeffRelf  Jeff-R...@Dec.26--5.31P.Seattle.2016
            Paavo_Helde│myfirstname@osa_  M5mdnYP0JMYQ0v_F...@giganews.com
          JeffRelf  Jeff-R...@Dec.27--10.56A.Seattle.2016
        Paavo_Helde│myfirstname@osa_  KrydnZ4Ez9e-Xv_F...@giganews.com
      JeffRelf  Jeff-R...@Dec.27--11.56A.Seattle.2016
    Paavo_Helde│myfirstname@osa_  _u-dnbF6oopsef_F...@giganews.com
            JeffRelf  Jeff-R...@Dec.27--4.16P.Seattle.2016
          Ian_Collins│ian-news  ecghqg...@mid.individual.net
        JeffRelf  Jeff-R...@Dec.27--5.22P.Seattle.2016
      Ian_Collins│ian-news  ecgmls...@mid.individual.net
    JeffRelf  Jeff-R...@Dec.27--6.53P.Seattle.2016
  Ian_Collins│ian-news    ecgp03...@mid.individual.net

Ian Collins

unread,
Dec 27, 2016, 11:35:38 PM12/27/16
to
On 12/28/16 05:09 PM, Jeff-Relf.Me wrote:
> You ( Ian Collins ) replied ( to me ):
>> > What's being controlled, a robot ?
>>
>> Heavy machinery.
>>
>> > What OS are you running on this "32 core machine",
>> > and how many people access it ?
>>
>> Some Linux, some Windows.
>> All virtual machines on SmartOS hypervisors.
>
> Compile time isn't the bottle neck then
> because, to run, you have to wait on 50+ people,
> running various _guest operating systems ( on the _host ),
> controlling the (slow?) "heavy machinery".

Nope, there's no waiting and the build machines are mainly
cross-compiling for the machine controllers.

> Checking code in and out limits the size of the .CPP file,
> not compile time; whatever the limitations, still:
>
> Fewer, Larger, .CPP files are better.

Nope, build times are the bottleneck. If there were larger files, there
would be less build distribution, some files would need too much memory
to optimise, developers would waste too much time merging changes and
they would get pissed off editing the large files.

--
Ian

woodb...@gmail.com

unread,
Dec 27, 2016, 11:36:19 PM12/27/16
to
On Tuesday, December 27, 2016 at 4:26:43 PM UTC-6, Ian Collins wrote:

This poor man cried, and the L-RD heard him and saved him
out of all his troubles. Psalms 34:6

Ian Collins

unread,
Dec 27, 2016, 11:42:57 PM12/27/16
to
On 12/28/16 05:36 PM, woodb...@gmail.com wrote:
> On Tuesday, December 27, 2016 at 4:26:43 PM UTC-6, Ian Collins wrote:
>> fuckwit

> This poor man cried, and the L-RD heard him and saved him
> out of all his troubles. Psalms 34:6

So you respond to a fair summary of your nasty, unjustified insult with
more bollocks?

Anyway, you haven't declared L or RD, so L-RD is a syntax error.

--
Ian

woodb...@gmail.com

unread,
Dec 28, 2016, 12:24:47 AM12/28/16
to
On Tuesday, December 27, 2016 at 10:42:57 PM UTC-6, Ian Collins wrote:
> On 12/28/16 05:36 PM, woodb...@gmail.com wrote:

You are trying to add your swearing back? Wow.
I'm sorry, but things have changed now and changed for the
better.



Brian
Ebenezer Enterprises - In G-d we trust.
http://webEbenezer.net

woodb...@gmail.com

unread,
Dec 28, 2016, 1:16:42 AM12/28/16
to
On Tuesday, December 27, 2016 at 11:24:47 PM UTC-6, woodb...@gmail.com wrote:
>
> You are trying to add your swearing back? Wow.
> I'm sorry, but things have changed now and changed for the
> better.


It might be more accurate to say that things are changing
and changing for the better... and I'm sorry that the places
where things are changing for the better aren't more numerous.
Syrians deserved better ...

Jeff-Relf.Me

unread,
Dec 28, 2016, 1:49:34 AM12/28/16
to
You ( Ian Collins ) replied ( to me ):
> > Checking code in and out limits the size of the .CPP file,
> > not compile time; whatever the limitations, still:
> >    Fewer, Larger, .CPP files are better.
> 
> Nope, build times are the bottleneck.  If there were larger files, there 
> would be less build distribution, some files would need too much memory 
> to optimise, developers would waste too much time merging changes and 
> they would get pissed off editing the large files.

You _say that neither your programmers nor your compilers
could handle fewer, larger .CPP files but you could be wrong.

Have you tried fewer, larger .CPP files ?

Would a hardware/software upgrade help ?

Are you running legacy hardware/software ?

Öö Tiib

unread,
Dec 28, 2016, 5:08:35 AM12/28/16
to
On Tuesday, 27 December 2016 22:16:38 UTC+2, Jeff-Relf.Me wrote:
> You ( Öö Tiib ) replied ( to me ):
> > > I use Visaul Studio 2015, exclusively;
> > > so my code conforms to its standards,
> > > C++11, C++14 and C++17 ( anticipated ).
> >
> > Playing daff? I keep telling you that _Loop is reserved name
> > that programmers should not use by every of these standards.
>
> _Loop() works fine; I don't use "concurrent_vector.h";
> even if I did, my local definition OverRides it.
> I could change the name, of course. I don't create .H files.

You may do or not do and use or avoid using whatever you want with your own
code. That does not matter to others. However why you advice others to do
these irrational things? These only waste time, give no benefits and
make teamwork more difficult.

>
> > > Are you _Really worried about compilers "ripping you a new one" ? !
> >
> > Can't you read? I wrote that those likely won't manifest. Only
> > sometimes waste time pointlessly. Why to make such defects knowingly?
>
> Sorry, but I only see the upside ( readablity ).
>
> There are tons of macros/funcs/vars from outside libraries;
> OverRiding them ( with local definitions ) does happen, rarely,
> but it has little to do with underscores.

Where is that readability? Your words lack logic. One who sees
that _Loop in code most likely thinks that it is some compiler-specific
keyword (like _Bool or _Complex of C). Later it occurs that it is just
other guy misusing reserved naming convention for his own custom
code-mutating macro. So it was confusing. "Confusing" is not synonym
of "readable".

If you write code that confuses others then it makes it hard to cooperate
with you. That is bad since most software is not written alone. What I
have typically seen are up to 10 teams of 4 to 8 persons per team.

Jeff-Relf.Me

unread,
Dec 28, 2016, 10:30:00 AM12/28/16
to
You ( Öö Tiib ) replied ( to me ):
> > Sorry, but I only see the upside ( readablity ).
> > 
> > There are tons of macros/funcs/vars from outside libraries;
> > OverRiding them ( with local definitions ) does happen, rarely,
> > but it has little to do with underscores.
> 
> Where is that readability? Your words lack logic. One who sees 
> that _Loop in code most likely thinks that it is some compiler-specific
> keyword (like _Bool or _Complex of C). Later it occurs that it is just
> other guy misusing reserved naming convention for his own custom
> code-mutating macro. So it was confusing. "Confusing" is not synonym
> of "readable".
> 
> If you write code that confuses others then it makes it hard to cooperate
> with you. That is bad since most software is not written alone. What I
> have typically seen are up to 10 teams of 4 to 8 persons per team.

UnderScores or Not, one must check for local OverRides.
Search the .CPP file, to see if it's defined locally ( it is ).

woodb...@gmail.com

unread,
Dec 28, 2016, 12:46:01 PM12/28/16
to
If you intentionally write code that confuses others ...
is how I would say it.

> That is bad since most software is not written alone. What I
> have typically seen are up to 10 teams of 4 to 8 persons per team.

I've worked at a number of big companies and so I'm familiar
with what you are talking about. And I believe the 3-tier
architecture of the C++ Middleware Writer would work well
for teams of the size you mention. It took me a few years
to realize that the web interface I had in 2003 wasn't going
to cut it.


Brian
Ebenezer Enterprises
http://webEbenezer.net

Richard

unread,
Dec 28, 2016, 1:10:58 PM12/28/16
to
[Please do not mail me a copy of your followup]

Paavo Helde <myfir...@osa.pri.ee> spake the secret code
<fpudnft1K_KUOPzF...@giganews.com> thusly:

>I have changed away from C and macro madness and have no plans to go
>back, thank you.

Fuckin' A, bubba.
--
"The Direct3D Graphics Pipeline" free book <http://tinyurl.com/d3d-pipeline>
The Terminals Wiki <http://terminals-wiki.org>
The Computer Graphics Museum <http://computergraphicsmuseum.org>
Legalize Adulthood! (my blog) <http://legalizeadulthood.wordpress.com>

woodb...@gmail.com

unread,
Dec 28, 2016, 1:20:19 PM12/28/16
to
On Wednesday, December 28, 2016 at 12:10:58 PM UTC-6, Richard wrote:

I'm glad these "men" were busted:

http://www.twincities.com/2016/12/27/south-st-paul-teacher-partner-allegedly-abused-8-victims/

Children deserve better than "teachers" getting them
drunk and high in order to abuse them.

Ian Collins

unread,
Dec 28, 2016, 2:09:46 PM12/28/16
to
On 12/28/16 07:49 PM, Jeff-Relf.Me wrote:
> You ( Ian Collins ) replied ( to me ):
>> > Checking code in and out limits the size of the .CPP file,
>> > not compile time; whatever the limitations, still:
>> > Fewer, Larger, .CPP files are better.
>>
>> Nope, build times are the bottleneck. If there were larger files, there
>> would be less build distribution, some files would need too much memory
>> to optimise, developers would waste too much time merging changes and
>> they would get pissed off editing the large files.
>
> You _say that neither your programmers nor your compilers
> could handle fewer, larger .CPP files but you could be wrong.
>
> Have you tried fewer, larger .CPP files ?

No, for the simple reasons stated above.

> Would a hardware/software upgrade help ?

Faster hardware always helps.... We current have the fastest available.

> Are you running legacy hardware/software ?

No.

--
Ian

Chris Vine

unread,
Dec 28, 2016, 2:36:59 PM12/28/16
to
Brian,

You are a nasty piece of work who thinks it is OK to slag off anyone
or any countries that you happen to come across.

Why not just fuck off? Then you wouldn't need to worry about the
"swearing". It would also relieve us of seeing your weirdo postings.

Richard

unread,
Dec 28, 2016, 3:01:09 PM12/28/16
to
[Please do not mail me a copy of your followup]

Ian Collins <ian-...@hotmail.com> spake the secret code
<ecgtof...@mid.individual.net> thusly:

>Nope, build times are the bottleneck.

I'm looking forward to modules as an improvement here.

woodb...@gmail.com

unread,
Dec 28, 2016, 3:41:32 PM12/28/16
to
On Wednesday, December 28, 2016 at 1:36:59 PM UTC-6, Chris Vine wrote:
>
> Brian,
>
> You are a nasty piece of work who thinks it is OK to slag off anyone
> or any countries that you happen to come across.

I was criticizing "leaders" like Putin.

I asked a question about parameter type deduction with constructors:
https://groups.google.com/forum/#!topic/comp.lang.c++/m43-E2_msOw

Perhaps you could help sort that out? And over the years
there are many things that I've asked about that I hope
we will revisit.


Brian
Ebenezer Enterprises - "G-d is our refuge and strength,
a very present help in trouble. Therefore we will not
fear though the earth gives way, though the mountains
be moved into the heart of the sea, though its waters
roar and foam, though the mountains tremble at its
swelling. Selah" Psalms 46:1-3

http://webEbenezer.net

Ian Collins

unread,
Dec 28, 2016, 4:09:02 PM12/28/16
to
On 12/29/16 09:41 AM, woodb...@gmail.com wrote:
> On Wednesday, December 28, 2016 at 1:36:59 PM UTC-6, Chris Vine wrote:
>>
>> Brian,
>>
>> You are a nasty piece of work who thinks it is OK to slag off anyone
>> or any countries that you happen to come across.
>
> I was criticizing "leaders" like Putin.

No you weren't, you were directing nasty baseless insults at a dozen
countries.

--
Ian

woodb...@gmail.com

unread,
Dec 28, 2016, 4:29:21 PM12/28/16
to
The baseless hatred is toward Israel.

"Barack Obama has done his best for nearly eight years
to undermine the state of Israel."

Read more at: http://www.nationalreview.com/article/443371/obama-anti-israel-jewish-jerusalem-judeo-christian-western-civilization


Brian
Ebenezer Enterprises - "The nations rage, the kingdoms totter;
He utters his voice, the earth melts." Psalms 46:6

http://webEbenezer.net

Ian Collins

unread,
Dec 28, 2016, 4:46:38 PM12/28/16
to
On 12/29/16 10:29 AM, woodb...@gmail.com wrote:
> On Wednesday, December 28, 2016 at 3:09:02 PM UTC-6, Ian Collins wrote:
>> On 12/29/16 09:41 AM, woodb...@gmail.com wrote:
>>> On Wednesday, December 28, 2016 at 1:36:59 PM UTC-6, Chris Vine wrote:
>>>>
>>>> Brian,
>>>>
>>>> You are a nasty piece of work who thinks it is OK to slag off anyone
>>>> or any countries that you happen to come across.
>>>
>>> I was criticizing "leaders" like Putin.
>>
>> No you weren't, you were directing nasty baseless insults at a dozen
>> countries.
>>
>
> The baseless hatred is toward Israel.

Objecting to the Israeli governments illegal actions is not antisemitic.
Get your facts straight before you start lobbing insults around.

--
Ian

Chris Vine

unread,
Dec 28, 2016, 4:59:23 PM12/28/16
to
On Wed, 28 Dec 2016 12:41:13 -0800 (PST)
woodb...@gmail.com wrote:

> On Wednesday, December 28, 2016 at 1:36:59 PM UTC-6, Chris Vine wrote:
> >
> > Brian,
> >
> > You are a nasty piece of work who thinks it is OK to slag off anyone
> > or any countries that you happen to come across.
>
> I was criticizing "leaders" like Putin.
>
> I asked a question about parameter type deduction with constructors:
> https://groups.google.com/forum/#!topic/comp.lang.c++/m43-E2_msOw
>
> Perhaps you could help sort that out? And over the years
> there are many things that I've asked about that I hope
> we will revisit.

You seem to show a disregard for the truth. It is enough for you to
pose as right even if you are being malicious, objectionable and (in
this latest posting) evasive. Perhaps those are the Christian virtues
you like to aspire to? Happily I think most people realise that you are
not espousing Christian values but are instead a rather unpleasant nut
job.

On disregard for the truth, your comments were not about Putin: the
evidence of your posting is there, right in front of us. You cannot
now remove it by wishing to change the subject. Your comments were
about numerous countries, including my own. Covertly they were about
all those who have opposed the current Israeli government's position on
settlements in the occupied territories, which as it happens are
probably opposed by a plurality of Israeli citizens also.

On evasiveness, you are trying to change the subject from your previous
objectionable and off topic remarks to that of type deduction with
constructors. This is your standard ploy with all your off topic
posting. You are incapable of following any logical line of argument
because of it.

I would like you to follow the original advice and fuck off. Please
give very serious thought to that. You would be doing both us and
yourself a favour.

woodb...@gmail.com

unread,
Dec 28, 2016, 6:14:57 PM12/28/16
to
On Wednesday, December 28, 2016 at 3:59:23 PM UTC-6, Chris Vine wrote:

Chris, please don't swear here.

I've been speaking truth to power ala Yohanan the Immerser
(aka John the Baptist) for years. Criticizing Bill
Clinton, George W. Bush and especially Obama and Putin.
Yohanan the Immerser criticized King Herod and Herod had
him beheaded. Herod sounds like Assad.

It's not wise to follow "leaders" who are turning away
from G-d. Obama, Putin, Assad, ... they are corrupt
and foolish men.

Ian Collins

unread,
Dec 28, 2016, 7:05:33 PM12/28/16
to
On 12/29/16 12:14 PM, woodb...@gmail.com wrote:
> On Wednesday, December 28, 2016 at 3:59:23 PM UTC-6, Chris Vine wrote:
>
> Chris, please don't swear here.

So you can insult whole countries, but Chris can't swear?

Sanctimonious hypocrite.
--
Ian

Jeff-Relf.Me

unread,
Dec 28, 2016, 7:08:30 PM12/28/16
to
You ( Ian Collins ) replied ( to me ):
> > Have you tried fewer, larger .CPP files ?
> 
> No, for the simple reasons stated above.
> 
> > Would a hardware/software upgrade help ?
> 
> Faster hardware always helps....
> We current have the fastest available.

Sadly, I've failed to merge some of my .CPP files/apps
because the required testing would be too expensive/painful;
as a result, they're not as fresh/tested as they could be.

Dombo

unread,
Dec 29, 2016, 8:32:00 AM12/29/16
to
Op 29-Dec-16 om 0:14 schreef woodb...@gmail.com:
> On Wednesday, December 28, 2016 at 3:59:23 PM UTC-6, Chris Vine
> wrote:
>
> Chris, please don't swear here.

Why not? "Fuck" is Perhaps one of the most interesting, versatile and
colorful words in the English language today. It is the one magical word
which, just by its sound, can describe pain, pleasure, love, and hate.

In language, "fuck" falls into many grammatical categories. It can be
used as a verb, both transitive (John fucked Mary) and intransitive
(Mary was fucked by John). It can be an action verb (John really gives a
fuck), a passive verb (Mary really doesn't give a fuck), an adverb (Mary
is fucking interested in John), or as a noun (Mary is a terrific fuck).

It can also be used as an adjective (Mary is fucking beautiful) or an
interjection (Fuck! I'm late for my date with Mary). It can even be used
as a conjunction (Mary is easy, fuck she's also stupid). As you can see,
there are very few words with the overall versatility of the word "fuck"..

Aside from its sexual connotations, this incredible word can be used to
describe many situations:

1. Greetings: "How the fuck are ya?"

2. Fraud: "I got fucked by the car dealer."

3. Resignation: "Oh, fuck it!"

4. Trouble: "I guess I'm fucked now."

5. Aggression: "FUCK YOU!"

6. Disgust: "Fuck me."

7. Confusion: "What the fuck.......?"

8. Difficulty: "I don't understand this fucking business!"

9. Despair: "Fucked again..."

10. Pleasure: "I fucking couldn't be happier."

11. Displeasure: "What the fuck is going on here?"

12. Lost: "Where the fuck are we."

13. Disbelief: "UNFUCKINGBELIEVABLE!"

14. Retaliation: "Up your fucking ass!"

15. Denial: "I didn't fucking do it."

16. Perplexity: "I know fuck all about it."

17. Apathy: "Who really gives a fuck, anyhow?"

18. Greetings: "How the fuck are ya?"

19. Suspicion: "Who the fuck are you?"

20. Panic: "Let's get the fuck out of here."

21. Directions: "Fuck off."

22. Disbelief: "How the fuck did you do that?"

It can be used in an anatomical description- "He's a fucking asshole."
It can be used to tell time- "It's five fucking thirty." It can be used
in business- "How did I wind up with this fucking job?" It can be
maternal- "Motherfucker." It can be political- "Fuck Dan Quayle!"

It has also been used by many notable people throughout history:

"What the fuck was that?"
- Mayor of Hiroshima

"Where did all these fucking Indians come from?"
- General Custer

"Where the fuck is all this water coming from?"
- Captain of the Titanic

"That's not a real fucking gun."
- John Lennon

"Who's gonna fucking find out?"
- Richard Nixon

"Heads are going to fucking roll."
- Anne Boleyn

"Let the fucking woman drive."
- Commander of Space Shuttle

"What fucking map?"
- "Challenger," Mark Thatcher

"Any fucking idiot could understand that."
- Albert Einstein

"It does so fucking look like her!"
- Picasso

"How the fuck did you work that out?"
- Pythagoras

"You want what on the fucking ceiling?"
- Michaelangelo

"Fuck a duck."
- Walt Disney

"Why?- Because its fucking there!"
- Edmund Hilary

"I don't suppose its gonna fucking rain?"
- Joan of Arc

"Scattered fucking showers my ass."
- Noah

"I need this parade like I need a fucking hole in my head."
- John F. Kennedy


woodb...@gmail.com

unread,
Dec 29, 2016, 1:27:57 PM12/29/16
to
On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:

And he said: "Truly I tell you, unless you change and become
like little children, you will never enter the kingdom of heaven.
Matthew 18:3

Please don't swear here.


Brian
Ebenezer Enterprises - Here are five demonstrations that the
“Palestinians want peace” notion is an outright lie, and that
Palestinians actually prefer a continued conflict that
maintains the possibility of the full-scale destruction of
the Jewish State.

http://www.dailywire.com/news/11993/do-palestinians-want-peace-here-are-5-facts-say-no-ben-shapiro

Dombo

unread,
Dec 29, 2016, 2:31:17 PM12/29/16
to
Op 29-Dec-16 om 19:27 schreef woodb...@gmail.com:
> On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:
>
> And he said: "Truly I tell you, unless you change and become
> like little children, you will never enter the kingdom of heaven.
> Matthew 18:3

You really believe that the verses in your "holy" bible are like magic
spells don't you? Guess what, they don't do fuck. Grow up.


> Please don't swear here.

Your religion is your fucking problem mate, don't try make it my problem.

Ian Collins

unread,
Dec 29, 2016, 3:55:57 PM12/29/16
to
On 12/30/16 07:27 AM, woodb...@gmail.com wrote:
> On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:
>
> And he said: "Truly I tell you, unless you change and become
> like little children, you will never enter the kingdom of heaven.
> Matthew 18:3

Do little children insult whole countries?

> Please don't swear here.

Hypocrite.

--
Ian

woodb...@gmail.com

unread,
Dec 29, 2016, 5:19:51 PM12/29/16
to
On Thursday, December 29, 2016 at 2:55:57 PM UTC-6, Ian Collins wrote:
> On 12/30/16 07:27 AM, woodb...@gmail.com wrote:
> > On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:
> >
> > And he said: "Truly I tell you, unless you change and become
> > like little children, you will never enter the kingdom of heaven.
> > Matthew 18:3
>
> Do little children insult whole countries?

I agree with Ben Shapiro when he describes himself
as a "radical individualist". I'm for people,
but against the baseless hatred in some "leaders"
-- Putin, Obama ...

Some would like to set a trap for Israel with this
UN (United Nothing) vote. The funny thing is that
these "leaders" will have the trap they intended for
Israel recoil on themselves. I'll be buying products
from Taiwan and South Korea, rather than China or Japan.


Brian
Ebenezer Enterprises - "They prepared a net for my steps;
My soul is bowed down; They dug a pit before me; they
themselves have fallen into the midst of it. Selah." Psalms 57:6

http://webEbenezer.net

Ian Collins

unread,
Dec 29, 2016, 5:25:45 PM12/29/16
to
On 12/30/16 11:19 AM, woodb...@gmail.com wrote:
> On Thursday, December 29, 2016 at 2:55:57 PM UTC-6, Ian Collins wrote:
>> On 12/30/16 07:27 AM, woodb...@gmail.com wrote:
>>> On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:
>>>
>>> And he said: "Truly I tell you, unless you change and become
>>> like little children, you will never enter the kingdom of heaven.
>>> Matthew 18:3
>>
>> Do little children insult whole countries?
>
> I agree with Ben Shapiro when he describes himself
> as a "radical individualist". I'm for people,
> but against the baseless hatred in some "leaders"

So how much do you know about the people and leaders of New Zealand?
Enough to insult us?

--
Ian

woodb...@gmail.com

unread,
Dec 30, 2016, 12:59:57 AM12/30/16
to
G-d loves people from New Zealand, including the leaders. G-d
loved King Herod even though Herod murdered Yohanan the Immerser
(aka John the Baptist). But G-d sent Yohanan and Yeshua (aka
Jesus), in part, to stand up to Herod. Herod didn't respond
well to their rebuke. I'm afraid there's no shortage of corrupt
people like Herod in power today.

Ian Collins

unread,
Dec 30, 2016, 3:27:59 AM12/30/16
to
On 12/30/16 06:59 PM, woodb...@gmail.com wrote:
> On Thursday, December 29, 2016 at 4:25:45 PM UTC-6, Ian Collins wrote:
>> On 12/30/16 11:19 AM, woodb...@gmail.com wrote:
>>> On Thursday, December 29, 2016 at 2:55:57 PM UTC-6, Ian Collins wrote:
>>>> On 12/30/16 07:27 AM, woodb...@gmail.com wrote:
>>>>> On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:
>>>>>
>>>>> And he said: "Truly I tell you, unless you change and become
>>>>> like little children, you will never enter the kingdom of heaven.
>>>>> Matthew 18:3
>>>>
>>>> Do little children insult whole countries?
>>>
>>> I agree with Ben Shapiro when he describes himself
>>> as a "radical individualist". I'm for people,
>>> but against the baseless hatred in some "leaders"
>>
>> So how much do you know about the people and leaders of New Zealand?
>> Enough to insult us?
>>
>
> G-d loves people from New Zealand, including the leaders.


In other words, no. An apology would be appropriate.

--
Ian

David Brown

unread,
Dec 30, 2016, 4:08:06 AM12/30/16
to
On 29/12/16 23:19, woodb...@gmail.com wrote:
> On Thursday, December 29, 2016 at 2:55:57 PM UTC-6, Ian Collins wrote:
>> On 12/30/16 07:27 AM, woodb...@gmail.com wrote:
>>> On Thursday, December 29, 2016 at 7:32:00 AM UTC-6, Dombo wrote:
>>>
>>> And he said: "Truly I tell you, unless you change and become
>>> like little children, you will never enter the kingdom of heaven.
>>> Matthew 18:3
>>
>> Do little children insult whole countries?
>
> I agree with Ben Shapiro when he describes himself
> as a "radical individualist". I'm for people,
> but against the baseless hatred in some "leaders"
> -- Putin, Obama ...
>

So you claim to be /for/ the people (of USA, NZ, UK, Russia, etc.), and
against their leaders? Fair enough - there is nothing wrong with having
a political opinion (though it is always much better if it is /informed/
opinion, rather than just knee-jerk reaction).

So why do you then insult the /people/ (of USA, etc.) rather than their
leaders?

And why do you accuse them of "anti-semitism" - prejudice against Jews
either as a people or as members of a religion? Both the leaders and
the majority of the populace of these countries disapproves of Israel's
/leaders/ and political policies - they have nothing against either the
people of Israel, the Jewish religion, or anything else that could be
construed as anti-semitism. They just don't think that one country
should invade its neighbours and turn that country into a giant prison
camp while stealing their land and resources. The leaders and populace
of USA, etc., don't care if the tyrants behind this plan are Jewish,
Christian, Muslim, Martians, or whatever.

The hypocrisy behind your "thinking" is just astounding. It does not
matter how often you quote your old book, or complain about swearing -
you can't claim to be Christian if you don't understand basic humanity
and if you don't follow Jesus' most important rule - love thy neighbour.


> Some would like to set a trap for Israel with this
> UN (United Nothing) vote. The funny thing is that
> these "leaders" will have the trap they intended for
> Israel recoil on themselves. I'll be buying products
> from Taiwan and South Korea, rather than China or Japan.
>

Whoa, these countries are in for a shock! When they find out that Brian
is no longer buying products from China and Japan, their economies will
be collapsing in no time. Watch out for that "recoil"!


asetof...@gmail.com

unread,
Dec 30, 2016, 5:50:08 AM12/30/16
to
The leaders are choosed many time from peoples but only
in a rose, or in a little set choosed
from elite...
So where is the choose people has?

asetof...@gmail.com

unread,
Dec 30, 2016, 6:17:30 AM12/30/16
to
For me it is better leader is the
parliaments so many peoples
not just one...
More people there are in parlaments
better it is

woodb...@gmail.com

unread,
Dec 30, 2016, 12:52:04 PM12/30/16
to
If I were planning a trip to your part of the world, I'd
go to Australia.

"Australian Foreign Minister claims that if it had had a say,
Australia would not have voted for the recent "one-sided" UN resolution."

http://www.israelnationalnews.com/News/News.aspx/222531

I've never been to Australia or New Zealand, but
Austrailia is looking like they still have a heart.


Brian
Ebenezer Enterprises - Enjoy programming again.
http://webEbenezer.net

interv...@gmail.com

unread,
Dec 30, 2016, 1:43:55 PM12/30/16
to
On Monday, December 26, 2016 at 1:51:38 PM UTC-8, Jeff-Relf.Me wrote:
> Macros are _good_, you should use them.

Sure. Microsoft created a whole language out of them. Its called MFC.

Wouter van Ooijen

unread,
Dec 30, 2016, 1:46:11 PM12/30/16
to
Op 30-Dec-16 om 6:51 PM schreef woodb...@gmail.com:
> On Friday, December 30, 2016 at 2:27:59 AM UTC-6, Ian Collins wrote:
>> On 12/30/16 06:59 PM, woodb...@gmail.com wrote:
>>>>
>>>
>>> G-d loves people from New Zealand, including the leaders.
>>
>>
>> In other words, no. An apology would be appropriate.
>>
>
> If I were planning a trip to your part of the world, I'd
> go to Australia.
>
> "Australian Foreign Minister claims that if it had had a say,
> Australia would not have voted for the recent "one-sided" UN resolution."

one-sided?

ROFL!

Wouter "Objects? No Thanks!" van Ooijen

Jeff-Relf.Me

unread,
Dec 30, 2016, 5:17:33 PM12/30/16
to
You ( interval1066 ) replied ( to me ):
> > Macros are _good_, you should use them.
> 
> Sure.  Microsoft created a whole language out of them.  Its called MFC.

True that, MFC sucks.  _My Macros are good ( for me, and only me ).

P.S. I improved the look of my Source Code Comparison routine.
ScreenShot:
My Source Code Comparison routine.

Richard

unread,
Jan 1, 2017, 7:44:57 PM1/1/17
to
[Please do not mail me a copy of your followup]

interv...@gmail.com spake the secret code
<6d043fba-f4c8-45c2...@googlegroups.com> thusly:

>On Monday, December 26, 2016 at 1:51:38 PM UTC-8, Jeff-Relf.Me wrote:
>> Macros are _good_, you should use them.
>
>Sure. Microsoft created a whole language out of them. Its called MFC.

That's a bit unfair. When MFC was created, lots of what we can do
with templates wasn't known yet. Also, the message maps and whatnot
are basically static data structures. If you didn't use macros to
eliminate the boilerplate, it would be worse.

There are still a few small tasks at which macros are useful. Namely
token composition and emitting a chunk of repeated boilerplate. In
this regard, the preprocessor is basically being used as a limited
form of code generation. It's fine until you get into advanced code
generation and then you're better off with a separate tool, which
thankfully is easily written in standard C++.

Jeff-Relf.Me

unread,
Jan 2, 2017, 2:51:56 AM1/2/17
to
#define came from God himself, it's sacred.

For example: At times, my code needs to set flags; to wit:

#define TopFlags ( S = BB_Slow <= EE_Slow, \
_S = _BB_Slow <= _EE_Slow, \
F = BB_Fast <= EE_Fast, \
_F = _BB_Fast <= _EE_Fast )

#define BtmFlags ( S = EE_Slow >= BB_Slow, \
_S = _EE_Slow >= _BB_Slow, \
F = EE_Fast >= BB_Fast, \
_F = _EE_Fast >= _BB_Fast )

I'd much rather see "TopFlags", in places, then the expansion.

The best code ( for me, and only me )
is the code I designed and wrote myself.

As a programmer, text file comparison is essential, like water.
So I wrote my own diff routines
( ScreenShot: http://Jeff-Relf.Me/Diff.PNG ).
[ See X.EXE, X.HTM and X.CPP in http://Jeff-Relf.Me/X.ZIP ]

Diff scans ( comparing "Tokens"[*] ) from four directions at once
( LeftOlder: to Top, to Bottom; RightNewer: to Top, to Bottom ).
[ *: "Lines" in files, "Words" in lines ]

At it's heart, and right off the bat,
Diff skips unchanged Tokens at the start and/or end.
I call this "the Pinch".

Then it "peels off" MisMatches from the ends ( the "diffs" )...
Stopping when it finds MatchCount matches[*]...
Pinching and Peeling, from the edges to the middle.
[ *: MatchCount is 1 for normal, nearby matches,
not counting BlankLines. Otherwise, WhiteSpace matters. ]

The "diffs" are then sorted by line number and printed...
both the lines in the files and the words in the lines...
green for the new stuff, red for the old stuff.

This way, I can easily focus on the red and green words,
(mostly) ingnoring the rest.

Peel(), below, peels off diffs from the tops and bottoms
of LeftOlder and RightNewer text files.

BB is a pointer to start of a dynamic array of lines ( pointers );
EE points to the end of the array.

Already, BB and EE point to "diffs" (mismatches lines).
BB and EE are from the LeftOlder file.
_BB and _EE are from the RightNewer file.

void Peel( LnA BB, LnA EE, LnA _BB, LnA _EE ) { int rv, S, _S, F, _F ;
LnP t, _t ; LnA BB_Slow, _BB_Slow, BB_Fast, _BB_Fast, EE_Slow, _EE_Slow, EE_Fast, _EE_Fast ;
TopMatch = BtmMatch = 0, BB_Slow = BB, _BB_Slow = _BB, EE_Slow = EE, _EE_Slow = _EE, ReSetBB_Fast, ReSetEE_Fast ;

Top: if ( TopMatch ) if ( BtmMatch ) goto Done ; else goto Btm ;
if ( TopFlags, TopMatch = !S && !_S ) {

// Done scaning the top of LeftOlder and RightNewer, no matches.
BB_Match = 0 ; goto Btm ; }

if ( F && _S ) if ( !gTopMatch( BB_Fast - BB_Slow, BB_Fast, EE, _BB_Slow, _EE ) ) BB_Fast++ ; else goto Btm ;
if ( _F && S ) if ( !gTopMatch( _BB_Fast - _BB_Slow, BB_Slow, EE, _BB_Fast, _EE ) ) _BB_Fast++ ; else goto Btm ;

// Lower the top of LeftOlder and RightNewer.
if ( TopFlags, !( F && _S || _F && S ) ) BB_Slow += S, _BB_Slow += _S, ReSetBB_Fast ; goto Btm ;

Btm: if ( BtmMatch ) if ( TopMatch ) goto Done ; else goto Top ;
if ( BtmFlags, BtmMatch = !S && !_S ) {

// Done scaning the bottom of LeftOlder and RightNewer, no matches.
EE_Match = 0 ; goto Top ; }

if ( F && _S ) if ( !gBtmMatch( EE_Slow - EE_Fast, BB, EE_Fast, _BB, _EE_Slow ) ) EE_Fast-- ; else goto Top ;
if ( _F && S ) if ( !gBtmMatch( _EE_Slow - _EE_Fast, BB, EE_Slow, _BB, _EE_Fast ) ) _EE_Fast-- ; else goto Top ;

// Raise the bottom of LeftOlder and RightNewer.
if ( BtmFlags, !( F && _S || _F && S ) ) EE_Slow -= S, _EE_Slow -= _S, ReSetEE_Fast ; goto Top ;

Done: BB_Match = BB_Match && EE_Match ? BB_Match : EE_Match ? ( _BB_Match = _EE_Match, EE_Match ) : ( _BB_Match = _EE, EE );
EE_Match = BB_Match && EE_Match ? EE_Match : BB_Match ? ( _EE_Match = _BB_Match, BB_Match ) : ( _EE_Match = _BB, BB ); }

Globals:

int TopMatch, BtmMatch ; LnP F, _F ;
LnA BBx, EEx, _BBx, _EEx, BB_Match, EE_Match, _BB_Match, _EE_Match ;

#define TokensMatch ( F && _F && F[-1] == _F[-1] && Eq( F, _F ) )
#define ReSetBB_Fast ( BB_Fast = BB_Slow, _BB_Fast = _BB_Slow )
#define ReSetEE_Fast ( EE_Fast = EE_Slow, _EE_Fast = _EE_Slow )

#define ShaveDown ( goDown( F, EEx, EE ), goDown( _F, _EEx, _EE ), TokensMatch )
#define PinchDown ( goDown( F, BBx, EE ), goDown( _F, _BBx, _EE ), TokensMatch )
#define goDown( P, PP, EE ) ( P = ++PP >= EE ? 0 : *PP )

int gTopMatch( int Wander, LnA BB, LnA EE, LnA _BB, LnA _EE ) {
BB_Match = EEx = BB, _BB_Match = _EEx = _BB, EEx--, _EEx-- ;
Loop( 1 + Wander/99 ) if ( ShaveDown ) eJ += !*F ; else return 0 ;
return TopMatch = 1 ; }

#define ShaveUp ( goUp( F, BBx, BB ), goUp( _F, _BBx, _BB ), TokensMatch )
#define PinchUp ( goUp( F, EEx, BBx ), goUp( _F, _EEx, _BBx ), TokensMatch )
#define goUp( P, PP, BB ) ( P = --PP < BB ? 0 : *PP )

int gBtmMatch( int Wander, LnA BB, LnA EE, LnA _BB, LnA _EE ) {
EE_Match = BBx = EE, _EE_Match = _BBx = _EE ;
Loop( 1 + Wander/99 ) if ( ShaveUp ) eJ += !*F ; else return 0 ;
return BtmMatch = 1 ; }

Far Globals:

#define Loop( N ) int eJ = ( N ) - 1, J = -1 ; while ( ++J <= eJ )

typedef wchar_t wchar ; typedef wchar *LnP ; typedef LnP *LnA ;

Jeff-Relf.Me

unread,
Jan 2, 2017, 3:01:04 AM1/2/17
to
#define came from God himself, it's sacred. #define came from God
himself. Himself, it's sacred.

To set flags; to set flags; to set flags; to set flags; to wit: For
example: At times, my code needs to set flags; to set.

_EE_Slow <= EE_Fast <= EE_Fast, \ F = _BB_Slow <= _EE_Slow, \ F =
BB_Slow, \ _F = BB_Slow, \ _S = BB_Fast <= EE_Slow <= EE_Slow <=
_BB_Fast <= _BB_Slow <= EE_Slow <= _BB_Fast <= EE_Fast <= EE_Fast )
#define TopFlags ( S = _BB_Slow, \ _F = BB_Slow <= EE_Slow <=.

> = BB_Slow, \ F = _BB_Slow = BB_Fast, \ _S = _EE_Slow = _BB_Fast =
> BB_Slow, \ _F = EE_Slow, \ _F = _EE_Slow, \ _F = EE_Slow = BB_Slow =
> _BB_Slow = BB_Slow, \ F = EE_Slow = BB_Slow, \ _F = _BB_Fast =
> _BB_Fast ) #define BtmFlags ( S = EE_Slow = _EE_Slow.

I'd much rathen ther see "TopFlags", in places, ther see "TopFlags",
in places, then the. Expansion.

Wrote myself. The best code ( for me, and only me ) is the best code I
designed and wrote myself. The code ( for me, and. The best code ( for
me, and wrote myself.

So I wrote my own diff.PNG ). [ See X.CPP in http://Jeff-Relf.Me/X.ZIP
] As a programmer, text file comparison is essential, like water. So I
wrote my own. Routines ( ScreenShot: http://Jeff-Relf.Me/X.ZIP ] As a
programmer, text file comparison is essential, like water. So I wrote
my own diff routines ( ScreenShot: http://Jeff-Relf.Me/X.ZIP ] As a
programmer, text file comparison is essential, like water.

Four directions at once ( comparing "Tokens"[*] ) from four directions
( LeftOlder: to Top, to Top, to Top, to Top, to Top, to Top, to Top,
to Top, to Bottom four directions at once ( LeftOlder: to Top, to Top,
to Bottom; RightNewer: to Bottom; RightNewer: to Top, to Top, to Top,
to Top, to Top, to Bottom; RightNewer: to Top, to Top, to Bottom four.

Heart, Diff skips unch". I call the Pinchanged Tokens at the bat, and
right off the bat, and right off this "the start, Diff this "the
Pinch". At it's heart, and right off the bat, Diff. At it's heart, and
right off the bat, and/or end.

*: MatchCount is 1 for normal, nearby matches[*]. MisMatchCount
matters. [ *: Matches to the "diffs" ). Pinching when it finds ( the
ends ( therwise, WhiteSpace middle. Othe edges from the ends ( the
middle. Stopping and Peels off" MisMatches, nearby matters. Stopping
and Peels off" MisMatchCount is 1 for not count matchCount matches,
nearby matchCount. Stopping, from the ends ( the ends ( the ends ( the
edges from the ends Matches from the "diffs" ). Othe ends ( the ends (
the "diffs" ). Stopping when it "peels off" MisMatches[*].

Both the old stuff, red by lines. Both the new stuff, red by line
number and the "diffs" are the words in the words in the words in then
sorted by line number and the number and then sorted by line number
and printed. Both the words in the old stuff, red by lines in the new
stuff, red by lines. Both the lines in then sorted.

This way, I can easily focus on the rest. This way. This way, I can
easily focus on the red and green words, (mostly) ing the red and
green words, (mostly) ing the rest. Rest.

Peel(), below, peels off diffs from the tops and RightNewer and
bottoms of LeftOlder. RightNewer and RightNewer and bottoms of
LeftOlder and RightNewer and bottoms of LeftOlder and RightNewer text
files.

BB is a pointers ); EE pointer to start of a pointer to the end.
Pointers ); EE points to start of a pointer to start of a points to
the end of lines ( pointer to start of a points to start of a dynamic
array.

BB and EE point to "diffs" (mismatches. Lines). BB and EE point to
"diffs" (mismatches lines). Already, BB and EE point to "diffs"
(mismatches lines). BB and EE are from the LeftOlder file. BB and _EE
are from the LeftOlder file. Already, BB and _EE point to "diffs"
(mismatches lines).

Peel( LnP t, EE, _BB, LnA BB_Slow, BB, _EE ) { int rv, S, _F ; LnA
BB_Slow, _F ; void Peel( LnA _BB_Fast ; LnA BB, _t ; LnA _BB, EE_Slow
= BtmMatch = 0, BB_Fast, _EE_Fast ; TopMatch = _BB_Slow, _BB, EE_Fast,
EE_Fast, _t ; LnA _BB, _BB_Slow = BB_Fast, _EE_Slow, BB_Slow, _BB_Slow
= EE, LnA EE, _BB_Slow = EE_Fast, EE, _EE_Slow = BtmMatch = _BB_Fast,
EE, ReSetEE_Fast, EE_Slow, _EE_Fast, _S, _EE_Slow, BB_Slow, _BB_Slow,
_F ; LnA _EE_Slow, _BB, LnA BB, LnA BB_Slow = EE_Slow = BtmMatch =
BtmMatch = BB_Slow = BB_Fast, _BB_Slow = EE_Fast, _BB_Fast, _BB,
_BB_Slow.

TopFlags, TopMatch ) if ( BtmMatch ) goto Done ; else goto Done ; else
goto BtmMatch ) if ( Btm ; else goto Done ; else goto Done ; else goto
Btm ; else goto BtmMatch ) goto BtmMatch ) if ( TopMatch ) if (
TopFlags.

BB_Match = 0 ; goto Btm ; } // Done scaning the top of LeftOlder and
RightNewer, no matches. BB_Matches. BB_Match = 0 ; goto. Top of
LeftOlder and RightNewer, no matches. BB_Matches.

If ( !gTopMatch( _F && S ) if ( _BB_Fast, EE, _BB_Slow, EE, _BB_Fast -
_BB_Slow, BB_Fast++ ; if ( _F && S ) BB_Slow, _BB_Fast - BB_Fast++ ;
else goto Btm ; if ( F && S ) if ( _BB_Fast - BB_Slow, BB_Fast, EE,
_BB_Fast - _BB_Fast++ ; else goto Btm ; else goto Btm ; else goto Btm
; else goto Btm ; if ( _F && S ) if ( _F && _S ) BB_Fast - _BB_Slow,
BB_Fast, EE, _EE ) BB_Slow, _BB_Fast, EE, _BB_Slow, BB_Fast - BB_Slow,
_EE.

RightNewer. If ( TopFlags, !( F && _S || _F && _S ||. If ( TopFlags,
!( F && _S, _BB_Slow += S, ReSetBB_Slow += S, _BB_Slow += S,
ReSetBB_Slow += S, _BB_Slow += S, _BB_Slow += S, _BB_Slow += _S,
ReSetBB_Slow += _S || _F && S ) BB_Slow += S, ReSetBB_Slow += S,
_BB_Slow += S, _BB_Fast ; goto Btm ; // Lower.

Goto Done ; if ( BtmMatch ) if ( BtmMatch = !S && !_S ) goto Done ; if
( BtmMatch ) goto TopMatch ) goto Done ; else goto TopMatch ) if (
TopMatch = !S && !_S ) if ( Btm: if ( BtmMatch ) { BtmMatch = !S &&
!_S ) {.

EE_Match. 0 ; goto Top ; goto Top ; } // Done scaning the bottom of
LeftOlder and RightNewer, no match = 0 ; goto Top ; goto Top ; } //
Done scaning the bottom of LeftOlder and RightNewer, no matches.

_EE_Slow, _BB, EE_Fast, BB, _BB, _EE_Slow - EE_Slow ) if ( !gBtmMatch(
EE_Fast, BB, _BB, EE_Slow ) if ( F && _S ) EE_Fast-- ; else goto Top ;
else goto Top ; else goto Top ; else goto Top ; else goto Top ; else
goto Top ; if ( !gBtmMatch( _F && _S ) if ( !gBtmMatch( EE_Fast ) if (
F && _S ) if ( F && _S ) _EE_Fast-- ; else goto Top ; else goto Top ;
else goto Top ; else goto Top ; else goto Top ; if ( F && _S ).

If ( BtmFlags, !( F && _S, ReSetEE_Slow -= _S || _F && S ) EE_Slow -=
_S || _F && _S || _F && _S || _F && S ) EE_Slow -= S, ReSetEE_Slow -=
_S || _F && _S || _F && _S, _EE_Slow -= S, _EE_Slow -= S, ReSetEE_Slow
-= S, ReSetEE_Fast. goto Top ; // Raise the bottom of LeftOlder and
RightNewer.

_EE, EE ); } Done: BB_Match = _BB_Match, EE_Match : BB_Match =
_EE_Match = _EE_Match : BB_Match ) : ( _EE, EE ); EE_Match ? (
_BB_Match = BB_Match = _EE_Match, EE_Match ) : BB_Match = _BB_Match )
: BB_Match : EE_Match : ( _EE_Match : ( _BB_Match ? BB_Match =
BB_Match = BB_Match ? ( _BB_Match = _BB_Match = BB_Match ? EE_Match,
EE ); EE_Match ? BB_Match ) : ( _EE, EE_Match ? ( _EE_Match &&
EE_Match = BB_Match ? EE_Match ? ( _BB_Match ? BB_Match ? BB_Match =
BB_Match = _BB_Match = BB_Match.

Globals:

LnP F, _BB_Match, EEx, _EEx, _BBx, BtmMatch, BtmMatch ; int TopMatch,
_BB_Match ; LnP F, _BB_Match, BB_Match ; LnP F, _EEx, _F ; LnA BBx,
BtmMatch, _BBx, EEx, BtmMatch, _BBx, BtmMatch, BtmMatch.

EE_Fast ( BB_Fast = EE_Fast = BB_Fast = _F[-1] && _F[-1] == _EE_Slow,
_F && _F[-1] && _F ) #define TokensMatch ( F, _F[-1] == _BB_Fast (
BB_Fast = EE_Slow, _F[-1] && Eq( F && _F && _F && Eq( F, _F && Eq( F
&& _F ) #define ReSetEE_Slow ) #define TokensMatch ( F && F[-1] ==
_EE_Fast = BB_Slow, _BB_Slow, _F[-1] == _EE_Fast = _F[-1] == _EE_Fast
( F && _F && _F ) #define TokensMatch.

_BBx, EE ), TokensMatch ) #define PinchDown ( goDown( P = ++PP )
#define goDown( F, _EE ? 0 : *PP ) #define PinchDown( F, EE ), goDown(
F, _EE ? 0 : *PP >= EE ), TokensMatch ) ( goDown( _F, _EE ), goDown(
F, _EEx, EE ), TokensMatch ) #define PinchDown( _F, BBx, EE ) #define
goDown( F, EE ), TokensMatch ) #define PinchDown ( goDown( F, EE ),
goDown ( goDown( P, EEx, _EEx, EE ), goDown ( goDown( F, BBx, EEx, EE
? 0 : *PP >= EEx, EE.

_BB, LnA BB_Match = EEx = EEx-- ; else return TopMatch( int Wander,
LnA BB, LnA _EEx = BB_Match( int Wander, LnA _BB, EEx--, _BB, _EEx--,
_BB_Match = _BB, LnA EE, LnA BB, EEx = _EEx = BB, EEx = _EE ) if (
ShaveDown ) { BB_Match( int gTopMatch( int Wander, LnA BB, LnA _EEx--,
_BB_Match = BB, LnA EEx--, _BB, LnA _EE ) eJ += !*F ; Loop( 1 +
Wander/99 ) eJ += !*F ; else return 0 ; else return TopMatch = _EEx =
_BB, LnA EE, LnA BB_Match =.

*PP < BB ? 0 : *PP < BB ) #define goUp( F, _BB ), goUp( F, _EEx, BBx,
_BBx, _EEx, _BB ? 0 : *PP < BB ), TokensMatch ) #define PinchUp (
goUp( F, _EEx, _BBx, _EEx, BB ), goUp( P, BBx, _BBx ), goUp( _F, EEx,
_EEx, _BB ), TokensMatch ) ( goUp( P = --PP ) #define PinchUp ( goUp(
_F, _BB ), goUp( _F, EEx, BBx ), TokensMatch ) #define goUp( _F, _BBx,
_BB ), TokensMatch ) #define PinchUp ( goUp( _F, EEx, _BB ), goUp(.

GBtmMatch = 1 + Wander, LnA BB, LnA _EE_Match = _EE ) if ( ShaveUp )
if ( ShaveUp ) { EE_Match = EE, LnA _EE_Match( int gBtmMatch = 1 +
Wander/99 ) { EE_Match( int gBtmMatch = _BB, LnA _BB, LnA BB, LnA BBx
= _BB, LnA EE, LnA EE_Match( int Wander, LnA _BB, LnA EE, _EE ) eJ +=
!*F ; Loop( 1 + Wander, LnA _BB, LnA EE, LnA _EE_Match = EE_Match =
EE_Match = _BBx = EE, _EE_Match = _BB, LnA BBx = EE_Match( int.

Gls: Globalobals: Falobals:s:.

While ( ++J <= eJ ) - 1, J = ( N ) - 1, J = ( N ) int eJ ) int eJ ) -
1, J = ( ++J <= eJ = ( ++J <= eJ = ( ++J <= eJ ) - 1, J = ( N ) - 1.

Wchar *LnP ; typedef wchar_t wchar ; typedef wchar_t wchar *LnP ;
typedef LnP ; typedef wchar ; typedef.

Michael Moroney

unread,
Jan 2, 2017, 10:59:01 PM1/2/17
to
Gee, the code from the forged Relf looks better than the code from
the real Jeff.

Jeff-Relf.Me

unread,
Jan 3, 2017, 3:47:05 AM1/3/17
to
You ( MichaelMoroney ) wrote:
> Gee, the code from the forged Relf looks better than
> the code from the real Jeff.

No one gives a shit about the C++ code I posted,
nor should they, but it helps _me.

Since then, I completely reWrote it, of course;
I'm sure to change it again, as time goes by.

Currently, it's:

// ScreenShot: http://Jeff-Relf.Me/Diff.PNG
// Help/Settings: http://Jeff-Relf.Me/X.HTM

// Peel(), below, peels off diffs from the tops and bottoms
// of LeftOlder and RightNewer text files.
//
// BB is a pointer to the start of a dynamic array of lines ( pointers );
// EE points to the end of the array.
//
// Already, BB and EE point to "diffs" (mismatches lines).
// BB and EE are from the LeftOlder file.
// _BB and _EE are from the RightNewer file.

void Peel( LnA BB, LnA EE, LnA _BB, LnA _EE ) { int rv, S, _S, F, _F ;
LnP t, _t ; LnA BB_Slow, _BB_Slow, BB_Fast, _BB_Fast, EE_Slow, _EE_Slow, EE_Fast
, _EE_Fast, Mid = BB + ( EE - BB )/2, _Mid = _BB + ( _EE - _BB )/2 ;
TopMatch = BtmMatch = 0, BB_Slow = BB, _BB_Slow = _BB ;
EE_Slow = EE, _EE_Slow = _EE, ReSetBB_Fast, ReSetEE_Fast ;

Top: if ( TopMatch ) if ( BtmMatch ) goto Done ; else goto Btm ;
if ( Level = BB_Fast - BB_Slow, TopFlags, TopMatch = !S && !_S ) {

// Done scaning the top of LeftOlder and RightNewer, no matches.
BB_Match = 0 ; goto Btm ; }

if ( F && _S ) if ( !gTopMatch( BB_Fast, EE, _BB_Slow, _EE ) ) BB_Fast++ ; else goto Btm ;
if ( _F && S ) if ( !gTopMatch( BB_Slow, EE, _BB_Fast, _EE ) ) _BB_Fast++ ; else goto Btm ;

// Lower the top of LeftOlder and RightNewer, thus growing a pair of diffs.
if ( TopFlags, !( F && _S || _F && S ) ) BB_Slow += S, _BB_Slow += _S, ReSetBB_Fast ; goto Btm ;

Btm: if ( BtmMatch ) if ( TopMatch ) goto Done ; else goto Top ;
if ( Level = EE_Slow - EE_Fast, BtmFlags, BtmMatch = !S && !_S ) {

// Done scaning the bottom of LeftOlder and RightNewer, no matches.
EE_Match = 0 ; goto Top ; }

if ( F && _S ) if ( !gBtmMatch( EE_Fast, BB, _EE_Slow, _BB ) ) EE_Fast-- ; else goto Top ;
if ( _F && S ) if ( !gBtmMatch( EE_Slow, BB, _EE_Fast, _BB ) ) _EE_Fast-- ; else goto Top ;

// Raise the bottom of LeftOlder and RightNewer, thus growing a pair of diffs.
if ( BtmFlags, !( F && _S || _F && S ) ) EE_Slow -= S, _EE_Slow -= _S, ReSetEE_Fast ; goto Top ;

Done: BB_Match = BB_Match && EE_Match ? BB_Match : EE_Match ? ( _BB_Match = _EE_Match, EE_Match ) : ( _BB_Match = _EE, EE );
EE_Match = BB_Match && EE_Match ? EE_Match : BB_Match ? ( _EE_Match = _BB_Match, BB_Match ) : ( _EE_Match = _BB, BB ); }


Near Globals:

int Level, TopMatch, BtmMatch ; LnP F, _F ;
LnA BBx, EEx, _BBx, _EEx, BB_Match, EE_Match, _BB_Match, _EE_Match ;

#define TokensMatch ( F && _F && F[-1] == _F[-1] && Eq( F, _F ) )
#define ReSetBB_Fast ( BB_Fast = BB_Slow, _BB_Fast = _BB_Slow )
#define ReSetEE_Fast ( EE_Fast = EE_Slow, _EE_Fast = _EE_Slow )

#define MatchDwn ( _MatchDwn( F, PP, EE ), _MatchDwn( _F, _PP, _EE ), TopMatch = TokensMatch )
#define _MatchDwn( P, PP, EE ) ( P = ++PP >= EE ? 0 : *PP )

#define MatchUp ( _MatchUp( F, PP, BB ), _MatchUp( _F, _PP, _BB ), BtmMatch = TokensMatch )
#define _MatchUp( P, PP, BB ) ( P = --PP < BB ? 0 : *PP )

int gTopMatch( LnA PP, LnA EE, LnA _PP, LnA _EE ) { BB_Match = PP, _BB_Match = _PP, PP--, _PP-- ;

// For nearby comparisons, One Match ( not counting blank lines ) is good;
// more matches are needed when "zooming out" hundreds of lines.
Loop( 1 + Level/99 ) eJ += !MatchDwn ? -eJ : !*F ; return TopMatch ; }

int gBtmMatch( LnA PP, LnA BB, LnA _PP, LnA _BB ) { EE_Match = PP, _EE_Match = _PP ;
Loop( 1 + Level/99 ) eJ += !MatchUp ? -eJ : !*F ; return BtmMatch ; }

Pinch( LnA BB, LnA EE, LnA _BB, LnA _EE ) {
LnA PP = BB - 1, _PP = _BB - 1 ; while ( MatchDwn );
BBx = BB = PP, _BBx = _BB = _PP, PP = EE, _PP = _EE ;
while ( MatchUp ); EEx = ++PP, _EEx = ++_PP ; }

#define TopFlags ( S = BB_Slow <= Mid, _S = _BB_Slow <= _Mid, F = BB_Fast <= Mid, _F = _BB_Fast <= _Mid )
#define BtmFlags ( S = EE_Slow >= Mid, _S = _EE_Slow >= _Mid, F = EE_Fast >= Mid, _F = _EE_Fast >= _Mid )

Jeff-Relf.Me

unread,
Jan 3, 2017, 3:52:04 AM1/3/17
to
؛ ɐuן* duן ɟǝpǝdʎʇ ؛ duן* ɹɐɥɔʍ ɟǝpǝdʎʇ ؛ ɹɐɥɔʍ ʇ‾ɹɐɥɔʍ ɟǝpǝdʎʇ

( ɾǝ => ɾ++ ) ǝןıɥʍ ؛ Ɩ- = ɾ 'Ɩ - ( u ) = ɾǝ ʇuı ( u )dooן ǝuıɟǝp#

:sןɐqoןb ɹɐɟ

( pıɯ‾ =< ʇsɐɟ‾ǝǝ‾ = ɟ‾ 'pıɯ =< ʇsɐɟ‾ǝǝ = ɟ 'pıɯ‾ =< ʍoןs‾ǝǝ‾ = s‾ 'pıɯ =< ʍoןs‾ǝǝ = s ) sbɐןɟɯʇq ǝuıɟǝp#
( pıɯ‾ => ʇsɐɟ‾qq‾ = ɟ‾ 'pıɯ => ʇsɐɟ‾qq = ɟ 'pıɯ‾ => ʍoןs‾qq‾ = s‾ 'pıɯ => ʍoןs‾qq = s ) sbɐןɟdoʇ ǝuıɟǝp#

{ ؛ dd‾++ = xǝǝ‾ 'dd++ = xǝǝ ؛( dnɥɔʇɐɯ ) ǝןıɥʍ
؛ ǝǝ‾ = dd‾ 'ǝǝ = dd 'dd‾ = qq‾ = xqq‾ 'dd = qq = xqq
؛( uʍpɥɔʇɐɯ ) ǝןıɥʍ ؛ Ɩ - qq‾ = dd‾ 'Ɩ - qq = dd ɐuן
} ( ǝǝ‾ ɐuן 'qq‾ ɐuן 'ǝǝ ɐuן 'qq ɐuן )ɥɔuıd

{ ؛ ɥɔʇɐɯɯʇq uɹnʇǝɹ ؛ ɟ*¡ : ɾǝ- ¿ dnɥɔʇɐɯ¡ =+ ɾǝ ( 66/ןǝʌǝן + Ɩ )dooן
؛ dd‾ = ɥɔʇɐɯ‾ǝǝ‾ 'dd = ɥɔʇɐɯ‾ǝǝ } ( qq‾ ɐuן 'dd‾ ɐuן 'qq ɐuן 'dd ɐuן )ɥɔʇɐɯɯʇqb ʇuı

{ ؛ ɥɔʇɐɯdoʇ uɹnʇǝɹ ؛ ɟ*¡ : ɾǝ- ¿ uʍpɥɔʇɐɯ¡ =+ ɾǝ ( 66/ןǝʌǝן + Ɩ )dooן
˙sǝuıן ɟo spǝɹpunɥ „ʇno buıɯooz„ uǝɥʍ pǝpǝǝu ǝɹɐ sǝɥɔʇɐɯ ǝɹoɯ //
؛poob sı ( sǝuıן ʞuɐןq buıʇunoɔ ʇou ) ɥɔʇɐɯ ǝuo 'suosıɹɐdɯoɔ ʎqɹɐǝu ɹoɟ //

؛ --dd‾ '--dd 'dd‾ = ɥɔʇɐɯ‾qq‾ 'dd = ɥɔʇɐɯ‾qq } ( ǝǝ‾ ɐuן 'dd‾ ɐuן 'ǝǝ ɐuן 'dd ɐuן )ɥɔʇɐɯdoʇb ʇuı

( dd* : 0 ¿ qq > dd-- = d ) ( qq 'dd 'd )dnɥɔʇɐɯ‾ ǝuıɟǝp#
( ɥɔʇɐɯsuǝʞoʇ = ɥɔʇɐɯɯʇq '( qq‾ 'dd‾ 'ɟ‾ )dnɥɔʇɐɯ‾ '( qq 'dd 'ɟ )dnɥɔʇɐɯ‾ ) dnɥɔʇɐɯ ǝuıɟǝp#

( dd* : 0 ¿ ǝǝ =< dd++ = d ) ( ǝǝ 'dd 'd )uʍpɥɔʇɐɯ‾ ǝuıɟǝp#
( ɥɔʇɐɯsuǝʞoʇ = ɥɔʇɐɯdoʇ '( ǝǝ‾ 'dd‾ 'ɟ‾ )uʍpɥɔʇɐɯ‾ '( ǝǝ 'dd 'ɟ )uʍpɥɔʇɐɯ‾ ) uʍpɥɔʇɐɯ ǝuıɟǝp#

( ʍoןs‾ǝǝ‾ = ʇsɐɟ‾ǝǝ‾ 'ʍoןs‾ǝǝ = ʇsɐɟ‾ǝǝ ) ʇsɐɟ‾ǝǝʇǝsǝɹ ǝuıɟǝp#
( ʍoןs‾qq‾ = ʇsɐɟ‾qq‾ 'ʍoןs‾qq = ʇsɐɟ‾qq ) ʇsɐɟ‾qqʇǝsǝɹ ǝuıɟǝp#
( ( ɟ‾ 'ɟ )bǝ && [Ɩ-]ɟ‾ == [Ɩ-]ɟ && ɟ‾ && ɟ ) ɥɔʇɐɯsuǝʞoʇ ǝuıɟǝp#

؛ ɥɔʇɐɯ‾ǝǝ‾ 'ɥɔʇɐɯ‾qq‾ 'ɥɔʇɐɯ‾ǝǝ 'ɥɔʇɐɯ‾qq 'xǝǝ‾ 'xqq‾ 'xǝǝ 'xqq ɐuן
؛ ɟ‾ 'ɟ duן ؛ ɥɔʇɐɯɯʇq 'ɥɔʇɐɯdoʇ 'ןǝʌǝן ʇuı

:sןɐqoןb ɹɐǝu


{ ؛( qq 'qq‾ = ɥɔʇɐɯ‾ǝǝ‾ ) : ( ɥɔʇɐɯ‾qq 'ɥɔʇɐɯ‾qq‾ = ɥɔʇɐɯ‾ǝǝ‾ ) ¿ ɥɔʇɐɯ‾qq : ɥɔʇɐɯ‾ǝǝ ¿ ɥɔʇɐɯ‾ǝǝ && ɥɔʇɐɯ‾qq = ɥɔʇɐɯ‾ǝǝ
؛( ǝǝ 'ǝǝ‾ = ɥɔʇɐɯ‾qq‾ ) : ( ɥɔʇɐɯ‾ǝǝ 'ɥɔʇɐɯ‾ǝǝ‾ = ɥɔʇɐɯ‾qq‾ ) ¿ ɥɔʇɐɯ‾ǝǝ : ɥɔʇɐɯ‾qq ¿ ɥɔʇɐɯ‾ǝǝ && ɥɔʇɐɯ‾qq = ɥɔʇɐɯ‾qq :ǝuop

؛ doʇ oʇob ؛ ʇsɐɟ‾ǝǝʇǝsǝɹ 's‾ =- ʍoןs‾ǝǝ‾ 's =- ʍoןs‾ǝǝ ( ( s && ɟ‾ || s‾ && ɟ )¡ 'sbɐןɟɯʇq ) ɟı
˙sɟɟıp ɟo ɹıɐd ɐ buıʍoɹb snɥʇ 'ɹǝʍǝuʇɥbıɹ puɐ ɹǝpןoʇɟǝן ɟo ɯoʇʇoq ǝɥʇ ǝsıɐɹ //

؛ doʇ oʇob ǝsןǝ ؛ --ʇsɐɟ‾ǝǝ‾ ( ( qq‾ 'ʇsɐɟ‾ǝǝ‾ 'qq 'ʍoןs‾ǝǝ )ɥɔʇɐɯɯʇqb¡ ) ɟı ( s && ɟ‾ ) ɟı
؛ doʇ oʇob ǝsןǝ ؛ --ʇsɐɟ‾ǝǝ ( ( qq‾ 'ʍoןs‾ǝǝ‾ 'qq 'ʇsɐɟ‾ǝǝ )ɥɔʇɐɯɯʇqb¡ ) ɟı ( s‾ && ɟ ) ɟı

{ ؛ doʇ oʇob ؛ 0 = ɥɔʇɐɯ‾ǝǝ
˙sǝɥɔʇɐɯ ou 'ɹǝʍǝuʇɥbıɹ puɐ ɹǝpןoʇɟǝן ɟo ɯoʇʇoq ǝɥʇ buıuɐɔs ǝuop //

} ( s‾¡ && s¡ = ɥɔʇɐɯɯʇq 'sbɐןɟɯʇq 'ʇsɐɟ‾ǝǝ - ʍoןs‾ǝǝ = ןǝʌǝן ) ɟı
؛ doʇ oʇob ǝsןǝ ؛ ǝuop oʇob ( ɥɔʇɐɯdoʇ ) ɟı ( ɥɔʇɐɯɯʇq ) ɟı :ɯʇq

؛ ɯʇq oʇob ؛ ʇsɐɟ‾qqʇǝsǝɹ 's‾ =+ ʍoןs‾qq‾ 's =+ ʍoןs‾qq ( ( s && ɟ‾ || s‾ && ɟ )¡ 'sbɐןɟdoʇ ) ɟı
˙sɟɟıp ɟo ɹıɐd ɐ buıʍoɹb snɥʇ 'ɹǝʍǝuʇɥbıɹ puɐ ɹǝpןoʇɟǝן ɟo doʇ ǝɥʇ ɹǝʍoן //

؛ ɯʇq oʇob ǝsןǝ ؛ ++ʇsɐɟ‾qq‾ ( ( ǝǝ‾ 'ʇsɐɟ‾qq‾ 'ǝǝ 'ʍoןs‾qq )ɥɔʇɐɯdoʇb¡ ) ɟı ( s && ɟ‾ ) ɟı
؛ ɯʇq oʇob ǝsןǝ ؛ ++ʇsɐɟ‾qq ( ( ǝǝ‾ 'ʍoןs‾qq‾ 'ǝǝ 'ʇsɐɟ‾qq )ɥɔʇɐɯdoʇb¡ ) ɟı ( s‾ && ɟ ) ɟı

{ ؛ ɯʇq oʇob ؛ 0 = ɥɔʇɐɯ‾qq
˙sǝɥɔʇɐɯ ou 'ɹǝʍǝuʇɥbıɹ puɐ ɹǝpןoʇɟǝן ɟo doʇ ǝɥʇ buıuɐɔs ǝuop //

} ( s‾¡ && s¡ = ɥɔʇɐɯdoʇ 'sbɐןɟdoʇ 'ʍoןs‾qq - ʇsɐɟ‾qq = ןǝʌǝן ) ɟı
؛ ɯʇq oʇob ǝsןǝ ؛ ǝuop oʇob ( ɥɔʇɐɯɯʇq ) ɟı ( ɥɔʇɐɯdoʇ ) ɟı :doʇ

؛ ʇsɐɟ‾ǝǝʇǝsǝɹ 'ʇsɐɟ‾qqʇǝsǝɹ 'ǝǝ‾ = ʍoןs‾ǝǝ‾ 'ǝǝ = ʍoןs‾ǝǝ
؛ qq‾ = ʍoןs‾qq‾ 'qq = ʍoןs‾qq '0 = ɥɔʇɐɯɯʇq = ɥɔʇɐɯdoʇ
؛ ᄅ/( qq‾ - ǝǝ‾ ) + qq‾ = pıɯ‾ 'ᄅ/( qq - ǝǝ ) + qq = pıɯ 'ʇsɐɟ‾ǝǝ‾ '
ʇsɐɟ‾ǝǝ 'ʍoןs‾ǝǝ‾ 'ʍoןs‾ǝǝ 'ʇsɐɟ‾qq‾ 'ʇsɐɟ‾qq 'ʍoןs‾qq‾ 'ʍoןs‾qq ɐuן ؛ ʇ‾ 'ʇ duן
؛ ɟ‾ 'ɟ 's‾ 's 'ʌɹ ʇuı } ( ǝǝ‾ ɐuן 'qq‾ ɐuן 'ǝǝ ɐuן 'qq ɐuן )ןǝǝd pıoʌ

˙ǝןıɟ ɹǝʍǝuʇɥbıɹ ǝɥʇ ɯoɹɟ ǝɹɐ ǝǝ‾ puɐ qq‾ //
˙ǝןıɟ ɹǝpןoʇɟǝן ǝɥʇ ɯoɹɟ ǝɹɐ ǝǝ puɐ qq //
˙(sǝuıן sǝɥɔʇɐɯsıɯ) „sɟɟıp„ oʇ ʇuıod ǝǝ puɐ qq 'ʎpɐǝɹןɐ //
//
˙ʎɐɹɹɐ ǝɥʇ ɟo puǝ ǝɥʇ oʇ sʇuıod ǝǝ //
؛( sɹǝʇuıod ) sǝuıן ɟo ʎɐɹɹɐ ɔıɯɐuʎp ɐ ɟo ʇɹɐʇs ǝɥʇ oʇ ɹǝʇuıod ɐ sı qq //
//
˙sǝןıɟ ʇxǝʇ ɹǝʍǝuʇɥbıɹ puɐ ɹǝpןoʇɟǝן ɟo //
sɯoʇʇoq puɐ sdoʇ ǝɥʇ ɯoɹɟ sɟɟıp ɟɟo sןǝǝd 'ʍoןǝq '()ןǝǝd //

ɯʇɥ˙x/ǝɯ˙ɟןǝɹ-ɟɟǝɾ//:dʇʇɥ :sbuıʇʇǝs/dןǝɥ //
bud˙ɟɟıp/ǝɯ˙ɟןǝɹ-ɟɟǝɾ//:dʇʇɥ :ʇoɥsuǝǝɹɔs //

:s,ʇı 'ʎןʇuǝɹɹnɔ

˙ʎq sǝob ǝɯıʇ sɐ 'uıɐbɐ ʇı ǝbuɐɥɔ oʇ ǝɹns ɯ,ı
؛ǝsɹnoɔ ɟo 'ʇı ǝʇoɹʍǝɹ ʎןǝʇǝןdɯoɔ ı 'uǝɥʇ ǝɔuıs

˙ǝɯ‾ sdןǝɥ ʇı ʇnq 'ʎǝɥʇ pןnoɥs ɹou
'pǝʇsod ı ǝpoɔ ++ɔ ǝɥʇ ʇnoqɐ ʇıɥs ɐ sǝʌıb ǝuo ou

˙ɟɟǝɾ ןɐǝɹ ǝɥʇ ɯoɹɟ ǝpoɔ ǝɥʇ <
uɐɥʇ ɹǝʇʇǝq sʞooן ɟןǝɹ pǝbɹoɟ ǝɥʇ ɯoɹɟ ǝpoɔ ǝɥʇ 'ǝǝb <
:ǝʇoɹʍ ( ʎǝuoɹoɯןǝɐɥɔıɯ ) noʎ

Jeff-Relf.Me

unread,
Jan 3, 2017, 6:04:21 AM1/3/17
to
My diff routine (posted) produces the "Least Longest" diffs;
and I can explain the algorithm in detail.

There are 4 pairs of pointers scaning from top to bottom
and bottom to top, meeting in the middle;
each pair notes the begging and end of a diff pair.

The LeftOlder text file scans the RightNewer file,
and vice versa, in lock step, all advancing at the same rate.

For nearby comparisons, One Match ( not counting blank lines ) is best;
more matches are needed when "zooming out" hundreds of lines;
otherwise, one might get an excessively large diff based on a bad match.

Peter Köhlmann

unread,
Jan 3, 2017, 6:13:51 AM1/3/17
to
The worst "programmer" of all time babbled:
Ye gods!

Melzzzzz

unread,
Jan 3, 2017, 6:29:00 AM1/3/17
to
I think that he is insane...

--
press any key to continue or any other to quit...

chrisv

unread,
Jan 3, 2017, 8:32:31 AM1/3/17
to
Peter Köhlmann wrote:

> The worst "programmer" of all time babbled:
>>
If "Ezekiel" was here, and you said that the above code was crap, he
would demand "facts and a code analysis". LOL

The kreep even claimed that it was "ignorant" to say that Relf's
statements eschewing the importance of compliler warnings were
"stupid".

I couldn't make this stuff up!

Ezekreep was a trolling fsckwit, if ever there was one. Apparently,
he thought that he could beat us with his lies.

--
"For some reason the mindless droids here equate anything open source
with somehow being technically superior." - trolling fsckwit
"Ezekiel", lying shamelessly

GreyCloud

unread,
Jan 3, 2017, 2:16:15 PM1/3/17
to
He doesn't work for anybody needing code. That much is certain.
Otherwise, he'd have been fired.

GreyCloud

unread,
Jan 3, 2017, 2:16:49 PM1/3/17
to
>>> if ( Level = BB_Fast - BB_Slow, TopFlags, TopMatch = !S&& !_S

red floyd

unread,
Jan 3, 2017, 3:30:43 PM1/3/17
to
Indeed. That code is full of constructs that exhibit UB. Any
identifier with a leading underscore followed by an uppercase
letter is reserved to the implementation, and the use of such
identifiers is undefined.

Jeff-Relf.Me

unread,
Jan 3, 2017, 4:00:25 PM1/3/17
to
You two ( ChrisV and Peter Köhlmann ) keep telling us:

Turn on _all warnings; all else is _foolish/_noobish.

With "warnings as errors", turn off these warnings:

C4100: unreferenced parameter.
C4101: unreferenced local variable.
C4189: local variable is initialized but not referenced.

Variables gets comment out, at times, when debugging.
UnUsed code is informative, and might be needed again.

Other C++ Coding Rules:

http://Jeff-Relf.Me/C++CodingRules.HTM

Vir Campestris

unread,
Jan 3, 2017, 4:27:20 PM1/3/17
to
On 03/01/2017 03:58, Michael Moroney wrote:
> Gee, the code from the forged Relf looks better than the code from
> the real Jeff.
>
FFS - HE's got a stalker???

Jeff-Relf.Me

unread,
Jan 3, 2017, 5:31:10 PM1/3/17
to
You ( Vir Campestris ) replied ( to Michael Moroney ):
> > Gee, the code from the forged Relf looks better than
> > the code from the real Jeff.
> 
> FFS - HE's got a stalker???

I have an AntiFanBoy, from time to time.

Scott Lurndal

unread,
Jan 4, 2017, 8:34:00 AM1/4/17
to
I dunno - I've seen similar code in shipping products:

For example (Product: ADSINP, language: BPL circa 1977):

DEFINE flip (x) = x := x NOT 1#, &FLIP 0/1 00223000
inc (a,b,c,d,e,f,g,h,i,j,k) = 00224000
a := a + IFF (b,b,1) 00225000
IFF (c,+c) IFF (d,+d) IFF (e,+e) IFF (f,+f) IFF (g,+g) 00226000
IFF (h,+h) IFF (i,+i) IFF (j,+j) IFF (k,+k)#, 00227000
dinc (a,b) = inc (a,b,b)#, 00228000
dec (a,b,c,d,e,f,g,h,i,j,k) = 00229000
a := a - IFF (b,b,1) 00230000
IFF (c,-c) IFF (d,-d) IFF (e,-e) IFF (f,-f) IFF (g,-g) 00231000
IFF (h,-h) IFF (i,-i) IFF (j,-j) IFF (k,-k)#, 00232000
ddec (a,b) = dec (a,b,b)#, 00233000

or

@PAGE&******************************************************************00136700
&***********************************************************************00136800
PROCEDURE.CONVERT_DATE; 00136900
BEGIN 00137000
OWN INTEGER DAYS_TO_DATE (65) := 00137100
36699335123051127410244092130818207152061210509104060030310200001; 00137200
INTEGER TRASH (4),LOCAL_JULIAN_DATE(5); 00137300
00137400
LOCAL_JULIAN_DATE := THE_JULIAN_DATE; 00137500
GREGORIAN_DATE.2.+6 := LOCAL_JULIAN_DATE.2; 00137600
IF LOCAL_JULIAN_DATE.3.+2 GEQ 60 THEN 00137700
BEGIN 00137800
TRASH := LOCAL_JULIAN_DATE.2 * 25; 00137900
IF TRASH.2.+2 NEQ 0 THEN 00138000
LOCAL_JULIAN_DATE := LOCAL_JULIAN_DATE + 1; 00138100
END; 00138200
SEARCH LOW DAYS_TO_DATE.3 THRU DAYS_TO_DATE.+65 00138300
FOR LOCAL_JULIAN_DATE.3.+2 INCREMENT 5; 00138400
GREGORIAN_DATE.2 := BASE.2.+3.IX1; 00138500
GREGORIAN_DATE.2.+3.NM := LOCAL_JULIAN_DATE.3.+2 - BASE.3.IX1; 00138600
END; & CONVERT_DATE 00138700

chrisv

unread,
Jan 4, 2017, 8:45:28 AM1/4/17
to
Scott Lurndal wrote:

> some POS that calls itself "GreyCloud" wrote:
>>
>>He doesn't work for anybody needing code. That much is certain.
>>Otherwise, he'd have been fired.
>
>I dunno - I've seen similar code in shipping products:
>
>For example (Product: ADSINP, language: BPL circa 1977):

I suppose that there are some clueless managers who are "impressed" by
impenetrable code.

--
"Or could it be that some ISPs are using the shitty linux servers that
draws in viruses and malware? LOL!!!" - some POS that calls itself
"GreyCloud"

Scott Lurndal

unread,
Jan 4, 2017, 9:54:53 AM1/4/17
to
chrisv <chr...@nospam.invalid> writes:
>Scott Lurndal wrote:
>
>> some POS that calls itself "GreyCloud" wrote:
>>>
>>>He doesn't work for anybody needing code. That much is certain.
>>>Otherwise, he'd have been fired.
>>
>>I dunno - I've seen similar code in shipping products:
>>
>>For example (Product: ADSINP, language: BPL circa 1977):
>
>I suppose that there are some clueless managers who are "impressed" by
>impenetrable code.

to be fair, in the 1970's, there were limits on pretty
much everything, including number of lines that a compiler could
handle in a reasonable amount of time given memory constraints.

Compact (dense) code was more the rule than the exception in those
days.

Jeff-Relf.Me

unread,
Jan 4, 2017, 1:18:13 PM1/4/17
to
You ( Scott Lurndal ) replied:
> > > > He doesn't work for anybody needing code.
> > > > That much is certain. Otherwise, he'd have been fired.
> > >
> > > I dunno - I've seen similar code in shipping products:
> > > For example (Product: ADSINP, language: BPL circa 1977):
> >
> > I suppose that there are some clueless managers
> > who are "impressed" by impenetrable code.
>
> to be fair, in the 1970's, there were limits on pretty
> much everything, including number of lines that a compiler could
> handle in a reasonable amount of time given memory constraints.
>
> Compact (dense) code was more the rule
> than the exception in those days.

My C++ is dense, 236 columns wide, and I'm running:

Core i7-5775c, TeraBye SSD, 16 gigs of 1.9 gigaHz RAM,
and an ArmMounted 4k UHD IPS monitor.

When I see sparse code, with lots of whitespace and comments,
I _immediately know the programmer is struggling.

P.S. Another day, another rewrite.
All the code that I posted here has been _trashed already.

Today, when I find the time, I plan on using
the Longest Common Sequence ( NonContiguous ) algorithm ( recursive ); like:

LCS( "ABCDE", "AEBDF" ) = Max( LCS( "ABCD", "AEBDF" ), LCS( "AEBD", "ABCDE" ) )
LCS( "ABCD", "AEBD" ) = 1 + LCS( "ABC", "AEB" )

Peter Köhlmann

unread,
Jan 4, 2017, 1:19:55 PM1/4/17
to
wrote:
Idiot

Michael Moroney

unread,
Jan 4, 2017, 10:34:46 PM1/4/17
to
Jeff-Relf.Me <@.> writes:

>All the code that I posted here has been _trashed already.

Yay! Relfie did something right for once!
It is loading more messages.
0 new messages