Simulink Embedded Codder C-Code Compiler Error

Question

Version: MATLAB_R2024_A Computer: Macbook Air M2 (ARM64) Purpose: Simulink-Program -> Embedded-Coder -> C-Code -> Error-Compiling

I've built a basic Simulink program (testing purpose) for which I generated C-Code (with main-function) using Simulinks Embedded Coder. I tried to compile the received code in Visual Studio Code. Unfortunately I get an error message and I don't really know how to fix it.

The error message:

[Running] cd "/path/CodeGenerationMontags_ert_rtw/" && gcc ert_main.c -o ert_main && "/path/CodeGenerationMontags_ert_rtw/"ert_main
Undefined symbols for architecture arm64:
  "_CodeGenerationMontags_M", referenced from:
      _rt_OneStep in ert_main-50dd2d.o
      _main in ert_main-50dd2d.o
      _main in ert_main-50dd2d.o
  "_CodeGenerationMontags_initialize", referenced from:
      _main in ert_main-50dd2d.o
  "_CodeGenerationMontags_step", referenced from:
      _rt_OneStep in ert_main-50dd2d.o
  "_CodeGenerationMontags_terminate", referenced from:
      _main in ert_main-50dd2d.o
ld: symbol(s) not found for architecture arm64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

[Done] exited with code=1 in 0.471 seconds

Structure of program

What I already tried?

• receiving the Code as an Zip-file (therefore all the dependencies are included, e.g. tmwtypes.h)
• including libraries manually

What could be wrong?

• the error indicates that the linker cannot find the symbols for the functions and variables used in my code. It should included in the compilation and linking process. Yet I do not know how to fix it..

I hope it is understandable even without the code snippets. I appreciate any help! Thanks in advance.

Leopold

ert_main.c

#include <stddef.h>
#include <stdio.h>            /* This example main program uses printf/fflush */
#include "CodeGenerationMontags.h"     /* Model header file */

/*
 * Associating rt_OneStep with a real-time clock or interrupt service routine
 * is what makes the generated code "real-time".  The function rt_OneStep is
 * always associated with the base rate of the model.  Subrates are managed
 * by the base rate from inside the generated code.  Enabling/disabling
 * interrupts and floating point context switches are target specific.  This
 * example code indicates where these should take place relative to executing
 * the generated code step function.  Overrun behavior should be tailored to
 * your application needs.  This example simply sets an error status in the
 * real-time model and returns from rt_OneStep.
 */
void rt_OneStep(void);
void rt_OneStep(void)
{
  static boolean_T OverrunFlag = false;

  /* Disable interrupts here */

  /* Check for overrun */
  if (OverrunFlag) {
    rtmSetErrorStatus(CodeGenerationMontags_M, "Overrun");
    return;
  }

  OverrunFlag = true;

  /* Save FPU context here (if necessary) */
  /* Re-enable timer or interrupt here */
  /* Set model inputs here */

  /* Step the model */
  CodeGenerationMontags_step();

  /* Get model outputs here */

  /* Indicate task complete */
  OverrunFlag = false;

  /* Disable interrupts here */
  /* Restore FPU context here (if necessary) */
  /* Enable interrupts here */
}

/*
 * The example main function illustrates what is required by your
 * application code to initialize, execute, and terminate the generated code.
 * Attaching rt_OneStep to a real-time clock is target specific. This example
 * illustrates how you do this relative to initializing the model.
 */
