p99_new.h

Go to the documentation of this file.

/* This may look like nonsense, but it really is -*- mode: C; coding: utf-8 -*- */
/*                                                                              */
/* Except for parts copied from previous work and as explicitly stated below,   */
/* the authors and copyright holders for this work are as follows:              */
/* (C) copyright  2010-2013 Jens Gustedt, INRIA, France                         */
/* (C) copyright  2012 William Morris                                           */
/*                                                                              */
/* This file is free software; it is part of the P99 project.                   */
/*                                                                              */
/* Licensed under the Apache License, Version 2.0 (the "License");              */
/* you may not use this file except in compliance with the License.             */
/* You may obtain a copy of the License at                                      */
/*                                                                              */
/*     http://www.apache.org/licenses/LICENSE-2.0                               */
/*                                                                              */
/* Unless required by applicable law or agreed to in writing, software          */
/* distributed under the License is distributed on an "AS IS" BASIS,            */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.     */
/* See the License for the specific language governing permissions and          */
/* limitations under the License.                                               */
/*                                                                              */
#ifndef     P99_NEW_H_
# define    P99_NEW_H_
 
#include "p99_c99.h"
#include "p99_int.h"
 
P99_MACRO_END(dummy);
 
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_PZERO, 0)
#define P99_PZERO(X, N) (memset((X), 0, sizeof(X[0]) * N))
 
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_TZERO, 0)
#define P99_TZERO(X) (memset(&(X), 0, sizeof(X)))
 
p99_inline
unsigned char
(*p00_memcpy(size_t p00_len, unsigned char (*p00_tar)[p00_len], unsigned char const (*p00_src)[p00_len]))[] {
  memcpy(&(*p00_tar)[0], &(*p00_src)[0], p00_len);
  return p00_tar;
}
 
P00_DOCUMENT_TYPE_ARGUMENT(P99_ASUB, 1)
#define P99_ASUB(X, T, N, L)                                   \
(                                                              \
 (T(*)[L                                                       \
       /* check for validity                                   \
          / !!(L && (sizeof(T[N+L]) < sizeof(*X)))*/])         \
 (P99_LVAL(T*, &((*X)[N])))                                    \
)
 
p99_inline
unsigned char
(*p00_initialize(size_t p00_len, unsigned char (*p00_base)[p00_len], size_t p00_init))[] {
  for (; (p00_init * 2u) <= p00_len; p00_init *= 2u) {
    p00_memcpy(p00_init,
               P99_ASUB(p00_base, unsigned char, p00_init, p00_init),
               P99_ASUB(p00_base, unsigned char const, 0, p00_init));
  }
  if (p00_len > p00_init) {
    p00_len -= p00_init;
    p00_memcpy(p00_len,
               P99_ASUB(p00_base, unsigned char, p00_init, p00_len),
               P99_ASUB(p00_base, unsigned char const, 0, p00_len));
  }
  return p00_base;
}
 
#if ((P99_COMPILER & P99_COMPILER_GNU) && (P99_GCC_VERSION < 40704UL))
# define P00_ABLESS_BUG 1
#endif
 
#if defined(P99_TYPEOF) && !P00_ABLESS_BUG
# define P00_ABLESS(X, ...) ((P99_TYPEOF(__VA_ARGS__)*restrict)(unsigned char(*)[sizeof(__VA_ARGS__)]){ X })
#else
# define P00_ABLESS(X, ...) ((void*restrict)(unsigned char(*)[sizeof(__VA_ARGS__)]){ X })
#endif
 
#define P00_APLAIN(X, N) ((unsigned char(*)[N])(X))
#define P99_APLAIN(...)                                        \
(P99_IF_LT_2(P99_NARG(__VA_ARGS__))                            \
 (P00_APLAIN(__VA_ARGS__, sizeof(*__VA_ARGS__)))               \
 (P00_APLAIN(__VA_ARGS__))                                     \
 )
 
