p99_logical.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 author and copyright holder for this work is                             */
/* (C) copyright  2010-2013 Jens Gustedt, INRIA, France                         */
/*                                                                              */
/* 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_LOGICAL_H_
# define    P99_LOGICAL_H_
 
#include "p99_args.h"
#include "p99_list.h"
 
#define P99_IS_EQ(_0, _1) P99_HAS_COMMA(P99_PASTE4(P00_IS_, _0, _EQ_, _1)())
 
 
#define P99_LOGIC_EVAL(_0) P00_EVAL_0(P99_IS_EMPTY(_0), P99_IS_EQ_0(_0))
 
#define P00_EVAL_0(_0, _1) P99_PASTE3(P00_EVAL_, _0, _1)
 
#define P00_EVAL_00 1
#define P00_EVAL_10 0
#define P00_EVAL_01 0
/* should never happen */
#define P00_EVAL_11 WEIRD_EVALUATION_ERROR
 
#define P99_LOGIC_NOT(A)  P00_NOT_0(P99_IS_EMPTY(_0), P99_IS_EQ_0(_0))
 
#define P00_NOT_0(_0, _1) P99_PASTE3(P00_NOT_, _0, _1)
 
#define P00_NOT_00 1
#define P00_NOT_10 0
#define P00_NOT_01 1
/* should never happen */
#define P00_NOT_11 WEIRD_NEGATION_ERROR
 
#define P99_LOGIC_XOR(A, B) P99_IS_EQ(P99_LOGIC_NOT(A), P99_LOGIC_EVAL(B))
 
 
#define P99_LOGIC_OR(A, B) P00_LOGIC_OR(P99_LOGIC_EVAL(A), P99_LOGIC_EVAL(B))
 
 
#define P00_LOGIC_OR(_0, _1) P99_PASTE3(P00_LOGIC_OR_, _0, _1)
 
#define P00_LOGIC_OR_00 0
#define P00_LOGIC_OR_10 1
#define P00_LOGIC_OR_01 1
#define P00_LOGIC_OR_11 1
 
#define P99_LOGIC_AND(A, B) P00_LOGIC_AND(P99_LOGIC_EVAL(A), P99_LOGIC_EVAL(B))
 
 
#define P00_LOGIC_AND(_0, _1) P99_PASTE3(P00_LOGIC_AND_, _0, _1)
 
#define P00_LOGIC_AND_00 0
#define P00_LOGIC_AND_10 0
#define P00_LOGIC_AND_01 0
#define P00_LOGIC_AND_11 1
 
 
 
#define P99_IS_VOID(...) P00_IS_VOID(P99_IS_EMPTY(__VA_ARGS__), P99_IS_EQ_void(__VA_ARGS__))
 
#define P00_IS_VOID(_0, _1) P99_PASTE3(P00_IS_VOID_, _0, _1)
 
#define P00_IS_VOID_00 0
#define P00_IS_VOID_01 1
#define P00_IS_VOID_10 1
/* should not happen */
#define P00_IS_VOID_11 WEIRD_VOID_ARG_ERROR
 
#define P99_IS_INT(...) P00_IS_INT(P99_IS_EQ_signed(__VA_ARGS__), P99_IS_EQ_int(__VA_ARGS__))
 
#define P00_IS_INT(_0, _1) P99_PASTE3(P00_IS_INT_, _0, _1)
 
#define P00_IS_INT_00 0
#define P00_IS_INT_01 1
#define P00_IS_INT_10 1
/* should not happen */
#define P00_IS_INT_11 WEIRD_INT_ARG_ERROR
 
#define P99_IF_INT(TOK) P99_IF_EQ_1(P99_IS_INT(TOK))
 
#define P99_IS_LT(_0, _1)  P00_LT( P99_IS_EQ_0(_1), P99_CHS(_0, P99_SELS(_1, P00_ALL_ONES()), P00_ALL_ZEROES()))
#define P00_LT(_0, _1)  P99_PASTE2(P00_LT_, _0)(_1)
 
#define P00_LT_0(_0) _0
#define P00_LT_1(_0) 0
 
#define P99_IS_GE(_0, _1)  P00_GE( P99_IS_EQ_0(_1), P99_CHS(_0, P99_SELS(_1, P00_ALL_ZEROES()), P00_ALL_ONES()))
#define P00_GE(_0, _1)  P99_PASTE2(P00_GE_, _0)(_1)
 
#define P00_GE_0(_0) _0
#define P00_GE_1(_0) 1
 
#define P99_IS_GT(_0, _1)  P99_IS_LT(_1, _0)
 