int_T main(int_T argc, const char *argv[])
{
  /* Unused arguments */
  (void)(argc);
  (void)(argv);

  /* Initialize model */
  CodeGenerationMontags_initialize();

  /* Simulating the model step behavior (in non real-time) to
   *  simulate model behavior at stop time.
   */
  while (rtmGetErrorStatus(CodeGenerationMontags_M) == (NULL)&&
         !rtmGetStopRequested(CodeGenerationMontags_M)) {
    rt_OneStep();
  }

  /* Terminate model */
  CodeGenerationMontags_terminate();
  return 0;
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */

CodeGenerationMontags.c:

#include "CodeGenerationMontags.h"
#include "rtwtypes.h"
#include "CodeGenerationMontags_private.h"
#include <math.h>

/* Block signals (default storage) */
B_CodeGenerationMontags_T CodeGenerationMontags_B;

/* Continuous states */
X_CodeGenerationMontags_T CodeGenerationMontags_X;

/* Disabled State Vector */
XDis_CodeGenerationMontags_T CodeGenerationMontags_XDis;

/* Real-time model */
static RT_MODEL_CodeGenerationMontag_T CodeGenerationMontags_M_;
RT_MODEL_CodeGenerationMontag_T *const CodeGenerationMontags_M =
  &CodeGenerationMontags_M_;

/*
 * This function updates continuous states using the ODE4 fixed-step
 * solver algorithm
 */
static void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si )
{
  time_T t = rtsiGetT(si);
  time_T tnew = rtsiGetSolverStopTime(si);
  time_T h = rtsiGetStepSize(si);
  real_T *x = rtsiGetContStates(si);
  ODE4_IntgData *id = (ODE4_IntgData *)rtsiGetSolverData(si);
  real_T *y = id->y;
  real_T *f0 = id->f[0];
  real_T *f1 = id->f[1];
  real_T *f2 = id->f[2];
  real_T *f3 = id->f[3];
  real_T temp;
  int_T i;
  int_T nXc = 1;
  rtsiSetSimTimeStep(si,MINOR_TIME_STEP);

  /* Save the state values at time t in y, we'll use x as ynew. */
  (void) memcpy(y, x,
                (uint_T)nXc*sizeof(real_T));

  /* Assumes that rtsiSetT and ModelOutputs are up-to-date */
  /* f0 = f(t,y) */
  rtsiSetdX(si, f0);
  CodeGenerationMontags_derivatives();

  /* f1 = f(t + (h/2), y + (h/2)*f0) */
  temp = 0.5 * h;
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (temp*f0[i]);
  }

  rtsiSetT(si, t + temp);
  rtsiSetdX(si, f1);
  CodeGenerationMontags_step();
  CodeGenerationMontags_derivatives();

  /* f2 = f(t + (h/2), y + (h/2)*f1) */
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (temp*f1[i]);
  }

  rtsiSetdX(si, f2);
  CodeGenerationMontags_step();
  CodeGenerationMontags_derivatives();

  /* f3 = f(t + h, y + h*f2) */
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (h*f2[i]);
  }

  rtsiSetT(si, tnew);
  rtsiSetdX(si, f3);
  CodeGenerationMontags_step();
  CodeGenerationMontags_derivatives();

  /* tnew = t + h
     ynew = y + (h/6)*(f0 + 2*f1 + 2*f2 + 2*f3) */
  temp = h / 6.0;
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + temp*(f0[i] + 2.0*f1[i] + 2.0*f2[i] + f3[i]);
  }

  rtsiSetSimTimeStep(si,MAJOR_TIME_STEP);
}

/*
 * Output and update for atomic system:
 *    '<Root>/1//RC1'
 *    '<Root>/1//RC2'
 */
void CodeGenerationMontags_uRC1(real_T rtu_u, real_T *rty_y)
{
  *rty_y = 10000.0 * rtu_u;
}

