Generate code for a MATLAB function that takes structure inputs.

1. Write a MATLAB function, topfun, that assigns the name MyStruct to its input parameter.

   function y = topfun(x)   %#codegen
   % Assign the name 'MyStruct' to the input variable in 
   % the generated code
     coder.cstructname(x, 'MyStruct');
     y = x;
   end

2. Declare a structure s in MATLAB. s is the structure definition for the input variable x.

   s = struct('a',42,'b',4711);

3. Generate a MEX function for topfun, using the -args option to specify that the input parameter is a structure.

   codegen topfun.m -args { s }

   codegen generates a MEX function in the default folder codegen\mex\topfun. In this folder, the structure definition is in topfun_types.h.

   typedef struct
   {
       double a;
       double b;
   } MyStruct;

Assign the name MyStruct to the structure var. Pass the structure to a C function use_struct.

1. Create a C header file, use_struct.h, for a use_structfunction that takes a parameter of type MyStruct. Define a structure of type MyStruct in the header file.

   #ifdef MATLAB_MEX_FILE
   #include <tmwtypes.h>
   #else
   #include "rtwtypes.h"
   #endif
   
   typedef struct MyStruct
   {
       double s1;
       double s2;
   } MyStruct;
   
   void use_struct(struct MyStruct *my_struct);
   

2. Write the C function use_struct.c.

   #include <stdio.h>
   #include <stdlib.h>
   
   #include "use_struct.h"
   
   void use_struct(struct MyStruct *my_struct)
   {
     double x = my_struct->s1;
     double y = my_struct->s2;
   }
   

3. Write a m_use_struct compliant with MATLAB that declares a structure. Have the function assign the name MyStruct to the structure. Then, have the function call the C function use_struct using coder.ceval.

   function m_use_struct   %#codegen
   % The directive %#codegen indicates that the function
   % is intended for code generation
   % Declare a MATLAB structure
   var.s1 = 1;
   var.s2 = 2;
   
   % Assign the name MyStruct to the structure variable.
   % extern indicates this is an externally defined 
   % structure.
   coder.cstructname(var, 'MyStruct', 'extern');
   
   % Call the C function use_struct. The type of var 
   % matches the signature of use_struct.
   % Use coder.rref to pass the variable var by 
   % reference as a read-only input to the external C 
   % function use_struct
   coder.ceval('use_struct', coder.rref(var));
   

4. Generate C library code for function m_use_struct, passing use_struct.h to include the structure definition.

   codegen -config:lib m_use_struct use_struct.c use_struct.h

   codegen generates C code in the default folder codegen\lib\m_use_struct. The generated header file m_use_struct_types.h in this folder does not contain a definition of the structure MyStruct because MyStruct is an external type.

Use coder.cstructname to assign a name to a substructure.

1. Define a MATLAB structure, top, that has another structure, lower, as a field.

   % Define structure top with field lower, 
   % which is a structure with fields a and b
   top.lower = struct('a',1,'b',1);
   top.c = 1;

2. Define a function, MyFunc, which takes an argument, TopVar, as input. Mark the function for code generation using %#codegen.

   function out = MyFunc(TopVar) %#codegen

3. Inside MyFunc, include the following lines

   coder.cstructname(TopVar,'topType');
   coder.cstructname(TopVar.lower,'lowerType');

4. So that TopVar has the same type as top, generate C code for MyFunc with an argument having the same type as top.

   codegen -config:lib MyFunc -args coder.typeof(top)

   In the generated C code, the field variable TopVar.lower is assigned the type name lowerType. For instance, the structure declaration of the variable TopVar.lower appears in the C code as:

   typedef struct
   {
       /* Definitions of a and b appear here */  
   } lowerType;

   and the structure declaration of the variable TopVar appears as:

   typedef struct
   {
        lowerType lower;
       /* Definition of c appears here */  
   } topType;

Create a coder.type object and pass it as codegen argument.

S = struct('a',double(0),'b',single(0))
T = coder.typeof(S);
T = coder.cstructname(T,'mytype');
codegen -config:lib MyFile -args T 

In this example, you create a coder.type object T. The object is passed as a codegen argument. However, because of the coder.cstructname statement, T is replaced with mytype in the generated C code. For instance, the declaration of T appears in the C code as:

typedef struct
{
    /* Field definitions appear here */  
} mytype;

Create a C header file, MyFile.h, containing the definition of a structure type, mytype.

typedef struct {
    /* Field definitions */
    double a;
    float b;
   } mytype;

Save the file in the folder, C:\MyHeaders.

Define a coder.type object, T, with the same fields as mytype.

T = coder.typeof(struct('a',double(0),'b',single(0))); 

Using coder.cstructname, rename T as mytype. Specify that the definition of mytype is in MyFile.h.

T = coder.cstructname(T,'mytype','extern','HeaderFile','MyFile.h');

Generate code for MATLAB function, MyFunc, which takes a structure of type, T, as input argument. Add the folder, C:\MyHeaders, to the include path during code generation.

codegen -config:lib MyFunc -args T -I C:\MyHeaders

In the generated code, the structure, T, is assigned the name, mytype. The code generator does not generate the definition of mytype. Instead the software includes the header file, MyFile.h, in the generated code.

Create a coder.CellType object for a cell array whose first element is char and whose second element is double.

T = coder.typeof({'c', 1})

T = 

coder.CellType
   1x2 heterogeneous cell 
      f0: 1x1 char
      f1: 1x1 double

T is a heterogeneous coder.CellType object.

Create a copy of T that specifies the name myname for the structure type that represents T in the generated code.

T = coder.cstructname(T, 'myname')

coder.CellType
   1x2 heterogeneous cell myname
      f0: 1x1 char
      f1: 1x1 double

Write a function struct_in_cell that has a cell array x{1} that contains a structure. The coder.cstructname call follows the assignment to x{1}.

function z = struct_in_cell()
x = cell(2,2);
x{1} = struct('a', 3);
coder.cstructname(x{1}, 'mytype');
z = x{1};
end

Generate a static library for struct_in_cell.

codegen -config:lib struct_in_cell -report

The type for a has the name mytype.

 typedef struct {
  double a;
} mytype;