/* sscc : C CODE OF SORTED EQUATIONS simple2 - SIMULATION MODE */

/* AUXILIARY DECLARATIONS */

#ifndef STRLEN
#define STRLEN 81
#endif
#define _COND(A,B,C) ((A)?(B):(C))
#ifdef TRACE_ACTION
#include <stdio.h>
#endif
#ifndef NULL
#define NULL ((char*)0)
#endif

#ifndef __EXEC_STATUS_H_LOADED
#define __EXEC_STATUS_H_LOADED

typedef struct {
unsigned int start:1;
unsigned int kill:1;
unsigned int active:1;
unsigned int suspended:1;
unsigned int prev_active:1;
unsigned int prev_suspended:1;
unsigned int exec_index;
unsigned int task_exec_index;
void (*pStart)();
int (*pRet)();
} __ExecStatus;

#endif
#define __ResetExecStatus(status) {\
   status.prev_active = status.active; \
   status.prev_suspended = status.suspended; \
   status.start = status.kill = status.active = status.suspended = 0; }
#define __DSZ(V) (--(V)<=0)
#define BASIC_TYPES_DEFINED
typedef int boolean;
typedef int integer;
typedef char* string;
#define CSIMUL_H_LOADED
typedef struct {char text[STRLEN];} symbolic;
extern void _boolean();
extern boolean _eq_boolean();
extern boolean _ne_boolean();
extern boolean _cond_boolean();
extern char* _boolean_to_text();
extern int _check_boolean();
extern void _text_to_boolean();
extern void _integer();
extern boolean _eq_integer();
extern boolean _ne_integer();
extern integer _cond_integer();
extern char* _integer_to_text();
extern int _check_integer();
extern void _text_to_integer();
extern void _string();
extern boolean _eq_string();
extern boolean _ne_string();
extern string _cond_string();
extern char* _string_to_text();
extern int _check_string();
extern void _text_to_string();
extern void _float();
extern boolean _eq_float();
extern boolean _ne_float();
extern float _cond_float();
extern char* _float_to_text();
extern int _check_float();
extern void _text_to_float();
extern void _double();
extern boolean _eq_double();
extern boolean _ne_double();
extern double _cond_double();
extern char* _double_to_text();
extern int _check_double();
extern void _text_to_double();
extern void _symbolic();
extern boolean _eq_symbolic();
extern boolean _ne_symbolic();
extern symbolic _cond_symbolic();
extern char* _symbolic_to_text();
extern int _check_symbolic();
extern void _text_to_symbolic();
extern char* __PredefinedTypeToText();
#define _true 1
#define _false 0
#define __simple2_GENERIC_TEST(TEST) return TEST;
typedef (*__simple2_APF)();
extern __simple2_APF *__simple2_PActionArray;
extern int **__simple2_PCheckArray;
struct __SourcePoint {
int linkback;
int line;
int column;
int instance_index;
};
struct __InstanceEntry {
char *module_name;
int father_index;
char *dir_name;
char *file_name;
struct __SourcePoint source_point;
struct __SourcePoint end_point;
struct __SourcePoint instance_point;
};
struct __TaskEntry {
char *name;
int   nb_args_ref;
int   nb_args_val;
int  *type_codes_array;
struct __SourcePoint source_point;
};
struct __SignalEntry {
char *name;
int code;
int variable_index;
int present;
struct __SourcePoint source_point;
};
struct __InputEntry {
char *name;
int hash;
char *type_name;
int is_a_sensor;
int type_code;
int multiple;
int signal_index;
int (*p_check_input)();
int (*p_input_function)();
int present;
struct __SourcePoint source_point;
};
struct __ReturnEntry {
char *name;
int hash;
char *type_name;
int type_code;
int signal_index;
int exec_index;
int (*p_check_input)();
int (*p_input_function)();
int present;
struct __SourcePoint source_point;
};
struct __ImplicationEntry {
int master;
int slave;
struct __SourcePoint source_point;
};
struct __ExclusionEntry {
int *exclusion_list;
struct __SourcePoint source_point;
};
struct __VariableEntry {
char *full_name;
char *short_name;
char *type_name;
int type_code;
int comment_kind;
int is_initialized;
char *p_variable;
char *source_name;
int written;
unsigned char written_in_transition;
unsigned char read_in_transition;
struct __SourcePoint source_point;
};
struct __ExecEntry {
int task_index;
int *var_indexes_array;
char **p_values_array;
struct __SourcePoint source_point;
};
struct __HaltEntry {
struct __SourcePoint source_point;
};
struct __NetEntry {
int known;
int value;
int number_of_source_points;
struct __SourcePoint* source_point_array;
};
struct __ModuleEntry {
char *version_id;
char *name;
int number_of_instances;
int number_of_tasks;
int number_of_signals;
int number_of_inputs;
int number_of_returns;
int number_of_sensors;
int number_of_outputs;
int number_of_locals;
int number_of_exceptions;
int number_of_implications;
int number_of_exclusions;
int number_of_variables;
int number_of_execs;
int number_of_halts;
int number_of_nets;
int number_of_states;
int state;
unsigned short *halt_list;
unsigned short *awaited_list;
unsigned short *emitted_list;
unsigned short *started_list;
unsigned short *killed_list;
unsigned short *suspended_list;
unsigned short *active_list;
int run_time_error_code;
int error_info;
int (*init)();
int (*run)();
int (*reset)();
char *(*show_variable)();
int (*set_variable)();
int (*check_value)();
int (*execute_action)();
struct __InstanceEntry* instance_table;
struct __TaskEntry* task_table;
struct __SignalEntry* signal_table;
struct __InputEntry* input_table;
struct __ReturnEntry* return_table;
struct __ImplicationEntry* implication_table;
struct __ExclusionEntry* exclusion_table;
struct __VariableEntry* variable_table;
struct __ExecEntry* exec_table;
struct __HaltEntry* halt_table;
struct __NetEntry* net_table;
};

                  
/* EXTERN DECLARATIONS */