/* Model step function */
void CodeGenerationMontags_step(void)
{
  real_T rtb_y;
  real_T rtb_y_i;
  if (rtmIsMajorTimeStep(CodeGenerationMontags_M)) {
    /* set solver stop time */
    rtsiSetSolverStopTime(&CodeGenerationMontags_M->solverInfo,
                          ((CodeGenerationMontags_M->Timing.clockTick0+1)*
      CodeGenerationMontags_M->Timing.stepSize0));
  }                                    /* end MajorTimeStep */

  /* Update absolute time of base rate at minor time step */
  if (rtmIsMinorTimeStep(CodeGenerationMontags_M)) {
    CodeGenerationMontags_M->Timing.t[0] = rtsiGetT
      (&CodeGenerationMontags_M->solverInfo);
  }

  /* MATLAB Function: '<Root>/1//RC1' incorporates:
   *  Integrator: '<Root>/Integrator'
   */
  CodeGenerationMontags_uRC1(CodeGenerationMontags_X.Integrator_CSTATE, &rtb_y_i);

  /* MATLAB Function: '<Root>/1//RC2' incorporates:
   *  Sin: '<Root>/U_E'
   */
  CodeGenerationMontags_uRC1(sin(31415.9265 * CodeGenerationMontags_M->Timing.t
    [0]), &rtb_y);

  /* Sum: '<Root>/Sum' */
  CodeGenerationMontags_B.U_Addt = rtb_y - rtb_y_i;
  if (rtmIsMajorTimeStep(CodeGenerationMontags_M)) {
    rt_ertODEUpdateContinuousStates(&CodeGenerationMontags_M->solverInfo);

    /* Update absolute time for base rate */
    /* The "clockTick0" counts the number of times the code of this task has
     * been executed. The absolute time is the multiplication of "clockTick0"
     * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not
     * overflow during the application lifespan selected.
     */
    ++CodeGenerationMontags_M->Timing.clockTick0;
    CodeGenerationMontags_M->Timing.t[0] = rtsiGetSolverStopTime
      (&CodeGenerationMontags_M->solverInfo);

    {
      /* Update absolute timer for sample time: [6.66671111140741E-5s, 0.0s] */
      /* The "clockTick1" counts the number of times the code of this task has
       * been executed. The resolution of this integer timer is 6.66671111140741E-5, which is the step size
       * of the task. Size of "clockTick1" ensures timer will not overflow during the
       * application lifespan selected.
       */
      CodeGenerationMontags_M->Timing.clockTick1++;
    }
  }                                    /* end MajorTimeStep */
}

/* Derivatives for root system: '<Root>' */
void CodeGenerationMontags_derivatives(void)
{
  XDot_CodeGenerationMontags_T *_rtXdot;
  _rtXdot = ((XDot_CodeGenerationMontags_T *) CodeGenerationMontags_M->derivs);

  /* Derivatives for Integrator: '<Root>/Integrator' */
  _rtXdot->Integrator_CSTATE = CodeGenerationMontags_B.U_Addt;
}

