├── LICENSE
├── README.md
├── examples
    └── incbin-print-self
    │   └── incbin-print-self.ino
├── incbin.png
├── library.properties
└── src
    ├── README.md
    ├── UNLICENSE
    ├── _incbin.h
    └── incbin.h


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021, Dale Weiler (https://github.com/graphitemaster)
 4 | Copyright (c) 2021, github.com/AlexIII
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # incbin - Include binary and text files in your Arduino project with ease
  2 | <img align="right" width="400" src="incbin.png" />
  3 | 
  4 | *This is a fork of [this](https://github.com/graphitemaster/incbin) project wrapped as an Arduino library.*
  5 | 
  6 | The library allows to include any file into your Arduino project in a single line without 
  7 | converting it into c-array or maintaining a file system (such as SPIFFS).
  8 | 
  9 | Easily include wav sound, bmp image, html, js, txt, etc.
 10 | 
 11 | ## IMPORTANT NOTE
 12 | 
 13 | When using this library,
 14 |   1. Close **all** Arduino IDE windows,
 15 |   2. Re-open your ***.ino file via double-click**. Do NOT do File -> Open...
 16 | 
 17 | See [Limitations](#Limitations) for the explanation.
 18 | 
 19 | 
 20 | ## How to use
 21 | 
 22 | ```C++
 23 | #include "incbin.h"
 24 | 
 25 | INCTXT(WebPage, "index.html");          // For text     (will be NULL-terminated)
 26 | INCBIN(Sound, "sound.wav");             // For binary
 27 | 
 28 | void setup() {
 29 |   Serial.begin(115200);
 30 | 
 31 |   Serial.println(gWebPageData);         // print content of index.html
 32 |   Serial.println();
 33 | 
 34 |   Serial.print(F("index.html size: "));
 35 |   Serial.println(gWebPageSize);         // print size of index.html
 36 | 
 37 |   Serial.print(F("sound.wav size: "));
 38 |   Serial.println(gSoundSize);           // print size of sound.wav
 39 | }
 40 | ```
 41 | 
 42 | Macros `INCTXT(NAME, FILE)` and `INCBIN(NAME, FILE)` accept path to the `FILE` 
 43 | **relative to the project main folder** (where the *.ino file is placed), and 
 44 | NOT to the source file in which you use these macros. You can use absolute path as well.
 45 | 
 46 | See the [`incbin-print-self.ino`](examples/incbin-print-self/incbin-print-self.ino) example for more. 
 47 | 
 48 | 
 49 | ## How it works
 50 | 
 51 | The library includes the content of the specified file in Flash ROM of the microcontroller.
 52 | It means that,
 53 | 
 54 | - the RAM is not wasted;
 55 | - the file is included as a constant, its content cannot be changed;
 56 | - you cannot work with the file content as with a normal array on AVR-based Arduino, as it's stored in the flash memory (PROGMEM). See [here](https://www.arduino.cc/reference/en/language/variables/utilities/progmem/) on how to read the flash.
 57 | 
 58 | 
 59 | ## Limitations
 60 | 
 61 | If you encounter a compilation error like this
 62 | 
 63 | ```
 64 | ***PATH***.s: Assembler messages:
 65 | ***PATH***.s:16: Error: file not found: ***FILE YOU TRIED TO INCBIN***
 66 | lto-wrapper.exe: fatal error: 
 67 |     ...
 68 | ```
 69 | 
 70 | do the following steps:
 71 | 
 72 | #### Windows Arduino IDE 1.8 users
 73 |   1. Close **all** Arduino IDE windows,
 74 |   2. Re-open your ***.ino file via double-click**. Do NOT do File -> Open...
 75 | 
 76 | #### [VS Code Arduino](https://marketplace.visualstudio.com/items?itemName=vsciot-vscode.vscode-arduino) extension users (any OS)
 77 |   1. Upgrade your extension to v0.4.7 or newer,
 78 |   2. Ensure the path in the `INCBIN` or `INCTXT` is **relative to the workspace folder**, and not to the source file. You can also use absolute path.
 79 | 
 80 | #### Windows Arduino IDE 2 Beta, Linux Arduino IDE (any)
 81 | No solutions to use relative path. Sorry. Use absolute path instead. Linux users may also use path relative to home.
 82 | 
 83 | ### Ok, but why???
 84 | 
 85 | The underlying library uses the `.incbin` directive of the inline assembler. The thing is, it accepts the path relative to the current directory in which the compiler is running (and not to the source file).
 86 | Arduino IDE *usually* starts the build in the project main directory (in which the *.ino file resides), but it is not guaranteed. Sometimes build can start in another directory and will fail. Re-opening the IDE via double-click on the *.ino file convinces it to start the build in the project's folder (but only in ver. 1.8 under Windows).
 87 | 
 88 | Also, a library example never runs compilation in its own folder, that's why you need to copy it somewhere on the disk, otherwise the compilation will fail.
 89 | 
 90 | **If you have an idea on how to handle this *right* way, please post an issue on the subject.**
 91 | 
 92 | 
 93 | ## Supported architectures
 94 | 
 95 | Tested with
 96 | - AVR-based Arduino: Uno, Nano, Mini Pro, 2560, etc.
 97 | - ESP8266
 98 | 
 99 | Should also work with
100 | - ARM-based Arduino
101 | - ESP8285
102 | 
103 | 
104 | ## License
105 | 
106 | MIT 
107 | 
108 | © [Dale Weiler](https://github.com/graphitemaster)
109 | 
110 | © [AlexIII](https://github.com/AlexIII)
111 | 
112 | 
113 | The original library goes under [UNLICENSE](src/UNLICENSE).
114 | I'm no legal expert, but I think it permits derivative work to have a different license.
115 | If you think it's not, then please post an issue.
116 | 


--------------------------------------------------------------------------------
/examples/incbin-print-self/incbin-print-self.ino:
--------------------------------------------------------------------------------
 1 | /*  
 2 |  * File:          incbin-print-self.ino
 3 |  * Description:   incbin Aduino example. Prints out the content of this file to Serial.
 4 |  * URL:           https://github.com/AlexIII/incbin-arduino
 5 |  * 
 6 |  */ 
 7 | //                                    !!! IMPORTANT !!!
 8 | //          !!! This example WON'T COMPILE unless you follow these instructions !!! 
 9 | /* -----------------------------------------------------------------------------------------------
10 |  *      1. SAVE this example (CTRL+S) to any folder on your disk
11 |  *      2. CLOSE ALL Arduino windows
12 |  *      3. Re-open the *.ino file you've just saved via DOUBLE-CLICK (DO NOT do File -> Open...)
13 |  * -----------------------------------------------------------------------------------------------
14 |  * 
15 |  * 
16 |  *    - You can use this library in your *.ino project as usual,
17 |  *      it will compile fine, but you will have to open it via double-click every time.
18 |  *    - See the github page for detailed explanation of these shenanigans.
19 |  *    - If you have troubles using this library feel free to open an issue on the github.
20 |  *    
21 |  */
22 | 
23 | #include "incbin.h"
24 | 
25 | // Include TEXT file "incbin-print-self.ino" with name `Sketch`
26 | INCTXT(SketchText, "incbin-print-self.ino");
27 | // This will create global variables:
28 | //  const __FlashStringHelper gSketchTextData[];        // NULL-terminated Flash string, pointer to the data
29 | //  const __FlashStringHelper *const gSketchTextEnd;    // Pointer to the end of the data
30 | //  const unsigned int gSketchTextSize;                 // Size of the data in bytes
31 | 
32 | 
33 | // Alternatively you can include the file as BINARY data
34 | // --
35 | // INCBIN(SketchText, "incbin-print-self.ino");
36 | // --
37 | // This will create global variables:
38 | //  const unsigned char gSketchTextData[];              // Pointer to the data
39 | //  const unsigned char *const gSketchTextEnd;          // Pointer to the end of the data
40 | //  const unsigned int gSketchTextSize;                 // Size of the data in bytes
41 | 
42 | void setup() {
43 |   Serial.begin(115200);
44 | 
45 |   // Print data content
46 |   Serial.println(F("----------------------------------"));
47 |   Serial.println(gSketchTextData);
48 |   Serial.println(F("----------------------------------"));
49 | 
50 |   // Print data size
51 |   Serial.print(F("Sketch file size: "));
52 |   Serial.println(gSketchTextSize);
53 | 
54 | 
55 | /* Alternatively, read the data from ROM byte-by-byte */
56 | //  PGM_P p = reinterpret_cast<PGM_P>(gSketchTextData);
57 | //  for(int i = 0; i < gSketchTextSize; ++i) {
58 | //    unsigned char c = pgm_read_byte(p++);
59 | //    Serial.write(c);
60 | //  }
61 | //  Serial.println();
62 | 
63 | }
64 | 
65 | void loop() {}
66 | 


--------------------------------------------------------------------------------
/incbin.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlexIII/incbin-arduino/d7ee21d2f3e695d959fc9533b07a84c69b99e0be/incbin.png


--------------------------------------------------------------------------------
/library.properties:
--------------------------------------------------------------------------------
 1 | name=incbin
 2 | version=0.1.2
 3 | author=Dale Weiler, AlexIII
 4 | maintainer=AlexIII
 5 | sentence=Include binary and text files in your Arduino project with ease.
 6 | paragraph=The library allows to include any file into your Arduino project in a single line without converting it into c-array or maintaining a file system (such as SPIFFS). Easily include wav sound, bmp image, html, js, txt, etc.
 7 | category=Data Storage
 8 | url=https://github.com/AlexIII/incbin-arduino
 9 | architectures=*
10 | includes=incbin.h


--------------------------------------------------------------------------------
/src/README.md:
--------------------------------------------------------------------------------
  1 | # incbin
  2 | 
  3 | Include binary files in your C/C++ applications with ease
  4 | 
  5 | ## Example
  6 | 
  7 | ``` c
  8 |     #include "incbin.h"
  9 | 
 10 |     INCBIN(Icon, "icon.png");
 11 | 
 12 |     // This translation unit now has three symbols
 13 |     // const unsigned char gIconData[];
 14 |     // const unsigned char *const gIconEnd; // a marker to the end, take the address to get the ending pointer
 15 |     // const unsigned int gIconSize;
 16 | 
 17 |     // Reference in other translation units like this
 18 |     INCBIN_EXTERN(Icon);
 19 | 
 20 |     // This translation unit now has three extern symbols
 21 |     // Use `extern "C"` in case of writing C++ code
 22 |     // extern const unsigned char gIconData[];
 23 |     // extern const unsigned char *const gIconEnd; // a marker to the end, take the address to get the ending pointer
 24 |     // extern const unsigned int gIconSize;
 25 | ```
 26 | 
 27 | ## Portability
 28 | 
 29 | Known to work on the following compilers
 30 | 
 31 | * GCC
 32 | * Clang
 33 | * PathScale
 34 | * Intel
 35 | * Solaris & Sun Studio
 36 | * Green Hills
 37 | * SNC (ProDG)
 38 | * Diab C++ (WindRiver)
 39 | * XCode
 40 | * ArmCC
 41 | * RealView
 42 | * ImageCraft
 43 | * Stratus VOS C
 44 | * TinyCC
 45 | * cparser & libfirm
 46 | * LCC
 47 | * MSVC _See MSVC below_
 48 | 
 49 | If your compiler is not listed, as long as it supports GCC inline assembler, this
 50 | should work.
 51 | 
 52 | ## MISRA
 53 | INCBIN can be used in MISRA C setting. However it should be independently checked
 54 | due to its use of inline assembly to achieve what it does. Independent verification
 55 | of the header has been done several times based on commit: 7e327a28ba5467c4202ec37874beca7084e4b08c
 56 | 
 57 | ## Alignment
 58 | 
 59 | The data included by this tool will be aligned on the architectures word boundary
 60 | unless some variant of SIMD is detected, then it's aligned on a byte boundary that
 61 | respects SIMD convention just incase your binary data may be used in vectorized
 62 | code. The table of the alignments for SIMD this header recognizes is as follows:
 63 | 
 64 | | SIMD                                    | Alignment |
 65 | |-----------------------------------------|-----------|
 66 | | SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2  | 16        |
 67 | | Neon                                    | 16        |
 68 | | AVX, AVX2                               | 32        |
 69 | | AVX512                                  | 64        |
 70 | 
 71 | ## Prefix
 72 | By default, `incbin.h` emits symbols with a `g` prefix. This can be adjusted by
 73 | defining `INCBIN_PREFIX` before including `incbin.h` with a desired prefix. For
 74 | instance
 75 | 
 76 | ``` c
 77 |     #define INCBIN_PREFIX g_
 78 |     #include "incbin.h"
 79 |     INCBIN(test, "test.txt");
 80 | 
 81 |     // This translation unit now has three symbols
 82 |     // const unsigned char g_testData[];
 83 |     // const unsigned char *const g_testEnd;
 84 |     // const unsigned int g_testSize;
 85 | ```
 86 | 
 87 | You can also choose to have no prefix by defining the prefix with nothing, for example:
 88 | 
 89 | ``` c
 90 |     #define INCBIN_PREFIX
 91 |     #include "incbin.h"
 92 |     INCBIN(test, "test.txt");
 93 | 
 94 |     // This translation unit now has three symbols
 95 |     // const unsigned char testData[];
 96 |     // const unsigned char *const testEnd;
 97 |     // const unsigned int testSize;
 98 | ```
 99 | 
100 | ## Style
101 | By default, `incbin.h` emits symbols with `CamelCase` style. This can be adjusted
102 | by defining `INCBIN_STYLE` before including `incbin.h` to change the style. There
103 | are two possible styles to choose from
104 | 
105 | * INCBIN_STYLE_CAMEL (CamelCase)
106 | * INCBIN_STYLE_SNAKE (snake_case)
107 | 
108 | For instance:
109 | 
110 | ``` c
111 |     #define INCBIN_STYLE INCBIN_STYLE_SNAKE
112 |     #include "incbin.h"
113 |     INCBIN(test, "test.txt");
114 | 
115 |     // This translation unit now has three symbols
116 |     // const unsigned char gtest_data[];
117 |     // const unsigned char *const gtest_end;
118 |     // const unsigned int gtest_size;
119 | ```
120 | 
121 | Combining both the style and prefix allows for you to adjust `incbin.h` to suite
122 | your existing style and practices.
123 | 
124 | ## Overriding Linker Output section
125 | By default, `incbin.h` emits into the read-only linker output section used on
126 | the detected platform. If you need to override this for whatever reason, you
127 | can manually specify the linker output section.
128 | 
129 | For example, to emit data into program memory for
130 | [esp8266/Arduino](github.com/esp8266/Arduino):
131 | 
132 | ``` c
133 | #define INCBIN_OUTPUT_SECTION ".irom.text"
134 | #include "incbin.h"
135 | INCBIN(Foo, "foo.txt");
136 | // Data is emitted into program memory that never gets copied to RAM
137 | ```
138 | 
139 | ## Explanation
140 | 
141 | `INCBIN` is a macro which uses the inline assembler provided by almost all
142 | compilers to include binary files. It achieves this by utilizing the `.incbin`
143 | directive of the inline assembler. It then uses the assembler to calculate the
144 | size of the included binary and exports two global symbols that can be externally
145 | referenced in other translation units which contain the data and size of the
146 | included binary data respectively.
147 | 
148 | ## MSVC
149 | 
150 | Supporting MSVC is slightly harder as MSVC lacks an inline assembler which can
151 | include data. To support this we ship a tool which can process source files
152 | containing `INCBIN` macro usage and generate an external source file containing
153 | the data of all of them combined. This file is named `data.c` by default.
154 | Just include it into your build and use the `incbin.h` to reference data as
155 | needed. It's suggested you integrate this tool as part of your projects's
156 | pre-build events so that this can be automated. A more comprehensive list of
157 | options for this tool can be viewed by invoking the tool with `-help`
158 | 
159 | If you're using a custom prefix, be sure to specify the prefix on the command
160 | line with `-p <prefix>` so that everything matches up; similarly, if you're
161 | using a custom style, be sure to specify the style on the command line with
162 | `-S <style>` as well.
163 | 
164 | ## Miscellaneous
165 | 
166 | Documentation for the API is provided by the header using Doxygen notation.
167 | For licensing information see UNLICENSE.
168 | 


--------------------------------------------------------------------------------
/src/UNLICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <http://unlicense.org/>
25 | 


--------------------------------------------------------------------------------
/src/_incbin.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @file incbin.h
  3 |  * @author Dale Weiler
  4 |  * @brief Utility for including binary files
  5 |  *
  6 |  * Facilities for including binary files into the current translation unit and
  7 |  * making use from them externally in other translation units.
  8 |  */
  9 | #ifndef INCBIN_HDR
 10 | #define INCBIN_HDR
 11 | #include <limits.h>
 12 | #if   defined(__AVX512BW__) || \
 13 |       defined(__AVX512CD__) || \
 14 |       defined(__AVX512DQ__) || \
 15 |       defined(__AVX512ER__) || \
 16 |       defined(__AVX512PF__) || \
 17 |       defined(__AVX512VL__) || \
 18 |       defined(__AVX512F__)
 19 | # define INCBIN_ALIGNMENT_INDEX 6
 20 | #elif defined(__AVX__)      || \
 21 |       defined(__AVX2__)
 22 | # define INCBIN_ALIGNMENT_INDEX 5
 23 | #elif defined(__SSE__)      || \
 24 |       defined(__SSE2__)     || \
 25 |       defined(__SSE3__)     || \
 26 |       defined(__SSSE3__)    || \
 27 |       defined(__SSE4_1__)   || \
 28 |       defined(__SSE4_2__)   || \
 29 |       defined(__neon__)
 30 | # define INCBIN_ALIGNMENT_INDEX 4
 31 | #elif ULONG_MAX != 0xffffffffu
 32 | # define INCBIN_ALIGNMENT_INDEX 3
 33 | # else
 34 | # define INCBIN_ALIGNMENT_INDEX 2
 35 | #endif
 36 | 
 37 | /* Lookup table of (1 << n) where `n' is `INCBIN_ALIGNMENT_INDEX' */
 38 | #define INCBIN_ALIGN_SHIFT_0 1
 39 | #define INCBIN_ALIGN_SHIFT_1 2
 40 | #define INCBIN_ALIGN_SHIFT_2 4
 41 | #define INCBIN_ALIGN_SHIFT_3 8
 42 | #define INCBIN_ALIGN_SHIFT_4 16
 43 | #define INCBIN_ALIGN_SHIFT_5 32
 44 | #define INCBIN_ALIGN_SHIFT_6 64
 45 | 
 46 | /* Actual alignment value */
 47 | #define INCBIN_ALIGNMENT \
 48 |     INCBIN_CONCATENATE( \
 49 |         INCBIN_CONCATENATE(INCBIN_ALIGN_SHIFT, _), \
 50 |         INCBIN_ALIGNMENT_INDEX)
 51 | 
 52 | /* Stringize */
 53 | #define INCBIN_STR(X) \
 54 |     #X
 55 | #define INCBIN_STRINGIZE(X) \
 56 |     INCBIN_STR(X)
 57 | /* Concatenate */
 58 | #define INCBIN_CAT(X, Y) \
 59 |     X ## Y
 60 | #define INCBIN_CONCATENATE(X, Y) \
 61 |     INCBIN_CAT(X, Y)
 62 | /* Deferred macro expansion */
 63 | #define INCBIN_EVAL(X) \
 64 |     X
 65 | #define INCBIN_INVOKE(N, ...) \
 66 |     INCBIN_EVAL(N(__VA_ARGS__))
 67 | 
 68 | /* Green Hills uses a different directive for including binary data */
 69 | #if defined(__ghs__)
 70 | #  if (__ghs_asm == 2)
 71 | #    define INCBIN_MACRO ".file"
 72 | /* Or consider the ".myrawdata" entry in the ld file */
 73 | #  else
 74 | #    define INCBIN_MACRO "\tINCBIN"
 75 | #  endif
 76 | #else
 77 | #  define INCBIN_MACRO ".incbin"
 78 | #endif
 79 | 
 80 | #ifndef _MSC_VER
 81 | #  define INCBIN_ALIGN \
 82 |     __attribute__((aligned(INCBIN_ALIGNMENT)))
 83 | #else
 84 | #  define INCBIN_ALIGN __declspec(align(INCBIN_ALIGNMENT))
 85 | #endif
 86 | 
 87 | #if defined(__arm__) || /* GNU C and RealView */ \
 88 |     defined(__arm) || /* Diab */ \
 89 |     defined(_ARM) /* ImageCraft */
 90 | #  define INCBIN_ARM
 91 | #endif
 92 | 
 93 | #ifdef __GNUC__
 94 | /* Utilize .balign where supported */
 95 | #  define INCBIN_ALIGN_HOST ".balign " INCBIN_STRINGIZE(INCBIN_ALIGNMENT) "\n"
 96 | #  define INCBIN_ALIGN_BYTE ".balign 1\n"
 97 | #elif defined(INCBIN_ARM)
 98 | /*
 99 |  * On arm assemblers, the alignment value is calculated as (1 << n) where `n' is
100 |  * the shift count. This is the value passed to `.align'
101 |  */
102 | #  define INCBIN_ALIGN_HOST ".align " INCBIN_STRINGIZE(INCBIN_ALIGNMENT_INDEX) "\n"
103 | #  define INCBIN_ALIGN_BYTE ".align 0\n"
104 | #else
105 | /* We assume other inline assembler's treat `.align' as `.balign' */
106 | #  define INCBIN_ALIGN_HOST ".align " INCBIN_STRINGIZE(INCBIN_ALIGNMENT) "\n"
107 | #  define INCBIN_ALIGN_BYTE ".align 1\n"
108 | #endif
109 | 
110 | /* INCBIN_CONST is used by incbin.c generated files */
111 | #if defined(__cplusplus)
112 | #  define INCBIN_EXTERNAL extern "C"
113 | #  define INCBIN_CONST    extern const
114 | #else
115 | #  define INCBIN_EXTERNAL extern
116 | #  define INCBIN_CONST    const
117 | #endif
118 | 
119 | /**
120 |  * @brief Optionally override the linker section into which data is emitted.
121 |  *
122 |  * @warning If you use this facility, you'll have to deal with platform-specific linker output
123 |  * section naming on your own
124 |  *
125 |  * Overriding the default linker output section, e.g for esp8266/Arduino:
126 |  * @code
127 |  * #define INCBIN_OUTPUT_SECTION ".irom.text"
128 |  * #include "incbin.h"
129 |  * INCBIN(Foo, "foo.txt");
130 |  * // Data is emitted into program memory that never gets copied to RAM
131 |  * @endcode
132 |  */
133 | #if !defined(INCBIN_OUTPUT_SECTION)
134 | #  if defined(__APPLE__)
135 | #    define INCBIN_OUTPUT_SECTION         ".const_data"
136 | #  else
137 | #    define INCBIN_OUTPUT_SECTION         ".rodata"
138 | #  endif
139 | #endif
140 | 
141 | /**
142 |  * @brief Optionally override the linker section into which data size is emitted.
143 |  * Deaults to INCBIN_OUTPUT_SECTION
144 |  */
145 | #if !defined(INCBIN_SIZE_OUTPUT_SECTION)
146 | #   define INCBIN_SIZE_OUTPUT_SECTION     INCBIN_OUTPUT_SECTION
147 | #endif
148 | 
149 | 
150 | #if defined(__APPLE__)
151 | /* The directives are different for Apple branded compilers */
152 | #  define INCBIN_SECTION         INCBIN_OUTPUT_SECTION "\n"
153 | #  define INCBIN_SIZE_SECTION    INCBIN_SIZE_OUTPUT_SECTION "\n"
154 | #  define INCBIN_GLOBAL(NAME)    ".globl " INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME "\n"
155 | #  define INCBIN_INT             ".long "
156 | #  define INCBIN_MANGLE          "_"
157 | #  define INCBIN_BYTE            ".byte "
158 | #  define INCBIN_TYPE(...)
159 | #else
160 | #  define INCBIN_SECTION         ".section " INCBIN_OUTPUT_SECTION "\n"
161 | #  define INCBIN_SIZE_SECTION    ".section " INCBIN_SIZE_OUTPUT_SECTION "\n"
162 | #  define INCBIN_GLOBAL(NAME)    ".global " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME "\n"
163 | #  if defined(__ghs__)
164 | #    define INCBIN_INT           ".word "
165 | #  else
166 | #    define INCBIN_INT           ".int "
167 | #  endif
168 | #  if defined(__USER_LABEL_PREFIX__)
169 | #    define INCBIN_MANGLE        INCBIN_STRINGIZE(__USER_LABEL_PREFIX__)
170 | #  else
171 | #    define INCBIN_MANGLE        ""
172 | #  endif
173 | #  if defined(INCBIN_ARM)
174 | /* On arm assemblers, `@' is used as a line comment token */
175 | #    define INCBIN_TYPE(NAME)    ".type " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME ", %object\n"
176 | #  elif defined(__MINGW32__) || defined(__MINGW64__)
177 | /* Mingw doesn't support this directive either */
178 | #    define INCBIN_TYPE(NAME)
179 | #  else
180 | /* It's safe to use `@' on other architectures */
181 | #    define INCBIN_TYPE(NAME)    ".type " INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME ", @object\n"
182 | #  endif
183 | #  define INCBIN_BYTE            ".byte "
184 | #endif
185 | 
186 | /* List of style types used for symbol names */
187 | #define INCBIN_STYLE_CAMEL 0
188 | #define INCBIN_STYLE_SNAKE 1
189 | 
190 | /**
191 |  * @brief Specify the prefix to use for symbol names.
192 |  *
193 |  * By default this is `g', producing symbols of the form:
194 |  * @code
195 |  * #include "incbin.h"
196 |  * INCBIN(Foo, "foo.txt");
197 |  *
198 |  * // Now you have the following symbols:
199 |  * // const unsigned char gFooData[];
200 |  * // const unsigned char *const gFooEnd;
201 |  * // const unsigned int gFooSize;
202 |  * @endcode
203 |  *
204 |  * If however you specify a prefix before including: e.g:
205 |  * @code
206 |  * #define INCBIN_PREFIX incbin
207 |  * #include "incbin.h"
208 |  * INCBIN(Foo, "foo.txt");
209 |  *
210 |  * // Now you have the following symbols instead:
211 |  * // const unsigned char incbinFooData[];
212 |  * // const unsigned char *const incbinFooEnd;
213 |  * // const unsigned int incbinFooSize;
214 |  * @endcode
215 |  */
216 | #if !defined(INCBIN_PREFIX)
217 | #  define INCBIN_PREFIX g
218 | #endif
219 | 
220 | /**
221 |  * @brief Specify the style used for symbol names.
222 |  *
223 |  * Possible options are
224 |  * - INCBIN_STYLE_CAMEL "CamelCase"
225 |  * - INCBIN_STYLE_SNAKE "snake_case"
226 |  *
227 |  * Default option is *INCBIN_STYLE_CAMEL* producing symbols of the form:
228 |  * @code
229 |  * #include "incbin.h"
230 |  * INCBIN(Foo, "foo.txt");
231 |  *
232 |  * // Now you have the following symbols:
233 |  * // const unsigned char <prefix>FooData[];
234 |  * // const unsigned char *const <prefix>FooEnd;
235 |  * // const unsigned int <prefix>FooSize;
236 |  * @endcode
237 |  *
238 |  * If however you specify a style before including: e.g:
239 |  * @code
240 |  * #define INCBIN_STYLE INCBIN_STYLE_SNAKE
241 |  * #include "incbin.h"
242 |  * INCBIN(foo, "foo.txt");
243 |  *
244 |  * // Now you have the following symbols:
245 |  * // const unsigned char <prefix>foo_data[];
246 |  * // const unsigned char *const <prefix>foo_end;
247 |  * // const unsigned int <prefix>foo_size;
248 |  * @endcode
249 |  */
250 | #if !defined(INCBIN_STYLE)
251 | #  define INCBIN_STYLE INCBIN_STYLE_CAMEL
252 | #endif
253 | 
254 | /* Style lookup tables */
255 | #define INCBIN_STYLE_0_DATA Data
256 | #define INCBIN_STYLE_0_END End
257 | #define INCBIN_STYLE_0_SIZE Size
258 | #define INCBIN_STYLE_1_DATA _data
259 | #define INCBIN_STYLE_1_END _end
260 | #define INCBIN_STYLE_1_SIZE _size
261 | 
262 | /* Style lookup: returning identifier */
263 | #define INCBIN_STYLE_IDENT(TYPE) \
264 |     INCBIN_CONCATENATE( \
265 |         INCBIN_STYLE_, \
266 |         INCBIN_CONCATENATE( \
267 |             INCBIN_EVAL(INCBIN_STYLE), \
268 |             INCBIN_CONCATENATE(_, TYPE)))
269 | 
270 | /* Style lookup: returning string literal */
271 | #define INCBIN_STYLE_STRING(TYPE) \
272 |     INCBIN_STRINGIZE( \
273 |         INCBIN_STYLE_IDENT(TYPE)) \
274 | 
275 | /* Generate the global labels by indirectly invoking the macro with our style
276 |  * type and concatenating the name against them. */
277 | #define INCBIN_GLOBAL_LABELS(NAME, TYPE) \
278 |     INCBIN_INVOKE( \
279 |         INCBIN_GLOBAL, \
280 |         INCBIN_CONCATENATE( \
281 |             NAME, \
282 |             INCBIN_INVOKE( \
283 |                 INCBIN_STYLE_IDENT, \
284 |                 TYPE))) \
285 |     INCBIN_INVOKE( \
286 |         INCBIN_TYPE, \
287 |         INCBIN_CONCATENATE( \
288 |             NAME, \
289 |             INCBIN_INVOKE( \
290 |                 INCBIN_STYLE_IDENT, \
291 |                 TYPE)))
292 | 
293 | /**
294 |  * @brief If defined, one null-byte (value 0) is appended to the data
295 |  */
296 | #ifdef INCBIN_APPEND_TERMINATING_NULL
297 | #   define INCBIN_APPEND_AFTER_DATA \
298 |         INCBIN_BYTE "0\n"
299 | #else
300 | #   define INCBIN_APPEND_AFTER_DATA
301 | #endif
302 | 
303 | /**
304 |  * @brief Same as INCBIN_EXTERN, but allows to specify data pointer type.
305 |  */
306 | #define INCBIN_EXTERN_PTR_TYPE(NAME, DATA_PTR_TYPE) \
307 |     INCBIN_EXTERNAL const INCBIN_ALIGN DATA_PTR_TYPE \
308 |         INCBIN_CONCATENATE( \
309 |             INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
310 |             INCBIN_STYLE_IDENT(DATA))[]; \
311 |     INCBIN_EXTERNAL const INCBIN_ALIGN DATA_PTR_TYPE *const \
312 |     INCBIN_CONCATENATE( \
313 |         INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
314 |         INCBIN_STYLE_IDENT(END)); \
315 |     INCBIN_EXTERNAL const unsigned int \
316 |         INCBIN_CONCATENATE( \
317 |             INCBIN_CONCATENATE(INCBIN_PREFIX, NAME), \
318 |             INCBIN_STYLE_IDENT(SIZE))
319 | 
320 | /**
321 |  * @brief Externally reference binary data included in another translation unit.
322 |  *
323 |  * Produces three external symbols that reference the binary data included in
324 |  * another translation unit.
325 |  *
326 |  * The symbol names are a concatenation of `INCBIN_PREFIX' before *NAME*; with
327 |  * "Data", as well as "End" and "Size" after. An example is provided below.
328 |  *
329 |  * @param NAME The name given for the binary data
330 |  *
331 |  * @code
332 |  * INCBIN_EXTERN(Foo);
333 |  *
334 |  * // Now you have the following symbols:
335 |  * // extern const unsigned char <prefix>FooData[];
336 |  * // extern const unsigned char *const <prefix>FooEnd;
337 |  * // extern const unsigned int <prefix>FooSize;
338 |  * @endcode
339 |  */
340 | #define INCBIN_EXTERN(NAME) \
341 |     INCBIN_EXTERN_PTR_TYPE(NAME, unsigned char)
342 | 
343 | /**
344 |  * @brief Same as INCBIN, but allows to specify data pointer type.
345 |  */
346 | #ifdef _MSC_VER
347 | #define INCBIN_PTR_TYPE(NAME, FILENAME, DATA_PTR_TYPE) \
348 |     INCBIN_EXTERN_PTR_TYPE(NAME, DATA_PTR_TYPE)
349 | #else
350 | #define INCBIN_PTR_TYPE(NAME, FILENAME, DATA_PTR_TYPE) \
351 |     __asm__(INCBIN_SECTION \
352 |             INCBIN_GLOBAL_LABELS(NAME, DATA) \
353 |             INCBIN_ALIGN_HOST \
354 |             INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(DATA) ":\n" \
355 |             INCBIN_MACRO " \"" FILENAME "\"\n" \
356 |             INCBIN_GLOBAL_LABELS(NAME, END) \
357 |             INCBIN_ALIGN_BYTE \
358 |             INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(END) ":\n" \
359 |             INCBIN_APPEND_AFTER_DATA \
360 |                 INCBIN_BYTE "1\n" \
361 |             INCBIN_SIZE_SECTION \
362 |             INCBIN_GLOBAL_LABELS(NAME, SIZE) \
363 |             INCBIN_ALIGN_HOST \
364 |             INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(SIZE) ":\n" \
365 |                 INCBIN_INT INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(END) " - " \
366 |                            INCBIN_MANGLE INCBIN_STRINGIZE(INCBIN_PREFIX) #NAME INCBIN_STYLE_STRING(DATA) "\n" \
367 |             INCBIN_ALIGN_HOST \
368 |             ".text\n" \
369 |     ); \
370 |     INCBIN_EXTERN_PTR_TYPE(NAME, DATA_PTR_TYPE)
371 | #endif
372 | 
373 | /**
374 |  * @brief Include a binary file into the current translation unit.
375 |  *
376 |  * Includes a binary file into the current translation unit, producing three symbols
377 |  * for objects that encode the data and size respectively.
378 |  *
379 |  * The symbol names are a concatenation of `INCBIN_PREFIX' before *NAME*; with
380 |  * "Data", as well as "End" and "Size" after. An example is provided below.
381 |  *
382 |  * @param NAME The name to associate with this binary data (as an identifier.)
383 |  * @param FILENAME The file to include (as a string literal.)
384 |  *
385 |  * @code
386 |  * INCBIN(Icon, "icon.png");
387 |  *
388 |  * // Now you have the following symbols:
389 |  * // const unsigned char <prefix>IconData[];
390 |  * // const unsigned char *const <prefix>IconEnd;
391 |  * // const unsigned int <prefix>IconSize;
392 |  * @endcode
393 |  *
394 |  * @warning This must be used in global scope
395 |  * @warning The identifiers may be different if INCBIN_STYLE is not default
396 |  *
397 |  * To externally reference the data included by this in another translation unit
398 |  * please @see INCBIN_EXTERN.
399 |  */
400 | #define INCBIN(NAME, FILENAME) \
401 |     INCBIN_PTR_TYPE(NAME, FILENAME, unsigned char)
402 | 
403 | #endif
404 | 


--------------------------------------------------------------------------------
/src/incbin.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author AlexIII
 3 |  * @brief Arduino wrapper for incbin.h
 4 |  */
 5 | 
 6 | #ifndef _ARDUINO_INCBIN_LIB_H_
 7 | #define _ARDUINO_INCBIN_LIB_H_
 8 | 
 9 | #ifndef INCBIN_OUTPUT_SECTION
10 | #   if defined(__AVR__)
11 | #       define INCBIN_OUTPUT_SECTION ".text.progmem"
12 | #       define INCBIN_SIZE_OUTPUT_SECTION ".rodata"
13 | #   elif defined(ESP8266)
14 | #       define INCBIN_OUTPUT_SECTION ".irom.text"
15 | #       define INCBIN_SIZE_OUTPUT_SECTION ".rodata"
16 | #   endif
17 | #endif
18 | 
19 | #define INCBIN_APPEND_TERMINATING_NULL
20 | 
21 | #include "_incbin.h"    // include the original library
22 | 
23 | #if defined(__AVR__) || defined(ESP8266)
24 | #   define INCTEXT(NAME, FILENAME) \
25 |         INCBIN_PTR_TYPE(NAME, FILENAME, __FlashStringHelper)
26 | #else
27 | #   define INCTEXT(NAME, FILENAME) \
28 |         INCBIN_PTR_TYPE(NAME, FILENAME, char)
29 | #endif
30 | 
31 | #ifndef INCTXT
32 | #   define INCTXT(NAME, FILENAME) INCTEXT(NAME, FILENAME)
33 | #endif
34 | 
35 | #endif /* _ARDUINO_INCBIN_LIB_H_ */
36 | 


--------------------------------------------------------------------------------