CHDK_DE Vorschauversion  Trunk Rev. 5544
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
Datenstrukturen | Makrodefinitionen | Typdefinitionen | Funktionen | Variablen
stdlib.h-Dateireferenz
#include "versions.h"
+ Include-Abhängigkeitsdiagramm für stdlib.h:
+ Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  chdkColor
 
struct  confColor
 
struct  stat
 
struct  FILE_S
 
struct  dirent
 
struct  DIR
 
struct  tm
 
struct  utimbuf
 
struct  exmem_alloc_info
 

Makrodefinitionen

#define MAKE_COLOR(bg, fg)   ((twoColors)(((color)(bg) << 8) | (color)(fg)))
 
#define FG_COLOR(c)   ((color)(c ))
 
#define BG_COLOR(c)   ((color)(c >> 8))
 
#define NULL   ((void*)0)
 
#define SEEK_SET   0
 
#define SEEK_CUR   1
 
#define SEEK_END   2
 
#define O_RDONLY   0
 
#define O_WRONLY   1
 
#define O_RDWR   2
 
#define O_APPEND   8
 
#define O_TRUNC   0x200
 
#define O_CREAT   0x100
 
#define atoi(n)   strtol((n),NULL,0)
 
#define errno   (errnoOfTaskGet(0))
 
#define DOS_ATTR_RDONLY   0x01 /* read-only file */
 
#define DOS_ATTR_HIDDEN   0x02 /* hidden file */
 
#define DOS_ATTR_SYSTEM   0x04 /* system file */
 
#define DOS_ATTR_VOL_LABEL   0x08 /* volume label (not a file) */
 
#define DOS_ATTR_DIRECTORY   0x10 /* entry is a sub-directory */
 
#define DOS_ATTR_ARCHIVE   0x20 /* file subject to archiving */
 
#define OPENDIR_FL_NONE   0x0
 
#define OPENDIR_FL_CHDK_LFN   0x1
 

Typdefinitionen

typedef int coord
 
typedef unsigned char color
 
typedef unsigned short twoColors
 
typedef struct FILE_S FILE
 
typedef unsigned long time_t
 

Funktionen

int rand (void)
 
void * srand (unsigned int seed)
 
void qsort (void *__base, int __nelem, int __size, int(*__cmp)(const void *__e1, const void *__e2))
 
int isdigit (int c)
 
int isspace (int c)
 
int isalpha (int c)
 
int isupper (int c)
 
int islower (int c)
 
int ispunct (int c)
 
int isxdigit (int c)
 
int iscntrl (int c)
 
int isalnum (int c)
 
long sprintf (char *s, const char *st,...)
 
long strlen (const char *s)
 
int strcmp (const char *s1, const char *s2)
 
int strncmp (const char *s1, const char *s2, long n)
 
char * strchr (const char *s, int c)
 
char * strcpy (char *dest, const char *src)
 
char * strncpy (char *dest, const char *src, long n)
 
char * strcat (char *dest, const char *app)
 
char * strrchr (const char *s, int c)
 
char * strpbrk (const char *s, const char *accept)
 
char * strstr (const char *s, const char *s2)
 
long strtol (const char *nptr, char **endptr, int base)
 
unsigned long strtoul (const char *nptr, char **endptr, int base)
 
int tolower (int c)
 
int toupper (int c)
 
void * malloc (long size)
 
void free (void *p)
 
void * umalloc (long size)
 
void ufree (void *p)
 
void * memcpy (void *dest, const void *src, long n)
 
void * memset (void *s, int c, int n)
 
int memcmp (const void *s1, const void *s2, long n)
 
void * memchr (const void *s, int c, int n)
 
void SleepTask (long msec)
 
long taskLock ()
 
long taskUnlock ()
 
int creat (const char *name, int flags)
 
int open (const char *name, int flags, int mode)
 
int close (int fd)
 
int write (int fd, const void *buffer, long nbytes)
 
int read (int fd, void *buffer, long nbytes)
 
int lseek (int fd, long offset, int whence)
 
long mkdir (const char *dirname)
 
long mkdir_if_not_exist (const char *dirname)
 
int rename (const char *oldname, const char *newname)
 
int chdir (char *pathname)
 
int remove (const char *name)
 
int stat (const char *name, struct stat *pStat)
 
unsigned char SetFileAttributes (const char *fn, unsigned char attr)
 
FILE * fopen (const char *filename, const char *mode)
 
