Generate Code to Read a Text File

Open Live Script

This example shows how to generate a standalone C library from MATLAB® code that reads a file from disk using the functions fopen/fread/fclose.

About the `readfile` Function

The readfile.m function takes a file name (or path) as input and returns a string containing the contents of the file.

type readfile

% y = readfile(filename)
% Read file 'filename' and return a MATLAB string with the contents
% of the file.
function y = readfile(filename) %#codegen

% Put class and size constraints on function input.
assert(isa(filename, 'char'));
assert(size(filename, 1) == 1);
assert(size(filename, 2) <= 1024);

% Call fopen(filename 'r'), but we need to convert the MATLAB
% string into a C type string (which is the same string with the
% NUL (\0) string terminator).
f = fopen(filename, 'r');

% Call fseek(f, 0, SEEK_END) to set file position to the end of
% the file.
fseek(f, 0, 'eof');

% Call ftell(f) which will return the length of the file in bytes
% (as current file position is at the end of the file).
filelen = int32(ftell(f));

% Reset current file position
fseek(f,0,'bof');

% Initialize a buffer
maxBufferSize = int32(2^16);
buffer = zeros(1, maxBufferSize,'uint8');

% Remaining is the number of bytes to read (from the file)
remaining = filelen;

% Index is the current position to read into the buffer
index = int32(1);

while remaining > 0
    % Buffer overflow?
    if remaining + index > size(buffer,2)
        fprintf('Attempt to read file which is bigger than internal buffer.\n');
        fprintf('Current buffer size is %d bytes and file size is %d bytes.\n', maxBufferSize, filelen);
        break
    end
    % Read as much as possible from the file into internal buffer

    [dataRead, nread] = fread(f,remaining, 'char');
    buffer(index:index+nread-1) = dataRead;
    n = int32(nread);
    if n == 0
        % Nothing more to read
        break;
    end
    % Did something went wrong when reading?
    if n < 0
        fprintf('Could not read from file: %d.\n', n);
        break;
    end
    % Update state variables
    remaining = remaining - n;
    index = index + n;
end

% Close file
fclose(f);

y = char(buffer(1:index));

Generate the MEX Function for Testing

Generate a MEX function using the codegen command.

codegen readfile

Code generation successful.

Before generating C code, you should first test the MEX function in MATLAB to ensure that it is functionally equivalent to the original MATLAB code and that no run-time errors occur. By default, codegen generates a MEX function named readfile_mex in the current folder. This allows you to test the MATLAB code and MEX function and compare the results.

Run the MEX Function

Call the generated MEX function and display the size of the returned string and its first 100 characters.

y = readfile_mex('readfile.m');
size(y)

ans = 1×2

           1        1857

y(1:100)

ans = 
    '% y = readfile(filename)
     % Read file 'filename' and return a MATLAB string with the contents
     % of th'

Generate C Code

codegen -config:lib readfile

Code generation successful.

Using codegen with the specified -config cfg option produces a standalone C library.

Inspect the Generated Code

By default, the code generated for the library is in the folder codegen/lib/readfile/.

The files are:

dir codegen/lib/readfile/

.                      ..                     _clang-format          buildInfo.mat          codeInfo.mat           codedescriptor.dmr     compileInfo.mat        examples               fileManager.c          fileManager.h          fileManager.o          fread.c                fread.h                fread.o                fseek.c                fseek.h                fseek.o                ftell.c                ftell.h                ftell.o                interface              readfile.a             readfile.c             readfile.h             readfile.o             readfile_data.c        readfile_data.h        readfile_data.o        readfile_emxAPI.c      readfile_emxAPI.h      readfile_emxAPI.o      readfile_emxutil.c     readfile_emxutil.h     readfile_emxutil.o     readfile_initialize.c  readfile_initialize.h  readfile_initialize.o  readfile_rtw.mk        readfile_terminate.c   readfile_terminate.h   readfile_terminate.o   readfile_types.h       rtw_proj.tmw           rtwtypes.h

Inspect the C Code for the `readfile.c` Function

type codegen/lib/readfile/readfile.c

/*
 * File: readfile.c
 *
 * MATLAB Coder version            : 24.2
 * C/C++ source code generated on  : 22-Jan-2025 23:07:37
 */

/* Include Files */
#include "readfile.h"
#include "fileManager.h"
#include "fread.h"
#include "fseek.h"
#include "ftell.h"
#include "readfile_data.h"
#include "readfile_emxutil.h"
#include "readfile_initialize.h"
#include "readfile_types.h"
#include <math.h>
#include <stdio.h>
#include <string.h>

/* Function Declarations */
static double rt_roundd_snf(double u);

/* Function Definitions */
/*
 * Arguments    : double u
 * Return Type  : double
 */
static double rt_roundd_snf(double u)
{
  double y;
  if (fabs(u) < 4.503599627370496E+15) {
    if (u >= 0.5) {
      y = floor(u + 0.5);
    } else if (u > -0.5) {
      y = u * 0.0;
    } else {
      y = ceil(u - 0.5);
    }
  } else {
    y = u;
  }
  return y;
}

