summaryrefslogtreecommitdiff
path: root/examples/libc
diff options
context:
space:
mode:
Diffstat (limited to 'examples/libc')
-rw-r--r--examples/libc/SConscript8
-rw-r--r--examples/libc/dirent.c56
-rw-r--r--examples/libc/env.c18
-rw-r--r--examples/libc/ex1.c37
-rw-r--r--examples/libc/ex2.c114
-rw-r--r--examples/libc/ex3.c154
-rw-r--r--examples/libc/ex4.c108
-rw-r--r--examples/libc/ex5.c105
-rw-r--r--examples/libc/ex6.c37
-rw-r--r--examples/libc/ex7.c101
-rw-r--r--examples/libc/file.c516
-rw-r--r--examples/libc/memory.c54
-rw-r--r--examples/libc/printf.c200
-rw-r--r--examples/libc/rand.c43
-rw-r--r--examples/libc/time.c24
15 files changed, 1575 insertions, 0 deletions
diff --git a/examples/libc/SConscript b/examples/libc/SConscript
new file mode 100644
index 0000000000..af43df3ddb
--- /dev/null
+++ b/examples/libc/SConscript
@@ -0,0 +1,8 @@
+Import('env')
+
+src_local = Glob('*.c')
+
+# The set of source files associated with this SConscript file.
+obj = env.Object(src_local)
+
+Return('obj')
diff --git a/examples/libc/dirent.c b/examples/libc/dirent.c
new file mode 100644
index 0000000000..a763ecb022
--- /dev/null
+++ b/examples/libc/dirent.c
@@ -0,0 +1,56 @@
+/*
+ * dirent.c
+ *
+ * Created on: 2010-11-17
+ * Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+#include <dirent.h>
+int libc_dirent()
+{
+ DIR * dirp;
+ long int save3 = 0;
+ long int cur;
+ int i = 0;
+ int result = 0;
+ struct dirent *dp;
+
+ dirp = opendir("/");
+ for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
+ {
+ /* save position 3 (after fourth entry) */
+ if (i++ == 3)
+ save3 = telldir(dirp);
+
+ printf("%s\n", dp->d_name);
+
+ /* stop at 400 (just to make sure dirp->__offset and dirp->__size are
+ scrambled */
+ if (i == 400)
+ break;
+ }
+
+ printf("going back past 4-th entry...\n");
+
+ /* go back to saved entry */
+ seekdir(dirp, save3);
+
+ /* Check whether telldir equals to save3 now. */
+ cur = telldir(dirp);
+ if (cur != save3)
+ {
+ printf("seekdir (d, %ld); telldir (d) == %ld\n", save3, cur);
+ result = 1;
+ }
+
+ /* print remaining files (3-last) */
+ for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
+ printf("%s\n", dp->d_name);
+
+ closedir(dirp);
+ return result;
+}
+FINSH_FUNCTION_EXPORT(libc_dirent, dirent test for libc);
diff --git a/examples/libc/env.c b/examples/libc/env.c
new file mode 100644
index 0000000000..56f906774f
--- /dev/null
+++ b/examples/libc/env.c
@@ -0,0 +1,18 @@
+/*
+ * env.c
+ *
+ * Created on: 2010-11-17
+ * Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+int libc_env()
+{
+ printf("PATH=%s\n", getenv("PATH"));
+ putenv("foo=bar");
+ printf("foo=%s\n", getenv("foo"));
+ return 0;
+}
+FINSH_FUNCTION_EXPORT(libc_env, get/set_env test);
diff --git a/examples/libc/ex1.c b/examples/libc/ex1.c
new file mode 100644
index 0000000000..2acbfc3a39
--- /dev/null
+++ b/examples/libc/ex1.c
@@ -0,0 +1,37 @@
+/* Creates two threads, one printing 10000 "a"s, the other printing
+ 10000 "b"s.
+ Illustrates: thread creation, thread joining. */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <unistd.h>
+#include "pthread.h"
+
+static void *process(void * arg)
+{
+ int i;
+ printf("Starting process %s\n", (char *)arg);
+ for (i = 0; i < 10000; i++)
+ write(1, (char *) arg, 1);
+ return NULL;
+}
+
+#define sucfail(r) (r != 0 ? "failed" : "succeeded")
+int libc_ex1(void)
+{
+ int pret, ret = 0;
+ pthread_t th_a, th_b;
+ void *retval;
+
+ ret += (pret = pthread_create(&th_a, NULL, process, (void *)"a"));
+ printf("create a %s %d\n", sucfail(pret), pret);
+ ret += (pret = pthread_create(&th_b, NULL, process, (void *)"b"));
+ printf("create b %s %d\n", sucfail(pret), pret);
+ ret += (pret = pthread_join(th_a, &retval));
+ printf("join a %s %d\n", sucfail(pret), pret);
+ ret += (pret = pthread_join(th_b, &retval));
+ printf("join b %s %d\n", sucfail(pret), pret);
+ return ret;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex1, example 1 for libc);
diff --git a/examples/libc/ex2.c b/examples/libc/ex2.c
new file mode 100644
index 0000000000..925f4e1f23
--- /dev/null
+++ b/examples/libc/ex2.c
@@ -0,0 +1,114 @@
+/* The classic producer-consumer example.
+ Illustrates mutexes and conditions.
+ All integers between 0 and 9999 should be printed exactly twice,
+ once to the right of the arrow and once to the left. */
+
+#include <stdio.h>
+#include "pthread.h"
+
+#define BUFFER_SIZE 16
+
+/* Circular buffer of integers. */
+
+struct prodcons {
+ int buffer[BUFFER_SIZE]; /* the actual data */
+ pthread_mutex_t lock; /* mutex ensuring exclusive access to buffer */
+ int readpos, writepos; /* positions for reading and writing */
+ pthread_cond_t notempty; /* signaled when buffer is not empty */
+ pthread_cond_t notfull; /* signaled when buffer is not full */
+};
+
+/* Initialize a buffer */
+
+static void init(struct prodcons * b)
+{
+ pthread_mutex_init(&b->lock, NULL);
+ pthread_cond_init(&b->notempty, NULL);
+ pthread_cond_init(&b->notfull, NULL);
+ b->readpos = 0;
+ b->writepos = 0;
+}
+
+/* Store an integer in the buffer */
+static void put(struct prodcons * b, int data)
+{
+ pthread_mutex_lock(&b->lock);
+ /* Wait until buffer is not full */
+ while ((b->writepos + 1) % BUFFER_SIZE == b->readpos) {
+ pthread_cond_wait(&b->notfull, &b->lock);
+ /* pthread_cond_wait reacquired b->lock before returning */
+ }
+ /* Write the data and advance write pointer */
+ b->buffer[b->writepos] = data;
+ b->writepos++;
+ if (b->writepos >= BUFFER_SIZE) b->writepos = 0;
+ /* Signal that the buffer is now not empty */
+ pthread_cond_signal(&b->notempty);
+ pthread_mutex_unlock(&b->lock);
+}
+
+/* Read and remove an integer from the buffer */
+
+static int get(struct prodcons * b)
+{
+ int data;
+ pthread_mutex_lock(&b->lock);
+ /* Wait until buffer is not empty */
+ while (b->writepos == b->readpos) {
+ pthread_cond_wait(&b->notempty, &b->lock);
+ }
+ /* Read the data and advance read pointer */
+ data = b->buffer[b->readpos];
+ b->readpos++;
+ if (b->readpos >= BUFFER_SIZE) b->readpos = 0;
+ /* Signal that the buffer is now not full */
+ pthread_cond_signal(&b->notfull);
+ pthread_mutex_unlock(&b->lock);
+ return data;
+}
+
+/* A test program: one thread inserts integers from 1 to 10000,
+ the other reads them and prints them. */
+
+#define OVER (-1)
+
+struct prodcons buffer;
+
+static void * producer(void * data)
+{
+ int n;
+ for (n = 0; n < 10000; n++) {
+ printf("%d --->\n", n);
+ put(&buffer, n);
+ }
+ put(&buffer, OVER);
+ return NULL;
+}
+
+static void * consumer(void * data)
+{
+ int d;
+ while (1) {
+ d = get(&buffer);
+ if (d == OVER) break;
+ printf("---> %d\n", d);
+ }
+ return NULL;
+}
+
+int libc_ex2(void)
+{
+ pthread_t th_a, th_b;
+ void * retval;
+
+ init(&buffer);
+ /* Create the threads */
+ pthread_create(&th_a, NULL, producer, 0);
+ pthread_create(&th_b, NULL, consumer, 0);
+ /* Wait until producer and consumer finish. */
+ pthread_join(th_a, &retval);
+ pthread_join(th_b, &retval);
+ return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex2, example 2 for libc);
diff --git a/examples/libc/ex3.c b/examples/libc/ex3.c
new file mode 100644
index 0000000000..e4e3405d20
--- /dev/null
+++ b/examples/libc/ex3.c
@@ -0,0 +1,154 @@
+/* Multi-thread searching.
+ Illustrates: thread cancellation, cleanup handlers. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <pthread.h>
+
+/* Defines the number of searching threads */
+#define NUM_THREADS 5
+
+/* Function prototypes */
+void *search(void *);
+void print_it(void *);
+
+/* Global variables */
+pthread_t threads[NUM_THREADS];
+pthread_mutex_t lock;
+int tries;
+volatile int started;
+
+int libc_ex3()
+{
+ int i;
+ int pid;
+
+ /* create a number to search for */
+ pid = getpid();
+ printf("Searching for the number = %d...\n", pid);
+
+ /* Initialize the mutex lock */
+ pthread_mutex_init(&lock, NULL);
+
+ /* Create the searching threads */
+ for (started=0; started<NUM_THREADS; started++)
+ pthread_create(&threads[started], NULL, search, (void *)pid);
+
+ /* Wait for (join) all the searching threads */
+ for (i=0; i<NUM_THREADS; i++)
+ pthread_join(threads[i], NULL);
+
+ printf("It took %d tries to find the number.\n", tries);
+
+ /* Exit the program */
+ return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex3, example 5 for libc);
+
+/* This is the cleanup function that is called
+ when the threads are cancelled */
+
+void print_it(void *arg)
+{
+ int *try = (int *) arg;
+ pthread_t tid;
+
+ /* Get the calling thread's ID */
+ tid = pthread_self();
+
+ /* Print where the thread was in its search when it was cancelled */
+ printf("Thread %lx was canceled on its %d try.\n", tid, *try);
+}
+
+/* This is the search routine that is executed in each thread */
+
+void *search(void *arg)
+{
+ int num = (int) arg;
+ int i, j, ntries;
+ pthread_t tid;
+
+ /* get the calling thread ID */
+ tid = pthread_self();
+
+ /* use the thread ID to set the seed for the random number generator */
+ /* Since srand and rand are not thread-safe, serialize with lock */
+
+ /* Try to lock the mutex lock --
+ if locked, check to see if the thread has been cancelled
+ if not locked then continue */
+ while (pthread_mutex_trylock(&lock) == EBUSY)
+ pthread_testcancel();
+
+ srand((int)tid);
+ i = rand() & 0xFFFFFF;
+ pthread_mutex_unlock(&lock);
+ ntries = 0;
+
+ /* Set the cancellation parameters --
+ - Enable thread cancellation
+ - Defer the action of the cancellation */
+
+ pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+ pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+
+ while (started < NUM_THREADS)
+ sched_yield ();
+
+ /* Push the cleanup routine (print_it) onto the thread
+ cleanup stack. This routine will be called when the
+ thread is cancelled. Also note that the pthread_cleanup_push
+ call must have a matching pthread_cleanup_pop call. The
+ push and pop calls MUST be at the same lexical level
+ within the code */
+
+ /* Pass address of `ntries' since the current value of `ntries' is not
+ the one we want to use in the cleanup function */
+
+ pthread_cleanup_push(print_it, (void *)&ntries);
+
+ /* Loop forever */
+ while (1) {
+ i = (i + 1) & 0xFFFFFF;
+ ntries++;
+
+ /* Does the random number match the target number? */
+ if (num == i) {
+ /* Try to lock the mutex lock --
+ if locked, check to see if the thread has been cancelled
+ if not locked then continue */
+ while (pthread_mutex_trylock(&lock) == EBUSY)
+ pthread_testcancel();
+
+ /* Set the global variable for the number of tries */
+ tries = ntries;
+ printf("Thread %lx found the number!\n", tid);
+
+ /* Cancel all the other threads */
+ for (j=0; j<NUM_THREADS; j++)
+ if (threads[j] != tid) pthread_cancel(threads[j]);
+
+ /* Break out of the while loop */
+ break;
+ }
+
+ /* Every 100 tries check to see if the thread has been cancelled. */
+ if (ntries % 100 == 0) {
+ pthread_testcancel();
+ }
+ }
+
+ /* The only way we can get here is when the thread breaks out
+ of the while loop. In this case the thread that makes it here
+ has found the number we are looking for and does not need to run
+ the thread cleanup function. This is why the pthread_cleanup_pop
+ function is called with a 0 argument; this will pop the cleanup
+ function off the stack without executing it */
+
+ pthread_cleanup_pop(0);
+ return((void *)0);
+}
diff --git a/examples/libc/ex4.c b/examples/libc/ex4.c
new file mode 100644
index 0000000000..eb79840372
--- /dev/null
+++ b/examples/libc/ex4.c
@@ -0,0 +1,108 @@
+/* Making a library function that uses static variables thread-safe.
+ Illustrates: thread-specific data, pthread_once(). */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+/* This is a typical example of a library function that uses
+ static variables to accumulate results between calls.
+ Here, it just returns the concatenation of all string arguments
+ that were given to it. */
+
+#if 0
+
+char * str_accumulate(char * s)
+{
+ static char accu[1024] = { 0 };
+ strcat(accu, s);
+ return accu;
+}
+
+#endif
+
+/* Of course, this cannot be used in a multi-threaded program
+ because all threads store "accu" at the same location.
+ So, we'll use thread-specific data to have a different "accu"
+ for each thread. */
+
+/* Key identifying the thread-specific data */
+static pthread_key_t str_key;
+/* "Once" variable ensuring that the key for str_alloc will be allocated
+ exactly once. */
+static pthread_once_t str_alloc_key_once = PTHREAD_ONCE_INIT;
+
+/* Forward functions */
+static void str_alloc_key(void);
+static void str_alloc_destroy_accu(void * accu);
+
+/* Thread-safe version of str_accumulate */
+
+char * str_accumulate(const char * s)
+{
+ char * accu;
+
+ /* Make sure the key is allocated */
+ pthread_once(&str_alloc_key_once, str_alloc_key);
+ /* Get the thread-specific data associated with the key */
+ accu = (char *) pthread_getspecific(str_key);
+ /* It's initially NULL, meaning that we must allocate the buffer first. */
+ if (accu == NULL) {
+ accu = malloc(1024);
+ if (accu == NULL) return NULL;
+ accu[0] = 0;
+ /* Store the buffer pointer in the thread-specific data. */
+ pthread_setspecific(str_key, (void *) accu);
+ printf("Thread %lx: allocating buffer at %p\n", pthread_self(), accu);
+ }
+ /* Now we can use accu just as in the non thread-safe code. */
+ strcat(accu, s);
+ return accu;
+}
+
+/* Function to allocate the key for str_alloc thread-specific data. */
+
+static void str_alloc_key(void)
+{
+ pthread_key_create(&str_key, str_alloc_destroy_accu);
+ printf("Thread %lx: allocated key %d\n", pthread_self(), str_key);
+}
+
+/* Function to free the buffer when the thread exits. */
+/* Called only when the thread-specific data is not NULL. */
+
+static void str_alloc_destroy_accu(void * accu)
+{
+ printf("Thread %lx: freeing buffer at %p\n", pthread_self(), accu);
+ free(accu);
+}
+
+/* Test program */
+
+static void *process(void * arg)
+{
+ char *res;
+ res = str_accumulate("Result of ");
+ res = str_accumulate((char *) arg);
+ res = str_accumulate(" thread");
+ printf("Thread %lx: \"%s\"\n", pthread_self(), res);
+ return NULL;
+}
+
+int libc_ex4()
+{
+ char * res;
+ pthread_t th1, th2;
+
+ // res = str_accumulate("Result of ");
+ pthread_create(&th1, NULL, process, (void *) "first");
+ pthread_create(&th2, NULL, process, (void *) "second");
+ // res = str_accumulate("initial thread");
+ printf("Thread %lx: \"%s\"\n", pthread_self(), res);
+ pthread_join(th1, NULL);
+ pthread_join(th2, NULL);
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex4, example 4 for libc);
diff --git a/examples/libc/ex5.c b/examples/libc/ex5.c
new file mode 100644
index 0000000000..aa94c34063
--- /dev/null
+++ b/examples/libc/ex5.c
@@ -0,0 +1,105 @@
+/* The classic producer-consumer example, implemented with semaphores.
+ All integers between 0 and 9999 should be printed exactly twice,
+ once to the right of the arrow and once to the left. */
+
+#include <stdio.h>
+#include "pthread.h"
+#include "semaphore.h"
+
+#define BUFFER_SIZE 16
+
+/* Circular buffer of integers. */
+
+struct prodcons {
+ int buffer[BUFFER_SIZE]; /* the actual data */
+ int readpos, writepos; /* positions for reading and writing */
+ sem_t sem_read; /* number of elements available for reading */
+ sem_t sem_write; /* number of locations available for writing */
+};
+
+/* Initialize a buffer */
+
+void init(struct prodcons * b)
+{
+ sem_init(&b->sem_write, 0, BUFFER_SIZE - 1);
+ sem_init(&b->sem_read, 0, 0);
+ b->readpos = 0;
+ b->writepos = 0;
+}
+
+/* Store an integer in the buffer */
+
+void put(struct prodcons * b, int data)
+{
+ /* Wait until buffer is not full */
+ sem_wait(&b->sem_write);
+ /* Write the data and advance write pointer */
+ b->buffer[b->writepos] = data;
+ b->writepos++;
+ if (b->writepos >= BUFFER_SIZE) b->writepos = 0;
+ /* Signal that the buffer contains one more element for reading */
+ sem_post(&b->sem_read);
+}
+
+/* Read and remove an integer from the buffer */
+
+int get(struct prodcons * b)
+{
+ int data;
+ /* Wait until buffer is not empty */
+ sem_wait(&b->sem_read);
+ /* Read the data and advance read pointer */
+ data = b->buffer[b->readpos];
+ b->readpos++;
+ if (b->readpos >= BUFFER_SIZE) b->readpos = 0;
+ /* Signal that the buffer has now one more location for writing */
+ sem_post(&b->sem_write);
+ return data;
+}
+
+/* A test program: one thread inserts integers from 1 to 10000,
+ the other reads them and prints them. */
+
+#define OVER (-1)
+
+struct prodcons buffer;
+
+static void *producer(void * data)
+{
+ int n;
+ for (n = 0; n < 10000; n++) {
+ printf("%d --->\n", n);
+ put(&buffer, n);
+ }
+ put(&buffer, OVER);
+ return NULL;
+}
+
+static void *consumer(void * data)
+{
+ int d;
+ while (1) {
+ d = get(&buffer);
+ if (d == OVER) break;
+ printf("---> %d\n", d);
+ }
+ return NULL;
+}
+
+int libc_ex5(void)
+{
+ pthread_t th_a, th_b;
+ void * retval;
+
+ init(&buffer);
+ /* Create the threads */
+ pthread_create(&th_a, NULL, producer, 0);
+ pthread_create(&th_b, NULL, consumer, 0);
+ /* Wait until producer and consumer finish. */
+ pthread_join(th_a, &retval);
+ pthread_join(th_b, &retval);
+ return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex5, example 5 for libc);
+
diff --git a/examples/libc/ex6.c b/examples/libc/ex6.c
new file mode 100644
index 0000000000..dea6ead8cb
--- /dev/null
+++ b/examples/libc/ex6.c
@@ -0,0 +1,37 @@
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#define usleep rt_thread_sleep
+
+static void *test_thread(void *v_param) {
+ return NULL;
+}
+
+int libc_ex6(void) {
+ unsigned long count;
+
+ setvbuf(stdout, NULL, _IONBF, 0);
+
+ for (count = 0; count < 2000; ++count) {
+ pthread_t thread;
+ int status;
+
+ status = pthread_create(&thread, NULL, test_thread, NULL);
+ if (status != 0) {
+ printf("status = %d, count = %lu: %s\n", status, count, strerror(
+ errno));
+ return 1;
+ } else {
+ printf("count = %lu\n", count);
+ }
+ /* pthread_detach (thread); */
+ pthread_join(thread, NULL);
+ usleep(10);
+ }
+ return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex6, example 6 for libc);
diff --git a/examples/libc/ex7.c b/examples/libc/ex7.c
new file mode 100644
index 0000000000..859d18e7bd
--- /dev/null
+++ b/examples/libc/ex7.c
@@ -0,0 +1,101 @@
+/* ex7
+ *
+ * Test case that illustrates a timed wait on a condition variable.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#define usleep rt_thread_sleep
+
+/* Our event variable using a condition variable contruct. */
+typedef struct {
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+ int flag;
+} event_t;
+
+/* Global event to signal main thread the timeout of the child thread. */
+event_t main_event;
+
+static void *test_thread(void *ms_param) {
+ int status = 0;
+ event_t foo;
+ struct timespec time;
+ struct timeval now;
+ long ms = (long) ms_param;
+
+ /* initialize cond var */
+ pthread_cond_init(&foo.cond, NULL);
+ pthread_mutex_init(&foo.mutex, NULL);
+ foo.flag = 0;
+
+ /* set the time out value */
+ printf("waiting %ld ms ...\n", ms);
+ gettimeofday(&now, NULL);
+ time.tv_sec = now.tv_sec + ms / 1000 + (now.tv_usec + (ms % 1000) * 1000)
+ / 1000000;
+ time.tv_nsec = ((now.tv_usec + (ms % 1000) * 1000) % 1000000) * 1000;
+
+ /* Just use this to test the time out. The cond var is never signaled. */
+ pthread_mutex_lock(&foo.mutex);
+ while (foo.flag == 0 && status != ETIMEDOUT) {
+ status = pthread_cond_timedwait(&foo.cond, &foo.mutex, &time);
+ }
+ pthread_mutex_unlock(&foo.mutex);
+
+ /* post the main event */
+ pthread_mutex_lock(&main_event.mutex);
+ main_event.flag = 1;
+ pthread_cond_signal(&main_event.cond);
+ pthread_mutex_unlock(&main_event.mutex);
+
+ /* that's it, bye */
+ return (void*) status;
+}
+
+int libc_ex7(void) {
+ unsigned long count;
+
+ setvbuf(stdout, NULL, _IONBF, 0);
+
+ /* initialize main event cond var */
+ pthread_cond_init(&main_event.cond, NULL);
+ pthread_mutex_init(&main_event.mutex, NULL);
+ main_event.flag = 0;
+
+ for (count = 0; count < 20; ++count) {
+ pthread_t thread;
+ int status;
+
+ /* pass down the milli-second timeout in the void* param */
+ status = pthread_create(&thread, NULL, test_thread, (void*) (count
+ * 100));
+ if (status != 0) {
+ printf("status = %d, count = %lu: %s\n", status, count, strerror(
+ errno));
+ return 1;
+ } else {
+
+ /* wait for the event posted by the child thread */
+ pthread_mutex_lock(&main_event.mutex);
+ while (main_event.flag == 0) {
+ pthread_cond_wait(&main_event.cond, &main_event.mutex);
+ }
+ main_event.flag = 0;
+ pthread_mutex_unlock(&main_event.mutex);
+
+ printf("count = %lu\n", count);
+ }
+
+ usleep(10);
+ }
+
+ return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex7, example 7 for libc);
diff --git a/examples/libc/file.c b/examples/libc/file.c
new file mode 100644
index 0000000000..94aa206ce9
--- /dev/null
+++ b/examples/libc/file.c
@@ -0,0 +1,516 @@
+/*
+ * fstat.c
+ *
+ * Created on: 2010-11-17
+ * Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+#include <errno.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+
+const char* text = "this is a test string\n";
+void libc_fstat()
+{
+ int fd;
+ struct stat s;
+
+ fd = open("/tmp/tt.txt", O_WRONLY | O_CREAT, 0);
+ if (fd < 0)
+ {
+ printf("open failed\n");
+ return;
+ }
+
+ write(fd, text, strlen(text) + 1);
+ printf("begin: %d\n", lseek(fd, 0, SEEK_SET));
+ printf("end: %d\n", lseek(fd, 0, SEEK_END));
+
+ printf("fstat result: %d\n", fstat(fd, &s));
+ close(fd);
+}
+FINSH_FUNCTION_EXPORT(libc_fstat, fstat test for libc);
+
+void libc_lseek()
+{
+ int fd;
+
+ fd = open("/tmp/tt.txt", O_WRONLY | O_CREAT, 0);
+ if (fd < 0)
+ {
+ printf("open failed\n");
+ return;
+ }
+
+ write(fd, text, strlen(text) + 1);
+ printf("begin: %d\n", lseek(fd, 0, SEEK_SET));
+ printf("end: %d\n", lseek(fd, 0, SEEK_END));
+ close(fd);
+}
+FINSH_FUNCTION_EXPORT(libc_lseek, lseek test for libc);
+
+void sleep(int tick)
+{
+ rt_thread_sleep(tick);
+}
+
+int libc_fseek(void)
+{
+ const char *tmpdir;
+ char *fname;
+ int fd;
+ FILE *fp;
+ const char outstr[] = "hello world!\n";
+ char strbuf[sizeof outstr];
+ char buf[200];
+ struct stat st1;
+ struct stat st2;
+ int result = 0;
+
+ tmpdir = getenv("TMPDIR");
+ if (tmpdir == NULL || tmpdir[0] == '\0')
+ tmpdir = "/tmp";
+
+ asprintf(&fname, "%s/tst-fseek.XXXXXX", tmpdir);
+ if (fname == NULL)
+ {
+ fprintf(stderr, "cannot generate name for temporary file: %s\n",
+ strerror(errno));
+ return 1;
+ }
+
+ /* Create a temporary file. */
+ fd = mkstemp(fname);
+ if (fd == -1)
+ {
+ fprintf(stderr, "cannot open temporary file: %s\n", strerror(errno));
+ return 1;
+ }
+
+ fp = fdopen(fd, "w+");
+ if (fp == NULL)
+ {
+ fprintf(stderr, "cannot get FILE for temporary file: %s\n", strerror(
+ errno));
+ return 1;
+ }
+ setbuffer(fp, strbuf, sizeof(outstr) - 1);
+
+ if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: write error\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+
+ /* The EOF flag must be reset. */
+ if (fgetc(fp) != EOF)
+ {
+ printf("%d: managed to read at end of file\n", __LINE__);
+ result = 1;
+ }
+ else if (!feof(fp))
+ {
+ printf("%d: EOF flag not set\n", __LINE__);
+ result = 1;
+ }
+ if (fseek(fp, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: fseek(fp, 0, SEEK_CUR) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (feof(fp))
+ {
+ printf("%d: fseek() didn't reset EOF flag\n", __LINE__);
+ result = 1;
+ }
+
+ /* Do the same for fseeko(). */
+ if (fgetc(fp) != EOF)
+ {
+ printf("%d: managed to read at end of file\n", __LINE__);
+ result = 1;
+ }
+ else if (!feof(fp))
+ {
+ printf("%d: EOF flag not set\n", __LINE__);
+ result = 1;
+ }
+ if (fseeko(fp, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: fseek(fp, 0, SEEK_CUR) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (feof(fp))
+ {
+ printf("%d: fseek() didn't reset EOF flag\n", __LINE__);
+ result = 1;
+ }
+
+ /* Go back to the beginning of the file: absolute. */
+ if (fseek(fp, 0, SEEK_SET) != 0)
+ {
+ printf("%d: fseek(fp, 0, SEEK_SET) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fflush(fp) != 0)
+ {
+ printf("%d: fflush() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (lseek(fd, 0, SEEK_CUR) != 0)
+ {
+ int pos = lseek(fd, 0, SEEK_CUR);
+ printf("%d: lseek() returned different position, pos %d\n", __LINE__,
+ pos);
+ result = 1;
+ }
+ else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: fread() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+ {
+ printf("%d: content after fseek(,,SEEK_SET) wrong\n", __LINE__);
+ result = 1;
+ }
+
+ /* Now with fseeko. */
+ if (fseeko(fp, 0, SEEK_SET) != 0)
+ {
+ printf("%d: fseeko(fp, 0, SEEK_SET) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fflush(fp) != 0)
+ {
+ printf("%d: fflush() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (lseek(fd, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: lseek() returned different position\n", __LINE__);
+ result = 1;
+ }
+ else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: fread() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+ {
+ printf("%d: content after fseeko(,,SEEK_SET) wrong\n", __LINE__);
+ result = 1;
+ }
+
+ /* Go back to the beginning of the file: relative. */
+ if (fseek(fp, -((int) sizeof(outstr) - 1), SEEK_CUR) != 0)
+ {
+ printf("%d: fseek(fp, 0, SEEK_SET) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fflush(fp) != 0)
+ {
+ printf("%d: fflush() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (lseek(fd, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: lseek() returned different position\n", __LINE__);
+ result = 1;
+ }
+ else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: fread() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+ {
+ printf("%d: content after fseek(,,SEEK_SET) wrong\n", __LINE__);
+ result = 1;
+ }
+
+ /* Now with fseeko. */
+ if (fseeko(fp, -((int) sizeof(outstr) - 1), SEEK_CUR) != 0)
+ {
+ printf("%d: fseeko(fp, 0, SEEK_SET) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fflush(fp) != 0)
+ {
+ printf("%d: fflush() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (lseek(fd, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: lseek() returned different position\n", __LINE__);
+ result = 1;
+ }
+ else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: fread() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+ {
+ printf("%d: content after fseeko(,,SEEK_SET) wrong\n", __LINE__);
+ result = 1;
+ }
+
+ /* Go back to the beginning of the file: from the end. */
+ if (fseek(fp, -((int) sizeof(outstr) - 1), SEEK_END) != 0)
+ {
+ printf("%d: fseek(fp, 0, SEEK_SET) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fflush(fp) != 0)
+ {
+ printf("%d: fflush() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (lseek(fd, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: lseek() returned different position\n", __LINE__);
+ result = 1;
+ }
+ else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: fread() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+ {
+ printf("%d: content after fseek(,,SEEK_SET) wrong\n", __LINE__);
+ result = 1;
+ }
+
+ /* Now with fseeko. */
+ if (fseeko(fp, -((int) sizeof(outstr) - 1), SEEK_END) != 0)
+ {
+ printf("%d: fseeko(fp, 0, SEEK_SET) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fflush(fp) != 0)
+ {
+ printf("%d: fflush() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (lseek(fd, 0, SEEK_CUR) != 0)
+ {
+ printf("%d: lseek() returned different position\n", __LINE__);
+ result = 1;
+ }
+ else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: fread() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+ {
+ printf("%d: content after fseeko(,,SEEK_SET) wrong\n", __LINE__);
+ result = 1;
+ }
+
+ if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: write error 2\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+
+ if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: write error 3\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+
+ if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: write error 4\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+
+ if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+ {
+ printf("%d: write error 5\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+
+ if (fputc('1', fp) == EOF || fputc('2', fp) == EOF)
+ {
+ printf("%d: cannot add characters at the end\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+
+ /* Check the access time. */
+ if (fstat(fd, &st1) < 0)
+ {
+ printf("%d: fstat64() before fseeko() failed\n\n", __LINE__);
+ result = 1;
+ }
+ else
+ {
+ sleep(1);
+
+ if (fseek(fp, -(2 + 2 * (sizeof(outstr) - 1)), SEEK_CUR) != 0)
+ {
+ printf("%d: fseek() after write characters failed\n", __LINE__);
+ result = 1;
+ goto out;
+ }
+ else
+ {
+
+ time_t t;
+ /* Make sure the timestamp actually can be different. */
+ sleep(1);
+ t = time(NULL);
+
+ if (fstat(fd, &st2) < 0)
+ {
+ printf("%d: fstat64() after fseeko() failed\n\n", __LINE__);
+ result = 1;
+ }
+ if (st1.st_ctime >= t)
+ {
+ printf("%d: st_ctime not updated\n", __LINE__);
+ result = 1;
+ }
+ if (st1.st_mtime >= t)
+ {
+ printf("%d: st_mtime not updated\n", __LINE__);
+ result = 1;
+ }
+ if (st1.st_ctime >= st2.st_ctime)
+ {
+ printf("%d: st_ctime not changed\n", __LINE__);
+ result = 1;
+ }
+ if (st1.st_mtime >= st2.st_mtime)
+ {
+ printf("%d: st_mtime not changed\n", __LINE__);
+ result = 1;
+ }
+ }
+ }
+
+ if (fread(buf, 1, 2 + 2 * (sizeof(outstr) - 1), fp) != 2 + 2
+ * (sizeof(outstr) - 1))
+ {
+ printf("%d: reading 2 records plus bits failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0 || memcmp(
+ &buf[sizeof(outstr) - 1], outstr, sizeof(outstr) - 1) != 0 || buf[2
+ * (sizeof(outstr) - 1)] != '1' || buf[2 * (sizeof(outstr) - 1) + 1]
+ != '2')
+ {
+ printf("%d: reading records failed\n", __LINE__);
+ result = 1;
+ }
+ else if (ungetc('9', fp) == EOF)
+ {
+ printf("%d: ungetc() failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fseek(fp, -(2 + 2 * (sizeof(outstr) - 1)), SEEK_END) != 0)
+ {
+ printf("%d: fseek after ungetc failed\n", __LINE__);
+ result = 1;
+ }
+ else if (fread(buf, 1, 2 + 2 * (sizeof(outstr) - 1), fp) != 2 + 2
+ * (sizeof(outstr) - 1))
+ {
+ printf("%d: reading 2 records plus bits failed\n", __LINE__);
+ result = 1;
+ }
+ else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0 || memcmp(
+ &buf[sizeof(outstr) - 1], outstr, sizeof(outstr) - 1) != 0 || buf[2
+ * (sizeof(outstr) - 1)] != '1')
+ {
+ printf("%d: reading records for the second time failed\n", __LINE__);
+ result = 1;
+ }
+ else if (buf[2 * (sizeof(outstr) - 1) + 1] == '9')
+ {
+ printf("%d: unget character not ignored\n", __LINE__);
+ result = 1;
+ }
+ else if (buf[2 * (sizeof(outstr) - 1) + 1] != '2')
+ {
+ printf("%d: unget somehow changed character\n", __LINE__);
+ result = 1;
+ }
+
+ fclose(fp);
+
+ fp = fopen(fname, "r");
+ if (fp == NULL)
+ {
+ printf("%d: fopen() failed\n\n", __LINE__);
+ result = 1;
+ }
+ else if (fstat(fileno(fp), &st1) < 0)
+ {
+ printf("%d: fstat64() before fseeko() failed\n\n", __LINE__);
+ result = 1;
+ }
+ else if (fseeko(fp, 0, SEEK_END) != 0)
+ {
+ printf("%d: fseeko(fp, 0, SEEK_END) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (ftello(fp) != st1.st_size)
+ {
+ printf("%d: fstat64 st_size %zd ftello %zd\n", __LINE__,
+ (size_t) st1.st_size, (size_t) ftello(fp));
+ result = 1;
+ }
+ else
+ printf("%d: SEEK_END works\n", __LINE__);
+ if (fp != NULL)
+ fclose(fp);
+
+ fp = fopen(fname, "r");
+ if (fp == NULL)
+ {
+ printf("%d: fopen() failed\n\n", __LINE__);
+ result = 1;
+ }
+ else if (fstat(fileno(fp), &st1) < 0)
+ {
+ printf("%d: fstat64() before fgetc() failed\n\n", __LINE__);
+ result = 1;
+ }
+ else if (fgetc(fp) == EOF)
+ {
+ printf("%d: fgetc() before fseeko() failed\n\n", __LINE__);
+ result = 1;
+ }
+ else if (fseeko(fp, 0, SEEK_END) != 0)
+ {
+ printf("%d: fseeko(fp, 0, SEEK_END) failed\n", __LINE__);
+ result = 1;
+ }
+ else if (ftello(fp) != st1.st_size)
+ {
+ printf("%d: fstat64 st_size %zd ftello %zd\n", __LINE__,
+ (size_t) st1.st_size, (size_t) ftello(fp));
+ result = 1;
+ }
+ else
+ printf("%d: SEEK_END works\n", __LINE__);
+ if (fp != NULL)
+ fclose(fp);
+
+ out: unlink(fname);
+
+ return result;
+}
+FINSH_FUNCTION_EXPORT(libc_fseek, lseek test for libc);
diff --git a/examples/libc/memory.c b/examples/libc/memory.c
new file mode 100644
index 0000000000..0a0bfecd80
--- /dev/null
+++ b/examples/libc/memory.c
@@ -0,0 +1,54 @@
+/*
+ * memory.c
+ *
+ * Created on: 2010-11-17
+ * Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+#include <errno.h>
+
+static int errors = 0;
+static void merror(const char *msg)
+{
+ ++errors;
+ printf("Error: %s\n", msg);
+}
+
+int libc_mem(void)
+{
+ void *p;
+ int save;
+
+ errno = 0;
+
+ p = malloc(-1);
+ save = errno;
+
+ if (p != NULL)
+ merror("malloc (-1) succeeded.");
+
+ if (p == NULL && save != ENOMEM)
+ merror("errno is not set correctly");
+
+ p = malloc(10);
+ if (p == NULL)
+ merror("malloc (10) failed.");
+
+ /* realloc (p, 0) == free (p). */
+ p = realloc(p, 0);
+ if (p != NULL)
+ merror("realloc (p, 0) failed.");
+
+ p = malloc(0);
+ if (p == NULL)
+ merror("malloc (0) failed.");
+
+ p = realloc(p, 0);
+ if (p != NULL)
+ merror("realloc (p, 0) failed.");
+
+ return errors != 0;
+}
+FINSH_FUNCTION_EXPORT(libc_mem, memory test for libc);
diff --git a/examples/libc/printf.c b/examples/libc/printf.c
new file mode 100644
index 0000000000..12435731b7
--- /dev/null
+++ b/examples/libc/printf.c
@@ -0,0 +1,200 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/fcntl.h>
+
+#include <finsh.h>
+
+char * format[] = {
+ "%",
+ "%0.",
+ "%.0",
+ "%+0.",
+ "%+.0",
+ "%.5",
+ "%+.5",
+ "%2.5",
+ "%22.5",
+ "%022.5",
+ "%#022.5",
+ "%-#022.5",
+ "%+#022.5",
+ "%-22.5",
+ "%+22.5",
+ "%--22.5",
+ "%++22.5",
+ "%+-22.5",
+ "%-+22.5",
+ "%-#022.5",
+ "%-#22.5",
+ "%-2.22",
+ "%+2.22",
+ "%-#02.22",
+ "%-#2.22",
+ "%-1.5",
+ "%1.5",
+ "%-#01.5",
+ "%-#1.5",
+ "%-#.5",
+ "%-#1.",
+ "%-#.",
+ NULL
+};
+
+
+static void
+intchk (const char *fmt)
+{
+ (void) printf("%15s :, \"", fmt);
+ (void) printf(fmt, 0);
+ (void) printf("\", \"");
+ (void) printf(fmt, 123);
+ (void) printf("\", \"");
+ (void) printf(fmt, -18);
+ (void) printf("\"\n");
+}
+
+static void
+fltchk (const char *fmt)
+{
+ (void) printf("%15s :, \"", fmt);
+ (void) printf(fmt, 0.0);
+ (void) printf("\", \"");
+ (void) printf(fmt, 123.0001);
+ (void) printf("\", \"");
+ (void) printf(fmt, -18.0002301);
+ (void) printf("\"\n");
+}
+
+
+int printf_test()
+{
+ char buf[256];
+ int i;
+
+ printf("%s\n\n", "# vim:syntax=off:");
+
+ /* integers */
+ for(i=0;format[i];i++) {
+ strcpy(buf, format[i]);
+ strcat(buf, "d");
+ intchk(buf);
+ }
+
+ /* floats */
+ for(i=0;format[i];i++) {
+ strcpy(buf, format[i]);
+ strcat(buf, "f");
+ fltchk(buf);
+ }
+ /* hexa */
+ for(i=0;format[i];i++) {
+ strcpy(buf, format[i]);
+ strcat(buf, "x");
+ intchk(buf);
+ }
+
+ printf("#%.4x %4x#\n", 4, 88);
+ printf("#%4x#\n",4);
+ printf("#%#22.8x#\n",1234567);
+
+ printf("#%+2i#\n",18);
+ printf("#%i#\n",18);
+ printf("#%llu#\n",4294967297ULL);
+ printf("#%#x#\n",44444);
+ printf("#%-8i#\n",33);
+ printf("#%i#\n",18);
+ printf("#%d#\n",18);
+ printf("#%u#\n",18);
+ printf("#%lu#\n",18);
+ printf("#%li#\n",18);
+ printf("#%-+#06d#\n", -123);
+ printf("#%-+#6d#\n", -123);
+ printf("#%+#06d#\n", -123);
+ printf("#%06d#\n", -123);
+ printf("#%+15s#\n","ABCDEF");
+ /* from ncurses make_keys */
+ printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 16, 16, "KEY_A1", "key_a1");
+ printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 16, 2, "KEY_A1", "key_a1");
+ printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 2, 16, "KEY_A1", "key_a1");
+ printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 16, 0, "KEY_A1", "key_a1");
+ printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 0, 16, "KEY_A1", "key_a1");
+ printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 0, 0, "KEY_A1", "key_a1");
+ printf("{ %4d, %*.*s },\t/* %s */\n", 139, 16, 16, "KEY_A1", "key_a1");
+ printf("{ %4d, %*.*s },\t/* %s */\n", 139, 16, 2, "KEY_A1", "key_a1");
+ printf("{ %4d, %*.*s },\t/* %s */\n", 139, 2, 16, "KEY_A1", "key_a1");
+ printf("{ %4d, %*.*s },\t/* %s */\n", 139, 16, 0, "KEY_A1", "key_a1");
+ printf("{ %4d, %*.*s },\t/* %s */\n", 139, 0, 16, "KEY_A1", "key_a1");
+ printf("{ %4d, %*.*s },\t/* %s */\n", 139, 0, 0, "KEY_A1", "key_a1");
+ printf("%*.*f\n", 0, 16, 0.0);
+ printf("%*.*f\n", 16, 16, 0.0);
+ printf("%*.*f\n", 2, 2, -0.0);
+ printf("%*.*f\n", 20, 0, -123.123);
+ printf("%*.*f\n", 10, 0, +123.123);
+
+
+ i = printf("\"%s\"\n","A");
+ printf("%i\n", i);
+ /* from glibc's tst-printf.c */
+
+ {
+ char buf[20];
+ char buf2[512];
+ int i;
+
+ printf ("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n",
+ snprintf (buf, sizeof (buf), "%30s", "foo"), (int) sizeof (buf),
+ buf);
+ memset(buf2,0,sizeof(buf));
+ i=snprintf(buf2, 256, "%.9999u", 10);
+ printf("%i %i\n",i,strlen(buf2));
+
+ printf ("snprintf (\"%%.999999u\", 10) == %d\n",
+ snprintf(buf2, sizeof(buf2), "%.999999u", 10));
+ }
+ return 0;
+}
+
+void libc_printf()
+{
+ printf("stdout test!!\n");
+ fprintf(stdout, "fprintf test!!\n");
+ fprintf(stderr, "fprintf test!!\n");
+ puts("puts test!!\n");
+
+ putc('1', stderr);
+ putc('2', stderr);
+ putc('\n', stderr);
+
+ printf_test();
+}
+FINSH_FUNCTION_EXPORT(libc_printf, printf test in libc);
+
+
+void libc_dprintf()
+{
+ int fd;
+
+ fd = open("/dev/console", O_WRONLY, 0);
+ if (fd >0)
+ {
+ dprintf(fd, "fd:%d printf test!!\n", fd);
+ close(fd);
+ }
+}
+FINSH_FUNCTION_EXPORT(libc_dprintf, dprintf test);
+
+
+void libc_fdopen()
+{
+ int fd;
+ FILE* fp;
+
+ fd = open("/dev/console", O_WRONLY, 0);
+ if (fd >0)
+ {
+ fp = fdopen(fd, "w");
+ fprintf(fp, "fdopen test, fd %d!!\n", fileno(fp));
+ fclose(fp);
+ }
+}
+FINSH_FUNCTION_EXPORT(libc_fdopen, fdopen test);
diff --git a/examples/libc/rand.c b/examples/libc/rand.c
new file mode 100644
index 0000000000..ca74353adc
--- /dev/null
+++ b/examples/libc/rand.c
@@ -0,0 +1,43 @@
+/*
+ * rand.c
+ *
+ * Created on: 2010-11-17
+ * Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+int libc_rand(void)
+{
+ int i1, i2;
+ int j1, j2;
+
+ /* The C standard says that "If rand is called before any calls to
+ srand have been made, the same sequence shall be generated as
+ when srand is first called with a seed value of 1." */
+ i1 = rand();
+ i2 = rand();
+ srand(1);
+ j1 = rand();
+ j2 = rand();
+ if (i1 < 0 || i2 < 0 || j1 < 0 || j2 < 0)
+ {
+ puts("Test FAILED!");
+ }
+ if (j1 == i1 && j2 == i2)
+ {
+ puts("Test succeeded.");
+ return 0;
+ }
+ else
+ {
+ if (j1 != i1)
+ printf("%d != %d\n", j1, i1);
+ if (j2 != i2)
+ printf("%d != %d\n", j2, i2);
+ puts("Test FAILED!");
+ return 1;
+ }
+}
+FINSH_FUNCTION_EXPORT(libc_rand, rand test for libc);
diff --git a/examples/libc/time.c b/examples/libc/time.c
new file mode 100644
index 0000000000..cbe5773ec0
--- /dev/null
+++ b/examples/libc/time.c
@@ -0,0 +1,24 @@
+/*
+ * time.c
+ *
+ * Created on: 2010-11-17
+ * Author: bernard
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+int speed()
+{
+ int i;
+ time_t t;
+
+ printf("%d\n", time(0));
+ for (i = 0; i < 10000000; ++i)
+ t = time(0);
+
+ printf("%d\n", time(0));
+ return 0;
+}
+FINSH_FUNCTION_EXPORT(speed, speed test);
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 14:59:02 +0000