Friday, March 31, 2017

Digest for comp.lang.c++@googlegroups.com - 5 updates in 4 topics

Jorgen Grahn <grahn+nntp@snipabacken.se>: Mar 31 06:32PM

On Thu, 2017-03-30, Richard wrote:
 
>>> That sounds to me like you haven't tried to do what you suggest
 
>>What do I suggest?
 
> Do you not even know what you posted or can't read it above?
 
(I don't think you mean "copying the source code", since we have tools
like rsync to do that quickly these days.)
 
I suggested using a Makefile, but if you insinuate that I haven't
tried that, that's trivially false. Of course I have tried it; I use
make for all my projects. I've also used it to speed up and clarify
other projects' build processses, too. I remember speeding up one
build from 20 minutes to around twelve seconds.
 
I'm active looking for valid, technical reasons to use something else,
but haven't found any so far. Modulo the "I'm not Linus" bit;
projects like the Linux kernel definitely need something else.
 
/Jorgen
 
--
// Jorgen Grahn <grahn@ Oo o. . .
\X/ snipabacken.se> O o .
woodbrian77@gmail.com: Mar 31 03:52PM -0700

On Friday, March 31, 2017 at 1:33:02 PM UTC-5, Jorgen Grahn wrote:
 
> I'm active looking for valid, technical reasons to use something else,
> but haven't found any so far. Modulo the "I'm not Linus" bit;
> projects like the Linux kernel definitely need something else.
 
Make works reasonably well for me now that I've put more
work into it. It's kind of a pain to have one makefile
for BSD/Linux/etc and another for Windows, but I've put
up with that for years.
 
My build takes around 14 seconds on my laptop and that's
doing a
 
make all example
 
I'm not sure if it would be better to include the example
target in all or leave it separate.
 
 
Brian
Ebenezer Enterprises
http://webEbenezer.net
"Chris M. Thomasson" <invalid@invalid.invalid>: Mar 30 10:50PM -0700

On 3/25/2017 8:29 AM, fir wrote:
 
>>> This is why i am not seeking at discussing C++ with you on this forum.
 
>> Why are you here?
 
> ramine idiot is here to spam - to make advertisments of his idiot state to everybody
 
Damn.
Jeff-Relf.Me @.: Mar 30 08:21PM -0700

bitrex <bitrex@de.lete.earthlink.net>: Mar 30 08:46PM -0400

On 03/30/2017 09:49 AM, bitrex wrote:
> struct is placed in it via placement new. Then another class wraps that,
> and using the CRTP ensures that each child class has its own copy of the
> buffer (rather than one being shared among all the subclasses.)
 
<snip>
 
Disregard, this code's all wrong.
 
Lemme get back to you...
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:

Thursday, March 30, 2017

Digest for comp.lang.c++@googlegroups.com - 2 updates in 2 topics

legalize+jeeves@mail.xmission.com (Richard): Mar 30 11:20PM

[Please do not mail me a copy of your followup]
 
Jorgen Grahn <grahn+nntp@snipabacken.se> spake the secret code
>>>to build, and building it there, is very small today.
 
>> That sounds to me like you haven't tried to do what you suggest
 
>What do I suggest?
 
Do you not even know what you posted or can't read it above?
 
 
--
"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>
red floyd <dont.bother@its.invalid>: Mar 30 03:19PM -0700

On 3/30/2017 1:49 PM, Vir Campestris wrote:
 
> packed array of items of any (small) number of bits. Handy when you want
> to address a display with 8 greys per pixel. And yes, we did program
> that one in C!
 
The TI processor was the TMS340x0 series. I had the "pleasure" of
coding for the both the 34010 and 34020.
 
TI's graphics library had a bug when compiled at full optimization. A
memory mapped register was not declared "volatile", so the compiler
would optimize out the read on a spin loop, and hang if the condition
was not met on initial loop.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:

Digest for comp.lang.c++@googlegroups.com - 25 updates in 8 topics

Vir Campestris <vir.campestris@invalid.invalid>: Mar 30 09:59PM +0100

On 20/03/2017 07:40, Juha Nieminen wrote:
 
> If you think you can, then prove it. Give me a function that will take
> a linked list and a value, and will insert the value in the middle of
> the list inexpensively.
 
The insertion is cheap. It's finding the place that's expensive.
 
Andy
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Mar 30 02:09PM -0700

On Thursday, March 30, 2017 at 4:59:20 PM UTC-4, Vir Campestris wrote:
> > a linked list and a value, and will insert the value in the middle of
> > the list inexpensively.
 
> The insertion is cheap. It's finding the place that's expensive.
 
Potentially. Link lists are not ideal in every situation, but if you
are tracking through data and have anchors where you know where things
need to be inserted, then it is very nice.
 
It also makes parsing things easy. By creating a component link list,
and then processing through the components, you can translating, re-
arrange, delete, inject, as needed.
 
Thank you,
Rick C. Hodgin
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 30 02:58AM +0200

On 29-Mar-17 11:00 PM, Mr Flibble wrote:
> Linux uses UTF-8 for filenames
 
If so then Linux has diverged in an incompatible way from Unix mainstream.
 
Of old a Unix filename was just a sequence of bytes with no interpretation.
 
In particular, uppercasing or lowercasing a name was meaningless.
 
 
Cheers!,
 
- Alf
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 30 03:02AM +0200

On 30-Mar-17 2:58 AM, Alf P. Steinbach wrote:
 
> If so then Linux has diverged in an incompatible way from Unix mainstream.
 
> Of old a Unix filename was just a sequence of bytes with no interpretation.
 
> In particular, uppercasing or lowercasing a name was meaningless.
 
And, sorry, I was half asleep, a Unix filename could be invalid as UTF-8.
 
 
Cheers!,
 
- Alf
Daniel <danielaparker@gmail.com>: Mar 29 07:24PM -0700

On Wednesday, March 29, 2017 at 8:58:29 PM UTC-4, Alf P. Steinbach wrote:
> > Linux uses UTF-8 for filenames
 
> If so then Linux has diverged in an incompatible way from Unix mainstream.
 
> Of old a Unix filename was just a sequence of bytes with no interpretation.
 
Any sequence of bytes except for the forward slash / or the NUL byte. That
applies to Linux too. UTF-8 encoded filenames are fine, but so are filenames
in any other encoding. As a practical matter, though, some applications
may have difficulty with some encodings. I think it's fair to say that it's
considered best practice in Linux to use UTF-8 encoded filenames.
 
Daniel
Daniel <danielaparker@gmail.com>: Mar 29 08:46PM -0700

On Wednesday, March 29, 2017 at 5:00:48 PM UTC-4, Mr Flibble wrote:
> represented by a single scalar type are just as useless as variable
> length UTF-8 encoded codepoints as far as wanting an atomic "character"
> is concerned
 
I don't understand your point. Given a std::string that contains UTF-8
encoded bytes, some operations can be performed on that std::string without
iterating over the codepoints (or equivalently the UTF-8 character
sequences), for instance, compare equal with another UTF-8 encoded string.
But others cannot, for example, none of the std::string find operations will
work. I suppose you could specialize char_traits in basic_string with a
unicode version, but that leads to other issues.
 
 
> I strongly disagree with your assertion that UTF-8 should only be used
> during "serialization"
 
I never asserted that. My own view is that UTF-8 is probably the preferred
string _buffer_ encoding. wstring has been 32 bit on UNIX for a very long
time, and never gained any significant adoption in applications that have had
to support Unicode. I can't see u32string doing any better.
 
> and that an application should be unaware of it
 
I do believe that :-)
 
Most modern languages have one string class with a standard string interface,
not string, wstring, u16string, u32string, whole bunch of basic_string
possibilities with different character types, char_traits, allocators.
Instead of embuing encoding information in the type, they have an internal
type, and functions getBytes(encoding), toBytes(encoding) to convert the
internal representation from/to one of many possible external encoded types.
There's enough prior experience now to suggest that that's the right
approach.
 
Daniel
Robert Wessel <robertwessel2@yahoo.com>: Mar 30 01:13AM -0500


>http://stackoverflow.com/a/6972551/597607
 
>the 2200 series even had a C++ compiler. Or at least an eye-witness
>claims to have once seen the manual on-line. :-)
 
 
http://public.support.unisys.com/2200/docs/cp14.0/pdf/78310422-011.pdf
https://public.support.unisys.com/2200/docs/cp15.0/pdf/78310430-016.pdf
David Brown <david.brown@hesbynett.no>: Mar 30 10:00AM +0200

On 30/03/17 02:58, Alf P. Steinbach wrote:
> On 29-Mar-17 11:00 PM, Mr Flibble wrote:
>> Linux uses UTF-8 for filenames
 
> If so then Linux has diverged in an incompatible way from Unix mainstream.
 
It has not - Mr. Flibble is wrong. Like all *nix systems, Linux
filenames are a sequence of 8-bit characters terminated in \0. The only
characters disallowed in the names are / (reserved for directories) and
\0 (the terminator).
 
It is up to the shell, file manager, desktop, etc., to interpret the
filenames in any it wants. In the early days, ASCII was the common
interpretation. Then people started using 8-bit code pages for
different locales, before UTF-8 became dominant.
 
In modern systems, UTF-8 is by far the most common encoding (with the
huge majority of file names matching the ASCII encoding), but it is not
required by the native filesystems or the OS.
 
Some non-native filesystems, such as NTFS and VFAT, /do/ have
requirements on character encoding (such as UCS-2 / UTF-16 / whatever
half-made jumble MS picked for that particular version of the
filesystem), and Linux will of course follow the rules there.
 
David Brown <david.brown@hesbynett.no>: Mar 30 10:05AM +0200

On 30/03/17 05:46, Daniel wrote:
> But others cannot, for example, none of the std::string find operations will
> work. I suppose you could specialize char_traits in basic_string with a
> unicode version, but that leads to other issues.
 
Why won't "find" work with UTF-8 strings? UTF-8 is self-synchronising -
if you search for one UTF-8 string inside another, matches done as
Unicode code points will be the same as matches done as raw 8-bit data.
David Brown <david.brown@hesbynett.no>: Mar 30 10:06AM +0200

On 29/03/17 17:08, Scott Lurndal wrote:
>> can, of course, provide smaller divisions - but they are not "bytes" in
>> C parlance.
 