long fclose (FILE *f)
 
long fread (void *buf, long elsize, long count, FILE *f)
 
long fwrite (const void *buf, long elsize, long count, FILE *f)
 
long fseek (FILE *file, long offset, long whence)
 
long fflush (FILE *file)
 
long feof (FILE *file)
 
long ftell (FILE *file)
 
char * fgets (char *buf, int n, FILE *f)
 
void msleep (long msec)
 
long task_lock ()
 
long task_unlock ()
 
const char * task_name (int id)
 
int task_id_list_get (int *idlist, int size)
 
const char * strerror (int num)
 
int errnoOfTaskGet (int tid)
 
DIR * opendir (const char *name)
 
DIR * opendir_chdk (const char *name, unsigned flags)
 
struct dirent * readdir (DIR *)
 
int closedir (DIR *)
 
struct tm * localtime (const time_t *_tod)
 
struct tm * get_localtime ()
 
int utime (const char *file, struct utimbuf *newTimes)
 
unsigned long time (unsigned long *timer)
 
long strftime (char *s, unsigned long maxsize, const char *format, const struct tm *timp)
 
time_t mktime (struct tm *timp)
 
int abs (int v)
 
void DebugAssert (char *, int)
 
int CreateBinarySemaphore (char *name, int init)
 
int TakeSemaphore (int sem, int timeout)
 
void GiveSemaphore (int sem)
 
char * get_exmem_type_name (unsigned int type)
 
int get_exmem_type_status (unsigned int type, exmem_alloc_info *allocinf)
 
void * exmem_alloc_uncached (unsigned int type, unsigned int size, exmem_alloc_info *allocinf)
 
void exmem_free_uncached (unsigned int type)
 

Variablen

unsigned int exmem_type_count
 

Makro-Dokumentation

#define atoi (   n)    strtol((n),NULL,0)

Definiert in Zeile 95 der Datei stdlib.h.

#define BG_COLOR (   c)    ((color)(c >> 8))

Definiert in Zeile 34 der Datei stdlib.h.

#define DOS_ATTR_ARCHIVE   0x20 /* file subject to archiving */

Definiert in Zeile 172 der Datei stdlib.h.

#define DOS_ATTR_DIRECTORY   0x10 /* entry is a sub-directory */

Definiert in Zeile 171 der Datei stdlib.h.

#define DOS_ATTR_HIDDEN   0x02 /* hidden file */

Definiert in Zeile 168 der Datei stdlib.h.

#define DOS_ATTR_RDONLY   0x01 /* read-only file */

Definiert in Zeile 167 der Datei stdlib.h.

#define DOS_ATTR_SYSTEM   0x04 /* system file */

Definiert in Zeile 169 der Datei stdlib.h.

#define DOS_ATTR_VOL_LABEL   0x08 /* volume label (not a file) */

Definiert in Zeile 170 der Datei stdlib.h.

#define errno   (errnoOfTaskGet(0))

Definiert in Zeile 163 der Datei stdlib.h.

#define FG_COLOR (   c)    ((color)(c ))

Definiert in Zeile 33 der Datei stdlib.h.

#define MAKE_COLOR (   bg,
  fg 
)    ((twoColors)(((color)(bg) << 8) | (color)(fg)))

Definiert in Zeile 32 der Datei stdlib.h.

#define NULL   ((void*)0)

Definiert in Zeile 38 der Datei stdlib.h.

#define O_APPEND   8

Definiert in Zeile 47 der Datei stdlib.h.

#define O_CREAT   0x100

Definiert in Zeile 52 der Datei stdlib.h.

#define O_RDONLY   0

Definiert in Zeile 44 der Datei stdlib.h.

#define O_RDWR   2

Definiert in Zeile 46 der Datei stdlib.h.

#define O_TRUNC   0x200

Definiert in Zeile 51 der Datei stdlib.h.

#define O_WRONLY   1

Definiert in Zeile 45 der Datei stdlib.h.

#define OPENDIR_FL_CHDK_LFN   0x1

Definiert in Zeile 193 der Datei stdlib.h.

#define OPENDIR_FL_NONE   0x0

Definiert in Zeile 192 der Datei stdlib.h.

#define SEEK_CUR   1

Definiert in Zeile 41 der Datei stdlib.h.

#define SEEK_END   2

Definiert in Zeile 42 der Datei stdlib.h.

#define SEEK_SET   0

Definiert in Zeile 40 der Datei stdlib.h.