extern int __CheckVariables();
extern __ResetInput();
extern __ResetExecs();
extern __ResetVariables();
extern __ResetVariableStatus();
extern __AppendToList();
extern __ListCopy();
#ifndef _NO_EXTERN_DEFINITIONS
#endif

/* INITIALIZED CONSTANTS */

/* MEMORY ALLOCATION */

static boolean __simple2_V0;
static boolean __simple2_V1;
static boolean __simple2_V2;
static boolean __simple2_V3;

static unsigned short __simple2_HaltList[5];
static unsigned short __simple2_AwaitedList[8];
static unsigned short __simple2_EmittedList[8];
static unsigned short __simple2_StartedList[1];
static unsigned short __simple2_KilledList[1];
static unsigned short __simple2_SuspendedList[1];
static unsigned short __simple2_ActiveList[1];
static unsigned short __simple2_AllAwaitedList[8]={4,0,1,2,3};


/* INPUT FUNCTIONS */

simple2_I_rt_methane () {
__simple2_V0 = _true;
}
simple2_IS_rt_methane () {
__simple2_V0 = _true;
}
simple2_I_hi_methane () {
__simple2_V1 = _true;
}
simple2_IS_hi_methane () {
__simple2_V1 = _true;
}
simple2_I_hw_level () {
__simple2_V2 = _true;
}
simple2_IS_hw_level () {
__simple2_V2 = _true;
}
simple2_I_lw_level () {
__simple2_V3 = _true;
}
simple2_IS_lw_level () {
__simple2_V3 = _true;
}

/* FUNCTIONS RETURNING NUMBER OF EXEC */

int simple2_number_of_execs () {
return (0);
}


/* AUTOMATON (STATE ACTION-TREES) */

/* ACTIONS */

/* PREDEFINED ACTIONS */

/* PRESENT SIGNAL TESTS */

static int __simple2_A1 () {
__simple2_GENERIC_TEST(__simple2_V0);
}
static int __simple2_Check1 [] = {1,0,0};
static int __simple2_A2 () {
__simple2_GENERIC_TEST(__simple2_V1);
}
static int __simple2_Check2 [] = {1,0,0};
static int __simple2_A3 () {
__simple2_GENERIC_TEST(__simple2_V2);
}
static int __simple2_Check3 [] = {1,0,0};
static int __simple2_A4 () {
__simple2_GENERIC_TEST(__simple2_V3);
}
static int __simple2_Check4 [] = {1,0,0};

/* OUTPUT ACTIONS */

static int __simple2_A5 () {
#ifdef __OUTPUT
simple2_O_alarm();
#endif
__AppendToList(__simple2_EmittedList,4);
return 0;
}
static int __simple2_Check5 [] = {1,0,0};
static int __simple2_A6 () {
#ifdef __OUTPUT
simple2_O_strt_pump();
#endif
__AppendToList(__simple2_EmittedList,5);
return 0;
}
static int __simple2_Check6 [] = {1,0,0};
static int __simple2_A7 () {
#ifdef __OUTPUT
simple2_O_stop_pump();
#endif
__AppendToList(__simple2_EmittedList,6);
return 0;
}
static int __simple2_Check7 [] = {1,0,0};

