Saturday, May 19, 2018

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

"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: May 20 01:31AM +0200

On 18.05.2018 09:05, Alf P. Steinbach wrote:
 
> That solution was very complicated, using dirty template tricks.
 
> Now I'm thinking about something like the following:
> [snip originally posted code]
 
After sleeping on it + some work it's more acceptable:
 
#include <type_traits> // std::is_base_of
#include <utility> // std::(enable_if_t, move)
 
namespace cppx
{
using std::is_base_of;
 
// is_base_and_derived<B, D> == std::is_base_of_v<B, D>
template< class Base, class Derived >
constexpr bool is_base_and_derived = is_base_of<Base, Derived>::value;
}
 
// Preferably use this only in namespace `::tag`
#define CPPX_DEFINE_TAGTYPE( name ) \
using name = struct name ## _tag_struct volatile*
 
namespace cppx
{
inline namespace options
{
using std::enable_if_t;
using std::move;
 
struct Options_class_tag {};
 
template< class Value, class Key >
struct Option_value_
: virtual Options_class_tag
{
Value value;
 
Option_value_() = default;
 
Option_value_( Key, Value v )
: value( move( v ) )
{}
};
 
// Reads like `Opt{} | value_of<Blah>( 123 ) |
value_of<Gnorbl>( '@' )`.
template< class Key, class Value >
auto value_of( Value v )
-> Option_value_<Value, Key>
{ return {Key{}, move( v )}; }
 
template< class Options, class Key, class Value >
auto set_value_in( Options& o, Option_value_<Value, Key> value_of )
-> Options&
{
static_cast<Option_value_<Value, Key>&>( o ) = move(
value_of );
return o;
}
 
namespace impl
{
template< class Key, class Value >
auto value_type( Option_value_<Value, Key> const& ) -> Value;
}
 
template< class Options, class Key
, class = enable_if_t< is_base_and_derived<
Options_class_tag, Options > >
 
auto value_in( Options const& o, Key )
{
using Value = decltype( impl::value_type<Key>( o ) );
return static_cast<Option_value_<Value, Key> const&>( o
).value;
}
 

//------------------------------------------------------------------
// Syntactic sugar
 
template< class Options, class Key, class Value >
auto operator|( Options&& o, Option_value_<Value, Key> value_of )
-> Options&&
{ return move( set_value_in( o, value_of ) ); }
 
template< class Options, class Key, class Value >
auto operator|( Options& o, Option_value_<Key, Value> value_of )
-> Options
{
Options copy = o;
set_value_in( copy, value_of );
return copy;
}
 
template< class Options, class Key
, class = enable_if_t< is_base_and_derived<
Options_class_tag, Options > >
 
auto item( Key, Options const& o )
{ return value_in( o, Key{} ); }
} // namespace options
} // namespace cppx
 
namespace tag
{
CPPX_DEFINE_TAGTYPE( Position );
CPPX_DEFINE_TAGTYPE( Speed );
CPPX_DEFINE_TAGTYPE( Speed ); // Just to show that multiple
defs are OK.
} // namespace tag
 
struct Base_options
: cppx::Option_value_<int, tag::Position>
{};
 
struct Derived_options
: Base_options
, cppx::Option_value_<int, tag::Speed>
{};
 
#include <iostream>
auto main()
-> int
{
using namespace std;
using namespace tag;
using namespace cppx::options;
 
auto const o = Derived_options{} | value_of<Position>( 1 ) |
value_of<Speed>( 2 );
cout << "Position " << item( Position{}, o ) << endl;
cout << "Speed " << item( Speed{}, o ) << endl;
}
 
 
Sky89 <Sky89@sky68.com>: May 19 06:48PM -0400

Hello...
 
 
To standard or not to standard ?
 
I think you know me more today, so we have to be more smart..
 
So my question of today has come to me from the fact that
modern Object Pascal of Delphi and FreePascal that is much powerful than
pascal is not a standard like C++ or ADA. So an important question
from this fact arises: Is it so problematic to not have a standard like
this ? I think that we have to be frank and be more smart, because
i think that making a standard is a slower process and it can be an not
an efficient process, because this can be: not everything in the
standard is efficient.. so the standard in itself can be not efficient,
i give you an example so that you will understand me:
 
Look at this algorithm that is not scalable:
 
A more scalable reader/writer lock, and a bit less harsh consideration
of the idea
 
http://joeduffyblog.com/2009/02/20/a-more-scalable-readerwriter-lock-and-a-bit-less-harsh-consideration-of-the-idea/
 
 
And look at my "scalable" algorithms of my scalable RWLocks here:
 
https://sites.google.com/site/aminer68/scalable-rwlock
 
 
As you have noticed that i am using Intel and AMD CPUID by by writing
assembler on my scalable algorithms like this to get the processor number:
 
function GetCurrentProcessorNumber:long;
asm
{$IFDEF CPU32}
push ebx
mov eax, 1
CPUID
shr ebx, 24
mov eax, ebx
pop ebx
{$ENDIF CPU32}
{$IFDEF CPU64}
push rbx
mov rax, 1
cpuid
shr rbx, 24
mov rax, rbx
pop rbx
{$ENDIF CPU64}
end;
 
 
 
So as you have noticed this is not a standard way , but it is an
efficient way that makes my scalable algorithms "scalable",
so as you have noticed if i have wanted to make it standard,
i have to use for example the Thread ID "modulo" the number of cores
,
but this will make my algorithms less efficient and not scalable,
this is why i will say that making standards (like C++) is a slow
process and it can be not efficient.
 
 
This is why i love modern Object Pascal of Delphi and FreePascal,
because even if they are not standards , they can evolve
rapidly to change and for example there libraries can be implemented
efficiently, this is why i love them.
 
Also:
 
I think i will also continu to work more with Delphi and FreePascal and
Lazarus, all of them use a "modern" Object Pascal that is much more
powerful than pascal.
 
Delphi for example works on the following platforms:
 
Windows
Linux
macOS
iOS
Android
 
 
You have to look at the new Delphi here, it is very powerful:
 
https://www.embarcadero.com/products/delphi
 
 
Lazarus and FreePascal are very interesting to use, you have to look
at Lazarus here to notice it:
 
https://www.lazarus-ide.org/
 
 
What i love in Delphi and FreePascal and Lazarus is that
Delphi and FreePascal like ADA come with range checking and Run-time
checks that catch conversion from negative signed to unsigned , and
catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc. and that's good for reliability.
 
But C++ and C don't have range checking etc. so that's not good in C++
and C and that's not good for reliability and it is not good for
safety-critical systems.
 
 
This is why i will also to continu to work more with Delphi and
FreePascal and Lazarus, and my Delphi projects can be used with C++Builder.
 
Look for example at my last invention , here is my last invention for
Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
You can find my other "inventions"(that are my scalable algorithms etc.)
and my other projects here:
 
https://sites.google.com/site/aminer68/
 
Also you can improve strict-type safety(and thus reliability) in Delphi
and FreePascal with variants like this:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 19 02:09PM -0400

Hello...
 
 
I think i will also continu to work more with Delphi and FreePascal and
Lazarus, all of them use a "modern" Object Pascal that is much more
powerful than pascal.
 
Delphi for example works on the following platforms:
 
Windows
Linux
macOS
iOS
Android
 
 
You have to look at the new Delphi here, it is very powerful:
 
https://www.embarcadero.com/products/delphi
 
 
Lazarus and FreePascal are very interesting to use, you have to look
at Lazarus here to notice it:
 
https://www.lazarus-ide.org/
 
 
What i love in Delphi and FreePascal and Lazarus is that
Delphi and FreePascal like ADA come with range checking and Run-time
checks that catch conversion from negative signed to unsigned , and
catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc. and that's good for reliability.
 
But C++ and C don't have range checking etc. so that's not good in C++
and C and that's not good for reliability and it is not good for
safety-critical systems.
 
 
This is why i will also to continu to work more with Delphi and
FreePascal and Lazarus, and my Delphi projects can be used with C++Builder.
 
Look for example at my last invention , here is my last invention for
Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
You can find my other "inventions"(that are my scalable algorithms etc.)
and my other projects here:
 
https://sites.google.com/site/aminer68/
 
Also you can improve strict-type safety(and thus reliability) in Delphi
and FreePascal with variants like this:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 19 12:59PM -0400

Hello,
 
 
There is still a problem with C++ and C
 
About Escher C++ Verifier, read carefully:
 
"Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012)."
 
Read here:
 
http://www.eschertech.com/products/index.php
 
 
So it verifies just a "subset" of C, so that's not good for C++
because for other applications that are not a subset of C , it can
not do for example Run-time checks, so we are again into
this problem again, so read the following carefully:
 
I think that Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking etc. so that's not good in C++
and C because it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 19 12:37PM -0400

Hello,
 
 
I have presented you the following specialist:
 
You can carefully read him here:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
Here is there solution for C++:
 
Escher C++ Verifier
 
Escher C Verifier enables the development of formally-verifiable
software in a subset of C (based on MISRA-C 2012). It performs static
analysis on the code, checks conformance with many of the MISRA rules,
and verifies mathematically that the software is free from run-time
errors and "undefined behaviour" for all inputs.
 
Optionally, Escher C Verifier can also verify that the software meets
functional specifications.
 
 
http://www.eschertech.com/products/index.php
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 19 12:20PM -0400

Hello...
 
Yet read again, i correct..
 
I think that Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking etc. so that's not good in C++
and C because it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 19 12:17PM -0400

Hello,
 
More precision, read again..
 
I think that Delphi and FreePascal like ADA come with range checking and
Run-time checks that catch conversion from negative signed to unsigned ,
and catch out-of-bounds indices of dynamic and static arrays and catch
arithmetic overflow etc. and you can also dynamically catch this
exception of ERangeError etc.
 
But C++ and C don't have range checking, so that's not good in C++ and C
because it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 19 12:09PM -0400

Hello..
 
 
I think that Delphi and FreePascal like ADA come with range checking
that catch conversion from negative signed to unsigned , and catch
out-of-bounds indices of dynamic and static arrays etc. and you
can also dynamically catch this exception of ERangeError.
 
But C++ and C don't have range checking, so that's not good in C++ and C
because it is not good for safety-critical systems.
 
You can carefully read the following, it is very important:
 
https://critical.eschertech.com/2010/07/07/run-time-checks-are-they-worth-it/
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 10:45PM -0400

Hello...
 
 
Sorry i correct..
 
To be more precise...
 
 
C++ and Delphi and FreePascal can approximate better the safety
of Rust by using more tools, and i have given you a solution of that in
my previous posts that uses variants to emulate strict-type safety of
Rust, so from this we can affirm that the sum of mean time between
failures will become much more big using those methods, so that it can
save us more money for example.
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 10:30PM -0400

Hello,
 
 
To be more precise...
 
 
C++ and Delphi and FreePascal can approximate better the safety
of Rust by using more tools, and i have given you a solution of that in
my previous posts that uses variants to emulate strict-type safety of
Rust, so from this we can affirm that the sum of mean time between
failures will become much more small using those methods, so that it can
save us more money for example.
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 10:10PM -0400

Hello,
 
 
I think that Rust will not Win, because Rust is especially
designed for very high safety that is needed for safety-critical
systems, so it can win on safety-critical systems, but it can
not win Java and it can not win even C++ because not everyone needs this
kind of very high safety of Rust. So we can continu to program and love
Delphi and FreePascal and C++ and Java.
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 09:49PM -0400

Hello,
 
 
I think Rust is "restrictive" to be able to be more disciplined , so
that to be more reliability. This the game of Rust.
 
C++ is more "permissive" by being it more weakly typed etc.
and this is not good for reliability.
 
Rust will win, because Rust is much better for reliability and
for Safety-critical systems.
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 09:39PM -0400

Hello...
 
 
About discipline and reliability: we have to adopt Rust, Rust is
designed for discipline and reliability, C++ is less reliability than
Rust and it can not compete with Rust.
 
I think from now on, i will start also to program in Rust.
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 09:26PM -0400

Hello,
 
 
About Rust and Spark and C++
 
I think Rust and Spark "enforce" discipline with strict-type safety and
static and dynamic checks for more reliability and this is good for
Safety-critical systems
 
But C++ is more "permissive" with being it more weakly typed etc. and
this is not good for Safety-critical systems.
 
 
 
Thank you,
Amine Moulay Ramdane.
wyniijj@gmail.com: May 18 06:13PM -0700

https://sourceforge.net/projects/cscall/?source=typ_redirect
A C++ library genuinely for system programming by wrapping commonly
used system calls and C library functions into forms appropriate in
C++ context for system programming. The API is designed fool-proof,
application normally just use it mechanically, not many rule/names
invented to remember.
 
Download and uncompress file libwy-0.54.tgz, type make, make install,
easier to see manpage documents. Latter, you can 'make uninstall' if
you don't like it.
I had only tested on Fedora 28 (g++ 8.1.1). Many people knows I don't
use C++ standard library, this is the answer 'why', because I can do
more and spend less (time/resource). Suggestions/opinons are welcome.
Sky89 <Sky89@sky68.com>: May 18 09:05PM -0400

Hello,
 
 
I wrote before this:
 
Also read this about Software reliability:
 
"Both Rust and Spark languages implement a number of static and dynamic
checks directly in the language definition. For example, they implement
strict-type safety; that is, objects can't be implicitly converted from
one type to the next. The following doesn't compile in SPARK"
 
 
Read more here:
 
http://www.electronicdesign.com/industrial/rust-and-spark-software-reliability-everyone
 
 
I think C++Builder has a good implementation of variants that allows
you to "emulate" much better strict-type safety of Rust and Spark,
i have looked to Boost variants and i think it is less powerful
than the one in C++Builder, here is how you have to extend
type-safety, you realize this solution with objects that contains
variants that represent different types and the functions that work with
them like Add and Multiply and Divide etc, here is the solution
for FreePascal and Delphi and C++Builder and you can extend
it, so i think FreePascal and Delphi and C++Builder are now acceptable
for more reliability:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Melzzzzz <Melzzzzz@zzzzz.com>: May 18 11:30PM

>> systems where overcommit and copy-on-write are common,
 
> Sensible Unix systems do not use over-commit, it is a Linux specific
> abomination.
 
Linux overcommit is enabled by default in distros. It can be disabled no
problem.
It's because some programs do lot of forking, and of course some VMs/GCs
allocate even TB of RAM ;)
 
 
--
press any key to continue or any other to quit...
Vir Campestris <vir.campestris@invalid.invalid>: May 18 10:08PM +0100

> Really? How do you think all the various GUI events were run in the background
> then while your application ran its main thread? Or do you remember having
> to - for example - explicitely program the cursor to flash in a text box?
 
By queuing events to be handled by the main event loop.
 
Andy
Sky89 <Sky89@sky68.com>: May 18 08:30PM -0400

Hello..
 
 
Read again, i correct some typos because i write fast:
 
We have to be more smart about C++
 
I think that C++ as it is, is not well suited for realtime systems
and realtime critical systems.. you have to add over it
Extended static checking (ESC) etc. so that C++ be acceptable
or here is one of my other solution to the problem that i have
talked about: As you have noticed i have spoken before about the how to
disallow conversion from negative signed to positive unsigned, here is
my solution with variants, also you can extend this solution with
objects that contains variants that represent different types and the
functions that work with them like Add and Multiply and Divide etc :
 
 
Here is the solution that works also with C++Builder , since
C++Builder has a good implementation of variants
 
As you know i am working with Delphi and FreePascal and C++..
 
And now about Software Reliability:
 
Extended static checking (ESC) can identify a range of errors which are
currently outside the scope of a type checker, including division by
zero, array out of bounds, integer overflow and null dereferences,
this can be done with Delphi and FreePascal compilers.
 
Furthermore, extended static checking aims to report errors by
exploiting user-supplied specifications, in the form of pre- and
post-conditions, loop invariants and class invariants, this can
be done by assertions in Delphi and FreePascal.
 
Read more here:
 
http://whiley.org/2010/06/26/what-is-extended-static-checking/
 
 
Also read this about Software reliability:
 
"Both Rust and Spark languages implement a number of static and dynamic
checks directly in the language definition. For example, they implement
strict-type safety; that is, objects can't be implicitly converted from
one type to the next. The following doesn't compile in SPARK"
 
 
Read more here:
 
http://www.electronicdesign.com/industrial/rust-and-spark-software-reliability-everyone
 
 
Here is how you can have strict-type safety in Delphi and FreePascal,
here is a Delphi program that shows an example using variants:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 08:21PM -0400

Hello...
 
 
We have to be more smart about C++
 
I think that C++ as it is, is not well suited for realtime systems
and realtime critical systems.. you have to add over it
Extended static checking (ESC) etc. so that C++ be acceptable
or here is one of my other solution to the problem that i have
talked about: As you have noticed i have spoken before about the how to
disallow conversion from negative signed to positive unsigned, here is
my solution with variants, also you can extend this solution with
objects contains variants that represent different types and the
functions that works with them like Add and Multiply and Divide etc :
 
 
Here is the solution that works also with C++Builder , since
C++Builder has a good implementation of variants
 
As you know i am working with Delphi and FreePascal and C++..
 
And now about Software Reliability:
 
Extended static checking (ESC) can identify a range of errors which are
currently outside the scope of a type checker, including division by
zero, array out of bounds, integer overflow and null dereferences,
this can be done with Delphi and FreePascal compilers.
 
Furthermore, extended static checking aims to report errors by
exploiting user-supplied specifications, in the form of pre- and
post-conditions, loop invariants and class invariants, this can
be done by assertions in Delphi and FreePascal.
 
Read more here:
 
http://whiley.org/2010/06/26/what-is-extended-static-checking/
 
 
Also read this about Software reliability:
 
"Both Rust and Spark languages implement a number of static and dynamic
checks directly in the language definition. For example, they implement
strict-type safety; that is, objects can't be implicitly converted from
one type to the next. The following doesn't compile in SPARK"
 
 
Read more here:
 
http://www.electronicdesign.com/industrial/rust-and-spark-software-reliability-everyone
 
 
 
Here is how you can have strict-type safety in Delphi and FreePascal,
here is a Delphi program that shows an example using variants:
 
--
 
program test;
 
uses VARIANTS,SYSUTILS;
 
var f:double;
a:integer;
 
 
 
FUNCTION ASSIGN(a,B:VARIANT):VARIANT;
 
begin
 
IF VARTYPE(A)=VARTYPE(B) THEN
BEGIN
A:=B;
RESULT:=A;
END
ELSE RAISE EXCEPTION.CREATE('ASSIGNEMENT NOT OK');
 
 
end;
 
begin
 
a:=2;
 
f:=a;
 
A:=ASSIGN(F,A);
 
 
end.
--
 
 
Here is the Vartype function:
 
http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/Variants_VarType.html
 
 
 
 
 
Thank you,
Amine Moulay Ramdane.
Sky89 <Sky89@sky68.com>: May 18 06:33PM -0400

Hello...
 
 
I think you know me more today, i program in Delphi and FreePascal, and
in FreePascal i program in the Delphi "mode" too, so as you have noticed
i am not programming in pascal, i am programming in "modern" Object
Pascal that is "much" more powerful than pascal, this is why i love
Delphi and FreePascal and Lazarus too that uses FreePascal, and as you
have noticed i have made Delphi and FreePascal better by for example
inventing "scalable" algorithms and implementing them in Delphi and
FreePascal, and as you have noticed my work is a more serious work,
and to notice it please look for example at my last invention in Delphi
and FreePascal here:
 
Here is my last invention for Delphi and FreePascal:
 
Scalable reference counting with efficient support for weak references
 
https://sites.google.com/site/aminer68/scalable-reference-counting-with-efficient-support-for-weak-references
 
As you have noticed my inventions that are my scalable algorithms have
enhanced much more Delphi and FreePascal, this is why i am here to make
Delphi and FreePascal better, i don't like C++ or C, because as
i have explained in my previous posts, they are too weakly typed,
they are not like modern Object Pascal of Delphi and FreePascal that
is more strongly typed than C++ or C , that means it is more safer in
this matter, and since ADA looks a lot like Delphi and FreePascal,
so i think i will port some of my projects to ADA, because i have
looked at ADA and ADA is easy for me.
 
 
You will find my others inventions(that are my scalable algorithms
implementations) and my other software projects here:
 
https://sites.google.com/site/aminer68/
 
 
Thank you,
Amine Moulay Ramdane.
Chris Vine <chris@cvine--nospam--.freeserve.co.uk>: May 18 11:40PM +0100

On Fri, 18 May 2018 18:33:52 -0400
Sky89 <Sky89@sky68.com> wrote:
[snip]
... i don't like C++ or C, because as i have explained in my previous
> posts, they are too weakly typed, they are not like modern Object Pascal
> of Delphi and FreePascal that is more strongly typed than C++ or C
 
That's great, because it means you can go away. So go away.
 
In case you missed the point, go away. Your posts are ridiculous.
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:

Post a Comment

Subscribe to: Post Comments (Atom)