Dokumentation der benutzerdefinierten Typen

typedef unsigned char color

Definiert in Zeile 29 der Datei stdlib.h.

typedef int coord

Definiert in Zeile 28 der Datei stdlib.h.

typedef struct FILE_S FILE
typedef unsigned long time_t

Definiert in Zeile 217 der Datei stdlib.h.

typedef unsigned short twoColors

Definiert in Zeile 30 der Datei stdlib.h.

Dokumentation der Funktionen

int abs ( int  v)
int chdir ( char *  pathname)
int close ( int  fd)

Definiert in Zeile 477 der Datei wrappers.c.

478 {
479 #if defined(OPT_FILEIO_STATS)
480  camera_info.fileio_stats.close_count++;
481 #endif
482  if (fd == -1)
483  {
484 #if defined(OPT_FILEIO_STATS)
485  camera_info.fileio_stats.close_badfile_count++;
486 #endif
487  return -1;
488  }
489  int haveSemaphore = takeFileIOSemaphore();
490  if (!haveSemaphore)
491 #if defined(CAM_IS_VID_REC_WORKS)
492  if (!conf.allow_unsafe_io)
493 #endif
494  return -1;
495  int r = _Close(fd);
496  if (haveSemaphore)
497  _GiveSemaphore(fileio_semaphore);
498 #if defined(OPT_FILEIO_STATS)
499  if (r == -1)
500  camera_info.fileio_stats.close_fail_count++;
501 #endif
502  return r;
503 }
int closedir ( DIR *  )

Definiert in Zeile 116 der Datei lib_thumb.c.

117 {
118  int rv = -1;
119  if (d && d->cam_DIR)
120  {
121 #if defined(CAM_DRYOS)
122  if (d->fw_dir == 0)
123  {
124  rv = CHDKCloseDir(d->cam_DIR);
125  }
126  else
127 #endif
128  rv = fw_closedir(d->cam_DIR);
129 
130  // Mark closed (just in case)
131  d->cam_DIR = 0;
132  // Free allocated memory
133  free(d);
134  }
135  return rv;
136 }
int creat ( const char *  name,
int  flags 
)
int CreateBinarySemaphore ( char *  name,
int  init 
)

Definiert in Zeile 1975 der Datei wrappers.c.

1976 {
1977  extern int _CreateBinarySemaphore(char*, int);
1978  return _CreateBinarySemaphore(name, init);
1979 }
void DebugAssert ( char *  ,
int   
)

Definiert in Zeile 1964 der Datei wrappers.c.

1965 {
1966 #if CAM_3ARG_DebugAssert
1967  extern void _DebugAssert(int, char*, int);
1968  _DebugAssert(0, err, line);
1969 #else
1970  extern void _DebugAssert(char*, int);
1971  _DebugAssert(err, line);
1972 #endif
1973 }
int errnoOfTaskGet ( int  tid)

Definiert in Zeile 834 der Datei wrappers.c.

834  {
835 #if !CAM_DRYOS
836  return _errnoOfTaskGet(tid);
837 #else
838  return 0;
839 #endif
840 }
void* exmem_alloc_uncached ( unsigned int  type,
unsigned int  size,
exmem_alloc_info *  allocinf 
)

Definiert in Zeile 1006 der Datei wrappers.c.

1007 {
1008  return _exmem_ualloc(type, size, allocinf);
1009 }
void exmem_free_uncached ( unsigned int  type)

Definiert in Zeile 1010 der Datei wrappers.c.

1011 {
1012  _exmem_ufree(type);
1013 }
long fclose ( FILE *  f)

Definiert in Zeile 792 der Datei wrappers.c.

792  {
793  return _Fclose_Fut((long)f);
794 }
long feof ( FILE *  file)

Definiert in Zeile 808 der Datei wrappers.c.

808  {
809  return _Feof_Fut((long)file);
810 }
long fflush ( FILE *  file)

Definiert in Zeile 812 der Datei wrappers.c.

812  {
813  return _Fflush_Fut((long)file);
814 }
char* fgets ( char *  buf,
int  n,
FILE *  f 
)

Definiert in Zeile 816 der Datei wrappers.c.

816  {
817  return _Fgets_Fut(buf,n,(int)f);
818 }
FILE* fopen ( const char *  filename,
const char *  mode 
)

Definiert in Zeile 777 der Datei wrappers.c.

