openbcm

Git mirror of https://github.com/Broadcom-Network-Switching-Software/OpenBCM
git clone git://git.finwo.net/mirror/broadcom/openbcm
Log | Files | Refs | README

cint_stubs.c (2746B)

      1 /*
      2  * 
      3  * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
      4  * 
      5  * Copyright 2007-2019 Broadcom Inc. All rights reserved.
      6  *
      7  * File:        cint_stubs.c
      8  * Purpose:     portability stub definitions
      9  */
     10 
     11 #include "cint_stubs.h"
     12 
     13 #if CINT_CONFIG_INCLUDE_STUBS == 1
     14 
     15 #include <stdio.h>
     16 #include <stdlib.h>
     17 #include <string.h>
     18 #include <unistd.h>
     19 
     20 int
     21 cint_stub_printf(const char *format, ...)
     22 {
     23     int rv;
     24 
     25     va_list ap;
     26     va_start(ap, format);
     27     rv = cint_stub_vprintf(format, ap);
     28     va_end(ap);
     29 
     30     return rv;
     31 }
     32 
     33 int
     34 cint_stub_vprintf(const char *format, va_list ap)
     35 {
     36     return vprintf(format, ap);
     37 }
     38 
     39 void *
     40 cint_stub_malloc(size_t size)
     41 {
     42     return malloc(size);
     43 }
     44 
     45 void *
     46 cint_stub_realloc(void *ptr, size_t size)
     47 {
     48     return realloc(ptr, size);
     49 }
     50 
     51 void
     52 cint_stub_free(void *ptr)
     53 {
     54     free(ptr);
     55 }
     56 
     57 char *
     58 cint_stub_strrchr(const char *s, int c)
     59 {
     60     return strrchr(s,c);
     61 }
     62 
     63 int
     64 cint_stub_strcmp(const char *s1, const char *s2)
     65 {
     66     return strcmp(s1, s2);
     67 }
     68 
     69 char *
     70 cint_stub_strstr(const char *s1, const char *s2)
     71 {
     72     return strstr(s1, s2);
     73 }
     74 
     75 void *
     76 cint_stub_memcpy(void *dest, const void *src, size_t n)
     77 {
     78     return memcpy(dest, src, n);
     79 }
     80 
     81 void *
     82 cint_stub_memset(void *s, int c, size_t n)
     83 {
     84     return memset(s, c, n);
     85 }
     86 
     87 int
     88 cint_stub_sprintf(char *str, const char *format, ...)
     89 {
     90     int rv;
     91 
     92     va_list ap;
     93     va_start(ap, format);
     94     rv = vsprintf(str, format, ap);
     95     va_end(ap);
     96 
     97     return rv;
     98 }
     99 
    100 int
    101 cint_stub_snprintf(char *str, size_t size, const char *format, ...)
    102 {
    103     int rv;
    104 
    105     va_list ap;
    106     va_start(ap, format);
    107     rv = cint_stub_vsnprintf(str, size, format, ap);
    108     va_end(ap);
    109 
    110     return rv;
    111 }
    112 
    113 int
    114 cint_stub_vsnprintf(char *str, size_t size,
    115                     const char *format, va_list ap)
    116 {
    117     return vsnprintf(str, size, format, ap);
    118 }
    119 
    120 char *
    121 cint_stub_strcat(char *dest, const char *src)
    122 {
    123     return strcat(dest, src);
    124 }
    125 
    126 char *
    127 cint_stub_strdup(const char *s)
    128 {
    129     return strdup(s);
    130 }
    131 
    132 size_t
    133 cint_stub_strlen(const char *s)
    134 {
    135     return strlen(s);
    136 }
    137 
    138 char *
    139 cint_stub_strncpy(char *dest, const char *src, size_t n)
    140 {
    141     return strncpy(dest, src, n);
    142 }
    143 
    144 void
    145 cint_stub_fatal_error(const char *msg)
    146 {
    147     fputs(msg, stderr);
    148     exit(2);
    149 }
    150 
    151 FILE *
    152 cint_stub_fopen(const char *path, const char *mode)
    153 {
    154     return fopen(path, mode);
    155 }
    156 
    157 int
    158 cint_stub_fclose(FILE *stream)
    159 {
    160     return fclose(stream);
    161 }
    162 
    163 size_t
    164 cint_stub_fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
    165 {
    166     return fread(ptr, size, nmemb, stream);
    167 }
    168 
    169 int
    170 cint_stub_ferror(FILE *stream)
    171 {
    172     return ferror(stream);
    173 }
    174 
    175 int
    176 cint_stub_getc(FILE *stream)
    177 {
    178     return getc(stream);
    179 }
    180 
    181 #endif /* CINT_CONFIG_CINT_STUBS */