> Yes, the 48-bit systems have six 8-bit bytes.
 
Sorry - I misread your post as saying that 48-bit words were decomposed
into "6-bit bytes", not "6 bytes".
Bo Persson <bop@gmb.dk>: Mar 30 10:57AM +0200

On 2017-03-30 08:13, Robert Wessel wrote:
>> claims to have once seen the manual on-line. :-)
 
> http://public.support.unisys.com/2200/docs/cp14.0/pdf/78310422-011.pdf
> https://public.support.unisys.com/2200/docs/cp15.0/pdf/78310430-016.pdf
 
Oh, thanks! :-)
 
 
 
Bo Persson
Daniel <danielaparker@gmail.com>: Mar 30 05:30AM -0700

On Thursday, March 30, 2017 at 4:05:22 AM UTC-4, David Brown wrote:
 
> Why won't "find" work with UTF-8 strings? UTF-8 is self-synchronising -
> if you search for one UTF-8 string inside another, matches done as
> Unicode code points will be the same as matches done as raw 8-bit data.dd
 
Good point. I hadn't thought of that, thanks.
 
Daniel
David Brown <david.brown@hesbynett.no>: Mar 30 04:10PM +0200

On 30/03/17 14:30, Daniel wrote:
>> if you search for one UTF-8 string inside another, matches done as
>> Unicode code points will be the same as matches done as raw 8-bit data.dd
 
> Good point. I hadn't thought of that, thanks.
 
And I thought it was I who had missed something here.
 
The self-synchronising aspect of UTF-8 was a key design point, and I
think the ability to find substrings was a major reason for having it.
Vir Campestris <vir.campestris@invalid.invalid>: Mar 30 09:49PM +0100

On 29/03/2017 13:54, Scott Lurndal wrote:
> four would be packed into a 36-bit word). On 48-bit systems[**], a word
> can be decomposed into 6 bytes using various instructions, but individual
> byte access to memory isn't supported.
 
_Was_ is the operative word. I first learned assembly on a DECSystem10.
The 36 bit words normally contained 5 7-bit characters, with a spare
bit. There was no byte access. I've also used ICL1900s (24 bit word, 4x6
bit characters) and a weird TI graphics processor where you could have a
packed array of items of any (small) number of bits. Handy when you want
to address a display with 8 greys per pixel. And yes, we did program
that one in C!
 
But this was all a long time ago...
 
Andy
Jeff-Relf.Me @.: Mar 30 01:07PM -0700

Manfred <invalid@invalid.add>: Mar 30 12:24AM +0200


> I'm wondering if there are things with my Windows makefile
> that could be improved on:
 
> https://bitbucket.org/webenezer/onwards/src/7a925499bdaa2ce53df5401f255b2db9d6100bf0/makefile.windows?at=master&fileviewer=file-view-default
 
quicklz.obj: quicklz.h
$(CC) $(CFLAGS) -c quicklz.c
 
marshalling_integer.obj: marshalling_integer.hh
$(CC) $(CFLAGS) -c marshalling_integer.cc
 
The above should indicate the .c and .cc sources as dependencies
Jorgen Grahn <grahn+nntp@snipabacken.se>: Mar 30 07:08PM

On Wed, 2017-03-29, Richard wrote:
 
>>Perhaps, but the cost of copying the source code to whereever you want
>>to build, and building it there, is very small today.
 
> That sounds to me like you haven't tried to do what you suggest
 
What do I suggest?
 
> with any sizeable distribution or with any project that has a mildly
> complex build.
 
For the size, Make scales really well. One more source file, one more
line in the Makefile. (If you write decent Makefiles, which I do.)
 
For complexity, almost no systems have a complex build these days --
except when the build system itself is the source of complexity.
 
> In those situations where I've attempted to do what you suggest, it
> was significantly more painful than just running CMake. CMake
> supports this trivially out-of-the-box using the same source tree.
 
I don't quite understand. For someone else's project, you build with
whatever they offer. If that project uses CMake, you build using
CMake. (For me, it's usually a .configure script.)
 
If it was my project, I'd probably choose a plain Makefile.
 
Granted, there /are/ exceptions. Like the Linux kernel, where extreme
configurability is a must. Plain Make would not work there -- there's
no fixed dependency graph. But I'm not Linus, and I don't run any
projects like that. I won't place that kind of cost on a project
which doesn't need it, just because some /other/ project does.
 
/Jorgen
 
--
// Jorgen Grahn <grahn@ Oo o. . .
\X/ snipabacken.se> O o .
Lynn McGuire <lynnmcguire5@gmail.com>: Mar 30 12:20PM -0500

On 3/26/2017 3:30 PM, Stefan Ram wrote:
> "Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com> writes:
...
> called »C++19/20« by some now).
 
> Of course with regard to a graphical output or a GUI, there does
> not even seem to be a TS in sight.
 
What is a TS ?
 
Thanks,
Lynn
scott@slp53.sl.home (Scott Lurndal): Mar 30 05:29PM


>> Of course with regard to a graphical output or a GUI, there does
>> not even seem to be a TS in sight.
 
>What is a TS ?
 
First hit on google "C++ TS" gives the answer.
bitrex <bitrex@de.lete.earthlink.net>: Mar 30 09:49AM -0400

Suppose I have a structure like this, where a wrapper class for a POD
struct has a static memory buffer, and on construction a copy of the POD
struct is placed in it via placement new. Then another class wraps that,
and using the CRTP ensures that each child class has its own copy of the
buffer (rather than one being shared among all the subclasses.)
 
And suppose I have a "constexpr" function that creates a constant vector
or array of these objects at runtime, initialized with the default
constructor. The classes inside just sit around holding their static
buffer and a nullptr.
 
And then I create a stack data structure holding pointers to those
objects. What I'd like to be able to do is pop a pointer off the stack,
dereference it, and assign it such that the operation constructs a new
wrapper holding my POD data "in place" in the vector/array of originally
default-initialized objects.
 
I was thinking "PODWrapper" could also hold a reference to the stack, so
that the destructor would push its own "this" pointer back on it when
the wrapper went out of scope.
 
I'm not sure the best way to write the copy constructors for the
following two classes such that dereferencing and assignment for this
type of class is possible, though, without ending up with memcpys that
try to use the same source and destination argument.
 
#include <cstring>
 
struct POD
{
int a;
int b;
int c;
};
 
template <template <typename> class Derived,
typename T>
struct PODHolder
{
virtual ~PODHolder() {}
 
operator T() const { return *pod_ptr_; }
T* operator&() const { return pod_ptr_; }
T* operator&(const PODHolder& other) const { return pod_ptr_; }
 
protected:
PODHolder() = default;
 
PODHolder(const T& pod) :
pod_ptr_(new (_pod_buf()) T(pod))
{}
 
PODHolder(const T* pod) : pod_ptr_(_pod_buf())
{
std::memcpy(pod_ptr_, pod, sizeof(T));
}
 
private:
static char* _pod_buf()
{
static auto buf = new char[sizeof(T)];
return &buf[0];
}
 
T *const pod_ptr_ = nullptr;
};
 
template <typename T>
struct PODWrapper : public PODHolder<PODWrapper, T>
{
PODWrapper() = default;
 
PODWrapper(const T& pod) :
PODHolder<PODWrapper,T>(pod) {}
 
PODWrapper(const T* pod) :
PODHolder<PODWrapper,T>(pod) {}
};
bitrex <bitrex@de.lete.earthlink.net>: Mar 30 09:53AM -0400

On 03/30/2017 09:49 AM, bitrex wrote:
 