777  {
778 #ifdef CAM_DRYOS
779  if(!filename || filename[0]!='A') {
780  return NULL;
781  }
782 #endif
783 
784  // Check fileio semaphore, if not available we are probably recording video
785  if (!takeFileIOSemaphore())
786  return NULL;
787  _GiveSemaphore(fileio_semaphore);
788 
789  return (FILE *)_Fopen_Fut(filename,mode);
790 }
long fread ( void *  buf,
long  elsize,
long  count,
FILE *  f 
)

Definiert in Zeile 796 der Datei wrappers.c.

796  {
797  return _Fread_Fut(buf,elsize,count,(long)f);
798 }
void free ( void *  p)

Definiert in Zeile 299 der Datei memmgmt.c.

300 {
301  extern void canon_free(void *p);
302 
303  if (!chdk_free(&aram_heap,p))
304  if (!chdk_free(&exmem_heap,p))
305  canon_free(p);
306 }
long fseek ( FILE *  file,
long  offset,
long  whence 
)

Definiert in Zeile 804 der Datei wrappers.c.

804  {
805  return _Fseek_Fut((long)file,offset,whence);
806 }
long ftell ( FILE *  file)

Definiert in Zeile 381 der Datei main.c.

381  {
382  if(!file) return -1;
383  return file->pos;
384 }
long fwrite ( const void *  buf,
long  elsize,
long  count,
FILE *  f 
)

Definiert in Zeile 800 der Datei wrappers.c.

800  {
801  return _Fwrite_Fut(buf,elsize,count,(long)f);
802 }
char* get_exmem_type_name ( unsigned int  type)

Definiert in Zeile 313 der Datei memmgmt.c.

314 {
315  extern char* exmem_types_table[];
316 
317  if (type<exmem_type_count) {
318  return exmem_types_table[type];
319  }
320  return 0;
321 }
int get_exmem_type_status ( unsigned int  type,
exmem_alloc_info *  allocinf 
)

Definiert in Zeile 325 der Datei memmgmt.c.

326 {
327  extern exmem_alloc_info exmem_alloc_table[];
328  if (type<exmem_type_count && allocinf) {
329  allocinf->addr = exmem_alloc_table[type].addr;
330  allocinf->len = exmem_alloc_table[type].len;
331  return 1;
332  }
333  return 0;
334 }
struct tm* get_localtime ( )

Definiert in Zeile 224 der Datei lib_thumb.c.

225 {
226  time_t t = time(NULL);
227  return localtime(&t);
228 }
void GiveSemaphore ( int  sem)

Definiert in Zeile 1986 der Datei wrappers.c.

1987 {
1988  _GiveSemaphore(sem);
1989 }
int isalnum ( int  c)

Definiert in Zeile 175 der Datei lib_thumb.c.

175 { return (isdigit(c) || isalpha(c)); }
int isalpha ( int  c)

Definiert in Zeile 15 der Datei issmth.c.

16 {
17  return (c>='A' && c<='Z') || (c>='a' && c<='z');
18 }
int iscntrl ( int  c)

Definiert in Zeile 171 der Datei lib_thumb.c.

171 { return ((c >=0 && c <32) || c == 127); }
int isdigit ( int  c)

Definiert in Zeile 3 der Datei issmth.c.

4 {
5  return (c>='0') && (c<='9');
6 }
int islower ( int  c)

Definiert in Zeile 28 der Datei wrappers.c.

28 { return _islower(c); }
int ispunct ( int  c)

Definiert in Zeile 29 der Datei wrappers.c.

29 { return _ispunct(c); }
int isspace ( int  c)

Definiert in Zeile 8 der Datei issmth.c.

9 {
10  if ((c >= '\t') && (c <= '\r')) return 1;
11  if (c == ' ') return 1;
12  return 0;
13 }
int isupper ( int  c)

Definiert in Zeile 20 der Datei issmth.c.

21 {
22  return (c>='A' && c<='Z');
23 }
int isxdigit ( int  c)

Definiert in Zeile 30 der Datei wrappers.c.

30 { return _isxdigit(c); }
struct tm* localtime ( const time_t *  _tod)

Definiert in Zeile 951 der Datei wrappers.c.

951  {
952 #if !CAM_DRYOS
953  return _localtime(_tod);
954 #else
955  // for DRYOS cameras do something with this! - sizeof(x[]) must be >= sizeof(struct tm) : 'static int x[9];'
956  static int x[10];
957  return _LocalTime(_tod, &x);
958 #endif
959 }
int lseek ( int  fd,
long  offset,
int  whence 
)

