473,324 Members | 2,178 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,324 software developers and data experts.

Code problem

I posted this to comp.std.c, but may be of interest here too:

Consider this:

extern void abort(void);
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;

*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.
I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.

Apparently gcc disagrees.

Am I doing something wrong somewhere?

I should first cast into a long long THEN into an unsigned
long long?

Thanks for your help.

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Dec 6 '07 #1
19 2181
jacob navia <ja***@nospam.comwrites:
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
Why the cast? It should be unnecessary.
*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.
unsigned long long has to be at least 64 bits in size.
18446744073709551613 is the minimum correct value for *x here.
I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.
I don't see any cast to unsigned int in the above program.
--
Ben Pfaff
http://benpfaff.org
Dec 6 '07 #2
jacob navia said:
I posted this to comp.std.c, but may be of interest here too:

Consider this:

extern void abort(void);
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
Remove the unnecessary cast:

unsigned long long *x = &xx;
>
*x = -3;
See 6.2.5(9).
*x = *x * *x;
if (*x != 9)
abort ();
It is deeply unlikely that *x will be 9 at this point.
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.
That's a bug in lcc-win. *x must have the value ULLONG_MAX - 2, and since
ULLONG_MAX must be at least 18446744073709551615, *x must be at least
18446744073709551613.
I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.
Why?
Apparently gcc disagrees.

Am I doing something wrong somewhere?
Yes. If your article is an accurate description of lcc-win's behaviour,
your mistake is in using a non-conforming compiler.
I should first cast into a long long THEN into an unsigned
long long?
No, there is almost certainly no need to cast anything at all. The first
step is to identify the problem you are trying to solve, which is far from
clear. If you want to know the result of multiplying -3 by -3, why use an
unsigned type in the first place?

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999
Dec 6 '07 #3
jacob navia wrote:
I posted this to comp.std.c, but may be of interest here too:

Consider this:

extern void abort(void);
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;

*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.
The minimum value for ULLONG_MAX is 18446744073709551615, so you
should be getting a value of at least 18446744073709551613
I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.
Why did you do that?
Apparently gcc disagrees.

Am I doing something wrong somewhere?
Yes.
I should first cast into a long long THEN into an unsigned
long long?
Why do you think that? Why are you using intermediaries?

You should be converting -3 directly to unsigned long long. You should
neither detour through unsigned int, nor detour through long long. The
result should be ULLONG_MAX+1-3.
Dec 6 '07 #4
Richard Heathfield <rj*@see.sig.invalidwrites:
jacob navia said:
> unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();

It is deeply unlikely that *x will be 9 at this point.
2**64 - 3 == 18446744073709551613
(18446744073709551613)**2 = 340282366920938463352694142989510901769
340282366920938463352694142989510901769 % 2**64 = 9

At least according to the calculator I have here.
--
int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv wxyz.\
\n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}
Dec 6 '07 #5
jacob navia wrote:
I posted this to comp.std.c, but may be of interest here too:

Consider this:

extern void abort(void);
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
What is the cast for? (Hint: What is the type of
the expression `&xx'?)
*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
That cannot possibly be correct. ULLONG_MAX is at
least 18446744073709551615, so ULLONG_MAX-2 (the required
result) is at least 18446744073709551614.
since x points to an UNSIGNED long long.
I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.
That would be correct iff ULLONG_MAX==ULONG_MAX.

Imagine converting a signed char to an unsigned long
by the analogous route. Let's assume an 8-bit char, a
16-bit int, and a 32-bit long (and because there's no
way to write a literal of type char, I'll need to use
a variable instead):

signed char sc = -3;
unsigned long ul = sc;

The procedure you've outlined would convert sc to an
unsigned int, getting 65533u, and then convert that value
to unsigned long, yielding 65533ul. Yet the correct
result is ULONG_MAX-2 == 4294967293. The intermediate
conversion has lost sign information that affects the
ultimate result.
Apparently gcc disagrees.

Am I doing something wrong somewhere?

I should first cast into a long long THEN into an unsigned
long long?
You should convert the signed int to unsigned long long
by adding or subtracting ULLONG_MAX+1 the appropriate number
of times: in this case, by adding it once.

--
Er*********@sun.com
Dec 6 '07 #6
Ben Pfaff wrote:
jacob navia <ja***@nospam.comwrites:
>int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;

Why the cast? It should be unnecessary.
> *x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.

unsigned long long has to be at least 64 bits in size.
18446744073709551613 is the minimum correct value for *x here.
>I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.

I don't see any cast to unsigned int in the above program.
Of course not. The casts were the result of loading a 32 bit constant
and extending it to a 64 bit constant in assembly.

I was missing the sign extend in the process.

Conceptually however, what is
(unsigned)-3

???

supposing sizeof(int)=4
sizeof(long long)=8

-3 is 4294967293

When you write "-3" that is a signed integer constant, in my system
32 bits, i.e. the above number.

When I do a sign extend, then it works
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Dec 6 '07 #7
Ben Pfaff wrote:
Richard Heathfield <rj*@see.sig.invalidwrites:
>jacob navia said:
>> unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
It is deeply unlikely that *x will be 9 at this point.

2**64 - 3 == 18446744073709551613
(18446744073709551613)**2 = 340282366920938463352694142989510901769
340282366920938463352694142989510901769 % 2**64 = 9

At least according to the calculator I have here.
Yes, it should be 9. I was missing a sign extend when
converting a signed int into an unsigned long long.

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Dec 6 '07 #8
ja*********@verizon.net wrote:
jacob navia wrote:
>I posted this to comp.std.c, but may be of interest here too:

Consider this:

extern void abort(void);
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;

*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.

The minimum value for ULLONG_MAX is 18446744073709551615, so you
should be getting a value of at least 18446744073709551613
>I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.

Why did you do that?
>Apparently gcc disagrees.

Am I doing something wrong somewhere?

Yes.
>I should first cast into a long long THEN into an unsigned
long long?

Why do you think that? Why are you using intermediaries?

You should be converting -3 directly to unsigned long long. You should
neither detour through unsigned int, nor detour through long long. The
result should be ULLONG_MAX+1-3.
Yes, I was missing a sign extend.

But the abstract problem is still not clear to me. I mean when I see
a number like

-3

unadorned this is a signed integer constant. Since I am assigning it to
an unsigned value, I reinterpret the bits as an unsigned (this is my
mistake probably) and then convert THAT into an unsigned long long.
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Dec 6 '07 #9
Richard Heathfield wrote:
>Am I doing something wrong somewhere?

Yes. If your article is an accurate description of lcc-win's behaviour,
your mistake is in using a non-conforming compiler.
????

Bugs are non conforming by definition...

:()

>I should first cast into a long long THEN into an unsigned
long long?

No, there is almost certainly no need to cast anything at all. The first
step is to identify the problem you are trying to solve, which is far from
clear. If you want to know the result of multiplying -3 by -3, why use an
unsigned type in the first place?
Because that is part of a bigger program that I got
and I isolated (after some hours of debugging) the code
that exposes the bug in my software! (lcc-win)

I assure you that I know the multiplication tables, but thanks
for the answer anyway.

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Dec 6 '07 #10
Ben Pfaff said:
Richard Heathfield <rj*@see.sig.invalidwrites:
>It is deeply unlikely that *x will be 9 at this point.

2**64 - 3 == 18446744073709551613
(18446744073709551613)**2 = 340282366920938463352694142989510901769
340282366920938463352694142989510901769 % 2**64 = 9
I did the math before posting, and removed an entire paragraph about this
(further down the article), but evidently I omitted to remove the above
sentence. Oops, sorry etc.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999
Dec 6 '07 #11
Eric Sosman said:
ULLONG_MAX is at
least 18446744073709551615, so ULLONG_MAX-2 (the required
result) is at least 18446744073709551614.
ITYM 18446744073709551613

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999
Dec 6 '07 #12
In article <fj**********@aioe.org>, jacob navia <ja***@nospam.orgwrote:
>> unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;

*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
Is there supposed to be any significance to using *x instead of xx?
The types of *x and xx are the same, so the same conversions should
apply.
>But the abstract problem is still not clear to me. I mean when I see
a number like

-3

unadorned this is a signed integer constant.
Strictly speaking, there are no negative integer constants. The syntax
for integer constants doesn't allow minus signs. It's a constant
expression of type int (the result of applying unary minus to the
integer constant 3).
>Since I am assigning it to
an unsigned value, I reinterpret the bits as an unsigned (this is my
mistake probably) and then convert THAT into an unsigned long long.
Yes, this is your mistake. You have an int that you are assigning to
an unsigned long long, so you should do that conversion in a single
step.

The final answer will be 9 as your code implies, since the result of
the conversion will be equal to -3 (mod N), where log2(N) is the
number of bits in an unsigned long long, and if

a = A (mod N) and b = B (mod N)
then
a*b = A*B (mod N)

-- Richard
--
:wq
Dec 6 '07 #13
In article <fj**********@aioe.org>, jacob navia <ja***@nospam.orgwrote:
>Bugs are non conforming by definition...
Not necessarily - a bug in code that implements undefined behaviour
just results in some other undefined behaviour, which is equally
conformant :-)

-- Richard
--
:wq
Dec 6 '07 #14
Richard Heathfield wrote:
Eric Sosman said:
>ULLONG_MAX is at
least 18446744073709551615, so ULLONG_MAX-2 (the required
result) is at least 18446744073709551614.

ITYM 18446744073709551613
YTC.

--
Eric Sosman
es*****@ieee-dot-org.invalid
Dec 7 '07 #15
jacob navia wrote:
[...]
But the abstract problem is still not clear to me. I mean when I see
a number like

-3

unadorned this is a signed integer constant. Since I am assigning it to
an unsigned value, I reinterpret the bits as an unsigned (this is my
mistake probably) and then convert THAT into an unsigned long long.
Yes, that's the error. Conversion from one type to another
involves the *value* being converted, not its representation.
As a related example consider

signed char sc = -1;
int a = sc;
unsigned int b = sc;

In neither case will "reinterpret the bits and then convert"
produce the correct answer. What you're doing is more akin to

unsigned int c = (unsigned char)sc;

--
Eric Sosman
es*****@ieee-dot-org.invalid
Dec 7 '07 #16
On Thu, 06 Dec 2007 23:09:24 +0100, jacob navia <ja***@nospam.com>
wrote in comp.lang.c:
I posted this to comp.std.c, but may be of interest here too:

Consider this:

extern void abort(void);
int main (void)
{
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;

*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
return(0);
}

lcc-win interprets
*x = -3;
as
*x = 4294967293;
since x points to an UNSIGNED long long.
I cast the 32 bit integer -3 into an unsigned integer
then I cast the result to an unsigned long long.

Apparently gcc disagrees.

Am I doing something wrong somewhere?
Yes, I believe you are.

The C standard's wording on initializing scalars (6.7.8 P11) states:

"The initializer for a scalar shall be a single expression, optionally
enclosed in braces. The initial value of the object is that of the
expression (after conversion); the same type constraints and
conversions as for simple assignment apply, taking the type of the
scalar to be the unqualified version of its declared type."

Referring to "Simple assignment" 6.5.26.2 P2:

"In simple assignment (=), the value of the right operand is converted
to the type of the assignment expression and replaces the value stored
in the object designated by the left operand."

Putting these together, the integer constant expression -3, of type
int, is converted to type unsigned long long. There are no
intermediate conversions specified or implied to unsigned int or
signed long long. Your compiler might take these intermediate steps,
under the as-if rule, but only if you produce the same results as a
direct conversion.

And the correct result is (ULLONG_MAX + 1) - 3;
I should first cast into a long long THEN into an unsigned
long long?
No, I think not. What would the result be if you had written either
of these:

*x = -3ULL;

....or:

*x = (unsigned long long)3;

I think you are getting hung up on the details of how you code the
conversion in your compiler, and losing sight of the meaning of the
expression in the language.

The conversion, like all such in C, is defined in terms of value, not
of steps or types to achieve it.

As a practical matter, I suspect the simplest method to get the
correct result would be to convert the signed int constant to signed
long long, then to unsigned long long.

Note the following program, and its output when run in VS 2005
Express, which does not support much of C99 but does support the long
long types:

#include <stdlib.h>
#include <stdio.h>

int main(void)
{
unsigned long long x = (unsigned int)-3;
unsigned long long y = (unsigned long long)-3;
unsigned long long z = -3;
unsigned long long a = (long long)-3;
printf("x = %llu\ny = %llu\nz = %llu\na = %llu\n",
x, y, z, a);
return 0;
}

Output:

x = 4294967293
y = 18446744073709551613
z = 18446744073709551613
a = 18446744073709551613

So I suspect your compiler will generate the proper value using the
signed int to signed long long to unsigned long long series of
conversions.
Thanks for your help.
You're welcome.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html
Dec 7 '07 #17
On Dec 7, 4:02 am, Ben Pfaff <b...@cs.stanford.eduwrote:
Richard Heathfield <r...@see.sig.invalidwrites:
jacob navia said:
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
It is deeply unlikely that *x will be 9 at this point.

2**64 - 3 == 18446744073709551613
(18446744073709551613)**2 = 340282366920938463352694142989510901769
340282366920938463352694142989510901769 % 2**64 = 9

At least according to the calculator I have here.

I beg your pardon for asking basic question in the flow of high level
technical discussion .I am sorry if it break the flow of the
discussion .

My doubt is about the following lines and the result.

1) *x = -3;
2) *x = *x * *x;

After executing line 1) *x will be equal to at least
18446744073709551613.
And after executing line 2)
*x is 3. But my doubt is how it is possible?

My doubt is while executing *x * *x is *x again converted to 3 ?
That's why 3 * 3 is 9? If yes why it is required?
Because now *x is not negative so it is not required to be converted
to unsigned.


Dec 7 '07 #18
somenath wrote:
On Dec 7, 4:02 am, Ben Pfaff <b...@cs.stanford.eduwrote:
>Richard Heathfield <r...@see.sig.invalidwrites:
>>jacob navia said:
unsigned long long xx;
unsigned long long *x = (unsigned long long *) &xx;
*x = -3;
*x = *x * *x;
if (*x != 9)
abort ();
It is deeply unlikely that *x will be 9 at this point.
Actually, it's guaranteed to be 9.
>2**64 - 3 == 18446744073709551613
(18446744073709551613)**2 = 340282366920938463352694142989510901769
340282366920938463352694142989510901769 % 2**64 = 9

At least according to the calculator I have here.


I beg your pardon for asking basic question in the flow of high level
technical discussion .I am sorry if it break the flow of the
discussion .

My doubt is about the following lines and the result.

1) *x = -3;
2) *x = *x * *x;

After executing line 1) *x will be equal to at least
18446744073709551613.
And after executing line 2)
*x is 3. But my doubt is how it is possible?
*x isn't 3 at that point. It should be 9.
My doubt is while executing *x * *x is *x again converted to 3 ?
That's why 3 * 3 is 9? If yes why it is required?
No. It's a little more interesting than that. All of the following
expressions are intended to be interpreted mathematically, rather than
as C expressions that could (and would) overflow. The value that should
be stored in *x in step 1 is obtained by adding ULLONG_MAX + 1 to -3 as
many times as are needed to generate a value between 0 an ULLONG_MAX,
inclusive. In this case, it only has to be added one time:

ULLONG_MAX + 1 - 3

Now, let's calculate the mathematical value of the square of that value:

(ULLONG_MAX + 1)^2 -2*3*(ULLONG_MAX + 1) + 9

= (ULLONG_MAX - 5)*(ULLONG_MAX + 1) + 9

The value that is actually stored in *x by step 2 is obtained from that
mathematical value by (conceptually) subtracting ULLONG_MAX + 1 as many
times as needed until the result is between 0 and ULLONG_MAX, inclusive.
I hope it's clear that it needs to be subtracted exactly ULLONG_MAX-5
times, giving a result of 9. This isn't a coincidence, but a normal
consequence of modulus arithmetic. In reality, of course, no
subtractions are actually carried out; the required result is obtained
naturally as a result of properly implemented unsigned multiplication.
The explanation given above can be generalized to prove that

((a mod c) * (b mod c)) mod c = (a*b) mod c

(I hope I got the modulus notation right - it's been nearly three
decades since I last used it)
In this case, a and b are -3, and c is ULLONG_MAX + 1
Dec 7 '07 #19
James Kuyper said:
>>Richard Heathfield <r...@see.sig.invalidwrites:
It is deeply unlikely that *x will be 9 at this point.

Actually, it's guaranteed to be 9.
I was in error to leave that sentence in my article after discovering that
it was incorrect. (I wrote an entire paragraph proving that it would not
be 9, but I ended up proving otherwise, so I deleted the paragraph
completely, but the above sentence survived, alas.)

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999
Dec 7 '07 #20

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

51
by: Mudge | last post by:
Please, someone, tell me why OO in PHP is better than procedural.
242
by: James Cameron | last post by:
Hi I'm developing a program and the client is worried about future reuse of the code. Say 5, 10, 15 years down the road. This will be a major factor in selecting the development language. Any...
53
by: Cardman | last post by:
Greetings, I am trying to solve a problem that has been inflicting my self created Order Forms for a long time, where the problem is that as I cannot reproduce this error myself, then it is...
67
by: Steven T. Hatton | last post by:
Some people have suggested the desire for code completion and refined edit-time error detection are an indication of incompetence on the part of the programmer who wants such features. ...
8
by: Paul Cochrane | last post by:
Hi all, I've got an application that I'm writing that autogenerates python code which I then execute with exec(). I know that this is not the best way to run things, and I'm not 100% sure as to...
8
by: Steve Jorgensen | last post by:
Hi folks, I'm posting this message because it's an issue I come up against relatively often, but I can't find any writings on the subject, and I haven't been able to figure out even what key...
2
by: Praveen K | last post by:
I have a problem in communicating between the C# and the Excel Interop objects. The problem is something as described below. I use Microsoft Office-XP PIA dll’s as these dll’s were been...
6
by: TPJ | last post by:
Help me please, because I really don't get it. I think it's some stupid mistake I make, but I just can't find it. I have been thinking about it for three days so far and I still haven't found any...
16
by: Rex | last post by:
Hi All - I have a question that I think MIGHT be of interest to a number of us developers. I am somewhat new to VIsual Studio 2005 but not new to VB. I am looking for ideas about quick and...
8
by: Andy B | last post by:
Before I do a no no on a newsgroup, I need to ask a question: What is the max number of lines of code you can/should post here before it gets too long?
0
by: DolphinDB | last post by:
Tired of spending countless mintues downsampling your data? Look no further! In this article, you’ll learn how to efficiently downsample 6.48 billion high-frequency records to 61 million...
0
by: ryjfgjl | last post by:
ExcelToDatabase: batch import excel into database automatically...
0
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
1
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
1
by: PapaRatzi | last post by:
Hello, I am teaching myself MS Access forms design and Visual Basic. I've created a table to capture a list of Top 30 singles and forms to capture new entries. The final step is a form (unbound)...
1
by: CloudSolutions | last post by:
Introduction: For many beginners and individual users, requiring a credit card and email registration may pose a barrier when starting to use cloud servers. However, some cloud server providers now...
1
by: Defcon1945 | last post by:
I'm trying to learn Python using Pycharm but import shutil doesn't work
0
by: af34tf | last post by:
Hi Guys, I have a domain whose name is BytesLimited.com, and I want to sell it. Does anyone know about platforms that allow me to list my domain in auction for free. Thank you
0
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 3 Apr 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome former...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.