emApps online compiler
Online S32 compiler to evaluate emApps and Flasher Apps.
Overview
emApps and Apps for Flasher provide great flexibility and strong separation from the actual firmware the apps are intended to run on.
The emApps S32 compiler test provides guidance on performance and resource usage through example apps, making it easy to experiment with app ideas in a sandboxed environment without installing anything on a target system.
emApps online compiler
Compiler results will be displayed here.
#pragma S32C stack_size(8192)
static const int aExpected[] = {
1, 2, 3, 4, 5, 6, 7,
2, 3, 4, 5, 6, 7, 8,
3, 5, 7, 9, 11, 13, 15,
5, 13, 29, 61, 125, 253, 509
};
static int ackermann(int m, int n) {
if (m == 0) {
return n + 1;
}
if (n == 0) {
return ackermann(m-1, 1);
}
return ackermann(m-1, ackermann(m, n-1));
}
int main(void) {
int m, n, u;
int ErrorCnt;
//
ErrorCnt = 0;
u = 0;
//
for (m = 0; m < 4; ++m) {
for (n = 0; n < 7; ++n) {
printf("Ackerman(%d, %d) = %d\n", m, n, ackermann(m, n));
ErrorCnt += ackermann(m, n) != aExpected[u++];
}
}
//
printf("\n");
//
return ErrorCnt;
}
#pragma S32C stack_size(512)
#define DHRY_ITERS 100000
#define structassign(d, s) d = s
typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5} Enumeration;
#define Null 0
#define true 1
#define false 0
typedef int One_Thirty;
typedef int One_Fifty;
typedef char Capital_Letter;
typedef int Boolean;
typedef char Str_30 [31];
typedef int Arr_1_Dim [50];
typedef int Arr_2_Dim [50] [50];
typedef struct record
{
struct record *Ptr_Comp;
Enumeration Discr;
union {
struct {
Enumeration Enum_Comp;
int Int_Comp;
char Str_Comp [31];
} var_1;
struct {
Enumeration E_Comp_2;
char Str_2_Comp [31];
} var_2;
struct {
char Ch_1_Comp;
char Ch_2_Comp;
} var_3;
} variant;
} Rec_Type, *Rec_Pointer;
Rec_Pointer Ptr_Glob,
Next_Ptr_Glob;
int Int_Glob;
Boolean Bool_Glob;
char Ch_1_Glob,
Ch_2_Glob;
int Arr_1_Glob [50];
int Arr_2_Glob [50] [50];
Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val);
Boolean Func_2 (Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref);
Boolean Func_3 (Enumeration Enum_Par_Val);
void Proc_1 (Rec_Pointer Ptr_Val_Par);
void Proc_2 (One_Fifty *Int_Par_Ref);
void Proc_3 (Rec_Pointer *Ptr_Ref_Par);
void Proc_4 (void);
void Proc_5 (void);
void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par);
void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref);
void Proc_8 (Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref, int Int_1_Par_Val, int Int_2_Par_Val);
#ifndef REG
#define REG
#endif
static int ErrCnt;
static void Assert(int ok) {
if (!ok) {
++ErrCnt;
}
}
int main(void)
/*****/
/* main program, corresponds to procedures */
/* Main and Proc_0 in the Ada version */
{
One_Fifty Int_1_Loc;
REG One_Fifty Int_2_Loc;
One_Fifty Int_3_Loc;
REG char Ch_Index;
Enumeration Enum_Loc;
Str_30 Str_1_Loc;
Str_30 Str_2_Loc;
REG int Run_Index;
REG int Number_Of_Runs;
unsigned T0;
T0 = SYS_GetTime_ms();
/* Initializations */
static Rec_Type V1;
static Rec_Type V2;
Next_Ptr_Glob = (Rec_Pointer) &V1;
Ptr_Glob = (Rec_Pointer) &V2;
Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
Ptr_Glob->Discr = Ident_1;
Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
Ptr_Glob->variant.var_1.Int_Comp = 40;
strcpy (Ptr_Glob->variant.var_1.Str_Comp,
"DHRYSTONE PROGRAM, SOME STRING");
strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
Arr_2_Glob [8][7] = 10;
/* Was missing in published program. Without this statement, */
/* Arr_2_Glob [8][7] would have an undefined value. */
/* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
/* overflow may occur for this array element. */
Number_Of_Runs = DHRY_ITERS;
for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
{
Proc_5();
Proc_4();
/* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
Int_1_Loc = 2;
Int_2_Loc = 3;
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
Enum_Loc = Ident_2;
Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
/* Bool_Glob == 1 */
while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
{
Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
/* Int_3_Loc == 7 */
Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
/* Int_3_Loc == 7 */
Int_1_Loc += 1;
} /* while */
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
/* Int_Glob == 5 */
Proc_1 (Ptr_Glob);
for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
/* loop body executed twice */
{
if (Enum_Loc == Func_1 (Ch_Index, 'C'))
/* then, not executed */
{
Proc_6 (Ident_1, &Enum_Loc);
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
Int_2_Loc = Run_Index;
Int_Glob = Run_Index;
}
}
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
Int_2_Loc = Int_2_Loc * Int_1_Loc;
Int_1_Loc = Int_2_Loc / Int_3_Loc;
Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
/* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
Proc_2 (&Int_1_Loc);
/* Int_1_Loc == 5 */
} /* loop "for Run_Index" */
T0 = SYS_GetTime_ms() - T0;
Assert(Int_Glob == 5);
Assert(Bool_Glob == 1);
Assert(Ch_1_Glob == 'A');
Assert(Ch_2_Glob == 'B');
Assert(Arr_1_Glob[8] == 7);
Assert(Arr_2_Glob[8][7] == Number_Of_Runs + 10);
Assert(Ptr_Glob->Discr == 0);
Assert(Ptr_Glob->variant.var_1.Enum_Comp == Ident_3);
Assert(Ptr_Glob->variant.var_1.Int_Comp == 17);
Assert(Next_Ptr_Glob->Discr == 0);
Assert(Next_Ptr_Glob->variant.var_1.Enum_Comp == Ident_2);
Assert(Next_Ptr_Glob->variant.var_1.Int_Comp == 18);
Assert(Int_1_Loc == 5);
Assert(Int_2_Loc == 13);
Assert(Int_3_Loc == 7);
Assert(Enum_Loc == 1);
//
if (T0 == 0) {
printf("Number of iterations too small or no timer available\n\n");
} else {
printf("%d Dhrystones/s, %d DMIPS\n\n",
UTIL_MulDiv(1000, DHRY_ITERS, T0),
UTIL_MulDiv(1000, DHRY_ITERS, T0) / 1757);
}
//
return ErrCnt;
}
void Proc_1 (Rec_Pointer Ptr_Val_Par)
/******************/
/* executed once */
{
REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
/* == Ptr_Glob_Next */
/* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
/* corresponds to "rename" in Ada, "with" in Pascal */
structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
Ptr_Val_Par->variant.var_1.Int_Comp = 5;
Next_Record->variant.var_1.Int_Comp
= Ptr_Val_Par->variant.var_1.Int_Comp;
Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
Proc_3 (&Next_Record->Ptr_Comp);
/* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
== Ptr_Glob->Ptr_Comp */
if (Next_Record->Discr == Ident_1)
/* then, executed */
{
Next_Record->variant.var_1.Int_Comp = 6;
Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
&Next_Record->variant.var_1.Enum_Comp);
Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
&Next_Record->variant.var_1.Int_Comp);
}
else /* not executed */
structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
} /* Proc_1 */
void Proc_2 (One_Fifty *Int_Par_Ref)
/******************/
/* executed once */
/* *Int_Par_Ref == 1, becomes 4 */
{
One_Fifty Int_Loc;
Enumeration Enum_Loc;
Int_Loc = *Int_Par_Ref + 10;
do /* executed once */
if (Ch_1_Glob == 'A')
/* then, executed */
{
Int_Loc -= 1;
*Int_Par_Ref = Int_Loc - Int_Glob;
Enum_Loc = Ident_1;
} /* if */
while (Enum_Loc != Ident_1); /* true */
} /* Proc_2 */
void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
/******************/
/* executed once */
/* Ptr_Ref_Par becomes Ptr_Glob */
{
if (Ptr_Glob != Null)
/* then, executed */
*Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
} /* Proc_3 */
void Proc_4 (void) /* without parameters */
/*******/
/* executed once */
{
Boolean Bool_Loc;
Bool_Loc = Ch_1_Glob == 'A';
Bool_Glob = Bool_Loc | Bool_Glob;
Ch_2_Glob = 'B';
} /* Proc_4 */
void Proc_5 (void) /* without parameters */
/*******/
/* executed once */
{
Ch_1_Glob = 'A';
Bool_Glob = false;
} /* Proc_5 */
void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par)
/*********************************/
/* executed once */
/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
{
*Enum_Ref_Par = Enum_Val_Par;
if (! Func_3 (Enum_Val_Par))
/* then, not executed */
*Enum_Ref_Par = Ident_4;
switch (Enum_Val_Par)
{
case Ident_1:
*Enum_Ref_Par = Ident_1;
break;
case Ident_2:
if (Int_Glob > 100)
/* then */
*Enum_Ref_Par = Ident_1;
else *Enum_Ref_Par = Ident_4;
break;
case Ident_3: /* executed */
*Enum_Ref_Par = Ident_2;
break;
case Ident_4: break;
case Ident_5:
*Enum_Ref_Par = Ident_3;
break;
} /* switch */
} /* Proc_6 */
void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref)
/**********************************************/
/* executed three times */
/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
/* Int_Par_Ref becomes 7 */
/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
/* Int_Par_Ref becomes 17 */
/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
/* Int_Par_Ref becomes 18 */
{
One_Fifty Int_Loc;
Int_Loc = Int_1_Par_Val + 2;
*Int_Par_Ref = Int_2_Par_Val + Int_Loc;
} /* Proc_7 */
void Proc_8 (Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref, int Int_1_Par_Val, int Int_2_Par_Val)
/*********************************************************************/
/* executed once */
/* Int_Par_Val_1 == 3 */
/* Int_Par_Val_2 == 7 */
{
REG One_Fifty Int_Index;
REG One_Fifty Int_Loc;
Int_Loc = Int_1_Par_Val + 5;
Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
Int_Glob = 5;
} /* Proc_8 */
Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val)
/*************************************************/
/* executed three times */
/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
{
Capital_Letter Ch_1_Loc;
Capital_Letter Ch_2_Loc;
Ch_1_Loc = Ch_1_Par_Val;
Ch_2_Loc = Ch_1_Loc;
if (Ch_2_Loc != Ch_2_Par_Val)
/* then, executed */
return (Ident_1);
else /* not executed */
{
Ch_1_Glob = Ch_1_Loc;
return (Ident_2);
}
} /* Func_1 */
Boolean Func_2 (Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref)
/*************************************************/
/* executed once */
/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
{
REG One_Thirty Int_Loc;
Capital_Letter Ch_Loc;
Int_Loc = 2;
while (Int_Loc <= 2) /* loop body executed once */
if (Func_1 (Str_1_Par_Ref[Int_Loc],
Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
/* then, executed */
{
Ch_Loc = 'A';
Int_Loc += 1;
} /* if, while */
if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
/* then, not executed */
Int_Loc = 7;
if (Ch_Loc == 'R')
/* then, not executed */
return (true);
else /* executed */
{
if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
/* then, not executed */
{
Int_Loc += 7;
Int_Glob = Int_Loc;
return (true);
}
else /* executed */
return (false);
} /* if Ch_Loc */
} /* Func_2 */
Boolean Func_3 (Enumeration Enum_Par_Val)
/***************************/
/* executed once */
/* Enum_Par_Val == Ident_3 */
{
Enumeration Enum_Loc;
Enum_Loc = Enum_Par_Val;
if (Enum_Loc == Ident_3)
/* then, executed */
return (true);
else /* not executed */
return (false);
} /* Func_3 */
int main(void) {
int Handle;
int Status;
char acBuf[128];
//
Handle = FOpen("Hello.txt", FILE_MODE_READ | FILE_MODE_WRITE);
if (Handle < 0) {
printf("fatal: can't open 'Hello.txt' for writing\n");
return -1;
}
//
// Write file with DOS/Windows end-of-line characters.
//
Status = FWrite(Handle, "Hello, world!\r\n", 15);
if (Status != 15) {
printf("fatal: can't write to 'Hello.txt'\n");
return -1;
}
Status = FClose(Handle);
if (Status < 0) {
printf("fatal: can't close 'Hello.txt'\n");
return -1;
}
//
// Read and display the file.
//
Handle = FOpen("Hello.txt", FILE_MODE_READ);
if (Handle < 0) {
printf("fatal: can't open 'Hello.txt' for reading\n");
return -1;
}
//
for (;;) {
Status = FRead(Handle, acBuf, sizeof(acBuf));
if (Status < 0) {
printf("fatal: error reading 'Hello.txt'");
return -1;
}
if (Status == 0) {
return 0;
}
printf("%.*s", Status, acBuf);
}
}
void main(void) {
printf("Hello, world!\n");
}
#define MAX_PRIME 17
int IsPrime(int c) {
int f;
//
for (f = 3; f*f <= c; f += 2) { // factor to test
if (c % f == 0) {
return 0;
}
}
return 1;
}
void main(void) {
int c;
//
printf("2 ");
for (c = 3; c <= MAX_PRIME; c += 2) { // candidate primes
if (IsPrime(c)) {
printf("%d ", c);
}
}
printf("\n\n");
}
#define SIZE 8190
char flags[SIZE+1];
int main(void) {
int i, prime, k, count, iter;
//
for (iter = 1; iter <= 10; iter ++) {
count = 0;
for (i = 0; i <= SIZE; i++)
flags[i] = 1;
for (i = 0; i <= SIZE; i++) {
if (flags[i]) {
prime = i + i + 3;
k = i + prime;
while (k <= SIZE) {
flags[k] = 0;
k += prime;
}
count = count + 1;
}
}
}
//
if (count = 1899) {
puts("Correctly counted 1899 primes");
} else {
puts("Didn't correctly count 1899 primes");
}
puts("");
//
return count;
}
How the emApps online compiler works
emApps consists of a PC development environment, a compiler for creating apps, and source code for host integration. Also included is a PC-based executor for running, testing, tracing, and even profiling apps on a desktop.
Users can test emApps by following the instructions below:
Flasher API
When the target platform of an app is a Flasher, the following functions can be used to control the Flasher's behavior:
| Declaration | Description |
|---|---|
int SYS_ExecCommand("SupplyPower=0"); | Disables target power (pin 19). Remains after the app has been executed. |
int SYS_ExecCommand("SupplyPower=1"); | Enables target power (pin 19). Remains after the app has been executed. |
int SYS_SetLED(U32 Index, U32 State); | Controls the Flasher LED:Index 0: "OK" LED (green)Index 1: "OK" LED (red)Index 2: "Fail" LED (green)Index 3: "Fail" LED (red) |
int printf(const char* sFormat, ...); | Outputs a formatted string to the terminal. |
int SYS_GetTime(); | Returns the Flasher’s uptime in milliseconds. |
void SYS_Exit(); | Stops the execution of the app and exits it. |
Licensing
The files generated by the compiler are the intellectual property of the person who wrote and uploaded the source code. The resulting executable is intended for evaluation purposes only and is meant to be used with a PC-based executor environment. SEGGER does not store any part of the source code or executable longer than required to compile it and provide the result for download. All files are removed immediately afterwards.
Get in touch with us
Have questions or need assistance? Our Embedded Experts are here to help!
Reach out to us for:
- Licensing quotes
- Technical inquiries
- Project support