Definiert in Zeile 531 der Datei wrappers.c.

532 {
533  return _lseek(fd, offset, whence); /* yes, it's lower-case lseek here since Lseek calls just lseek (A610) */
534 }
void* malloc ( long  size)

Definiert in Zeile 284 der Datei memmgmt.c.

285 {
286  extern void *canon_malloc(long size);
287 
288  void *p = chdk_malloc(&aram_heap,size);
289 
290  if (p == 0)
291  p = chdk_malloc(&exmem_heap,size);
292 
293  if (p == 0)
294  p = canon_malloc(size);
295 
296  return p;
297 }
void* memchr ( const void *  s,
int  c,
int  n 
)

Definiert in Zeile 1080 der Datei wrappers.c.

1080  {
1081  return _memchr(s,c,n);
1082 }
int memcmp ( const void *  s1,
const void *  s2,
long  n 
)

Definiert in Zeile 19 der Datei memcmp.c.

20 {
21  register const unsigned char *s1 = (const unsigned char*)str1;
22  register const unsigned char *s2 = (const unsigned char*)str2;
23 
24  while (count-- > 0)
25  {
26  if (*s1++ != *s2++)
27  return s1[-1] < s2[-1] ? -1 : 1;
28  }
29  return 0;
30 }
void* memcpy ( void *  dest,
const void *  src,
long  n 
)

Definiert in Zeile 18 der Datei memcpy.c.

19 {
20  return memmove(out, in, length);
21 }
void* memset ( void *  s,
int  c,
int  n 
)

Definiert in Zeile 1071 der Datei wrappers.c.

1071  {
1072  return _memset(s, c, n);
1073 }
long mkdir ( const char *  dirname)

Definiert in Zeile 536 der Datei wrappers.c.

537 {
538 #ifdef MKDIR_RETURN_ONE_ON_SUCCESS
539  // mkdir returns 1 on success, 0 on fail. So, values are inverted, to be compatible with previous versions
540  if(_MakeDirectory_Fut(dirname,1)) return 0;
541  else return 1;
542 #else
543  return _MakeDirectory_Fut(dirname,-1); // meaning of second arg is not clear, firmware seems to use -1
544 #endif
545 }
long mkdir_if_not_exist ( const char *  dirname)

Definiert in Zeile 283 der Datei file_shelter.c.

284 {
285  // Check if directory exists and create it if it does not.
286  if (stat(dirname,0) != 0) return mkdir(dirname);
287  return 0; // Success
288 }
time_t mktime ( struct tm *  timp)

Definiert in Zeile 965 der Datei wrappers.c.

965  {
966 #if !CAM_DRYOS
967  return _mktime(timp);
968 #else
969  int timp_ext[10]; // struct tm + a ptr
970  _memcpy(timp_ext,timp,9*sizeof(int));
971  timp_ext[9]=0;
972  long retval = _mktime_ext(&timp_ext);
973  _memcpy(timp,timp_ext,9*sizeof(int));
974  return retval;
975 #endif
976 }
void msleep ( long  msec)

Definiert in Zeile 47 der Datei wrappers.c.

48 {
49  _SleepTask(msec);
50 }
int open ( const char *  name,
int  flags,
int  mode 
)

Definiert in Zeile 448 der Datei wrappers.c.

449 {
450 #if defined(OPT_FILEIO_STATS)
451  camera_info.fileio_stats.open_count++;
452 #endif
453 #if !CAM_DRYOS
454  // Adjust O_TRUNC and O_CREAT flags for VxWorks
455  // Remove O_APPEND flag if present (not in VxWorks)
456  flags = (flags & ~(O_TRUNC|O_CREAT|O_APPEND)) | ((flags & (O_TRUNC|O_CREAT)) << 1);
457 #else
458  if(!name || name[0]!='A')
459  return -1;
460 #endif
461  int haveSemaphore = takeFileIOSemaphore();
462  if (!haveSemaphore)
463 #if defined(CAM_IS_VID_REC_WORKS)
464  if (!conf.allow_unsafe_io)
465 #endif
466  return -1;
467  int fd = _Open(name, flags, mode);
468  if (haveSemaphore)
469  _GiveSemaphore(fileio_semaphore);
470 #if defined(OPT_FILEIO_STATS)
471  if (fd == -1)
472  camera_info.fileio_stats.open_fail_count++;
473 #endif
474  return fd;
475 }
DIR* opendir ( const char *  name)

