p99_map.h

Go to the documentation of this file.

/* This may look like nonsense, but it really is -*- mode: C -*-              */
/*                                                                            */
/* 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.                 */
/* You can redistribute it and/or modify it under the terms of the QPL as     */
/* given in the file LICENSE. It is distributed without any warranty;         */
/* without even the implied warranty of merchantability or fitness for a      */
/* particular purpose.                                                        */
/*                                                                            */
#ifndef     P99_MAP_H_
# define    P99_MAP_H_

#include "p99_for.h"

#define P00_ACCESSOR(NAME, X, I) P99_IF_EMPTY(NAME)([I])((NAME)[I])
#define P00_VASSIGN(NAME, X, I) X = P00_ACCESSOR(NAME, X, I)
#define P00_STRLEN(NAME, X, I) strlen(X)
#define P00_SIZEOF(NAME, X, I) sizeof(X)
#define P00_TYPD(NAME, X, I) typedef X P99_PASTE2(NAME, I)
#define P00_DESIGNATE(NAME, X, I) X = (NAME)X
#define P00_ADD(NAME, I, REC, RES) P99_ADD(RES, REC)

#define P00_STRLENS(N, ...) P99_FOR(,N, P00_SUM, P00_STRLEN, __VA_ARGS__)
#define P00_SIZEOFS(N, ...) P99_FOR(,N, P00_SUM, P00_SIZEOF, __VA_ARGS__)
#define P00_ADDS(N, ...) P99_FOR(, N, P00_ADD, P00_IDT, __VA_ARGS__)

#define P00_POW0(X, _1, _2) (X)
#define P00_POW(X, _1, REC, _3) (X) * REC

P00_DOCUMENT_NUMBER_ARGUMENT(P99_IPOW, 0)
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_IPOW, 1)
#define P99_IPOW(N, X) P99_IF_EQ(N,0)(P99_SIGN_PROMOTE(1, X))((P99_FOR(X, N, P00_POW, P00_POW0, P99_REP(N,))))

#define P99_STRLENS(...) P00_STRLENS(P99_NARG(__VA_ARGS__),__VA_ARGS__)

#define P99_SIZEOFS(...) P00_SIZEOFS(P99_NARG(__VA_ARGS__),__VA_ARGS__)

#define P99_ADDS(...) P00_ADDS(P99_NARG(__VA_ARGS__),__VA_ARGS__)

#ifndef P00_DOXYGEN
P99_DECLARE_STRUCT(p00_strcat_state);
#endif

struct p00_strcat_state {
  char*restrict p00_buf;
  char*restrict p00_pos;
};

#if _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L
p99_inline
char *p00_stpcpy(char *restrict p00_des, const char *restrict p00_src) {
  return stpcpy(p00_des, p00_src);
}
#else
p99_inline
char *p00_stpcpy(char *restrict p00_des, const char *restrict p00_src) {
  for (;;) {
    *p00_des = *p00_src;
    if (!*p00_src) break;
    ++p00_des; ++p00_src;
  }
  return p00_des;
}
#endif


p99_inline
p00_strcat_state* p00_strcat(p00_strcat_state *restrict p00_des, char const*restrict p00_src) {
  if (!p00_des->p00_pos) p00_des->p00_pos = strchr(p00_des->p00_buf, 0);
  p00_des->p00_pos = p00_stpcpy(p00_des->p00_pos, p00_src);
  return p00_des;
}

P99_PURE_FUNCTION
p99_inline
char* p00_strcat_terminate(p00_strcat_state *restrict p00_des) {
  return p00_des->p00_buf;
}

#define P99_STRCATS(TARG, ...)                                 \
p00_strcat_terminate                                           \
(P99_BIGFUNC                                                   \
 (p00_strcat,                                                  \
  P99_NARG(TARG, __VA_ARGS__),                                 \
  (&(p00_strcat_state){ .p00_buf = (TARG), .p00_pos = 0  }),   \
   __VA_ARGS__))

P00_DOCUMENT_PERMITTED_ARGUMENT(P99_JOIN, 0)
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_JOIN, 1)
P00_DOCUMENT_PERMITTED_ARGUMENT(P99_JOIN, 2)
#define P99_JOIN(...) P99_STRCATS((char[P99_SIZEOFS(__VA_ARGS__) + 1]){ 0 }, __VA_ARGS__)

