Printable View
i'm writing an application for smart card and when i compiled the program i got this error message:
enc1.c(147): error E8000: arguments to _code can only be locals, arguments, globals, or integer constants
can someone please guide me through this..i'm running out of time.
So... no code, then?
the line where the error occur is like this:
CLkeysat-1 = length of block to be checksumCode:CHECKSUM(CLkeysat -1, apdu_group1.keyin, apdu_group1.S);
apdu_group1.keyin = pointer to the block to be cheksum.
apdu_group1.S = address of an unsign long that will be assigned the checksum.
the definition part :
Code:#pragma melpublic
//unsigned char publicData[136];
union {
apdu_data pData;
apdu_data2 pData2;
unsigned char pEncdata[16];
unsigned char pkeysat[CLkeysat];
unsigned int pKira1[1];
unsigned int pKira2[1];
//---baru----
unsigned long *S;
//unsigned char ceksum;
unsigned char keyin[CLkeysat-1];
//-----------
} apdu_group1;
Do you have a prototype of the CHECKSUM function?
the prototype is like this
i have include the multosarith.hCode:CHECKSUM(SIZE, BLOCK, SUM)
A macro? Ewww... use a function.
No... no buts.... use a function. I don't know much about macros, but it wouldn't suprise me if it didn't take pointers. Hence, why your argument is invalid. Also, consider that the error could be somewhere in the macro itself, it's just pointing you to the line of the call, but that is getting replaced by the entire macro prior compile time.
Long story short... use a function. It will make debugging much easier.
oooo..ok..i'll try..
Long story short... learn about macros. If you don't know about something, you can't really give advice regarding it.Quote:
Originally Posted by SlyMaelstrom
A macro is simple compile-time text replacement. That's all. Macros don't check type, because they don't care. They can "take pointers" or whatever you feel like passing to them. (Or nothing for that matter.)
All they are is text replacement.
Quzah.
so can u help me with the error?
Yes, fine, but I wasn't really sure of the fundementals of how they worked. For instance if you have a macroQuote:
Originally Posted by quzah
Which is why I wasn't sure if addresses were cool with macros. I guess they don't check what it is at all regardless of how bad the result can be. I guess in the end, it wouldn't make much of a difference. I shouldn't have jumped to a conclusion, there.Code:#define mult(x,y) x * y
/* Assume foo and
bar are defined as ints
with values 5 and 3, respectively
*/
/* ...and the macro is called as */
int ans = mult(foo,bar);
// When it's replaced with the macro code is the replacement:
// int ans = foo * bar;
// or is it
// int ans = 5 * 3;
EDIT: Hmm... got curious and tested in on GCC. It seemed to replace it withI guess that's expect as there is no reason for the preprocessor to resolve the values of the variables. So that answers that... should have been thinking. I wasn't.Code:int ans = foo * bar;
Paste the expansion of your CHECKSUM macro, from your header file.
is this it?
Code:/* SmartDeck arbitrary sized number support.
Copyright (c) 2001 Aspects Software Ltd.
*/
#ifndef __multosarith_H
#define __multosarith_H
#include <melasm.h>
/* support for N byte block arithmetic */
#define BLOCKCAST(N) *(struct { unsigned char __x[N]; }*)
/* OP N block at RHS to block at LHS */
#define ASSIGN_BINARY_OPN(N, OP, LHS, RHS) \
__push(BLOCKCAST(N)(__typechk(unsigned char *, RHS))); \
__code(OP, __typechk(unsigned char *, LHS), N); \
__code(POPN, N)
/* OP N blocks at OP1 and OP2 and store in SUM */
#define BINARY_OPN(N, OP, SUM, OP1, OP2) \
do { \
__push(BLOCKCAST(N)(__typechk(unsigned char *, OP1))); \
__push(BLOCKCAST(N)(__typechk(unsigned char *, OP2))); \
__code(OP, N); \
__code(POPN, N); \
__code(STORE, __typechk(unsigned char *, SUM), N); \
} while (0)
/* OP N block */
#define UNARY_OPN(N, OP, V) \
__code(OP, V, N);
#define ASSIGN_ADDN(N, LHS, RHS) ASSIGN_BINARY_OPN(N, ADDN, LHS, RHS)
#define ADDN(N, SUM, OP1, OP2) BINARY_OPN(N, ADDN, SUM, OP1, OP2)
#define ASSIGN_ANDN(N, LHS, RHS) ASSIGN_BINARY_OPN(N, ANDN, LHS, RHS)
#define ANDN(N, SUM, OP1, OP2) BINARY_OPN(N, ANDN, SUM, OP1, OP2)
#define ASSIGN_ORN(N, LHS, RHS) ASSIGN_BINARY_OPN(N, ORN, LHS, RHS)
#define ORN(N, SUM, OP1, OP2) BINARY_OPN(N, ORN, SUM, OP1, OP2)
#define ASSIGN_SUBN(N, LHS, RHS) ASSIGN_BINARY_OPN(N, SUBN, LHS, RHS)
#define SUBN(N, SUM, OP1, OP2) BINARY_OPN(N, SUBN, SUM, OP1, OP2)
#define ASSIGN_XORN(N, LHS, RHS) ASSIGN_BINARY_OPN(N, XORN, LHS, RHS)
#define XORN(N, SUM, OP1, OP2) BINARY_OPN(N, XORN, SUM, OP1, OP2)
#define CLEARN(N, V) UNARY_OPN(N, CLEARN, V)
#define INCN(N, V) UNARY_OPN(N, INCN, V)
#define DECN(N, V) UNARY_OPN(N, DECN, V);
#define NOTN(N, V) UNARY_OPN(N, NOTN, V);
#define TESTN(N, V) UNARY_OPN(N, TESTN, V);
/* Truncating assignment multiplication - note carry flag will NOT be set */
#define ASSIGN_MULN(N, LHS, RHS) \
do { \
__push(BLOCKCAST(N)(__typechk(unsigned char *, LHS))); \
__push(BLOCKCAST(N)(__typechk(unsigned char *, RHS))); \
__code(PRIM, 0x10, N); \
__code(STORE, LHS, N); \
__code(POPN, N); \
} while (0)
/* N byte multiplication product must be 2 * N sized */
#define MULN(N, PRODUCT, OP1, OP2) \
do { \
__push(BLOCKCAST(N)(__typechk(unsigned char *, OP1))); \
__push(BLOCKCAST(N)(__typechk(unsigned char *, OP2))); \
__code(PRIM, 0x10, N); \
__code(STORE, __typechk(unsigned char *, PRODUCT), N*2); \
} while (0)
/* N byte division QUOTIENT = NUMERATOR / DEMONIMATOR, REMAINDER = NUMERATOR % DENOMINATOR */
#define DIVN(N, NUMERATOR, DENOMINATOR, QUOTIENT, REMAINDER) \
do { \
__push(BLOCKCAST(N)(__typechk(unsigned char *, NUMERATOR))); \
__push(BLOCKCAST(N)(__typechk(unsigned char *, DENOMINATOR))); \
__code(PRIM, 0x08, N); \
__code(STORE, __typechk(unsigned char *, REMAINDER), N); \
__code(STORE, __typechk(unsigned char *, QUOTIENT), N); \
} while (0)
/* assignment division - quotient replaces numerator and remainder replaces denomator */
#define ASSIGN_DIVN(N, NUMERATOR, DENOMINATOR) \
DIVN(N, NUMERATOR, DENOMINATOR, NUMERATOR, DENOMINATOR)
/* RES = DATA << NUMBITS */
#define SHLN(N, DATA, NUMBITS, RES) \
do { \
__push(BLOCKCAST(N)(__typechk(unsigned char *, DATA))); \
__code(PRIM, 0x02, N, NUMBITS); \
__code(STORE, __typechk(unsigned char *, RES), N); \
} while (0)
/* DATA <<= NUMBITS */
#define ASSIGN_SHLN(N, DATA, NUMBITS) \
SHLN(N, DATA, NUMBITS, DATA)
/* RES = DATA >> NUMBITS */
#define SHRN(N, DATA, NUMBITS, RES) \
do { \
__push(BLOCKCAST(N)(__typechk(unsigned char *, DATA))); \
__code(PRIM, 0x03, N, NUMBITS); \
__code(STORE, __typechk(unsigned char *, RES), N); \
} while (0)
/* DATA >>= NUMBITS */
#define ASSIGN_SHRN(N, DATA, NUMBITS) \
SHRN(N, DATA, NUMBITS, DATA)
#define CMPN(N, OP1, OP2) memcmp(OP1, OP2, N)
/* N byte copy */
#define COPYN(N, DEST, SRC) \
do { \
__push(__typechk(unsigned char *, DEST)); \
__push(__typechk(unsigned char *, SRC)); \
__code(PRIM, 0x0e, N); \
} while (0)
#define CHECKSUM(SIZE, BLOCK, SUM) \
do { \
__push(__typechk(unsigned int, SIZE)); \
__push(__typechk(unsigned char *, BLOCK)); \
__code(PRIM, 0x82); \
__code(STORE, __typechk(unsigned long *, SUM), 4); \
} while (0)
#endif
And what are the definitions of __code and PRIM?
...I'm having this feeling that you'll need to contact whoever wrote the code and ask them about it. Maybe look for code documentation. Probably someone intended CHECKSUM to be used this way and not that way or that other way, you know.
> apdu_group1.keyin, apdu_group1.S
Why is it a union?
Attempting to use one member will trash the other.
Are you "REALLY" sure that S should be a pointer, or did you just make it a pointer to make something else shut the hell up?
unsigned long *S; .... apdu_group1.S
vs.
unsigned long S; .... &apdu_group1.S
would both satisfy some type constraint somewhere (by being a pointer to an unsigned int), but the results are very different.
Do you have any other example uses of CHECKSUM in your code which do the right thing?
Which compiler are you using?
Is this for some embedded system (not a desktop machine)?