Definiert in Zeile 18 der Datei lib_thumb.c.

19 {
20  return opendir_chdk(name,OPENDIR_FL_NONE);
21 }
DIR* opendir_chdk ( const char *  name,
unsigned  flags 
)

Definiert in Zeile 23 der Datei lib_thumb.c.

24 {
25  // Create CHDK DIR structure
26  DIR *dir = malloc(sizeof(DIR));
27  // If malloc failed return failure
28  if (dir == 0) return NULL;
29 
30 #if defined(CAM_DRYOS)
31  extern int get_fstype(void);
32  // try built-in routine first, but only on FAT
33  if ((get_fstype() < 4) && (flags & OPENDIR_FL_CHDK_LFN))
34  {
35  dir->fw_dir = 0;
36  dir->cam_DIR = CHDKOpenDir(name);
37  }
38  else
39  {
40  dir->cam_DIR = NULL;
41  }
42  if (!dir->cam_DIR)
43  {
44  // try firmware routine if built-in failed
45  dir->fw_dir = 1;
46  dir->cam_DIR = fw_opendir(name);
47  }
48 #else
49  dir->cam_DIR = fw_opendir(name);
50 #endif
51 
52  // Init readdir return value
53  dir->dir.d_name[0] = 0;
54 
55  // If failed clean up and return failure
56  if (!dir->cam_DIR)
57  {
58  free(dir);
59  return NULL;
60  }
61 
62  return dir;
63 }
void qsort ( void *  __base,
int  __nelem,
int  __size,
int(*)(const void *__e1, const void *__e2)  __cmp 
)

Definiert in Zeile 1153 der Datei wrappers.c.

1153  {
1154  _qsort(__base, __nelem, __size, __cmp);
1155 }
int rand ( void  )

Definiert in Zeile 20 der Datei rnd.c.

20  {
21  if ( seed_val <= quotient )
22  seed_val = (seed_val * 16807L) % LONG_MAX;
23  else {
24  long int high_part = seed_val / quotient;
25  long int low_part = seed_val % quotient;
26 
27  long int test = 16807L * low_part - remainder * high_part;
28 
29  if ( test > 0 )
30  seed_val = test;
31  else
32  seed_val = test + LONG_MAX;
33  }
34 
35  return seed_val;
36 }
int read ( int  fd,
void *  buffer,
long  nbytes 
)

Definiert in Zeile 526 der Datei wrappers.c.

527 {
528  return _Read(fd, buffer, nbytes);
529 }
struct dirent* readdir ( DIR *  )

Definiert in Zeile 73 der Datei lib_thumb.c.

74 {
75  if (d && d->cam_DIR)
76  {
77  // Get next entry from firmware function
78  extern void *fw_readdir(void *d);
79  struct __dirent *de = fw_readdir(d->cam_DIR);
80  // Return next directory name if present, else return 0 (end of list)
81  if (de)
82  {
83  strcpy(d->dir.d_name,de->d_name);
84  return &d->dir;
85  }
86  else
87  {
88  d->dir.d_name[0] = 0;
89  }
90  }
91  return NULL;
92 }
int remove ( const char *  name)

Definiert in Zeile 554 der Datei wrappers.c.

555 {
556 #ifdef CAM_DRYOS_2_3_R39
557  // For DryOS R39 and later need to check if 'name' is a file or directory
558  // and call appropriate delete function.
559  struct stat st;
560  if (stat(name,&st) == 0)
561  {
562  if (st.st_attrib & DOS_ATTR_DIRECTORY)
563  return _DeleteDirectory_Fut(name);
564  else
565  return _DeleteFile_Fut(name);
566  }
567  return -1; // return fail - file / directory does not exist
568 #else
569  return _DeleteFile_Fut(name);
570 #endif
571 }
int rename ( const char *  oldname,
const char *  newname 
)

Definiert in Zeile 820 der Datei wrappers.c.

820  {
821  return _RenameFile_Fut(oldname, newname);
822 }
unsigned char SetFileAttributes ( const char *  fn,
unsigned char  attr 
)

Definiert in Zeile 1753 der Datei wrappers.c.