> {
> static auto buf = new char[sizeof(T)];
> return &buf[0];
 
sorry, should be just "return buf;" here as buf is already a pointer.
ram@zedat.fu-berlin.de (Stefan Ram): Mar 30 12:05PM

I was reading an article by N. Wirth about "Program
Development by Stepwise Refinement" from 1971.
 
It is discussing the Eight Queens Problem and says:
 
»The reader is strongly urged to try to find a
solution by himself before embarking on the paper«.
 
Argh! So, now, I couldn't read on, but had to solve
the silly Eight Queens Problem myself first!
 
I read it mentioned so very often, but never actually
programmed a solution myself IIRC. So here it is in C++:
 
#include <algorithm>
#include <cassert>
#include <iostream>
#include <ostream>
#include <vector>
#include <string>
 
using position_t = int;
using direction_t = int;
 
::std::vector< direction_t >directions{ 0, 1, 2, 3, 4, 5, 6, 7 };
::std::vector< int >offset_y{ +1, +1, 0, -1, -1, -1, 0, +1 };
::std::vector< int >offset_x{ 0, +1, +1, +1, 0, -1, -1, -1 };
 
class board_t : public ::std::vector< position_t >
{ public:
 
using ::std::vector< position_t >::vector;
 
board_t(): board_t( 64 ){}
 
int operator()( int const y, int const x ) const
{ return this->at( y * 8 + x ); }
 
void set( position_t const position )
{ assert( !this->at( position ));
this->at( position )= 1; }
 
void unset( position_t const position )
{ assert( this->at( position ));
this->at( position )= 0; }
 
bool is_in_board( int const position ) const
{ return position >= 0 && position < 64; }
 
bool is_in_board( int const y, int const x ) const
{ return y >= 0 && y < 8 && x >= 0 && x < 8; }
 
bool conflict_with_other_position
( int const position_y, int const position_x ) const
{ for( direction_t const direction : directions )
{ int const dy = offset_y.at( direction );
int const dx = offset_x.at( direction );
int pos_y = position_y;
int pos_x = position_x;
for( int distance = 0;; ++distance )
{ pos_y += dy;
pos_x += dx;
if( !is_in_board( pos_y, pos_x ))break;
if( ( *this )( pos_y, pos_x ))return true; }}
return false; }
 
bool conflict_with_other_position( position_t const position ) const
{ return conflict_with_other_position( position / 8, position % 8 ); }
 
bool conflict_with_this_position( position_t const position ) const
{ return this->at( position ); }
 
bool conflict( position_t const position ) const
{ assert( is_in_board( position ));
if( conflict_with_this_position( position ))return true;
return conflict_with_other_position( position ); }
 
void print_cell_at( int const row, int const col ) const
{ ::std::cout <<( ( *this )( row, col )? 'W' : ':' ); }
 
void print_end_of_line() const
{ ::std::cout << '\n'; }
 
void print_all_cells_of( int const row ) const
{ for( int col = 0; col < 8; ++col )print_cell_at( row, col );
print_end_of_line(); }
 
void print_all_rows() const
{ for( int row = 8; row > 0; ){ --row; print_all_cells_of( row ); }}
 
void print() const
{ print_all_rows(); }};
 
static void print( board_t const & board )
{ board.print();
::std::cout << '\n'; }
 
struct place_eight_queens
{
int number_of_queen {};
 
board_t board;
 
void print_solution_or_set_next_queen( position_t const position )
{ if( 8 == number_of_queen )print( board );
else place_next_queen( position ); }
 
void set_this_queen( position_t const position )
{ board.set( position );
print_solution_or_set_next_queen( position );
board.unset( position ); }
 
void set_queen_if_no_conflict( position_t const position )
{ if( !board.conflict( position ))set_this_queen( position ); }
 
void try_all_positions( int const starting_position )
{ for( position_t position = starting_position; position < board.size(); ++position )
set_queen_if_no_conflict( position ); }
 
void place_next_queen( int const starting_position )
{ ++number_of_queen;
try_all_positions( starting_position );
number_of_queen--; }
 
void place_queens()
{ number_of_queen = 0;
int const starting_position = 0;
place_next_queen( starting_position ); }
 
void run() { place_queens(); }};
 
int main() { ::place_eight_queens{}.run(); }
 
I have not yet compared the output with solutions from the
literature, so I don't know whether it's correct.
 
Problem: The function »conflict_with_other_position(int,int)«
is way too long, but I was not yet able to find a elegant
decomposition into several smaller function with less than
three parameters each.
ram@zedat.fu-berlin.de (Stefan Ram): Mar 30 12:16PM

>::std::vector< direction_t >directions{ 0, 1, 2, 3, 4, 5, 6, 7 };
>::std::vector< int >offset_y{ +1, +1, 0, -1, -1, -1, 0, +1 };
>::std::vector< int >offset_x{ 0, +1, +1, +1, 0, -1, -1, -1 };
 
I possibly should have used »::std::array« above, following
the guideline to prefer »::std::array« to »::std::vector«
when »::std::vectors« advanced features (resizing) are not
needed.
 
Also, I am told:
 
warning: declaration requires a global destructor [clang-diagnostic-global-constructors]
::std::vector< direction_t >directions{ 0, 1, 2, 3, 4, 5, 6, 7 };
^
. Don't know what to make of this.
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 30 01:40PM +0200

In C++03 perfect forwarding of a sequence of arguments of arbitrary
types, caused a combinatorial explosion in const versus non-const.
 
In C++11 and later even just writing a function that /accepts/ arbitrary
argument types, when it's desirable to accept std::initializer_list
literals such as `{1, 2, 3}`, causes a combinatorial explosion in
initializer_list (which must known to the compiler as such) versus others.
 
E.g. in order to be able to call
 
multi( {1, 2, 3}, {5, 6, 7} )
 
with up to 3 arguments, a bunch of silly overloads are apparently needed:
 
template< class... Collections >
class Multidimensional_view_
{
public:
Multidimensional_view_( Collections const&... )
{}
};
 
template< class... Collections >
inline $f make_multidimensional_view( ref_<const Collections>... c )
-> Multidimensional_view_< Collections... >
{ return Multidimensional_view_< Collections... >{ c... }; }
 
template< class... Collections >
inline auto multi( ref_<Collections>... c )
{ return make_multidimensional_view( c... ); }
 
template< class Value >
// i
inline auto multi(
ref_<const initializer_list<Value>> list
)
{ return make_multidimensional_view( list ); }
 
template< class Collection, class Value >
// ci
inline auto multi(
ref_<const Collection> c,
ref_<const initializer_list<Value>> list
)
{ return make_multidimensional_view( c, list ); }
 
template< class Value, class Collection >
// ic
inline auto multi(
ref_<const initializer_list<Value>> list,
ref_<const Collection> c
)
{ return make_multidimensional_view( list, c ); }
 
template< class Value_1, class Value_2 >
// ii
inline $f multi(
ref_<const initializer_list<Value_1>> list_1,
ref_<const initializer_list<Value_2>> list_2
)
{ return make_multidimensional_view( list_1, list_2 ); }
 
template< class Collection_1, class Collection_2, class Value >
// cci
inline auto multi(
ref_<const Collection_1> c_1,
ref_<const Collection_2> c_2,
ref_<const initializer_list<Value>> list
)
{ return make_multidimensional_view( c_1, c_2, list ); }
 
template< class Collection_1, class Value, class Collection_2 >
// cic
inline auto multi(
ref_<const Collection_1> c_1,
ref_<const initializer_list<Value>> list,
ref_<const Collection_2> c_2
)
{ return make_multidimensional_view( c_1, list, c_2 ); }
 
template< class Collection, class Value_1, class Value_2 >
// cii
inline auto multi(
ref_<const Collection> c,
ref_<const initializer_list<Value_1>> list_1,
ref_<const initializer_list<Value_2>> list_2
)
{ return make_multidimensional_view( c, list_1, list_2 ); }
 
template< class Value, class Collection_1, class Collection_2 >
// icc
inline auto multi(
ref_<const initializer_list<Value>> list,
ref_<const Collection_1> c_1,
ref_<const Collection_2> c_2
)
{ return make_multidimensional_view( list, c_1, c_2 ); }
 
template< class Value_1, class Collection, class Value_2 >
// ici
inline auto multi(
ref_<const initializer_list<Value_1>> list_1,
ref_<const Collection> c,
ref_<const initializer_list<Value_2>> list_2
)
{ return make_multidimensional_view( list_1, c, list_2 ); }
 
template< class Value_1, class Value_2, class Collection >
// iic
inline auto multi(
ref_<const initializer_list<Value_1>> list_1,
ref_<const initializer_list<Value_2>> list_2,
ref_<const Collection> c
)
{ return make_multidimensional_view( list_1, list_2, c ); }
 
template< class Value_1, class Value_2, class Value_3 >
// iii
inline auto multi(
ref_<const initializer_list<Value_1>> list_1,
ref_<const initializer_list<Value_2>> list_2,
ref_<const initializer_list<Value_3>> list_3
)
{ return make_multidimensional_view( list_1, list_2, list_3 ); }
 
How can this be avoided?
 
 
Cheers!,
 
- Alf
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 30 01:44PM +0200

On 30-Mar-17 1:40 PM, Alf P. Steinbach wrote:
> [snip]
 
Sorry about the formatting, the non-aligned comments: it's Thunderbird
messing things up with its flowed format implementation.
 
Cheers!,
 
- Alf
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:

Wednesday, March 29, 2017

Fwd: Fw: Fwd: Fw: Fwd:



Sent from my iPad

Begin forwarded message:

From: Shu Gong <edg1996@yahoo.com>
Date: March 29, 2017 at 12:55:27 PM CDT
To: erdong wang <wanged@126.com>, Chou Mei Ling <ccd.meiling@gmail.com>, Su Mei Tseng <sumei7049@gmail.com>, Yu min Hsu <shu67@b-a.com.tw>, Lifeng Chang <magiclifeng@yahoo.com.tw>, 曾正奇 <tchengchi@gmail.com>, tina Soong <tinasoong@att.net>, 林慈玥 <tzuyuehlin@gmail.com>, peitzu Tsai <tpeitzu@yahoo.com.tw>, yichun <yichun.yeh@msa.hinet.net>, Yen-wen Hsiao <ywhsiao95@yahoo.com.tw>, 吴云 <yvonne.wy@hotmail.com>, lungchiao you <gsnpsyou@gmail.com>, "You, Shu Yu You" <yousy@tmue.edu.tw>, Peter Chang <chang737@gmail.com>, 涂瑞玲 <psychodrama3369@gmail.com>, "Dr. Pei-li Wu" <sd05017@yahoo.com>, Lai Annie <annielai2009@gmail.com>
Subject: Fwd: Fw: Fwd: Fw: Fwd:



Sent from my iPad

Begin forwarded message:

From: Richard Wang <rjjcdykr@yahoo.com>
Date: March 29, 2017 at 10:29:45 AM CDT
Subject: Fw: Fwd: Fw: Fwd:
Reply-To: Richard Wang <rjjcdykr@yahoo.com>






---------- Forwarded message ----------
From:
Date: 2017-03-27 22:08 GMT-07:00
Subject: Fw: Fwd:
To: 

Sent from Yahoo Mail for iPhone

Begin forwarded message:

On Monday, March 27, 2017, 9:57 PM, L Su <@gmail.com> wrote:



>> 康師傅…永別了！
>>  
>>   中華民族的敗類，讓它壽終正寢！
>>
>>   康師傅為日本購中國釣魚島捐三億日元！
>> 撕開康師傅的外衣，原來是披著羊皮的日貨！
>> 網上曝出康師傅名為台企，實際早就由日本朝日啤酒收購控股！
>> 看到中華大地遍地都是康師傅的水、飲料、方便面，痛心呀！
>> 以后堅決不再買康師傅的任何東西。
>> 大家多轉發，讓更多國人知道！
>> 朝日啤酒為日本購買釣魚島捐了三億日元，這垃圾企業！
>>
>>  誰群多，轉一下，日本人說中國人是垃圾，不團結！
>> 今天騰迅公司和日本人打賭，如果在兩周內轉發超過兩百萬的話， 日本人就是垃圾…
>> （是中國人就轉，是懦夫的可不轉）！
>>





Posted by at No comments:

Digest for comp.lang.c++@googlegroups.com - 25 updates in 5 topics

legalize+jeeves@mail.xmission.com (Richard): Mar 29 04:01PM

[Please do not mail me a copy of your followup]
 
Jorgen Grahn <grahn+nntp@snipabacken.se> spake the secret code
 
>> It's mind numbingly trivial if you use CMake :)
 
>Perhaps, but the cost of copying the source code to whereever you want
>to build, and building it there, is very small today.
 
That sounds to me like you haven't tried to do what you suggest with
any sizeable distribution or with any project that has a mildly
complex build.
 
In those situations where I've attempted to do what you suggest, it
was significantly more painful than just running CMake. CMake
supports this trivially out-of-the-box using the same source tree.
--
"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>
woodbrian77@gmail.com: Mar 29 03:08PM -0700

On Monday, March 27, 2017 at 4:03:15 PM UTC-5, Rick C. Hodgin wrote:
 
> It's even easier if you switch to Visual Studio. It handles it all
> for you. Just add files to projects, projects to solutions, and then
> you can click one of the buttons (or use the hotkeys):
 
I'm wondering if there are things with my Windows makefile
that could be improved on:
 
https://bitbucket.org/webenezer/onwards/src/7a925499bdaa2ce53df5401f255b2db9d6100bf0/makefile.windows?at=master&fileviewer=file-view-default
 
Let me know if that link doesn't work -- I'll post the file.
 
One of the rules there uses /link, but two of them don't.
It seems to work either way. I'm not sure about the libraries
I link to. They work on my Windows7 machine, but I don't have
anything with a newer version of Windows on it to work with.
I want to sell my laptop and buy a new one... then I'd
probably get a newer version of Windows. Thanks in advance.
 
 
Brian
Ebenezer Enterprises - In G-d we trust.
http://webEbenezer.net
jacobnavia <jacob@jacob.remcomp.fr>: Mar 29 01:27AM +0200

Le 29/03/2017 à 00:04, Hergen Lehmann a écrit :
 
> std::byte does not define arithmetic operators (+,-,*,/,%), so you can
> not accidentally do arithmetic on them.
 
The above program proves that it is indeed possible.
 
Anyway if you define
 
struct switches {
int lighisOn:1;
int soundisOn:1;
};
 
you can't do any addition or arithmetic operations on this type.
 
struct switches a,b,c;
 
c=a+b; // error
 
so, you ALREADY have the advantages of "byte".
Daniel <danielaparker@gmail.com>: Mar 28 05:14PM -0700

On Tuesday, March 28, 2017 at 7:11:51 PM UTC-4, Mr Flibble wrote:
 
> > It could be argued that C++ is more in need of a character type than a byte
> > type.
 
> char.
 
Unfortunately, char cannot represent a Unicode character. A sequence of char can represent a byte encoding of a Unicode character.
Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk>: Mar 28 07:50PM -0500


>> char.
 
> Unfortunately, char cannot represent a Unicode character. A sequence of
> char can represent a byte encoding of a Unicode character.
 
char and std::string are perfectly fine for Unicode in the form of UTF-8;
nothing else is needed at the model level.
 
/Flibble
Daniel <danielaparker@gmail.com>: Mar 28 08:34PM -0700

On Tuesday, March 28, 2017 at 8:50:18 PM UTC-4, Mr Flibble wrote:
 
> char and std::string are perfectly fine for Unicode in the form of UTF-8;
> nothing else is needed at the model level.
 
Um, no :-)
 