P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_STRDUP, 0)
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_STRDUP, 1)
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_STRDUP, 2)
#define P99_STRDUP(...) P99_STRCATS(memset(malloc(P99_STRLENS(__VA_ARGS__) + 1), 0, 1), __VA_ARGS__)

P00_DOCUMENT_NUMBER_ARGUMENT(P99_POSS, 0)
#define P99_POSS(N) P99_FOR(,N, P00_SEQ, P00_POS,)


#define P00_ACCESSORS(X, ...) P99_FOR(X, __VA_ARGS__, P00_SEQ, P00_ACCESSOR, )

P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_ACCESSORS, 0)
P00_DOCUMENT_NUMBER_ARGUMENT(P99_ACCESSORS, 1)
#define P99_ACCESSORS(X, N) P00_ACCESSORS(X, N)


P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_VASSIGNS, 0)
#define P99_VASSIGNS(NAME, ...)                                            \
P99_IF_LT(P99_NARG(__VA_ARGS__),2)                                         \
(P99_IF_VOID(__VA_ARGS__)((void)0)(__VA_ARGS__ = (NAME)[0]))               \
  (P99_FOR(NAME, P00_NARG(__VA_ARGS__),P00_SEP, P00_VASSIGN, __VA_ARGS__))

#define P00_TYPEDEFS(NAME, N, ...)                             \
  P99_IF_VOID(__VA_ARGS__)                                     \
  (P99_MACRO_END(NAME, _eat_the_semicolon_, N))                \
  (P99_FOR(NAME, N, P00_SEP, P00_TYPD, __VA_ARGS__))

#define P99_TYPEDEFS(NAME, ...)                                \
P00_TYPEDEFS(NAME, P99_NARG(__VA_ARGS__), __VA_ARGS__)

#define P00_DESIGNATED(VAR, N, ...) P99_FOR(VAR, N, P00_SEQ, P00_DESIGNATE, __VA_ARGS__)

P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_DESIGNATED, 0)
P00_DOCUMENT_DESIGNATOR_ARGUMENT(P99_DESIGNATED, 1)
P00_DOCUMENT_DESIGNATOR_ARGUMENT(P99_DESIGNATED, 2)
P00_DOCUMENT_DESIGNATOR_ARGUMENT(P99_DESIGNATED, 3)
#define P99_DESIGNATED(VAR, ...) { P00_DESIGNATED(VAR, P99_NARG(__VA_ARGS__), __VA_ARGS__) }

#define P99_ADESIGNATED(VAR, N) P99_DESIGNATED(VAR, P99_ACCESSORS(, N))

P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_LCOPY, 1)
P00_DOCUMENT_TYPE_ARGUMENT(P99_LCOPY, 0)
P00_DOCUMENT_DESIGNATOR_ARGUMENT(P99_LCOPY, 2)
P00_DOCUMENT_DESIGNATOR_ARGUMENT(P99_LCOPY, 3)
P00_DOCUMENT_DESIGNATOR_ARGUMENT(P99_LCOPY, 4)
#define P99_LCOPY(TYPE, VAR, ...) ((TYPE)P99_DESIGNATED(VAR, __VA_ARGS__))


#define P00_ACOPY4(TYPE, N, VAR, ...) ((TYPE[N])P99_DESIGNATED(VAR, P00_ACCESSORS(, __VA_ARGS__)))

#define P00_ACOPY3(TYPE, N, VAR) P00_ACOPY4(TYPE, N, VAR, N)

#ifdef P00_DOXYGEN

#define P99_ACOPY(TYPE, N, VAR, M)
#else
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_ACOPY, 2)
P00_DOCUMENT_DECLARATION_ARGUMENT(P99_ACOPY, 4)
#define P99_ACOPY(TYPE, N, ...)                                \
P99_IF_LT(P99_NARG(__VA_ARGS__), 2)                            \
(P00_ACOPY3(TYPE, N, __VA_ARGS__))                             \
(P00_ACOPY4(TYPE, N, __VA_ARGS__))
#endif

#ifdef P00_DOXYGEN

#define P99_AASSIGN(TARGET, SOURCE, N)
#else
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_AASSIGN, 0)
P00_DOCUMENT_MULTIPLE_ARGUMENT(P99_AASSIGN, 1)
#define P99_AASSIGN(TARGET, SOURCE, N) P99_BLOCK(P99_VASSIGNS(SOURCE, P99_ACCESSORS(TARGET, N));)
#endif

#endif      /* !P99_MAP_H_ */