problem

"undetermine command #pragma pack(1) create error and compiler dont say warning about this command"

The compiler is not obligated to provide a warning. The implementation can ignore unrecognized pragmas.

"undetermine command #pragma pack(1) create error and compiler dont say warning about this command"

The compiler is not obligated to provide a warning. The implementation can ignore unrecognized pragmas.

try example programm with #pragma pack(1)
and you will get surprise because Size <> 1 !!!
and you said ignore pragma? :-)

"try example programm with #pragma pack(1)"

Does my compiler claim to support this pragma?

"and you will get surprise because Size <> 1 !!!"

If my compiler does not support the pragma, I would not at all be surprised with that result.

"and you said ignore pragma?"

I said that if your compiler does not support that pragma, it is free to ignore it without producing a diagnostic. That's the whole point of pragmas -- to provide nonstandard implementation-specific features that other compilers are free to ignore.

ho-h0
if i wrote in program bla-bla-bla - compiler may dont say warning about bla-bla-bla?
and compiler may do what want free? because does not support bla-bla-bla ;-)
it is super compiler ;-)

"if i wrote in program bla-bla-bla - compiler may dont say warning about bla-bla-bla?"

If "bla-bla-bla" is a pragma supported by compiler #1 and not supported by compiler #2, compiler #2 can silently ignore the pragma. That's the way pragmas work as specified by the C standard, something which you might want to become more familiar with.

"bla-bla-bla not supported by compiler #2, compiler #2 can silently ignore the pragma."

KEIL compiler not support bla-bla-bla
but MOT IGNORE pragma - its generate crazy code !!!
try my example and after it we may will say about it
you dot undestand me - because didnt try my small example
if you try example you will be suprise !!!

"its generate crazy code !!!"

You have not yet posted the crazy code it generated.

"you dot undestand me - because didnt try my small example"

Your example produces no output and you didn't explain how you observed this craziness and arrived at your conclusion, so there's nothing to check.

If you are so absolutely convinced there is a compiler bug, why are you posting here instead of contacting Keil Support?

"You have not yet posted the crazy code it generated"
you may create and look code in your compiler
source C is enough

"Your example produces no output and you didn't explain how you observed this craziness and arrived at your conclusion, so there's nothing to check."

program has 4 operators
do you undestand this program? :-))))))))))
debug this programm in keil emulator - and look on variable Size !!! and you see bug

after it you may look assembler code

after it we may say something about problem :-) again

i all said ;-)

"you may create and look code in your compiler
source C is enough"

No, my compiler may be a different version than yours and produce different code. My compile options may be different than yours and produce different code.

"after it we may say something about problem "

No we won't because I'm done with your profound ignorance regarding how to present a problem for discussion or solution.

www.catb.org/.../smart-questions.html

Have you tried to print the variable Size, or have you only tried to watch it in the emulator?

If your code doesn't use Size for anything, the compiler may decide that it isn't important to make the assign.

A lot of strange things can happen if a compiler can deduce that a variable or an assign is never used.

if we have #pragma pack(1) - which must ignore and compiler must work how have no pragma
problem is what when write cmd2.packets = 1000;
this command erase cmd2.command

if we have no #pragma - we will see all OK

"No, my compiler may be a different version than yours and produce different code. My compile options may be different than yours and produce different code."
1 if you wanted - you got evalution version from keil
2 i try on few version compiler rvtc from keil
3 you say very much words - but dont said word
4 try and look - and dont say what you lower man - and try faqs again

Note one thing very important:

Two compilers can support a specific pragma, but they may define it to mean something completely different.

My question is still: Have you tried to print the variable Size?

Maybe the compiler do support #pragma pack(1) to mean exactly what you want it to mean, but are ignoring all use of the Size variable, since you haven't shown the compiler that you are really going to use it...

We can try and compile your code. However:

1) If you are wrong - we just lost time chasing ghosts.

2) If you are correct - then we can't solve your problem anyway.

3) A lot of users (expectedly all?) here already have an installed Keil compiler. Will the licensed version behave identically to the free version? What other settings do we need to care about, since you are only talking about a couple of lines of code - not a complete project...

4) Not all users here are using the same architecture or processor, so even if we do use Keil compilers, we might not have to care about this problem because it may not be applicable to our projects.

5) If there really is an error that do affect us, then the correct solution is that you send a complete project that correctly reproduces the problem to Keil support.

....................
very many words .....

programm has 4(FORE) commands
you may try or you have no KEIL COMPILER?
why did you write here if you have no keil arm compiler(RVTC) which i wrote up?
i repeat my question - YOU TRY CODE?
your answer - many many words about may be yes may be no
but program has 4(FORE) commands !!!
if you dont use keil arm(RVTC) what do you want ?
i wrote about my problem for user whith use keil arm compiler ;-)
again question ;-)
do you use keil arm compiler ?
have you problem whith my code?
have no problem - ok- i be glad for you ;-)

Conclusion: You are either not able to read (or count to four either) When seeing more than three words, you ignore it and just calls it "many words".

I don't have a problem.

Have you really verified that you have a problem?

The compiler does not need to generate a single instruction from your source code, unless you prove to it that you will use the data. What you see in the emulator may be random noise left in the processor registers...

Unless you can show that the compiler makes an incorrect conditional jump, or emits incorrect information, you don't have a case.

You have also not supplied any assembler listings showing incorrect code being generated.

"Have you really verified that you have a problem?"

Oh, he/she/it most assuredly has a problem -- the refusal to cut through all of the drivel and obfuscation by simply posting an assembly listing.