Embeddeds files in a folder -recursively- into C/C++ H files with name and size. The files are stored at array fsFiles with stFile struct type that has .name , .data and size fields. I'm using this in order to serve files from a ARM board running a web server with FreeRTOS , Lwip and Mongoose. #stm32 #embedded #c #filesystem #mongoose

fs2hex.cpp

#include <iostream>
#include "boost/filesystem.hpp"
#include <fstream>
#include <map>
#include <cstring>
#include <string>

// Turn all files from a folder into hex char with name and size.

// Fabio Vila
// chefvila@yahoo.com.br
// https://github.com/fabiovila

// Compile with:
// g++ -lstdc++ -lboost_system -lboost_filesystem fs2hex.cpp  -o fs2hc

using namespace std;
using namespace boost::filesystem;
std::vector <std::string> List;
std::map <std::string,std::string> mime = {{"js","application/javascript"},{"css","text/css"},{"html","text/html"},{"ttf","font/ttf"},{"json","application/json"}};

/* py
>>> for i in range(256):
...     print("{\"\\\\"+hex(i)+"\"},", end='')
*/
const string dec2hex[] = {{"\\x0"},{"\\x1"},{"\\x2"},{"\\x3"},{"\\x4"},{"\\x5"},{"\\x6"},{"\\x7"},{"\\x8"},{"\\x9"},{"\\xa"},{"\\xb"},{"\\xc"},{"\\xd"},{"\\xe"},{"\\xf"},{"\\x10"},{"\\x11"},{"\\x12"},{"\\x13"},{"\\x14"},{"\\x15"},{"\\x16"},{"\\x17"},{"\\x18"},{"\\x19"},{"\\x1a"},{"\\x1b"},{"\\x1c"},{"\\x1d"},{"\\x1e"},{"\\x1f"},{"\\x20"},{"\\x21"},{"\\x22"},{"\\x23"},{"\\x24"},{"\\x25"},{"\\x26"},{"\\x27"},{"\\x28"},{"\\x29"},{"\\x2a"},{"\\x2b"},{"\\x2c"},{"\\x2d"},{"\\x2e"},{"\\x2f"},{"\\x30"},{"\\x31"},{"\\x32"},{"\\x33"},{"\\x34"},{"\\x35"},{"\\x36"},{"\\x37"},{"\\x38"},{"\\x39"},{"\\x3a"},{"\\x3b"},{"\\x3c"},{"\\x3d"},{"\\x3e"},{"\\x3f"},{"\\x40"},{"\\x41"},{"\\x42"},{"\\x43"},{"\\x44"},{"\\x45"},{"\\x46"},{"\\x47"},{"\\x48"},{"\\x49"},{"\\x4a"},{"\\x4b"},{"\\x4c"},{"\\x4d"},{"\\x4e"},{"\\x4f"},{"\\x50"},{"\\x51"},{"\\x52"},{"\\x53"},{"\\x54"},{"\\x55"},{"\\x56"},{"\\x57"},{"\\x58"},{"\\x59"},{"\\x5a"},{"\\x5b"},{"\\x5c"},{"\\x5d"},{"\\x5e"},{"\\x5f"},{"\\x60"},{"\\x61"},{"\\x62"},{"\\x63"},{"\\x64"},{"\\x65"},{"\\x66"},{"\\x67"},{"\\x68"},{"\\x69"},{"\\x6a"},{"\\x6b"},{"\\x6c"},{"\\x6d"},{"\\x6e"},{"\\x6f"},{"\\x70"},{"\\x71"},{"\\x72"},{"\\x73"},{"\\x74"},{"\\x75"},{"\\x76"},{"\\x77"},{"\\x78"},{"\\x79"},{"\\x7a"},{"\\x7b"},{"\\x7c"},{"\\x7d"},{"\\x7e"},{"\\x7f"},{"\\x80"},{"\\x81"},{"\\x82"},{"\\x83"},{"\\x84"},{"\\x85"},{"\\x86"},{"\\x87"},{"\\x88"},{"\\x89"},{"\\x8a"},{"\\x8b"},{"\\x8c"},{"\\x8d"},{"\\x8e"},{"\\x8f"},{"\\x90"},{"\\x91"},{"\\x92"},{"\\x93"},{"\\x94"},{"\\x95"},{"\\x96"},{"\\x97"},{"\\x98"},{"\\x99"},{"\\x9a"},{"\\x9b"},{"\\x9c"},{"\\x9d"},{"\\x9e"},{"\\x9f"},{"\\xa0"},{"\\xa1"},{"\\xa2"},{"\\xa3"},{"\\xa4"},{"\\xa5"},{"\\xa6"},{"\\xa7"},{"\\xa8"},{"\\xa9"},{"\\xaa"},{"\\xab"},{"\\xac"},{"\\xad"},{"\\xae"},{"\\xaf"},{"\\xb0"},{"\\xb1"},{"\\xb2"},{"\\xb3"},{"\\xb4"},{"\\xb5"},{"\\xb6"},{"\\xb7"},{"\\xb8"},{"\\xb9"},{"\\xba"},{"\\xbb"},{"\\xbc"},{"\\xbd"},{"\\xbe"},{"\\xbf"},{"\\xc0"},{"\\xc1"},{"\\xc2"},{"\\xc3"},{"\\xc4"},{"\\xc5"},{"\\xc6"},{"\\xc7"},{"\\xc8"},{"\\xc9"},{"\\xca"},{"\\xcb"},{"\\xcc"},{"\\xcd"},{"\\xce"},{"\\xcf"},{"\\xd0"},{"\\xd1"},{"\\xd2"},{"\\xd3"},{"\\xd4"},{"\\xd5"},{"\\xd6"},{"\\xd7"},{"\\xd8"},{"\\xd9"},{"\\xda"},{"\\xdb"},{"\\xdc"},{"\\xdd"},{"\\xde"},{"\\xdf"},{"\\xe0"},{"\\xe1"},{"\\xe2"},{"\\xe3"},{"\\xe4"},{"\\xe5"},{"\\xe6"},{"\\xe7"},{"\\xe8"},{"\\xe9"},{"\\xea"},{"\\xeb"},{"\\xec"},{"\\xed"},{"\\xee"},{"\\xef"},{"\\xf0"},{"\\xf1"},{"\\xf2"},{"\\xf3"},{"\\xf4"},{"\\xf5"},{"\\xf6"},{"\\xf7"},{"\\xf8"},{"\\xf9"},{"\\xfa"},{"\\xfb"},{"\\xfc"},{"\\xfd"},{"\\xfe"},{"\\xff"}}; 