#define P99_IS_LE(_0, _1)  P99_IS_GE(_1, _0)
 
#define P99_ADD(_0, _1)                                        \
P00_ADD_(_0, _1,                                               \
         P99_IS_EQ_0(_0),                                      \
         P99_IS_EQ_0(_1),                                      \
         P99_NARG(                                             \
                  P99_SELS(_0, P00_ALL_ZEROES()),              \
                  P99_SELS(_1, P00_ALL_ZEROES())))
 
 
#define P00_ADD_(_0, _1, _2, _3, _4) P99_PASTE3(P00_ADD_, _2, _3)(_0, _1, _4)
 
#define P00_ADD_00(_0, _1, _2) _2
#define P00_ADD_01(_0, _1, _2) _0
#define P00_ADD_10(_0, _1, _2) _1
#define P00_ADD_11(_0, _1, _2) 0
 
 
#define P99_MINUS(_0, _1) P00_MINUS(_0, _1, P99_IS_EQ(_0, _1), P99_IS_EQ_0(_0), P99_IS_EQ_0(_1))
#define P00_MINUS(_0, _1, _2, _3, _4) P99_PASTE4(P00_MINUS_, _2, _3, _4)(_0, _1)
 
#define P00_MINUS_000(_0, _1) P00_MINUS_(_0, _1, P99_IS_LT(_0, _1))
/* if one of _0 or _1 is 0, there is not much to do */
#define P00_MINUS_001(_0, _1) _0
#define P00_MINUS_010(_0, _1) P99_PASTE2(minus_, _1)
/* should not occur */
#define P00_MINUS_011(_0, _1) P99_WEIRD_MINUS_ARG_ERROR
/* whenever _0 and _1 are equal there is nothing to do */
#define P00_MINUS_100(_0, _1) 0
#define P00_MINUS_101(_0, _1) 0
#define P00_MINUS_110(_0, _1) 0
#define P00_MINUS_111(_0, _1) 0
 
#define P00_MINUS_(_0, _1, _2) P99_PASTE2(P00_MINUS_, _2)(_0, _1)
 
#define P00_MINUS_0(_0, _1) P00_MINUS__(_0, _1)
#define P00_MINUS_1(_0, _1) P99_PASTE2(minus_, P00_MINUS__(_1, _0))
 
 
 
/* The general case both are non-zero and _0 is strictly greater than _1 */
#define P00_MINUS__(_0, _1) P99_NARG(P99_SKP(_1, P99_SELS(_0, P00_ALL_ZEROES())))
 
 
#define P99_PRED(N) P00_PRED(N)
#define P00_PRED(N) P00__PRED(P00_PRED_ , N)
#define P00__PRED(P, N) P ## N
 
#define P00_PRED_0 minus_1
 
#define P99_EVAL(EDEC) P99_PASTE2(P00_dec_eval_, EDEC)
 
 
#define P99_MUL(A, B) P99_PASTE3(P00_MUL_, P99_IS_EQ_0(A), P99_IS_EQ_0(B))(A, B)
 
#define P00_MUL_00(A, B) P99_NARG(P99_DUPL(A, P99_SELS(B, P00_ALL_ONES())))
#define P00_MUL_01(A, B) 0
#define P00_MUL_10(A, B) 0
#define P00_MUL_11(A, B) 0
 
 
#define P99_MOD(A, B) P00_MOD(A, P99_DUPL(32, P99_SELS(B, P00_ASCENDING())))
#define P00_MOD(A, ...) P99_CHS(A, __VA_ARGS__)
 
#define P99_LAST(...) P99_CHS(P99_PRED(P00_NARG(__VA_ARGS__)), __VA_ARGS__,)
 
#define P99_ALLBUTLAST(...) P99_PASTE2(P00_PRE,P99_PRED(P00_NARG(__VA_ARGS__)))(__VA_ARGS__,)
 
#define P00__PASTE(F, N, ...) F ## N(__VA_ARGS__)
#define P00_PASTE(N, ...) P00__PASTE(P99_PASTE, N, __VA_ARGS__)
 
 
#define P99_PASTE(...) P00_PASTE(P00_NARG(__VA_ARGS__), __VA_ARGS__)
 
#define P00_EAT_FIRST(SEQ) P00_EAT_ ## SEQ
 
#define P00_STARTS(TOK, SEQ) P99_IS_EQ(2, P99_NARG(P99_PASTE4(P00_TOK_, TOK, _STARTS_, SEQ)))
 
 
#endif      /* !P99_LOGICAL_H_ */