UTF-8 is a Unicode byte encoding. It's something you send over a wire or
serialize to a stream. It's not something the application programmer should
have to be aware of.
 
good::string s;
 
for (good::character c : s)
{
}
 
should loop over unicode codepoints, irrespective of the encoding of s
(likely UTF-8).
 
s.length() should return the length of the string in codepoints. The find
members on s should work.
 
An application programmer shouldn't have to write something
like
 
std::string source = "Hi \xf0\x9f\x99\x82";
 
auto g = codepoint_generator(source.begin(),source.end());
while (!g.done())
{
char32_t codepoint = g.codepoint();
g.next();
}
 
But I know, I know, you don't see it.
 
Best regards,
Daniel
Hergen Lehmann <hlehmann.expires.5-11@snafu.de>: Mar 29 05:59AM +0200

Am 29.03.2017 um 01:23 schrieb jacobnavia:
 
> };
 
> there is no math operations defined for that type , so all constraints
> supposed to be gained by "byte" are ALREADY THERE.
 
In fact, the struct with bitfields actually does provide the
sought-after constraints, while std::byte does not!
 
Accidental shift operations (which are allowed on std::byte!) would
break the boundaries between the bit fields in such a register the same
way an arithmetic operation would do. Nothing gained by forbidding
arithmetics only...
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 29 12:10PM +0200

On 28-Mar-17 11:41 PM, jacobnavia wrote:
> addressing in byte oriented machines, that since ages are standardized
> as a sequence of 8 bits. Nowhere is specified what these people think
> about that "many programs". Not ALL of them?
 
I think the author means access to memory view as raw bytes.
 
Thanks for the Werner Buchholz reference. I didn't know. Learned
something. :)
 
 
> store (eventually) small numbers in a byte. A signed byte can also
> contain quantities like age, that with some effort could arrive at 128,
> but....
 
AFAIK your choice is exactly opposite of most programmers' choice.
 
Still it would work on most architectures.
 
I gather it would work on /all/ extant architectures.
 
`signed char` has the formal problem that it can (read: once could) be
size-and-magnitude or one's complement, which has one bitpattern (just
one because all bits are required to be value representation bits) that
either denotes the same value as some other bitpattern, or is reserved
for some other purpose such as a trap representation.
 
Also, and probably for precisely that reason, the standard's special
support for bytes is for `unsigned char`, not `signed char`.
 
 
> I disgress.
 
Yes. :)
 
 
> <end quote>
 
> Yes. You can even store letters in an unsigned chars. All this is
> already possible with known syntax and known rules.
 
I agree. `std::byte` is just silly. And sad.
 
 
 
> No data is provided in the document to prove this assertion. No research
> is mentioned about what tools are confused and why should we bear yet
> another syntax rule.
 
I don't think the author's assertion holds at all.
 
As you, I have some decades of programming behind me.
 
If the problem existed I should certainly have encountered it.
 
 
> [snip]
> But we HAVE already rules to do that. But why keep it simple when we can
> complexify things?
 
Politics, I think.
 
Everybody gets to contribute, and can then support other things.
 
Still that's very sad, it's IMO not how things should work. The C++
standardization committee shouldn't have to garner the support of
newbies. Listen to the learners and their problems and wishes, yes,
yes!; letting them design the language, absolutely not...
 
 
Cheers!,
 
- Alf
Chris Vine <chris@cvine--nospam--.freeserve.co.uk>: Mar 29 11:45AM +0100

On Tue, 28 Mar 2017 17:14:33 -0700 (PDT)
 
> > char.
 
> Unfortunately, char cannot represent a Unicode character. A sequence
> of char can represent a byte encoding of a Unicode character.
 
An 8-bit integer could never represent the full set of Unicode code
points, if that is what you mean, except by a multi-byte encoding. In
a single-byte encoding it can only hold the ASCII subset of unicode.
 
However, there is a standard way of representing such code points in a
single character, namely the char32_t type, and the associated
std::u32string type.
 
What do you think that C++ should provide that these do not?
 
Chris
David Brown <david.brown@hesbynett.no>: Mar 29 01:00PM +0200

On 29/03/17 12:10, Alf P. Steinbach wrote:
>> addressing in byte oriented machines, that since ages are standardized
>> as a sequence of 8 bits. Nowhere is specified what these people think
>> about that "many programs". Not ALL of them?
 
There is still significant use for C and C++ on architectures that do
not support 8-bit types. The main class here is DSP's - many have
16-bit or 32-bit char, and a few have weirder sizes (though those
usually do not have C++ compilers). It would be reasonable to say that
future C or C++ standards would no longer need to fit with older
mainframe systems with 36-bit char and the like - but DSPs are current
architectures.
 
 
>> I mean all programs in C and C++ are using that access each day in
>> almost all computers running today. The sizeof() unit is a byte. The C
>> and the C++ languages are byte oriented languages.
 
The sizeof() unit is /always/ a "byte" in C and C++ - that is by
definition of the language. But "byte" does not always mean 8 bits in C
and C++. It is the most common choice, especially for C++, but it is
/not/ universal.
 
It would, of course, be much simpler if "byte" were fixed at 8 bits.
But the C and C++ standards committees (especially the C one) are very
reluctant to add new limitations to the types of systems that can use
the languages.
 
>> contain quantities like age, that with some effort could arrive at 128,
>> but....
 
> AFAIK your choice is exactly opposite of most programmers' choice.
 
Most people, I think, use plain "char" for text - at least for ASCII text.
 
 
>> Yes. You can even store letters in an unsigned chars. All this is
>> already possible with known syntax and known rules.
 
> I agree. `std::byte` is just silly. And sad.
 
The "char" types /do/ perform three separate jobs.
 
"char" is a sensible type for a "character" - a single element of the
basic character set. It won't hold a UTF character, but for a lot of
programs, that is not necessary - and there is char32_t for UTF-32
characters.
 
"char", "signed char" and "unsigned char" have never been good names for
small numerical types - but until C99 and C++11 had uint8_t, int8_t, and
related types, "signed char" and "unsigned char" were the only choices.
A particular problem with these types is that many people used "char"
and made assumptions about whether it was signed or unsigned.
 
And "char" or "unsigned char" is used as a "minimal item of memory" - a
"byte". Sometimes people use "uint8_t" here instead.
 
 
I think it is not unreasonable to give people an alternative type here,
to make it clearer what they mean. If you use "byte" in your code, it
is obvious that it is for raw memory storage, not for text characters or
small numbers. It is too late to /force/ people to use it (just as it
is too late to stop people using "char" for numbers). But it does mean
there is a standard name that can be used for this purpose.
 
The "sad" and "silly" thing about "std::byte", IMHO, is that we are
getting it /now/ - instead of getting it 30 or 40 years ago in C.
 
>> is mentioned about what tools are confused and why should we bear yet
>> another syntax rule.
 
> I don't think the author's assertion holds at all.
 
I don't remember seeing such mistakes either. But I have certainly seen
people use "char" when they should have specifically been using "signed
char", "unsigned char", "int8_t" or "uint8_t".
 
One thing I think is odd about std::byte is that they have defined
bitwise operations on them. I don't see the point of that at all. I
see a use for an opaque "small item of memory" type, but can't
comprehend why one would want to be able to apply shifts and masking
while specifically blocking arithmetic.
 
 
Daniel <danielaparker@gmail.com>: Mar 29 04:20AM -0700

On Wednesday, March 29, 2017 at 6:45:52 AM UTC-4, Chris Vine wrote:
> single character, namely the char32_t type, and the associated
> std::u32string type.
 