/* Model initialize function */
void CodeGenerationMontags_initialize(void)
{
  /* Registration code */
  {
    /* Setup solver object */
    rtsiSetSimTimeStepPtr(&CodeGenerationMontags_M->solverInfo,
                          &CodeGenerationMontags_M->Timing.simTimeStep);
    rtsiSetTPtr(&CodeGenerationMontags_M->solverInfo, &rtmGetTPtr
                (CodeGenerationMontags_M));
    rtsiSetStepSizePtr(&CodeGenerationMontags_M->solverInfo,
                       &CodeGenerationMontags_M->Timing.stepSize0);
    rtsiSetdXPtr(&CodeGenerationMontags_M->solverInfo,
                 &CodeGenerationMontags_M->derivs);
    rtsiSetContStatesPtr(&CodeGenerationMontags_M->solverInfo, (real_T **)
                         &CodeGenerationMontags_M->contStates);
    rtsiSetNumContStatesPtr(&CodeGenerationMontags_M->solverInfo,
      &CodeGenerationMontags_M->Sizes.numContStates);
    rtsiSetNumPeriodicContStatesPtr(&CodeGenerationMontags_M->solverInfo,
      &CodeGenerationMontags_M->Sizes.numPeriodicContStates);
    rtsiSetPeriodicContStateIndicesPtr(&CodeGenerationMontags_M->solverInfo,
      &CodeGenerationMontags_M->periodicContStateIndices);
    rtsiSetPeriodicContStateRangesPtr(&CodeGenerationMontags_M->solverInfo,
      &CodeGenerationMontags_M->periodicContStateRanges);
    rtsiSetContStateDisabledPtr(&CodeGenerationMontags_M->solverInfo, (boolean_T**)
      &CodeGenerationMontags_M->contStateDisabled);
    rtsiSetErrorStatusPtr(&CodeGenerationMontags_M->solverInfo,
                          (&rtmGetErrorStatus(CodeGenerationMontags_M)));
    rtsiSetRTModelPtr(&CodeGenerationMontags_M->solverInfo,
                      CodeGenerationMontags_M);
  }

  rtsiSetSimTimeStep(&CodeGenerationMontags_M->solverInfo, MAJOR_TIME_STEP);
  rtsiSetIsMinorTimeStepWithModeChange(&CodeGenerationMontags_M->solverInfo,
    false);
  rtsiSetIsContModeFrozen(&CodeGenerationMontags_M->solverInfo, false);
  CodeGenerationMontags_M->intgData.y = CodeGenerationMontags_M->odeY;
  CodeGenerationMontags_M->intgData.f[0] = CodeGenerationMontags_M->odeF[0];
  CodeGenerationMontags_M->intgData.f[1] = CodeGenerationMontags_M->odeF[1];
  CodeGenerationMontags_M->intgData.f[2] = CodeGenerationMontags_M->odeF[2];
  CodeGenerationMontags_M->intgData.f[3] = CodeGenerationMontags_M->odeF[3];
  CodeGenerationMontags_M->contStates = ((X_CodeGenerationMontags_T *)
    &CodeGenerationMontags_X);
  CodeGenerationMontags_M->contStateDisabled = ((XDis_CodeGenerationMontags_T *)
    &CodeGenerationMontags_XDis);
  CodeGenerationMontags_M->Timing.tStart = (0.0);
  rtsiSetSolverData(&CodeGenerationMontags_M->solverInfo, (void *)
                    &CodeGenerationMontags_M->intgData);
  rtsiSetSolverName(&CodeGenerationMontags_M->solverInfo,"ode4");
  rtmSetTPtr(CodeGenerationMontags_M, &CodeGenerationMontags_M->Timing.tArray[0]);
  CodeGenerationMontags_M->Timing.stepSize0 = 6.66671111140741E-5;

  /* InitializeConditions for Integrator: '<Root>/Integrator' */
  CodeGenerationMontags_X.Integrator_CSTATE = 0.0;
}

/* Model terminate function */
void CodeGenerationMontags_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */

CodeGenerationMontags.h:

#ifndef CodeGenerationMontags_h_
#define CodeGenerationMontags_h_
#ifndef CodeGenerationMontags_COMMON_INCLUDES_
#define CodeGenerationMontags_COMMON_INCLUDES_
#include "rtwtypes.h"
#include "rtw_continuous.h"
#include "rtw_solver.h"
#include "math.h"
#endif                              /* CodeGenerationMontags_COMMON_INCLUDES_ */

#include "CodeGenerationMontags_types.h"
#include <string.h>

/* Macros for accessing real-time model data structure */
#ifndef rtmGetErrorStatus
#define rtmGetErrorStatus(rtm)         ((rtm)->errorStatus)
#endif

#ifndef rtmSetErrorStatus
#define rtmSetErrorStatus(rtm, val)    ((rtm)->errorStatus = (val))
#endif

#ifndef rtmGetStopRequested
#define rtmGetStopRequested(rtm)       ((rtm)->Timing.stopRequestedFlag)
#endif

#ifndef rtmSetStopRequested
#define rtmSetStopRequested(rtm, val)  ((rtm)->Timing.stopRequestedFlag = (val))
#endif

#ifndef rtmGetStopRequestedPtr
#define rtmGetStopRequestedPtr(rtm)    (&((rtm)->Timing.stopRequestedFlag))
#endif

#ifndef rtmGetT
#define rtmGetT(rtm)                   (rtmGetTPtr((rtm))[0])
#endif

#ifndef rtmGetTPtr
#define rtmGetTPtr(rtm)                ((rtm)->Timing.t)
#endif

#ifndef rtmGetTStart
#define rtmGetTStart(rtm)              ((rtm)->Timing.tStart)
#endif

/* Block signals (default storage) */
typedef struct {
  real_T U_Addt;                       /* '<Root>/Sum' */
} B_CodeGenerationMontags_T;

/* Continuous states (default storage) */
typedef struct {
  real_T Integrator_CSTATE;            /* '<Root>/Integrator' */
} X_CodeGenerationMontags_T;