1754 {
1755 #ifdef CAM_DRYOS_2_3_R39
1756  return _SetFileAttributes(fn, attr);
1757 #else
1758  int fd;
1759  unsigned char ret = -1;
1760 
1761  fd = open(fn, 0, 0);
1762  if( fd ) {
1763  _SetFileAttributes(fd, attr);
1764  close(fd);
1765  ret = attr;
1766  }
1767  return ret;
1768 #endif
1769 }
void SleepTask ( long  msec)
long sprintf ( char *  s,
const char *  st,
  ... 
)

Definiert in Zeile 898 der Datei wrappers.c.

899 {
900  long res;
901  __builtin_va_list va;
902  __builtin_va_start(va, st);
903  res = _vsprintf(s, st, va);
904  __builtin_va_end(va);
905  return res;
906 }
void* srand ( unsigned int  seed)

Definiert in Zeile 1149 der Datei wrappers.c.

1149  {
1150  return _srand(seed);
1151 }
int stat ( const char *  name,
struct stat *  pStat 
)

Definiert in Zeile 751 der Datei wrappers.c.

752 {
753  // sanity check. canon firmware hangup if start not from 'A/'
754  if ( !name || (name[0] | 0x20)!='a' || name[1]!='/' ) return 1;
755 
756  // use temp __stat stucture to match camera firmware
757  // and copy values across to output
758  struct __stat lStat;
759  int rv = _stat(name, &lStat);
760  if (pStat)
761  {
762  if (rv == 0)
763  {
764  pStat->st_attrib = lStat.st_attrib;
765  pStat->st_size = lStat.st_size;
766  pStat->st_ctime = lStat.st_ctime;
767  pStat->st_mtime = lStat.st_mtime;
768  }
769  else
770  {
771  memset( pStat, 0, sizeof(struct stat));
772  }
773  }
774  return rv;
775 }
char* strcat ( char *  dest,
const char *  app 
)

Definiert in Zeile 869 der Datei wrappers.c.

869  {
870  return _strcat(dest, app);
871 }
char* strchr ( const char *  s,
int  c 
)

Definiert in Zeile 857 der Datei wrappers.c.

857  {
858  return _strchr(s, c);
859 }
int strcmp ( const char *  s1,
const char *  s2 
)

Definiert in Zeile 38 der Datei strcmp.c.

39 {
40  while (*s1 != '\0' && *s1 == *s2)
41  {
42  s1++;
43  s2++;
44  }
45 
46  return (*(unsigned char *) s1) - (*(unsigned char *) s2);
47 }
char* strcpy ( char *  dest,
const char *  src 
)

Definiert in Zeile 861 der Datei wrappers.c.

861  {
862  return _strcpy(dest, src);
863 }
const char* strerror ( int  num)

Definiert in Zeile 910 der Datei wrappers.c.

910  {
911 #if !CAM_DRYOS
912  static char msg[20];
913  sprintf(msg,"errno 0x%X",en);
914  return msg;
915 #else
916  return "error";
917 #endif
918 }
long strftime ( char *  s,
unsigned long  maxsize,
const char *  format,
const struct tm *  timp 
)

Definiert in Zeile 961 der Datei wrappers.c.

961  {
962  return _strftime(s,maxsize,format,timp);
963 }
long strlen ( const char *  s)

Definiert in Zeile 34 der Datei strlen.c.

35 {
36  const char *start = str;
37 
38  while (*str)
39  str++;
40 
41  return str - start;
42 }
int strncmp ( const char *  s1,
const char *  s2,
long  n 
)

Definiert in Zeile 853 der Datei wrappers.c.

853  {
854  return _strncmp(s1, s2, n);
855 }
char* strncpy ( char *  dest,
const char *  src,
long  n 
)

Definiert in Zeile 865 der Datei wrappers.c.

865  {
866  return _strncpy(dest, src, n);
867 }
char* strpbrk ( const char *  s,
const char *  accept 
)

Definiert in Zeile 890 der Datei wrappers.c.

891 {
892  return _strpbrk(s, accept);
893 }
char* strrchr ( const char *  s,
int  c 
)

Definiert in Zeile 873 der Datei wrappers.c.

873  {
874  return _strrchr(s, c);
875 }
char* strstr ( const char *  s,
const char *  s2 
)

Definiert in Zeile 196 der Datei lib_thumb.c.

197 {
198  const char *p = s1;
199  const int len = strlen(s2);
200 
201  for (; (p = strchr(p, *s2)) != 0; p++)
202  {
203  if (strncmp(p, s2, len) == 0)
204  return (char*)p;
205  }
206  return (0);
207 }
long strtol ( const char *  nptr,
char **  endptr,
int  base 
)

