/****************************************************************************** * P R O D U C T I O N C E L L *----------------------------------------------------------------------------- * INRIA - Unite de Recherche Rhone-Alpes * 655, avenue de l'Europe * 38330 Montbonnot Saint Martin * FRANCE *----------------------------------------------------------------------------- * Module : gate_functions.c * Auteurs : Hubert GARAVEL et Wendelin SERWE * Version : 1.9 * Date : 2025/08/06 14:36:57 *****************************************************************************/ #include #include /*---------------------------------------------------------------------------*/ #include "caesar_kernel.h" #define CAESAR_ADT_INTERFACE #include "cell.h" /*---------------------------------------------------------------------------*/ static CAESAR_TYPE_BOOLEAN JUST_AFTER_REACT = CAESAR_FALSE; /* * this variable is true immediately after a REACT and will become false * after the next GET_STATUS */ /*---------------------------------------------------------------------------*/ #define exit_if(C) if (C) { exit (0); } /*---------------------------------------------------------------------------*/ #define INPUT_SIZE 1024 char INPUT[INPUT_SIZE]; /*---------------------------------------------------------------------------*/ void REACT () { /* note: there is no gate REACT in the LOTOS / LNT specification */ fprintf (stdout, "react\n"); fflush (stdout); JUST_AFTER_REACT = CAESAR_TRUE; /* to enable GET_STATUS */ } /*---------------------------------------------------------------------------*/ int PRESS_UPWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "press_upward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int PRESS_STOP (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "press_stop\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int PRESS_DOWNWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "press_downward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM1_FORWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm1_forward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM1_STOP (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm1_stop\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM1_BACKWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm1_backward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM2_FORWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm2_forward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM2_STOP (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm2_stop\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM2_BACKWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm2_backward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM1_MAG_ON (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm1_mag_on\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM1_MAG_OFF (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm1_mag_off\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM2_MAG_ON (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm2_mag_on\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ARM2_MAG_OFF (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "arm2_mag_off\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ROBOT_LEFT (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "robot_left\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ROBOT_STOP (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "robot_stop\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int ROBOT_RIGHT (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "robot_right\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int TABLE_LEFT (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "table_left\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int TABLE_STOP_H (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "table_stop_h\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int TABLE_RIGHT (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "table_right\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int TABLE_UPWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "table_upward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int TABLE_STOP_V (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "table_stop_v\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int TABLE_DOWNWARD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "table_downward\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_TO_BELT2 (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_to_belt2\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_STOP_H (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_stop_h\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_TO_BELT1 (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_to_belt1\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_LIFT (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_lift\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_STOP_V (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_stop_v\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_LOWER (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_lower\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_MAG_ON (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_mag_on\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int CRANE_MAG_OFF (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "crane_mag_off\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int BELT1_START (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "belt1_start\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int BELT1_STOP (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "belt1_stop\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int BELT2_START (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "belt2_start\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int BELT2_STOP (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "belt2_stop\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ int BLANK_ADD (CAESAR_KERNEL_OFFER EOL) { CAESAR_KERNEL_ASSERT_EOL (EOL); fprintf (stdout, "blank_add\n"); fflush (stdout); CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (1); return (1); } /*---------------------------------------------------------------------------*/ void PARSE_ERROR_LIST (CAESAR_TYPE_FILE F, char *S) { /* * This function is called by GET_STATUS() below to parse string S; if * this string is different from "{0}", it denotes an error message that * will be dumped to file F */ exit_if (S == NULL); /* corrupted input, should not occur */ exit_if (*S != '{'); /* corrupted input, should not occur */ ++S; while (1) { switch (*S) { case '0': /* no error */ return; case '2': fprintf (F, "collision between feed belt and table\n"); break; case '3': fprintf (F, "table reached right stop\n"); break; case '4': fprintf (F, "robot reached left stop\n"); break; case '5': fprintf (F, "robot reached right stop\n"); break; case '6': fprintf (F, "arm1 dropped a blank\n"); break; case '7': fprintf (F, "collision between arm1 and press\n"); break; case '8': fprintf (F, "arm2 dropped a blank\n"); break; case '9': fprintf (F, "collision between arm2 and press\n"); break; case '1': ++S; switch (*S) { case ' ': case '}': fprintf (F, "blank dropped between feed belt and table\n"); break; case '0': fprintf (F, "blank from the deposit belt\n"); break; case '1': fprintf (F, "collision between crane and deposit belt\n"); break; case '2': fprintf (F, "collision between crane and feed belt\n"); break; case '3': fprintf (F, "crane dropped a blank\n"); break; case '4': fprintf (F, "crane reached stop over feed belt\n"); break; case '5': fprintf (F, "crane reached stop over deposit belt\n"); break; } --S; break; case ' ': /* continue with next character */ break; case '}': /* no further error code */ exit (1); } ++S; } } /*---------------------------------------------------------------------------*/ int GET_STATUS (CAESAR_KERNEL_OFFER INPUT1, char *BOOL1, ADT_BOOL * S1, CAESAR_KERNEL_OFFER INPUT2, char *BOOL2, ADT_BOOL * S2, CAESAR_KERNEL_OFFER INPUT3, char *BOOL3, ADT_BOOL * S3, CAESAR_KERNEL_OFFER INPUT4, char *REAL1, ADT_REAL * S4, CAESAR_KERNEL_OFFER INPUT5, char *REAL2, ADT_REAL * S5, CAESAR_KERNEL_OFFER INPUT6, char *REAL3, ADT_REAL * S6, CAESAR_KERNEL_OFFER INPUT7, char *BOOL4, ADT_BOOL * S7, CAESAR_KERNEL_OFFER INPUT8, char *BOOL5, ADT_BOOL * S8, CAESAR_KERNEL_OFFER INPUT9, char *REAL4, ADT_REAL * S9, CAESAR_KERNEL_OFFER INPUT10, char *BOOL6, ADT_BOOL * S10, CAESAR_KERNEL_OFFER INPUT11, char *BOOL7, ADT_BOOL * S11, CAESAR_KERNEL_OFFER INPUT12, char *REAL5, ADT_REAL * S12, CAESAR_KERNEL_OFFER INPUT13, char *BOOL8, ADT_BOOL * S13, CAESAR_KERNEL_OFFER INPUT14, char *BOOL9, ADT_BOOL * S14, CAESAR_KERNEL_OFFER INPUT15, char *STRING, ADT_STRING * S15, CAESAR_KERNEL_OFFER EOL) { char *RESULT; CAESAR_KERNEL_ASSERT_INPUT (INPUT1); CAESAR_KERNEL_ASSERT_INPUT (INPUT2); CAESAR_KERNEL_ASSERT_INPUT (INPUT3); CAESAR_KERNEL_ASSERT_INPUT (INPUT4); CAESAR_KERNEL_ASSERT_INPUT (INPUT5); CAESAR_KERNEL_ASSERT_INPUT (INPUT6); CAESAR_KERNEL_ASSERT_INPUT (INPUT7); CAESAR_KERNEL_ASSERT_INPUT (INPUT8); CAESAR_KERNEL_ASSERT_INPUT (INPUT9); CAESAR_KERNEL_ASSERT_INPUT (INPUT10); CAESAR_KERNEL_ASSERT_INPUT (INPUT11); CAESAR_KERNEL_ASSERT_INPUT (INPUT12); CAESAR_KERNEL_ASSERT_INPUT (INPUT13); CAESAR_KERNEL_ASSERT_INPUT (INPUT14); CAESAR_KERNEL_ASSERT_INPUT (INPUT15); CAESAR_KERNEL_ASSERT_TYPE (BOOL1, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL2, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL3, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL4, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL5, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL6, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL7, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL8, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (BOOL9, "ADT_BOOL"); CAESAR_KERNEL_ASSERT_TYPE (REAL1, "ADT_REAL"); CAESAR_KERNEL_ASSERT_TYPE (REAL2, "ADT_REAL"); CAESAR_KERNEL_ASSERT_TYPE (REAL3, "ADT_REAL"); CAESAR_KERNEL_ASSERT_TYPE (REAL4, "ADT_REAL"); CAESAR_KERNEL_ASSERT_TYPE (REAL5, "ADT_REAL"); CAESAR_KERNEL_ASSERT_TYPE (STRING, "ADT_STRING"); CAESAR_KERNEL_ASSERT_EOL (EOL); if (JUST_AFTER_REACT == CAESAR_FALSE) { /* GET_STATUS is only permitted after a REACT */ CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_RESULT (0); return (0); } fprintf (stdout, "do_get_status\n"); fflush (stdout); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S1 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S2 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S3 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ INPUT[strlen (INPUT) - 1] = '\0'; *S4 = (ADT_REAL) atof (INPUT); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ INPUT[strlen (INPUT) - 1] = '\0'; *S5 = (ADT_REAL) atof (INPUT); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ INPUT[strlen (INPUT) - 1] = '\0'; *S6 = (ADT_REAL) atof (INPUT); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S7 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S8 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ INPUT[strlen (INPUT) - 1] = '\0'; *S9 = (ADT_REAL) atof (INPUT); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S10 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S11 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ INPUT[strlen (INPUT) - 1] = '\0'; *S12 = (ADT_REAL) atof (INPUT); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S13 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ *S14 = (ADT_BOOL) ((INPUT[0] == '1') ? ADT_TRUE () : ADT_FALSE ()); RESULT = fgets (INPUT, INPUT_SIZE, stdin); exit_if (RESULT == NULL); /* end-of-file on stdin (broken pipe) */ PARSE_ERROR_LIST (stderr, INPUT); *S15 = INPUT; CAESAR_KERNEL_LOG_GATE (__func__); CAESAR_KERNEL_LOG_OFFER (INPUT1, BOOL1, *S1, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT2, BOOL2, *S2, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT3, BOOL3, *S3, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT4, REAL1, *S4, ADT_PRINT_REAL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT5, REAL2, *S5, ADT_PRINT_REAL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT6, REAL3, *S6, ADT_PRINT_REAL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT7, BOOL4, *S7, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT8, BOOL5, *S8, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT9, REAL4, *S9, ADT_PRINT_REAL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT10, BOOL6, *S10, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT11, BOOL7, *S11, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT12, REAL5, *S12, ADT_PRINT_REAL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT13, BOOL8, *S13, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT14, BOOL9, *S14, ADT_PRINT_BOOL, 1); CAESAR_KERNEL_LOG_OFFER (INPUT15, STRING, *S15, ADT_PRINT_STRING, 1); CAESAR_KERNEL_LOG_RESULT (1); JUST_AFTER_REACT = CAESAR_FALSE; return (1); } /*---------------------------------------------------------------------------*/