microSD カードのビットマップ・ファイルのビュアー.画像の最大値 縦:272ピクセル,横:480ピクセル. Bitmap file viewer for microSD card. Maximum size Vertical: 272 pixels, Horizontal: 480.
Dependencies: SDFileSystem_Warning_Fixed F746_GUI
mbed_src_STM32F7/common/retarget.cpp@1:bb146d5fe9aa, 2018-10-23 (annotated)
- Committer:
- MikamiUitOpen
- Date:
- Tue Oct 23 11:51:47 2018 +0000
- Revision:
- 1:bb146d5fe9aa
- Parent:
- 0:f62ffd3644bf
2
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
MikamiUitOpen | 0:f62ffd3644bf | 1 | /* mbed Microcontroller Library |
MikamiUitOpen | 0:f62ffd3644bf | 2 | * Copyright (c) 2006-2015 ARM Limited |
MikamiUitOpen | 0:f62ffd3644bf | 3 | * |
MikamiUitOpen | 0:f62ffd3644bf | 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
MikamiUitOpen | 0:f62ffd3644bf | 5 | * you may not use this file except in compliance with the License. |
MikamiUitOpen | 0:f62ffd3644bf | 6 | * You may obtain a copy of the License at |
MikamiUitOpen | 0:f62ffd3644bf | 7 | * |
MikamiUitOpen | 0:f62ffd3644bf | 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
MikamiUitOpen | 0:f62ffd3644bf | 9 | * |
MikamiUitOpen | 0:f62ffd3644bf | 10 | * Unless required by applicable law or agreed to in writing, software |
MikamiUitOpen | 0:f62ffd3644bf | 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
MikamiUitOpen | 0:f62ffd3644bf | 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
MikamiUitOpen | 0:f62ffd3644bf | 13 | * See the License for the specific language governing permissions and |
MikamiUitOpen | 0:f62ffd3644bf | 14 | * limitations under the License. |
MikamiUitOpen | 0:f62ffd3644bf | 15 | */ |
MikamiUitOpen | 0:f62ffd3644bf | 16 | #include "platform.h" |
MikamiUitOpen | 0:f62ffd3644bf | 17 | #include "FileHandle.h" |
MikamiUitOpen | 0:f62ffd3644bf | 18 | #include "FileSystemLike.h" |
MikamiUitOpen | 0:f62ffd3644bf | 19 | #include "FilePath.h" |
MikamiUitOpen | 0:f62ffd3644bf | 20 | #include "serial_api.h" |
MikamiUitOpen | 0:f62ffd3644bf | 21 | #include "toolchain.h" |
MikamiUitOpen | 0:f62ffd3644bf | 22 | #include "semihost_api.h" |
MikamiUitOpen | 0:f62ffd3644bf | 23 | #include "mbed_interface.h" |
MikamiUitOpen | 0:f62ffd3644bf | 24 | #if DEVICE_STDIO_MESSAGES |
MikamiUitOpen | 0:f62ffd3644bf | 25 | #include <stdio.h> |
MikamiUitOpen | 0:f62ffd3644bf | 26 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 27 | #include <errno.h> |
MikamiUitOpen | 0:f62ffd3644bf | 28 | |
MikamiUitOpen | 0:f62ffd3644bf | 29 | #if defined(__ARMCC_VERSION) |
MikamiUitOpen | 0:f62ffd3644bf | 30 | # include <rt_sys.h> |
MikamiUitOpen | 0:f62ffd3644bf | 31 | # define PREFIX(x) _sys##x |
MikamiUitOpen | 0:f62ffd3644bf | 32 | # define OPEN_MAX _SYS_OPEN |
MikamiUitOpen | 0:f62ffd3644bf | 33 | # ifdef __MICROLIB |
MikamiUitOpen | 0:f62ffd3644bf | 34 | # pragma import(__use_full_stdio) |
MikamiUitOpen | 0:f62ffd3644bf | 35 | # endif |
MikamiUitOpen | 0:f62ffd3644bf | 36 | |
MikamiUitOpen | 0:f62ffd3644bf | 37 | #elif defined(__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 38 | # include <yfuns.h> |
MikamiUitOpen | 0:f62ffd3644bf | 39 | # define PREFIX(x) _##x |
MikamiUitOpen | 0:f62ffd3644bf | 40 | # define OPEN_MAX 16 |
MikamiUitOpen | 0:f62ffd3644bf | 41 | |
MikamiUitOpen | 0:f62ffd3644bf | 42 | # define STDIN_FILENO 0 |
MikamiUitOpen | 0:f62ffd3644bf | 43 | # define STDOUT_FILENO 1 |
MikamiUitOpen | 0:f62ffd3644bf | 44 | # define STDERR_FILENO 2 |
MikamiUitOpen | 0:f62ffd3644bf | 45 | |
MikamiUitOpen | 0:f62ffd3644bf | 46 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 47 | # include <sys/stat.h> |
MikamiUitOpen | 0:f62ffd3644bf | 48 | # include <sys/unistd.h> |
MikamiUitOpen | 0:f62ffd3644bf | 49 | # include <sys/syslimits.h> |
MikamiUitOpen | 0:f62ffd3644bf | 50 | # define PREFIX(x) x |
MikamiUitOpen | 0:f62ffd3644bf | 51 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 52 | |
MikamiUitOpen | 0:f62ffd3644bf | 53 | using namespace mbed; |
MikamiUitOpen | 0:f62ffd3644bf | 54 | |
MikamiUitOpen | 0:f62ffd3644bf | 55 | #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000) |
MikamiUitOpen | 0:f62ffd3644bf | 56 | // Before version 5.03, we were using a patched version of microlib with proper names |
MikamiUitOpen | 0:f62ffd3644bf | 57 | extern const char __stdin_name[] = ":tt"; |
MikamiUitOpen | 0:f62ffd3644bf | 58 | extern const char __stdout_name[] = ":tt"; |
MikamiUitOpen | 0:f62ffd3644bf | 59 | extern const char __stderr_name[] = ":tt"; |
MikamiUitOpen | 0:f62ffd3644bf | 60 | |
MikamiUitOpen | 0:f62ffd3644bf | 61 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 62 | extern const char __stdin_name[] = "/stdin"; |
MikamiUitOpen | 0:f62ffd3644bf | 63 | extern const char __stdout_name[] = "/stdout"; |
MikamiUitOpen | 0:f62ffd3644bf | 64 | extern const char __stderr_name[] = "/stderr"; |
MikamiUitOpen | 0:f62ffd3644bf | 65 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 66 | |
MikamiUitOpen | 0:f62ffd3644bf | 67 | /* newlib has the filehandle field in the FILE struct as a short, so |
MikamiUitOpen | 0:f62ffd3644bf | 68 | * we can't just return a Filehandle* from _open and instead have to |
MikamiUitOpen | 0:f62ffd3644bf | 69 | * put it in a filehandles array and return the index into that array |
MikamiUitOpen | 0:f62ffd3644bf | 70 | * (or rather index+3, as filehandles 0-2 are stdin/out/err). |
MikamiUitOpen | 0:f62ffd3644bf | 71 | */ |
MikamiUitOpen | 0:f62ffd3644bf | 72 | static FileHandle *filehandles[OPEN_MAX]; |
MikamiUitOpen | 0:f62ffd3644bf | 73 | |
MikamiUitOpen | 0:f62ffd3644bf | 74 | FileHandle::~FileHandle() { |
MikamiUitOpen | 0:f62ffd3644bf | 75 | /* Remove all open filehandles for this */ |
MikamiUitOpen | 0:f62ffd3644bf | 76 | for (unsigned int fh_i = 0; fh_i < sizeof(filehandles)/sizeof(*filehandles); fh_i++) { |
MikamiUitOpen | 0:f62ffd3644bf | 77 | if (filehandles[fh_i] == this) { |
MikamiUitOpen | 0:f62ffd3644bf | 78 | filehandles[fh_i] = NULL; |
MikamiUitOpen | 0:f62ffd3644bf | 79 | } |
MikamiUitOpen | 0:f62ffd3644bf | 80 | } |
MikamiUitOpen | 0:f62ffd3644bf | 81 | } |
MikamiUitOpen | 0:f62ffd3644bf | 82 | |
MikamiUitOpen | 0:f62ffd3644bf | 83 | #if DEVICE_SERIAL |
MikamiUitOpen | 0:f62ffd3644bf | 84 | extern int stdio_uart_inited; |
MikamiUitOpen | 0:f62ffd3644bf | 85 | extern serial_t stdio_uart; |
MikamiUitOpen | 0:f62ffd3644bf | 86 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 87 | |
MikamiUitOpen | 0:f62ffd3644bf | 88 | static void init_serial() { |
MikamiUitOpen | 0:f62ffd3644bf | 89 | #if DEVICE_SERIAL |
MikamiUitOpen | 0:f62ffd3644bf | 90 | if (stdio_uart_inited) return; |
MikamiUitOpen | 0:f62ffd3644bf | 91 | serial_init(&stdio_uart, STDIO_UART_TX, STDIO_UART_RX); |
MikamiUitOpen | 0:f62ffd3644bf | 92 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 93 | } |
MikamiUitOpen | 0:f62ffd3644bf | 94 | |
MikamiUitOpen | 0:f62ffd3644bf | 95 | static inline int openmode_to_posix(int openmode) { |
MikamiUitOpen | 0:f62ffd3644bf | 96 | int posix = openmode; |
MikamiUitOpen | 0:f62ffd3644bf | 97 | #ifdef __ARMCC_VERSION |
MikamiUitOpen | 0:f62ffd3644bf | 98 | if (openmode & OPEN_PLUS) { |
MikamiUitOpen | 0:f62ffd3644bf | 99 | posix = O_RDWR; |
MikamiUitOpen | 0:f62ffd3644bf | 100 | } else if(openmode & OPEN_W) { |
MikamiUitOpen | 0:f62ffd3644bf | 101 | posix = O_WRONLY; |
MikamiUitOpen | 0:f62ffd3644bf | 102 | } else if(openmode & OPEN_A) { |
MikamiUitOpen | 0:f62ffd3644bf | 103 | posix = O_WRONLY|O_APPEND; |
MikamiUitOpen | 0:f62ffd3644bf | 104 | } else { |
MikamiUitOpen | 0:f62ffd3644bf | 105 | posix = O_RDONLY; |
MikamiUitOpen | 0:f62ffd3644bf | 106 | } |
MikamiUitOpen | 0:f62ffd3644bf | 107 | /* a, w, a+, w+ all create if file does not already exist */ |
MikamiUitOpen | 0:f62ffd3644bf | 108 | if (openmode & (OPEN_A|OPEN_W)) { |
MikamiUitOpen | 0:f62ffd3644bf | 109 | posix |= O_CREAT; |
MikamiUitOpen | 0:f62ffd3644bf | 110 | } |
MikamiUitOpen | 0:f62ffd3644bf | 111 | /* w and w+ truncate */ |
MikamiUitOpen | 0:f62ffd3644bf | 112 | if (openmode & OPEN_W) { |
MikamiUitOpen | 0:f62ffd3644bf | 113 | posix |= O_TRUNC; |
MikamiUitOpen | 0:f62ffd3644bf | 114 | } |
MikamiUitOpen | 0:f62ffd3644bf | 115 | #elif defined(__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 116 | switch (openmode & _LLIO_RDWRMASK) { |
MikamiUitOpen | 0:f62ffd3644bf | 117 | case _LLIO_RDONLY: posix = O_RDONLY; break; |
MikamiUitOpen | 0:f62ffd3644bf | 118 | case _LLIO_WRONLY: posix = O_WRONLY; break; |
MikamiUitOpen | 0:f62ffd3644bf | 119 | case _LLIO_RDWR : posix = O_RDWR ; break; |
MikamiUitOpen | 0:f62ffd3644bf | 120 | } |
MikamiUitOpen | 0:f62ffd3644bf | 121 | if (openmode & _LLIO_CREAT ) posix |= O_CREAT; |
MikamiUitOpen | 0:f62ffd3644bf | 122 | if (openmode & _LLIO_APPEND) posix |= O_APPEND; |
MikamiUitOpen | 0:f62ffd3644bf | 123 | if (openmode & _LLIO_TRUNC ) posix |= O_TRUNC; |
MikamiUitOpen | 0:f62ffd3644bf | 124 | #elif defined(TOOLCHAIN_GCC) |
MikamiUitOpen | 0:f62ffd3644bf | 125 | posix &= ~O_BINARY; |
MikamiUitOpen | 0:f62ffd3644bf | 126 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 127 | return posix; |
MikamiUitOpen | 0:f62ffd3644bf | 128 | } |
MikamiUitOpen | 0:f62ffd3644bf | 129 | |
MikamiUitOpen | 0:f62ffd3644bf | 130 | extern "C" FILEHANDLE PREFIX(_open)(const char* name, int openmode) { |
MikamiUitOpen | 0:f62ffd3644bf | 131 | #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000) |
MikamiUitOpen | 0:f62ffd3644bf | 132 | // Before version 5.03, we were using a patched version of microlib with proper names |
MikamiUitOpen | 0:f62ffd3644bf | 133 | // This is the workaround that the microlib author suggested us |
MikamiUitOpen | 0:f62ffd3644bf | 134 | static int n = 0; |
MikamiUitOpen | 0:f62ffd3644bf | 135 | if (!std::strcmp(name, ":tt")) return n++; |
MikamiUitOpen | 0:f62ffd3644bf | 136 | |
MikamiUitOpen | 0:f62ffd3644bf | 137 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 138 | /* Use the posix convention that stdin,out,err are filehandles 0,1,2. |
MikamiUitOpen | 0:f62ffd3644bf | 139 | */ |
MikamiUitOpen | 0:f62ffd3644bf | 140 | if (std::strcmp(name, __stdin_name) == 0) { |
MikamiUitOpen | 0:f62ffd3644bf | 141 | init_serial(); |
MikamiUitOpen | 0:f62ffd3644bf | 142 | return 0; |
MikamiUitOpen | 0:f62ffd3644bf | 143 | } else if (std::strcmp(name, __stdout_name) == 0) { |
MikamiUitOpen | 0:f62ffd3644bf | 144 | init_serial(); |
MikamiUitOpen | 0:f62ffd3644bf | 145 | return 1; |
MikamiUitOpen | 0:f62ffd3644bf | 146 | } else if (std::strcmp(name, __stderr_name) == 0) { |
MikamiUitOpen | 0:f62ffd3644bf | 147 | init_serial(); |
MikamiUitOpen | 0:f62ffd3644bf | 148 | return 2; |
MikamiUitOpen | 0:f62ffd3644bf | 149 | } |
MikamiUitOpen | 0:f62ffd3644bf | 150 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 151 | |
MikamiUitOpen | 0:f62ffd3644bf | 152 | // find the first empty slot in filehandles |
MikamiUitOpen | 0:f62ffd3644bf | 153 | unsigned int fh_i; |
MikamiUitOpen | 0:f62ffd3644bf | 154 | for (fh_i = 0; fh_i < sizeof(filehandles)/sizeof(*filehandles); fh_i++) { |
MikamiUitOpen | 0:f62ffd3644bf | 155 | if (filehandles[fh_i] == NULL) break; |
MikamiUitOpen | 0:f62ffd3644bf | 156 | } |
MikamiUitOpen | 0:f62ffd3644bf | 157 | if (fh_i >= sizeof(filehandles)/sizeof(*filehandles)) { |
MikamiUitOpen | 0:f62ffd3644bf | 158 | return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 159 | } |
MikamiUitOpen | 0:f62ffd3644bf | 160 | |
MikamiUitOpen | 0:f62ffd3644bf | 161 | FileHandle *res; |
MikamiUitOpen | 0:f62ffd3644bf | 162 | |
MikamiUitOpen | 0:f62ffd3644bf | 163 | /* FILENAME: ":0x12345678" describes a FileLike* */ |
MikamiUitOpen | 0:f62ffd3644bf | 164 | if (name[0] == ':') { |
MikamiUitOpen | 0:f62ffd3644bf | 165 | void *p; |
MikamiUitOpen | 0:f62ffd3644bf | 166 | sscanf(name, ":%p", &p); |
MikamiUitOpen | 0:f62ffd3644bf | 167 | res = (FileHandle*)p; |
MikamiUitOpen | 0:f62ffd3644bf | 168 | |
MikamiUitOpen | 0:f62ffd3644bf | 169 | /* FILENAME: "/file_system/file_name" */ |
MikamiUitOpen | 0:f62ffd3644bf | 170 | } else { |
MikamiUitOpen | 0:f62ffd3644bf | 171 | FilePath path(name); |
MikamiUitOpen | 0:f62ffd3644bf | 172 | |
MikamiUitOpen | 0:f62ffd3644bf | 173 | if (!path.exists()) |
MikamiUitOpen | 0:f62ffd3644bf | 174 | return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 175 | else if (path.isFile()) { |
MikamiUitOpen | 0:f62ffd3644bf | 176 | res = path.file(); |
MikamiUitOpen | 0:f62ffd3644bf | 177 | } else { |
MikamiUitOpen | 0:f62ffd3644bf | 178 | FileSystemLike *fs = path.fileSystem(); |
MikamiUitOpen | 0:f62ffd3644bf | 179 | if (fs == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 180 | int posix_mode = openmode_to_posix(openmode); |
MikamiUitOpen | 0:f62ffd3644bf | 181 | res = fs->open(path.fileName(), posix_mode); /* NULL if fails */ |
MikamiUitOpen | 0:f62ffd3644bf | 182 | } |
MikamiUitOpen | 0:f62ffd3644bf | 183 | } |
MikamiUitOpen | 0:f62ffd3644bf | 184 | |
MikamiUitOpen | 0:f62ffd3644bf | 185 | if (res == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 186 | filehandles[fh_i] = res; |
MikamiUitOpen | 0:f62ffd3644bf | 187 | |
MikamiUitOpen | 0:f62ffd3644bf | 188 | return fh_i + 3; // +3 as filehandles 0-2 are stdin/out/err |
MikamiUitOpen | 0:f62ffd3644bf | 189 | } |
MikamiUitOpen | 0:f62ffd3644bf | 190 | |
MikamiUitOpen | 0:f62ffd3644bf | 191 | extern "C" int PREFIX(_close)(FILEHANDLE fh) { |
MikamiUitOpen | 0:f62ffd3644bf | 192 | if (fh < 3) return 0; |
MikamiUitOpen | 0:f62ffd3644bf | 193 | |
MikamiUitOpen | 0:f62ffd3644bf | 194 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 195 | filehandles[fh-3] = NULL; |
MikamiUitOpen | 0:f62ffd3644bf | 196 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 197 | |
MikamiUitOpen | 0:f62ffd3644bf | 198 | return fhc->close(); |
MikamiUitOpen | 0:f62ffd3644bf | 199 | } |
MikamiUitOpen | 0:f62ffd3644bf | 200 | |
MikamiUitOpen | 0:f62ffd3644bf | 201 | #if defined(__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 202 | extern "C" size_t __write (int fh, const unsigned char *buffer, size_t length) { |
MikamiUitOpen | 0:f62ffd3644bf | 203 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 204 | extern "C" int PREFIX(_write)(FILEHANDLE fh, const unsigned char *buffer, unsigned int length, int mode) { |
MikamiUitOpen | 0:f62ffd3644bf | 205 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 206 | int n; // n is the number of bytes written |
MikamiUitOpen | 0:f62ffd3644bf | 207 | if (fh < 3) { |
MikamiUitOpen | 0:f62ffd3644bf | 208 | #if DEVICE_SERIAL |
MikamiUitOpen | 0:f62ffd3644bf | 209 | if (!stdio_uart_inited) init_serial(); |
MikamiUitOpen | 0:f62ffd3644bf | 210 | for (unsigned int i = 0; i < length; i++) { |
MikamiUitOpen | 0:f62ffd3644bf | 211 | serial_putc(&stdio_uart, buffer[i]); |
MikamiUitOpen | 0:f62ffd3644bf | 212 | } |
MikamiUitOpen | 0:f62ffd3644bf | 213 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 214 | n = length; |
MikamiUitOpen | 0:f62ffd3644bf | 215 | } else { |
MikamiUitOpen | 0:f62ffd3644bf | 216 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 217 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 218 | |
MikamiUitOpen | 0:f62ffd3644bf | 219 | n = fhc->write(buffer, length); |
MikamiUitOpen | 0:f62ffd3644bf | 220 | } |
MikamiUitOpen | 0:f62ffd3644bf | 221 | #ifdef __ARMCC_VERSION |
MikamiUitOpen | 0:f62ffd3644bf | 222 | return length-n; |
MikamiUitOpen | 0:f62ffd3644bf | 223 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 224 | return n; |
MikamiUitOpen | 0:f62ffd3644bf | 225 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 226 | } |
MikamiUitOpen | 0:f62ffd3644bf | 227 | |
MikamiUitOpen | 0:f62ffd3644bf | 228 | #if defined(__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 229 | extern "C" size_t __read (int fh, unsigned char *buffer, size_t length) { |
MikamiUitOpen | 0:f62ffd3644bf | 230 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 231 | extern "C" int PREFIX(_read)(FILEHANDLE fh, unsigned char *buffer, unsigned int length, int mode) { |
MikamiUitOpen | 0:f62ffd3644bf | 232 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 233 | int n; // n is the number of bytes read |
MikamiUitOpen | 0:f62ffd3644bf | 234 | if (fh < 3) { |
MikamiUitOpen | 0:f62ffd3644bf | 235 | // only read a character at a time from stdin |
MikamiUitOpen | 0:f62ffd3644bf | 236 | #if DEVICE_SERIAL |
MikamiUitOpen | 0:f62ffd3644bf | 237 | if (!stdio_uart_inited) init_serial(); |
MikamiUitOpen | 0:f62ffd3644bf | 238 | *buffer = serial_getc(&stdio_uart); |
MikamiUitOpen | 0:f62ffd3644bf | 239 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 240 | n = 1; |
MikamiUitOpen | 0:f62ffd3644bf | 241 | } else { |
MikamiUitOpen | 0:f62ffd3644bf | 242 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 243 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 244 | |
MikamiUitOpen | 0:f62ffd3644bf | 245 | n = fhc->read(buffer, length); |
MikamiUitOpen | 0:f62ffd3644bf | 246 | } |
MikamiUitOpen | 0:f62ffd3644bf | 247 | #ifdef __ARMCC_VERSION |
MikamiUitOpen | 0:f62ffd3644bf | 248 | return length-n; |
MikamiUitOpen | 0:f62ffd3644bf | 249 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 250 | return n; |
MikamiUitOpen | 0:f62ffd3644bf | 251 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 252 | } |
MikamiUitOpen | 0:f62ffd3644bf | 253 | |
MikamiUitOpen | 0:f62ffd3644bf | 254 | #ifdef __ARMCC_VERSION |
MikamiUitOpen | 0:f62ffd3644bf | 255 | extern "C" int PREFIX(_istty)(FILEHANDLE fh) |
MikamiUitOpen | 0:f62ffd3644bf | 256 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 257 | extern "C" int _isatty(FILEHANDLE fh) |
MikamiUitOpen | 0:f62ffd3644bf | 258 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 259 | { |
MikamiUitOpen | 0:f62ffd3644bf | 260 | /* stdin, stdout and stderr should be tty */ |
MikamiUitOpen | 0:f62ffd3644bf | 261 | if (fh < 3) return 1; |
MikamiUitOpen | 0:f62ffd3644bf | 262 | |
MikamiUitOpen | 0:f62ffd3644bf | 263 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 264 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 265 | |
MikamiUitOpen | 0:f62ffd3644bf | 266 | return fhc->isatty(); |
MikamiUitOpen | 0:f62ffd3644bf | 267 | } |
MikamiUitOpen | 0:f62ffd3644bf | 268 | |
MikamiUitOpen | 0:f62ffd3644bf | 269 | extern "C" |
MikamiUitOpen | 0:f62ffd3644bf | 270 | #if defined(__ARMCC_VERSION) |
MikamiUitOpen | 0:f62ffd3644bf | 271 | int _sys_seek(FILEHANDLE fh, long position) |
MikamiUitOpen | 0:f62ffd3644bf | 272 | #elif defined(__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 273 | long __lseek(int fh, long offset, int whence) |
MikamiUitOpen | 0:f62ffd3644bf | 274 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 275 | int _lseek(FILEHANDLE fh, int offset, int whence) |
MikamiUitOpen | 0:f62ffd3644bf | 276 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 277 | { |
MikamiUitOpen | 0:f62ffd3644bf | 278 | if (fh < 3) return 0; |
MikamiUitOpen | 0:f62ffd3644bf | 279 | |
MikamiUitOpen | 0:f62ffd3644bf | 280 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 281 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 282 | |
MikamiUitOpen | 0:f62ffd3644bf | 283 | #if defined(__ARMCC_VERSION) |
MikamiUitOpen | 0:f62ffd3644bf | 284 | return fhc->lseek(position, SEEK_SET); |
MikamiUitOpen | 0:f62ffd3644bf | 285 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 286 | return fhc->lseek(offset, whence); |
MikamiUitOpen | 0:f62ffd3644bf | 287 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 288 | } |
MikamiUitOpen | 0:f62ffd3644bf | 289 | |
MikamiUitOpen | 0:f62ffd3644bf | 290 | #ifdef __ARMCC_VERSION |
MikamiUitOpen | 0:f62ffd3644bf | 291 | extern "C" int PREFIX(_ensure)(FILEHANDLE fh) { |
MikamiUitOpen | 0:f62ffd3644bf | 292 | if (fh < 3) return 0; |
MikamiUitOpen | 0:f62ffd3644bf | 293 | |
MikamiUitOpen | 0:f62ffd3644bf | 294 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 295 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 296 | |
MikamiUitOpen | 0:f62ffd3644bf | 297 | return fhc->fsync(); |
MikamiUitOpen | 0:f62ffd3644bf | 298 | } |
MikamiUitOpen | 0:f62ffd3644bf | 299 | |
MikamiUitOpen | 0:f62ffd3644bf | 300 | extern "C" long PREFIX(_flen)(FILEHANDLE fh) { |
MikamiUitOpen | 0:f62ffd3644bf | 301 | if (fh < 3) return 0; |
MikamiUitOpen | 0:f62ffd3644bf | 302 | |
MikamiUitOpen | 0:f62ffd3644bf | 303 | FileHandle* fhc = filehandles[fh-3]; |
MikamiUitOpen | 0:f62ffd3644bf | 304 | if (fhc == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 305 | |
MikamiUitOpen | 0:f62ffd3644bf | 306 | return fhc->flen(); |
MikamiUitOpen | 0:f62ffd3644bf | 307 | } |
MikamiUitOpen | 0:f62ffd3644bf | 308 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 309 | |
MikamiUitOpen | 0:f62ffd3644bf | 310 | |
MikamiUitOpen | 0:f62ffd3644bf | 311 | #if !defined(__ARMCC_VERSION) && !defined(__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 312 | extern "C" int _fstat(int fd, struct stat *st) { |
MikamiUitOpen | 0:f62ffd3644bf | 313 | if ((STDOUT_FILENO == fd) || (STDERR_FILENO == fd) || (STDIN_FILENO == fd)) { |
MikamiUitOpen | 0:f62ffd3644bf | 314 | st->st_mode = S_IFCHR; |
MikamiUitOpen | 0:f62ffd3644bf | 315 | return 0; |
MikamiUitOpen | 0:f62ffd3644bf | 316 | } |
MikamiUitOpen | 0:f62ffd3644bf | 317 | |
MikamiUitOpen | 0:f62ffd3644bf | 318 | errno = EBADF; |
MikamiUitOpen | 0:f62ffd3644bf | 319 | return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 320 | } |
MikamiUitOpen | 0:f62ffd3644bf | 321 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 322 | |
MikamiUitOpen | 0:f62ffd3644bf | 323 | namespace std { |
MikamiUitOpen | 0:f62ffd3644bf | 324 | extern "C" int remove(const char *path) { |
MikamiUitOpen | 0:f62ffd3644bf | 325 | FilePath fp(path); |
MikamiUitOpen | 0:f62ffd3644bf | 326 | FileSystemLike *fs = fp.fileSystem(); |
MikamiUitOpen | 0:f62ffd3644bf | 327 | if (fs == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 328 | |
MikamiUitOpen | 0:f62ffd3644bf | 329 | return fs->remove(fp.fileName()); |
MikamiUitOpen | 0:f62ffd3644bf | 330 | } |
MikamiUitOpen | 0:f62ffd3644bf | 331 | |
MikamiUitOpen | 0:f62ffd3644bf | 332 | extern "C" int rename(const char *oldname, const char *newname) { |
MikamiUitOpen | 0:f62ffd3644bf | 333 | FilePath fpOld(oldname); |
MikamiUitOpen | 0:f62ffd3644bf | 334 | FilePath fpNew(newname); |
MikamiUitOpen | 0:f62ffd3644bf | 335 | FileSystemLike *fsOld = fpOld.fileSystem(); |
MikamiUitOpen | 0:f62ffd3644bf | 336 | FileSystemLike *fsNew = fpNew.fileSystem(); |
MikamiUitOpen | 0:f62ffd3644bf | 337 | |
MikamiUitOpen | 0:f62ffd3644bf | 338 | /* rename only if both files are on the same FS */ |
MikamiUitOpen | 0:f62ffd3644bf | 339 | if (fsOld != fsNew || fsOld == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 340 | |
MikamiUitOpen | 0:f62ffd3644bf | 341 | return fsOld->rename(fpOld.fileName(), fpNew.fileName()); |
MikamiUitOpen | 0:f62ffd3644bf | 342 | } |
MikamiUitOpen | 0:f62ffd3644bf | 343 | |
MikamiUitOpen | 0:f62ffd3644bf | 344 | extern "C" char *tmpnam(char *s) { |
MikamiUitOpen | 0:f62ffd3644bf | 345 | return NULL; |
MikamiUitOpen | 0:f62ffd3644bf | 346 | } |
MikamiUitOpen | 0:f62ffd3644bf | 347 | |
MikamiUitOpen | 0:f62ffd3644bf | 348 | extern "C" FILE *tmpfile() { |
MikamiUitOpen | 0:f62ffd3644bf | 349 | return NULL; |
MikamiUitOpen | 0:f62ffd3644bf | 350 | } |
MikamiUitOpen | 0:f62ffd3644bf | 351 | } // namespace std |
MikamiUitOpen | 0:f62ffd3644bf | 352 | |
MikamiUitOpen | 0:f62ffd3644bf | 353 | #ifdef __ARMCC_VERSION |
MikamiUitOpen | 0:f62ffd3644bf | 354 | extern "C" char *_sys_command_string(char *cmd, int len) { |
MikamiUitOpen | 0:f62ffd3644bf | 355 | return NULL; |
MikamiUitOpen | 0:f62ffd3644bf | 356 | } |
MikamiUitOpen | 0:f62ffd3644bf | 357 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 358 | |
MikamiUitOpen | 0:f62ffd3644bf | 359 | extern "C" DIR *opendir(const char *path) { |
MikamiUitOpen | 0:f62ffd3644bf | 360 | /* root dir is FileSystemLike */ |
MikamiUitOpen | 0:f62ffd3644bf | 361 | if (path[0] == '/' && path[1] == 0) { |
MikamiUitOpen | 0:f62ffd3644bf | 362 | return FileSystemLike::opendir(); |
MikamiUitOpen | 0:f62ffd3644bf | 363 | } |
MikamiUitOpen | 0:f62ffd3644bf | 364 | |
MikamiUitOpen | 0:f62ffd3644bf | 365 | FilePath fp(path); |
MikamiUitOpen | 0:f62ffd3644bf | 366 | FileSystemLike* fs = fp.fileSystem(); |
MikamiUitOpen | 0:f62ffd3644bf | 367 | if (fs == NULL) return NULL; |
MikamiUitOpen | 0:f62ffd3644bf | 368 | |
MikamiUitOpen | 0:f62ffd3644bf | 369 | return fs->opendir(fp.fileName()); |
MikamiUitOpen | 0:f62ffd3644bf | 370 | } |
MikamiUitOpen | 0:f62ffd3644bf | 371 | |
MikamiUitOpen | 0:f62ffd3644bf | 372 | extern "C" struct dirent *readdir(DIR *dir) { |
MikamiUitOpen | 0:f62ffd3644bf | 373 | return dir->readdir(); |
MikamiUitOpen | 0:f62ffd3644bf | 374 | } |
MikamiUitOpen | 0:f62ffd3644bf | 375 | |
MikamiUitOpen | 0:f62ffd3644bf | 376 | extern "C" int closedir(DIR *dir) { |
MikamiUitOpen | 0:f62ffd3644bf | 377 | return dir->closedir(); |
MikamiUitOpen | 0:f62ffd3644bf | 378 | } |
MikamiUitOpen | 0:f62ffd3644bf | 379 | |
MikamiUitOpen | 0:f62ffd3644bf | 380 | extern "C" void rewinddir(DIR *dir) { |
MikamiUitOpen | 0:f62ffd3644bf | 381 | dir->rewinddir(); |
MikamiUitOpen | 0:f62ffd3644bf | 382 | } |
MikamiUitOpen | 0:f62ffd3644bf | 383 | |
MikamiUitOpen | 0:f62ffd3644bf | 384 | extern "C" off_t telldir(DIR *dir) { |
MikamiUitOpen | 0:f62ffd3644bf | 385 | return dir->telldir(); |
MikamiUitOpen | 0:f62ffd3644bf | 386 | } |
MikamiUitOpen | 0:f62ffd3644bf | 387 | |
MikamiUitOpen | 0:f62ffd3644bf | 388 | extern "C" void seekdir(DIR *dir, off_t off) { |
MikamiUitOpen | 0:f62ffd3644bf | 389 | dir->seekdir(off); |
MikamiUitOpen | 0:f62ffd3644bf | 390 | } |
MikamiUitOpen | 0:f62ffd3644bf | 391 | |
MikamiUitOpen | 0:f62ffd3644bf | 392 | extern "C" int mkdir(const char *path, mode_t mode) { |
MikamiUitOpen | 0:f62ffd3644bf | 393 | FilePath fp(path); |
MikamiUitOpen | 0:f62ffd3644bf | 394 | FileSystemLike *fs = fp.fileSystem(); |
MikamiUitOpen | 0:f62ffd3644bf | 395 | if (fs == NULL) return -1; |
MikamiUitOpen | 0:f62ffd3644bf | 396 | |
MikamiUitOpen | 0:f62ffd3644bf | 397 | return fs->mkdir(fp.fileName(), mode); |
MikamiUitOpen | 0:f62ffd3644bf | 398 | } |
MikamiUitOpen | 0:f62ffd3644bf | 399 | |
MikamiUitOpen | 0:f62ffd3644bf | 400 | #if defined(TOOLCHAIN_GCC) |
MikamiUitOpen | 0:f62ffd3644bf | 401 | /* prevents the exception handling name demangling code getting pulled in */ |
MikamiUitOpen | 0:f62ffd3644bf | 402 | #include "mbed_error.h" |
MikamiUitOpen | 0:f62ffd3644bf | 403 | namespace __gnu_cxx { |
MikamiUitOpen | 0:f62ffd3644bf | 404 | void __verbose_terminate_handler() { |
MikamiUitOpen | 0:f62ffd3644bf | 405 | error("Exception"); |
MikamiUitOpen | 0:f62ffd3644bf | 406 | } |
MikamiUitOpen | 0:f62ffd3644bf | 407 | } |
MikamiUitOpen | 0:f62ffd3644bf | 408 | extern "C" WEAK void __cxa_pure_virtual(void); |
MikamiUitOpen | 0:f62ffd3644bf | 409 | extern "C" WEAK void __cxa_pure_virtual(void) { |
MikamiUitOpen | 0:f62ffd3644bf | 410 | exit(1); |
MikamiUitOpen | 0:f62ffd3644bf | 411 | } |
MikamiUitOpen | 0:f62ffd3644bf | 412 | |
MikamiUitOpen | 0:f62ffd3644bf | 413 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 414 | |
MikamiUitOpen | 0:f62ffd3644bf | 415 | // **************************************************************************** |
MikamiUitOpen | 0:f62ffd3644bf | 416 | // mbed_main is a function that is called before main() |
MikamiUitOpen | 0:f62ffd3644bf | 417 | // mbed_sdk_init() is also a function that is called before main(), but unlike |
MikamiUitOpen | 0:f62ffd3644bf | 418 | // mbed_main(), it is not meant for user code, but for the SDK itself to perform |
MikamiUitOpen | 0:f62ffd3644bf | 419 | // initializations before main() is called. |
MikamiUitOpen | 0:f62ffd3644bf | 420 | |
MikamiUitOpen | 0:f62ffd3644bf | 421 | extern "C" WEAK void mbed_main(void); |
MikamiUitOpen | 0:f62ffd3644bf | 422 | extern "C" WEAK void mbed_main(void) { |
MikamiUitOpen | 0:f62ffd3644bf | 423 | } |
MikamiUitOpen | 0:f62ffd3644bf | 424 | |
MikamiUitOpen | 0:f62ffd3644bf | 425 | extern "C" WEAK void mbed_sdk_init(void); |
MikamiUitOpen | 0:f62ffd3644bf | 426 | extern "C" WEAK void mbed_sdk_init(void) { |
MikamiUitOpen | 0:f62ffd3644bf | 427 | } |
MikamiUitOpen | 0:f62ffd3644bf | 428 | |
MikamiUitOpen | 0:f62ffd3644bf | 429 | #if defined(TOOLCHAIN_ARM) |
MikamiUitOpen | 0:f62ffd3644bf | 430 | extern "C" int $Super$$main(void); |
MikamiUitOpen | 0:f62ffd3644bf | 431 | |
MikamiUitOpen | 0:f62ffd3644bf | 432 | extern "C" int $Sub$$main(void) { |
MikamiUitOpen | 0:f62ffd3644bf | 433 | mbed_sdk_init(); |
MikamiUitOpen | 0:f62ffd3644bf | 434 | mbed_main(); |
MikamiUitOpen | 0:f62ffd3644bf | 435 | return $Super$$main(); |
MikamiUitOpen | 0:f62ffd3644bf | 436 | } |
MikamiUitOpen | 0:f62ffd3644bf | 437 | #elif defined(TOOLCHAIN_GCC) |
MikamiUitOpen | 0:f62ffd3644bf | 438 | extern "C" int __real_main(void); |
MikamiUitOpen | 0:f62ffd3644bf | 439 | |
MikamiUitOpen | 0:f62ffd3644bf | 440 | extern "C" int __wrap_main(void) { |
MikamiUitOpen | 0:f62ffd3644bf | 441 | mbed_sdk_init(); |
MikamiUitOpen | 0:f62ffd3644bf | 442 | mbed_main(); |
MikamiUitOpen | 0:f62ffd3644bf | 443 | return __real_main(); |
MikamiUitOpen | 0:f62ffd3644bf | 444 | } |
MikamiUitOpen | 0:f62ffd3644bf | 445 | #elif defined(TOOLCHAIN_IAR) |
MikamiUitOpen | 0:f62ffd3644bf | 446 | // IAR doesn't have the $Super/$Sub mechanism of armcc, nor something equivalent |
MikamiUitOpen | 0:f62ffd3644bf | 447 | // to ld's --wrap. It does have a --redirect, but that doesn't help, since redirecting |
MikamiUitOpen | 0:f62ffd3644bf | 448 | // 'main' to another symbol looses the original 'main' symbol. However, its startup |
MikamiUitOpen | 0:f62ffd3644bf | 449 | // code will call a function to setup argc and argv (__iar_argc_argv) if it is defined. |
MikamiUitOpen | 0:f62ffd3644bf | 450 | // Since mbed doesn't use argc/argv, we use this function to call our mbed_main. |
MikamiUitOpen | 0:f62ffd3644bf | 451 | extern "C" void __iar_argc_argv() { |
MikamiUitOpen | 0:f62ffd3644bf | 452 | mbed_sdk_init(); |
MikamiUitOpen | 0:f62ffd3644bf | 453 | mbed_main(); |
MikamiUitOpen | 0:f62ffd3644bf | 454 | } |
MikamiUitOpen | 0:f62ffd3644bf | 455 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 456 | |
MikamiUitOpen | 0:f62ffd3644bf | 457 | // Provide implementation of _sbrk (low-level dynamic memory allocation |
MikamiUitOpen | 0:f62ffd3644bf | 458 | // routine) for GCC_ARM which compares new heap pointer with MSP instead of |
MikamiUitOpen | 0:f62ffd3644bf | 459 | // SP. This make it compatible with RTX RTOS thread stacks. |
MikamiUitOpen | 0:f62ffd3644bf | 460 | #if defined(TOOLCHAIN_GCC_ARM) |
MikamiUitOpen | 0:f62ffd3644bf | 461 | // Linker defined symbol used by _sbrk to indicate where heap should start. |
MikamiUitOpen | 0:f62ffd3644bf | 462 | extern "C" int __end__; |
MikamiUitOpen | 0:f62ffd3644bf | 463 | |
MikamiUitOpen | 0:f62ffd3644bf | 464 | #if defined(TARGET_CORTEX_A) |
MikamiUitOpen | 0:f62ffd3644bf | 465 | extern "C" uint32_t __HeapLimit; |
MikamiUitOpen | 0:f62ffd3644bf | 466 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 467 | |
MikamiUitOpen | 0:f62ffd3644bf | 468 | // Turn off the errno macro and use actual global variable instead. |
MikamiUitOpen | 0:f62ffd3644bf | 469 | #undef errno |
MikamiUitOpen | 0:f62ffd3644bf | 470 | extern "C" int errno; |
MikamiUitOpen | 0:f62ffd3644bf | 471 | |
MikamiUitOpen | 0:f62ffd3644bf | 472 | // For ARM7 only |
MikamiUitOpen | 0:f62ffd3644bf | 473 | register unsigned char * stack_ptr __asm ("sp"); |
MikamiUitOpen | 0:f62ffd3644bf | 474 | |
MikamiUitOpen | 0:f62ffd3644bf | 475 | // Dynamic memory allocation related syscall. |
MikamiUitOpen | 0:f62ffd3644bf | 476 | extern "C" caddr_t _sbrk(int incr) { |
MikamiUitOpen | 0:f62ffd3644bf | 477 | static unsigned char* heap = (unsigned char*)&__end__; |
MikamiUitOpen | 0:f62ffd3644bf | 478 | unsigned char* prev_heap = heap; |
MikamiUitOpen | 0:f62ffd3644bf | 479 | unsigned char* new_heap = heap + incr; |
MikamiUitOpen | 0:f62ffd3644bf | 480 | |
MikamiUitOpen | 0:f62ffd3644bf | 481 | #if defined(TARGET_ARM7) |
MikamiUitOpen | 0:f62ffd3644bf | 482 | if (new_heap >= stack_ptr) { |
MikamiUitOpen | 0:f62ffd3644bf | 483 | #elif defined(TARGET_CORTEX_A) |
MikamiUitOpen | 0:f62ffd3644bf | 484 | if (new_heap >= (unsigned char*)&__HeapLimit) { /* __HeapLimit is end of heap section */ |
MikamiUitOpen | 0:f62ffd3644bf | 485 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 486 | if (new_heap >= (unsigned char*)__get_MSP()) { |
MikamiUitOpen | 0:f62ffd3644bf | 487 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 488 | errno = ENOMEM; |
MikamiUitOpen | 0:f62ffd3644bf | 489 | return (caddr_t)-1; |
MikamiUitOpen | 0:f62ffd3644bf | 490 | } |
MikamiUitOpen | 0:f62ffd3644bf | 491 | |
MikamiUitOpen | 0:f62ffd3644bf | 492 | heap = new_heap; |
MikamiUitOpen | 0:f62ffd3644bf | 493 | return (caddr_t) prev_heap; |
MikamiUitOpen | 0:f62ffd3644bf | 494 | } |
MikamiUitOpen | 0:f62ffd3644bf | 495 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 496 | |
MikamiUitOpen | 0:f62ffd3644bf | 497 | |
MikamiUitOpen | 0:f62ffd3644bf | 498 | #if defined TOOLCHAIN_GCC_ARM |
MikamiUitOpen | 0:f62ffd3644bf | 499 | extern "C" void _exit(int return_code) { |
MikamiUitOpen | 0:f62ffd3644bf | 500 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 501 | namespace std { |
MikamiUitOpen | 0:f62ffd3644bf | 502 | extern "C" void exit(int return_code) { |
MikamiUitOpen | 0:f62ffd3644bf | 503 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 504 | |
MikamiUitOpen | 0:f62ffd3644bf | 505 | #if DEVICE_STDIO_MESSAGES |
MikamiUitOpen | 0:f62ffd3644bf | 506 | fflush(stdout); |
MikamiUitOpen | 0:f62ffd3644bf | 507 | fflush(stderr); |
MikamiUitOpen | 0:f62ffd3644bf | 508 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 509 | |
MikamiUitOpen | 0:f62ffd3644bf | 510 | #if DEVICE_SEMIHOST |
MikamiUitOpen | 0:f62ffd3644bf | 511 | if (mbed_interface_connected()) { |
MikamiUitOpen | 0:f62ffd3644bf | 512 | semihost_exit(); |
MikamiUitOpen | 0:f62ffd3644bf | 513 | } |
MikamiUitOpen | 0:f62ffd3644bf | 514 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 515 | if (return_code) { |
MikamiUitOpen | 0:f62ffd3644bf | 516 | mbed_die(); |
MikamiUitOpen | 0:f62ffd3644bf | 517 | } |
MikamiUitOpen | 0:f62ffd3644bf | 518 | |
MikamiUitOpen | 0:f62ffd3644bf | 519 | while (1); |
MikamiUitOpen | 0:f62ffd3644bf | 520 | } |
MikamiUitOpen | 0:f62ffd3644bf | 521 | |
MikamiUitOpen | 0:f62ffd3644bf | 522 | #if !defined(TOOLCHAIN_GCC_ARM) |
MikamiUitOpen | 0:f62ffd3644bf | 523 | } //namespace std |
MikamiUitOpen | 0:f62ffd3644bf | 524 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 525 | |
MikamiUitOpen | 0:f62ffd3644bf | 526 | |
MikamiUitOpen | 0:f62ffd3644bf | 527 | namespace mbed { |
MikamiUitOpen | 0:f62ffd3644bf | 528 | |
MikamiUitOpen | 0:f62ffd3644bf | 529 | void mbed_set_unbuffered_stream(FILE *_file) { |
MikamiUitOpen | 0:f62ffd3644bf | 530 | #if defined (__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 531 | char buf[2]; |
MikamiUitOpen | 0:f62ffd3644bf | 532 | std::setvbuf(_file,buf,_IONBF,NULL); |
MikamiUitOpen | 0:f62ffd3644bf | 533 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 534 | setbuf(_file, NULL); |
MikamiUitOpen | 0:f62ffd3644bf | 535 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 536 | } |
MikamiUitOpen | 0:f62ffd3644bf | 537 | |
MikamiUitOpen | 0:f62ffd3644bf | 538 | int mbed_getc(FILE *_file){ |
MikamiUitOpen | 0:f62ffd3644bf | 539 | #if defined (__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 540 | /*This is only valid for unbuffered streams*/ |
MikamiUitOpen | 0:f62ffd3644bf | 541 | int res = std::fgetc(_file); |
MikamiUitOpen | 0:f62ffd3644bf | 542 | if (res>=0){ |
MikamiUitOpen | 0:f62ffd3644bf | 543 | _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */ |
MikamiUitOpen | 0:f62ffd3644bf | 544 | _file->_Rend = _file->_Wend; |
MikamiUitOpen | 0:f62ffd3644bf | 545 | _file->_Next = _file->_Wend; |
MikamiUitOpen | 0:f62ffd3644bf | 546 | } |
MikamiUitOpen | 0:f62ffd3644bf | 547 | return res; |
MikamiUitOpen | 0:f62ffd3644bf | 548 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 549 | return std::fgetc(_file); |
MikamiUitOpen | 0:f62ffd3644bf | 550 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 551 | } |
MikamiUitOpen | 0:f62ffd3644bf | 552 | |
MikamiUitOpen | 0:f62ffd3644bf | 553 | char* mbed_gets(char*s, int size, FILE *_file){ |
MikamiUitOpen | 0:f62ffd3644bf | 554 | #if defined (__ICCARM__) |
MikamiUitOpen | 0:f62ffd3644bf | 555 | /*This is only valid for unbuffered streams*/ |
MikamiUitOpen | 0:f62ffd3644bf | 556 | char *str = fgets(s,size,_file); |
MikamiUitOpen | 0:f62ffd3644bf | 557 | if (str!=NULL){ |
MikamiUitOpen | 0:f62ffd3644bf | 558 | _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */ |
MikamiUitOpen | 0:f62ffd3644bf | 559 | _file->_Rend = _file->_Wend; |
MikamiUitOpen | 0:f62ffd3644bf | 560 | _file->_Next = _file->_Wend; |
MikamiUitOpen | 0:f62ffd3644bf | 561 | } |
MikamiUitOpen | 0:f62ffd3644bf | 562 | return str; |
MikamiUitOpen | 0:f62ffd3644bf | 563 | #else |
MikamiUitOpen | 0:f62ffd3644bf | 564 | return std::fgets(s,size,_file); |
MikamiUitOpen | 0:f62ffd3644bf | 565 | #endif |
MikamiUitOpen | 0:f62ffd3644bf | 566 | } |
MikamiUitOpen | 0:f62ffd3644bf | 567 | |
MikamiUitOpen | 0:f62ffd3644bf | 568 | } // namespace mbed |