Definiert in Zeile 877 der Datei wrappers.c.

877  {
878  return _strtol(nptr, endptr, base);
879 }
unsigned long strtoul ( const char *  nptr,
char **  endptr,
int  base 
)

Definiert in Zeile 881 der Datei wrappers.c.

881  {
882 #if CAM_DRYOS
883  return (unsigned long)_strtolx(nptr, endptr, base, 0);
884 #else
885  return _strtoul(nptr, endptr, base);
886 #endif
887 }
int TakeSemaphore ( int  sem,
int  timeout 
)

Definiert in Zeile 1981 der Datei wrappers.c.

1982 {
1983  return _TakeSemaphore(sem, timeout);
1984 }
int task_id_list_get ( int *  idlist,
int  size 
)

Definiert in Zeile 68 der Datei wrappers.c.

69 {
70  return _taskIdListGet(idlist,size);
71 }
long task_lock ( )

Definiert in Zeile 53 der Datei wrappers.c.

54 {
55  return _taskLock();
56 }
const char* task_name ( int  id)

Definiert in Zeile 63 der Datei wrappers.c.

64 {
65  return _taskName(id);
66 }
long task_unlock ( )

Definiert in Zeile 58 der Datei wrappers.c.

59 {
60  return _taskUnlock();
61 }
long taskLock ( )
long taskUnlock ( )
unsigned long time ( unsigned long *  timer)

Definiert in Zeile 923 der Datei wrappers.c.

923  {
924  return _time(timer);
925 }
int tolower ( int  c)

Definiert in Zeile 32 der Datei wrappers.c.

32 { return _tolower(c); }
int toupper ( int  c)

Definiert in Zeile 33 der Datei wrappers.c.

33 { return _toupper(c); }
void ufree ( void *  p)

Definiert in Zeile 1056 der Datei wrappers.c.

1056  {
1057 #if CAM_DRYOS
1058  _FreeUncacheableMemory(p);
1059 #else
1060  if (!_TakeSemaphore(canon_heap_sem,CANON_HEAP_SEM_TIMEOUT)) {
1061  _FreeUncacheableMemory(p);
1062  _GiveSemaphore(canon_heap_sem);
1063  }
1064 #endif
1065 }
void* umalloc ( long  size)

Definiert in Zeile 1042 der Datei wrappers.c.

1042  {
1043 #if CAM_DRYOS
1044  return _AllocateUncacheableMemory(size);
1045 #else
1046  if (_TakeSemaphore(canon_heap_sem,CANON_HEAP_SEM_TIMEOUT)) {
1047  return 0;
1048  } else {
1049  void *r=_AllocateUncacheableMemory(size);
1050  _GiveSemaphore(canon_heap_sem);
1051  return r;
1052  }
1053 #endif
1054 }
int utime ( const char *  file,
struct utimbuf *  newTimes 
)

Definiert in Zeile 927 der Datei wrappers.c.

927  {
928 #if !CAM_DRYOS
929  return _utime(file, newTimes);
930 #else
931  int res=0;
932  int fd;
933  fd = _open(file, 0, 0);
934 
935 #ifdef CAM_DRYOS_2_3_R39
936  if (fd>=0) {
937  _close(fd);
938  res=_SetFileTimeStamp(file, newTimes->modtime, newTimes->actime);
939  }
940 #else
941  if (fd>=0) {
942  res=_SetFileTimeStamp(fd, newTimes->modtime, newTimes->actime);
943  _close(fd);
944  }
945  // return value compatibe with utime: ok=0 fail=-1
946 #endif
947  return (res)?0:-1;
948 #endif
949 }
int write ( int  fd,
const void *  buffer,
long  nbytes 
)

Definiert in Zeile 505 der Datei wrappers.c.

506 {
507  if (fd == -1)
508  {
509 #if defined(OPT_FILEIO_STATS)
510  camera_info.fileio_stats.write_badfile_count++;
511 #endif
512  return -1;
513  }
514  int haveSemaphore = takeFileIOSemaphore();
515  if (!haveSemaphore)
516 #if defined(CAM_IS_VID_REC_WORKS)
517  if (!conf.allow_unsafe_io)
518 #endif
519  return -1;
520  int r = _Write(fd, buffer, nbytes);
521  if (haveSemaphore)
522  _GiveSemaphore(fileio_semaphore);
523  return r;
524 }

Variablen-Dokumentation

unsigned int exmem_type_count