/* ASSIGNMENTS */

/* PROCEDURE CALLS */

/* CONDITIONS */

/* DECREMENTS */

/* START ACTIONS */

/* KILL ACTIONS */

/* SUSPEND ACTIONS */

/* ACTIVATE ACTIONS */

/* WRITE ARGS ACTIONS */

/* RESET ACTIONS */

/* ACTION SEQUENCES */


static int *__simple2_CheckArray[] = {
0,__simple2_Check1,__simple2_Check2,__simple2_Check3,__simple2_Check4,__simple2_Check5,__simple2_Check6,__simple2_Check7
};
static int **__simple2_PCheckArray =  __simple2_CheckArray;

/* INIT FUNCTION */

#ifndef NO_INIT
simple2_initialize () {
}
#endif

/* SHOW VARIABLE FUNCTION */

char* __simple2_show_variable (__V) int __V; {
extern struct __VariableEntry __simple2_VariableTable[];
struct __VariableEntry* p_var = &__simple2_VariableTable[__V];
if (p_var->type_code < 0) {return __PredefinedTypeToText(p_var->type_code, p_var->p_variable);
} else {
switch (p_var->type_code) {
default: return 0;
}
}
}

/* SET VARIABLE FUNCTION */

static __simple2_set_variable(__Type, __pVar, __Text)
int __Type; char* __pVar; char* __Text; {
}

/* CHECK VALUE FUNCTION */

static int __simple2_check_value (__Type,__Text) 
int __Type; char* __Text; {
}

/* SIMULATION TABLES */

struct __InstanceEntry __simple2_InstanceTable [] = {
{"simple2",0,"","pump.strl",{1,46,1,0},{1,65,1,0},{0,0,0,0}},
};

struct __SignalEntry __simple2_SignalTable [] = {
{"rt_methane",33,0,0,{1,48,7,0}},
{"hi_methane",33,0,0,{1,48,19,0}},
{"hw_level",33,0,0,{1,48,30,0}},
{"lw_level",33,0,0,{1,48,39,0}},
{"alarm",34,0,0,{1,49,8,0}},
{"strt_pump",34,0,0,{1,49,15,0}},
{"stop_pump",34,0,0,{1,49,25,0}}};

struct __InputEntry __simple2_InputTable [] = {
{"rt_methane",53,0,0,-1,0,0,0,simple2_IS_rt_methane,0,{1,48,7,0}},
{"hi_methane",32,0,0,-1,0,1,0,simple2_IS_hi_methane,0,{1,48,19,0}},
{"hw_level",46,0,0,-1,0,2,0,simple2_IS_hw_level,0,{1,48,30,0}},
{"lw_level",50,0,0,-1,0,3,0,simple2_IS_lw_level,0,{1,48,39,0}}};

struct __VariableEntry __simple2_VariableTable [] = {
{"__simple2_V0","V0","boolean",-2,2,0,(char*)&__simple2_V0,"rt_methane",0,0,0,{1,48,7,0}},
{"__simple2_V1","V1","boolean",-2,2,0,(char*)&__simple2_V1,"hi_methane",0,0,0,{1,48,19,0}},
{"__simple2_V2","V2","boolean",-2,2,0,(char*)&__simple2_V2,"hw_level",0,0,0,{1,48,30,0}},
{"__simple2_V3","V3","boolean",-2,2,0,(char*)&__simple2_V3,"lw_level",0,0,0,{1,48,39,0}}
};

struct __HaltEntry __simple2_HaltTable [] = {
{{1,65,1,0}},
{{1,54,15,0}},
{{1,56,15,0}},
{{1,62,4,0}}
};


static __simple2__reset_input () {
__simple2_V0 = _false;
__simple2_V1 = _false;
__simple2_V2 = _false;
__simple2_V3 = _false;
}


/* MODULE DATA FOR SIMULATION */

int simple2();
int simple2_reset();

static struct __ModuleEntry __simple2_ModuleData = {
"Simulation interface release 4","simple2",
1,0,7,4,0,0,3,0,0,0,0,4,0,4,0,0,0,
__simple2_HaltList,
__simple2_AwaitedList,
__simple2_EmittedList,
__simple2_StartedList,
__simple2_KilledList,
__simple2_SuspendedList,
__simple2_ActiveList,
0,0,
simple2_initialize,simple2,simple2_reset,
__simple2_show_variable,__simple2_set_variable,__simple2_check_value,0,
__simple2_InstanceTable,
0,
__simple2_SignalTable,__simple2_InputTable,0,
0,0,
__simple2_VariableTable,
0,
__simple2_HaltTable,
0};