/* State derivatives (default storage) */
typedef struct {
  real_T Integrator_CSTATE;            /* '<Root>/Integrator' */
} XDot_CodeGenerationMontags_T;

/* State disabled  */
typedef struct {
  boolean_T Integrator_CSTATE;         /* '<Root>/Integrator' */
} XDis_CodeGenerationMontags_T;

#ifndef ODE4_INTG
#define ODE4_INTG

/* ODE4 Integration Data */
typedef struct {
  real_T *y;                           /* output */
  real_T *f[4];                        /* derivatives */
} ODE4_IntgData;

#endif

/* Real-time Model Data Structure */
struct tag_RTM_CodeGenerationMontags_T {
  const char_T *errorStatus;
  RTWSolverInfo solverInfo;
  X_CodeGenerationMontags_T *contStates;
  int_T *periodicContStateIndices;
  real_T *periodicContStateRanges;
  real_T *derivs;
  XDis_CodeGenerationMontags_T *contStateDisabled;
  boolean_T zCCacheNeedsReset;
  boolean_T derivCacheNeedsReset;
  boolean_T CTOutputIncnstWithState;
  real_T odeY[1];
  real_T odeF[4][1];
  ODE4_IntgData intgData;

  /*
   * Sizes:
   * The following substructure contains sizes information
   * for many of the model attributes such as inputs, outputs,
   * dwork, sample times, etc.
   */
  struct {
    int_T numContStates;
    int_T numPeriodicContStates;
    int_T numSampTimes;
  } Sizes;

  /*
   * Timing:
   * The following substructure contains information regarding
   * the timing information for the model.
   */
  struct {
    uint32_T clockTick0;
    time_T stepSize0;
    uint32_T clockTick1;
    time_T tStart;
    SimTimeStep simTimeStep;
    boolean_T stopRequestedFlag;
    time_T *t;
    time_T tArray[2];
  } Timing;
};

/* Block signals (default storage) */
extern B_CodeGenerationMontags_T CodeGenerationMontags_B;

/* Continuous states (default storage) */
extern X_CodeGenerationMontags_T CodeGenerationMontags_X;

/* Disabled states (default storage) */
extern XDis_CodeGenerationMontags_T CodeGenerationMontags_XDis;

/* Model entry point functions */
extern void CodeGenerationMontags_initialize(void);
extern void CodeGenerationMontags_step(void);
extern void CodeGenerationMontags_terminate(void);

/* Real-time Model object */
extern RT_MODEL_CodeGenerationMontag_T *const CodeGenerationMontags_M;

/*-
 * These blocks were eliminated from the model due to optimizations:
 *
 * Block '<Root>/Display' : Unused code path elimination
 * Block '<S3>/Data Type Duplicate' : Unused code path elimination
 * Block '<S3>/MinMax' : Unused code path elimination
 * Block '<S4>/FixPt Data Type Duplicate2' : Unused code path elimination
 * Block '<S4>/Initial Condition' : Unused code path elimination
 * Block '<S4>/Memory' : Unused code path elimination
 * Block '<S4>/Reset' : Unused code path elimination
 * Block '<Root>/Scope' : Unused code path elimination
 */

/*-
 * The generated code includes comments that allow you to trace directly
 * back to the appropriate location in the model.  The basic format
 * is <system>/block_name, where system is the system number (uniquely
 * assigned by Simulink) and block_name is the name of the block.
 *
 * Use the MATLAB hilite_system command to trace the generated code back
 * to the model.  For example,
 *
 * hilite_system('<S3>')    - opens system 3
 * hilite_system('<S3>/Kp') - opens and selects block Kp which resides in S3
 *
 * Here is the system hierarchy for this model
 *
 * '<Root>' : 'CodeGenerationMontags'
 * '<S1>'   : 'CodeGenerationMontags/1//RC1'
 * '<S2>'   : 'CodeGenerationMontags/1//RC2'
 * '<S3>'   : 'CodeGenerationMontags/MinMax Running Resettable'
 * '<S4>'   : 'CodeGenerationMontags/MinMax Running Resettable/Subsystem'
 */