> What do you think that C++ should provide that these do not?
 
First of all, I don't see anybody using std::u32string. The
evolving best practice in C++ seems to be to keep the Unicode byte
encoding in UTF-8, and store them in std::string (Mr Flibble gets that
part right.) And use third party libraries for performing Unicode aware
operations on them (Mr Fliblle overlooks that.) At this point in the
evolution of C++, any path forward is going to have to keep std::string for
UTF-8 byte encodings.
 
A proper string class provides an abstract interface, and not merely an array
of codepoints.
 
Daniel
scott@slp53.sl.home (Scott Lurndal): Mar 29 12:54PM

>future C or C++ standards would no longer need to fit with older
>mainframe systems with 36-bit char and the like - but DSPs are current
>architectures.
 
Minor correction - on 36-bit systems[*], a "byte"[***] was 9-bits (such that
four would be packed into a 36-bit word). On 48-bit systems[**], a word
can be decomposed into 6 bytes using various instructions, but individual
byte access to memory isn't supported.
 
[*] e.g. Clearpath Dorado (formerly Univac 1100/2200), still in production
[**] e.g. Clearpath Libra (formerly Burroughs Large Systems), still in production
[***] A.K.A. Quarter-word.
 
I know that Libra has a C compiler. Not sure about Dorado. Both
architectures are over 50 years old and still plugging along
(albeit in emulation for the next generations).
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 29 03:23PM +0200

On 29-Mar-17 12:45 PM, Chris Vine wrote:
 
> An 8-bit integer could never represent the full set of Unicode code
> points, if that is what you mean, except by a multi-byte encoding. In
> a single-byte encoding it can only hold the ASCII subset of unicode.
 
Oh, if it's about technical details, then a C or C++ byte is always
sufficient to hold one of the 256 first code points of Unicode, which is
ISO Latin-1.
 
I don't go so deep into details that I care about the hyphen there. ;)
 
 
> single character, namely the char32_t type, and the associated
> std::u32string type.
 
> What do you think that C++ should provide that these do not?
 
I can't answer for Chris Vine but IMHO a strongly typed character
encoding unit that is natural for the current system, like `int` is the
natural integer type for the platform (disregarding cross-compilation).
 
Such a type can be defined easily, as a `wchar_t` based enum in Windows,
for UTF-16 encoding, and as `char` based enum in Unix-land, for UTF-8
encoding. But there's no way to define a natural way to write string
literals for it. User defined literals just don't cut it, as I once
believed they would. Then one must use macros, which is ugly.
 
I've played around with the concept for some years, and wrote an article
in ACCU Overload journal. And my experience is that core language
support is definitely needed. But then one is up against the
single-universal-encoding dream of a certain subset of Unix-land folks,
which is baffling to me since C++ is a multi-paradigm language
originating in the most multi-paradigm OS ever devised, the ironically
named Unix (okay, I know the history, Multics and all that, but I
absolutely won't let inconvenient facts stand in the way of good arg).
 
 
Cheers!.
 
- Alf
Bo Persson <bop@gmb.dk>: Mar 29 03:25PM +0200

On 2017-03-28 23:41, jacobnavia wrote:
 
> I disgress.
 
> What is important is that the existing language already gives you all
> possible tools for doing all kinds of operations on unsigned chars.
 
The idea is to have a limited abstraction that is used ONLY for
accessing raw memory.
 
A std::byte has the advantage that it is NOT implicitly convertible to
integer or floating point types. It can be used as a function parameter
without getting ambiguous overloads with functions taking a std::uint8_t.
 
And the standard library will not try to convert it to a char if you
accidentally write std::cout << b;. You get an error instead.
 
 
The thing is that sometimes it is easier to write correct code if you
limit yourself, so you don't have to use the biggest sledge hammer on
the smallest nail.
 
 
 
Bo Persson
David Brown <david.brown@hesbynett.no>: Mar 29 04:01PM +0200

On 29/03/17 14:54, Scott Lurndal wrote:
>> architectures.
 
> Minor correction - on 36-bit systems[*], a "byte"[***] was 9-bits (such that
> four would be packed into a 36-bit word).
 
Have there been no systems with 36-bit bytes? I know of systems with
12-bit bytes, 16-bit bytes, 18-bit bytes, 24-bit bytes and 32-bit bytes.
But those were not mainframes (they are DSPs or other specialised
processors).
 
> On 48-bit systems[**], a word
> can be decomposed into 6 bytes using various instructions, but individual
> byte access to memory isn't supported.
 
I think in C (and C++), a "byte" must be at least 8 bits. The hardware
can, of course, provide smaller divisions - but they are not "bytes" in
C parlance.
 
David Brown <david.brown@hesbynett.no>: Mar 29 04:04PM +0200

On 29/03/17 15:25, Bo Persson wrote:
 
> A std::byte has the advantage that it is NOT implicitly convertible to
> integer or floating point types. It can be used as a function parameter
> without getting ambiguous overloads with functions taking a std::uint8_t.
 
Overloads might well be a key reason for std::byte. The fact that small
integer types are the same as character types makes it difficult to make
overloaded output functions that work nicely with those types.
 
fir <profesor.fir@gmail.com>: Mar 29 07:39AM -0700

W dniu środa, 29 marca 2017 14:54:51 UTC+2 użytkownik Scott Lurndal napisał:
 
> I know that Libra has a C compiler. Not sure about Dorado. Both
> architectures are over 50 years old and still plugging along
> (albeit in emulation for the next generations).
 
note when we talk about basic hardware types today we should probably not mention only 2 sizes (byte size, word size) but probably about 3 ones (byte size, word size, integer size) - today word (understood as an capable index over a ram) and basic integer size dont must necessary come together
scott@slp53.sl.home (Scott Lurndal): Mar 29 03:08PM

>12-bit bytes, 16-bit bytes, 18-bit bytes, 24-bit bytes and 32-bit bytes.
> But those were not mainframes (they are DSPs or other specialised
>processors).
 
Well, the PDP-6 and PDP-10 used 36-bit words (double the 18-bits of PDP-1/4) where
character data was stored in 6-bit fields within the 36-bit
word but the instruction set (on the PDP-10) included instructions that could extract
arbitrary n-bit wide fields from the word.
 
Likewise the 12-bit PDP-5/PDP-8, the word size was 12-bits and generally two
6-bit characters were encoded into each word.
 
 
>I think in C (and C++), a "byte" must be at least 8 bits. The hardware
>can, of course, provide smaller divisions - but they are not "bytes" in
>C parlance.
 
Yes, the 48-bit systems have six 8-bit bytes.
 
Bo Persson <bop@gmb.dk>: Mar 29 06:18PM +0200

On 2017-03-29 17:08, Scott Lurndal wrote:
 
>>> I know that Libra has a C compiler. Not sure about Dorado. Both
>>> architectures are over 50 years old and still plugging along
>>> (albeit in emulation for the next generations).
 
According to the comments here
 
http://stackoverflow.com/a/6972551/597607
 
the 2200 series even had a C++ compiler. Or at least an eye-witness
claims to have once seen the manual on-line. :-)
 
 
Bo Persson
Mr Flibble <flibbleREMOVETHISBIT@i42.co.uk>: Mar 29 10:00PM +0100

On 29/03/2017 04:34, Daniel wrote:
> g.next();
> }
 
> But I know, I know, you don't see it.
 
Sorry but you are talking nonsense. Individual Unicode codepoints
represented by a single scalar type are just as useless as variable
length UTF-8 encoded codepoints as far as wanting an atomic "character"
is concerned; you would know this if you did any serious i18n and/or
Unicode work.
 
I strongly disagree with your assertion that UTF-8 should only be used
during "serialization" and that an application should be unaware of it:
you are obviously a newbie or suffering from Dunning-Kruger effect if
you hold such views. Did you know Linux uses UTF-8 for filenames?
 
The text edit widget in my GUI library accepts UTF-8 as input; caches it
as both UTF-32 and font glyphs (after any glyph shaping performed for
e.g. Arabic script) and it works a treat so I do have practical
knowledge in this area.
 
/Flibble
fir <profesor.fir@gmail.com>: Mar 29 04:17AM -0700