/* REDEFINABLE BIT TYPE */

#ifndef __SSC_BIT_TYPE_DEFINED
typedef char __SSC_BIT_TYPE;
#endif

/* REGISTER VARIABLES */

static __SSC_BIT_TYPE __simple2_R[4] = {_true,_false,_false,_false};

/* AUTOMATON ENGINE */

int simple2 () {
/* AUXILIARY VARIABLES */

static __SSC_BIT_TYPE E[7];

__simple2_ModuleData.awaited_list = __simple2_AwaitedList;
__ResetModuleEntryBeforeReaction();
E[0] = (__simple2_R[1]||__simple2_R[2]);
E[1] = (E[0]&&(__CheckVariables(__simple2_CheckArray[2]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 2\n"),
#endif
__simple2_A2()));
if (E[1]) {
__AppendToList(__simple2_EmittedList,4);
}
if (E[1]) {
__CheckVariables(__simple2_CheckArray[5]);__simple2_A5();
#ifdef TRACE_ACTION
fprintf(stderr, "__abc_A5\n");
#endif
}
E[2] = (E[0]&&!((__CheckVariables(__simple2_CheckArray[2]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 2\n"),
#endif
__simple2_A2())));
E[3] = (__simple2_R[1]&&E[2]);
E[4] = (E[3]&&(__CheckVariables(__simple2_CheckArray[3]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 3\n"),
#endif
__simple2_A3()));
if (E[4]) {
__AppendToList(__simple2_EmittedList,5);
}
if (E[4]) {
__CheckVariables(__simple2_CheckArray[6]);__simple2_A6();
#ifdef TRACE_ACTION
fprintf(stderr, "__abc_A6\n");
#endif
}
E[2] = (__simple2_R[2]&&E[2]);
E[5] = (E[2]&&(__CheckVariables(__simple2_CheckArray[4]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 4\n"),
#endif
__simple2_A4()));
if ((E[1]||E[5])) {
__AppendToList(__simple2_EmittedList,6);
}
if (((E[1]||E[5]))) {
__CheckVariables(__simple2_CheckArray[7]);__simple2_A7();
#ifdef TRACE_ACTION
fprintf(stderr, "__abc_A7\n");
#endif
}
E[6] = !(_true);
__simple2_R[1] = (((__simple2_R[0]||((((E[3]&&!((__CheckVariables(__simple2_CheckArray[3]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 3\n"),
#endif
__simple2_A3()))))&&__simple2_R[1])))||((__simple2_R[3]&&(__CheckVariables(__simple2_CheckArray[1]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 1\n"),
#endif
__simple2_A1()))))||E[5]);
E[3] = (E[1]||((((__simple2_R[3]&&!((__CheckVariables(__simple2_CheckArray[1]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 1\n"),
#endif
__simple2_A1()))))&&__simple2_R[3])));
__simple2_R[2] = (E[4]||((((E[2]&&!((__CheckVariables(__simple2_CheckArray[4]),
#ifdef TRACE_ACTION
fprintf(stderr, "test 4\n"),
#endif
__simple2_A4()))))&&__simple2_R[2])));
E[2] = ((__simple2_R[1]||E[3])||__simple2_R[2]);
E[0] = (E[0]||__simple2_R[3]);
__simple2_R[0] = !(_true);
if (__simple2_R[1]) { __AppendToList(__simple2_HaltList,1); }
if (__simple2_R[2]) { __AppendToList(__simple2_HaltList,2); }
__simple2_R[3] = E[3];
if (__simple2_R[3]) { __AppendToList(__simple2_HaltList,3); }
if (!E[2]) { __AppendToList(__simple2_HaltList,0); }
__ResetModuleEntryAfterReaction();
__simple2_ModuleData.awaited_list = __simple2_AllAwaitedList;
__simple2__reset_input();
return E[2];
}

/* AUTOMATON RESET */

int simple2_reset () {
__simple2_ModuleData.awaited_list = __simple2_AwaitedList;
__ResetModuleEntry();
__simple2_ModuleData.awaited_list = __simple2_AllAwaitedList;
__simple2_ModuleData.state = 0;
__simple2_R[0] = _true;
__simple2_R[1] = _false;
__simple2_R[2] = _false;
__simple2_R[3] = _false;
__simple2__reset_input();
return 0;
}
char* CompilationType = "Compiled Sorted Equations";

int __NumberOfModules = 1;
struct __ModuleEntry* __ModuleTable[] = {
&__simple2_ModuleData
};