850 lines
14 KiB
C
850 lines
14 KiB
C
#include <stddef.h>
|
|
#include <math.h>
|
|
|
|
enum { FALSE = 0, TRUE = 1 };
|
|
|
|
const char cstr1[] = "Constant String1";
|
|
char defaultstring[] = "test";
|
|
static int mstatic1, mstatic2, mcount = 0;
|
|
static int period = 1000;
|
|
signed short int plot1 = -15000, plot2 = 0;
|
|
|
|
float vfloat = 1.0;
|
|
double vdouble = 1.0;
|
|
|
|
typedef int tdef1;
|
|
tdef1 vtdef1;
|
|
|
|
typedef short tdef2[10];
|
|
tdef2 vtdef2;
|
|
|
|
struct vstruct1_s {
|
|
int x, y;
|
|
}
|
|
vstruct1;
|
|
|
|
char vchar;
|
|
short vshort;
|
|
int vint = 1;
|
|
long vlong;
|
|
|
|
char * vpchar;
|
|
short * vpshort;
|
|
int * vpint;
|
|
long * vplong;
|
|
|
|
unsigned char vuchar;
|
|
unsigned short vushort;
|
|
unsigned int vuint;
|
|
unsigned long vulong;
|
|
|
|
unsigned char * vpuchar;
|
|
unsigned short * vpushort;
|
|
unsigned int * vpuint;
|
|
unsigned long * vpulong;
|
|
|
|
unsigned char * * vppuchar;
|
|
unsigned short * * vppushort;
|
|
unsigned int * * vppuint;
|
|
unsigned long * * vppulong;
|
|
|
|
unsigned long * * * vpppulong;
|
|
unsigned long * * * * vppppulong;
|
|
|
|
int varray[10];
|
|
|
|
typedef int tarray[10];
|
|
tarray vtarray;
|
|
|
|
char vdarray[5];
|
|
char vdiarray[] = "abcd";
|
|
char vdblarray[5][6];
|
|
char vtriplearray[2][3][4];
|
|
|
|
struct struct4 {
|
|
struct struct5 * pstruct5;
|
|
struct struct5 * * ppstruct5;
|
|
struct struct5 * pastruct5[2];
|
|
};
|
|
|
|
struct struct5 {
|
|
struct struct4 * pstruct4;
|
|
struct struct4 * * ppstruct4;
|
|
struct struct4 * pastruct4[2];
|
|
};
|
|
|
|
|
|
typedef struct struct1 {
|
|
const char * word;
|
|
int count;
|
|
struct struct1 * left;
|
|
struct struct1 * right;
|
|
int field1:2;
|
|
unsigned field2:3;
|
|
} strtype1 ;
|
|
|
|
strtype1 ast;
|
|
strtype1 pLinkedListBuf[5];
|
|
|
|
typedef struct struct1 structarray[10];
|
|
|
|
structarray stra1;
|
|
|
|
struct struct4 stra2[5][5];
|
|
|
|
struct union1 {
|
|
char * word;
|
|
int count;
|
|
struct struct1 * left;
|
|
struct struct1 * right;
|
|
union {
|
|
int ival;
|
|
float fval;
|
|
char * pval;
|
|
} uval;
|
|
int field1:2;
|
|
unsigned field2:3;
|
|
} aun;
|
|
|
|
struct struct2 {
|
|
char * word;
|
|
int count;
|
|
char name[10];
|
|
} str2;
|
|
|
|
struct struct6 {
|
|
int x;
|
|
struct struct7 {
|
|
char * word;
|
|
int count;
|
|
} vstruct7;
|
|
int y;
|
|
} str6;
|
|
|
|
|
|
struct abc {
|
|
int x;
|
|
int y;
|
|
};
|
|
|
|
struct abc def;
|
|
|
|
union tunion {
|
|
int z1;
|
|
short z2;
|
|
char z3;
|
|
struct abc z4;
|
|
} vunion;
|
|
|
|
enum enumtyp { enum1, enum2, enum4=4, enum7=7, enum8, enumx= -1 } enumvar;
|
|
|
|
int ( *funcptr ) (void);
|
|
|
|
void func0(void) /* empty function */
|
|
{
|
|
}
|
|
|
|
static void func1( int * intptr ) /* static function */
|
|
{
|
|
(*intptr)++;
|
|
}
|
|
|
|
void func2(void)
|
|
{
|
|
int autovar;
|
|
register int regvar;
|
|
static int fstatic = 44; /* initialized static variable */
|
|
static int fstatic2; /* not initialized static variable */
|
|
|
|
autovar = regvar = fstatic;
|
|
autovar++;
|
|
|
|
func1( &autovar ); /* to force autovar as stack-scope */
|
|
func1( &fstatic ); /* to force fstatic as static-scope */
|
|
|
|
for ( regvar = 0; regvar < 5 ; regvar++ )
|
|
mstatic1 += regvar*autovar;
|
|
|
|
fstatic += mstatic1;
|
|
fstatic2 = 2*fstatic;
|
|
|
|
if (mcount < 500)
|
|
return;
|
|
|
|
func1( &fstatic2 );
|
|
|
|
return;
|
|
}
|
|
|
|
void func2a(void)
|
|
{
|
|
char autovar; /* char stack variable */
|
|
register char regvar; /* char register variable */
|
|
|
|
autovar = regvar = (char) mstatic1;
|
|
autovar++;
|
|
|
|
for ( regvar = 0; regvar < (char) 5 ; regvar++ )
|
|
vchar += regvar*autovar;
|
|
}
|
|
|
|
void func2b(void)
|
|
{
|
|
long autovar; /* long stack variable */
|
|
register long regvar; /* long register variable */
|
|
|
|
autovar = regvar = mstatic1;
|
|
autovar++;
|
|
|
|
for ( regvar = 0; regvar < 5l ; regvar++ )
|
|
vlong += regvar*autovar;
|
|
}
|
|
|
|
void func2c(void)
|
|
{
|
|
#if !defined(NO_FLOAT)
|
|
double autovar; /* double stack variable */
|
|
register double regvar; /* double register variable */
|
|
|
|
autovar = regvar = (double) mstatic1;
|
|
autovar++;
|
|
|
|
for ( regvar = 0.0; regvar < 5.0 ; regvar += 1.0 )
|
|
vdouble += regvar*autovar;
|
|
#endif /* NO_FLOAT */
|
|
}
|
|
|
|
void func2d(void)
|
|
{
|
|
short autovar; /* short stack variable */
|
|
register short regvar; /* short register variable */
|
|
|
|
autovar = regvar = mstatic1;
|
|
autovar++;
|
|
|
|
for ( regvar = 0; regvar < 5l ; regvar++ )
|
|
vlong += regvar*autovar;
|
|
}
|
|
|
|
|
|
static int func3(void) /* simple function */
|
|
{
|
|
return 5;
|
|
}
|
|
|
|
struct struct1 func4( struct struct1 str ) /* function returning struct */
|
|
{
|
|
str.count++;
|
|
|
|
return str;
|
|
}
|
|
|
|
int func5( int a, char b, long c ) /* multiple arguments */
|
|
{
|
|
return a+b*c;
|
|
}
|
|
|
|
#if !defined(NO_FLOAT)
|
|
float func6( float a, float b )
|
|
{
|
|
vfloat = 1.0;
|
|
vfloat = -1.0;
|
|
vfloat = 10.0;
|
|
vfloat = 1.6;
|
|
|
|
return a*b;
|
|
}
|
|
|
|
double func7( double a, double b )
|
|
{
|
|
vdouble = 1.0;
|
|
vdouble = -1.0;
|
|
vdouble = 10.0;
|
|
vdouble = 1.6;
|
|
|
|
return a*b;
|
|
}
|
|
#endif /* NO_FLOAT */
|
|
|
|
struct bfield
|
|
{
|
|
int a:1;
|
|
int b:2;
|
|
int c:3;
|
|
int d:7;
|
|
int e:8;
|
|
int f:15;
|
|
int g:1;
|
|
int h:15;
|
|
int i:1;
|
|
int j:16;
|
|
unsigned k:1;
|
|
unsigned l:2;
|
|
unsigned m:16;
|
|
long n;
|
|
char o;
|
|
int p:15;
|
|
char q:6;
|
|
char r:1;
|
|
};
|
|
|
|
struct bfield vbfield;
|
|
|
|
void func8(void)
|
|
{
|
|
vbfield.a = 1;
|
|
vbfield.b = 1;
|
|
vbfield.c = 1;
|
|
vbfield.d = 1;
|
|
vbfield.e = 1;
|
|
vbfield.f = 1;
|
|
vbfield.g = 1;
|
|
vbfield.h = 1;
|
|
vbfield.i = 1;
|
|
vbfield.j = 1;
|
|
vbfield.k = 1;
|
|
vbfield.l = 1;
|
|
vbfield.m = 1;
|
|
vbfield.n = 1;
|
|
vbfield.o = 1;
|
|
vbfield.p = 1;
|
|
vbfield.q = 1;
|
|
vbfield.r = 1;
|
|
|
|
vbfield.a = -1;
|
|
vbfield.b = -1;
|
|
vbfield.c = -1;
|
|
vbfield.d = -1;
|
|
vbfield.e = -1;
|
|
vbfield.f = -1;
|
|
vbfield.g = -1;
|
|
vbfield.h = -1;
|
|
vbfield.i = -1;
|
|
vbfield.j = -1;
|
|
vbfield.k = -1 & 0x01;
|
|
vbfield.l = -1 & 0x03;
|
|
vbfield.m = (unsigned short) -1;
|
|
vbfield.n = -1;
|
|
vbfield.o = -1;
|
|
vbfield.p = -1;
|
|
vbfield.q = -1;
|
|
vbfield.r = -1;
|
|
}
|
|
|
|
static int * func9(void) /* nested local variables */
|
|
{
|
|
static int stat1 = 0;
|
|
register int reg1;
|
|
int auto1;
|
|
|
|
auto1 = stat1;
|
|
|
|
for ( reg1 = 0 ; reg1 < 2 ; reg1++ )
|
|
{
|
|
static int stat2 = 0;
|
|
register int reg2;
|
|
int auto2;
|
|
|
|
auto2 = stat2;
|
|
|
|
for ( reg2 = 0 ; reg2 < reg1 ; reg2++ )
|
|
{
|
|
func1( &stat1 );
|
|
func1( &auto1 );
|
|
func1( &stat2 );
|
|
func1( &auto2 );
|
|
}
|
|
}
|
|
|
|
return &stat1;
|
|
}
|
|
|
|
int __attribute__ ((weak)) func10(void)
|
|
{
|
|
register int i;
|
|
register int v1, v2, v3, v4, v5, v6, v7, v8;
|
|
register int v9, v10, v11, v12, v13, v14, v15, v16, v17;
|
|
|
|
v17 = 0;
|
|
for ( i = 0 ; i < 3 ; i++ )
|
|
v17 += i;
|
|
|
|
for ( v1 = 0 ; v1 < 3 ; v1++ )
|
|
v17 += v1;
|
|
for ( v2 = 0 ; v2 < 3 ; v2++ )
|
|
v17 += v2;
|
|
for ( v3 = 0 ; v3 < 3 ; v3++ )
|
|
v17 += v3;
|
|
for ( v4 = 0 ; v4 < 3 ; v4++ )
|
|
v17 += v4;
|
|
for ( v5 = 0 ; v5 < 3 ; v5++ )
|
|
v17 += v5;
|
|
for ( v6 = 0 ; v6 < 3 ; v6++ )
|
|
v17 += v6;
|
|
for ( v7 = 0 ; v7 < 3 ; v7++ )
|
|
v17 += v7;
|
|
for ( v8 = 0 ; v8 < 3 ; v8++ )
|
|
v17 += v8;
|
|
for ( v9 = 0 ; v9 < 3 ; v9++ )
|
|
v17 += v9;
|
|
for ( v10 = 0 ; v10 < 3 ; v10++ )
|
|
v17 += v10;
|
|
for ( v11 = 0 ; v11 < 3 ; v11++ )
|
|
v17 += v11;
|
|
for ( v12 = 0 ; v12 < 3 ; v12++ )
|
|
v17 += v12;
|
|
for ( v13 = 0 ; v13 < 3 ; v13++ )
|
|
v17 += v13;
|
|
for ( v14 = 0 ; v14 < 3 ; v14++ )
|
|
v17 += v14;
|
|
for ( v15 = 0 ; v15 < 3 ; v15++ )
|
|
v17 += v15;
|
|
for ( v16 = 0 ; v16 < 3 ; v16++ )
|
|
v17 += v16;
|
|
|
|
i = v17;
|
|
|
|
for ( v1 = 0 ; v1 < 3 ; v1++ )
|
|
v17 += v1;
|
|
for ( v2 = 0 ; v2 < 3 ; v2++ )
|
|
v17 += v2;
|
|
for ( v3 = 0 ; v3 < 3 ; v3++ )
|
|
v17 += v3;
|
|
for ( v4 = 0 ; v4 < 3 ; v4++ )
|
|
v17 += v4;
|
|
for ( v5 = 0 ; v5 < 3 ; v5++ )
|
|
v17 += v5;
|
|
for ( v6 = 0 ; v6 < 3 ; v6++ )
|
|
v17 += v6;
|
|
for ( v7 = 0 ; v7 < 3 ; v7++ )
|
|
v17 += v7;
|
|
for ( v8 = 0 ; v8 < 3 ; v8++ )
|
|
v17 += v8;
|
|
for ( v9 = 0 ; v9 < 3 ; v9++ )
|
|
v17 += v9;
|
|
for ( v10 = 0 ; v10 < 3 ; v10++ )
|
|
v17 += v10;
|
|
for ( v11 = 0 ; v11 < 3 ; v11++ )
|
|
v17 += v11;
|
|
for ( v12 = 0 ; v12 < 3 ; v12++ )
|
|
v17 += v12;
|
|
for ( v13 = 0 ; v13 < 3 ; v13++ )
|
|
v17 += v13;
|
|
for ( v14 = 0 ; v14 < 3 ; v14++ )
|
|
v17 += v14;
|
|
for ( v15 = 0 ; v15 < 3 ; v15++ )
|
|
v17 += v15;
|
|
for ( v16 = 0 ; v16 < 3 ; v16++ )
|
|
v17 += v16;
|
|
|
|
return v17;
|
|
}
|
|
|
|
int func11( int x ) /* multiple returns */
|
|
{
|
|
switch ( x )
|
|
{
|
|
case 1:
|
|
x = x+1;
|
|
x = x*2;
|
|
return x*x;
|
|
case 2:
|
|
return x+x;
|
|
case 3:
|
|
return x-x;
|
|
case 4:
|
|
x = x+1;
|
|
x = x*2;
|
|
return x*x;
|
|
case 5:
|
|
break;
|
|
case 6:
|
|
return x+x;
|
|
default:
|
|
break;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
typedef char undefarray[];
|
|
typedef undefarray * undefptr;
|
|
|
|
void func12( undefptr ptr ) /* pointer to array of unknown size */
|
|
{
|
|
(*ptr)[0] = 1;
|
|
}
|
|
|
|
int func13( int a, int c, int e ) /* arguments and locals stack-tracking */
|
|
{
|
|
int b, d, f;
|
|
|
|
b = a+c+e;
|
|
f = b+a;
|
|
d = f*b;
|
|
|
|
if ( e > 0 )
|
|
c += func13( b, f, e-1 );
|
|
|
|
return c+e+d;
|
|
}
|
|
|
|
int func14( char x1 ) /* Parameter: 1 Byte */
|
|
{
|
|
return 2*x1;
|
|
}
|
|
|
|
int func15( short x1 ) /* Parameter: 1 Word */
|
|
{
|
|
return 2*x1;
|
|
}
|
|
|
|
int func16( long x1 ) /* Parameter: 1 Long */
|
|
{
|
|
return (int) (2*x1);
|
|
}
|
|
|
|
int func17( short x1, short x2 ) /* Parameter: 2 Short */
|
|
{
|
|
return x1*x2;
|
|
}
|
|
|
|
int func18( short x1, long x2 ) /* Parameter: Short,Long */
|
|
{
|
|
return x1*x2;
|
|
}
|
|
|
|
int func19( long x1, short x2 ) /* Parameter: Long,Short */
|
|
{
|
|
return x1*x2;
|
|
}
|
|
|
|
int func20( short x1, short x2, short x3 ) /* Parameter: 3 Short */
|
|
{
|
|
return x1*x2*x3;
|
|
}
|
|
|
|
int func21( long x1, short x2, short x3 ) /* Parameter: Long,Short,Short */
|
|
{
|
|
return x1*x2*x3;
|
|
}
|
|
|
|
int func22( short x1, long x2, short x3 ) /* Parameter: Short,Long,Short */
|
|
{
|
|
return x1*x2*x3;
|
|
}
|
|
|
|
int func23( short x1, short x2, long x3 ) /* Parameter: Short,Short,Long */
|
|
{
|
|
return x1*x2*x3;
|
|
}
|
|
|
|
char func24(void) /* Char Return */
|
|
{
|
|
return 55;
|
|
}
|
|
|
|
long func25(void) /* Long Return */
|
|
{
|
|
return 12345678l;
|
|
}
|
|
|
|
char * func26(void) /* Pointer Return */
|
|
{
|
|
static char x1[] = "Babel Fish";
|
|
|
|
return x1;
|
|
}
|
|
|
|
struct struct1 func27( short x1, short x2 ) /* function returning struct */
|
|
{
|
|
ast.count = x1*x2;
|
|
|
|
return ast;
|
|
}
|
|
|
|
static int test_cond_instr( int arg1, int arg2 ) /* function with conditional (non-branch) instructions */
|
|
{
|
|
int result;
|
|
/* For - ARM Mode - OR - ThumbII - force conditional instructions */
|
|
#if defined(__arm__)&&(!defined(__thumb__)||(defined(__thumb__)&&__ARM_ARCH==7)||(defined(__thumb__)&&__ARM_ARCH==8&&!__ARM_ARCH_8M_BASE__))
|
|
__asm__ (
|
|
"subs %[arg2],%[arg1],%[arg2] \n\t"
|
|
"ittte ne \n\t"
|
|
"mulne %[arg2],%[arg1],%[arg2] \n\t"
|
|
"addne %[arg2],%[arg2],#42 \n\t"
|
|
"asrne %[result],%[arg2],#1 \n\t"
|
|
"moveq %[result],#0 \n\t"
|
|
: [result] "=r" (result) : [arg1] "r" (arg1), [arg2] "r" (arg2)
|
|
);
|
|
#else
|
|
arg2 = arg1 - arg2;
|
|
if (arg2){
|
|
arg2 = arg2 * arg1;
|
|
arg2 = arg2 + 42;
|
|
result = arg2 >> 1;
|
|
} else {
|
|
result = 0;
|
|
}
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
int int_sin(unsigned int x)
|
|
{
|
|
int sign=1;
|
|
if (x&0x20)
|
|
sign=-1;
|
|
x=x&0x1f;
|
|
if ((x&0x10)&&(x&0xf))
|
|
x=0x10-(x&0xf);
|
|
|
|
// sin(x) -Pi/2 <= x <= Pi/2 = x-x^3/3!+x^5/5!-...
|
|
return sign*((120*10*10*10*10*x - (20*10*10*x*x*x) + (x*x*x*x*x))>>9);
|
|
}
|
|
|
|
static short sinewave[630];
|
|
|
|
void func_sin()
|
|
{
|
|
int x;
|
|
|
|
for (x = 0; x < 628; x++)
|
|
sinewave[x] = int_sin(x)/(x/32+1);
|
|
}
|
|
|
|
void init_linked_list(void)
|
|
{
|
|
int i = 0;
|
|
const int last = sizeof(pLinkedListBuf) / sizeof(pLinkedListBuf[0]) - 1;
|
|
static const char* text[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
|
|
|
|
ast.left = pLinkedListBuf;
|
|
ast.right = NULL;
|
|
ast.count = 0;
|
|
ast.word = NULL;
|
|
|
|
for (i = 0; i <= last; i++) {
|
|
pLinkedListBuf[i].left = (i==last) ? NULL : &pLinkedListBuf[i+1]; /* next element */
|
|
pLinkedListBuf[i].right = (i==0) ? &ast : &pLinkedListBuf[i-1]; /* previous element */
|
|
pLinkedListBuf[i].count = i;
|
|
pLinkedListBuf[i].word = text[i % 7];
|
|
}
|
|
}
|
|
|
|
static char subst( char c)
|
|
{
|
|
switch ( c ){
|
|
case 'a':
|
|
return 'e';
|
|
case 'e':
|
|
return 'i';
|
|
case 'i':
|
|
return 'u';
|
|
case 'o':
|
|
return 'a';
|
|
case 'u':
|
|
return 'o';
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static char* encode( char str[] )
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; str[i]; i++){
|
|
char c = str[i];
|
|
if ('A' <= c && c <= 'Z'){
|
|
c = c + ('a'-'A');
|
|
c = subst(c);
|
|
c = c - ('a'-'A');
|
|
} else {
|
|
c = subst(c);
|
|
}
|
|
str[i] = c;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
struct shortrecord
|
|
{
|
|
short x;
|
|
short y;
|
|
};
|
|
|
|
struct shortrecord vshortrecord;
|
|
|
|
struct shortrecord func28( struct shortrecord x )
|
|
{
|
|
x.x++;
|
|
x.y = (short) (x.x+1);
|
|
return x;
|
|
}
|
|
|
|
union {
|
|
unsigned char b[4];
|
|
unsigned short w[2];
|
|
unsigned long l[1];
|
|
} datas;
|
|
|
|
static int sieve(void);
|
|
|
|
void (*monHook)(void) __attribute__ ((section (".data"))) = 0;
|
|
extern void (*watchdogTrigger)(void);
|
|
|
|
int main(void)
|
|
{
|
|
int j;
|
|
short int inc, sign;
|
|
char *p;
|
|
|
|
func_sin();
|
|
|
|
do {
|
|
if (monHook)
|
|
monHook();
|
|
if (watchdogTrigger)
|
|
watchdogTrigger();
|
|
|
|
mstatic1 = 12;
|
|
mstatic2 = 34;
|
|
mcount++;
|
|
|
|
inc = (4 * 15000) / period;
|
|
sign = ( (mcount % period) >= period/2 ) ? -1 : +1;
|
|
plot1 = plot1 + sign * inc;
|
|
plot2 = 25000 * sign;
|
|
|
|
vtriplearray[0][0][0] = 1;
|
|
vtriplearray[1][0][0] = 2;
|
|
vtriplearray[0][1][0] = 3;
|
|
vtriplearray[0][0][1] = 4;
|
|
|
|
func2();
|
|
func2a();
|
|
func2b();
|
|
func2c();
|
|
func2d();
|
|
|
|
funcptr = (int (*) ()) 0;
|
|
funcptr = func3;
|
|
|
|
init_linked_list();
|
|
ast.count = 12345;
|
|
ast.field1 = 1 + mstatic2;
|
|
ast.field2 = 2;
|
|
|
|
ast = func4(ast);
|
|
|
|
j = (*funcptr) ();
|
|
|
|
start:
|
|
j = func5((int) j, (char) 2, (long) 3);
|
|
|
|
if (j == 0)
|
|
goto start;
|
|
|
|
enumvar = enumx;
|
|
|
|
#if !defined(NO_FLOAT)
|
|
vfloat = 2.0;
|
|
func6( vfloat, (float) 3.0 );
|
|
vdouble = 2.0;
|
|
func7( vdouble, (double) 3.0 );
|
|
#endif /* NO_FLOAT */
|
|
|
|
func8();
|
|
func9();
|
|
func10();
|
|
func11(5);
|
|
func13(1, 2, 3);
|
|
func14((char) 55);
|
|
func15((short) 55);
|
|
func16((long) 55);
|
|
func17((short) 44, (short) 55);
|
|
func18((short) 44, (long) 55);
|
|
func19((long) 44, (short) 55);
|
|
func20((short) 33, (short) 44, (short) 55);
|
|
func21((long) 33, (short) 44, (short) 55);
|
|
func22((short) 33, (long) 44, (short) 55);
|
|
func23((short) 33, (short) 44, (long) 55);
|
|
|
|
j = func24();
|
|
vlong = func25();
|
|
p = func26();
|
|
vshortrecord = func28(vshortrecord);
|
|
|
|
encode(p);
|
|
sieve();
|
|
|
|
mstatic1 = test_cond_instr( 14, 14 ); /* returns 0 */
|
|
mstatic2 = test_cond_instr( 78, 55 ); /* returns 918 */
|
|
|
|
datas.b[0] = 0x12;
|
|
datas.b[1] = 0x12;
|
|
datas.b[2] = 0x12;
|
|
datas.b[3] = p[0];
|
|
datas.w[0] = 0x1234;
|
|
datas.w[1] = 0x1234;
|
|
datas.l[0] = 0x12345678;
|
|
datas.b[0] = 0x11;
|
|
datas.b[1] = 0x11;
|
|
datas.b[2] = 0x11;
|
|
datas.b[3] = 0x11;
|
|
datas.w[0] = 0x1122;
|
|
datas.w[1] = 0x1122;
|
|
datas.l[0] = 0x11223344;
|
|
|
|
} while (vint);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define SIZE 18
|
|
char flags[SIZE+1];
|
|
|
|
static int sieve(void) /* sieve of erathostenes */
|
|
{
|
|
register int i, prime, k;
|
|
int count;
|
|
|
|
count = 0;
|
|
|
|
for ( i = 0 ; i <= SIZE ; flags[ i++ ] = TRUE ) ;
|
|
|
|
for (i = 0; i <= SIZE; i++) {
|
|
if (flags[i]) {
|
|
prime = i + i + 3;
|
|
k = i + prime;
|
|
while (k <= SIZE) {
|
|
flags[k] = FALSE;
|
|
k += prime;
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
int __attribute__ ((naked)) background(void) /* job for background-demo - doesn't use stack*/
|
|
{
|
|
static long int bcnt1, bcnt2;
|
|
|
|
bcnt1 = bcnt2 = 0;
|
|
|
|
while (1) {
|
|
bcnt1 = 10000000;
|
|
while (bcnt1>0)
|
|
bcnt1--;
|
|
bcnt2++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|