#endif                                 /* CodeGenerationMontags_h_ */

/*
 * File trailer for generated code.
 *
 * [EOF]
 */

CodeGenerationMontags_private.h:

#ifndef CodeGenerationMontags_private_h_
#define CodeGenerationMontags_private_h_
#include "rtwtypes.h"
#include "CodeGenerationMontags_types.h"
#include "CodeGenerationMontags.h"
#include "rtw_continuous.h"
#include "rtw_solver.h"

/* Private macros used by the generated code to access rtModel */
#ifndef rtmIsMajorTimeStep
#define rtmIsMajorTimeStep(rtm)        (((rtm)->Timing.simTimeStep) == MAJOR_TIME_STEP)
#endif

#ifndef rtmIsMinorTimeStep
#define rtmIsMinorTimeStep(rtm)        (((rtm)->Timing.simTimeStep) == MINOR_TIME_STEP)
#endif

#ifndef rtmSetTPtr
#define rtmSetTPtr(rtm, val)           ((rtm)->Timing.t = (val))
#endif

extern void CodeGenerationMontags_uRC1(real_T rtu_u, real_T *rty_y);

/* private model entry point functions */
extern void CodeGenerationMontags_derivatives(void);

#endif                                 /* CodeGenerationMontags_private_h_ */

/*
 * File trailer for generated code.
 *
 * [EOF]
 */

CodeGenerationMontags_types.h:

#ifndef CodeGenerationMontags_types_h_
#define CodeGenerationMontags_types_h_

/* Forward declaration for rtModel */
typedef struct tag_RTM_CodeGenerationMontags_T RT_MODEL_CodeGenerationMontag_T;

#endif                                 /* CodeGenerationMontags_types_h_ */

rtw_continous.h:

#ifndef RTW_CONTINUOUS_H__
#define RTW_CONTINUOUS_H__

#ifdef MATLAB_MEX_FILE
#include "tmwtypes.h"
#else
#include "rtwtypes.h"
#endif

/* For models registering MassMatrix */
typedef enum {
    SS_MATRIX_NONE,
    SS_MATRIX_CONSTANT,
    SS_MATRIX_TIMEDEP,
    SS_MATRIX_STATEDEP
} ssMatrixType;

typedef enum {
    SOLVER_MODE_AUTO, /* only occurs in
                         mdlInitializeSizes/mdlInitializeSampleTimes */
    SOLVER_MODE_SINGLETASKING,
    SOLVER_MODE_MULTITASKING
} SolverMode;

typedef enum { MINOR_TIME_STEP, MAJOR_TIME_STEP } SimTimeStep;

/* =============================================================================
 * Model methods object
 * =============================================================================
 */
typedef void (*rtMdlInitializeSizesFcn)(void* rtModel);
typedef void (*rtMdlInitializeSampleTimesFcn)(void* rtModel);
typedef void (*rtMdlStartFcn)(void* rtModel);
typedef void (*rtMdlOutputsFcn)(void* rtModel, int_T tid);
typedef void (*rtMdlUpdateFcn)(void* rtModel, int_T tid);
typedef void (*rtMdlDerivativesFcn)(void* rtModel);
typedef void (*rtMdlProjectionFcn)(void* rtModel);
typedef void (*rtMdlMassMatrixFcn)(void* rtModel);
typedef void (*rtMdlForcingFunctionFcn)(void* rtModel);
typedef void (*rtMdlTerminateFcn)(void* rtModel);
#ifdef RT_MALLOC
typedef real_T (*rtMdlDiscreteEventsFcn)(void* pModel,
                                         int_T rtmNumSampTimes,
                                         void* rtmTimingData,
                                         int_T* rtmSampleHitPtr,
                                         int_T* rtmPerTaskSampleHits);
#endif