p99_inline
void* p00_memset(void* p00_tar, void const* p00_src, size_t p00_size, size_t p00_nb) {
  p00_initialize(p00_nb * p00_size,
                 P00_APLAIN(memcpy(p00_tar, p00_src, p00_size), p00_size),
                 p00_size);
  return p00_tar;
}
 
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_MEMSET, 1)
#define P99_MEMSET(TA, SO, N) p00_memset((TA), (void const*)&(SO), sizeof(SO), N)
 
P00_DOCUMENT_TYPE_ARGUMENT(P99_MEMZERO, 0)
#define P99_MEMZERO(T, TA, N) p00_memset((TA), (void const*)&P99_LVAL(const T), sizeof(T), N)
 
#define P99_MALLOC(X) malloc(sizeof(X))
 
 
#define P00_VMALLOC(X) P00_ABLESS(P99_MALLOC(X), X)
 
#define P00_INITIALIZE(X, L)                                         \
p00_initialize(sizeof(*X),                                           \
               P00_APLAIN(memcpy((X), (L), sizeof(*L)), sizeof(*X)), \
               sizeof(*L))
 
P00_DOCUMENT_WARN_VLA_ARGUMENT(P99_INITIALIZE, 0)
P00_DOCUMENT_WARN_VLA_ARGUMENT(P99_INITIALIZE, 1)
#define P99_INITIALIZE(X, L) P00_ABLESS(P00_INITIALIZE((X), (L)), *(X))
 
#define P00_ALLOC(X, L)                                                                  \
P00_ABLESS(p00_initialize(sizeof(X),                                                     \
                          P00_APLAIN(memcpy(P99_MALLOC(X), (&L), sizeof(L)), sizeof(X)), \
                          sizeof(L)),                                                    \
           (X))
 
#define P99_ALLOC(...) P99_IF_GT(P99_NARG(__VA_ARGS__), 1)(P00_ALLOC(__VA_ARGS__))(P00_VMALLOC(__VA_ARGS__))
 
#define P99_REALLOC(X, T) realloc((X), sizeof(T))
 
p99_inline
void* p00_calloc(void const* p00_src, size_t p00_size, size_t p00_nb) {
  return p00_memset(malloc(p00_size*p00_nb), p00_src, p00_size, p00_nb);
}
 
#define P00_CALLOC0(T, N) p00_calloc((void const*)&P99_LVAL(const T), sizeof(T), N)
#define P00_CALLOC(...) P00_CALLOC0(__VA_ARGS__)
 
#ifdef P00_DOXYGEN
 
P00_DOCUMENT_TYPE_ARGUMENT(P99_CALLOC, 0)
#define P99_CALLOC(T, N)
#else
P00_DOCUMENT_TYPE_ARGUMENT(P99_CALLOC, 0)
#define P99_CALLOC(...) P00_CALLOC(P99_CALL_DEFARG_LIST(P00_CALLOC, 2, __VA_ARGS__))
#endif
 
#define P00_CALLOC_defarg_1() 1
 
#define P00_NEW(T) P99_PASTE2(T, _init)(P99_MALLOC(T))
 
#define P00_NEW_ARGS(T, ...) P99_PASTE2(T, _init)(P99_MALLOC(T), __VA_ARGS__)
 
 
#define P99_NEW(...) P99_IF_LT(P99_NARG(__VA_ARGS__), 2)(P00_NEW(__VA_ARGS__))(P00_NEW_ARGS(__VA_ARGS__))
 
#ifdef P00_DOXYGEN
 
P00_DOCUMENT_TYPE_ARGUMENT(P99_DECLARE_DELETE, 0)
#define P99_DECLARE_DELETE(T)                                                                             \
                                                            \
 \
                                          \
                                                                                       \
                                                                                         \
  void P99_PASTE2(T, _delete)(T const*p00_el) { }
 