/*
 * Put class and size constraints on function input.
 *
 * Arguments    : const char filename_data[]
 *                const int filename_size[2]
 *                emxArray_char_T *y
 * Return Type  : void
 */
void readfile(const char filename_data[], const int filename_size[2],
              emxArray_char_T *y)
{
  emxArray_real_T *dataRead;
  double d;
  double *dataRead_data;
  int b_index;
  int i;
  int i2;
  int remaining;
  unsigned char buffer[65536];
  signed char fileid;
  char *y_data;
  boolean_T exitg1;
  if (!isInitialized_readfile) {
    readfile_initialize();
  }
  /*  y = readfile(filename) */
  /*  Read file 'filename' and return a MATLAB string with the contents */
  /*  of the file. */
  /*  Call fopen(filename 'r'), but we need to convert the MATLAB */
  /*  string into a C type string (which is the same string with the */
  /*  NUL (\0) string terminator). */
  fileid = cfopen(filename_data, filename_size);
  /*  Call fseek(f, 0, SEEK_END) to set file position to the end of */
  /*  the file. */
  b_fseek(fileid);
  /*  Call ftell(f) which will return the length of the file in bytes */
  /*  (as current file position is at the end of the file). */
  d = rt_roundd_snf(b_ftell(fileid));
  if (d < 2.147483648E+9) {
    if (d >= -2.147483648E+9) {
      i = (int)d;
    } else {
      i = MIN_int32_T;
    }
  } else if (d >= 2.147483648E+9) {
    i = MAX_int32_T;
  } else {
    i = 0;
  }
  /*  Reset current file position */
  c_fseek(fileid);
  /*  Initialize a buffer */
  memset(&buffer[0], 0, 65536U * sizeof(unsigned char));
  /*  Remaining is the number of bytes to read (from the file) */
  remaining = i;
  /*  Index is the current position to read into the buffer */
  b_index = 1;
  emxInit_real_T(&dataRead);
  exitg1 = false;
  while ((!exitg1) && (remaining > 0)) {
    int qY;
    /*  Buffer overflow? */
    if (b_index > MAX_int32_T - remaining) {
      qY = MAX_int32_T;
    } else {
      qY = remaining + b_index;
    }
    if (qY > 65536) {
      printf("Attempt to read file which is bigger than internal buffer.\n");
      fflush(stdout);
      printf("Current buffer size is %d bytes and file size is %d bytes.\n",
             65536, i);
      fflush(stdout);
      exitg1 = true;
    } else {
      double nread;
      int i1;
      /*  Read as much as possible from the file into internal buffer */
      nread = b_fread(fileid, remaining, dataRead);
      dataRead_data = dataRead->data;
      d = rt_roundd_snf((double)b_index + nread);
      if (d < 2.147483648E+9) {
        if (d >= -2.147483648E+9) {
          qY = (int)d;
        } else {
          qY = MIN_int32_T;
        }
      } else if (d >= 2.147483648E+9) {
        qY = MAX_int32_T;
      } else {
        qY = 0;
      }
      if (qY < -2147483647) {
        qY = MIN_int32_T;
      } else {
        qY--;
      }
      if (b_index > qY) {
        i1 = 0;
        qY = 0;
      } else {
        i1 = b_index - 1;
      }
      qY -= i1;
      for (i2 = 0; i2 < qY; i2++) {
        unsigned char u;
        d = rt_roundd_snf(dataRead_data[i2]);
        if (d < 256.0) {
          if (d >= 0.0) {
            u = (unsigned char)d;
          } else {
            u = 0U;
          }
        } else if (d >= 256.0) {
          u = MAX_uint8_T;
        } else {
          u = 0U;
        }
        buffer[i1 + i2] = u;
      }
      d = rt_roundd_snf(nread);
      if (d < 2.147483648E+9) {
        if (d >= -2.147483648E+9) {
          qY = (int)d;
        } else {
          qY = MIN_int32_T;
        }
      } else if (d >= 2.147483648E+9) {
        qY = MAX_int32_T;
      } else {
        qY = 0;
      }
      if (qY == 0) {
        /*  Nothing more to read */
        exitg1 = true;

        /*  Did something went wrong when reading? */
      } else if (qY < 0) {
        printf("Could not read from file: %d.\n", qY);
        fflush(stdout);
        exitg1 = true;
      } else {
        /*  Update state variables */
        remaining -= qY;
        if ((b_index < 0) && (qY < MIN_int32_T - b_index)) {
          b_index = MIN_int32_T;
        } else if ((b_index > 0) && (qY > MAX_int32_T - b_index)) {
          b_index = MAX_int32_T;
        } else {
          b_index += qY;
        }
      }
    }
  }
  emxFree_real_T(&dataRead);
  /*  Close file */
  cfclose(fileid);
  i = y->size[0] * y->size[1];
  y->size[0] = 1;
  y->size[1] = b_index;
  emxEnsureCapacity_char_T(y, i);
  y_data = y->data;
  for (i = 0; i < b_index; i++) {
    y_data[i] = (signed char)buffer[i];
  }
}

/*
 * File trailer for readfile.c
 *
 * [EOF]
 */