W dniu wtorek, 28 marca 2017 19:06:55 UTC+2 użytkownik fir napisał:
> 7*100k of blocks = 0.7 MB of blocks + 10k * 10 bytes - 0.1 MB of palettes - that would be like 1.35 MB of a result.. that i would be starting to get satisfied (if zip gives 12MB- > 0.8 MB imo the 12MB->1.3 MB of home easy packing would be starting to get satisfied
 
> the code would be also not to much hard to write in one evening - though im weary now and get no mood to code it now
 
> also could try this RLE but also to weary now
 
PS i write this RLE packing.. though i not tested if it works ok (im sometimes to wearylazy to test i just wrote and run as here)
 
//////////////////////////////
 
int CheckHowLongRepeatingSequenceOfUnsignedsHere(unsigned * input, unsigned * input_last)
{
int counter = 0;
 
for(unsigned * p = input; p<=input_last; p++)
{
if(*p==*input) counter++;
else break;
}
return counter;
}
 
 
int Encode31bitUnsignedsRLE(unsigned* input, int input_max, unsigned * output, int output_max)
{
 
int input_i = 0;
int output_i = 0;
 
for(;;)
{
if(input[input_i] & 0x80000000) ERROR_("error: 31 bit input values are assumed");
if( input_i>=input_max) return output_i;
if(output_i>=output_max) ERROR_("error: overflow in output (in EncodeRLE)");
 
int rep = CheckHowLongRepeatingSequenceOfUnsignedsHere(&input[input_i], &input[input_max-1]);
 
if(rep==1)
{
output[output_i] = input[input_i];
 
input_i ++;
output_i ++;
 
}
 
 
if(rep > 1)
{
output[output_i] = input[input_i] & 0x80000000;
output_i++;
output[output_i] = rep;
output_i++;
 
input_i += rep;
}
 
}
 
}
 
const int BitmapRLEEncoded_max = 4000*4000;
 
unsigned BitmapRLEEncoded[BitmapRLEEncoded_max];
 
 
int BitmapRLEEncoded_top = 0;
 
 
int EncodeBitmapRowRLE(int y)
{
int encoded_row_size = Encode31bitUnsignedsRLE(&indexed_map[y][0], map_x, &BitmapRLEEncoded[BitmapRLEEncoded_top], BitmapRLEEncoded_max - BitmapRLEEncoded_top );
 
return encoded_row_size;
 
}
 
int EncodeBitmapRLE()
{
int summaric_encoded_length = 0;
 
for(int y=0; y<map_y; y++)
{
int encoded_row_size = EncodeBitmapRowRLE(y);
 
flog("\n encoded row %d size %d", y, encoded_row_size );
 
summaric_encoded_length += encoded_row_size;
 
}
 
flog("\n summaric_encoded_length %d ", summaric_encoded_length );
 
}
 
///////////////////////////////
 
the results (im not sure if this encodes well though as i said) was
 
 
encoded row 0 size 315
encoded row 1 size 350
encoded row 2 size 400
encoded row 3 size 446
encoded row 4 size 514
encoded row 5 size 583
encoded row 6 size 565
encoded row 7 size 641
encoded row 8 size 666
encoded row 9 size 717
encoded row 10 size 736
encoded row 11 size 787
encoded row 12 size 801
encoded row 13 size 823
encoded row 14 size 843
encoded row 15 size 878
encoded row 16 size 916
encoded row 17 size 924
encoded row 18 size 926
encoded row 19 size 935
encoded row 20 size 903
encoded row 21 size 912
encoded row 22 size 886
encoded row 23 size 860
encoded row 24 size 835
encoded row 25 size 826
encoded row 26 size 865
encoded row 27 size 858
encoded row 28 size 854
encoded row 29 size 808
encoded row 30 size 864
encoded row 31 size 824
encoded row 32 size 818
encoded row 33 size 791
encoded row 34 size 796
encoded row 35 size 764
encoded row 36 size 766
encoded row 37 size 714
encoded row 38 size 796
encoded row 39 size 737
 
(...)
 
encoded row 1970 size 231
encoded row 1971 size 225
encoded row 1972 size 217
encoded row 1973 size 235
encoded row 1974 size 250
encoded row 1975 size 259
encoded row 1976 size 244
encoded row 1977 size 236
encoded row 1978 size 233
encoded row 1979 size 245
encoded row 1980 size 245
encoded row 1981 size 239
encoded row 1982 size 228
encoded row 1983 size 225
encoded row 1984 size 215
encoded row 1985 size 218
encoded row 1986 size 212
encoded row 1987 size 205
encoded row 1988 size 215
encoded row 1989 size 200
encoded row 1990 size 198
encoded row 1991 size 194
encoded row 1992 size 198
encoded row 1993 size 190
encoded row 1994 size 167
encoded row 1995 size 179
encoded row 1996 size 174
encoded row 1997 size 168
encoded row 1998 size 154
encoded row 1999 size 164
summaric_encoded_length 1257765
 
if so that would be 1.25 M ints it is quite well, better than even probably a bit eleborate indexing (i even encoded rows in separate encoding all rows as one could be probably only tiny better though)
 
if so that would be a full succes to me, though i need
to test if it is ok as i maybe not quite belive it and there are some errors here
 
this number is number of ints but those ints are indexes
and number of those indexes = number of unique colors and
can be encoded like in 8-16 bits (in present case even in 6 bits but it will grow, still for some time it will be 10 bits or less so for my case if this work it seems
good solution)
 
need to test if this really works well, i will check it later
fir <profesor.fir@gmail.com>: Mar 29 06:33AM -0700

W dniu poniedziałek, 27 marca 2017 17:26:50 UTC+2 użytkownik fir napisał:
 
> i get a little big tired when coding roguelike and maybe i could rest coding a side problem
 
ye i m resting from coding by doing coding
 
(could even say im doing rest form softcore coding by doing hardcore coding, (softcore seems harder), but its hard to say i coding rogualike is in fact more softcore and bitmap compression more hardcore (it would semms so to me, but do really?)- anyway in fact there are as it seems to me quite various types of coding work, they resemble selfs in many aspects but quite differ in other many aspects, well, i dont know)
fir <profesor.fir@gmail.com>: Mar 29 09:08AM -0700

W dniu środa, 29 marca 2017 15:33:39 UTC+2 użytkownik fir napisał:
 
> > i get a little big tired when coding roguelike and maybe i could rest coding a side problem
 
> ye i m resting from coding by doing coding
 
> (could even say im doing rest form softcore coding by doing hardcore coding, (softcore seems harder), but its hard to say i coding rogualike is in fact more softcore and bitmap compression more hardcore (it would semms so to me, but do really?)- anyway in fact there are as it seems to me quite various types of coding work, they resemble selfs in many aspects but quite differ in other many aspects, well, i dont know)
 
i think maybe the core difference is as when compressing bitmap one need to plan it and rethink (as this is algorithm that need rethinking) when coding roguelike otherwise it is a lot of more strightforward code, but a
lot of typing code jumping and error checking (less amount of complex thinking but a bigger amount of practical but quite wearysome mind-usage (quite scary there is so much lot of it needed then in fact one could rest thinking on some algorithm :C))
James Lothian <james@firstnamelastname.freeserve.co.uk>: Mar 29 04:03PM +0100

Stefan Ram wrote:
> Lambda My Ny Xi Omikron
> Pi Rho Sigma Tau Ypsilon
> Phi Chi Psi Omega
 
Just for entertainment, I did it like this:
 
----------------------------------------
 
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <sstream>
 
std::vector<std::string> split(const std::string &input)
{
std::istringstream buff(input);
std::vector<std::string> r;
std::string blah;
while(buff >> blah) {
r.push_back(blah);
}
return r;
}
 
std::vector<size_t> getColWidths(const std::vector<std::string> &strings,
size_t colCount)
{
std::vector<size_t> widths(colCount, 0);
for(size_t i = 0; i < strings.size(); ++ i) {
size_t col = i % colCount;
size_t length = strings[i].size();
if(length > widths[col]) {
widths[col] = length;
}
}
 
return widths;
}
 
void writeStrings(const std::vector<std::string> &strings,
const std::vector<size_t> &widths,
size_t colCount)
{
for(size_t i = 0; i < strings.size(); ++ i) {
std::string s = strings[i];
size_t width = widths[i % colCount] + 1;
std::cout << std::setw(width) << std::left << s;
if((i + 1) % colCount == 0) {
std::cout << std::endl;
}
}
std::cout << std::endl;
}
 
int main(int argc, char* argv[])
{
std::string input = "Alpha Beta Gamma Delta Epsilon"
" Zeta Eta Theta Iota Kappa"
" Lambda My Ny Xi Omikron"
" Pi Rho Sigma Tau Ypsilon"
" Phi Chi Psi Omega";
 
std::vector<std::string> strings = split(input);
std::vector<size_t> widths = getColWidths(strings, 5);
writeStrings(strings, widths, 5);
 
return 0;
}
 
 
 
 
--
---------------------------------------------
demangle my email address in the obvious way.
ALFREDO PIACENTINI DECALIA ASSET MANAGEMENT GENEVE <vunciunpudun@mail.com>: Mar 29 05:24AM -0700

PEDOFILO INCULA RAGAZZINI: DANIELE MINOTTI! NON MOSTRATEGLI MAI I VOSTRI FIGLI!! AVVOCATO NAZI DI RAPALLO! RICICLA CASH MAFIOSO! AGENTE SEGRETO OMICIDA! SUA LA SETTA DI SATANISTI STUPRA BIMBI CON GIULIANO FERRARA, ANSELMA DEL'OLIO E GIUSEPPE LAZZARI!

NASCONDETE I VOSTRI FIGLI, PLEASE, DA NOTO AVVOCATO PEDOFIL-O-MOSESSUALE DANIELE MINOTTI (FACEBOOK)! NOTISSIMO AVVOCATO PEDERASTA INCULA BAMBINI DANIELE MINOTTI DI RAPALLO E GENOVA (DA ANNI ED ANNI ISCRITTO PRESSO I PORCI PAZZI CHE STUPRANO ADOLESCENTI E BIMBI, OSSIA GLI ANIMALI PERICOLOSISSIMI DI " ORGOGLIO PEDOFILO" https://en.wikipedia.org/wiki/North_American_Man/Boy_Love_Association)! E' SUA LA SETTA DI SATANISTI STUPRA BIMBI CON DENTRO IL REGISTA, PURE PEDOFILO, GIUSEPPE LAZZARI (ARRESTATO), LA NOTA PEDOFILA TANTO QUANTO, ANSELMA DELL'OLIO ( CHE, COME VEDRETE IN UN VIDEO QUI A SEGUITO, DA' DEL GENIO AL SUO COMPARE DI ORGE SODOMIZZA RAGAZZINI: GIUSEPPE LAZZARI). ED IL, NOTORIAMENTE, DA SEMPRE PEDERASTA, GIULIANO FERRARA!
LO HANNO BECCATO UN'ALTRA VOLTA A STO SCHIFOSO SATANISTA, ANZI, A STO SATANAZISTA PEDOFIL-O-MOSESSUALE DI DANIELE MINOTTI, AVVOCATO CRIMINALISSIMO DI RAPALLO E GENOVA Sede di Rapallo (GE)
Via della Libertà, 4/10 – 16035 RAPALLO (GE)
Tel. +39 0185 57880
Fax +39 010 91 63 11 54
Sede di Genova
Via XX Settembre 3/13 16121 – GENOVA)
CHE EFFETTUA ANCHE, DA SEMPRE, TANTO RICICLAGGIO DI DENARO MAFIOSO, COME PURE ROVINA O TERMINA LA VITA DI GENTE PER BENISSIMO (ANCHE ORDINANDO OMICIDI), ATTRAVERSO COMPLOTTI MASSO-N-AZIFASCISTI, OSSIA, DI LOGGE SATANICHE DI ESTREMISSIMA DESTRA. STO VERME SCHIFOSO DI DANIELE MINOTTI FACEVA PARTE DI UNA SETTA DI PEDERASTA BERLUSCONIANI. IL CUI KAPO' E', OVVIAMENTE, IL PEDOFILO MAXIMO, IL SUO CAROGNESCO MANDANTE DI MILLE CRIMINALITA' E STALKING VIA WEB, ASSOLUTA METASTASI DI DEMOCRAZIA, LIBERTA' E GIUSTIZIA, STRAGISTA SPAPPOLA MAGISTRATI SILVIO BERLUSCONI.
http://www.huffingtonpost.it/2015/03/26/intervista-gianni-boncompagni_n_6945522.html
http://www.cappittomihai.com/tag/pedofilo/
http://www.ibtimes.co.uk/silvio-berlusconi-paid-10m-bribes-bunga-bunga-girls-paedophile-prostitution-trial-1508692
http://www.magicrules.pw/2013/Jul/18/16000.html
DI CUI IL NUMERO DUE E' IL SACCO STRA COLMO DI ESCREMENTI, NOTISSIMO PEDOFIL-O-MOSESSUALE TANTO QUANTO, GIULIANO FERRARA ( LUI STESSO CONSIGLIA IL FARSI SODOMIZZARE, QUI
http://www.blitzquotidiano.it/politica-italiana/giuliano-ferrara-omosessualita-giochetto-consiglio-contro-natura-1483446/
GIULIANO FERRARA E' DA SEMPRE UN PORCO PERVERTITO CHE AMA PARTECIPARE AD ORGE OMOSESSUALI E PEDERASTA... QUESTE FOTO E QUESTO LIBRO LO STRA CHIARISCONO
http://cdn-static.dagospia.com/img/patch/archivio/d0/ferrara_nudo_Visto_exc.jpg E
https://www.ibs.it/arcitaliano-ferrara-giuliano-biografia-di-libro-pino-nicotri/e/9788879531337 ).
VOLETE ALTRE PROVE? ECCOLE QUA. IAMM BELL, IA'! LA, INVECE LEI, NOTA LESBICA, ZOCCOLONA MOGLIE DI GIULIANO FERRARA, ANSELMA DELL'OLIO ( PEDOFILISSIMA ANCHE LEI, SPESSO IN ORGE LESBO CON POCO PIU' CHE BAMBINE), IN QUESTO VIDEO CHE SEGUE
http://video.corriere.it/sesso-11enne-arrestato-regista-giuseppe-lazzari-l-intervista-rai/4287e44c-5e41-11e6-bfed-33aa6b5e1635
DAVA DEL GENIO AL SODOMIZZA BIMBI ( COME I SUOI COMPARI SATANISTI E SATANAZISTI DANIELE MINOTTI, GIULIANO FERRARA ED IL GIA' TRE VOLTE IN GALERA PAOLO BARRAI, NATO A MILANO IL 28.6.1965, DI CRIMINALISSIMA WORLD MAN OPPORTUNITIES LUGANO E WMO SA PANAMA), L' APPENA ARRESTATO PER PEDOFILIA: REGISTA GIUSEPPE LAZZARI ( PEDOFILO E NON PER NIENTE, DA SEMPRE BERLUSCONIANISSIMO... OO CHE CASO, OO)!!!!!!
https://www.nextquotidiano.it/giuseppe-lazzari-regista-accusato-pedofilia/
CHE FACEVA SESSO CON UN BAMBINO DI 11 ANNI A RAVENNA. COME AVRETE NOTATO NEL VIDEO, LA PEDOFILA TANTO QUANTO, ANSELMA DELL'OLIO, DAVA DEL GENIO AL SUO COMPARE PEDERASTA GIUSEPPE LAZZARI. IN QUANTO PARTE DELLA STESSA SETTA SATANISTA E PEDOFILESCA DI SILVIO BERLUSCONI, GIULIANO FERRARA, PAOLO BARRAI DI CRIMINALISSIMA WORLD MAN OPPORTUINITES LUGANO ED IL CITATO NOTO AVVOCATO SODOMIZZA BAMBINI: DANIELE MINOTTI DI GENOVA E RAPALLO, PURE AGENTE SEGRETO IN COPERTO, DI TIPO ASSASSINO. SI, ASSASSINO, PER OVRA E GESTAPO PUBBLICHE E PRIVATE DI SILVIO BERLUSCONI!
VOLETE PROVE ED INIDIZI? IAMM BELL, IA'....GUARDATE QUESTI LINKS CHE SEGUONO, PLEASE.... GUARDATE COME STO PEDERASTA INCULA BAMBINI DI DANIELE MINOTTI, AVVOCATO CRIMINALISSIMO DI RAPALLO E GENOVA, SEMPRE DIFENDA SUOI DEPRAVATI "COLLEGHI", OSSIA VOMITEVOLI PEDOFILI COME LUI! O COME DIFENDA STUPRATORI SESSUALI O IL FARE SESSO CON POCO PIU' CHE BAMBINI, IN GENERALE!
http://www.lettera43.it/cronaca/adescava-minorenni-sul-web-miltare-a-processo_43675123449.htm
http://genova.repubblica.it/cronaca/2014/02/26/news/sesso_virtuale_in_cambio_di_soldi_per_videogame-79717213/
http://www.primocanale.it/notizie/accusato-di-adescare-minori-su-web-condanna-4-anni-e-4-mesi-142040.html
http://www.ilsecoloxix.it/p/genova/2008/08/14/ALZmws0B-denuncio_badante_sgozzata.shtml
http://www.ansa.it/liguria/notizie/2014/06/20/adescava-minori-sul-web-condannato_36c57304-90aa-4c7f-8463-c7d610ed10dd.html
http://iltirreno.gelocal.it/massa/cronaca/2013/04/19/news/casolare-a-luci-rosse-il-pm-7-anni-e-mezzo-all-ex-dipendente-nca-1.6917147
http://punto-informatico.it/1214697/PI/Commenti/legge-pedoweb-fumetti-assolti.aspx
http://www.interlex.it/forum10/relazioni/27minotti.htm
E QUI A SEGUITO, LEGGETE, SEMPRE, PLEASE, LA TESTIMONIANZA DI STEFAN CUMESCU ( A LIVELLO DI COMMENTI SOTTO IL POST IN QUESTIONE: VI ERAN MOLTI VERI E PROPRI POSTS DEL GRANDISSIMO STEFAN CUMESCU, SU INTERNET, MA L'AVVOCATO BASTARDAMENTE ASSASSINO, NONCHE' PEDOFIL-O-MOSESSUALE DANIELE MINOTTI LI STA FACENDO CANCELLARE, AVENDO, OVVIAMENTE, LA COSCIENZA LERCISSIMA). CHE APPENA A 14 ANNI FU PRIMA DROGATO, POI STUPRATO, POI SODOMIZZATO A SANGUE, POI SODOMIZZATO A MORTE, DAL BASTARDO NAZIPEDERASTA DANIELE MINOTTI, MASSONE NEO PIDUISTA, AVVOCATO INCULA RAGAZZINI, AVVOCATO INCULA BAMBINI, COME COSI' AVVOCATO DI MAFIOSI MEGA KILLER E CRIMINALI DI OGNI..
http://switzerland.indymedia.org/demix/2011/06/81999.shtml ).
ED ECCO VARI TESTI CHE CHIARISCONO QUANTO IL REPELLENTE PEDOFILO INCULA BAMBINI, DANIELE MINOTTI STESSO, DA SEMPRE, RICICLI PURE SOLDI ASSASSINI DI COSA NOSTRA, CAMORRA E NDRANGHETA! A GO GO!
http://grokbase.com/t/python/python-list/148jckyh1w/avvocato-pedofilomosessuale-ed-assassino-daniele-minotti-facebook-oltre-che-nazi-megalava-euro-mafiosi-e-come-detto-mandante-di-omicidi-o-suicidate-stalker-di-eroe-civile-michele-nista-su-ordine-di-tiranno-fasciocamorrista-silvio-berlusconi
http://www.perl-tk.pw/2014/Sep/19/12201.html
http://www.nyg-forum.xyz/2014/Oct/26/357297.html
http://www.hardwaresystems.pw/2014/Sep/17/5.html
https://fcku.it/it.comp.console/thread/775860
http://www.nautica.pw/b01b8cd0d77fb08099b3337999773f7c956bd7271ebd73a0da189637.html
A SEGUIRE, ANCORA, GLI INTERI TESTI, (A) DEL POVERO EX BAMBINO STEFAN CUMESCU, SODOMIZZATO QUASI A MORTE, DAL VERMINOSO BASTARDO PEDOFILO AVVOCATO DANIELE MINOTTI, E (B) DI COME LO STESSO RICICLI CASH ASSASSINO, DI COSA NOSTRA, CAMORRA E NDRANGHETA DA SEMPRE. SOON BACK!!!

TEXT A
Ciao tuti e scusate de mio italiano. Io sono rumeno e non me nascondo: me chiamo Stefan Cumescu e sono stato sodomizzato con violenza da avvocato assassino Daniele Minotti di Rapallo e Genova, esatamente nel estate 2009! Infati, io ora tengo 19 anni. Quindi, 5 anni e pasa fa tenevo 14 anni. E bene, 5 anni fa avvocato di giri nazifascisti misti a Cosa Nostra, Camorra, Ndrangheta, Daniele Minotti di Rapallo e Ganova, mi diede tre grammi di cocaina da vendere misti a qualcosa che te fa perdere sensi... mi fece svenire apposta e mentre ero mas di morto che vivo, me sodomizzo'. Vi era anche pancione pieno di merda Giuliano Ferrara de Il Foglio a guardare, ridere, cercare de masturbarse invano esendo noto impotente da sempre. Vi era anche il banchero immensamente pedofilo Gabriele Silvagni di Banca Carim Rimini, e sua moglie, notia prostituta pedofila tante quanto, Raffaella Vaccari, sempre de Rimini. Il filio de putana avvocato Daniele Minotti, criminalissimo avvocato di Rapallo e Genova me sodomizzo' insieme ad altri sei di suoi giri fascisti e mafiosi. Ho anche prove di tuto questo. Io, ora, Stefan Cumescu di Genova, quartiere Caruggi, facio il muratore, basta droga, basta prostituirsi (como doveti de fare a seguito di questo stupro, per poter rimanere vivo, per non venire amazato, e doveti de prostituirmi proprie su ordine de Mafia Berlusconiana e Fascismo Berlusconiano, a Genova, rapresentati da questo bastardo sodomizza bambini de avvocato Daniele Minotti). Guadanio un decimo di quanto guadaniavo prima e lavoro il triplo di quanto prima. Ma preferisco di questo, sento la mia vita uno poco di maggiore securo. Ma avvocato di Hitler, Vallanzasca e Satana, avvocato filio de putana di Silvio Berlusconi e Giuliano Ferrara, nazista e mafioso pederasta Daniele Minotti di Genova e Rapallo, davvero fa parte di setta di maniaci sessuali omosessuali molto pericolosi. Ciao. Stefan.
Posti Scrito
Io vedevo in giro uno belo testo che parlava di tuto questo...anche de orge depravatissime fate da incula bambini Daniele Minotti con Don Riccardo Seppia, ma ora non vedo tanto di piu' in giro de lo steso testo. Alora sai cosa facio? Di mia iniciativa facio cut and copy e provo di riproporlo io da tute parti e pe tuta mi vita. Ciao da Stefan e ri scusa di mio italiano... ma presto volio di fare corsi di sera di miliorarlo. Ciao.
TEXT B -
OCHO AD AVVOCATO "BERLUSCONIANISSIMAMENTE", MEGA RICICLA CASH MAFIOSO, NAZIFASCISTA, ASSASSINO E PEDOFILOMOSESSUALE: DANIELE MINOTTI ( PURE SU FACEBOOK) DI RAPALLO E GENOVA! TUTTI SANNO DI SUE "FESTE" SATANISTISSIME "ATTE A SODOMIZZARE ZINGARELLI DI 6-8 ANNI (A SANREMO, CON DON RICCARDO SEPPIA E COL TANTE VOLTE CONDANNATO A GALERA, PAOLO BARRAI DEL CRIMINALISSIMO BLOG MERCATO "MERDATO" LIBERO.. MA NON SOLO... E FRA POCO.. TUTTI I NOMI E COGNOMI)!!!
OCCHIO, PLS, ALL'AVVOCATO PIU' INFIMAMENTE NAZISTA, MEGA LAVA CASH MAFIOSO, MANDANTE DI OMICIDI E "SUICIDATE", E COME SE NON BASTASSE, ACCLARATO PEDOFILOMOSESSUALE, CHE ESISTA ( IL VOMITO VA' SULLA PARTE "PEDOFILO", PIU' CHE OMOSESSUALE, ANCHE SE IL MEGA SODOMIZZATORE DI BAMBINI, DANIELE MINOTTI, LO E' ENTRAMBE LE COSE; OLTRE AD ESSERE UN VERMINOSO CODARDO: METTEVA DELLE SUE FOTO CON FACCE DA ASSOLUTO PERICOLOSISSIMO MANICACO SESSUALE, SU TUTTA INTERNET... ED OVVIAMENTE, ORA, DOPO CHE LE ABBIAM FATTE NOTARE SU MIGLIAIA DI SITI, DA TOPO DI FOGNA, DETTE FOTO LE HA FATTE SUBITO IMBOSCARE)! COME SE NON BASTASSE, PURE FREQUENTISSIMO MANDANTE DI "SUICIDATE" ED OMICIDI: DANIELE MINOTTI DI GENOVA E RAPALLO.
Criminalissimo Studio Legale pro Mafia, Camorra, Ndrangheta e Neonazisti assassini, di noto pedofilomosessuale Daniele Minotti :: Genova - Rapallo
Via della Libertà, 4/10 - 16035 - Rapallo (GE) (Tribunale di Chiavari)
Via XX Settembre, 3/13 - 16121 - Genova
RICICLANTE DA ANNI CASH KILLER DEGLI EMANUELLO DI COSA NOSTRA, BASATI A GENOVA

http://www.ilsecoloxix.it/p/genova/2011/05/19/AOJ0cAV-rischio_gronda_arresti.shtml

O DEI FEROCI SICARI DELLA NDRANGHETA: I RAMPINO. SEMPRE BASATI A GENOVA

http://www.ilsecoloxix.it/p/genova/2013/06/05/APjJUSgF-ndrangheta_terra_liguria.shtml

BASTARDO VERO, PEDERASTA PERVERTITO DANIELE MINOTTI DI GENOVA E RAPALLO: TUTTI SANNO DELLE ORGE PEDOFILE CHE FACEVA CON DON RICCARDO SEPPIA A SANREMO. FRA SIMBOLI DEMONIACI E TERRIFICANTI SODOMIZZAZIONI DI BAMBINI DI 6-8 ANNI ( E AHIME.. FATEMI SDRAMMATIZZARE, PLS... ANCHE 6-8 ANI). BAMBINI ZINGARELLI! D'ALTRONDE, TOPI DI FOGNA CODARDI E SPIETATI COME IL CRIMINALISSIMO AVVOCATO DANIELE MINOTTI DI GENOVA CHE ALTRO AVREBBERO POTUTO RACCATTARE? IL TUTTO FRA CHILI DI COCAINA, MEGA CASH MAFIOSO, E SCIOCCANTISSIMAMENTE, DOZZINE DI TESSERE FASCIOCAMORRISTE DI FORZA ITALIA, FRATELLI D'ITALIA, CASA POUND, FIAMMA TRICOLORE E LEGA NORD. IL DAVVERO "AVVOCATO DEL DIAVOLO", IL BASTARDO MASSONE NAZISTA, IL VERME MASSO-NAZISTA ( MERDA ASSASSINA P2ISTICA PER INTENDERCI), MEGA LAVA CASH MAFIOSO, MANDANTE DI "SUICIDATE" ED OMICIDI A RAFFICA, SEMPRE INC.LANTE BAMBINI O POCO PIU' CHE BAMBINI, DANIELE MINOTTI DI GENOVA E RAPALLO, D'ALTRONDE, I PEDOFILOMOSESSUALI O PEDOFILI IN GENERE LI AMA, SE NE SENTE STRA PARTE, LI DIFENDE. NON CI CREDETE??? VOLETE FARE GLI STRUZZI, CHE PER FRATELLANZA MASSO-N-AZIFASCISTA, PREFERISCONO METTERE LA TESTA DOVE GIRANO I VERMI, SOTTO TERRA??? GIVE A LOOK RIGHT NOW, THEN, PLS:

http://www.ansa.it/liguria/notizie/2014/06/20/adescava-minori-sul-web-condannato_36c57304-90aa-4c7f-8463-c7d610ed10dd.html

http://iltirreno.gelocal.it/massa/cronaca/2013/04/19/news/casolare-a-luci-rosse-il-pm-7-anni-e-mezzo-all-ex-dipendente-nca-1.6917147

E SE GOOGLATE " DANIELE MINOTTI PEDOPORNOGRAFIA" VEDRETE CHE IN TUTTI I SUOI ARTICOLI, SOTTILISSIMAMENTE ( E MANCO TANTO, SOTTILISSIMAMENTE) DIFENDE I PEDOFILI, MINIMIZZA O ELUDE LE LORO ABERRANTI, SPEZZA VITE, COLPE! LI SUPPORTA: OVVIO, E' UN VERME SODOMIZZA BAMBINI LUI IN PRIMO! DA RINCHIUDERE IN GALERA O MANICOMIO CRIMINALE SUBITO: AVRA' GIA' UCCISO E FATTO SCOMPARIRE QUALCHE BIMBO CHE HA INCULATO! O PRESTO LO FARA'! QUI SALVIAMO VITE DI PICCOLISSIME CREATURE CON QUESTI SCRITTI!!! SALVIAMO IL MONDO!!!
PER FINIRE, ANYWAY, ORA TORNIANO A STO, PURE TERRORISTA NERO ( ED IN NERO), COME CITATO, FREQUENTE MANDANTE DI OMICIDI, "SUICIDATE" O TERRIFICANTI ISTIGAZIONI AL SUICIDIO: DANIELE MINOTTI DI RAPALLO E GENOVA. INCITA I VERMI DI ESTREMISSIMA DESTRA COME LUI, DI TUTTO IL MONDO, I KAMERADEN KILLER DEI TEA PARTIES, AD AMMAZZARE, NELLA MERDA BASTARDAMENTE DITTATORIALE DI "RENZUSCONIA" (O OVUNQUE SIANO NEL GLOBO), CHIUNQUE CRITICHI "TROPPO" I SUO LIDER MAXIMI, E LIDER MAXIMI IN TUTTO, SPECIE IN PEDOFILIA, FASCIOCAMORRA ED ORDINI DI UCCISIONI E STRAGI: SILVIO BERLUSCONI E LICIO GELLI (CITATI NAZIMAFIOSI DEI TEA PARTIES DI CUI E' STRA PARTE, INSIEME AD ALTRO VERME BERLUSCONAZISTA E CRIMINALISSIMO: GIACOMO ZUCCO, OVVIAMENTE, PURE LUI, MEGA LAVA SOLDI DI COSA NOSTRA, CAMORRA E NDRANGHETA, SPECIE VIA BITCOINS, E PURE LUI NOTO PEDOFILOMOSESSUALE TANTO QUANTO)! CON IL QUALE CONDIVIDE PURE, UNA, DA VOMITARE ANCHE LA BILE, TESSERA DEI PEDERASTA CHE "SON ORGOGLIOSI DI FAR SESSO CON BAMBINI", QUELLA DELL'ORGOGLIO PEDOFILO, OSSIA QUELLA D.. I

"North American Man-Boy Amore Association"

https://en.wikipedia.org/wiki/North_American_Man/Boy_Love_Association

http://www.today.it/rassegna/giornata-orgoglio-pedofilo.html
STO PUTRIDISSIMO TOPO DI FOGNA DI DANIELE MINOTTI DEL FORO DI CHIAVARI ( ALTRA SDRAMMATIZZAZIONE, PLS.. CHIAVARI SI.. E' DI CERTO LA COSA PIU' BELLA AL MONDO, MA ANCHE LA PIU' BRUTTA, QUANDO LO SI FA DEPRAVATISSIMAMENTE CON I BAMBINI, COME FA SEMPRE STO ESCREMENTOSO PEDOFILOMOSESSUALE DI DANIELE MINOTTI DI RAPALLO E GENOVA) E' OVVIAMENTE PURE UN BASTARDO RAZZISTA. AUSPICA LA MORTE SOCIALE, " MA ANCHE NON SOLO.. ANCHE TOTALISSIMA" , DI CHIUNQUE NATO SOTTO LA SUA PUZZOLENTISSIMAMENTE PIDUISTICA AREZZO!
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at No comments:
Subscribe to: Posts (Atom)