typedef struct _RTWRTModelMethodsInfo_tag {
    void* rtModelPtr;
    rtMdlInitializeSizesFcn rtmInitSizesFcn;
    rtMdlInitializeSampleTimesFcn rtmInitSampTimesFcn;
    rtMdlStartFcn rtmStartFcn;
    rtMdlOutputsFcn rtmOutputsFcn;
    rtMdlUpdateFcn rtmUpdateFcn;
    rtMdlDerivativesFcn rtmDervisFcn;
    rtMdlProjectionFcn rtmProjectionFcn;
    rtMdlMassMatrixFcn rtmMassMatrixFcn;
    rtMdlForcingFunctionFcn rtmForcingFunctionFcn;
    rtMdlTerminateFcn rtmTerminateFcn;
#ifdef RT_MALLOC
    rtMdlDiscreteEventsFcn rtmDiscreteEventsFcn;
#endif
} RTWRTModelMethodsInfo;

#define rtmiSetRTModelPtr(M, rtmp) ((M).rtModelPtr = (rtmp))
#define rtmiGetRTModelPtr(M) (M).rtModelPtr

#define rtmiSetInitSizesFcn(M, fp) ((M).rtmInitSizesFcn = ((rtMdlInitializeSizesFcn)(fp)))
#define rtmiSetInitSampTimesFcn(M, fp) \
    ((M).rtmInitSampTimesFcn = ((rtMdlInitializeSampleTimesFcn)(fp)))
#define rtmiSetStartFcn(M, fp) ((M).rtmStartFcn = ((rtMdlStartFcn)(fp)))
#define rtmiSetOutputsFcn(M, fp) ((M).rtmOutputsFcn = ((rtMdlOutputsFcn)(fp)))
#define rtmiSetUpdateFcn(M, fp) ((M).rtmUpdateFcn = ((rtMdlUpdateFcn)(fp)))
#define rtmiSetDervisFcn(M, fp) ((M).rtmDervisFcn = ((rtMdlDerivativesFcn)(fp)))
#define rtmiSetProjectionFcn(M, fp) ((M).rtmProjectionFcn = ((rtMdlProjectionFcn)(fp)))
#define rtmiSetMassMatrixFcn(M, fp) ((M).rtmMassMatrixFcn = ((rtMdlMassMatrixFcn)(fp)))
#define rtmiSetForcingFunctionFcn(M, fp) \
    ((M).rtmForcingFunctionFcn = ((rtMdlForcingFunctionFcn)(fp)))
#define rtmiSetTerminateFcn(M, fp) ((M).rtmTerminateFcn = ((rtMdlTerminateFcn)(fp)))
#ifdef RT_MALLOC
#define rtmiSetDiscreteEventsFcn(M, fp) ((M).rtmDiscreteEventsFcn = ((rtMdlDiscreteEventsFcn)(fp)))
#endif

#define rtmiInitializeSizes(M) ((*(M).rtmInitSizesFcn)((M).rtModelPtr))
#define rtmiInitializeSampleTimes(M) ((*(M).rtmInitSampTimesFcn)((M).rtModelPtr))
#define rtmiStart(M) ((*(M).rtmStartFcn)((M).rtModelPtr))
#define rtmiOutputs(M, tid) ((*(M).rtmOutputsFcn)((M).rtModelPtr, tid))
#define rtmiUpdate(M, tid) ((*(M).rtmUpdateFcn)((M).rtModelPtr, tid))
#define rtmiDerivatives(M) ((*(M).rtmDervisFcn)((M).rtModelPtr))
#define rtmiProjection(M) ((*(M).rtmProjectionFcn)((M).rtModelPtr))
#define rtmiMassMatrix(M) ((*(M).rtmMassMatrixFcn)((M).rtModelPtr))
#define rtmiForcingFunction(M) ((*(M).rtmForcingFunctionFcn)((M).rtModelPtr))
#define rtmiTerminate(M) ((*(M).rtmTerminateFcn)((M).rtModelPtr))
#ifdef RT_MALLOC
#define rtmiDiscreteEvents(M, x1, x2, x3, x4) \
    ((*(M).rtmDiscreteEventsFcn)((M).rtModelPtr, (x1), (x2), (x3), (x4)))
#endif
#endif /* __RTW_CONTINUOUS_H__ */