struct stFile {
	std::string 	name;
	char 			*bytes;
	int 			size;
	string			mime;
};
	
string getmime( string filename ){
	
	string ext = filename.substr(filename.find_last_of(".") + 1);
	
	
	
	return mime[ext];
}

void listfolder(const std::string& path)
{
	
    if (!path.empty())
    {
        namespace fs = boost::filesystem;

        fs::path apk_path(path);
        fs::recursive_directory_iterator end;

        for (fs::recursive_directory_iterator i(apk_path); i != end; ++i)
        {
            const fs::path cp = (*i);
            List.push_back(cp.string());
        }
    }
    return;
}

int main(int argc, char *argv[])
{
	
  std::vector <stFile> Files;
  stFile tFiles;
  char chBuffer[100];
  string path;
  string outputname;
  
  if (argc <= 1) {
	  boost::filesystem::path cpath(boost::filesystem::current_path());	
	  path = cpath.string();
	} else {
		path = argv[1];
	}

   if (argc == 3){
	   outputname = argv[2];
   } else outputname = "out.h";

  cout << "Mounting the filesystem ..." << "\n";
  listfolder(path);
  
  for (std::vector<std::string>::const_iterator i = List.begin(); i != List.end(); ++i){
		std::ifstream file(*i, std::ios::binary );
		if (file) {
					// Get file size
					file.seekg(0,std::ios::end);
					std::streampos          length = file.tellg();
					file.seekg(0,std::ios::beg);
					// Alloc buffer
					char * buffer = new char [length];
					// Read and store name and size
					file.read(buffer,length);
						tFiles.name = *i;
						// clear path
						tFiles.name = tFiles.name.substr(path.size(),tFiles.name.size());
						tFiles.mime = getmime(tFiles.name);
						tFiles.bytes = buffer;
						tFiles.size = length;					  
						Files.push_back(tFiles);
					file.close();
		} else exit(1);
	} 

	// Generate *.h file
	 std::ofstream out(outputname);
	 int index = 0, a = 0;
	 cout << "Creating H file ..." << "\n";
	 out << "typedef struct { char *name; char *mime; int size; char *data; } stFile;\n";
	 out << "#define FS_FILES	" << Files.size() << "\n";

	 
	 index = 0;
	 for (std::vector<stFile>::iterator i = Files.begin(); i != Files.end(); ++i) {
		 out << "// " << index << " : " << i->name  << " " << i->mime << " " << i->size << "\n";
		 index++;
	 }
	 
	 
	 out << "\n\nconst volatile stFile __attribute__ ((section (\".rodata\"))) fsFiles[" << Files.size() <<"] = { "; 
	 

	 for (std::vector<stFile>::iterator i = Files.begin(); i != Files.end(); ++i){
		 cout << " " << i->name << "\n";
		 
		 out << "{\"" << i->name << "\" , ";
		 out << "\"" << i->mime << "\" , ";
		 out << i->size << ", ";
		 out << "\""; 
			for (a = 0; a < i->size; a++) {
				out << dec2hex[(unsigned char) i->bytes[a]];	
			}
		if ( Files.end() - i == 1 ) out << "\"}"; else out << "\"}, "; 		
		 
	 }
	out << "};"; 
	out.close();
	cout << "File: " << outputname <<  "\n";
}

out.h

// Example of file (only first lines )
typedef struct { char *name; int size; char *data; } stFile;
#define FS_FILES	4
#define FS_MAXINDEX	3

// 0 : angular.min.js , 108385
// 1 : index.html , 2192
// 2 : fontawesome-webfont.ttf , 165548
// 3 : css.css , 4682


const volatile stFile __attribute__ ((section ("text"))) fsFiles[4] = { {"angular.min.js" , 108385, " \x2f\x2a\xa\x20\x41\x6e\x67\x75\x6c\x61\x72\x4a\