├── .github └── workflows │ ├── dist_publish.yml │ └── tests.yml ├── CHANGELOG ├── CONTRIBUTORS ├── LICENSE.txt ├── README.rst ├── arybo ├── __init__.py ├── lib │ ├── __init__.py │ ├── bool_solver.py │ ├── exprs_asm.py │ ├── exprs_passes.py │ ├── mba_exprs.py │ ├── mba_if.py │ ├── mba_impl_petanque.py │ ├── mba_impl_sympy.py │ └── tester.py └── tools │ ├── __init__.py │ ├── identify.py │ ├── petanque.py │ └── triton_.py ├── benchs ├── benchs ├── cmp.py └── run-suite.py ├── bin └── iarybo ├── docs ├── Makefile └── source │ ├── concepts.rst │ ├── conf.py │ ├── imgs │ └── ida_xor5C.png │ ├── index.rst │ ├── integration.rst │ ├── intro.rst │ ├── reference-arybo.rst │ ├── reference-libpetanque.rst │ ├── reference-pytanque.rst │ ├── setup.rst │ ├── tutorial.rst │ └── usage.rst ├── examples ├── dirac.py ├── gen_mba.py ├── gen_mba2.py ├── hitb2015_crypto400.py ├── opaque_predicates.py ├── sstic2016_crc.py ├── stribog.py ├── triton_ast.py ├── triton_ida.py ├── triton_ida_patch.py ├── xor_5C.py └── xor_6.py ├── petanque ├── CMakeCompilers.txt ├── CMakeLists.txt ├── CMakeRequiredLibraries.txt ├── LICENSE.txt ├── MANIFEST.in ├── README.rst ├── bindings │ ├── CMakeLists.txt │ └── python │ │ ├── CMakeLists.txt │ │ ├── distutils_pa_config │ │ └── pa │ │ │ └── config.h │ │ └── pytanque.cpp ├── cmake │ └── FindTBB.cmake ├── include │ └── pa │ │ ├── algos.h │ │ ├── analyses.h │ │ ├── app.h │ │ ├── bitfield.h │ │ ├── cast.h │ │ ├── compat.h │ │ ├── config.h.in │ │ ├── dynamic_caller.h │ │ ├── errors.h │ │ ├── exports.h │ │ ├── exprs.h │ │ ├── matrix.h │ │ ├── prettyprinter.h │ │ ├── simps.h │ │ ├── sorted_vector.h │ │ ├── subs.h │ │ ├── symbols.h │ │ ├── syms_hist.h │ │ ├── syms_set.h │ │ ├── traits.h │ │ ├── vector.h │ │ └── visitors.h ├── llvm_distutils_env.bat ├── setup.cfg ├── setup.py ├── src │ ├── CMakeLists.txt │ ├── analyses.cpp │ ├── app.cpp │ ├── bitfield.cpp │ ├── exprs.cpp │ ├── matrix.cpp │ ├── ops.cpp │ ├── prettyprinter.cpp │ ├── simps.cpp │ ├── subs.cpp │ ├── symbols.cpp │ ├── syms_hist.cpp │ ├── syms_set.cpp │ └── vector.cpp ├── tests │ ├── CMakeLists.txt │ ├── algos.cpp │ ├── app.cpp │ ├── bench.cpp │ ├── double_free.cpp │ ├── exprs.cpp │ ├── identify_ors_no_rec.cpp │ ├── matrix.cpp │ ├── op_add.cpp │ ├── op_complex.cpp │ ├── op_esf.cpp │ ├── op_mul.cpp │ ├── op_names.cpp │ ├── op_or.cpp │ ├── or_to_esf.cpp │ ├── prettyprinter.cpp │ ├── random_simplify.cpp │ ├── simp.cpp │ ├── simp_constants_prop.cpp │ ├── simp_expand.cpp │ ├── simp_expand_no_rec.cpp │ ├── simp_flatten.cpp │ ├── simp_flatten_no_rec.cpp │ ├── simp_remove_dead_ops.cpp │ ├── sort.cpp │ ├── sort2.cpp │ ├── sorted_vector.cpp │ ├── subs.cpp │ ├── syms_set.cpp │ ├── tests.cpp │ ├── tests.h │ ├── vec_int.cpp │ ├── vector.cpp │ ├── vectorial_decomp.cpp │ └── visitors.cpp ├── third-party │ ├── bcp.sh │ ├── boost │ │ ├── config.hpp │ │ ├── config │ │ │ ├── abi │ │ │ │ ├── borland_prefix.hpp │ │ │ │ ├── borland_suffix.hpp │ │ │ │ ├── msvc_prefix.hpp │ │ │ │ └── msvc_suffix.hpp │ │ │ ├── abi_prefix.hpp │ │ │ ├── abi_suffix.hpp │ │ │ ├── auto_link.hpp │ │ │ ├── compiler │ │ │ │ ├── borland.hpp │ │ │ │ ├── clang.hpp │ │ │ │ ├── codegear.hpp │ │ │ │ ├── comeau.hpp │ │ │ │ ├── common_edg.hpp │ │ │ │ ├── compaq_cxx.hpp │ │ │ │ ├── cray.hpp │ │ │ │ ├── diab.hpp │ │ │ │ ├── digitalmars.hpp │ │ │ │ ├── gcc.hpp │ │ │ │ ├── gcc_xml.hpp │ │ │ │ ├── greenhills.hpp │ │ │ │ ├── hp_acc.hpp │ │ │ │ ├── intel.hpp │ │ │ │ ├── kai.hpp │ │ │ │ ├── metrowerks.hpp │ │ │ │ ├── mpw.hpp │ │ │ │ ├── nvcc.hpp │ │ │ │ ├── pathscale.hpp │ │ │ │ ├── pgi.hpp │ │ │ │ ├── sgi_mipspro.hpp │ │ │ │ ├── sunpro_cc.hpp │ │ │ │ ├── vacpp.hpp │ │ │ │ ├── visualc.hpp │ │ │ │ ├── xlcpp.hpp │ │ │ │ └── xlcpp_zos.hpp │ │ │ ├── detail │ │ │ │ ├── posix_features.hpp │ │ │ │ ├── select_compiler_config.hpp │ │ │ │ ├── select_platform_config.hpp │ │ │ │ ├── select_stdlib_config.hpp │ │ │ │ └── suffix.hpp │ │ │ ├── header_deprecated.hpp │ │ │ ├── helper_macros.hpp │ │ │ ├── no_tr1 │ │ │ │ ├── cmath.hpp │ │ │ │ ├── complex.hpp │ │ │ │ ├── functional.hpp │ │ │ │ ├── memory.hpp │ │ │ │ └── utility.hpp │ │ │ ├── platform │ │ │ │ ├── aix.hpp │ │ │ │ ├── amigaos.hpp │ │ │ │ ├── beos.hpp │ │ │ │ ├── bsd.hpp │ │ │ │ ├── cloudabi.hpp │ │ │ │ ├── cray.hpp │ │ │ │ ├── cygwin.hpp │ │ │ │ ├── haiku.hpp │ │ │ │ ├── hpux.hpp │ │ │ │ ├── irix.hpp │ │ │ │ ├── linux.hpp │ │ │ │ ├── macos.hpp │ │ │ │ ├── qnxnto.hpp │ │ │ │ ├── solaris.hpp │ │ │ │ ├── symbian.hpp │ │ │ │ ├── vms.hpp │ │ │ │ ├── vxworks.hpp │ │ │ │ ├── win32.hpp │ │ │ │ └── zos.hpp │ │ │ ├── pragma_message.hpp │ │ │ ├── requires_threads.hpp │ │ │ ├── stdlib │ │ │ │ ├── dinkumware.hpp │ │ │ │ ├── libcomo.hpp │ │ │ │ ├── libcpp.hpp │ │ │ │ ├── libstdcpp3.hpp │ │ │ │ ├── modena.hpp │ │ │ │ ├── msl.hpp │ │ │ │ ├── roguewave.hpp │ │ │ │ ├── sgi.hpp │ │ │ │ ├── stlport.hpp │ │ │ │ ├── vacpp.hpp │ │ │ │ └── xlcpp_zos.hpp │ │ │ ├── user.hpp │ │ │ ├── warning_disable.hpp │ │ │ └── workaround.hpp │ │ ├── core │ │ │ └── addressof.hpp │ │ ├── cstdint.hpp │ │ ├── detail │ │ │ ├── indirect_traits.hpp │ │ │ └── workaround.hpp │ │ ├── integer │ │ │ └── static_log2.hpp │ │ ├── integer_fwd.hpp │ │ ├── iterator │ │ │ ├── detail │ │ │ │ ├── config_def.hpp │ │ │ │ ├── config_undef.hpp │ │ │ │ ├── enable_if.hpp │ │ │ │ └── facade_iterator_category.hpp │ │ │ ├── interoperable.hpp │ │ │ ├── iterator_categories.hpp │ │ │ ├── iterator_facade.hpp │ │ │ └── iterator_traits.hpp │ │ ├── limits.hpp │ │ ├── mpl │ │ │ ├── always.hpp │ │ │ ├── and.hpp │ │ │ ├── apply.hpp │ │ │ ├── apply_fwd.hpp │ │ │ ├── apply_wrap.hpp │ │ │ ├── arg.hpp │ │ │ ├── arg_fwd.hpp │ │ │ ├── assert.hpp │ │ │ ├── aux_ │ │ │ │ ├── adl_barrier.hpp │ │ │ │ ├── arg_typedef.hpp │ │ │ │ ├── arity.hpp │ │ │ │ ├── arity_spec.hpp │ │ │ │ ├── common_name_wknd.hpp │ │ │ │ ├── config │ │ │ │ │ ├── adl.hpp │ │ │ │ │ ├── arrays.hpp │ │ │ │ │ ├── bcc.hpp │ │ │ │ │ ├── bind.hpp │ │ │ │ │ ├── compiler.hpp │ │ │ │ │ ├── ctps.hpp │ │ │ │ │ ├── dmc_ambiguous_ctps.hpp │ │ │ │ │ ├── dtp.hpp │ │ │ │ │ ├── eti.hpp │ │ │ │ │ ├── gcc.hpp │ │ │ │ │ ├── gpu.hpp │ │ │ │ │ ├── has_apply.hpp │ │ │ │ │ ├── has_xxx.hpp │ │ │ │ │ ├── integral.hpp │ │ │ │ │ ├── intel.hpp │ │ │ │ │ ├── lambda.hpp │ │ │ │ │ ├── msvc.hpp │ │ │ │ │ ├── msvc_typename.hpp │ │ │ │ │ ├── nttp.hpp │ │ │ │ │ ├── overload_resolution.hpp │ │ │ │ │ ├── pp_counter.hpp │ │ │ │ │ ├── preprocessor.hpp │ │ │ │ │ ├── static_constant.hpp │ │ │ │ │ ├── ttp.hpp │ │ │ │ │ ├── use_preprocessed.hpp │ │ │ │ │ └── workaround.hpp │ │ │ │ ├── count_args.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── has_apply.hpp │ │ │ │ ├── has_rebind.hpp │ │ │ │ ├── has_type.hpp │ │ │ │ ├── include_preprocessed.hpp │ │ │ │ ├── integral_wrapper.hpp │ │ │ │ ├── lambda_arity_param.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── lambda_support.hpp │ │ │ │ ├── logical_op.hpp │ │ │ │ ├── msvc_dtw.hpp │ │ │ │ ├── msvc_is_class.hpp │ │ │ │ ├── msvc_never_true.hpp │ │ │ │ ├── na.hpp │ │ │ │ ├── na_assert.hpp │ │ │ │ ├── na_fwd.hpp │ │ │ │ ├── na_spec.hpp │ │ │ │ ├── nested_type_wknd.hpp │ │ │ │ ├── nttp_decl.hpp │ │ │ │ ├── preprocessed │ │ │ │ │ ├── bcc │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── bcc551 │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── bcc_pre590 │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── dmc │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── gcc │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── msvc60 │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── msvc70 │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── mwcw │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── no_ctps │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ ├── no_ttp │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ │ └── plain │ │ │ │ │ │ ├── advance_backward.hpp │ │ │ │ │ │ ├── advance_forward.hpp │ │ │ │ │ │ ├── and.hpp │ │ │ │ │ │ ├── apply.hpp │ │ │ │ │ │ ├── apply_fwd.hpp │ │ │ │ │ │ ├── apply_wrap.hpp │ │ │ │ │ │ ├── arg.hpp │ │ │ │ │ │ ├── basic_bind.hpp │ │ │ │ │ │ ├── bind.hpp │ │ │ │ │ │ ├── bind_fwd.hpp │ │ │ │ │ │ ├── bitand.hpp │ │ │ │ │ │ ├── bitor.hpp │ │ │ │ │ │ ├── bitxor.hpp │ │ │ │ │ │ ├── deque.hpp │ │ │ │ │ │ ├── divides.hpp │ │ │ │ │ │ ├── equal_to.hpp │ │ │ │ │ │ ├── fold_impl.hpp │ │ │ │ │ │ ├── full_lambda.hpp │ │ │ │ │ │ ├── greater.hpp │ │ │ │ │ │ ├── greater_equal.hpp │ │ │ │ │ │ ├── inherit.hpp │ │ │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ │ │ ├── less.hpp │ │ │ │ │ │ ├── less_equal.hpp │ │ │ │ │ │ ├── list.hpp │ │ │ │ │ │ ├── list_c.hpp │ │ │ │ │ │ ├── map.hpp │ │ │ │ │ │ ├── minus.hpp │ │ │ │ │ │ ├── modulus.hpp │ │ │ │ │ │ ├── not_equal_to.hpp │ │ │ │ │ │ ├── or.hpp │ │ │ │ │ │ ├── placeholders.hpp │ │ │ │ │ │ ├── plus.hpp │ │ │ │ │ │ ├── quote.hpp │ │ │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ │ │ ├── set.hpp │ │ │ │ │ │ ├── set_c.hpp │ │ │ │ │ │ ├── shift_left.hpp │ │ │ │ │ │ ├── shift_right.hpp │ │ │ │ │ │ ├── template_arity.hpp │ │ │ │ │ │ ├── times.hpp │ │ │ │ │ │ ├── unpack_args.hpp │ │ │ │ │ │ ├── vector.hpp │ │ │ │ │ │ └── vector_c.hpp │ │ │ │ ├── preprocessor │ │ │ │ │ ├── add.hpp │ │ │ │ │ ├── def_params_tail.hpp │ │ │ │ │ ├── default_params.hpp │ │ │ │ │ ├── enum.hpp │ │ │ │ │ ├── ext_params.hpp │ │ │ │ │ ├── filter_params.hpp │ │ │ │ │ ├── params.hpp │ │ │ │ │ ├── partial_spec_params.hpp │ │ │ │ │ ├── range.hpp │ │ │ │ │ ├── repeat.hpp │ │ │ │ │ ├── sub.hpp │ │ │ │ │ └── tuple.hpp │ │ │ │ ├── static_cast.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── template_arity_fwd.hpp │ │ │ │ ├── type_wrapper.hpp │ │ │ │ ├── value_wknd.hpp │ │ │ │ └── yes_no.hpp │ │ │ ├── bind.hpp │ │ │ ├── bind_fwd.hpp │ │ │ ├── bool.hpp │ │ │ ├── bool_fwd.hpp │ │ │ ├── eval_if.hpp │ │ │ ├── has_xxx.hpp │ │ │ ├── identity.hpp │ │ │ ├── if.hpp │ │ │ ├── int.hpp │ │ │ ├── int_fwd.hpp │ │ │ ├── integral_c_tag.hpp │ │ │ ├── is_placeholder.hpp │ │ │ ├── lambda.hpp │ │ │ ├── lambda_fwd.hpp │ │ │ ├── limits │ │ │ │ └── arity.hpp │ │ │ ├── next.hpp │ │ │ ├── next_prior.hpp │ │ │ ├── not.hpp │ │ │ ├── or.hpp │ │ │ ├── placeholders.hpp │ │ │ ├── protect.hpp │ │ │ ├── quote.hpp │ │ │ ├── void.hpp │ │ │ └── void_fwd.hpp │ │ ├── preprocessor │ │ │ ├── arithmetic │ │ │ │ ├── add.hpp │ │ │ │ ├── dec.hpp │ │ │ │ ├── inc.hpp │ │ │ │ └── sub.hpp │ │ │ ├── array │ │ │ │ ├── data.hpp │ │ │ │ ├── elem.hpp │ │ │ │ └── size.hpp │ │ │ ├── cat.hpp │ │ │ ├── comma_if.hpp │ │ │ ├── comparison │ │ │ │ └── not_equal.hpp │ │ │ ├── config │ │ │ │ └── config.hpp │ │ │ ├── control │ │ │ │ ├── detail │ │ │ │ │ ├── dmc │ │ │ │ │ │ └── while.hpp │ │ │ │ │ ├── edg │ │ │ │ │ │ └── while.hpp │ │ │ │ │ ├── msvc │ │ │ │ │ │ └── while.hpp │ │ │ │ │ └── while.hpp │ │ │ │ ├── expr_if.hpp │ │ │ │ ├── expr_iif.hpp │ │ │ │ ├── if.hpp │ │ │ │ ├── iif.hpp │ │ │ │ └── while.hpp │ │ │ ├── debug │ │ │ │ └── error.hpp │ │ │ ├── dec.hpp │ │ │ ├── detail │ │ │ │ ├── auto_rec.hpp │ │ │ │ ├── check.hpp │ │ │ │ ├── dmc │ │ │ │ │ └── auto_rec.hpp │ │ │ │ ├── is_binary.hpp │ │ │ │ └── split.hpp │ │ │ ├── empty.hpp │ │ │ ├── enum_shifted_params.hpp │ │ │ ├── expr_if.hpp │ │ │ ├── facilities │ │ │ │ ├── detail │ │ │ │ │ └── is_empty.hpp │ │ │ │ ├── empty.hpp │ │ │ │ ├── expand.hpp │ │ │ │ ├── identity.hpp │ │ │ │ ├── is_1.hpp │ │ │ │ ├── is_empty.hpp │ │ │ │ ├── is_empty_variadic.hpp │ │ │ │ └── overload.hpp │ │ │ ├── identity.hpp │ │ │ ├── inc.hpp │ │ │ ├── iterate.hpp │ │ │ ├── iteration │ │ │ │ ├── detail │ │ │ │ │ ├── bounds │ │ │ │ │ │ ├── lower1.hpp │ │ │ │ │ │ ├── lower2.hpp │ │ │ │ │ │ ├── lower3.hpp │ │ │ │ │ │ ├── lower4.hpp │ │ │ │ │ │ ├── lower5.hpp │ │ │ │ │ │ ├── upper1.hpp │ │ │ │ │ │ ├── upper2.hpp │ │ │ │ │ │ ├── upper3.hpp │ │ │ │ │ │ ├── upper4.hpp │ │ │ │ │ │ └── upper5.hpp │ │ │ │ │ ├── finish.hpp │ │ │ │ │ ├── iter │ │ │ │ │ │ ├── forward1.hpp │ │ │ │ │ │ ├── forward2.hpp │ │ │ │ │ │ ├── forward3.hpp │ │ │ │ │ │ ├── forward4.hpp │ │ │ │ │ │ ├── forward5.hpp │ │ │ │ │ │ ├── reverse1.hpp │ │ │ │ │ │ ├── reverse2.hpp │ │ │ │ │ │ ├── reverse3.hpp │ │ │ │ │ │ ├── reverse4.hpp │ │ │ │ │ │ └── reverse5.hpp │ │ │ │ │ ├── local.hpp │ │ │ │ │ ├── rlocal.hpp │ │ │ │ │ ├── self.hpp │ │ │ │ │ └── start.hpp │ │ │ │ ├── iterate.hpp │ │ │ │ ├── local.hpp │ │ │ │ └── self.hpp │ │ │ ├── list │ │ │ │ ├── adt.hpp │ │ │ │ ├── detail │ │ │ │ │ ├── dmc │ │ │ │ │ │ └── fold_left.hpp │ │ │ │ │ ├── edg │ │ │ │ │ │ ├── fold_left.hpp │ │ │ │ │ │ └── fold_right.hpp │ │ │ │ │ ├── fold_left.hpp │ │ │ │ │ └── fold_right.hpp │ │ │ │ ├── fold_left.hpp │ │ │ │ ├── fold_right.hpp │ │ │ │ ├── for_each_i.hpp │ │ │ │ └── reverse.hpp │ │ │ ├── logical │ │ │ │ ├── and.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bool.hpp │ │ │ │ └── compl.hpp │ │ │ ├── punctuation │ │ │ │ ├── comma.hpp │ │ │ │ ├── comma_if.hpp │ │ │ │ ├── detail │ │ │ │ │ └── is_begin_parens.hpp │ │ │ │ └── is_begin_parens.hpp │ │ │ ├── repeat.hpp │ │ │ ├── repetition │ │ │ │ ├── detail │ │ │ │ │ ├── dmc │ │ │ │ │ │ └── for.hpp │ │ │ │ │ ├── edg │ │ │ │ │ │ └── for.hpp │ │ │ │ │ ├── for.hpp │ │ │ │ │ └── msvc │ │ │ │ │ │ └── for.hpp │ │ │ │ ├── enum_params.hpp │ │ │ │ ├── enum_shifted_params.hpp │ │ │ │ ├── enum_trailing_params.hpp │ │ │ │ ├── for.hpp │ │ │ │ └── repeat.hpp │ │ │ ├── seq │ │ │ │ ├── detail │ │ │ │ │ ├── is_empty.hpp │ │ │ │ │ └── split.hpp │ │ │ │ ├── elem.hpp │ │ │ │ ├── first_n.hpp │ │ │ │ ├── fold_left.hpp │ │ │ │ ├── rest_n.hpp │ │ │ │ ├── seq.hpp │ │ │ │ ├── size.hpp │ │ │ │ └── subseq.hpp │ │ │ ├── slot │ │ │ │ ├── detail │ │ │ │ │ ├── counter.hpp │ │ │ │ │ ├── def.hpp │ │ │ │ │ ├── shared.hpp │ │ │ │ │ ├── slot1.hpp │ │ │ │ │ ├── slot2.hpp │ │ │ │ │ ├── slot3.hpp │ │ │ │ │ ├── slot4.hpp │ │ │ │ │ └── slot5.hpp │ │ │ │ └── slot.hpp │ │ │ ├── stringize.hpp │ │ │ ├── tuple │ │ │ │ ├── detail │ │ │ │ │ └── is_single_return.hpp │ │ │ │ ├── eat.hpp │ │ │ │ ├── elem.hpp │ │ │ │ ├── rem.hpp │ │ │ │ ├── size.hpp │ │ │ │ └── to_list.hpp │ │ │ └── variadic │ │ │ │ ├── elem.hpp │ │ │ │ └── size.hpp │ │ ├── static_assert.hpp │ │ ├── type_traits │ │ │ ├── add_const.hpp │ │ │ ├── add_lvalue_reference.hpp │ │ │ ├── add_pointer.hpp │ │ │ ├── add_reference.hpp │ │ │ ├── add_rvalue_reference.hpp │ │ │ ├── declval.hpp │ │ │ ├── detail │ │ │ │ ├── config.hpp │ │ │ │ ├── is_function_ptr_helper.hpp │ │ │ │ ├── is_function_ptr_tester.hpp │ │ │ │ ├── is_mem_fun_pointer_impl.hpp │ │ │ │ ├── is_mem_fun_pointer_tester.hpp │ │ │ │ └── yes_no_type.hpp │ │ │ ├── function_traits.hpp │ │ │ ├── integral_constant.hpp │ │ │ ├── intrinsics.hpp │ │ │ ├── is_abstract.hpp │ │ │ ├── is_arithmetic.hpp │ │ │ ├── is_array.hpp │ │ │ ├── is_class.hpp │ │ │ ├── is_complete.hpp │ │ │ ├── is_const.hpp │ │ │ ├── is_convertible.hpp │ │ │ ├── is_enum.hpp │ │ │ ├── is_floating_point.hpp │ │ │ ├── is_function.hpp │ │ │ ├── is_integral.hpp │ │ │ ├── is_lvalue_reference.hpp │ │ │ ├── is_member_function_pointer.hpp │ │ │ ├── is_member_pointer.hpp │ │ │ ├── is_pod.hpp │ │ │ ├── is_pointer.hpp │ │ │ ├── is_polymorphic.hpp │ │ │ ├── is_reference.hpp │ │ │ ├── is_rvalue_reference.hpp │ │ │ ├── is_same.hpp │ │ │ ├── is_scalar.hpp │ │ │ ├── is_union.hpp │ │ │ ├── is_void.hpp │ │ │ ├── is_volatile.hpp │ │ │ ├── remove_const.hpp │ │ │ ├── remove_cv.hpp │ │ │ ├── remove_pointer.hpp │ │ │ └── remove_reference.hpp │ │ ├── utility │ │ │ └── addressof.hpp │ │ └── version.hpp │ ├── pector │ │ ├── enhanced_allocators.h │ │ ├── malloc_allocator.h │ │ ├── pector.h │ │ ├── pector_internals.h │ │ └── recommended_size.h │ └── pybind11 │ │ ├── attr.h │ │ ├── buffer_info.h │ │ ├── cast.h │ │ ├── chrono.h │ │ ├── common.h │ │ ├── complex.h │ │ ├── detail │ │ ├── class.h │ │ ├── common.h │ │ ├── descr.h │ │ ├── init.h │ │ ├── internals.h │ │ └── typeid.h │ │ ├── eigen.h │ │ ├── embed.h │ │ ├── eval.h │ │ ├── functional.h │ │ ├── iostream.h │ │ ├── numpy.h │ │ ├── operators.h │ │ ├── options.h │ │ ├── pybind11.h │ │ ├── pytypes.h │ │ ├── stl.h │ │ └── stl_bind.h └── tools │ └── CMakeLists.txt ├── setup.cfg ├── setup.py └── tests ├── arybo ├── app.py ├── examples.py ├── lib.py ├── llvm.py └── mba_exprs.py └── tools ├── identify.py └── triton_.py /CHANGELOG: -------------------------------------------------------------------------------- 1 | CHANGELOG 2 | ========= 3 | 4 | O.2.0 5 | ----- 6 | 7 | Features: 8 | 9 | * Python2 support 10 | * Triton support 11 | * New APIs: zext/sext, rol/ror, slice gathering 12 | 13 | Bug fixes: 14 | * Fix pytanque.Matrix constructor w/ lambda function 15 | -------------------------------------------------------------------------------- /CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | Adrien Guinet (aguinet@quarkslab.com) 2 | Ninon Eyrolles (neyrolles@quarkslab.com) 3 | Philippe Teuwen (pteuwen@quarkslab.com) 4 | -------------------------------------------------------------------------------- /arybo/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/quarkslab/arybo/89d9a4266fa51c1a560f6c4a66f65d1ffde5f093/arybo/__init__.py -------------------------------------------------------------------------------- /benchs/benchs: -------------------------------------------------------------------------------- 1 | xor5C python3 ../examples/test_xor_5C.py 2 | mba7 python3 ../examples/test_gen_mba.py 7 3 | mba8 python3 ../examples/test_gen_mba.py 8 4 | mba9 python3 ../examples/test_gen_mba.py 9 5 | new_mba5 python3 ../examples/simp_new_mba.py 5 6 | new_mba6 python3 ../examples/simp_new_mba.py 6 7 | new_mba7 python3 ../examples/simp_new_mba.py 7 8 | -------------------------------------------------------------------------------- /benchs/run-suite.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # 3 | 4 | import sys 5 | import subprocess 6 | 7 | def do_bench(cmd): 8 | subp = subprocess.Popen("/usr/bin/time -f '%e %M' " + cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 9 | p = subp.communicate() 10 | rc = subp.returncode 11 | if rc != 0: 12 | print("Error while running '%s' (ret %d): %s" % (cmd, rc, p[1]), file=sys.stderr) 13 | return None 14 | time = p[1] 15 | ret = time.decode('ascii').strip().split(' ') 16 | return ret 17 | 18 | benchs = open("benchs", "r") 19 | for b in benchs: 20 | tmp = b.strip().split(' ') 21 | name = tmp[0] 22 | cmd = ' '.join(tmp[1:]) 23 | ret = do_bench(cmd) 24 | if ret != None: 25 | time_s, mem_kb = ret 26 | print("%s\t%0.2f\t%0.2f" % (name, float(time_s)*1000.0, float(mem_kb)/1024.0)) 27 | -------------------------------------------------------------------------------- /docs/source/imgs/ida_xor5C.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/quarkslab/arybo/89d9a4266fa51c1a560f6c4a66f65d1ffde5f093/docs/source/imgs/ida_xor5C.png -------------------------------------------------------------------------------- /docs/source/index.rst: -------------------------------------------------------------------------------- 1 | Welcome to Arybo's documentation! 2 | ================================= 3 | 4 | Contents: 5 | 6 | .. toctree:: 7 | :maxdepth: 2 8 | 9 | intro.rst 10 | setup.rst 11 | usage.rst 12 | tutorial.rst 13 | concepts.rst 14 | integration.rst 15 | reference-arybo.rst 16 | reference-pytanque.rst 17 | -------------------------------------------------------------------------------- /docs/source/intro.rst: -------------------------------------------------------------------------------- 1 | ============== 2 | What is Arybo? 3 | ============== 4 | 5 | Arybo is a tool that gives a bit-level symbolic representation of expressions 6 | involving various types of operations on bit vectors. Such a tool can be used to 7 | gain a better understanding of complex expressions, for example expressions 8 | that mix both arithmetic and boolean operators. It can also be useful for 9 | optimization purposes, such as proving bit hacks easily. 10 | 11 | It has been designed around two main components : 12 | * petanque: a C++ library for manipulating symbolic boolean expressions, 13 | designed for performance and a small memory footprint. Python bindings are provided. 14 | * arybo: a python library to compute symbolic boolean expressions of both 15 | arithmetic and boolean operations on bit-vector. 16 | 17 | See the :ref:`sec-theory` page for more background information, and the 18 | :ref:`sec-tutorials` page for examples. 19 | -------------------------------------------------------------------------------- /docs/source/reference-arybo.rst: -------------------------------------------------------------------------------- 1 | .. _sec-ref-arybo: 2 | 3 | Arybo reference 4 | =============== 5 | 6 | .. autoclass:: arybo.lib.MBA 7 | :members: 8 | 9 | .. autoclass:: arybo.lib.MBAVariable 10 | :members: 11 | 12 | .. autofunction:: arybo.lib.exprs_asm.asm_binary 13 | 14 | .. autofunction:: arybo.lib.exprs_asm.asm_module 15 | 16 | .. autofunction:: arybo.lib.boolean_expr_solve 17 | 18 | .. autofunction:: arybo.tools.tritonast2arybo 19 | 20 | .. autofunction:: arybo.tools.tritonexprs2arybo 21 | -------------------------------------------------------------------------------- /docs/source/reference-libpetanque.rst: -------------------------------------------------------------------------------- 1 | libpetanque reference 2 | ===================== 3 | -------------------------------------------------------------------------------- /docs/source/reference-pytanque.rst: -------------------------------------------------------------------------------- 1 | pytanque reference 2 | ================== 3 | 4 | .. automodule:: pytanque 5 | :members: 6 | -------------------------------------------------------------------------------- /examples/dirac.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA, boolean_expr_solve 2 | mba = MBA(64) 3 | x = mba.var('x') 4 | def f(X): 5 | T = ((X+1)&(~X)) 6 | C = ((T | 0x7AFAFA697AFAFA69) & 0x80A061440A061440)\ 7 | + ((~T & 0x10401050504) | 0x1010104) 8 | return C 9 | r = f(x) 10 | sols = boolean_expr_solve(r[63], x, 1) 11 | C0 = sols[0].get_int_be() 12 | print(hex(C0)) 13 | print(hex(f(0))) 14 | print(hex(f(C0))) 15 | -------------------------------------------------------------------------------- /examples/gen_mba.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA 2 | import sys 3 | 4 | mba = MBA(int(sys.argv[1])) 5 | X = mba.var('X') 6 | Y = mba.var('Y') 7 | 8 | xor = X+Y - ((X&Y) << 1) 9 | print(xor) 10 | -------------------------------------------------------------------------------- /examples/gen_mba2.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA 2 | import sys 3 | 4 | m = MBA(int(sys.argv[1])) 5 | X = m.var('X') 6 | Y = m.var('Y') 7 | 8 | res = (X+Y) - (X|Y) 9 | print(res) 10 | -------------------------------------------------------------------------------- /examples/opaque_predicates.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA 2 | 3 | 4 | mba32 = MBA(32) 5 | X = mba32.var('X') 6 | Y = mba32.var('Y') 7 | X.always_simplify() 8 | Y.always_simplify() 9 | 10 | op = (((X | 0xFDFFDBF3 ) - ((X | 0x7C5F9972) & 0x0248AD2E)) + 0x248AD36) 11 | print(hex(op.to_cst())) 12 | 13 | op = ((~X | 0x7AFAFA69) & 0xA061440) + (X & 0x1050504 | 0x101890D) 14 | print(hex(op.to_cst())) 15 | 16 | op = ((~X | 0x3BBDA8B5) & 0xB21C528) + (X & 0x4040474A | 0x40C00A46) 17 | print(hex(op.to_cst())) 18 | 19 | op = (X & 0xD281D094) - 1461583213 - (X | 0x2D7E2F6B) 20 | print(hex(op.to_cst())) 21 | -------------------------------------------------------------------------------- /examples/triton_ast.py: -------------------------------------------------------------------------------- 1 | import triton as TT 2 | from arybo.tools import tritonast2arybo 3 | 4 | TT.setArchitecture(TT.ARCH.X86_64) 5 | 6 | TT.convertRegisterToSymbolicVariable(TT.REG.RAX) 7 | TT.convertRegisterToSymbolicVariable(TT.REG.RBX) 8 | 9 | inst = TT.Instruction() 10 | inst.setOpcodes("\x48\x31\xd8") # xor rax, rbx 11 | TT.processing(inst) 12 | 13 | rax_ast = TT.buildSymbolicRegister(TT.REG.RAX) 14 | rax_ast = TT.getFullAst(rax_ast) 15 | print(rax_ast) 16 | 17 | e = tritonast2arybo(rax_ast) 18 | print(e) 19 | -------------------------------------------------------------------------------- /examples/xor_5C.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA 2 | import arybo.lib.mba_exprs as EX 3 | import sys 4 | 5 | use_exprs = False 6 | if len(sys.argv) >= 2: 7 | use_exprs = int(sys.argv[1]) 8 | 9 | def f(x): 10 | v0 = x*0xe5 + 0xF7 11 | v0 = v0&0xFF 12 | v3 = (((((v0*0x26)+0x55)&0xFE)+(v0*0xED)+0xD6)&0xFF ) 13 | v4 = ((((((- (v3*0x2))+0xFF)&0xFE)+v3)*0x03)+0x4D) 14 | v5 = (((((v4*0x56)+0x24)&0x46)*0x4B)+(v4*0xE7)+0x76) 15 | v7 = ((((v5*0x3A)+0xAF)&0xF4)+(v5*0x63)+0x2E) 16 | v6 = (v7&0x94) 17 | v8 = ((((v6+v6+(- (v7&0xFF)))*0x67)+0xD)) 18 | res = ((v8*0x2D)+(((v8*0xAE)|0x22)*0xE5)+0xC2)&0xFF 19 | return (0xed*(res-0xF7))&0xff 20 | 21 | mba8 = MBA(8) 22 | X = mba8.var('X') 23 | if use_exprs: 24 | X = EX.ExprBV(X) 25 | res = f(X) 26 | if use_exprs: 27 | res = EX.eval_expr(res,use_esf=False) 28 | print(res) 29 | if use_exprs: 30 | X = X.v 31 | VD = res.vectorial_decomp([X]) 32 | 33 | print("====") 34 | print("Cst = " + hex(VD.cst().get_int_be())) 35 | -------------------------------------------------------------------------------- /examples/xor_6.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA 2 | mba = MBA(4) 3 | 4 | p = mba.var('X') 5 | v0 = (p+2)&15; 6 | bp = (v0>>1)&1; 7 | cp = (v0>>2)&1; 8 | b = (p>>1)&1; 9 | v1 = v0 ^ ((bp << 2) | ((b & (bp ^ cp)) << 3)); 10 | v2 = v1 ^ (b << 3); 11 | VD = v2.vectorial_decomp([p]) 12 | 13 | print(v2) 14 | print("====") 15 | print("Cst = " + hex(VD.cst().get_int_be())) 16 | -------------------------------------------------------------------------------- /petanque/CMakeCompilers.txt: -------------------------------------------------------------------------------- 1 | set(CMAKE_CXX_STANDARD 14) 2 | set(CMAKE_CXX_STANDARD_REQUIRED ON) 3 | set(CMAKE_CXX_EXTENSIONS OFF) 4 | -------------------------------------------------------------------------------- /petanque/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8) 2 | project(petanque) 3 | 4 | enable_testing() 5 | 6 | list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") 7 | 8 | include(CMakeCompilers.txt) 9 | include(CMakeRequiredLibraries.txt) 10 | 11 | configure_file(${CMAKE_SOURCE_DIR}/include/pa/config.h.in ${CMAKE_BINARY_DIR}/include/pa/config.h @ONLY) 12 | 13 | include_directories(${CMAKE_SOURCE_DIR}/include) 14 | include_directories(${CMAKE_BINARY_DIR}/include) 15 | include_directories(${Boost_INCLUDE_DIRS}) 16 | include_directories(${CMAKE_SOURCE_DIR}/third-party) 17 | 18 | add_subdirectory(src) 19 | add_subdirectory(bindings) 20 | if (NOT (DEFINED NO_TESTS OR NO_TESTS)) 21 | add_subdirectory(tests) 22 | endif() 23 | if (NOT (DEFINED NO_TOOLS OR NO_TOOLS)) 24 | add_subdirectory(tools) 25 | endif() 26 | -------------------------------------------------------------------------------- /petanque/CMakeRequiredLibraries.txt: -------------------------------------------------------------------------------- 1 | find_package(PythonLibs ${PYTHON_VERSION}) 2 | set(PythonInterp_FIND_VERSION ${PYTHON_VERSION}) 3 | find_package(PythonInterp) 4 | 5 | if(${PYTHONLIBS_FOUND}) 6 | set(PYTHON_BINDINGS_ENABLED TRUE) 7 | else() 8 | set(PYTHON_BINDINGS_ENABLED FALSE) 9 | endif() 10 | 11 | if (NOT ${PYTHON_BINDINGS_ENABLED}) 12 | message(WARNING "Python ${PYTHON_VERSION} development librairies hasn't been found. Python bindings won't be compiled!") 13 | endif() 14 | 15 | find_package(TBB) 16 | if (NOT ${TBB_FOUND}) 17 | message(WARNING "Intel Threading Building Blocks hasn't been found. Some algorithms won't run across multiple threads.") 18 | set(CONFIG_USE_TBB 0) 19 | else() 20 | set(CONFIG_USE_TBB 1) 21 | endif() 22 | -------------------------------------------------------------------------------- /petanque/MANIFEST.in: -------------------------------------------------------------------------------- 1 | graft include/pa 2 | graft bindings/python/distutils_pa_config 3 | graft third-party/boost 4 | graft third-party/pybind11 5 | -------------------------------------------------------------------------------- /petanque/README.rst: -------------------------------------------------------------------------------- 1 | petanque 2 | ======== 3 | 4 | petanque (and its Python binding pytanque) is a library that helps manipulate 5 | symbolic boolean expressions. 6 | 7 | For more information, see the Arybo project: http://pythonhosted.org/arybo/. 8 | 9 | Quick start 10 | =========== 11 | 12 | Under Windows/Linux/OSX, pytanque can be installed through pip for Python3: 13 | 14 | .. code:: 15 | 16 | $ pip install pytanque 17 | 18 | You will need at least clang 3.5 or GCC 4.9 to compile the python extension 19 | "pytanque" under Linux/OSX. You need at least Visual Studio 2015 Update 3 to 20 | compile it under Windows. 21 | 22 | More details on the installation process can be found here: 23 | http://pythonhosted.org/arybo/setup.html. 24 | 25 | License 26 | ======= 27 | 28 | This is published under a BSD license (see LICENSE.txt file) 29 | 30 | Contact 31 | ======= 32 | 33 | For any issue, do not hesitate to open an issue/create a pull request on Github. 34 | -------------------------------------------------------------------------------- /petanque/bindings/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if (${PYTHON_BINDINGS_ENABLED}) 2 | add_subdirectory(python) 3 | endif() 4 | -------------------------------------------------------------------------------- /petanque/bindings/python/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include_directories(${PYTHON_INCLUDE_DIRS}) 2 | 3 | set(PYTHON_SRC_FILES 4 | pytanque.cpp 5 | ) 6 | 7 | add_library(pytanque SHARED ${PYTHON_SRC_FILES}) 8 | set_target_properties(pytanque PROPERTIES PREFIX "") # We need our ".so" to be named "pytanque" (same name as in the BOOST_PYTHON_MODULE macro) 9 | set_target_properties(pytanque PROPERTIES 10 | VISIBILITY_INLINES_HIDDEN ON 11 | C_VISIBILITY_PRESET hidden 12 | CXX_VISIBILITY_PRESET hidden) 13 | 14 | target_link_libraries(pytanque PRIVATE petanque ${PYTHON_LIBRARIES} ${Boost_LIBRARIES} ${TBB_LIBRARIES}) 15 | 16 | execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())" OUTPUT_VARIABLE PYTHON_INSTALL OUTPUT_STRIP_TRAILING_WHITESPACE) 17 | install(TARGETS pytanque LIBRARY DESTINATION ${PYTHON_INSTALL}/ ARCHIVE DESTINATION ${PYTHON_INSTALL}/) 18 | -------------------------------------------------------------------------------- /petanque/bindings/python/distutils_pa_config/pa/config.h: -------------------------------------------------------------------------------- 1 | // This is a fixed configuration for petanque when compiled through distutils. 2 | // For now, TBB isn't supported this way. 3 | 4 | #ifndef PA_CONFIG_H 5 | #define PA_CONFIG_H 6 | 7 | #if 0 8 | #define PA_USE_TBB 9 | #endif 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /petanque/include/pa/config.h.in: -------------------------------------------------------------------------------- 1 | #ifndef PA_CONFIG_H 2 | #define PA_CONFIG_H 3 | 4 | #if @CONFIG_USE_TBB@ 5 | #define PA_USE_TBB 6 | #endif 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /petanque/llvm_distutils_env.bat: -------------------------------------------------------------------------------- 1 | call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64 2 | SET MSSdk=1 3 | SET DISTUTILS_USE_SDK=1 4 | FOR /F "skip=2 tokens=3,*" %%A IN ('reg query "HKLM\Software\LLVM\LLVM" /reg:32 /ve') DO set "LLVM_PATH=%%B" 5 | echo LLVM found in %LLVM_PATH% 6 | SET PATH=%LLVM_PATH%\msbuild-bin;%PATH% 7 | cmd.exe /k -------------------------------------------------------------------------------- /petanque/setup.cfg: -------------------------------------------------------------------------------- 1 | [metadata] 2 | description-file = README.rst 3 | -------------------------------------------------------------------------------- /petanque/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(SRC_FILES 2 | analyses.cpp 3 | app.cpp 4 | bitfield.cpp 5 | exprs.cpp 6 | matrix.cpp 7 | ops.cpp 8 | prettyprinter.cpp 9 | simps.cpp 10 | subs.cpp 11 | symbols.cpp 12 | syms_hist.cpp 13 | syms_set.cpp 14 | vector.cpp 15 | ) 16 | 17 | set(HEADER_DIST_FILES 18 | ../include/pa/analyses.h 19 | ../include/pa/app.h 20 | ../include/pa/bitfield.h 21 | ../include/pa/exprs.h 22 | ../include/pa/matrix.h 23 | ../include/pa/prettyprinter.h 24 | ../include/pa/subs.h 25 | ../include/pa/symbols.h 26 | ../include/pa/syms_hist.h 27 | ../include/pa/syms_set.h 28 | ../include/pa/traits.h 29 | ../include/pa/vector.h 30 | ) 31 | 32 | add_library(petanque ${SRC_FILES}) 33 | set(LINK_LIBRARIES ${TBB_LIBRARIES}) 34 | target_link_libraries(petanque PUBLIC ${LINK_LIBRARIES}) 35 | set_property(TARGET petanque PROPERTY POSITION_INDEPENDENT_CODE ON) 36 | if (BUILD_SHARED_LIBS) 37 | set_target_properties(petanque PROPERTIES 38 | VISIBILITY_INLINES_HIDDEN ON 39 | C_VISIBILITY_PRESET hidden 40 | CXX_VISIBILITY_PRESET hidden) 41 | else() 42 | target_compile_definitions(petanque PUBLIC petanque_STATIC) 43 | endif() 44 | 45 | install(TARGETS petanque LIBRARY DESTINATION lib ARCHIVE DESTINATION lib) 46 | install(FILES ${HEADER_DIST_FILES} DESTINATION include/pa) 47 | -------------------------------------------------------------------------------- /petanque/tests/algos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | int main() 7 | { 8 | { 9 | int ar_test[] = {0, 0, 1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 7}; 10 | int* ar_end = pa::remove_consecutives(std::begin(ar_test), std::end(ar_test)); 11 | std::cout << std::distance(ar_test, ar_end) << std::endl; 12 | for (int* pI = &ar_test[0]; pI < ar_end; pI++) { 13 | std::cout << *pI << ","; 14 | } 15 | std::cout << std::endl; 16 | } 17 | 18 | { 19 | int ar_test[] = {0, 1, 2, 3, 4, 5, 6}; 20 | int* ar_end = pa::remove_consecutives(std::begin(ar_test), std::end(ar_test)); 21 | std::cout << std::distance(ar_test, ar_end) << std::endl; 22 | for (int* pI = &ar_test[0]; pI < ar_end; pI++) { 23 | std::cout << *pI << ","; 24 | } 25 | std::cout << std::endl; 26 | } 27 | 28 | { 29 | int ar_test[] = {1}; 30 | int* ar_end = pa::remove_consecutives(std::begin(ar_test), std::end(ar_test)); 31 | std::cout << std::distance(ar_test, ar_end) << std::endl; 32 | for (int* pI = &ar_test[0]; pI < ar_end; pI++) { 33 | std::cout << *pI << ","; 34 | } 35 | std::cout << std::endl; 36 | } 37 | 38 | 39 | { 40 | int ar_test[] = {0, 0, 0, 0}; 41 | int* ar_end = pa::remove_consecutives(std::begin(ar_test), std::end(ar_test)); 42 | std::cout << std::distance(ar_test, ar_end) << std::endl; 43 | for (int* pI = &ar_test[0]; pI < ar_end; pI++) { 44 | std::cout << *pI << ","; 45 | } 46 | std::cout << std::endl; 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /petanque/tests/app.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace pa; 6 | 7 | int main() 8 | { 9 | int ret = 0; 10 | 11 | Expr x = symbol("x"); 12 | Expr y = symbol("y"); 13 | Expr z = symbol("z"); 14 | Expr t = symbol("t"); 15 | 16 | Vector syms({x, y, z, t}); 17 | Vector v({x + ExprImm(1), y + ExprImm(1), z + ExprImm(1), t + ExprImm(1)}); 18 | 19 | VectorApp app(syms, v); 20 | { 21 | Vector ref({Symbols::arg_symbol(0) + ExprImm(1), Symbols::arg_symbol(1) + ExprImm(1), Symbols::arg_symbol(2) + ExprImm(1), Symbols::arg_symbol(3) + ExprImm(1)}); 22 | if (app.vector() != ref) { 23 | std::cerr << "Error while creating VectorApp: bad vector computed!" << std::endl; 24 | ret = 1; 25 | } 26 | } 27 | 28 | { 29 | Vector test = app(syms); 30 | if (test != v) { 31 | std::cerr << "Error applying VectorApp: bad result" << std::endl; 32 | ret = 1; 33 | } 34 | } 35 | 36 | return ret; 37 | } 38 | -------------------------------------------------------------------------------- /petanque/tests/bench.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | int main(int argc, char** argv) 8 | { 9 | if (argc < 2) { 10 | std::cerr << "Usage: " << argv[0] << " n" << std::endl; 11 | return 1; 12 | } 13 | 14 | srand(time(NULL)); 15 | 16 | const size_t n = atoll(argv[1]); 17 | pa::Expr a = pa::symbol("a"); 18 | pa::Expr b = pa::symbol("b"); 19 | pa::Expr e = pa::ExprAdd(a, b); 20 | for (size_t i = 0; i < n; i++) { 21 | switch (rand()%7) { 22 | case 0: 23 | e = pa::ExprAdd(e, a); 24 | break; 25 | case 1: 26 | e = pa::ExprAdd(e, b); 27 | break; 28 | case 2: 29 | e = pa::ExprMul(e, a); 30 | break; 31 | case 3: 32 | e = pa::ExprMul(e, b); 33 | break; 34 | case 4: 35 | e = pa::ExprMul(e, pa::ExprAdd(b, a)); 36 | break; 37 | case 5: 38 | e = pa::ExprAdd(e, pa::ExprImm(1)); 39 | break; 40 | case 6: 41 | e = pa::ExprAdd(e, pa::ExprMul(a, b)); 42 | break; 43 | } 44 | } 45 | 46 | //std::cout << pa::pretty_print(e) << std::endl; 47 | pa::simps::expand(e); 48 | std::cout << pa::pretty_print(e) << std::endl; 49 | 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /petanque/tests/op_complex.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tests.h" 3 | 4 | int main() 5 | { 6 | int ret = 0; 7 | pa::Expr s0 = pa::ExprSym(0); 8 | pa::Expr s1 = pa::ExprSym(1); 9 | 10 | { 11 | pa::Expr expr = (s1 * (s0 + s1) + pa::ExprImm(1)) * pa::ExprImm(0); 12 | ret |= check_expr("(s1 * (s0 + s1) + pa::ExprImm(1)) * pa::ExprImm(0)", expr, pa::ExprImm(0)); 13 | } 14 | 15 | return ret; 16 | } 17 | -------------------------------------------------------------------------------- /petanque/tests/op_esf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "tests.h" 5 | 6 | #include 7 | 8 | int main() 9 | { 10 | int ret = 0; 11 | 12 | pa::Expr a = pa::symbol("a"); 13 | pa::Expr b = pa::symbol("b"); 14 | pa::Expr c = pa::symbol("c"); 15 | pa::Expr d = pa::symbol("d"); 16 | 17 | #if 0 18 | { 19 | pa::ExprAdd sf_add{{pa::ExprESF{2, {a, b}}, pa::ExprESF{1, {b, a}}, pa::ExprESF{1, {a, b}}}}; 20 | pa::simps::simplify(sf_add); 21 | ret |= check_expr("simplify(ESF(2, a, b) + ESF(1, b, a) + ESF(1, a, b))", sf_add, pa::ExprMul({a, b})); 22 | } 23 | #endif 24 | 25 | { 26 | pa::ExprESF sf2{1, {a, b, a}}; 27 | pa::simps::simplify(sf2); 28 | ret |= check_expr("ESF(1, a, b, a)", sf2, b); 29 | } 30 | 31 | { 32 | pa::ExprESF sf{1, {a, b, c, d}}; 33 | //sf.expand(); 34 | ret |= check_expr("expand(ESF(1, a, b, c, d))", sf, pa::ExprAdd({a, b, c, d})); 35 | } 36 | 37 | { 38 | pa::ExprESF sf{2, {a, b, c, d}}; 39 | sf.expand(); 40 | ret |= check_expr("expand(ESF(2, a, b, c, d))", sf, (a * b) + (a * c) + (a * d) + (b * c) + (b * d) + (c * d)); 41 | } 42 | 43 | { 44 | pa::ExprESF sf{2, {a, b, c, d}}; 45 | sf.expand(); 46 | ret |= check_expr("expand(ESF(2, a, b, c, d))", sf, (a * b) + (a * c) + (a * d) + (b * c) + (b * d) + (c * d)); 47 | } 48 | 49 | { 50 | pa::ExprESF sf{4, {a, b, c, d}}; 51 | ret |= check_expr("ESF(4, a, b, c, d)", sf, a*b*c*d); 52 | } 53 | 54 | return ret; 55 | } 56 | -------------------------------------------------------------------------------- /petanque/tests/op_names.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "tests.h" 3 | 4 | int main() 5 | { 6 | int ret = 0; 7 | 8 | pa::Expr m = pa::ExprMul(); 9 | pa::ExprAdd a; 10 | pa::Expr i(pa::ExprImm(true)); 11 | pa::Expr s(pa::ExprSym(0)); 12 | 13 | ret |= check_name(i, "Imm"); 14 | ret |= check_name(s, "Sym"); 15 | ret |= check_name(m, "Mul"); 16 | ret |= check_name(a, "Add"); 17 | 18 | return ret; 19 | } 20 | -------------------------------------------------------------------------------- /petanque/tests/or_to_esf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | 7 | static int check_expr(const char* expr, pa::Expr const& v, pa::Expr const& ref) 8 | { 9 | if (v != ref) { 10 | std::cerr << expr << " is invalid, expected "; 11 | pa::pretty_print(std::cerr, ref); 12 | std::cerr << ", got "; 13 | pa::pretty_print(std::cerr, v); 14 | std::cerr << std::endl; 15 | return 1; 16 | } 17 | else { 18 | std::cerr << expr << " gave "; 19 | pa::pretty_print(std::cerr, v); 20 | std::cerr << " as expected"; 21 | std::cerr << std::endl; 22 | } 23 | return 0; 24 | } 25 | 26 | int main() 27 | { 28 | int ret = 0; 29 | pa::pp_sym_display(true); 30 | 31 | pa::Expr s0 = pa::ExprSym(0); 32 | pa::Expr s1 = pa::ExprSym(1); 33 | pa::Expr s2 = pa::ExprSym(2); 34 | pa::Expr s3 = pa::ExprSym(3); 35 | pa::Expr s4 = pa::ExprSym(4); 36 | 37 | { 38 | pa::Expr e = s0|s1; 39 | pa::simps::or_to_esf(e); 40 | std::cout << pa::pretty_print(e) << std::endl; 41 | } 42 | 43 | { 44 | pa::Expr e = s0|s1|s2; 45 | pa::simps::or_to_esf(e); 46 | std::cout << pa::pretty_print(e) << std::endl; 47 | } 48 | 49 | { 50 | pa::Expr e = s0|s1|s2|s3; 51 | pa::simps::or_to_esf(e); 52 | std::cout << pa::pretty_print(e) << std::endl; 53 | } 54 | 55 | { 56 | pa::Expr e = s0|s1|s2|s3|s4; 57 | pa::simps::or_to_esf(e); 58 | std::cout << pa::pretty_print(e) << std::endl; 59 | } 60 | 61 | return ret; 62 | } 63 | -------------------------------------------------------------------------------- /petanque/tests/simp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "tests.h" 6 | 7 | using namespace pa; 8 | 9 | static int check(Expr const& e, Expr const& ref) 10 | { 11 | return check_expr(e, ref, [](pa::Expr& e) { simps::simplify(e); }); 12 | } 13 | 14 | int main() 15 | { 16 | // simplify will sort the arguments of add and mul operations and remove 17 | // duplicates. 18 | 19 | int ret = 0; 20 | 21 | Expr a = symbol("a"); 22 | Expr b = symbol("b"); 23 | Expr c = symbol("c"); 24 | Expr d = symbol("d"); 25 | Expr e = symbol("e"); 26 | 27 | { 28 | // ((Sym(X0) * Sym(Y0)) + (Sym(X0) * Sym(Y0) * Sym(X0) * Sym(Y0)) + Sym(X2) + Sym(Y2)) 29 | Expr exp = ExprAdd({ExprMul({a, b}), ExprMul({a, b, a, b}), d, e}); 30 | ret |= check(exp, ExprAdd({d, e})); 31 | } 32 | 33 | { 34 | // x[0]*y[0]*(x[0]+y[0]) 35 | Expr exp = ExprMul({a, b, ExprAdd({a, b})}); 36 | ret |= check(exp, ExprImm(false)); 37 | } 38 | 39 | { 40 | Expr exp = ExprMul({ExprOr({a,b}), c}); 41 | ret |= check(exp, ExprMul({ExprOr({a,b}), c})); 42 | } 43 | 44 | return ret; 45 | } 46 | -------------------------------------------------------------------------------- /petanque/tests/simp_constants_prop.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "tests.h" 5 | 6 | using namespace pa; 7 | 8 | int main() 9 | { 10 | // simplify will sort the arguments of add and mul operations and remove 11 | // duplicates. 12 | 13 | int ret = 0; 14 | 15 | Expr a = symbol("a"); 16 | Expr b = symbol("b"); 17 | Expr c = symbol("c"); 18 | Expr d = symbol("d"); 19 | Expr e = symbol("e"); 20 | 21 | { 22 | Expr exp = ExprMul({a, ExprMul({b, c}), a, b, ExprImm(0)}); 23 | simps::constants_prop(exp); 24 | ret |= check_expr("a * (b*c) * a * b * 0", exp, ExprImm(0)); 25 | } 26 | 27 | return ret; 28 | } 29 | -------------------------------------------------------------------------------- /petanque/tests/syms_set.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define ASSERT_VALID(b)\ 7 | if (!(b)) {\ 8 | std::cerr << #b << " is false" << std::endl;\ 9 | ret = 1;\ 10 | } 11 | 12 | int main() 13 | { 14 | pa::SymbolsSet sset; 15 | pa::ExprSym sA = pa::symbol("sA"); 16 | pa::ExprSym sB = pa::symbol("sB"); 17 | pa::ExprSym sC = pa::symbol("sC"); 18 | pa::ExprSym sD = pa::symbol("sD"); 19 | 20 | int ret = 0; 21 | 22 | ASSERT_VALID(sset.insert(sA) == true); 23 | ASSERT_VALID(sset.insert(sA) == false); 24 | ASSERT_VALID(sset.has(sA)); 25 | ASSERT_VALID(sset.insert(sB) == true); 26 | ASSERT_VALID(sset.insert(sC) == true); 27 | ASSERT_VALID(sset.insert(sD) == true); 28 | ASSERT_VALID(sset.insert(sB) == false); 29 | ASSERT_VALID(sset.insert(sC) == false); 30 | ASSERT_VALID(sset.insert(sD) == false); 31 | 32 | std::set list; 33 | for (pa::ExprSym S: sset) { 34 | list.insert(S); 35 | } 36 | std::set ref; 37 | ref.insert(sA); 38 | ref.insert(sB); 39 | ref.insert(sC); 40 | ref.insert(sD); 41 | ASSERT_VALID((list == ref)); 42 | 43 | 44 | return ret; 45 | } 46 | -------------------------------------------------------------------------------- /petanque/tests/tests.h: -------------------------------------------------------------------------------- 1 | #ifndef PA_TESTS_H 2 | #define PA_TESTS_H 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | 9 | int check_expr(pa::Expr const& e_, pa::Expr const& ref, std::function const& F); 10 | int check_expr(const char* expr, pa::Expr const& v, pa::Expr const& ref); 11 | int check_imm(pa::Expr const& e, bool v); 12 | int check_name(pa::Expr const& e, const char* name); 13 | 14 | template 15 | static int check_type(pa::Expr const& e) 16 | { 17 | if (e.type() != (E::type_id)) { 18 | std::cerr << "Bad type!" << std::endl; 19 | return 1; 20 | } 21 | return 0; 22 | } 23 | 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /petanque/tests/vec_int.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() 5 | { 6 | pa::Vector v; 7 | int ret = 0; 8 | for (int i = 0; i < 1024; i++) { 9 | v.set_int_be(i, 4); 10 | int vbe = v.get_int_be(); 11 | int ref = i&15; 12 | if (vbe != ref) { 13 | std::cerr << "(be) " << pa::pretty_print(v) << " != " << ref << ", got " << vbe << std::endl; 14 | ret = 1; 15 | } 16 | 17 | v.set_int_le(i, 4); 18 | int vle = v.get_int_le(); 19 | if (vle != ref) { 20 | std::cerr << "(le) " << pa::pretty_print(v) << " != " << ref << ", got " << vle << std::endl; 21 | ret = 1; 22 | } 23 | 24 | if (vle != vbe) { 25 | std::cerr << "for i = " << i << ", vbe != vle (" << vbe << " != " << vle << ")" << std::endl; 26 | ret = 1; 27 | } 28 | } 29 | 30 | return ret; 31 | } 32 | -------------------------------------------------------------------------------- /petanque/tests/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace pa; 5 | 6 | int check_vector(Vector const& v, Vector const& ref) 7 | { 8 | if (v != ref) { 9 | std::cerr << "Invalid vector, got " << pretty_print(v) << ", got " << pretty_print(ref) << std::endl; 10 | return 1; 11 | } 12 | return 0; 13 | } 14 | 15 | int main() 16 | { 17 | int ret = 0; 18 | 19 | Expr a = symbol("a"); 20 | Expr b = symbol("b"); 21 | 22 | Vector v1(4, ExprImm(1)); 23 | Vector v0(4, ExprImm(0)); 24 | 25 | Vector va(4, a); 26 | Vector vb(4, b); 27 | 28 | ret |= check_vector(va + vb, Vector(4, a + b)); 29 | ret |= check_vector(va + v1, Vector(4, a + ExprImm(1))); 30 | ret |= check_vector(va + v0, Vector(4, a)); 31 | ret |= check_vector(va + va, Vector(4, ExprImm(0))); 32 | ret |= check_vector(va*va, va); 33 | 34 | va *= va; 35 | ret |= check_vector(va, va); 36 | 37 | va += va; 38 | ret |= check_vector(va, Vector(4, ExprImm(0))); 39 | 40 | Expr c = symbol("c"); 41 | Expr d = symbol("d"); 42 | 43 | Vector vs({{a, b, c, d}}); 44 | 45 | ret |= check_vector(vs << 2, Vector({{c, d, ExprImm(0), ExprImm(0)}})); 46 | ret |= check_vector(vs << 4, Vector(4, ExprImm(0))); 47 | ret |= check_vector(vs >> 1, Vector({{ExprImm(0), a, b, c}})); 48 | ret |= check_vector(vs >> 4, Vector(4, ExprImm(0))); 49 | ret |= check_vector(vs >> 5, Vector(4, ExprImm(0))); 50 | 51 | return ret; 52 | } 53 | -------------------------------------------------------------------------------- /petanque/third-party/bcp.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # Script used to extract the part of boost needed 3 | 4 | rm -rf tmp boost 5 | mkdir tmp 6 | bcp --unix-lines --boost=/usr/include type_traits/function_traits.hpp integer/static_log2.hpp iterator/iterator_facade.hpp tmp 7 | mv tmp/boost . 8 | rm -rf tmp 9 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/abi/borland_prefix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // for C++ Builder the following options effect the ABI: 7 | // 8 | // -b (on or off - effect emum sizes) 9 | // -Vx (on or off - empty members) 10 | // -Ve (on or off - empty base classes) 11 | // -aX (alignment - 5 options). 12 | // -pX (Calling convention - 4 options) 13 | // -VmX (member pointer size and layout - 5 options) 14 | // -VC (on or off, changes name mangling) 15 | // -Vl (on or off, changes struct layout). 16 | 17 | // In addition the following warnings are sufficiently annoying (and 18 | // unfixable) to have them turned off by default: 19 | // 20 | // 8027 - functions containing [for|while] loops are not expanded inline 21 | // 8026 - functions taking class by value arguments are not expanded inline 22 | 23 | #pragma nopushoptwarn 24 | # pragma option push -a8 -Vx- -Ve- -b- -pc -Vmv -VC- -Vl- -w-8027 -w-8026 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/abi/borland_suffix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | # pragma option pop 7 | #pragma nopushoptwarn 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/abi/msvc_prefix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // 7 | // Boost binaries are built with the compiler's default ABI settings, 8 | // if the user changes their default alignment in the VS IDE then their 9 | // code will no longer be binary compatible with the bjam built binaries 10 | // unless this header is included to force Boost code into a consistent ABI. 11 | // 12 | // Note that inclusion of this header is only necessary for libraries with 13 | // separate source, header only libraries DO NOT need this as long as all 14 | // translation units are built with the same options. 15 | // 16 | #if defined(_M_X64) 17 | # pragma pack(push,16) 18 | #else 19 | # pragma pack(push,8) 20 | #endif 21 | 22 | 23 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/abi/msvc_suffix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #pragma pack(pop) 7 | 8 | 9 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/abi_prefix.hpp: -------------------------------------------------------------------------------- 1 | // abi_prefix header -------------------------------------------------------// 2 | 3 | // (c) Copyright John Maddock 2003 4 | 5 | // Use, modification and distribution are subject to the Boost Software License, 6 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt). 8 | 9 | #ifndef BOOST_CONFIG_ABI_PREFIX_HPP 10 | # define BOOST_CONFIG_ABI_PREFIX_HPP 11 | #else 12 | # error double inclusion of header boost/config/abi_prefix.hpp is an error 13 | #endif 14 | 15 | #include 16 | 17 | // this must occur after all other includes and before any code appears: 18 | #ifdef BOOST_HAS_ABI_HEADERS 19 | # include BOOST_ABI_PREFIX 20 | #endif 21 | 22 | #if defined( __BORLANDC__ ) 23 | #pragma nopushoptwarn 24 | #endif 25 | 26 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/abi_suffix.hpp: -------------------------------------------------------------------------------- 1 | // abi_sufffix header -------------------------------------------------------// 2 | 3 | // (c) Copyright John Maddock 2003 4 | 5 | // Use, modification and distribution are subject to the Boost Software License, 6 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt). 8 | 9 | // This header should be #included AFTER code that was preceded by a #include 10 | // . 11 | 12 | #ifndef BOOST_CONFIG_ABI_PREFIX_HPP 13 | # error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp 14 | #else 15 | # undef BOOST_CONFIG_ABI_PREFIX_HPP 16 | #endif 17 | 18 | // the suffix header occurs after all of our code: 19 | #ifdef BOOST_HAS_ABI_HEADERS 20 | # include BOOST_ABI_SUFFIX 21 | #endif 22 | 23 | #if defined( __BORLANDC__ ) 24 | #pragma nopushoptwarn 25 | #endif 26 | 27 | 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/compiler/compaq_cxx.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // Tru64 C++ compiler setup (now HP): 9 | 10 | #define BOOST_COMPILER "HP Tru64 C++ " BOOST_STRINGIZE(__DECCXX_VER) 11 | 12 | #include 13 | 14 | // 15 | // versions check: 16 | // Nothing to do here? 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/compiler/diab.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Brian Kuhl 2016. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // Check this is a recent EDG based compiler, otherwise we don't support it here: 7 | 8 | 9 | #ifndef __EDG_VERSION__ 10 | # error "Unknown Diab compiler version - please run the configure tests and report the results" 11 | #endif 12 | 13 | #include "boost/config/compiler/common_edg.hpp" 14 | 15 | #define BOOST_NO_TWO_PHASE_NAME_LOOKUP 16 | #define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS 17 | 18 | #define BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 19 | #define BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS 20 | #define BOOST_REGEX_NO_EXTERNAL_TEMPLATES 21 | 22 | #define BOOST_NO_CXX11_HDR_INITIALIZER_LIST 23 | #define BOOST_NO_CXX11_HDR_CODECVT 24 | #define BOOST_NO_CXX11_NUMERIC_LIMITS 25 | 26 | #define BOOST_COMPILER "Wind River Diab " BOOST_STRINGIZE(__VERSION_NUMBER__) 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/compiler/greenhills.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // Greenhills C++ compiler setup: 9 | 10 | #define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs) 11 | 12 | #include 13 | 14 | // 15 | // versions check: 16 | // we don't support Greenhills prior to version 0: 17 | #if __ghs < 0 18 | # error "Compiler not supported or configured - please reconfigure" 19 | #endif 20 | // 21 | // last known and checked version is 0: 22 | #if (__ghs > 0) 23 | # if defined(BOOST_ASSERT_CONFIG) 24 | # error "Unknown compiler version - please run the configure tests and report the results" 25 | # endif 26 | #endif 27 | 28 | 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/compiler/kai.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001. 2 | // (C) Copyright David Abrahams 2002. 3 | // (C) Copyright Aleksey Gurtovoy 2002. 4 | // Use, modification and distribution are subject to the 5 | // Boost Software License, Version 1.0. (See accompanying file 6 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 7 | 8 | // See http://www.boost.org for most recent version. 9 | 10 | // Kai C++ compiler setup: 11 | 12 | #include 13 | 14 | # if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG) 15 | // at least on Sun, the contents of is not in namespace std 16 | # define BOOST_NO_STDC_NAMESPACE 17 | # endif 18 | 19 | // see also common_edg.hpp which needs a special check for __KCC 20 | # if !defined(_EXCEPTIONS) && !defined(BOOST_NO_EXCEPTIONS) 21 | # define BOOST_NO_EXCEPTIONS 22 | # endif 23 | 24 | // 25 | // last known and checked version is 4001: 26 | #if (__KCC_VERSION > 4001) 27 | # if defined(BOOST_ASSERT_CONFIG) 28 | # error "Unknown compiler version - please run the configure tests and report the results" 29 | # endif 30 | #endif 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/compiler/pgi.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Noel Belcourt 2007. 2 | // Copyright 2017, NVIDIA CORPORATION. 3 | // Use, modification and distribution are subject to the 4 | // Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // PGI C++ compiler setup: 10 | 11 | #define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__ 12 | #define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) 13 | 14 | // PGI is mostly GNU compatible. So start with that. 15 | #include 16 | 17 | // Now adjust for things that are different. 18 | 19 | // __float128 is a typedef, not a distinct type. 20 | #undef BOOST_HAS_FLOAT128 21 | 22 | // __int128 is not supported. 23 | #undef BOOST_HAS_INT128 24 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/compiler/sgi_mipspro.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2002. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // SGI C++ compiler setup: 9 | 10 | #define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION) 11 | 12 | #include 13 | 14 | // 15 | // Threading support: 16 | // Turn this on unconditionally here, it will get turned off again later 17 | // if no threading API is detected. 18 | // 19 | #define BOOST_HAS_THREADS 20 | #define BOOST_NO_TWO_PHASE_NAME_LOOKUP 21 | 22 | #undef BOOST_NO_SWPRINTF 23 | #undef BOOST_DEDUCED_TYPENAME 24 | 25 | // 26 | // version check: 27 | // probably nothing to do here? 28 | 29 | 30 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/header_deprecated.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED 2 | #define BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED 3 | 4 | // Copyright 2017 Peter Dimov. 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // 8 | // See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt 10 | // 11 | // BOOST_HEADER_DEPRECATED("") 12 | // 13 | // Expands to the equivalent of 14 | // BOOST_PRAGMA_MESSAGE("This header is deprecated. Use instead.") 15 | // 16 | // Note that this header is C compatible. 17 | 18 | #include 19 | 20 | #if defined(BOOST_ALLOW_DEPRECATED_HEADERS) 21 | # define BOOST_HEADER_DEPRECATED(a) 22 | #else 23 | # define BOOST_HEADER_DEPRECATED(a) BOOST_PRAGMA_MESSAGE("This header is deprecated. Use " a " instead.") 24 | #endif 25 | 26 | #endif // BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/helper_macros.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED 2 | #define BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED 3 | 4 | // Copyright 2001 John Maddock. 5 | // Copyright 2017 Peter Dimov. 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // 9 | // See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt 11 | // 12 | // BOOST_STRINGIZE(X) 13 | // BOOST_JOIN(X, Y) 14 | // 15 | // Note that this header is C compatible. 16 | 17 | // 18 | // Helper macro BOOST_STRINGIZE: 19 | // Converts the parameter X to a string after macro replacement 20 | // on X has been performed. 21 | // 22 | #define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) 23 | #define BOOST_DO_STRINGIZE(X) #X 24 | 25 | // 26 | // Helper macro BOOST_JOIN: 27 | // The following piece of macro magic joins the two 28 | // arguments together, even when one of the arguments is 29 | // itself a macro (see 16.3.1 in C++ standard). The key 30 | // is that macro expansion of macro arguments does not 31 | // occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. 32 | // 33 | #define BOOST_JOIN(X, Y) BOOST_DO_JOIN(X, Y) 34 | #define BOOST_DO_JOIN(X, Y) BOOST_DO_JOIN2(X,Y) 35 | #define BOOST_DO_JOIN2(X, Y) X##Y 36 | 37 | #endif // BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED 38 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/no_tr1/cmath.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2008. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/cmath is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_CMATH 14 | # define BOOST_CONFIG_CMATH 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_CMATH_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_CMATH_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_CMATH_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/no_tr1/complex.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/complex is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_COMPLEX 14 | # define BOOST_CONFIG_COMPLEX 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_COMPLEX_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_COMPLEX_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_COMPLEX_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/no_tr1/functional.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/functional is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_FUNCTIONAL 14 | # define BOOST_CONFIG_FUNCTIONAL 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/no_tr1/memory.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/memory is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_MEMORY 14 | # define BOOST_CONFIG_MEMORY 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_MEMORY_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_MEMORY_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_MEMORY_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/no_tr1/utility.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/utility is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_UTILITY 14 | # define BOOST_CONFIG_UTILITY 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_UTILITY_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_UTILITY_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_UTILITY_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/aix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2002. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // IBM/Aix specific config options: 9 | 10 | #define BOOST_PLATFORM "IBM Aix" 11 | 12 | #define BOOST_HAS_UNISTD_H 13 | #define BOOST_HAS_NL_TYPES_H 14 | #define BOOST_HAS_NANOSLEEP 15 | #define BOOST_HAS_CLOCK_GETTIME 16 | 17 | // This needs support in "boost/cstdint.hpp" exactly like FreeBSD. 18 | // This platform has header named which includes all 19 | // the things needed. 20 | #define BOOST_HAS_STDINT_H 21 | 22 | // Threading API's: 23 | #define BOOST_HAS_PTHREADS 24 | #define BOOST_HAS_PTHREAD_DELAY_NP 25 | #define BOOST_HAS_SCHED_YIELD 26 | //#define BOOST_HAS_PTHREAD_YIELD 27 | 28 | // boilerplate code: 29 | #include 30 | 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/amigaos.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2002. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | #define BOOST_PLATFORM "AmigaOS" 9 | 10 | #define BOOST_DISABLE_THREADS 11 | #define BOOST_NO_CWCHAR 12 | #define BOOST_NO_STD_WSTRING 13 | #define BOOST_NO_INTRINSIC_WCHAR_T 14 | 15 | 16 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/beos.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // BeOS specific config options: 9 | 10 | #define BOOST_PLATFORM "BeOS" 11 | 12 | #define BOOST_NO_CWCHAR 13 | #define BOOST_NO_CWCTYPE 14 | #define BOOST_HAS_UNISTD_H 15 | 16 | #define BOOST_HAS_BETHREADS 17 | 18 | #ifndef BOOST_DISABLE_THREADS 19 | # define BOOST_HAS_THREADS 20 | #endif 21 | 22 | // boilerplate code: 23 | #include 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/cloudabi.hpp: -------------------------------------------------------------------------------- 1 | // Copyright Nuxi, https://nuxi.nl/ 2015. 2 | // Distributed under the Boost Software License, Version 1.0. 3 | // (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #define BOOST_PLATFORM "CloudABI" 7 | 8 | #define BOOST_HAS_DIRENT_H 9 | #define BOOST_HAS_STDINT_H 10 | #define BOOST_HAS_UNISTD_H 11 | 12 | #define BOOST_HAS_CLOCK_GETTIME 13 | #define BOOST_HAS_EXPM1 14 | #define BOOST_HAS_GETTIMEOFDAY 15 | #define BOOST_HAS_LOG1P 16 | #define BOOST_HAS_NANOSLEEP 17 | #define BOOST_HAS_PTHREADS 18 | #define BOOST_HAS_SCHED_YIELD 19 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/cray.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2011. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // SGI Irix specific config options: 10 | 11 | #define BOOST_PLATFORM "Cray" 12 | 13 | // boilerplate code: 14 | #define BOOST_HAS_UNISTD_H 15 | #include 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/haiku.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Jessica Hamilton 2014. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // Haiku specific config options: 9 | 10 | #define BOOST_PLATFORM "Haiku" 11 | 12 | #define BOOST_HAS_UNISTD_H 13 | #define BOOST_HAS_STDINT_H 14 | 15 | #ifndef BOOST_DISABLE_THREADS 16 | # define BOOST_HAS_THREADS 17 | #endif 18 | 19 | #define BOOST_NO_CXX11_HDR_TYPE_TRAITS 20 | #define BOOST_NO_CXX11_ATOMIC_SMART_PTR 21 | #define BOOST_NO_CXX11_STATIC_ASSERT 22 | #define BOOST_NO_CXX11_VARIADIC_MACROS 23 | 24 | // 25 | // thread API's not auto detected: 26 | // 27 | #define BOOST_HAS_SCHED_YIELD 28 | #define BOOST_HAS_GETTIMEOFDAY 29 | 30 | // boilerplate code: 31 | #include 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/irix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2003. 2 | // (C) Copyright Jens Maurer 2003. 3 | // Use, modification and distribution are subject to the 4 | // Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | 8 | // See http://www.boost.org for most recent version. 9 | 10 | // SGI Irix specific config options: 11 | 12 | #define BOOST_PLATFORM "SGI Irix" 13 | 14 | #define BOOST_NO_SWPRINTF 15 | // 16 | // these are not auto detected by POSIX feature tests: 17 | // 18 | #define BOOST_HAS_GETTIMEOFDAY 19 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 20 | 21 | #ifdef __GNUC__ 22 | // GNU C on IRIX does not support threads (checked up to gcc 3.3) 23 | # define BOOST_DISABLE_THREADS 24 | #endif 25 | 26 | // boilerplate code: 27 | #define BOOST_HAS_UNISTD_H 28 | #include 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/qnxnto.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Jim Douglas 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // QNX specific config options: 9 | 10 | #define BOOST_PLATFORM "QNX" 11 | 12 | #define BOOST_HAS_UNISTD_H 13 | #include 14 | 15 | // QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h 16 | // or log1p and expm1: 17 | #undef BOOST_HAS_NL_TYPES_H 18 | #undef BOOST_HAS_LOG1P 19 | #undef BOOST_HAS_EXPM1 20 | 21 | #define BOOST_HAS_PTHREADS 22 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 23 | 24 | #define BOOST_HAS_GETTIMEOFDAY 25 | #define BOOST_HAS_CLOCK_GETTIME 26 | #define BOOST_HAS_NANOSLEEP 27 | 28 | 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/solaris.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2003. 2 | // (C) Copyright Jens Maurer 2003. 3 | // Use, modification and distribution are subject to the 4 | // Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // sun specific config options: 10 | 11 | #define BOOST_PLATFORM "Sun Solaris" 12 | 13 | #define BOOST_HAS_GETTIMEOFDAY 14 | 15 | // boilerplate code: 16 | #define BOOST_HAS_UNISTD_H 17 | #include 18 | 19 | // 20 | // pthreads don't actually work with gcc unless _PTHREADS is defined: 21 | // 22 | #if defined(__GNUC__) && defined(_POSIX_THREADS) && !defined(_PTHREADS) 23 | # undef BOOST_HAS_PTHREADS 24 | #endif 25 | 26 | #define BOOST_HAS_STDINT_H 27 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 28 | #define BOOST_HAS_LOG1P 29 | #define BOOST_HAS_EXPM1 30 | 31 | 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/vms.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Artyom Beilis 2010. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #ifndef BOOST_CONFIG_PLATFORM_VMS_HPP 7 | #define BOOST_CONFIG_PLATFORM_VMS_HPP 8 | 9 | #define BOOST_PLATFORM "OpenVMS" 10 | 11 | #undef BOOST_HAS_STDINT_H 12 | #define BOOST_HAS_UNISTD_H 13 | #define BOOST_HAS_NL_TYPES_H 14 | #define BOOST_HAS_GETTIMEOFDAY 15 | #define BOOST_HAS_DIRENT_H 16 | #define BOOST_HAS_PTHREADS 17 | #define BOOST_HAS_NANOSLEEP 18 | #define BOOST_HAS_CLOCK_GETTIME 19 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 20 | #define BOOST_HAS_LOG1P 21 | #define BOOST_HAS_EXPM1 22 | #define BOOST_HAS_THREADS 23 | #undef BOOST_HAS_SCHED_YIELD 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/platform/zos.hpp: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2017 Dynatrace 2 | // 3 | // Distributed under the Boost Software License, Version 1.0. 4 | // See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // Platform setup for IBM z/OS. 10 | 11 | #define BOOST_PLATFORM "IBM z/OS" 12 | 13 | #include // For __UU, __C99, __TR1, ... 14 | 15 | #if defined(__UU) 16 | # define BOOST_HAS_GETTIMEOFDAY 17 | #endif 18 | 19 | #if defined(_OPEN_THREADS) || defined(__SUSV3_THR) 20 | # define BOOST_HAS_PTHREADS 21 | # define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 22 | # define BOOST_HAS_THREADS 23 | #endif 24 | 25 | #if defined(__SUSV3) || defined(__SUSV3_THR) 26 | # define BOOST_HAS_SCHED_YIELD 27 | #endif 28 | 29 | #define BOOST_HAS_SIGACTION 30 | #define BOOST_HAS_UNISTD_H 31 | #define BOOST_HAS_DIRENT_H 32 | #define BOOST_HAS_NL_TYPES_H 33 | -------------------------------------------------------------------------------- /petanque/third-party/boost/config/pragma_message.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED 2 | #define BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED 3 | 4 | // Copyright 2017 Peter Dimov. 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // 8 | // See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt 10 | // 11 | // BOOST_PRAGMA_MESSAGE("message") 12 | // 13 | // Expands to the equivalent of #pragma message("message") 14 | // 15 | // Note that this header is C compatible. 16 | 17 | #include 18 | 19 | #if defined(BOOST_DISABLE_PRAGMA_MESSAGE) 20 | # define BOOST_PRAGMA_MESSAGE(x) 21 | #elif defined(__INTEL_COMPILER) 22 | # define BOOST_PRAGMA_MESSAGE(x) __pragma(message(__FILE__ "(" BOOST_STRINGIZE(__LINE__) "): note: " x)) 23 | #elif defined(__GNUC__) 24 | # define BOOST_PRAGMA_MESSAGE(x) _Pragma(BOOST_STRINGIZE(message(x))) 25 | #elif defined(_MSC_VER) 26 | # define BOOST_PRAGMA_MESSAGE(x) __pragma(message(__FILE__ "(" BOOST_STRINGIZE(__LINE__) "): note: " x)) 27 | #else 28 | # define BOOST_PRAGMA_MESSAGE(x) 29 | #endif 30 | 31 | #endif // BOOST_CONFIG_PRAGMA_MESSAGE_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/detail/workaround.hpp: -------------------------------------------------------------------------------- 1 | // Copyright David Abrahams 2002. 2 | // Distributed under the Boost Software License, Version 1.0. (See 3 | // accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | #ifndef WORKAROUND_DWA2002126_HPP 6 | #define WORKAROUND_DWA2002126_HPP 7 | 8 | #include 9 | 10 | #endif // WORKAROUND_DWA2002126_HPP 11 | -------------------------------------------------------------------------------- /petanque/third-party/boost/iterator/detail/config_undef.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Thomas Witt 2002. 2 | // Distributed under the Boost Software License, Version 1.0. (See 3 | // accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // no include guard multiple inclusion intended 7 | 8 | // 9 | // This is a temporary workaround until the bulk of this is 10 | // available in boost config. 11 | // 23/02/03 thw 12 | // 13 | 14 | #undef BOOST_NO_IS_CONVERTIBLE 15 | #undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE 16 | #undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY 17 | #undef BOOST_NO_LVALUE_RETURN_DETECTION 18 | #undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP 19 | 20 | #ifdef BOOST_ITERATOR_CONFIG_DEF 21 | # undef BOOST_ITERATOR_CONFIG_DEF 22 | #else 23 | # error missing or nested #include config_def 24 | #endif 25 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/always.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED 3 | #define BOOST_MPL_ALWAYS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | namespace boost { namespace mpl { 22 | 23 | template< typename Value > struct always 24 | { 25 | template< 26 | BOOST_MPL_PP_DEFAULT_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, typename T, na) 27 | > 28 | struct apply 29 | { 30 | typedef Value type; 31 | }; 32 | }; 33 | 34 | BOOST_MPL_AUX_ARITY_SPEC(0, always) 35 | 36 | }} 37 | 38 | #endif // BOOST_MPL_ALWAYS_HPP_INCLUDED 39 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/arg_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_ARG_FWD_HPP_INCLUDED 4 | 5 | // Copyright Peter Dimov 2001-2002 6 | // Copyright Aleksey Gurtovoy 2001-2004 7 | // 8 | // Distributed under the Boost Software License, Version 1.0. 9 | // (See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt) 11 | // 12 | // See http://www.boost.org/libs/mpl for documentation. 13 | 14 | // $Id$ 15 | // $Date$ 16 | // $Revision$ 17 | 18 | #include 19 | #include 20 | 21 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 22 | 23 | template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arg; 24 | 25 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 26 | BOOST_MPL_AUX_ADL_BARRIER_DECL(arg) 27 | 28 | #endif // BOOST_MPL_ARG_FWD_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/arg_typedef.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ 21 | || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) 22 | 23 | # define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) typedef T name; 24 | 25 | #else 26 | 27 | # define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) /**/ 28 | 29 | #endif 30 | 31 | #endif // BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_ARITY_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_ARITY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) 20 | 21 | # include 22 | # include 23 | 24 | namespace boost { namespace mpl { namespace aux { 25 | 26 | // agurt, 15/mar/02: it's possible to implement the template so that it will 27 | // "just work" and do not require any specialization, but not on the compilers 28 | // that require the arity workaround in the first place 29 | template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > 30 | struct arity 31 | { 32 | BOOST_STATIC_CONSTANT(int, value = N); 33 | }; 34 | 35 | }}} 36 | 37 | #endif // BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES 38 | 39 | #endif // BOOST_MPL_AUX_ARITY_HPP_INCLUDED 40 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/common_name_wknd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if BOOST_WORKAROUND(__BORLANDC__, < 0x561) 20 | // agurt, 12/nov/02: to suppress the bogus "Cannot have both a template class 21 | // and function named 'xxx'" diagnostic 22 | # define BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ 23 | namespace name_##wknd { \ 24 | template< typename > void name(); \ 25 | } \ 26 | /**/ 27 | 28 | #else 29 | 30 | # define BOOST_MPL_AUX_COMMON_NAME_WKND(name) /**/ 31 | 32 | #endif // __BORLANDC__ 33 | 34 | #endif // BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/arrays.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2003-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \ 21 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 22 | && ( BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ 23 | || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 24 | ) 25 | 26 | # define BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES 27 | 28 | #endif 29 | 30 | #endif // BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/bcc.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2008 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date: 2004-09-02 10:41:37 -0500 (Thu, 02 Sep 2004) $ 15 | // $Revision: 24874 $ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && BOOST_WORKAROUND(__BORLANDC__, >= 0x590) \ 22 | && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) 23 | 24 | # define BOOST_MPL_CFG_BCC590_WORKAROUNDS 25 | 26 | #endif 27 | 28 | #endif // BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/bind.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 4 | 5 | // Copyright David Abrahams 2002 6 | // Copyright Aleksey Gurtovoy 2002-2004 7 | // 8 | // Distributed under the Boost Software License, Version 1.0. 9 | // (See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt) 11 | // 12 | // See http://www.boost.org/libs/mpl for documentation. 13 | 14 | // $Id$ 15 | // $Date$ 16 | // $Revision$ 17 | 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \ 22 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 23 | && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 24 | || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ 25 | ) 26 | 27 | # define BOOST_MPL_CFG_NO_BIND_TEMPLATE 28 | 29 | #endif 30 | 31 | //#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT 32 | 33 | #endif // BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/ctps.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) \ 21 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 22 | && BOOST_WORKAROUND(__BORLANDC__, < 0x582) 23 | 24 | # define BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC 25 | 26 | #endif 27 | 28 | // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined in 29 | 30 | #endif // BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) 22 | 23 | # define BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS 24 | 25 | #endif 26 | 27 | #endif // BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/eti.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | // flags for MSVC 6.5's so-called "early template instantiation bug" 21 | #if !defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \ 22 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 23 | && BOOST_WORKAROUND(BOOST_MSVC, < 1300) 24 | 25 | # define BOOST_MPL_CFG_MSVC_60_ETI_BUG 26 | 27 | #endif 28 | 29 | #if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \ 30 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 31 | && BOOST_WORKAROUND(BOOST_MSVC, == 1300) 32 | 33 | # define BOOST_MPL_CFG_MSVC_70_ETI_BUG 34 | 35 | #endif 36 | 37 | #if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) \ 38 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 39 | && ( defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \ 40 | || defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \ 41 | ) 42 | 43 | # define BOOST_MPL_CFG_MSVC_ETI_BUG 44 | 45 | #endif 46 | 47 | #endif // BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED 48 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/gcc.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if defined(__GNUC__) && !defined(__EDG_VERSION__) 18 | # define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__) 19 | #else 20 | # define BOOST_MPL_CFG_GCC 0 21 | #endif 22 | 23 | #endif // BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/gpu.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 4 | 5 | // Copyright Eric Niebler 2014 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_GPU_ENABLED) \ 20 | 21 | # define BOOST_MPL_CFG_GPU_ENABLED BOOST_GPU_ENABLED 22 | 23 | #endif 24 | 25 | #if defined __CUDACC__ 26 | 27 | # define BOOST_MPL_CFG_GPU 1 28 | 29 | #else 30 | 31 | # define BOOST_MPL_CFG_GPU 0 32 | 33 | #endif 34 | 35 | #endif // BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 36 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/has_apply.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) \ 22 | && ( defined(BOOST_MPL_CFG_NO_HAS_XXX) \ 23 | || BOOST_WORKAROUND(__EDG_VERSION__, < 300) \ 24 | || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 25 | || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ 26 | ) 27 | 28 | # define BOOST_MPL_CFG_NO_HAS_APPLY 29 | 30 | #endif 31 | 32 | #endif // BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/has_xxx.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // Copyright David Abrahams 2002-2003 7 | // 8 | // Distributed under the Boost Software License, Version 1.0. 9 | // (See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt) 11 | // 12 | // See http://www.boost.org/libs/mpl for documentation. 13 | 14 | // $Id$ 15 | // $Date$ 16 | // $Revision$ 17 | 18 | #include 19 | #include 20 | 21 | // agurt, 11/jan/03: signals a stub-only 'has_xxx' implementation 22 | 23 | #if !defined(BOOST_MPL_CFG_NO_HAS_XXX) \ 24 | && ( defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ 25 | || BOOST_WORKAROUND(__GNUC__, <= 2) \ 26 | || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ 27 | ) 28 | 29 | # define BOOST_MPL_CFG_NO_HAS_XXX 30 | # define BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 31 | 32 | #endif 33 | 34 | #endif // BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/integral.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if !defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \ 21 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 22 | && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) 23 | 24 | # define BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS 25 | 26 | #endif 27 | 28 | #if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) \ 29 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 30 | && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 31 | || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \ 32 | ) 33 | 34 | # define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC 35 | 36 | #endif 37 | 38 | #endif // BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED 39 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/intel.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | 18 | // BOOST_INTEL_CXX_VERSION is defined here: 19 | #include 20 | 21 | #endif // BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/lambda.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | // agurt, 15/jan/02: full-fledged implementation requires both 21 | // template template parameters _and_ partial specialization 22 | 23 | #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ 24 | && ( defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ 25 | || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 26 | ) 27 | 28 | # define BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT 29 | 30 | #endif 31 | 32 | #endif // BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/msvc.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | 18 | // BOOST_MSVC is defined here: 19 | #include 20 | 21 | #endif // BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/msvc_typename.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 21 | # define BOOST_MSVC_TYPENAME 22 | #else 23 | # define BOOST_MSVC_TYPENAME typename 24 | #endif 25 | 26 | #endif // BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/nttp.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | // MSVC 6.5 ICE-s on the code as simple as this (see "aux_/nttp_decl.hpp" 21 | // for a workaround): 22 | // 23 | // namespace std { 24 | // template< typename Char > struct string; 25 | // } 26 | // 27 | // void foo(std::string); 28 | // 29 | // namespace boost { namespace mpl { 30 | // template< int > struct arg; 31 | // }} 32 | 33 | #if !defined(BOOST_MPL_CFG_NTTP_BUG) \ 34 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 35 | && BOOST_WORKAROUND(BOOST_MSVC, < 1300) 36 | 37 | # define BOOST_MPL_CFG_NTTP_BUG 38 | 39 | #endif 40 | 41 | #endif // BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED 42 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/overload_resolution.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && ( BOOST_WORKAROUND(__BORLANDC__, < 0x590) \ 22 | || BOOST_WORKAROUND(__MWERKS__, < 0x3001) \ 23 | ) 24 | 25 | # define BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION 26 | 27 | #endif 28 | 29 | #endif // BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 30 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/pp_counter.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2006 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if !defined(BOOST_MPL_AUX_PP_COUNTER) 18 | # include 19 | # if BOOST_WORKAROUND(BOOST_MSVC, >= 1300) 20 | # define BOOST_MPL_AUX_PP_COUNTER() __COUNTER__ 21 | # else 22 | # define BOOST_MPL_AUX_PP_COUNTER() __LINE__ 23 | # endif 24 | #endif 25 | 26 | #endif // BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/preprocessor.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) \ 20 | && ( BOOST_WORKAROUND(__MWERKS__, <= 0x3003) \ 21 | || BOOST_WORKAROUND(__BORLANDC__, < 0x582) \ 22 | || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \ 23 | ) 24 | 25 | # define BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION 26 | 27 | #endif 28 | 29 | #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) 30 | # define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES 31 | #endif 32 | 33 | #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) \ 34 | && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) 35 | # define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING 36 | #endif 37 | 38 | 39 | #endif // BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED 40 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/static_constant.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if !defined(BOOST_MPL_PREPROCESSING_MODE) 18 | // BOOST_STATIC_CONSTANT is defined here: 19 | # include 20 | #else 21 | // undef the macro for the preprocessing mode 22 | # undef BOOST_STATIC_CONSTANT 23 | #endif 24 | 25 | #endif // BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 26 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/ttp.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ 22 | && ( defined(BOOST_NO_TEMPLATE_TEMPLATES) \ 23 | || BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x590) ) \ 24 | ) 25 | 26 | # define BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS 27 | 28 | #endif 29 | 30 | 31 | #if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ 32 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 33 | && ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ 34 | || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \ 35 | ) 36 | 37 | # define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING 38 | 39 | #endif 40 | 41 | #endif // BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED 42 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/use_preprocessed.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | // #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS 18 | 19 | #endif // BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/config/workaround.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #endif // BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/has_apply.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | namespace boost { namespace mpl { namespace aux { 21 | #if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) 22 | BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false) 23 | #else 24 | template< typename T, typename fallback_ = false_ > 25 | struct has_apply 26 | : fallback_ 27 | { 28 | }; 29 | #endif 30 | }}} 31 | 32 | #endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/has_type.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | namespace boost { namespace mpl { namespace aux { 20 | BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_type, type, true) 21 | }}} 22 | 23 | #endif // BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/lambda_arity_param.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) 20 | # define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) 21 | #else 22 | # define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param 23 | #endif 24 | 25 | #endif // BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 26 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/msvc_never_true.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 21 | 22 | namespace boost { namespace mpl { namespace aux { 23 | 24 | template< typename T > 25 | struct msvc_never_true 26 | { 27 | enum { value = false }; 28 | }; 29 | 30 | }}} 31 | 32 | #endif // BOOST_MSVC 33 | 34 | #endif // BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/na_assert.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !BOOST_WORKAROUND(_MSC_FULL_VER, <= 140050601) \ 22 | && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) 23 | # include 24 | # define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ 25 | BOOST_MPL_ASSERT_NOT((boost::mpl::is_na)) \ 26 | /**/ 27 | #else 28 | # include 29 | # define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ 30 | BOOST_STATIC_ASSERT(!boost::mpl::is_na::value) \ 31 | /**/ 32 | #endif 33 | 34 | #endif // BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/na_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 20 | 21 | // n.a. == not available 22 | struct na 23 | { 24 | typedef na type; 25 | enum { value = 0 }; 26 | }; 27 | 28 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 29 | BOOST_MPL_AUX_ADL_BARRIER_DECL(na) 30 | 31 | #endif // BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/nttp_decl.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if defined(BOOST_MPL_CFG_NTTP_BUG) 20 | 21 | typedef bool _mpl_nttp_bool; 22 | typedef int _mpl_nttp_int; 23 | typedef unsigned _mpl_nttp_unsigned; 24 | typedef long _mpl_nttp_long; 25 | 26 | # include 27 | # define BOOST_MPL_AUX_NTTP_DECL(T, x) BOOST_PP_CAT(_mpl_nttp_,T) x /**/ 28 | 29 | #else 30 | 31 | # define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/ 32 | 33 | #endif 34 | 35 | #endif // BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 36 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc551/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc_pre590/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc_pre590/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2008 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na, int dummy_ = 0 17 | > 18 | struct bind; 19 | 20 | template< 21 | typename F, int dummy_ = 0 22 | > 23 | struct bind0; 24 | 25 | template< 26 | typename F, typename T1, int dummy_ = 0 27 | > 28 | struct bind1; 29 | 30 | template< 31 | typename F, typename T1, typename T2, int dummy_ = 0 32 | > 33 | struct bind2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3, int dummy_ = 0 37 | > 38 | struct bind3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | , int dummy_ = 0 43 | > 44 | struct bind4; 45 | 46 | template< 47 | typename F, typename T1, typename T2, typename T3, typename T4 48 | , typename T5, int dummy_ = 0 49 | > 50 | struct bind5; 51 | 52 | }} 53 | 54 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct bind; 19 | 20 | template< 21 | typename F 22 | > 23 | struct bind0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct bind1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct bind2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct bind3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct bind4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct bind5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct apply0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct apply1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct apply2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct apply3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct apply4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct apply5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc60/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | template<> 40 | struct template_arity 41 | : mpl::int_< -1 > 42 | { 43 | }; 44 | 45 | }}} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct apply0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct apply1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct apply2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct apply3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct apply4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct apply5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | template<> 40 | struct template_arity 41 | : mpl::int_< -1 > 42 | { 43 | }; 44 | 45 | }}} 46 | 47 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct bind; 19 | 20 | template< 21 | typename F 22 | > 23 | struct bind0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct bind1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct bind2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct bind3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct bind4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct bind5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | namespace aux { 15 | template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser; 16 | } 17 | 18 | template< 19 | typename F 20 | > 21 | struct apply0; 22 | 23 | template< 24 | typename F, typename T1 25 | > 26 | struct apply1; 27 | 28 | template< 29 | typename F, typename T1, typename T2 30 | > 31 | struct apply2; 32 | 33 | template< 34 | typename F, typename T1, typename T2, typename T3 35 | > 36 | struct apply3; 37 | 38 | template< 39 | typename F, typename T1, typename T2, typename T3, typename T4 40 | > 41 | struct apply4; 42 | 43 | template< 44 | typename F, typename T1, typename T2, typename T3, typename T4 45 | , typename T5 46 | > 47 | struct apply5; 48 | 49 | }} 50 | 51 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct bind; 19 | 20 | template< 21 | typename F 22 | > 23 | struct bind0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct bind1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct bind2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct bind3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct bind4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct bind5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct bind; 19 | 20 | template< 21 | typename F 22 | > 23 | struct bind0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct bind1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct bind2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct bind3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct bind4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct bind5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/plain/and.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/and.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | namespace aux { 15 | 16 | template< bool C_, typename T1, typename T2, typename T3, typename T4 > 17 | struct and_impl 18 | : false_ 19 | { 20 | }; 21 | 22 | template< typename T1, typename T2, typename T3, typename T4 > 23 | struct and_impl< true,T1,T2,T3,T4 > 24 | : and_impl< 25 | BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value 26 | , T2, T3, T4 27 | , true_ 28 | > 29 | { 30 | }; 31 | 32 | template<> 33 | struct and_impl< 34 | true 35 | , true_, true_, true_, true_ 36 | > 37 | : true_ 38 | { 39 | }; 40 | 41 | } // namespace aux 42 | 43 | template< 44 | typename BOOST_MPL_AUX_NA_PARAM(T1) 45 | , typename BOOST_MPL_AUX_NA_PARAM(T2) 46 | , typename T3 = true_, typename T4 = true_, typename T5 = true_ 47 | > 48 | struct and_ 49 | 50 | : aux::and_impl< 51 | BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value 52 | , T2, T3, T4, T5 53 | > 54 | 55 | { 56 | }; 57 | 58 | BOOST_MPL_AUX_NA_SPEC2( 59 | 2 60 | , 5 61 | , and_ 62 | ) 63 | 64 | }} 65 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/apply_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct apply; 19 | 20 | template< 21 | typename F 22 | > 23 | struct apply0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct apply1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct apply2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct apply3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct apply4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct apply5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F, typename T1 = na, typename T2 = na, typename T3 = na 16 | , typename T4 = na, typename T5 = na 17 | > 18 | struct bind; 19 | 20 | template< 21 | typename F 22 | > 23 | struct bind0; 24 | 25 | template< 26 | typename F, typename T1 27 | > 28 | struct bind1; 29 | 30 | template< 31 | typename F, typename T1, typename T2 32 | > 33 | struct bind2; 34 | 35 | template< 36 | typename F, typename T1, typename T2, typename T3 37 | > 38 | struct bind3; 39 | 40 | template< 41 | typename F, typename T1, typename T2, typename T3, typename T4 42 | > 43 | struct bind4; 44 | 45 | template< 46 | typename F, typename T1, typename T2, typename T3, typename T4 47 | , typename T5 48 | > 49 | struct bind5; 50 | 51 | }} 52 | 53 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/plain/or.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/or.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | namespace aux { 15 | 16 | template< bool C_, typename T1, typename T2, typename T3, typename T4 > 17 | struct or_impl 18 | : true_ 19 | { 20 | }; 21 | 22 | template< typename T1, typename T2, typename T3, typename T4 > 23 | struct or_impl< false,T1,T2,T3,T4 > 24 | : or_impl< 25 | BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value 26 | , T2, T3, T4 27 | , false_ 28 | > 29 | { 30 | }; 31 | 32 | template<> 33 | struct or_impl< 34 | false 35 | , false_, false_, false_, false_ 36 | > 37 | : false_ 38 | { 39 | }; 40 | 41 | } // namespace aux 42 | 43 | template< 44 | typename BOOST_MPL_AUX_NA_PARAM(T1) 45 | , typename BOOST_MPL_AUX_NA_PARAM(T2) 46 | , typename T3 = false_, typename T4 = false_, typename T5 = false_ 47 | > 48 | struct or_ 49 | 50 | : aux::or_impl< 51 | BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value 52 | , T2, T3, T4, T5 53 | > 54 | 55 | { 56 | }; 57 | 58 | BOOST_MPL_AUX_NA_SPEC2( 59 | 2 60 | , 5 61 | , or_ 62 | ) 63 | 64 | }} 65 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessed/plain/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessor/filter_params.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #define BOOST_MPL_PP_FILTER_PARAMS_0(p1,p2,p3,p4,p5,p6,p7,p8,p9) 18 | #define BOOST_MPL_PP_FILTER_PARAMS_1(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1 19 | #define BOOST_MPL_PP_FILTER_PARAMS_2(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2 20 | #define BOOST_MPL_PP_FILTER_PARAMS_3(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3 21 | #define BOOST_MPL_PP_FILTER_PARAMS_4(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4 22 | #define BOOST_MPL_PP_FILTER_PARAMS_5(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5 23 | #define BOOST_MPL_PP_FILTER_PARAMS_6(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6 24 | #define BOOST_MPL_PP_FILTER_PARAMS_7(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7 25 | #define BOOST_MPL_PP_FILTER_PARAMS_8(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7,p8 26 | #define BOOST_MPL_PP_FILTER_PARAMS_9(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7,p8,p9 27 | 28 | #endif // BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessor/partial_spec_params.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | 23 | #define BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ 24 | BOOST_MPL_PP_PARAMS(n, param) \ 25 | BOOST_PP_COMMA_IF(BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,n)) \ 26 | BOOST_MPL_PP_ENUM( \ 27 | BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,n) \ 28 | , def \ 29 | ) \ 30 | /**/ 31 | 32 | #endif // BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessor/range.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #define BOOST_MPL_PP_RANGE_ITEM(z,n,_) (n) 22 | 23 | #define BOOST_MPL_PP_RANGE(first, length) \ 24 | BOOST_PP_SEQ_SUBSEQ( \ 25 | BOOST_PP_REPEAT(BOOST_PP_ADD(first,length), BOOST_MPL_PP_RANGE_ITEM, _), \ 26 | first, length \ 27 | ) \ 28 | /**/ 29 | 30 | #endif // BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/preprocessor/tuple.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0 18 | #define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1 19 | #define BOOST_MPL_PP_TUPLE_11_ELEM_2(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e2 20 | #define BOOST_MPL_PP_TUPLE_11_ELEM_3(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e3 21 | #define BOOST_MPL_PP_TUPLE_11_ELEM_4(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e4 22 | #define BOOST_MPL_PP_TUPLE_11_ELEM_5(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e5 23 | #define BOOST_MPL_PP_TUPLE_11_ELEM_6(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e6 24 | #define BOOST_MPL_PP_TUPLE_11_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e7 25 | #define BOOST_MPL_PP_TUPLE_11_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e8 26 | #define BOOST_MPL_PP_TUPLE_11_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e9 27 | #define BOOST_MPL_PP_TUPLE_11_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e10 28 | 29 | #endif // BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED 30 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/static_cast.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ 20 | || BOOST_WORKAROUND(__GNUC__, < 3) \ 21 | || BOOST_WORKAROUND(__MWERKS__, <= 0x3001) 22 | # define BOOST_MPL_AUX_STATIC_CAST(T, expr) (T)(expr) 23 | #else 24 | # define BOOST_MPL_AUX_STATIC_CAST(T, expr) static_cast(expr) 25 | #endif 26 | 27 | #endif // BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/template_arity_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | namespace boost { namespace mpl { namespace aux { 18 | 19 | template< typename F > struct template_arity; 20 | 21 | }}} 22 | 23 | #endif // BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/type_wrapper.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // Copyright Peter Dimov 2000-2003 7 | // 8 | // Distributed under the Boost Software License, Version 1.0. 9 | // (See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt) 11 | // 12 | // See http://www.boost.org/libs/mpl for documentation. 13 | 14 | // $Id$ 15 | // $Date$ 16 | // $Revision$ 17 | 18 | #include 19 | 20 | namespace boost { namespace mpl { namespace aux { 21 | 22 | template< typename T > struct type_wrapper 23 | { 24 | typedef T type; 25 | }; 26 | 27 | #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) 28 | // agurt 08/may/03: a complicated way to extract the wrapped type; need it 29 | // mostly for the sake of GCC (3.2.x), which ICEs if you try to extract the 30 | // nested 'type' from 'type_wrapper' when the latter was the result of a 31 | // 'typeof' expression 32 | template< typename T > struct wrapped_type; 33 | 34 | template< typename T > struct wrapped_type< type_wrapper > 35 | { 36 | typedef T type; 37 | }; 38 | #else 39 | template< typename W > struct wrapped_type 40 | { 41 | typedef typename W::type type; 42 | }; 43 | #endif 44 | 45 | }}} 46 | 47 | #endif // BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED 48 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/aux_/yes_no.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_YES_NO_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_YES_NO_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | 23 | namespace boost { namespace mpl { namespace aux { 24 | 25 | typedef char (&no_tag)[1]; 26 | typedef char (&yes_tag)[2]; 27 | 28 | template< bool C_ > struct yes_no_tag 29 | { 30 | typedef no_tag type; 31 | }; 32 | 33 | template<> struct yes_no_tag 34 | { 35 | typedef yes_tag type; 36 | }; 37 | 38 | 39 | template< BOOST_MPL_AUX_NTTP_DECL(long, n) > struct weighted_tag 40 | { 41 | #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) 42 | typedef char (&type)[n]; 43 | #else 44 | char buf[n]; 45 | typedef weighted_tag type; 46 | #endif 47 | }; 48 | 49 | #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) 50 | template<> struct weighted_tag<0> 51 | { 52 | typedef char (&type)[1]; 53 | }; 54 | #endif 55 | 56 | }}} 57 | 58 | #endif // BOOST_MPL_AUX_YES_NO_HPP_INCLUDED 59 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/bool.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_BOOL_HPP_INCLUDED 3 | #define BOOST_MPL_BOOL_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 22 | 23 | template< bool C_ > struct bool_ 24 | { 25 | BOOST_STATIC_CONSTANT(bool, value = C_); 26 | typedef integral_c_tag tag; 27 | typedef bool_ type; 28 | typedef bool value_type; 29 | BOOST_CONSTEXPR operator bool() const { return this->value; } 30 | }; 31 | 32 | #if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) 33 | template< bool C_ > 34 | bool const bool_::value; 35 | #endif 36 | 37 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 38 | 39 | #endif // BOOST_MPL_BOOL_HPP_INCLUDED 40 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/bool_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_BOOL_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_BOOL_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 20 | 21 | template< bool C_ > struct bool_; 22 | 23 | // shorcuts 24 | typedef bool_ true_; 25 | typedef bool_ false_; 26 | 27 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 28 | 29 | BOOST_MPL_AUX_ADL_BARRIER_DECL(bool_) 30 | BOOST_MPL_AUX_ADL_BARRIER_DECL(true_) 31 | BOOST_MPL_AUX_ADL_BARRIER_DECL(false_) 32 | 33 | #endif // BOOST_MPL_BOOL_FWD_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/identity.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_IDENTITY_HPP_INCLUDED 3 | #define BOOST_MPL_IDENTITY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | namespace boost { namespace mpl { 21 | 22 | template< 23 | typename BOOST_MPL_AUX_NA_PARAM(T) 24 | > 25 | struct identity 26 | { 27 | typedef T type; 28 | BOOST_MPL_AUX_LAMBDA_SUPPORT(1, identity, (T)) 29 | }; 30 | 31 | template< 32 | typename BOOST_MPL_AUX_NA_PARAM(T) 33 | > 34 | struct make_identity 35 | { 36 | typedef identity type; 37 | BOOST_MPL_AUX_LAMBDA_SUPPORT(1, make_identity, (T)) 38 | }; 39 | 40 | BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, identity) 41 | BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, make_identity) 42 | 43 | }} 44 | 45 | #endif // BOOST_MPL_IDENTITY_HPP_INCLUDED 46 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/int.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INT_HPP_INCLUDED 3 | #define BOOST_MPL_INT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #define AUX_WRAPPER_VALUE_TYPE int 20 | #include 21 | 22 | #endif // BOOST_MPL_INT_HPP_INCLUDED 23 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/int_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INT_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_INT_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 21 | 22 | template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct int_; 23 | 24 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 25 | BOOST_MPL_AUX_ADL_BARRIER_DECL(int_) 26 | 27 | #endif // BOOST_MPL_INT_FWD_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/integral_c_tag.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 3 | #define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | 18 | #include 19 | #include 20 | 21 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 22 | struct integral_c_tag { BOOST_STATIC_CONSTANT(int, value = 0); }; 23 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 24 | BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c_tag) 25 | 26 | #endif // BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/lambda.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_LAMBDA_HPP_INCLUDED 3 | #define BOOST_MPL_LAMBDA_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) 22 | # include 23 | #else 24 | # include 25 | # include 26 | # define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS 27 | #endif 28 | 29 | #endif // BOOST_MPL_LAMBDA_HPP_INCLUDED 30 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/lambda_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) 22 | 23 | # include 24 | # include 25 | # include 26 | 27 | namespace boost { namespace mpl { 28 | 29 | template< 30 | typename T = na 31 | , typename Tag = void_ 32 | BOOST_MPL_AUX_LAMBDA_ARITY_PARAM( 33 | typename Arity = int_< aux::template_arity::value > 34 | ) 35 | > 36 | struct lambda; 37 | 38 | }} 39 | 40 | #else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT 41 | 42 | # include 43 | 44 | namespace boost { namespace mpl { 45 | 46 | template< 47 | typename T = na 48 | , typename Tag = void_ 49 | , typename Protect = true_ 50 | > 51 | struct lambda; 52 | 53 | }} 54 | 55 | #endif 56 | 57 | #endif // BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED 58 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/limits/arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 3 | #define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) 18 | # define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5 19 | #endif 20 | 21 | #endif // BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/next.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_NEXT_HPP_INCLUDED 3 | #define BOOST_MPL_NEXT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #endif // BOOST_MPL_NEXT_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/next_prior.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED 3 | #define BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | namespace boost { namespace mpl { 22 | 23 | BOOST_MPL_AUX_COMMON_NAME_WKND(next) 24 | BOOST_MPL_AUX_COMMON_NAME_WKND(prior) 25 | 26 | template< 27 | typename BOOST_MPL_AUX_NA_PARAM(T) 28 | > 29 | struct next 30 | { 31 | typedef typename T::next type; 32 | BOOST_MPL_AUX_LAMBDA_SUPPORT(1,next,(T)) 33 | }; 34 | 35 | template< 36 | typename BOOST_MPL_AUX_NA_PARAM(T) 37 | > 38 | struct prior 39 | { 40 | typedef typename T::prior type; 41 | BOOST_MPL_AUX_LAMBDA_SUPPORT(1,prior,(T)) 42 | }; 43 | 44 | BOOST_MPL_AUX_NA_SPEC(1, next) 45 | BOOST_MPL_AUX_NA_SPEC(1, prior) 46 | 47 | }} 48 | 49 | #endif // BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED 50 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/not.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_NOT_HPP_INCLUDED 3 | #define BOOST_MPL_NOT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | 23 | namespace boost { namespace mpl { 24 | 25 | namespace aux { 26 | 27 | template< BOOST_MPL_AUX_NTTP_DECL(long, C_) > // 'long' is intentional here 28 | struct not_impl 29 | : bool_ 30 | { 31 | }; 32 | 33 | } // namespace aux 34 | 35 | 36 | template< 37 | typename BOOST_MPL_AUX_NA_PARAM(T) 38 | > 39 | struct not_ 40 | : aux::not_impl< 41 | BOOST_MPL_AUX_NESTED_TYPE_WKND(T)::value 42 | > 43 | { 44 | BOOST_MPL_AUX_LAMBDA_SUPPORT(1,not_,(T)) 45 | }; 46 | 47 | BOOST_MPL_AUX_NA_SPEC(1,not_) 48 | 49 | }} 50 | 51 | #endif // BOOST_MPL_NOT_HPP_INCLUDED 52 | -------------------------------------------------------------------------------- /petanque/third-party/boost/mpl/void_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_VOID_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_VOID_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 20 | 21 | struct void_; 22 | 23 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 24 | BOOST_MPL_AUX_ADL_BARRIER_DECL(void_) 25 | 26 | #endif // BOOST_MPL_VOID_FWD_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/array/data.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ARRAY_DATA_HPP 13 | # define BOOST_PREPROCESSOR_ARRAY_DATA_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* BOOST_PP_ARRAY_DATA */ 19 | # 20 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 21 | # define BOOST_PP_ARRAY_DATA(array) BOOST_PP_TUPLE_ELEM(2, 1, array) 22 | # else 23 | # define BOOST_PP_ARRAY_DATA(array) BOOST_PP_ARRAY_DATA_I(array) 24 | # define BOOST_PP_ARRAY_DATA_I(array) BOOST_PP_ARRAY_DATA_II array 25 | # define BOOST_PP_ARRAY_DATA_II(size, data) data 26 | # endif 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/array/elem.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ARRAY_ELEM_HPP 13 | # define BOOST_PREPROCESSOR_ARRAY_ELEM_HPP 14 | # 15 | # include 16 | # include 17 | # include 18 | # include 19 | # 20 | # /* BOOST_PP_ARRAY_ELEM */ 21 | # 22 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 23 | # define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array)) 24 | # else 25 | # define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_ARRAY_ELEM_I(i, array) 26 | # define BOOST_PP_ARRAY_ELEM_I(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array)) 27 | # endif 28 | # 29 | # endif 30 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/array/size.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ARRAY_SIZE_HPP 13 | # define BOOST_PREPROCESSOR_ARRAY_SIZE_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* BOOST_PP_ARRAY_SIZE */ 19 | # 20 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 21 | # define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_TUPLE_ELEM(2, 0, array) 22 | # else 23 | # define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_ARRAY_SIZE_I(array) 24 | # define BOOST_PP_ARRAY_SIZE_I(array) BOOST_PP_ARRAY_SIZE_II array 25 | # define BOOST_PP_ARRAY_SIZE_II(size, data) size 26 | # endif 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/cat.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_CAT_HPP 15 | # define BOOST_PREPROCESSOR_CAT_HPP 16 | # 17 | # include 18 | # 19 | # /* BOOST_PP_CAT */ 20 | # 21 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() 22 | # define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b) 23 | # else 24 | # define BOOST_PP_CAT(a, b) BOOST_PP_CAT_OO((a, b)) 25 | # define BOOST_PP_CAT_OO(par) BOOST_PP_CAT_I ## par 26 | # endif 27 | # 28 | # if (~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) 29 | # define BOOST_PP_CAT_I(a, b) a ## b 30 | # else 31 | # define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(~, a ## b) 32 | # define BOOST_PP_CAT_II(p, res) res 33 | # endif 34 | # 35 | # endif 36 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/comma_if.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_COMMA_IF_HPP 13 | # define BOOST_PREPROCESSOR_COMMA_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/control/expr_if.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IF_HPP 15 | # define BOOST_PREPROCESSOR_CONTROL_EXPR_IF_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_EXPR_IF */ 22 | # 23 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 24 | # define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IIF(BOOST_PP_BOOL(cond), expr) 25 | # else 26 | # define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IF_I(cond, expr) 27 | # define BOOST_PP_EXPR_IF_I(cond, expr) BOOST_PP_EXPR_IIF(BOOST_PP_BOOL(cond), expr) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/control/expr_iif.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP 13 | # define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP 14 | # 15 | # include 16 | # 17 | # /* BOOST_PP_EXPR_IIF */ 18 | # 19 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() 20 | # define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_I(bit, expr) 21 | # else 22 | # define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_OO((bit, expr)) 23 | # define BOOST_PP_EXPR_IIF_OO(par) BOOST_PP_EXPR_IIF_I ## par 24 | # endif 25 | # 26 | # define BOOST_PP_EXPR_IIF_I(bit, expr) BOOST_PP_EXPR_IIF_ ## bit(expr) 27 | # 28 | # define BOOST_PP_EXPR_IIF_0(expr) 29 | # define BOOST_PP_EXPR_IIF_1(expr) expr 30 | # 31 | # endif 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/control/if.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_CONTROL_IF_HPP 15 | # define BOOST_PREPROCESSOR_CONTROL_IF_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_IF */ 22 | # 23 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 24 | # define BOOST_PP_IF(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) 25 | # else 26 | # define BOOST_PP_IF(cond, t, f) BOOST_PP_IF_I(cond, t, f) 27 | # define BOOST_PP_IF_I(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/control/iif.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_CONTROL_IIF_HPP 13 | # define BOOST_PREPROCESSOR_CONTROL_IIF_HPP 14 | # 15 | # include 16 | # 17 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() 18 | # define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_I(bit, t, f) 19 | # else 20 | # define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_OO((bit, t, f)) 21 | # define BOOST_PP_IIF_OO(par) BOOST_PP_IIF_I ## par 22 | # endif 23 | # 24 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() 25 | # define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_ ## bit(t, f) 26 | # else 27 | # define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_II(BOOST_PP_IIF_ ## bit(t, f)) 28 | # define BOOST_PP_IIF_II(id) id 29 | # endif 30 | # 31 | # define BOOST_PP_IIF_0(t, f) f 32 | # define BOOST_PP_IIF_1(t, f) t 33 | # 34 | # endif 35 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/dec.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_DEC_HPP 13 | # define BOOST_PREPROCESSOR_DEC_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/detail/is_binary.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP 13 | # define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* BOOST_PP_IS_BINARY */ 19 | # 20 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 21 | # define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) 22 | # else 23 | # define BOOST_PP_IS_BINARY(x) BOOST_PP_IS_BINARY_I(x) 24 | # define BOOST_PP_IS_BINARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) 25 | # endif 26 | # 27 | # define BOOST_PP_IS_BINARY_CHECK(a, b) 1 28 | # define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/empty.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_EMPTY_HPP 13 | # define BOOST_PREPROCESSOR_EMPTY_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/enum_shifted_params.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP 13 | # define BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/expr_if.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_EXPR_IF_HPP 13 | # define BOOST_PREPROCESSOR_EXPR_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/facilities/empty.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP 15 | # define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP 16 | # 17 | # include 18 | # 19 | # /* BOOST_PP_EMPTY */ 20 | # 21 | # define BOOST_PP_EMPTY() 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/facilities/expand.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP 15 | # define BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP 16 | # 17 | # include 18 | # 19 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() 20 | # define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_I(x) 21 | # else 22 | # define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_OO((x)) 23 | # define BOOST_PP_EXPAND_OO(par) BOOST_PP_EXPAND_I ## par 24 | # endif 25 | # 26 | # define BOOST_PP_EXPAND_I(x) x 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/facilities/identity.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # /* Revised by Edward Diener (2015) */ 12 | # 13 | # /* See http://www.boost.org for most recent version. */ 14 | # 15 | # ifndef BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP 16 | # define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP 17 | # 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_IDENTITY */ 22 | # 23 | # define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY 24 | # 25 | # define BOOST_PP_IDENTITY_N(item,n) item BOOST_PP_TUPLE_EAT_N(n) 26 | # 27 | # endif 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/facilities/is_1.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2003. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP 13 | # define BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* BOOST_PP_IS_1 */ 19 | # 20 | # define BOOST_PP_IS_1(x) BOOST_PP_IS_EMPTY(BOOST_PP_CAT(BOOST_PP_IS_1_HELPER_, x)) 21 | # define BOOST_PP_IS_1_HELPER_1 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/facilities/overload.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2011. * 4 | # * (C) Copyright Edward Diener 2011. * 5 | # * Distributed under the Boost Software License, Version 1.0. (See * 6 | # * accompanying file LICENSE_1_0.txt or copy at * 7 | # * http://www.boost.org/LICENSE_1_0.txt) * 8 | # * * 9 | # ************************************************************************** */ 10 | # 11 | # /* See http://www.boost.org for most recent version. */ 12 | # 13 | # ifndef BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP 14 | # define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP 15 | # 16 | # include 17 | # include 18 | # 19 | # /* BOOST_PP_OVERLOAD */ 20 | # 21 | # if BOOST_PP_VARIADICS 22 | # define BOOST_PP_OVERLOAD(prefix, ...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)) 23 | # endif 24 | # 25 | # endif 26 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/identity.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_IDENTITY_HPP 13 | # define BOOST_PREPROCESSOR_IDENTITY_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/inc.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_INC_HPP 13 | # define BOOST_PREPROCESSOR_INC_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/iterate.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ITERATE_HPP 13 | # define BOOST_PREPROCESSOR_ITERATE_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/iteration/detail/self.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # if !defined(BOOST_PP_INDIRECT_SELF) 13 | # error BOOST_PP_ERROR: no indirect file to include 14 | # endif 15 | # 16 | # define BOOST_PP_IS_SELFISH 1 17 | # 18 | # include BOOST_PP_INDIRECT_SELF 19 | # 20 | # undef BOOST_PP_IS_SELFISH 21 | # undef BOOST_PP_INDIRECT_SELF 22 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/iteration/local.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ITERATION_LOCAL_HPP 13 | # define BOOST_PREPROCESSOR_ITERATION_LOCAL_HPP 14 | # 15 | # include 16 | # include 17 | # include 18 | # 19 | # /* BOOST_PP_LOCAL_ITERATE */ 20 | # 21 | # define BOOST_PP_LOCAL_ITERATE() 22 | # 23 | # define BOOST_PP_LOCAL_C(n) (BOOST_PP_LOCAL_S) <= n && (BOOST_PP_LOCAL_F) >= n 24 | # define BOOST_PP_LOCAL_R(n) (BOOST_PP_LOCAL_F) <= n && (BOOST_PP_LOCAL_S) >= n 25 | # 26 | # endif 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/iteration/self.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ITERATION_SELF_HPP 13 | # define BOOST_PREPROCESSOR_ITERATION_SELF_HPP 14 | # 15 | # /* BOOST_PP_INCLUDE_SELF */ 16 | # 17 | # define BOOST_PP_INCLUDE_SELF() 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/logical/and.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_LOGICAL_AND_HPP 15 | # define BOOST_PREPROCESSOR_LOGICAL_AND_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_AND */ 22 | # 23 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 24 | # define BOOST_PP_AND(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) 25 | # else 26 | # define BOOST_PP_AND(p, q) BOOST_PP_AND_I(p, q) 27 | # define BOOST_PP_AND_I(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/logical/compl.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP 13 | # define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP 14 | # 15 | # include 16 | # 17 | # /* BOOST_PP_COMPL */ 18 | # 19 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() 20 | # define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x) 21 | # else 22 | # define BOOST_PP_COMPL(x) BOOST_PP_COMPL_OO((x)) 23 | # define BOOST_PP_COMPL_OO(par) BOOST_PP_COMPL_I ## par 24 | # endif 25 | # 26 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() 27 | # define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x 28 | # else 29 | # define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ID(BOOST_PP_COMPL_ ## x) 30 | # define BOOST_PP_COMPL_ID(id) id 31 | # endif 32 | # 33 | # define BOOST_PP_COMPL_0 1 34 | # define BOOST_PP_COMPL_1 0 35 | # 36 | # endif 37 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/punctuation/comma.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP 15 | # define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP 16 | # 17 | # /* BOOST_PP_COMMA */ 18 | # 19 | # define BOOST_PP_COMMA() , 20 | # 21 | # endif 22 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/punctuation/comma_if.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP 15 | # define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # include 21 | # 22 | # /* BOOST_PP_COMMA_IF */ 23 | # 24 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 25 | # define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() 26 | # else 27 | # define BOOST_PP_COMMA_IF(cond) BOOST_PP_COMMA_IF_I(cond) 28 | # define BOOST_PP_COMMA_IF_I(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() 29 | # endif 30 | # 31 | # endif 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/repeat.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_REPEAT_HPP 13 | # define BOOST_PREPROCESSOR_REPEAT_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/seq/subseq.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_SEQ_SUBSEQ_HPP 13 | # define BOOST_PREPROCESSOR_SEQ_SUBSEQ_HPP 14 | # 15 | # include 16 | # include 17 | # include 18 | # 19 | # /* BOOST_PP_SEQ_SUBSEQ */ 20 | # 21 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 22 | # define BOOST_PP_SEQ_SUBSEQ(seq, i, len) BOOST_PP_SEQ_FIRST_N(len, BOOST_PP_SEQ_REST_N(i, seq)) 23 | # else 24 | # define BOOST_PP_SEQ_SUBSEQ(seq, i, len) BOOST_PP_SEQ_SUBSEQ_I(seq, i, len) 25 | # define BOOST_PP_SEQ_SUBSEQ_I(seq, i, len) BOOST_PP_SEQ_FIRST_N(len, BOOST_PP_SEQ_REST_N(i, seq)) 26 | # endif 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/stringize.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_STRINGIZE_HPP 15 | # define BOOST_PREPROCESSOR_STRINGIZE_HPP 16 | # 17 | # include 18 | # 19 | # /* BOOST_PP_STRINGIZE */ 20 | # 21 | # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() 22 | # define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_A((text)) 23 | # define BOOST_PP_STRINGIZE_A(arg) BOOST_PP_STRINGIZE_I arg 24 | # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() 25 | # define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_OO((text)) 26 | # define BOOST_PP_STRINGIZE_OO(par) BOOST_PP_STRINGIZE_I ## par 27 | # else 28 | # define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_I(text) 29 | # endif 30 | # 31 | # define BOOST_PP_STRINGIZE_I(text) #text 32 | # 33 | # endif 34 | -------------------------------------------------------------------------------- /petanque/third-party/boost/preprocessor/tuple/size.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Edward Diener 2011. * 4 | # * (C) Copyright Paul Mensonides 2011. * 5 | # * Distributed under the Boost Software License, Version 1.0. (See * 6 | # * accompanying file LICENSE_1_0.txt or copy at * 7 | # * http://www.boost.org/LICENSE_1_0.txt) * 8 | # * * 9 | # ************************************************************************** */ 10 | # 11 | # /* See http://www.boost.org for most recent version. */ 12 | # 13 | # ifndef BOOST_PREPROCESSOR_TUPLE_SIZE_HPP 14 | # define BOOST_PREPROCESSOR_TUPLE_SIZE_HPP 15 | # 16 | # include 17 | # include 18 | # include 19 | # 20 | # if BOOST_PP_VARIADICS 21 | # if BOOST_PP_VARIADICS_MSVC 22 | # define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_CAT(BOOST_PP_VARIADIC_SIZE tuple,) 23 | # else 24 | # define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_VARIADIC_SIZE tuple 25 | # endif 26 | # endif 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/add_lvalue_reference.hpp: -------------------------------------------------------------------------------- 1 | // Copyright 2010 John Maddock 2 | 3 | // Distributed under the Boost Software License, Version 1.0. 4 | // See http://www.boost.org/LICENSE_1_0.txt 5 | 6 | #ifndef BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 7 | #define BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 8 | 9 | #include 10 | 11 | namespace boost{ 12 | 13 | template struct add_lvalue_reference 14 | { 15 | typedef typename boost::add_reference::type type; 16 | }; 17 | 18 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 19 | template struct add_lvalue_reference 20 | { 21 | typedef T& type; 22 | }; 23 | #endif 24 | 25 | #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) 26 | 27 | template using add_lvalue_reference_t = typename add_lvalue_reference::type; 28 | 29 | #endif 30 | 31 | } 32 | 33 | #endif // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 34 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/detail/yes_no_type.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright John Maddock and Steve Cleary 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | // 9 | // macros and helpers for working with integral-constant-expressions. 10 | 11 | #ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 12 | #define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 13 | 14 | namespace boost { 15 | namespace type_traits { 16 | 17 | typedef char yes_type; 18 | struct no_type 19 | { 20 | char padding[8]; 21 | }; 22 | 23 | } // namespace type_traits 24 | } // namespace boost 25 | 26 | #endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/is_arithmetic.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 10 | #define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 11 | 12 | #include 13 | #include 14 | 15 | namespace boost { 16 | 17 | template 18 | struct is_arithmetic : public integral_constant::value || is_floating_point::value> {}; 19 | 20 | } // namespace boost 21 | 22 | #endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 23 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/is_reference.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, 3 | // Howard Hinnant and John Maddock 2000, 2010. 4 | // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 5 | 6 | // Use, modification and distribution are subject to the Boost Software License, 7 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt). 9 | // 10 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 11 | 12 | #ifndef BOOST_TT_IS_REFERENCE_HPP_INCLUDED 13 | #define BOOST_TT_IS_REFERENCE_HPP_INCLUDED 14 | 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | template struct is_reference 21 | : public 22 | integral_constant< 23 | bool, 24 | ::boost::is_lvalue_reference::value || ::boost::is_rvalue_reference::value> 25 | {}; 26 | 27 | } // namespace boost 28 | 29 | #endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED 30 | 31 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/is_rvalue_reference.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright John Maddock 2010. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED 10 | #define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED 11 | 12 | #include 13 | #include 14 | 15 | namespace boost { 16 | 17 | template struct is_rvalue_reference : public false_type {}; 18 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 19 | template struct is_rvalue_reference : public true_type {}; 20 | #endif 21 | 22 | } // namespace boost 23 | 24 | #endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED 25 | 26 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/is_scalar.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_IS_SCALAR_HPP_INCLUDED 10 | #define BOOST_TT_IS_SCALAR_HPP_INCLUDED 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | namespace boost { 19 | 20 | template 21 | struct is_scalar 22 | : public integral_constant::value || ::boost::is_enum::value || ::boost::is_pointer::value || ::boost::is_member_pointer::value> 23 | {}; 24 | 25 | } // namespace boost 26 | 27 | #endif // BOOST_TT_IS_SCALAR_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/is_union.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard 3 | // Hinnant & John Maddock 2000. 4 | // Use, modification and distribution are subject to the Boost Software License, 5 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt). 7 | // 8 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 9 | 10 | 11 | #ifndef BOOST_TT_IS_UNION_HPP_INCLUDED 12 | #define BOOST_TT_IS_UNION_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | namespace boost { 18 | 19 | #ifdef BOOST_IS_UNION 20 | template struct is_union : public integral_constant {}; 21 | #else 22 | template struct is_union : public integral_constant {}; 23 | #endif 24 | 25 | template struct is_union : public is_union{}; 26 | template struct is_union : public is_union{}; 27 | template struct is_union : public is_union{}; 28 | 29 | } // namespace boost 30 | 31 | #endif // BOOST_TT_IS_UNION_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /petanque/third-party/boost/type_traits/is_void.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_IS_VOID_HPP_INCLUDED 10 | #define BOOST_TT_IS_VOID_HPP_INCLUDED 11 | 12 | #include 13 | 14 | namespace boost { 15 | 16 | template 17 | struct is_void : public false_type {}; 18 | 19 | template<> struct is_void : public true_type {}; 20 | template<> struct is_void : public true_type{}; 21 | template<> struct is_void : public true_type{}; 22 | template<> struct is_void : public true_type{}; 23 | 24 | } // namespace boost 25 | 26 | #endif // BOOST_TT_IS_VOID_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /petanque/third-party/boost/utility/addressof.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Glen Fernandes 3 | * 4 | * Distributed under the Boost Software License, Version 1.0. (See 5 | * accompanying file LICENSE_1_0.txt or copy at 6 | * http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef BOOST_UTILITY_ADDRESSOF_HPP 10 | #define BOOST_UTILITY_ADDRESSOF_HPP 11 | 12 | // The header file at this path is deprecated; 13 | // use boost/core/addressof.hpp instead. 14 | 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /petanque/third-party/boost/version.hpp: -------------------------------------------------------------------------------- 1 | // Boost version.hpp configuration header file ------------------------------// 2 | 3 | // (C) Copyright John maddock 1999. Distributed under the Boost 4 | // Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | // See http://www.boost.org/libs/config for documentation 8 | 9 | #ifndef BOOST_VERSION_HPP 10 | #define BOOST_VERSION_HPP 11 | 12 | // 13 | // Caution: this is the only Boost header that is guaranteed 14 | // to change with every Boost release. Including this header 15 | // will cause a recompile every time a new Boost version is 16 | // used. 17 | // 18 | // BOOST_VERSION % 100 is the patch level 19 | // BOOST_VERSION / 100 % 1000 is the minor version 20 | // BOOST_VERSION / 100000 is the major version 21 | 22 | #define BOOST_VERSION 106700 23 | 24 | // 25 | // BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION 26 | // but as a *string* in the form "x_y[_z]" where x is the major version 27 | // number, y is the minor version number, and z is the patch level if not 0. 28 | // This is used by to select which library version to link to. 29 | 30 | #define BOOST_LIB_VERSION "1_67" 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /petanque/third-party/pector/enhanced_allocators.h: -------------------------------------------------------------------------------- 1 | // This file is part of pector (https://github.com/aguinet/pector). 2 | // Copyright (C) 2014-2015 Adrien Guinet 3 | // 4 | // This library is free software; you can redistribute it and/or 5 | // modify it under the terms of the GNU Lesser General Public 6 | // License as published by the Free Software Foundation; either 7 | // version 2.1 of the License, or (at your option) any later version. 8 | // 9 | // This library is distributed in the hope that it will be useful, 10 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | // Lesser General Public License for more details. 13 | // 14 | // You should have received a copy of the GNU Lesser General Public 15 | // License along with this library; if not, write to the Free Software 16 | // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | 18 | 19 | #ifndef PECTOR_ENHANCED_ALLOCATORS_H 20 | #define PECTOR_ENHANCED_ALLOCATORS_H 21 | 22 | namespace pt { 23 | 24 | struct size_aware_allocator { }; 25 | struct reallocable_allocator { }; 26 | 27 | template 28 | struct is_size_aware_allocator: public std::is_base_of 29 | { }; 30 | 31 | template 32 | struct is_reallocable_allocator: public std::is_base_of 33 | { }; 34 | 35 | } 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /petanque/third-party/pybind11/common.h: -------------------------------------------------------------------------------- 1 | #include "detail/common.h" 2 | #warning "Including 'common.h' is deprecated. It will be removed in v3.0. Use 'pybind11.h'." 3 | -------------------------------------------------------------------------------- /petanque/tools/CMakeLists.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/quarkslab/arybo/89d9a4266fa51c1a560f6c4a66f65d1ffde5f093/petanque/tools/CMakeLists.txt -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | [metadata] 2 | description-file = README.rst 3 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | from setuptools import setup 2 | 3 | setup( 4 | name="arybo", 5 | version="1.1.0", 6 | author="Adrien Guinet", 7 | author_email="aguinet@quarkslab.com", 8 | description="Manipulation, canonicalization and identification of mixed boolean-arithmetic symbolic expressions", 9 | packages=["arybo", "arybo.lib", "arybo.tools"], 10 | install_requires=[ 11 | "networkx==2.4", 12 | "pytanque >= 1.0", 13 | "six" 14 | ], 15 | classifiers=[ 16 | 'Development Status :: 5 - Production/Stable', 17 | 'Intended Audience :: Science/Research', 18 | 'Intended Audience :: Developers', 19 | 'Topic :: Software Development :: Build Tools', 20 | 'Topic :: Security', 21 | 'Topic :: Scientific/Engineering', 22 | 'License :: OSI Approved :: BSD License', 23 | 'Programming Language :: Python :: 3', 24 | 'Programming Language :: Python :: 3.5', 25 | 'Programming Language :: Python :: 3.6', 26 | 'Programming Language :: Python :: 3.7', 27 | 'Programming Language :: Python :: 3.8', 28 | ], 29 | keywords='symbolic computation canonicalization boolean-arithmetic expressions', 30 | license='BSD', 31 | url = "https://github.com/quarkslab/arybo", 32 | download_url = "https://github.com/quarkslab/arybo/releases", 33 | scripts=["bin/iarybo"] 34 | ) 35 | -------------------------------------------------------------------------------- /tests/arybo/app.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA, simplify 2 | from arybo.tools import is_app_inversible, app_inverse 3 | 4 | import unittest 5 | 6 | class AppTest(unittest.TestCase): 7 | def setUp(self): 8 | mba = MBA(4) 9 | mba.use_esf = False 10 | self.X = mba.var('X') 11 | 12 | def test_app1(self): 13 | X = self.X 14 | A = (7*X+5).vectorial_decomp([X]) 15 | Ainv = app_inverse(A) 16 | 17 | self.assertIsNotNone(Ainv) 18 | ident = simplify(Ainv(A(X.vec))) 19 | self.assertEqual(ident, self.X.vec) 20 | 21 | def test_app2(self): 22 | X = self.X 23 | A = (16+11*X+12*X*X+2*X*X*X).vectorial_decomp([X]) 24 | Ainv = app_inverse(A) 25 | 26 | self.assertIsNotNone(Ainv) 27 | ident = simplify(Ainv(A(X.vec))) 28 | self.assertEqual(ident, self.X.vec) 29 | 30 | if __name__ == "__main__": 31 | unittest.main() 32 | -------------------------------------------------------------------------------- /tests/arybo/lib.py: -------------------------------------------------------------------------------- 1 | from arybo.lib import MBA 2 | from arybo.lib import MBATester 3 | 4 | import unittest 5 | 6 | class Lib(unittest.TestCase): 7 | def test_lib(self): 8 | mba = MBA(4) 9 | mba_tester = MBATester(mba) 10 | ret = mba_tester.test_all() 11 | self.assertTrue(ret) 12 | 13 | if __name__ == "__main__": 14 | unittest.main() 15 | -------------------------------------------------------------------------------- /tests/tools/identify.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | 3 | from arybo.lib import MBA 4 | import arybo.lib.mba_exprs as EX 5 | from arybo.tools import identify 6 | 7 | class IdentifyTest(unittest.TestCase): 8 | def setUp(self): 9 | self.mba8 = MBA(8) 10 | self.x = self.mba8.var('x') 11 | self.ex = EX.ExprBV(self.mba8.var('x')) 12 | 13 | def check(self, e, ref): 14 | app = e.vectorial_decomp([self.x]) 15 | eid = identify(app,"x") 16 | self.assertEqual(EX.eval_expr(eid), EX.eval_expr(ref)) 17 | 18 | def test_identify_xor(self): 19 | e = self.x^0xAA 20 | self.check(e, EX.ExprXor(self.ex, EX.ExprCst(0xAA, 8))) 21 | 22 | def test_identify_xor(self): 23 | e = self.x&0xAA 24 | self.check(e, EX.ExprAnd(self.ex, EX.ExprCst(0xAA, 8))) 25 | 26 | def test_identify_xor_and(self): 27 | e = (self.x&0x7F)^0xAA 28 | self.check(e, EX.ExprXor(EX.ExprAnd(self.ex, EX.ExprCst(0x7F, 8)), EX.ExprCst(0xAA,8))) 29 | 30 | if __name__ == "__main__": 31 | unittest.main() 32 | --------------------------------------------------------------------------------