Rahul Dahiya / Mbed OS STM32F7 Ethernet

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

mbed-os/platform/mbed_retarget.cpp@0:fb8047b156bb, 2020-01-15 (annotated)

Committer:
rahul_dahiya
Date:
Wed Jan 15 15:57:15 2020 +0530
Revision:
0:fb8047b156bb
STM32F7 LWIP

Who changed what in which revision?

UserRevisionLine numberNew contents of line
rahul_dahiya 0:fb8047b156bb 1 /* mbed Microcontroller Library
rahul_dahiya 0:fb8047b156bb 2 * Copyright (c) 2006-2015 ARM Limited
rahul_dahiya 0:fb8047b156bb 3 *
rahul_dahiya 0:fb8047b156bb 4 * Licensed under the Apache License, Version 2.0 (the "License");
rahul_dahiya 0:fb8047b156bb 5 * you may not use this file except in compliance with the License.
rahul_dahiya 0:fb8047b156bb 6 * You may obtain a copy of the License at
rahul_dahiya 0:fb8047b156bb 7 *
rahul_dahiya 0:fb8047b156bb 8 * http://www.apache.org/licenses/LICENSE-2.0
rahul_dahiya 0:fb8047b156bb 9 *
rahul_dahiya 0:fb8047b156bb 10 * Unless required by applicable law or agreed to in writing, software
rahul_dahiya 0:fb8047b156bb 11 * distributed under the License is distributed on an "AS IS" BASIS,
rahul_dahiya 0:fb8047b156bb 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
rahul_dahiya 0:fb8047b156bb 13 * See the License for the specific language governing permissions and
rahul_dahiya 0:fb8047b156bb 14 * limitations under the License.
rahul_dahiya 0:fb8047b156bb 15 */
rahul_dahiya 0:fb8047b156bb 16 #include <time.h>
rahul_dahiya 0:fb8047b156bb 17 #include "platform/platform.h"
rahul_dahiya 0:fb8047b156bb 18 #include "platform/FilePath.h"
rahul_dahiya 0:fb8047b156bb 19 #include "hal/serial_api.h"
rahul_dahiya 0:fb8047b156bb 20 #include "hal/us_ticker_api.h"
rahul_dahiya 0:fb8047b156bb 21 #include "platform/mbed_toolchain.h"
rahul_dahiya 0:fb8047b156bb 22 #include "platform/mbed_semihost_api.h"
rahul_dahiya 0:fb8047b156bb 23 #include "platform/mbed_interface.h"
rahul_dahiya 0:fb8047b156bb 24 #include "platform/SingletonPtr.h"
rahul_dahiya 0:fb8047b156bb 25 #include "platform/PlatformMutex.h"
rahul_dahiya 0:fb8047b156bb 26 #include "platform/mbed_error.h"
rahul_dahiya 0:fb8047b156bb 27 #include "platform/mbed_stats.h"
rahul_dahiya 0:fb8047b156bb 28 #include "platform/mbed_critical.h"
rahul_dahiya 0:fb8047b156bb 29 #include "platform/PlatformMutex.h"
rahul_dahiya 0:fb8047b156bb 30 #include "us_ticker_api.h"
rahul_dahiya 0:fb8047b156bb 31 #include "lp_ticker_api.h"
rahul_dahiya 0:fb8047b156bb 32 #include <stdlib.h>
rahul_dahiya 0:fb8047b156bb 33 #include <string.h>
rahul_dahiya 0:fb8047b156bb 34 #include <limits.h>
rahul_dahiya 0:fb8047b156bb 35 #if DEVICE_STDIO_MESSAGES
rahul_dahiya 0:fb8047b156bb 36 #include <stdio.h>
rahul_dahiya 0:fb8047b156bb 37 #endif
rahul_dahiya 0:fb8047b156bb 38 #include <errno.h>
rahul_dahiya 0:fb8047b156bb 39 #include "platform/mbed_retarget.h"
rahul_dahiya 0:fb8047b156bb 40
rahul_dahiya 0:fb8047b156bb 41 static SingletonPtr<PlatformMutex> _mutex;
rahul_dahiya 0:fb8047b156bb 42
rahul_dahiya 0:fb8047b156bb 43 #if defined(__ARMCC_VERSION)
rahul_dahiya 0:fb8047b156bb 44 # if __ARMCC_VERSION >= 6010050
rahul_dahiya 0:fb8047b156bb 45 # include <arm_compat.h>
rahul_dahiya 0:fb8047b156bb 46 # endif
rahul_dahiya 0:fb8047b156bb 47 # include <rt_sys.h>
rahul_dahiya 0:fb8047b156bb 48 # include <rt_misc.h>
rahul_dahiya 0:fb8047b156bb 49 # include <stdint.h>
rahul_dahiya 0:fb8047b156bb 50 # define PREFIX(x) _sys##x
rahul_dahiya 0:fb8047b156bb 51 # define OPEN_MAX _SYS_OPEN
rahul_dahiya 0:fb8047b156bb 52 # ifdef __MICROLIB
rahul_dahiya 0:fb8047b156bb 53 # pragma import(__use_full_stdio)
rahul_dahiya 0:fb8047b156bb 54 # endif
rahul_dahiya 0:fb8047b156bb 55
rahul_dahiya 0:fb8047b156bb 56 #elif defined(__ICCARM__)
rahul_dahiya 0:fb8047b156bb 57 # include <yfuns.h>
rahul_dahiya 0:fb8047b156bb 58 # define PREFIX(x) _##x
rahul_dahiya 0:fb8047b156bb 59 # define OPEN_MAX 16
rahul_dahiya 0:fb8047b156bb 60
rahul_dahiya 0:fb8047b156bb 61 # define STDIN_FILENO 0
rahul_dahiya 0:fb8047b156bb 62 # define STDOUT_FILENO 1
rahul_dahiya 0:fb8047b156bb 63 # define STDERR_FILENO 2
rahul_dahiya 0:fb8047b156bb 64
rahul_dahiya 0:fb8047b156bb 65 #else
rahul_dahiya 0:fb8047b156bb 66 # include <sys/syslimits.h>
rahul_dahiya 0:fb8047b156bb 67 # define PREFIX(x) x
rahul_dahiya 0:fb8047b156bb 68 #endif
rahul_dahiya 0:fb8047b156bb 69
rahul_dahiya 0:fb8047b156bb 70 #define FILE_HANDLE_RESERVED 0xFFFFFFFF
rahul_dahiya 0:fb8047b156bb 71
rahul_dahiya 0:fb8047b156bb 72 using namespace mbed;
rahul_dahiya 0:fb8047b156bb 73
rahul_dahiya 0:fb8047b156bb 74 #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000)
rahul_dahiya 0:fb8047b156bb 75 // Before version 5.03, we were using a patched version of microlib with proper names
rahul_dahiya 0:fb8047b156bb 76 extern const char __stdin_name[] = ":tt";
rahul_dahiya 0:fb8047b156bb 77 extern const char __stdout_name[] = ":tt";
rahul_dahiya 0:fb8047b156bb 78 extern const char __stderr_name[] = ":tt";
rahul_dahiya 0:fb8047b156bb 79
rahul_dahiya 0:fb8047b156bb 80 #else
rahul_dahiya 0:fb8047b156bb 81 extern const char __stdin_name[] = "/stdin";
rahul_dahiya 0:fb8047b156bb 82 extern const char __stdout_name[] = "/stdout";
rahul_dahiya 0:fb8047b156bb 83 extern const char __stderr_name[] = "/stderr";
rahul_dahiya 0:fb8047b156bb 84 #endif
rahul_dahiya 0:fb8047b156bb 85
rahul_dahiya 0:fb8047b156bb 86 unsigned char *mbed_heap_start = 0;
rahul_dahiya 0:fb8047b156bb 87 uint32_t mbed_heap_size = 0;
rahul_dahiya 0:fb8047b156bb 88
rahul_dahiya 0:fb8047b156bb 89 /* newlib has the filehandle field in the FILE struct as a short, so
rahul_dahiya 0:fb8047b156bb 90 * we can't just return a Filehandle* from _open and instead have to
rahul_dahiya 0:fb8047b156bb 91 * put it in a filehandles array and return the index into that array
rahul_dahiya 0:fb8047b156bb 92 * (or rather index+3, as filehandles 0-2 are stdin/out/err).
rahul_dahiya 0:fb8047b156bb 93 */
rahul_dahiya 0:fb8047b156bb 94 static FileHandle *filehandles[OPEN_MAX];
rahul_dahiya 0:fb8047b156bb 95 static SingletonPtr<PlatformMutex> filehandle_mutex;
rahul_dahiya 0:fb8047b156bb 96
rahul_dahiya 0:fb8047b156bb 97 namespace mbed {
rahul_dahiya 0:fb8047b156bb 98 void remove_filehandle(FileHandle *file) {
rahul_dahiya 0:fb8047b156bb 99 filehandle_mutex->lock();
rahul_dahiya 0:fb8047b156bb 100 /* Remove all open filehandles for this */
rahul_dahiya 0:fb8047b156bb 101 for (unsigned int fh_i = 0; fh_i < sizeof(filehandles)/sizeof(*filehandles); fh_i++) {
rahul_dahiya 0:fb8047b156bb 102 if (filehandles[fh_i] == file) {
rahul_dahiya 0:fb8047b156bb 103 filehandles[fh_i] = NULL;
rahul_dahiya 0:fb8047b156bb 104 }
rahul_dahiya 0:fb8047b156bb 105 }
rahul_dahiya 0:fb8047b156bb 106 filehandle_mutex->unlock();
rahul_dahiya 0:fb8047b156bb 107 }
rahul_dahiya 0:fb8047b156bb 108 }
rahul_dahiya 0:fb8047b156bb 109
rahul_dahiya 0:fb8047b156bb 110 #if DEVICE_SERIAL
rahul_dahiya 0:fb8047b156bb 111 extern int stdio_uart_inited;
rahul_dahiya 0:fb8047b156bb 112 extern serial_t stdio_uart;
rahul_dahiya 0:fb8047b156bb 113 #if MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
rahul_dahiya 0:fb8047b156bb 114 static char stdio_in_prev;
rahul_dahiya 0:fb8047b156bb 115 static char stdio_out_prev;
rahul_dahiya 0:fb8047b156bb 116 #endif
rahul_dahiya 0:fb8047b156bb 117 #endif
rahul_dahiya 0:fb8047b156bb 118
rahul_dahiya 0:fb8047b156bb 119 static void init_serial() {
rahul_dahiya 0:fb8047b156bb 120 #if DEVICE_SERIAL
rahul_dahiya 0:fb8047b156bb 121 if (stdio_uart_inited) return;
rahul_dahiya 0:fb8047b156bb 122 serial_init(&stdio_uart, STDIO_UART_TX, STDIO_UART_RX);
rahul_dahiya 0:fb8047b156bb 123 #if MBED_CONF_PLATFORM_STDIO_BAUD_RATE
rahul_dahiya 0:fb8047b156bb 124 serial_baud(&stdio_uart, MBED_CONF_PLATFORM_STDIO_BAUD_RATE);
rahul_dahiya 0:fb8047b156bb 125 #endif
rahul_dahiya 0:fb8047b156bb 126 #endif
rahul_dahiya 0:fb8047b156bb 127 }
rahul_dahiya 0:fb8047b156bb 128
rahul_dahiya 0:fb8047b156bb 129 /**
rahul_dahiya 0:fb8047b156bb 130 * Sets errno when file opening fails.
rahul_dahiya 0:fb8047b156bb 131 * Wipes out the filehandle too.
rahul_dahiya 0:fb8047b156bb 132 *
rahul_dahiya 0:fb8047b156bb 133 * @param error is a negative error code returned from an mbed function and
rahul_dahiya 0:fb8047b156bb 134 * will be negated to store a positive error code in errno
rahul_dahiya 0:fb8047b156bb 135 */
rahul_dahiya 0:fb8047b156bb 136 static int handle_open_errors(int error, unsigned filehandle_idx) {
rahul_dahiya 0:fb8047b156bb 137 errno = -error;
rahul_dahiya 0:fb8047b156bb 138 // Free file handle
rahul_dahiya 0:fb8047b156bb 139 filehandles[filehandle_idx] = NULL;
rahul_dahiya 0:fb8047b156bb 140 return -1;
rahul_dahiya 0:fb8047b156bb 141 }
rahul_dahiya 0:fb8047b156bb 142
rahul_dahiya 0:fb8047b156bb 143 static inline int openmode_to_posix(int openmode) {
rahul_dahiya 0:fb8047b156bb 144 int posix = openmode;
rahul_dahiya 0:fb8047b156bb 145 #ifdef __ARMCC_VERSION
rahul_dahiya 0:fb8047b156bb 146 if (openmode & OPEN_PLUS) {
rahul_dahiya 0:fb8047b156bb 147 posix = O_RDWR;
rahul_dahiya 0:fb8047b156bb 148 } else if(openmode & OPEN_W) {
rahul_dahiya 0:fb8047b156bb 149 posix = O_WRONLY;
rahul_dahiya 0:fb8047b156bb 150 } else if(openmode & OPEN_A) {
rahul_dahiya 0:fb8047b156bb 151 posix = O_WRONLY|O_APPEND;
rahul_dahiya 0:fb8047b156bb 152 } else {
rahul_dahiya 0:fb8047b156bb 153 posix = O_RDONLY;
rahul_dahiya 0:fb8047b156bb 154 }
rahul_dahiya 0:fb8047b156bb 155 /* a, w, a+, w+ all create if file does not already exist */
rahul_dahiya 0:fb8047b156bb 156 if (openmode & (OPEN_A|OPEN_W)) {
rahul_dahiya 0:fb8047b156bb 157 posix |= O_CREAT;
rahul_dahiya 0:fb8047b156bb 158 }
rahul_dahiya 0:fb8047b156bb 159 /* w and w+ truncate */
rahul_dahiya 0:fb8047b156bb 160 if (openmode & OPEN_W) {
rahul_dahiya 0:fb8047b156bb 161 posix |= O_TRUNC;
rahul_dahiya 0:fb8047b156bb 162 }
rahul_dahiya 0:fb8047b156bb 163 #elif defined(__ICCARM__)
rahul_dahiya 0:fb8047b156bb 164 switch (openmode & _LLIO_RDWRMASK) {
rahul_dahiya 0:fb8047b156bb 165 case _LLIO_RDONLY: posix = O_RDONLY; break;
rahul_dahiya 0:fb8047b156bb 166 case _LLIO_WRONLY: posix = O_WRONLY; break;
rahul_dahiya 0:fb8047b156bb 167 case _LLIO_RDWR : posix = O_RDWR ; break;
rahul_dahiya 0:fb8047b156bb 168 }
rahul_dahiya 0:fb8047b156bb 169 if (openmode & _LLIO_CREAT ) posix |= O_CREAT;
rahul_dahiya 0:fb8047b156bb 170 if (openmode & _LLIO_APPEND) posix |= O_APPEND;
rahul_dahiya 0:fb8047b156bb 171 if (openmode & _LLIO_TRUNC ) posix |= O_TRUNC;
rahul_dahiya 0:fb8047b156bb 172 #elif defined(TOOLCHAIN_GCC)
rahul_dahiya 0:fb8047b156bb 173 posix &= ~O_BINARY;
rahul_dahiya 0:fb8047b156bb 174 #endif
rahul_dahiya 0:fb8047b156bb 175 return posix;
rahul_dahiya 0:fb8047b156bb 176 }
rahul_dahiya 0:fb8047b156bb 177
rahul_dahiya 0:fb8047b156bb 178 /* @brief standard c library fopen() retargeting function.
rahul_dahiya 0:fb8047b156bb 179 *
rahul_dahiya 0:fb8047b156bb 180 * This function is invoked by the standard c library retargeting to handle fopen()
rahul_dahiya 0:fb8047b156bb 181 *
rahul_dahiya 0:fb8047b156bb 182 * @return
rahul_dahiya 0:fb8047b156bb 183 * On success, a valid FILEHANDLE is returned.
rahul_dahiya 0:fb8047b156bb 184 * On failure, -1 is returned and errno is set to an appropriate value e.g.
rahul_dahiya 0:fb8047b156bb 185 * ENOENT file not found (default errno setting)
rahul_dahiya 0:fb8047b156bb 186 * EMFILE the maximum number of open files was exceeded.
rahul_dahiya 0:fb8047b156bb 187 *
rahul_dahiya 0:fb8047b156bb 188 * */
rahul_dahiya 0:fb8047b156bb 189 extern "C" FILEHANDLE PREFIX(_open)(const char* name, int openmode) {
rahul_dahiya 0:fb8047b156bb 190 #if defined(__MICROLIB) && (__ARMCC_VERSION>5030000)
rahul_dahiya 0:fb8047b156bb 191 #if !defined(MBED_CONF_RTOS_PRESENT)
rahul_dahiya 0:fb8047b156bb 192 // valid only for mbed 2
rahul_dahiya 0:fb8047b156bb 193 // for ulib, this is invoked after RAM init, prior c++
rahul_dahiya 0:fb8047b156bb 194 // used as hook, as post stack/heap is not active there
rahul_dahiya 0:fb8047b156bb 195 extern void mbed_copy_nvic(void);
rahul_dahiya 0:fb8047b156bb 196 extern void mbed_sdk_init(void);
rahul_dahiya 0:fb8047b156bb 197
rahul_dahiya 0:fb8047b156bb 198 static int mbed_sdk_inited = 0;
rahul_dahiya 0:fb8047b156bb 199 if (!mbed_sdk_inited) {
rahul_dahiya 0:fb8047b156bb 200 mbed_copy_nvic();
rahul_dahiya 0:fb8047b156bb 201 mbed_sdk_init();
rahul_dahiya 0:fb8047b156bb 202 mbed_sdk_inited = 1;
rahul_dahiya 0:fb8047b156bb 203 }
rahul_dahiya 0:fb8047b156bb 204 #endif
rahul_dahiya 0:fb8047b156bb 205 // Before version 5.03, we were using a patched version of microlib with proper names
rahul_dahiya 0:fb8047b156bb 206 // This is the workaround that the microlib author suggested us
rahul_dahiya 0:fb8047b156bb 207 static int n = 0;
rahul_dahiya 0:fb8047b156bb 208 if (!std::strcmp(name, ":tt")) return n++;
rahul_dahiya 0:fb8047b156bb 209 #else
rahul_dahiya 0:fb8047b156bb 210 /* Use the posix convention that stdin,out,err are filehandles 0,1,2.
rahul_dahiya 0:fb8047b156bb 211 */
rahul_dahiya 0:fb8047b156bb 212 if (std::strcmp(name, __stdin_name) == 0) {
rahul_dahiya 0:fb8047b156bb 213 init_serial();
rahul_dahiya 0:fb8047b156bb 214 return 0;
rahul_dahiya 0:fb8047b156bb 215 } else if (std::strcmp(name, __stdout_name) == 0) {
rahul_dahiya 0:fb8047b156bb 216 init_serial();
rahul_dahiya 0:fb8047b156bb 217 return 1;
rahul_dahiya 0:fb8047b156bb 218 } else if (std::strcmp(name, __stderr_name) == 0) {
rahul_dahiya 0:fb8047b156bb 219 init_serial();
rahul_dahiya 0:fb8047b156bb 220 return 2;
rahul_dahiya 0:fb8047b156bb 221 }
rahul_dahiya 0:fb8047b156bb 222 #endif
rahul_dahiya 0:fb8047b156bb 223
rahul_dahiya 0:fb8047b156bb 224 // find the first empty slot in filehandles
rahul_dahiya 0:fb8047b156bb 225 filehandle_mutex->lock();
rahul_dahiya 0:fb8047b156bb 226 unsigned int fh_i;
rahul_dahiya 0:fb8047b156bb 227 for (fh_i = 0; fh_i < sizeof(filehandles)/sizeof(*filehandles); fh_i++) {
rahul_dahiya 0:fb8047b156bb 228 /* Take a next free filehandle slot available. */
rahul_dahiya 0:fb8047b156bb 229 if (filehandles[fh_i] == NULL) break;
rahul_dahiya 0:fb8047b156bb 230 }
rahul_dahiya 0:fb8047b156bb 231 if (fh_i >= sizeof(filehandles)/sizeof(*filehandles)) {
rahul_dahiya 0:fb8047b156bb 232 /* Too many file handles have been opened */
rahul_dahiya 0:fb8047b156bb 233 errno = EMFILE;
rahul_dahiya 0:fb8047b156bb 234 filehandle_mutex->unlock();
rahul_dahiya 0:fb8047b156bb 235 return -1;
rahul_dahiya 0:fb8047b156bb 236 }
rahul_dahiya 0:fb8047b156bb 237 filehandles[fh_i] = (FileHandle*)FILE_HANDLE_RESERVED;
rahul_dahiya 0:fb8047b156bb 238 filehandle_mutex->unlock();
rahul_dahiya 0:fb8047b156bb 239
rahul_dahiya 0:fb8047b156bb 240 FileHandle *res = NULL;
rahul_dahiya 0:fb8047b156bb 241
rahul_dahiya 0:fb8047b156bb 242 /* FILENAME: ":(pointer)" describes a FileHandle* */
rahul_dahiya 0:fb8047b156bb 243 if (name[0] == ':') {
rahul_dahiya 0:fb8047b156bb 244 void *p;
rahul_dahiya 0:fb8047b156bb 245 memcpy(&p, name + 1, sizeof(p));
rahul_dahiya 0:fb8047b156bb 246 res = (FileHandle*)p;
rahul_dahiya 0:fb8047b156bb 247
rahul_dahiya 0:fb8047b156bb 248 /* FILENAME: "/file_system/file_name" */
rahul_dahiya 0:fb8047b156bb 249 } else {
rahul_dahiya 0:fb8047b156bb 250 FilePath path(name);
rahul_dahiya 0:fb8047b156bb 251
rahul_dahiya 0:fb8047b156bb 252 if (!path.exists()) {
rahul_dahiya 0:fb8047b156bb 253 /* The first part of the filename (between first 2 '/') is not a
rahul_dahiya 0:fb8047b156bb 254 * registered mount point in the namespace.
rahul_dahiya 0:fb8047b156bb 255 */
rahul_dahiya 0:fb8047b156bb 256 return handle_open_errors(-ENODEV, fh_i);
rahul_dahiya 0:fb8047b156bb 257 }
rahul_dahiya 0:fb8047b156bb 258
rahul_dahiya 0:fb8047b156bb 259 if (path.isFile()) {
rahul_dahiya 0:fb8047b156bb 260 res = path.file();
rahul_dahiya 0:fb8047b156bb 261 } else {
rahul_dahiya 0:fb8047b156bb 262 FileSystemHandle *fs = path.fileSystem();
rahul_dahiya 0:fb8047b156bb 263 if (fs == NULL) {
rahul_dahiya 0:fb8047b156bb 264 return handle_open_errors(-ENODEV, fh_i);
rahul_dahiya 0:fb8047b156bb 265 }
rahul_dahiya 0:fb8047b156bb 266 int posix_mode = openmode_to_posix(openmode);
rahul_dahiya 0:fb8047b156bb 267 int err = fs->open(&res, path.fileName(), posix_mode);
rahul_dahiya 0:fb8047b156bb 268 if (err) {
rahul_dahiya 0:fb8047b156bb 269 return handle_open_errors(err, fh_i);
rahul_dahiya 0:fb8047b156bb 270 }
rahul_dahiya 0:fb8047b156bb 271 }
rahul_dahiya 0:fb8047b156bb 272 }
rahul_dahiya 0:fb8047b156bb 273
rahul_dahiya 0:fb8047b156bb 274 filehandles[fh_i] = res;
rahul_dahiya 0:fb8047b156bb 275
rahul_dahiya 0:fb8047b156bb 276 return fh_i + 3; // +3 as filehandles 0-2 are stdin/out/err
rahul_dahiya 0:fb8047b156bb 277 }
rahul_dahiya 0:fb8047b156bb 278
rahul_dahiya 0:fb8047b156bb 279 extern "C" int PREFIX(_close)(FILEHANDLE fh) {
rahul_dahiya 0:fb8047b156bb 280 if (fh < 3) return 0;
rahul_dahiya 0:fb8047b156bb 281
rahul_dahiya 0:fb8047b156bb 282 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 283 filehandles[fh-3] = NULL;
rahul_dahiya 0:fb8047b156bb 284 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 285 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 286 return -1;
rahul_dahiya 0:fb8047b156bb 287 }
rahul_dahiya 0:fb8047b156bb 288
rahul_dahiya 0:fb8047b156bb 289 int err = fhc->close();
rahul_dahiya 0:fb8047b156bb 290 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 291 errno = -err;
rahul_dahiya 0:fb8047b156bb 292 return -1;
rahul_dahiya 0:fb8047b156bb 293 } else {
rahul_dahiya 0:fb8047b156bb 294 return 0;
rahul_dahiya 0:fb8047b156bb 295 }
rahul_dahiya 0:fb8047b156bb 296 }
rahul_dahiya 0:fb8047b156bb 297
rahul_dahiya 0:fb8047b156bb 298 #if defined(__ICCARM__)
rahul_dahiya 0:fb8047b156bb 299 extern "C" size_t __write (int fh, const unsigned char *buffer, size_t length) {
rahul_dahiya 0:fb8047b156bb 300 #else
rahul_dahiya 0:fb8047b156bb 301 extern "C" int PREFIX(_write)(FILEHANDLE fh, const unsigned char *buffer, unsigned int length, int mode) {
rahul_dahiya 0:fb8047b156bb 302 #endif
rahul_dahiya 0:fb8047b156bb 303 int n; // n is the number of bytes written
rahul_dahiya 0:fb8047b156bb 304
rahul_dahiya 0:fb8047b156bb 305 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
rahul_dahiya 0:fb8047b156bb 306 if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
rahul_dahiya 0:fb8047b156bb 307 error("Error - writing to a file in an ISR or critical section\r\n");
rahul_dahiya 0:fb8047b156bb 308 }
rahul_dahiya 0:fb8047b156bb 309 #endif
rahul_dahiya 0:fb8047b156bb 310
rahul_dahiya 0:fb8047b156bb 311 if (fh < 3) {
rahul_dahiya 0:fb8047b156bb 312 #if DEVICE_SERIAL
rahul_dahiya 0:fb8047b156bb 313 if (!stdio_uart_inited) init_serial();
rahul_dahiya 0:fb8047b156bb 314 #if MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
rahul_dahiya 0:fb8047b156bb 315 for (unsigned int i = 0; i < length; i++) {
rahul_dahiya 0:fb8047b156bb 316 if (buffer[i] == '\n' && stdio_out_prev != '\r') {
rahul_dahiya 0:fb8047b156bb 317 serial_putc(&stdio_uart, '\r');
rahul_dahiya 0:fb8047b156bb 318 }
rahul_dahiya 0:fb8047b156bb 319 serial_putc(&stdio_uart, buffer[i]);
rahul_dahiya 0:fb8047b156bb 320 stdio_out_prev = buffer[i];
rahul_dahiya 0:fb8047b156bb 321 }
rahul_dahiya 0:fb8047b156bb 322 #else
rahul_dahiya 0:fb8047b156bb 323 for (unsigned int i = 0; i < length; i++) {
rahul_dahiya 0:fb8047b156bb 324 serial_putc(&stdio_uart, buffer[i]);
rahul_dahiya 0:fb8047b156bb 325 }
rahul_dahiya 0:fb8047b156bb 326 #endif
rahul_dahiya 0:fb8047b156bb 327 #endif
rahul_dahiya 0:fb8047b156bb 328 n = length;
rahul_dahiya 0:fb8047b156bb 329 } else {
rahul_dahiya 0:fb8047b156bb 330 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 331 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 332 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 333 return -1;
rahul_dahiya 0:fb8047b156bb 334 }
rahul_dahiya 0:fb8047b156bb 335
rahul_dahiya 0:fb8047b156bb 336 n = fhc->write(buffer, length);
rahul_dahiya 0:fb8047b156bb 337 if (n < 0) {
rahul_dahiya 0:fb8047b156bb 338 errno = -n;
rahul_dahiya 0:fb8047b156bb 339 }
rahul_dahiya 0:fb8047b156bb 340 }
rahul_dahiya 0:fb8047b156bb 341 #ifdef __ARMCC_VERSION
rahul_dahiya 0:fb8047b156bb 342 return length-n;
rahul_dahiya 0:fb8047b156bb 343 #else
rahul_dahiya 0:fb8047b156bb 344 return n;
rahul_dahiya 0:fb8047b156bb 345 #endif
rahul_dahiya 0:fb8047b156bb 346 }
rahul_dahiya 0:fb8047b156bb 347
rahul_dahiya 0:fb8047b156bb 348 #if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
rahul_dahiya 0:fb8047b156bb 349 extern "C" void PREFIX(_exit)(int return_code) {
rahul_dahiya 0:fb8047b156bb 350 while(1) {}
rahul_dahiya 0:fb8047b156bb 351 }
rahul_dahiya 0:fb8047b156bb 352
rahul_dahiya 0:fb8047b156bb 353 extern "C" void _ttywrch(int ch) {
rahul_dahiya 0:fb8047b156bb 354 serial_putc(&stdio_uart, ch);
rahul_dahiya 0:fb8047b156bb 355 }
rahul_dahiya 0:fb8047b156bb 356 #endif
rahul_dahiya 0:fb8047b156bb 357
rahul_dahiya 0:fb8047b156bb 358 #if defined(__ICCARM__)
rahul_dahiya 0:fb8047b156bb 359 extern "C" size_t __read (int fh, unsigned char *buffer, size_t length) {
rahul_dahiya 0:fb8047b156bb 360 #else
rahul_dahiya 0:fb8047b156bb 361 extern "C" int PREFIX(_read)(FILEHANDLE fh, unsigned char *buffer, unsigned int length, int mode) {
rahul_dahiya 0:fb8047b156bb 362 #endif
rahul_dahiya 0:fb8047b156bb 363 int n; // n is the number of bytes read
rahul_dahiya 0:fb8047b156bb 364
rahul_dahiya 0:fb8047b156bb 365 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
rahul_dahiya 0:fb8047b156bb 366 if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
rahul_dahiya 0:fb8047b156bb 367 error("Error - reading from a file in an ISR or critical section\r\n");
rahul_dahiya 0:fb8047b156bb 368 }
rahul_dahiya 0:fb8047b156bb 369 #endif
rahul_dahiya 0:fb8047b156bb 370
rahul_dahiya 0:fb8047b156bb 371 if (fh < 3) {
rahul_dahiya 0:fb8047b156bb 372 // only read a character at a time from stdin
rahul_dahiya 0:fb8047b156bb 373 #if DEVICE_SERIAL
rahul_dahiya 0:fb8047b156bb 374 if (!stdio_uart_inited) init_serial();
rahul_dahiya 0:fb8047b156bb 375 #if MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES
rahul_dahiya 0:fb8047b156bb 376 while (true) {
rahul_dahiya 0:fb8047b156bb 377 char c = serial_getc(&stdio_uart);
rahul_dahiya 0:fb8047b156bb 378 if ((c == '\r' && stdio_in_prev != '\n') ||
rahul_dahiya 0:fb8047b156bb 379 (c == '\n' && stdio_in_prev != '\r')) {
rahul_dahiya 0:fb8047b156bb 380 stdio_in_prev = c;
rahul_dahiya 0:fb8047b156bb 381 *buffer = '\n';
rahul_dahiya 0:fb8047b156bb 382 break;
rahul_dahiya 0:fb8047b156bb 383 } else if ((c == '\r' && stdio_in_prev == '\n') ||
rahul_dahiya 0:fb8047b156bb 384 (c == '\n' && stdio_in_prev == '\r')) {
rahul_dahiya 0:fb8047b156bb 385 stdio_in_prev = c;
rahul_dahiya 0:fb8047b156bb 386 // onto next character
rahul_dahiya 0:fb8047b156bb 387 continue;
rahul_dahiya 0:fb8047b156bb 388 } else {
rahul_dahiya 0:fb8047b156bb 389 stdio_in_prev = c;
rahul_dahiya 0:fb8047b156bb 390 *buffer = c;
rahul_dahiya 0:fb8047b156bb 391 break;
rahul_dahiya 0:fb8047b156bb 392 }
rahul_dahiya 0:fb8047b156bb 393 }
rahul_dahiya 0:fb8047b156bb 394 #else
rahul_dahiya 0:fb8047b156bb 395 *buffer = serial_getc(&stdio_uart);
rahul_dahiya 0:fb8047b156bb 396 #endif
rahul_dahiya 0:fb8047b156bb 397 #endif
rahul_dahiya 0:fb8047b156bb 398 n = 1;
rahul_dahiya 0:fb8047b156bb 399 } else {
rahul_dahiya 0:fb8047b156bb 400 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 401 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 402 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 403 return -1;
rahul_dahiya 0:fb8047b156bb 404 }
rahul_dahiya 0:fb8047b156bb 405
rahul_dahiya 0:fb8047b156bb 406 n = fhc->read(buffer, length);
rahul_dahiya 0:fb8047b156bb 407 if (n < 0) {
rahul_dahiya 0:fb8047b156bb 408 errno = -n;
rahul_dahiya 0:fb8047b156bb 409 }
rahul_dahiya 0:fb8047b156bb 410 }
rahul_dahiya 0:fb8047b156bb 411 #ifdef __ARMCC_VERSION
rahul_dahiya 0:fb8047b156bb 412 return length-n;
rahul_dahiya 0:fb8047b156bb 413 #else
rahul_dahiya 0:fb8047b156bb 414 return n;
rahul_dahiya 0:fb8047b156bb 415 #endif
rahul_dahiya 0:fb8047b156bb 416 }
rahul_dahiya 0:fb8047b156bb 417
rahul_dahiya 0:fb8047b156bb 418
rahul_dahiya 0:fb8047b156bb 419 #ifdef __ARMCC_VERSION
rahul_dahiya 0:fb8047b156bb 420 extern "C" int PREFIX(_istty)(FILEHANDLE fh)
rahul_dahiya 0:fb8047b156bb 421 #else
rahul_dahiya 0:fb8047b156bb 422 extern "C" int _isatty(FILEHANDLE fh)
rahul_dahiya 0:fb8047b156bb 423 #endif
rahul_dahiya 0:fb8047b156bb 424 {
rahul_dahiya 0:fb8047b156bb 425 /* stdin, stdout and stderr should be tty */
rahul_dahiya 0:fb8047b156bb 426 if (fh < 3) return 1;
rahul_dahiya 0:fb8047b156bb 427
rahul_dahiya 0:fb8047b156bb 428 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 429 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 430 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 431 return 0;
rahul_dahiya 0:fb8047b156bb 432 }
rahul_dahiya 0:fb8047b156bb 433
rahul_dahiya 0:fb8047b156bb 434 int tty = fhc->isatty();
rahul_dahiya 0:fb8047b156bb 435 if (tty < 0) {
rahul_dahiya 0:fb8047b156bb 436 errno = -tty;
rahul_dahiya 0:fb8047b156bb 437 return 0;
rahul_dahiya 0:fb8047b156bb 438 } else {
rahul_dahiya 0:fb8047b156bb 439 return tty;
rahul_dahiya 0:fb8047b156bb 440 }
rahul_dahiya 0:fb8047b156bb 441 }
rahul_dahiya 0:fb8047b156bb 442
rahul_dahiya 0:fb8047b156bb 443 extern "C"
rahul_dahiya 0:fb8047b156bb 444 #if defined(__ARMCC_VERSION)
rahul_dahiya 0:fb8047b156bb 445 int _sys_seek(FILEHANDLE fh, long offset)
rahul_dahiya 0:fb8047b156bb 446 #elif defined(__ICCARM__)
rahul_dahiya 0:fb8047b156bb 447 long __lseek(int fh, long offset, int whence)
rahul_dahiya 0:fb8047b156bb 448 #else
rahul_dahiya 0:fb8047b156bb 449 int _lseek(FILEHANDLE fh, int offset, int whence)
rahul_dahiya 0:fb8047b156bb 450 #endif
rahul_dahiya 0:fb8047b156bb 451 {
rahul_dahiya 0:fb8047b156bb 452 #if defined(__ARMCC_VERSION)
rahul_dahiya 0:fb8047b156bb 453 int whence = SEEK_SET;
rahul_dahiya 0:fb8047b156bb 454 #endif
rahul_dahiya 0:fb8047b156bb 455
rahul_dahiya 0:fb8047b156bb 456 if (fh < 3) {
rahul_dahiya 0:fb8047b156bb 457 errno = ESPIPE;
rahul_dahiya 0:fb8047b156bb 458 return -1;
rahul_dahiya 0:fb8047b156bb 459 }
rahul_dahiya 0:fb8047b156bb 460
rahul_dahiya 0:fb8047b156bb 461 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 462 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 463 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 464 return -1;
rahul_dahiya 0:fb8047b156bb 465 }
rahul_dahiya 0:fb8047b156bb 466
rahul_dahiya 0:fb8047b156bb 467 off_t off = fhc->seek(offset, whence);
rahul_dahiya 0:fb8047b156bb 468 if (off < 0) {
rahul_dahiya 0:fb8047b156bb 469 errno = -off;
rahul_dahiya 0:fb8047b156bb 470 return -1;
rahul_dahiya 0:fb8047b156bb 471 }
rahul_dahiya 0:fb8047b156bb 472 // Assuming INT_MAX = LONG_MAX, so we don't care about prototype difference
rahul_dahiya 0:fb8047b156bb 473 if (off > INT_MAX) {
rahul_dahiya 0:fb8047b156bb 474 errno = EOVERFLOW;
rahul_dahiya 0:fb8047b156bb 475 return -1;
rahul_dahiya 0:fb8047b156bb 476 }
rahul_dahiya 0:fb8047b156bb 477 return off;
rahul_dahiya 0:fb8047b156bb 478 }
rahul_dahiya 0:fb8047b156bb 479
rahul_dahiya 0:fb8047b156bb 480 #ifdef __ARMCC_VERSION
rahul_dahiya 0:fb8047b156bb 481 extern "C" int PREFIX(_ensure)(FILEHANDLE fh) {
rahul_dahiya 0:fb8047b156bb 482 if (fh < 3) return 0;
rahul_dahiya 0:fb8047b156bb 483
rahul_dahiya 0:fb8047b156bb 484 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 485 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 486 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 487 return -1;
rahul_dahiya 0:fb8047b156bb 488 }
rahul_dahiya 0:fb8047b156bb 489
rahul_dahiya 0:fb8047b156bb 490 int err = fhc->sync();
rahul_dahiya 0:fb8047b156bb 491 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 492 errno = -err;
rahul_dahiya 0:fb8047b156bb 493 return -1;
rahul_dahiya 0:fb8047b156bb 494 } else {
rahul_dahiya 0:fb8047b156bb 495 return 0;
rahul_dahiya 0:fb8047b156bb 496 }
rahul_dahiya 0:fb8047b156bb 497 }
rahul_dahiya 0:fb8047b156bb 498
rahul_dahiya 0:fb8047b156bb 499 extern "C" long PREFIX(_flen)(FILEHANDLE fh) {
rahul_dahiya 0:fb8047b156bb 500 if (fh < 3) {
rahul_dahiya 0:fb8047b156bb 501 errno = EINVAL;
rahul_dahiya 0:fb8047b156bb 502 return -1;
rahul_dahiya 0:fb8047b156bb 503 }
rahul_dahiya 0:fb8047b156bb 504
rahul_dahiya 0:fb8047b156bb 505 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 506 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 507 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 508 return -1;
rahul_dahiya 0:fb8047b156bb 509 }
rahul_dahiya 0:fb8047b156bb 510
rahul_dahiya 0:fb8047b156bb 511 off_t size = fhc->size();
rahul_dahiya 0:fb8047b156bb 512 if (size < 0) {
rahul_dahiya 0:fb8047b156bb 513 errno = -size;
rahul_dahiya 0:fb8047b156bb 514 return -1;
rahul_dahiya 0:fb8047b156bb 515 }
rahul_dahiya 0:fb8047b156bb 516 if (size > LONG_MAX) {
rahul_dahiya 0:fb8047b156bb 517 errno = EOVERFLOW;
rahul_dahiya 0:fb8047b156bb 518 return -1;
rahul_dahiya 0:fb8047b156bb 519 }
rahul_dahiya 0:fb8047b156bb 520 return size;
rahul_dahiya 0:fb8047b156bb 521 }
rahul_dahiya 0:fb8047b156bb 522
rahul_dahiya 0:fb8047b156bb 523 extern "C" char Image$$RW_IRAM1$$ZI$$Limit[];
rahul_dahiya 0:fb8047b156bb 524
rahul_dahiya 0:fb8047b156bb 525 extern "C" MBED_WEAK __value_in_regs struct __initial_stackheap _mbed_user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3)
rahul_dahiya 0:fb8047b156bb 526 {
rahul_dahiya 0:fb8047b156bb 527 uint32_t zi_limit = (uint32_t)Image$$RW_IRAM1$$ZI$$Limit;
rahul_dahiya 0:fb8047b156bb 528 uint32_t sp_limit = __current_sp();
rahul_dahiya 0:fb8047b156bb 529
rahul_dahiya 0:fb8047b156bb 530 zi_limit = (zi_limit + 7) & ~0x7; // ensure zi_limit is 8-byte aligned
rahul_dahiya 0:fb8047b156bb 531
rahul_dahiya 0:fb8047b156bb 532 struct __initial_stackheap r;
rahul_dahiya 0:fb8047b156bb 533 r.heap_base = zi_limit;
rahul_dahiya 0:fb8047b156bb 534 r.heap_limit = sp_limit;
rahul_dahiya 0:fb8047b156bb 535 return r;
rahul_dahiya 0:fb8047b156bb 536 }
rahul_dahiya 0:fb8047b156bb 537
rahul_dahiya 0:fb8047b156bb 538 extern "C" __value_in_regs struct __initial_stackheap __user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3) {
rahul_dahiya 0:fb8047b156bb 539 return _mbed_user_setup_stackheap(R0, R1, R2, R3);
rahul_dahiya 0:fb8047b156bb 540 }
rahul_dahiya 0:fb8047b156bb 541
rahul_dahiya 0:fb8047b156bb 542 #endif
rahul_dahiya 0:fb8047b156bb 543
rahul_dahiya 0:fb8047b156bb 544
rahul_dahiya 0:fb8047b156bb 545 #if !defined(__ARMCC_VERSION) && !defined(__ICCARM__)
rahul_dahiya 0:fb8047b156bb 546 extern "C" int _fstat(int fh, struct stat *st) {
rahul_dahiya 0:fb8047b156bb 547 if (fh < 3) {
rahul_dahiya 0:fb8047b156bb 548 st->st_mode = S_IFCHR;
rahul_dahiya 0:fb8047b156bb 549 return 0;
rahul_dahiya 0:fb8047b156bb 550 }
rahul_dahiya 0:fb8047b156bb 551
rahul_dahiya 0:fb8047b156bb 552 FileHandle* fhc = filehandles[fh-3];
rahul_dahiya 0:fb8047b156bb 553 if (fhc == NULL) {
rahul_dahiya 0:fb8047b156bb 554 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 555 return -1;
rahul_dahiya 0:fb8047b156bb 556 }
rahul_dahiya 0:fb8047b156bb 557
rahul_dahiya 0:fb8047b156bb 558 st->st_mode = fhc->isatty() ? S_IFCHR : S_IFREG;
rahul_dahiya 0:fb8047b156bb 559 st->st_size = fhc->size();
rahul_dahiya 0:fb8047b156bb 560 return 0;
rahul_dahiya 0:fb8047b156bb 561 }
rahul_dahiya 0:fb8047b156bb 562 #endif
rahul_dahiya 0:fb8047b156bb 563
rahul_dahiya 0:fb8047b156bb 564 namespace std {
rahul_dahiya 0:fb8047b156bb 565 extern "C" int remove(const char *path) {
rahul_dahiya 0:fb8047b156bb 566 FilePath fp(path);
rahul_dahiya 0:fb8047b156bb 567 FileSystemHandle *fs = fp.fileSystem();
rahul_dahiya 0:fb8047b156bb 568 if (fs == NULL) {
rahul_dahiya 0:fb8047b156bb 569 errno = ENODEV;
rahul_dahiya 0:fb8047b156bb 570 return -1;
rahul_dahiya 0:fb8047b156bb 571 }
rahul_dahiya 0:fb8047b156bb 572
rahul_dahiya 0:fb8047b156bb 573 int err = fs->remove(fp.fileName());
rahul_dahiya 0:fb8047b156bb 574 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 575 errno = -err;
rahul_dahiya 0:fb8047b156bb 576 return -1;
rahul_dahiya 0:fb8047b156bb 577 } else {
rahul_dahiya 0:fb8047b156bb 578 return 0;
rahul_dahiya 0:fb8047b156bb 579 }
rahul_dahiya 0:fb8047b156bb 580 }
rahul_dahiya 0:fb8047b156bb 581
rahul_dahiya 0:fb8047b156bb 582 extern "C" int rename(const char *oldname, const char *newname) {
rahul_dahiya 0:fb8047b156bb 583 FilePath fpOld(oldname);
rahul_dahiya 0:fb8047b156bb 584 FilePath fpNew(newname);
rahul_dahiya 0:fb8047b156bb 585 FileSystemHandle *fsOld = fpOld.fileSystem();
rahul_dahiya 0:fb8047b156bb 586 FileSystemHandle *fsNew = fpNew.fileSystem();
rahul_dahiya 0:fb8047b156bb 587
rahul_dahiya 0:fb8047b156bb 588 if (fsOld == NULL) {
rahul_dahiya 0:fb8047b156bb 589 errno = ENODEV;
rahul_dahiya 0:fb8047b156bb 590 return -1;
rahul_dahiya 0:fb8047b156bb 591 }
rahul_dahiya 0:fb8047b156bb 592
rahul_dahiya 0:fb8047b156bb 593 /* rename only if both files are on the same FS */
rahul_dahiya 0:fb8047b156bb 594 if (fsOld != fsNew) {
rahul_dahiya 0:fb8047b156bb 595 errno = EXDEV;
rahul_dahiya 0:fb8047b156bb 596 return -1;
rahul_dahiya 0:fb8047b156bb 597 }
rahul_dahiya 0:fb8047b156bb 598
rahul_dahiya 0:fb8047b156bb 599 int err = fsOld->rename(fpOld.fileName(), fpNew.fileName());
rahul_dahiya 0:fb8047b156bb 600 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 601 errno = -err;
rahul_dahiya 0:fb8047b156bb 602 return -1;
rahul_dahiya 0:fb8047b156bb 603 } else {
rahul_dahiya 0:fb8047b156bb 604 return 0;
rahul_dahiya 0:fb8047b156bb 605 }
rahul_dahiya 0:fb8047b156bb 606 }
rahul_dahiya 0:fb8047b156bb 607
rahul_dahiya 0:fb8047b156bb 608 extern "C" char *tmpnam(char *s) {
rahul_dahiya 0:fb8047b156bb 609 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 610 return NULL;
rahul_dahiya 0:fb8047b156bb 611 }
rahul_dahiya 0:fb8047b156bb 612
rahul_dahiya 0:fb8047b156bb 613 extern "C" FILE *tmpfile() {
rahul_dahiya 0:fb8047b156bb 614 errno = EBADF;
rahul_dahiya 0:fb8047b156bb 615 return NULL;
rahul_dahiya 0:fb8047b156bb 616 }
rahul_dahiya 0:fb8047b156bb 617 } // namespace std
rahul_dahiya 0:fb8047b156bb 618
rahul_dahiya 0:fb8047b156bb 619 #ifdef __ARMCC_VERSION
rahul_dahiya 0:fb8047b156bb 620 extern "C" char *_sys_command_string(char *cmd, int len) {
rahul_dahiya 0:fb8047b156bb 621 return NULL;
rahul_dahiya 0:fb8047b156bb 622 }
rahul_dahiya 0:fb8047b156bb 623 #endif
rahul_dahiya 0:fb8047b156bb 624
rahul_dahiya 0:fb8047b156bb 625 extern "C" DIR *opendir(const char *path) {
rahul_dahiya 0:fb8047b156bb 626 FilePath fp(path);
rahul_dahiya 0:fb8047b156bb 627 FileSystemHandle* fs = fp.fileSystem();
rahul_dahiya 0:fb8047b156bb 628 if (fs == NULL) {
rahul_dahiya 0:fb8047b156bb 629 errno = ENODEV;
rahul_dahiya 0:fb8047b156bb 630 return NULL;
rahul_dahiya 0:fb8047b156bb 631 }
rahul_dahiya 0:fb8047b156bb 632
rahul_dahiya 0:fb8047b156bb 633 DirHandle *dir;
rahul_dahiya 0:fb8047b156bb 634 int err = fs->open(&dir, fp.fileName());
rahul_dahiya 0:fb8047b156bb 635 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 636 errno = -err;
rahul_dahiya 0:fb8047b156bb 637 return NULL;
rahul_dahiya 0:fb8047b156bb 638 }
rahul_dahiya 0:fb8047b156bb 639
rahul_dahiya 0:fb8047b156bb 640 return dir;
rahul_dahiya 0:fb8047b156bb 641 }
rahul_dahiya 0:fb8047b156bb 642
rahul_dahiya 0:fb8047b156bb 643 extern "C" struct dirent *readdir(DIR *dir) {
rahul_dahiya 0:fb8047b156bb 644 static struct dirent ent;
rahul_dahiya 0:fb8047b156bb 645 int err = dir->read(&ent);
rahul_dahiya 0:fb8047b156bb 646 if (err < 1) {
rahul_dahiya 0:fb8047b156bb 647 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 648 errno = -err;
rahul_dahiya 0:fb8047b156bb 649 }
rahul_dahiya 0:fb8047b156bb 650 return NULL;
rahul_dahiya 0:fb8047b156bb 651 }
rahul_dahiya 0:fb8047b156bb 652
rahul_dahiya 0:fb8047b156bb 653 return &ent;
rahul_dahiya 0:fb8047b156bb 654 }
rahul_dahiya 0:fb8047b156bb 655
rahul_dahiya 0:fb8047b156bb 656 extern "C" int closedir(DIR *dir) {
rahul_dahiya 0:fb8047b156bb 657 int err = dir->close();
rahul_dahiya 0:fb8047b156bb 658 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 659 errno = -err;
rahul_dahiya 0:fb8047b156bb 660 return -1;
rahul_dahiya 0:fb8047b156bb 661 } else {
rahul_dahiya 0:fb8047b156bb 662 return 0;
rahul_dahiya 0:fb8047b156bb 663 }
rahul_dahiya 0:fb8047b156bb 664 }
rahul_dahiya 0:fb8047b156bb 665
rahul_dahiya 0:fb8047b156bb 666 extern "C" void rewinddir(DIR *dir) {
rahul_dahiya 0:fb8047b156bb 667 dir->rewind();
rahul_dahiya 0:fb8047b156bb 668 }
rahul_dahiya 0:fb8047b156bb 669
rahul_dahiya 0:fb8047b156bb 670 extern "C" off_t telldir(DIR *dir) {
rahul_dahiya 0:fb8047b156bb 671 return dir->tell();
rahul_dahiya 0:fb8047b156bb 672 }
rahul_dahiya 0:fb8047b156bb 673
rahul_dahiya 0:fb8047b156bb 674 extern "C" void seekdir(DIR *dir, off_t off) {
rahul_dahiya 0:fb8047b156bb 675 dir->seek(off);
rahul_dahiya 0:fb8047b156bb 676 }
rahul_dahiya 0:fb8047b156bb 677
rahul_dahiya 0:fb8047b156bb 678 extern "C" int mkdir(const char *path, mode_t mode) {
rahul_dahiya 0:fb8047b156bb 679 FilePath fp(path);
rahul_dahiya 0:fb8047b156bb 680 FileSystemHandle *fs = fp.fileSystem();
rahul_dahiya 0:fb8047b156bb 681 if (fs == NULL) {
rahul_dahiya 0:fb8047b156bb 682 errno = ENODEV;
rahul_dahiya 0:fb8047b156bb 683 return -1;
rahul_dahiya 0:fb8047b156bb 684 }
rahul_dahiya 0:fb8047b156bb 685
rahul_dahiya 0:fb8047b156bb 686 int err = fs->mkdir(fp.fileName(), mode);
rahul_dahiya 0:fb8047b156bb 687 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 688 errno = -err;
rahul_dahiya 0:fb8047b156bb 689 return -1;
rahul_dahiya 0:fb8047b156bb 690 } else {
rahul_dahiya 0:fb8047b156bb 691 return 0;
rahul_dahiya 0:fb8047b156bb 692 }
rahul_dahiya 0:fb8047b156bb 693 }
rahul_dahiya 0:fb8047b156bb 694
rahul_dahiya 0:fb8047b156bb 695 extern "C" int stat(const char *path, struct stat *st) {
rahul_dahiya 0:fb8047b156bb 696 FilePath fp(path);
rahul_dahiya 0:fb8047b156bb 697 FileSystemHandle *fs = fp.fileSystem();
rahul_dahiya 0:fb8047b156bb 698 if (fs == NULL) {
rahul_dahiya 0:fb8047b156bb 699 errno = ENODEV;
rahul_dahiya 0:fb8047b156bb 700 return -1;
rahul_dahiya 0:fb8047b156bb 701 }
rahul_dahiya 0:fb8047b156bb 702
rahul_dahiya 0:fb8047b156bb 703 int err = fs->stat(fp.fileName(), st);
rahul_dahiya 0:fb8047b156bb 704 if (err < 0) {
rahul_dahiya 0:fb8047b156bb 705 errno = -err;
rahul_dahiya 0:fb8047b156bb 706 return -1;
rahul_dahiya 0:fb8047b156bb 707 } else {
rahul_dahiya 0:fb8047b156bb 708 return 0;
rahul_dahiya 0:fb8047b156bb 709 }
rahul_dahiya 0:fb8047b156bb 710 }
rahul_dahiya 0:fb8047b156bb 711
rahul_dahiya 0:fb8047b156bb 712 #if defined(TOOLCHAIN_GCC)
rahul_dahiya 0:fb8047b156bb 713 /* prevents the exception handling name demangling code getting pulled in */
rahul_dahiya 0:fb8047b156bb 714 #include "mbed_error.h"
rahul_dahiya 0:fb8047b156bb 715 namespace __gnu_cxx {
rahul_dahiya 0:fb8047b156bb 716 void __verbose_terminate_handler() {
rahul_dahiya 0:fb8047b156bb 717 error("Exception");
rahul_dahiya 0:fb8047b156bb 718 }
rahul_dahiya 0:fb8047b156bb 719 }
rahul_dahiya 0:fb8047b156bb 720 extern "C" WEAK void __cxa_pure_virtual(void);
rahul_dahiya 0:fb8047b156bb 721 extern "C" WEAK void __cxa_pure_virtual(void) {
rahul_dahiya 0:fb8047b156bb 722 exit(1);
rahul_dahiya 0:fb8047b156bb 723 }
rahul_dahiya 0:fb8047b156bb 724
rahul_dahiya 0:fb8047b156bb 725 #endif
rahul_dahiya 0:fb8047b156bb 726
rahul_dahiya 0:fb8047b156bb 727 // Provide implementation of _sbrk (low-level dynamic memory allocation
rahul_dahiya 0:fb8047b156bb 728 // routine) for GCC_ARM which compares new heap pointer with MSP instead of
rahul_dahiya 0:fb8047b156bb 729 // SP. This make it compatible with RTX RTOS thread stacks.
rahul_dahiya 0:fb8047b156bb 730 #if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR)
rahul_dahiya 0:fb8047b156bb 731
rahul_dahiya 0:fb8047b156bb 732 #if defined(TARGET_CORTEX_A)
rahul_dahiya 0:fb8047b156bb 733 extern "C" uint32_t __HeapLimit;
rahul_dahiya 0:fb8047b156bb 734 #endif
rahul_dahiya 0:fb8047b156bb 735
rahul_dahiya 0:fb8047b156bb 736 // Turn off the errno macro and use actual global variable instead.
rahul_dahiya 0:fb8047b156bb 737 #undef errno
rahul_dahiya 0:fb8047b156bb 738 extern "C" int errno;
rahul_dahiya 0:fb8047b156bb 739
rahul_dahiya 0:fb8047b156bb 740 // Dynamic memory allocation related syscall.
rahul_dahiya 0:fb8047b156bb 741 #if defined(TARGET_NUVOTON)
rahul_dahiya 0:fb8047b156bb 742 // Overwrite _sbrk() to support two region model (heap and stack are two distinct regions).
rahul_dahiya 0:fb8047b156bb 743 // __wrap__sbrk() is implemented in:
rahul_dahiya 0:fb8047b156bb 744 // TARGET_NUMAKER_PFM_NUC472 targets/TARGET_NUVOTON/TARGET_NUC472/TARGET_NUMAKER_PFM_NUC472/TOOLCHAIN_GCC_ARM/nuc472_retarget.c
rahul_dahiya 0:fb8047b156bb 745 // TARGET_NUMAKER_PFM_M453 targets/TARGET_NUVOTON/TARGET_M451/TARGET_NUMAKER_PFM_M453/TOOLCHAIN_GCC_ARM/m451_retarget.c
rahul_dahiya 0:fb8047b156bb 746 extern "C" void *__wrap__sbrk(int incr);
rahul_dahiya 0:fb8047b156bb 747 extern "C" caddr_t _sbrk(int incr) {
rahul_dahiya 0:fb8047b156bb 748 return (caddr_t) __wrap__sbrk(incr);
rahul_dahiya 0:fb8047b156bb 749 }
rahul_dahiya 0:fb8047b156bb 750 #else
rahul_dahiya 0:fb8047b156bb 751 // Linker defined symbol used by _sbrk to indicate where heap should start.
rahul_dahiya 0:fb8047b156bb 752 extern "C" uint32_t __end__;
rahul_dahiya 0:fb8047b156bb 753 extern "C" caddr_t _sbrk(int incr) {
rahul_dahiya 0:fb8047b156bb 754 static unsigned char* heap = (unsigned char*)&__end__;
rahul_dahiya 0:fb8047b156bb 755 unsigned char* prev_heap = heap;
rahul_dahiya 0:fb8047b156bb 756 unsigned char* new_heap = heap + incr;
rahul_dahiya 0:fb8047b156bb 757
rahul_dahiya 0:fb8047b156bb 758 #if defined(TARGET_CORTEX_A)
rahul_dahiya 0:fb8047b156bb 759 if (new_heap >= (unsigned char*)&__HeapLimit) { /* __HeapLimit is end of heap section */
rahul_dahiya 0:fb8047b156bb 760 #else
rahul_dahiya 0:fb8047b156bb 761 if (new_heap >= (unsigned char*)__get_MSP()) {
rahul_dahiya 0:fb8047b156bb 762 #endif
rahul_dahiya 0:fb8047b156bb 763 errno = ENOMEM;
rahul_dahiya 0:fb8047b156bb 764 return (caddr_t)-1;
rahul_dahiya 0:fb8047b156bb 765 }
rahul_dahiya 0:fb8047b156bb 766
rahul_dahiya 0:fb8047b156bb 767 // Additional heap checking if set
rahul_dahiya 0:fb8047b156bb 768 if (mbed_heap_size && (new_heap >= mbed_heap_start + mbed_heap_size)) {
rahul_dahiya 0:fb8047b156bb 769 errno = ENOMEM;
rahul_dahiya 0:fb8047b156bb 770 return (caddr_t)-1;
rahul_dahiya 0:fb8047b156bb 771 }
rahul_dahiya 0:fb8047b156bb 772
rahul_dahiya 0:fb8047b156bb 773 heap = new_heap;
rahul_dahiya 0:fb8047b156bb 774 return (caddr_t) prev_heap;
rahul_dahiya 0:fb8047b156bb 775 }
rahul_dahiya 0:fb8047b156bb 776 #endif
rahul_dahiya 0:fb8047b156bb 777 #endif
rahul_dahiya 0:fb8047b156bb 778
rahul_dahiya 0:fb8047b156bb 779 #if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR)
rahul_dahiya 0:fb8047b156bb 780 extern "C" void _exit(int return_code) {
rahul_dahiya 0:fb8047b156bb 781 #else
rahul_dahiya 0:fb8047b156bb 782 namespace std {
rahul_dahiya 0:fb8047b156bb 783 extern "C" void exit(int return_code) {
rahul_dahiya 0:fb8047b156bb 784 #endif
rahul_dahiya 0:fb8047b156bb 785
rahul_dahiya 0:fb8047b156bb 786 #if DEVICE_STDIO_MESSAGES
rahul_dahiya 0:fb8047b156bb 787 #if MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT
rahul_dahiya 0:fb8047b156bb 788 fflush(stdout);
rahul_dahiya 0:fb8047b156bb 789 fflush(stderr);
rahul_dahiya 0:fb8047b156bb 790 #endif
rahul_dahiya 0:fb8047b156bb 791 #endif
rahul_dahiya 0:fb8047b156bb 792
rahul_dahiya 0:fb8047b156bb 793 #if DEVICE_SEMIHOST
rahul_dahiya 0:fb8047b156bb 794 if (mbed_interface_connected()) {
rahul_dahiya 0:fb8047b156bb 795 semihost_exit();
rahul_dahiya 0:fb8047b156bb 796 }
rahul_dahiya 0:fb8047b156bb 797 #endif
rahul_dahiya 0:fb8047b156bb 798 if (return_code) {
rahul_dahiya 0:fb8047b156bb 799 mbed_die();
rahul_dahiya 0:fb8047b156bb 800 }
rahul_dahiya 0:fb8047b156bb 801
rahul_dahiya 0:fb8047b156bb 802 while (1);
rahul_dahiya 0:fb8047b156bb 803 }
rahul_dahiya 0:fb8047b156bb 804
rahul_dahiya 0:fb8047b156bb 805 #if !defined(TOOLCHAIN_GCC_ARM) && !defined(TOOLCHAIN_GCC_CR)
rahul_dahiya 0:fb8047b156bb 806 } //namespace std
rahul_dahiya 0:fb8047b156bb 807 #endif
rahul_dahiya 0:fb8047b156bb 808
rahul_dahiya 0:fb8047b156bb 809 #if defined(TOOLCHAIN_ARM) || defined(TOOLCHAIN_GCC)
rahul_dahiya 0:fb8047b156bb 810
rahul_dahiya 0:fb8047b156bb 811 // This series of function disable the registration of global destructors
rahul_dahiya 0:fb8047b156bb 812 // in a dynamic table which will be called when the application exit.
rahul_dahiya 0:fb8047b156bb 813 // In mbed, program never exit properly, it dies.
rahul_dahiya 0:fb8047b156bb 814 // More informations about this topic for ARMCC here:
rahul_dahiya 0:fb8047b156bb 815 // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/6449.html
rahul_dahiya 0:fb8047b156bb 816 extern "C" {
rahul_dahiya 0:fb8047b156bb 817 int __aeabi_atexit(void *object, void (*dtor)(void* /*this*/), void *handle) {
rahul_dahiya 0:fb8047b156bb 818 return 1;
rahul_dahiya 0:fb8047b156bb 819 }
rahul_dahiya 0:fb8047b156bb 820
rahul_dahiya 0:fb8047b156bb 821 int __cxa_atexit(void (*dtor)(void* /*this*/), void *object, void *handle) {
rahul_dahiya 0:fb8047b156bb 822 return 1;
rahul_dahiya 0:fb8047b156bb 823 }
rahul_dahiya 0:fb8047b156bb 824
rahul_dahiya 0:fb8047b156bb 825 void __cxa_finalize(void *handle) {
rahul_dahiya 0:fb8047b156bb 826 }
rahul_dahiya 0:fb8047b156bb 827
rahul_dahiya 0:fb8047b156bb 828 } // end of extern "C"
rahul_dahiya 0:fb8047b156bb 829
rahul_dahiya 0:fb8047b156bb 830 #endif
rahul_dahiya 0:fb8047b156bb 831
rahul_dahiya 0:fb8047b156bb 832
rahul_dahiya 0:fb8047b156bb 833 #if defined(TOOLCHAIN_GCC)
rahul_dahiya 0:fb8047b156bb 834
rahul_dahiya 0:fb8047b156bb 835 /*
rahul_dahiya 0:fb8047b156bb 836 * Depending on how newlib is configured, it is often not enough to define
rahul_dahiya 0:fb8047b156bb 837 * __aeabi_atexit, __cxa_atexit and __cxa_finalize in order to override the
rahul_dahiya 0:fb8047b156bb 838 * behavior regarding the registration of handlers with atexit.
rahul_dahiya 0:fb8047b156bb 839 *
rahul_dahiya 0:fb8047b156bb 840 * To overcome this limitation, exit and atexit are overriden here.
rahul_dahiya 0:fb8047b156bb 841 */
rahul_dahiya 0:fb8047b156bb 842 extern "C"{
rahul_dahiya 0:fb8047b156bb 843
rahul_dahiya 0:fb8047b156bb 844 /**
rahul_dahiya 0:fb8047b156bb 845 * @brief Retarget of exit for GCC.
rahul_dahiya 0:fb8047b156bb 846 * @details Unlike the standard version, this function doesn't call any function
rahul_dahiya 0:fb8047b156bb 847 * registered with atexit before calling _exit.
rahul_dahiya 0:fb8047b156bb 848 */
rahul_dahiya 0:fb8047b156bb 849 void __wrap_exit(int return_code) {
rahul_dahiya 0:fb8047b156bb 850 _exit(return_code);
rahul_dahiya 0:fb8047b156bb 851 }
rahul_dahiya 0:fb8047b156bb 852
rahul_dahiya 0:fb8047b156bb 853 /**
rahul_dahiya 0:fb8047b156bb 854 * @brief Retarget atexit from GCC.
rahul_dahiya 0:fb8047b156bb 855 * @details This function will always fail and never register any handler to be
rahul_dahiya 0:fb8047b156bb 856 * called at exit.
rahul_dahiya 0:fb8047b156bb 857 */
rahul_dahiya 0:fb8047b156bb 858 int __wrap_atexit(void (*func)()) {
rahul_dahiya 0:fb8047b156bb 859 return 1;
rahul_dahiya 0:fb8047b156bb 860 }
rahul_dahiya 0:fb8047b156bb 861
rahul_dahiya 0:fb8047b156bb 862 }
rahul_dahiya 0:fb8047b156bb 863
rahul_dahiya 0:fb8047b156bb 864 #endif
rahul_dahiya 0:fb8047b156bb 865
rahul_dahiya 0:fb8047b156bb 866
rahul_dahiya 0:fb8047b156bb 867
rahul_dahiya 0:fb8047b156bb 868 namespace mbed {
rahul_dahiya 0:fb8047b156bb 869
rahul_dahiya 0:fb8047b156bb 870 void mbed_set_unbuffered_stream(std::FILE *_file) {
rahul_dahiya 0:fb8047b156bb 871 #if defined (__ICCARM__)
rahul_dahiya 0:fb8047b156bb 872 char buf[2];
rahul_dahiya 0:fb8047b156bb 873 std::setvbuf(_file,buf,_IONBF,NULL);
rahul_dahiya 0:fb8047b156bb 874 #else
rahul_dahiya 0:fb8047b156bb 875 setbuf(_file, NULL);
rahul_dahiya 0:fb8047b156bb 876 #endif
rahul_dahiya 0:fb8047b156bb 877 }
rahul_dahiya 0:fb8047b156bb 878
rahul_dahiya 0:fb8047b156bb 879 /* Applications are expected to use fdopen()
rahul_dahiya 0:fb8047b156bb 880 * not this function directly. This code had to live here because FILE and FileHandle
rahul_dahiya 0:fb8047b156bb 881 * processes are all linked together here.
rahul_dahiya 0:fb8047b156bb 882 */
rahul_dahiya 0:fb8047b156bb 883 std::FILE *mbed_fdopen(FileHandle *fh, const char *mode)
rahul_dahiya 0:fb8047b156bb 884 {
rahul_dahiya 0:fb8047b156bb 885 // This is to avoid scanf(buf, ":%.4s", fh) and the bloat it brings.
rahul_dahiya 0:fb8047b156bb 886 char buf[1 + sizeof(fh)]; /* :(pointer) */
rahul_dahiya 0:fb8047b156bb 887 MBED_STATIC_ASSERT(sizeof(buf) == 5, "Pointers should be 4 bytes.");
rahul_dahiya 0:fb8047b156bb 888 buf[0] = ':';
rahul_dahiya 0:fb8047b156bb 889 memcpy(buf + 1, &fh, sizeof(fh));
rahul_dahiya 0:fb8047b156bb 890
rahul_dahiya 0:fb8047b156bb 891 std::FILE *stream = std::fopen(buf, mode);
rahul_dahiya 0:fb8047b156bb 892 /* newlib-nano doesn't appear to ever call _isatty itself, so
rahul_dahiya 0:fb8047b156bb 893 * happily fully buffers an interactive stream. Deal with that here.
rahul_dahiya 0:fb8047b156bb 894 */
rahul_dahiya 0:fb8047b156bb 895 if (stream && fh->isatty()) {
rahul_dahiya 0:fb8047b156bb 896 mbed_set_unbuffered_stream(stream);
rahul_dahiya 0:fb8047b156bb 897 }
rahul_dahiya 0:fb8047b156bb 898 return stream;
rahul_dahiya 0:fb8047b156bb 899 }
rahul_dahiya 0:fb8047b156bb 900
rahul_dahiya 0:fb8047b156bb 901 int mbed_getc(std::FILE *_file){
rahul_dahiya 0:fb8047b156bb 902 #if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ < 8000000)
rahul_dahiya 0:fb8047b156bb 903 /*This is only valid for unbuffered streams*/
rahul_dahiya 0:fb8047b156bb 904 int res = std::fgetc(_file);
rahul_dahiya 0:fb8047b156bb 905 if (res>=0){
rahul_dahiya 0:fb8047b156bb 906 _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */
rahul_dahiya 0:fb8047b156bb 907 _file->_Rend = _file->_Wend;
rahul_dahiya 0:fb8047b156bb 908 _file->_Next = _file->_Wend;
rahul_dahiya 0:fb8047b156bb 909 }
rahul_dahiya 0:fb8047b156bb 910 return res;
rahul_dahiya 0:fb8047b156bb 911 #else
rahul_dahiya 0:fb8047b156bb 912 return std::fgetc(_file);
rahul_dahiya 0:fb8047b156bb 913 #endif
rahul_dahiya 0:fb8047b156bb 914 }
rahul_dahiya 0:fb8047b156bb 915
rahul_dahiya 0:fb8047b156bb 916 char* mbed_gets(char*s, int size, std::FILE *_file){
rahul_dahiya 0:fb8047b156bb 917 #if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ < 8000000)
rahul_dahiya 0:fb8047b156bb 918 /*This is only valid for unbuffered streams*/
rahul_dahiya 0:fb8047b156bb 919 char *str = fgets(s,size,_file);
rahul_dahiya 0:fb8047b156bb 920 if (str!=NULL){
rahul_dahiya 0:fb8047b156bb 921 _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */
rahul_dahiya 0:fb8047b156bb 922 _file->_Rend = _file->_Wend;
rahul_dahiya 0:fb8047b156bb 923 _file->_Next = _file->_Wend;
rahul_dahiya 0:fb8047b156bb 924 }
rahul_dahiya 0:fb8047b156bb 925 return str;
rahul_dahiya 0:fb8047b156bb 926 #else
rahul_dahiya 0:fb8047b156bb 927 return std::fgets(s,size,_file);
rahul_dahiya 0:fb8047b156bb 928 #endif
rahul_dahiya 0:fb8047b156bb 929 }
rahul_dahiya 0:fb8047b156bb 930
rahul_dahiya 0:fb8047b156bb 931 } // namespace mbed
rahul_dahiya 0:fb8047b156bb 932
rahul_dahiya 0:fb8047b156bb 933 #if defined (__ICCARM__)
rahul_dahiya 0:fb8047b156bb 934 // Stub out locks when an rtos is not present
rahul_dahiya 0:fb8047b156bb 935 extern "C" WEAK void __iar_system_Mtxinit(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 936 extern "C" WEAK void __iar_system_Mtxdst(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 937 extern "C" WEAK void __iar_system_Mtxlock(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 938 extern "C" WEAK void __iar_system_Mtxunlock(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 939 extern "C" WEAK void __iar_file_Mtxinit(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 940 extern "C" WEAK void __iar_file_Mtxdst(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 941 extern "C" WEAK void __iar_file_Mtxlock(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 942 extern "C" WEAK void __iar_file_Mtxunlock(__iar_Rmtx *mutex) {}
rahul_dahiya 0:fb8047b156bb 943 #if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ >= 8000000)
rahul_dahiya 0:fb8047b156bb 944 #pragma section="__iar_tls$$DATA"
rahul_dahiya 0:fb8047b156bb 945 extern "C" WEAK void *__aeabi_read_tp (void) {
rahul_dahiya 0:fb8047b156bb 946 // Thread Local storage is not supported, using main thread memory for errno
rahul_dahiya 0:fb8047b156bb 947 return __section_begin("__iar_tls$$DATA");
rahul_dahiya 0:fb8047b156bb 948 }
rahul_dahiya 0:fb8047b156bb 949 #endif
rahul_dahiya 0:fb8047b156bb 950 #elif defined(__CC_ARM)
rahul_dahiya 0:fb8047b156bb 951 // Do nothing
rahul_dahiya 0:fb8047b156bb 952 #elif defined (__GNUC__)
rahul_dahiya 0:fb8047b156bb 953 struct _reent;
rahul_dahiya 0:fb8047b156bb 954 // Stub out locks when an rtos is not present
rahul_dahiya 0:fb8047b156bb 955 extern "C" WEAK void __rtos_malloc_lock( struct _reent *_r ) {}
rahul_dahiya 0:fb8047b156bb 956 extern "C" WEAK void __rtos_malloc_unlock( struct _reent *_r ) {}
rahul_dahiya 0:fb8047b156bb 957 extern "C" WEAK void __rtos_env_lock( struct _reent *_r ) {}
rahul_dahiya 0:fb8047b156bb 958 extern "C" WEAK void __rtos_env_unlock( struct _reent *_r ) {}
rahul_dahiya 0:fb8047b156bb 959
rahul_dahiya 0:fb8047b156bb 960 extern "C" void __malloc_lock( struct _reent *_r )
rahul_dahiya 0:fb8047b156bb 961 {
rahul_dahiya 0:fb8047b156bb 962 __rtos_malloc_lock(_r);
rahul_dahiya 0:fb8047b156bb 963 }
rahul_dahiya 0:fb8047b156bb 964
rahul_dahiya 0:fb8047b156bb 965 extern "C" void __malloc_unlock( struct _reent *_r )
rahul_dahiya 0:fb8047b156bb 966 {
rahul_dahiya 0:fb8047b156bb 967 __rtos_malloc_unlock(_r);
rahul_dahiya 0:fb8047b156bb 968 }
rahul_dahiya 0:fb8047b156bb 969
rahul_dahiya 0:fb8047b156bb 970 extern "C" void __env_lock( struct _reent *_r )
rahul_dahiya 0:fb8047b156bb 971 {
rahul_dahiya 0:fb8047b156bb 972 __rtos_env_lock(_r);
rahul_dahiya 0:fb8047b156bb 973 }
rahul_dahiya 0:fb8047b156bb 974
rahul_dahiya 0:fb8047b156bb 975 extern "C" void __env_unlock( struct _reent *_r )
rahul_dahiya 0:fb8047b156bb 976 {
rahul_dahiya 0:fb8047b156bb 977 __rtos_env_unlock(_r);
rahul_dahiya 0:fb8047b156bb 978 }
rahul_dahiya 0:fb8047b156bb 979
rahul_dahiya 0:fb8047b156bb 980 #define CXA_GUARD_INIT_DONE (1 << 0)
rahul_dahiya 0:fb8047b156bb 981 #define CXA_GUARD_INIT_IN_PROGRESS (1 << 1)
rahul_dahiya 0:fb8047b156bb 982 #define CXA_GUARD_MASK (CXA_GUARD_INIT_DONE | CXA_GUARD_INIT_IN_PROGRESS)
rahul_dahiya 0:fb8047b156bb 983
rahul_dahiya 0:fb8047b156bb 984 extern "C" int __cxa_guard_acquire(int *guard_object_p)
rahul_dahiya 0:fb8047b156bb 985 {
rahul_dahiya 0:fb8047b156bb 986 uint8_t *guard_object = (uint8_t *)guard_object_p;
rahul_dahiya 0:fb8047b156bb 987 if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) {
rahul_dahiya 0:fb8047b156bb 988 return 0;
rahul_dahiya 0:fb8047b156bb 989 }
rahul_dahiya 0:fb8047b156bb 990 singleton_lock();
rahul_dahiya 0:fb8047b156bb 991 if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) {
rahul_dahiya 0:fb8047b156bb 992 singleton_unlock();
rahul_dahiya 0:fb8047b156bb 993 return 0;
rahul_dahiya 0:fb8047b156bb 994 }
rahul_dahiya 0:fb8047b156bb 995 MBED_ASSERT(0 == (*guard_object & CXA_GUARD_MASK));
rahul_dahiya 0:fb8047b156bb 996 *guard_object = *guard_object | CXA_GUARD_INIT_IN_PROGRESS;
rahul_dahiya 0:fb8047b156bb 997 return 1;
rahul_dahiya 0:fb8047b156bb 998 }
rahul_dahiya 0:fb8047b156bb 999
rahul_dahiya 0:fb8047b156bb 1000 extern "C" void __cxa_guard_release(int *guard_object_p)
rahul_dahiya 0:fb8047b156bb 1001 {
rahul_dahiya 0:fb8047b156bb 1002 uint8_t *guard_object = (uint8_t *)guard_object_p;
rahul_dahiya 0:fb8047b156bb 1003 MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK));
rahul_dahiya 0:fb8047b156bb 1004 *guard_object = (*guard_object & ~CXA_GUARD_MASK) | CXA_GUARD_INIT_DONE;
rahul_dahiya 0:fb8047b156bb 1005 singleton_unlock();
rahul_dahiya 0:fb8047b156bb 1006 }
rahul_dahiya 0:fb8047b156bb 1007
rahul_dahiya 0:fb8047b156bb 1008 extern "C" void __cxa_guard_abort(int *guard_object_p)
rahul_dahiya 0:fb8047b156bb 1009 {
rahul_dahiya 0:fb8047b156bb 1010 uint8_t *guard_object = (uint8_t *)guard_object_p;
rahul_dahiya 0:fb8047b156bb 1011 MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK));
rahul_dahiya 0:fb8047b156bb 1012 *guard_object = *guard_object & ~CXA_GUARD_INIT_IN_PROGRESS;
rahul_dahiya 0:fb8047b156bb 1013 singleton_unlock();
rahul_dahiya 0:fb8047b156bb 1014 }
rahul_dahiya 0:fb8047b156bb 1015
rahul_dahiya 0:fb8047b156bb 1016 #endif
rahul_dahiya 0:fb8047b156bb 1017
rahul_dahiya 0:fb8047b156bb 1018 void *operator new(std::size_t count)
rahul_dahiya 0:fb8047b156bb 1019 {
rahul_dahiya 0:fb8047b156bb 1020 void *buffer = malloc(count);
rahul_dahiya 0:fb8047b156bb 1021 if (NULL == buffer) {
rahul_dahiya 0:fb8047b156bb 1022 error("Operator new out of memory\r\n");
rahul_dahiya 0:fb8047b156bb 1023 }
rahul_dahiya 0:fb8047b156bb 1024 return buffer;
rahul_dahiya 0:fb8047b156bb 1025 }
rahul_dahiya 0:fb8047b156bb 1026
rahul_dahiya 0:fb8047b156bb 1027 void *operator new[](std::size_t count)
rahul_dahiya 0:fb8047b156bb 1028 {
rahul_dahiya 0:fb8047b156bb 1029 void *buffer = malloc(count);
rahul_dahiya 0:fb8047b156bb 1030 if (NULL == buffer) {
rahul_dahiya 0:fb8047b156bb 1031 error("Operator new[] out of memory\r\n");
rahul_dahiya 0:fb8047b156bb 1032 }
rahul_dahiya 0:fb8047b156bb 1033 return buffer;
rahul_dahiya 0:fb8047b156bb 1034 }
rahul_dahiya 0:fb8047b156bb 1035
rahul_dahiya 0:fb8047b156bb 1036 void *operator new(std::size_t count, const std::nothrow_t& tag)
rahul_dahiya 0:fb8047b156bb 1037 {
rahul_dahiya 0:fb8047b156bb 1038 return malloc(count);
rahul_dahiya 0:fb8047b156bb 1039 }
rahul_dahiya 0:fb8047b156bb 1040
rahul_dahiya 0:fb8047b156bb 1041 void *operator new[](std::size_t count, const std::nothrow_t& tag)
rahul_dahiya 0:fb8047b156bb 1042 {
rahul_dahiya 0:fb8047b156bb 1043 return malloc(count);
rahul_dahiya 0:fb8047b156bb 1044 }
rahul_dahiya 0:fb8047b156bb 1045
rahul_dahiya 0:fb8047b156bb 1046 void operator delete(void *ptr)
rahul_dahiya 0:fb8047b156bb 1047 {
rahul_dahiya 0:fb8047b156bb 1048 if (ptr != NULL) {
rahul_dahiya 0:fb8047b156bb 1049 free(ptr);
rahul_dahiya 0:fb8047b156bb 1050 }
rahul_dahiya 0:fb8047b156bb 1051 }
rahul_dahiya 0:fb8047b156bb 1052 void operator delete[](void *ptr)
rahul_dahiya 0:fb8047b156bb 1053 {
rahul_dahiya 0:fb8047b156bb 1054 if (ptr != NULL) {
rahul_dahiya 0:fb8047b156bb 1055 free(ptr);
rahul_dahiya 0:fb8047b156bb 1056 }
rahul_dahiya 0:fb8047b156bb 1057 }
rahul_dahiya 0:fb8047b156bb 1058
rahul_dahiya 0:fb8047b156bb 1059 /* @brief standard c library clock() function.
rahul_dahiya 0:fb8047b156bb 1060 *
rahul_dahiya 0:fb8047b156bb 1061 * This function returns the number of clock ticks elapsed since the start of the program.
rahul_dahiya 0:fb8047b156bb 1062 *
rahul_dahiya 0:fb8047b156bb 1063 * @note Synchronization level: Thread safe
rahul_dahiya 0:fb8047b156bb 1064 *
rahul_dahiya 0:fb8047b156bb 1065 * @return
rahul_dahiya 0:fb8047b156bb 1066 * the number of clock ticks elapsed since the start of the program.
rahul_dahiya 0:fb8047b156bb 1067 *
rahul_dahiya 0:fb8047b156bb 1068 * */
rahul_dahiya 0:fb8047b156bb 1069 extern "C" clock_t clock()
rahul_dahiya 0:fb8047b156bb 1070 {
rahul_dahiya 0:fb8047b156bb 1071 _mutex->lock();
rahul_dahiya 0:fb8047b156bb 1072 clock_t t = ticker_read(get_us_ticker_data());
rahul_dahiya 0:fb8047b156bb 1073 t /= 1000000 / CLOCKS_PER_SEC; // convert to processor time
rahul_dahiya 0:fb8047b156bb 1074 _mutex->unlock();
rahul_dahiya 0:fb8047b156bb 1075 return t;
rahul_dahiya 0:fb8047b156bb 1076 }
rahul_dahiya 0:fb8047b156bb 1077
rahul_dahiya 0:fb8047b156bb 1078 // temporary - Default to 1MHz at 32 bits if target does not have us_ticker_get_info
rahul_dahiya 0:fb8047b156bb 1079 MBED_WEAK const ticker_info_t* us_ticker_get_info()
rahul_dahiya 0:fb8047b156bb 1080 {
rahul_dahiya 0:fb8047b156bb 1081 static const ticker_info_t info = {
rahul_dahiya 0:fb8047b156bb 1082 1000000,
rahul_dahiya 0:fb8047b156bb 1083 32
rahul_dahiya 0:fb8047b156bb 1084 };
rahul_dahiya 0:fb8047b156bb 1085 return &info;
rahul_dahiya 0:fb8047b156bb 1086 }
rahul_dahiya 0:fb8047b156bb 1087
rahul_dahiya 0:fb8047b156bb 1088 // temporary - Default to 1MHz at 32 bits if target does not have lp_ticker_get_info
rahul_dahiya 0:fb8047b156bb 1089 MBED_WEAK const ticker_info_t* lp_ticker_get_info()
rahul_dahiya 0:fb8047b156bb 1090 {
rahul_dahiya 0:fb8047b156bb 1091 static const ticker_info_t info = {
rahul_dahiya 0:fb8047b156bb 1092 1000000,
rahul_dahiya 0:fb8047b156bb 1093 32
rahul_dahiya 0:fb8047b156bb 1094 };
rahul_dahiya 0:fb8047b156bb 1095 return &info;
rahul_dahiya 0:fb8047b156bb 1096 }