#define P99_DEFINE_DELETE(T) P99_INSTANTIATE(void, P99_PASTE2(T, _delete), T const*)
#else
P00_DOCUMENT_TYPE_ARGUMENT(P99_DECLARE_DELETE, 0)
#define P99_DECLARE_DELETE(...)                                \
P99_IF_LT(P99_NARG(__VA_ARGS__), 2)                            \
(P00_DECLARE_DELETE(__VA_ARGS__, p99_inline))                  \
(P00_DECLARE_DELETE(__VA_ARGS__))                              \
P99_MACRO_END(P99_DECLARE_DELETE)
#define P99_DEFINE_DELETE(...) P00_DEFINE_DELETE(__VA_ARGS__,)
#endif
 
#define P00_DECLARE_DELETE(T, ...)                             \
__VA_ARGS__                                                    \
void P99_PASTE2(T, _delete)(T const*p00_el) {                  \
  if (p00_el) {                                                \
    T* p00_e = (T*)p00_el;                                     \
    P99_PASTE2(T, _destroy)(p00_e);                            \
    free((void*)p00_e);                                        \
  }                                                            \
}
 
#define P00_DEFINE_DELETE(T, ...) P99_INSTANTIATE(void, P99_PASTE2(T, _delete), T const*)
 
P99_CONST_FUNCTION
p99_inline
size_t p99_maxof(size_t p00_m, size_t p00_n) {
  return p00_m < p00_n ? p00_n : p00_m;
}
 
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_MINOF, 0)
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_MINOF, 1)
#define P99_MAXOF(A, B) ((A) < (B) ? (B) : (A))
 
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_MAXOF, 0)
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_MAXOF, 1)
#define P99_MINOF(A, B) ((A) < (B) ? (A) : (B))
 
#define P00_SIZEOF2(T, ...) sizeof(P99_TOKJOIN(., P99_LVAL(const T), __VA_ARGS__))
 
#ifdef P00_DOXYGEN
 
#define P99_SIZEOF(T, F, ...) P99_IF_EQ(P99_NARG(__VA_ARGS__), 1)(sizeof(__VA_ARGS__))(P00_SIZEOF2(__VA_ARGS__))
#else
#define P99_SIZEOF(...) P99_IF_EQ(P99_NARG(__VA_ARGS__), 1)(sizeof(__VA_ARGS__))(P00_SIZEOF2(__VA_ARGS__))
#endif
 
P00_DOCUMENT_TYPE_ARGUMENT(P99_FHEAD, 0)
#define P99_FHEAD(T, F, P) ((T*)(((char*)P) - offsetof(T, F)))
 
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_FSIZEOF, 2)
P00_DOCUMENT_TYPE_ARGUMENT(P99_FSIZEOF, 0)
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_FSIZEOF, 1)
#define P99_FSIZEOF(T, F, N) P99_MAXOF(sizeof(T), offsetof(T, F) + P99_SIZEOF(T, F[0]) * N)
#define P00_FSIZEOF(T, F, M) p99_maxof(sizeof(T), offsetof(T, F) + M)
 
#define P00_FREALLOC(P, T, F, M) realloc(P, P00_FSIZEOF(T, F, M))
 
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_FREALLOC, 3)
P00_DOCUMENT_TYPE_ARGUMENT(P99_FREALLOC, 1)
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_FREALLOC, 2)
#define P99_FREALLOC(P, T, F, N) realloc(P, P99_FSIZEOF(T, F, N))
 
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_FMALLOC, 2)
P00_DOCUMENT_TYPE_ARGUMENT(P99_FMALLOC, 0)
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_FMALLOC, 1)
#define P99_FMALLOC(T, F, N) malloc(P99_FSIZEOF(T, F, N))
#define P00_FMALLOC(T, F, M) malloc(P00_FSIZEOF(T, F, M))
 
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_FCALLOC, 2)
P00_DOCUMENT_TYPE_ARGUMENT(P99_FCALLOC, 0)
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_FCALLOC, 1)
#define P99_FCALLOC(T, F, N) calloc(P99_FSIZEOF(T, F, N),1)
#define P00_FCALLOC(T, F, M) calloc(P00_FSIZEOF(T, F, M),1)
 
#endif      /* !P99_NEW_H_ */