@ -1,23 +1,14 @@ | |||
#!/bin/sh | |||
DMENU='dmenu -z 1900 -x 10 -y 10 -i' | |||
blacklist="powerlevel10k|secret|gitignore|log|plugins|patches|config/surf|BetterDiscord" | |||
whitelist="config.h|keybind.h|colors.h|color.h|rules.h" | |||
blacklist="powerlevel10k|secret|gitignore|log|plugins|patches|config/surf|BetterDiscord|\.ccls-cache" | |||
files="$(git --git-dir=$HOME/.dotfiles.git/ --work-tree=$HOME ls-files)" | |||
files="$(git --git-dir="$HOME/.dotfiles.git/" --work-tree="$HOME" ls-files)" | |||
items=$(echo "$files" | grep -Ev $blacklist) | |||
scripts=$(echo "$files" | grep -Ev $blacklist) | |||
suckless=$(echo "$files" | grep -Ev $blacklist | grep -E $whitelist) | |||
selection=$(printf "$items\n$scripts\n$suckless" | $DMENU) | |||
selection=$(printf "%s" "$items" | $DMENU) | |||
if [ ! "$selection" = "" ]; then | |||
if [ $(echo $selection | cut -d"/" -f 1) = "scripts" ]; then | |||
st -c vim -n vim -e $EDITOR "$HOME/$selection" | |||
elif [ $(echo $selection | cut -d"/" -f 1) = "suckless" ]; then | |||
st -c vim -n vim -e $EDITOR "$HOME/$selection" | |||
else | |||
st -c vim -n vim -e $EDITOR "$HOME/$selection" | |||
fi | |||
st -c vim -n vim -e "$EDITOR" "$HOME/$selection" | |||
fi |
@ -0,0 +1,6 @@ | |||
#!/bin/sh | |||
title=$(mpc -f "%title%" 2> /dev/null | head -n 1 | xargs) | |||
artist=$(mpc -f "%artist%" 2> /dev/null | head -n 1 | xargs) | |||
notify-send -a " $artist" -t 1500 "~ $title ~ " |
@ -1,13 +1,13 @@ | |||
home/home/ | |||
home/home/ [:VIM_EVAL:]expand('%:t')[:END_EVAL:] | |||
home/home/ [:VIM_EVAL:]expand('%:p:h:t')[:END_EVAL:] | |||
home/home/ | |||
home/home/ Created by Yigit Colakoglu on [:VIM_EVAL:]strftime('%mhome/%dhome/%y')[:END_EVAL:]. | |||
home/home/ Copyright [:VIM_EVAL:]strftime('%Y')[:END_EVAL:]. Yigit Colakoglu. All rights reserved. | |||
home/home/ | |||
// | |||
// [:VIM_EVAL:]expand('%:t')[:END_EVAL:] | |||
// [:VIM_EVAL:]expand('%:p:h:t')[:END_EVAL:] | |||
// | |||
// Created by Yigit Colakoglu on [:VIM_EVAL:]strftime('%m/%d/%y')[:END_EVAL:]. | |||
// Copyright [:VIM_EVAL:]strftime('%Y')[:END_EVAL:]. Yigit Colakoglu. All rights reserved. | |||
// | |||
#ifndef [:VIM_EVAL:]substitute(expand('%:t'),'\.',"_","")[:END_EVAL:] | |||
#define [:VIM_EVAL:]substitute(expand('%:t'),'\.',"_","")[:END_EVAL:] | |||
#endif home/* [:VIM_EVAL:]substitute(expand('%:t'),'\.',"_","")[:END_EVAL:] *home/ | |||
#endif /* [:VIM_EVAL:]substitute(expand('%:t'),'\.',"_","")[:END_EVAL:] */ |
@ -1,50 +0,0 @@ | |||
static const Rule rules[] = { | |||
/* xprop(1): | |||
* WM_CLASS(STRING) = instance, class | |||
* WM_NAME(STRING) = title | |||
* WM_WINDOW_ROLE(STRING) = role | |||
* _NET_WM_WINDOW_TYPE(ATOM) = wintype | |||
*/ | |||
RULE(.class = "discord", .tags = 1 << 8) | |||
RULE(.class = "firefoxdeveloperedition", .tags = 1 << 1) | |||
RULE(.class = "Brave-browser", .tags = 1 << 1) | |||
RULE(.class = "firefox", .tags = 1 << 1) | |||
RULE(.class = "tabbed-surf", .tags = 1 << 1) | |||
RULE(.class = "bitwarden", .tags = 1 << 6) | |||
RULE(.class = "QtPass", .tags = 1 << 6) | |||
RULE(.class = "qtpass", .tags = 1 << 6) | |||
RULE(.class = "Bitwarden", .tags = 1 << 6) | |||
RULE(.class = "Mailspring", .tags = 1 << 7) | |||
RULE(.class = "Thunderbird", .tags = 1 << 7) | |||
RULE(.class = "st-256color", .tags = 1 << 0, .isfloating=0) | |||
RULE(.class = "Tor Browser", .tags = 1 << 1) | |||
RULE(.class = "Chromium", .tags = 1 << 1) | |||
RULE(.class = "TelegramDesktop", .tags = 1 << 8) | |||
RULE(.class = "whatsapp-nativefier-d52542", .tags = 1 << 8) | |||
RULE(.class = "Sublime_Text", .tags = 1 << 2) | |||
RULE(.class = "code-oss", .tags = 1 << 2) | |||
RULE(.class = "jetbrains-idea", .tags = 1 << 2) | |||
RULE(.class = "Nemo", .isfloating = 1, .floatpos="50% 50% 1200W 800H") | |||
RULE(.class = "Spotify", .tags = 1 << 9) | |||
RULE(.instance = "spterm", .tags = SPTAG(0), .isfloating = 1) | |||
RULE(.class = "spfeh", .tags = SPTAG(1), .isfloating = 1) | |||
RULE(.instance = "spmutt", .tags = SPTAG(2), .isfloating = 1) | |||
RULE(.instance = "spfile", .tags = SPTAG(3), .isfloating = 1) | |||
RULE(.instance = "spmusic", .tags = SPTAG(4), .isfloating = 1) | |||
RULE(.instance = "spcal", .tags = SPTAG(5), .isfloating = 1) | |||
/* Terminal Window Rules */ | |||
RULE(.class = "ranger", 0, .isfloating = 1, .floatpos="50% 50% 800W 560H") | |||
RULE(.class = "lf", 0, .isfloating = 1, .floatpos="50% 50% 800W 560H") | |||
RULE(.class = "vim", 0, .isfloating = 1, .floatpos="50% 50% 1000W 700H") | |||
RULE(.class = "stpulse", 0, .isfloating = 1, .floatpos="50% 50% 800W 560H") | |||
RULE(.class = "mpv", 0, .isfloating = 1, .floatpos="100% 1% 600W 350H") | |||
RULE(.instance = "sxiv", 0, .isfloating = 1, .floatpos="100% 1% 600W 350H") | |||
RULE(.class = "neomutt-send", 0, .isfloating = 1, .floatpos="50% 50% 1000W 700H") | |||
//RULE(.class = "Zathura", 0, .isfloating = 1, .floatpos="100% 50% 700W 1000H") | |||
//RULE(.class = "Surf", 0, .isfloating = 1, .floatpos="100% 100% 800W 1200H") | |||
RULE(.class = "weather", 0, .isfloating = 1, .floatpos="50% 50% 1200W 800H") | |||
RULE(.class = "center", 0, .isfloating = 1, .floatpos="50% 50% 1000W 600H") | |||
RULE(.class = "htop", 0, .isfloating = 1, .floatpos="50% 50% 1200W 600H") | |||
RULE(.title = "SimCrop", 0, .isfloating = 1, .floatpos="50% 50% 800W 500H") | |||
}; |
@ -1,39 +0,0 @@ | |||
/* appearance */ | |||
static const unsigned int gappx = 6; | |||
static const unsigned int borderpx = 3; /* border pixel of windows */ | |||
static const unsigned int snap = 32; /* snap pixel */ | |||
static const int showbar = 1; /* 0 means no bar */ | |||
static const int user_bh = 27; | |||
static const int bar_height = 27; | |||
static const int topbar = 1; /* 0 means bottom bar */ | |||
static const char *fonts[] = { "CaskaydiaCove Nerd Font:size=10" }; | |||
static const char dmenufont[] = "CaskaydiaCove Nerd Font:size=10"; | |||
static const int vertpad = 10; /* vertical padding of bar */ | |||
static const int sidepad = 10; /* horizontal padding of bar */ | |||
static const char fore[] = "#e5e9f0"; | |||
static const char back[] = "#0f111a"; | |||
static const char border[] = "#3a575c"; | |||
static const char col0[] = "#3b4252"; | |||
static const char col1[] = "#bf616a"; /* red */ | |||
static const char col2[] = "#a3be8c"; /* green */ | |||
static const char col3[] = "#ebcb8b"; /* yellow */ | |||
static const char col4[] = "#81a1c1"; /* light_blue */ | |||
static const char col5[] = "#a48ead"; /* puple */ | |||
static const char col6[] = "#88c0d0"; /* blue */ | |||
static const char col7[] = "#e5e9f0"; /* white */ | |||
static const char col8[] = "#4c566a"; /* gray */ | |||
static char *colors[][ColCount] = { | |||
/* fg bg border float */ | |||
[SchemeNorm] = { fore, back, border, border}, | |||
[SchemeSel] = { fore, back, col1, col1}, | |||
[SchemeTitleNorm] = { fore, back, border }, | |||
[SchemeTitleSel] = { fore, back, border, border}, | |||
[SchemeTagsNorm] = { fore, back, border, border}, | |||
[SchemeTagsSel] = { back, col1, border, border}, | |||
[SchemeHid] = { back, col4, border, border}, | |||
[SchemeUrg] = { back, col5, border, border}, | |||
}; | |||
@ -1,79 +0,0 @@ | |||
/* Macros and inline functions to swap the order of bytes in integer values. | |||
Copyright (C) 1997-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#if !defined _BYTESWAP_H && !defined _NETINET_IN_H && !defined _ENDIAN_H | |||
# error "Never use <bits/byteswap.h> directly; include <byteswap.h> instead." | |||
#endif | |||
#ifndef _BITS_BYTESWAP_H | |||
#define _BITS_BYTESWAP_H 1 | |||
#include <features.h> | |||
#include <bits/types.h> | |||
/* Swap bytes in 16-bit value. */ | |||
#define __bswap_constant_16(x) \ | |||
((__uint16_t) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))) | |||
static __inline __uint16_t | |||
__bswap_16 (__uint16_t __bsx) | |||
{ | |||
#if __GNUC_PREREQ (4, 8) | |||
return __builtin_bswap16 (__bsx); | |||
#else | |||
return __bswap_constant_16 (__bsx); | |||
#endif | |||
} | |||
/* Swap bytes in 32-bit value. */ | |||
#define __bswap_constant_32(x) \ | |||
((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >> 8) \ | |||
| (((x) & 0x0000ff00u) << 8) | (((x) & 0x000000ffu) << 24)) | |||
static __inline __uint32_t | |||
__bswap_32 (__uint32_t __bsx) | |||
{ | |||
#if __GNUC_PREREQ (4, 3) | |||
return __builtin_bswap32 (__bsx); | |||
#else | |||
return __bswap_constant_32 (__bsx); | |||
#endif | |||
} | |||
/* Swap bytes in 64-bit value. */ | |||
#define __bswap_constant_64(x) \ | |||
((((x) & 0xff00000000000000ull) >> 56) \ | |||
| (((x) & 0x00ff000000000000ull) >> 40) \ | |||
| (((x) & 0x0000ff0000000000ull) >> 24) \ | |||
| (((x) & 0x000000ff00000000ull) >> 8) \ | |||
| (((x) & 0x00000000ff000000ull) << 8) \ | |||
| (((x) & 0x0000000000ff0000ull) << 24) \ | |||
| (((x) & 0x000000000000ff00ull) << 40) \ | |||
| (((x) & 0x00000000000000ffull) << 56)) | |||
__extension__ static __inline __uint64_t | |||
__bswap_64 (__uint64_t __bsx) | |||
{ | |||
#if __GNUC_PREREQ (4, 3) | |||
return __builtin_bswap64 (__bsx); | |||
#else | |||
return __bswap_constant_64 (__bsx); | |||
#endif | |||
} | |||
#endif /* _BITS_BYTESWAP_H */ |
@ -1,49 +0,0 @@ | |||
/* Endian macros for string.h functions | |||
Copyright (C) 1992-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<http://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_ENDIAN_H | |||
#define _BITS_ENDIAN_H 1 | |||
/* Definitions for byte order, according to significance of bytes, | |||
from low addresses to high addresses. The value is what you get by | |||
putting '4' in the most significant byte, '3' in the second most | |||
significant byte, '2' in the second least significant byte, and '1' | |||
in the least significant byte, and then writing down one digit for | |||
each byte, starting with the byte at the lowest address at the left, | |||
and proceeding to the byte with the highest address at the right. */ | |||
#define __LITTLE_ENDIAN 1234 | |||
#define __BIG_ENDIAN 4321 | |||
#define __PDP_ENDIAN 3412 | |||
/* This file defines `__BYTE_ORDER' for the particular machine. */ | |||
#include <bits/endianness.h> | |||
/* Some machines may need to use a different endianness for floating point | |||
values. */ | |||
#ifndef __FLOAT_WORD_ORDER | |||
# define __FLOAT_WORD_ORDER __BYTE_ORDER | |||
#endif | |||
#if __BYTE_ORDER == __LITTLE_ENDIAN | |||
# define __LONG_LONG_PAIR(HI, LO) LO, HI | |||
#elif __BYTE_ORDER == __BIG_ENDIAN | |||
# define __LONG_LONG_PAIR(HI, LO) HI, LO | |||
#endif | |||
#endif /* bits/endian.h */ |
@ -1,11 +0,0 @@ | |||
#ifndef _BITS_ENDIANNESS_H | |||
#define _BITS_ENDIANNESS_H 1 | |||
#ifndef _BITS_ENDIAN_H | |||
# error "Never use <bits/endianness.h> directly; include <endian.h> instead." | |||
#endif | |||
/* i386/x86_64 are little-endian. */ | |||
#define __BYTE_ORDER __LITTLE_ENDIAN | |||
#endif /* bits/endianness.h */ |
@ -1,86 +0,0 @@ | |||
/* Handle feature test macros at the start of a header. | |||
Copyright (C) 2016-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
/* This header is internal to glibc and should not be included outside | |||
of glibc headers. Headers including it must define | |||
__GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first. This header | |||
cannot have multiple include guards because ISO C feature test | |||
macros depend on the definition of the macro when an affected | |||
header is included, not when the first system header is | |||
included. */ | |||
#ifndef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION | |||
# error "Never include <bits/libc-header-start.h> directly." | |||
#endif | |||
#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION | |||
#include <features.h> | |||
/* ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__ | |||
macro. */ | |||
#undef __GLIBC_USE_LIB_EXT2 | |||
#if (defined __USE_GNU \ | |||
|| (defined __STDC_WANT_LIB_EXT2__ && __STDC_WANT_LIB_EXT2__ > 0)) | |||
# define __GLIBC_USE_LIB_EXT2 1 | |||
#else | |||
# define __GLIBC_USE_LIB_EXT2 0 | |||
#endif | |||
/* ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__ | |||
macro. Most but not all symbols enabled by that macro in TS | |||
18661-1 are enabled unconditionally in C2X; the symbols in Annex F | |||
still require that macro in C2X. */ | |||
#undef __GLIBC_USE_IEC_60559_BFP_EXT | |||
#if defined __USE_GNU || defined __STDC_WANT_IEC_60559_BFP_EXT__ | |||
# define __GLIBC_USE_IEC_60559_BFP_EXT 1 | |||
#else | |||
# define __GLIBC_USE_IEC_60559_BFP_EXT 0 | |||
#endif | |||
#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X | |||
#if __GLIBC_USE (IEC_60559_BFP_EXT) || __GLIBC_USE (ISOC2X) | |||
# define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1 | |||
#else | |||
# define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 0 | |||
#endif | |||
/* ISO/IEC TS 18661-4:2015 defines the | |||
__STDC_WANT_IEC_60559_FUNCS_EXT__ macro. Other than the reduction | |||
functions, the symbols from this TS are enabled unconditionally in | |||
C2X. */ | |||
#undef __GLIBC_USE_IEC_60559_FUNCS_EXT | |||
#if defined __USE_GNU || defined __STDC_WANT_IEC_60559_FUNCS_EXT__ | |||
# define __GLIBC_USE_IEC_60559_FUNCS_EXT 1 | |||
#else | |||
# define __GLIBC_USE_IEC_60559_FUNCS_EXT 0 | |||
#endif | |||
#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X | |||
#if __GLIBC_USE (IEC_60559_FUNCS_EXT) || __GLIBC_USE (ISOC2X) | |||
# define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1 | |||
#else | |||
# define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 0 | |||
#endif | |||
/* ISO/IEC TS 18661-3:2015 defines the | |||
__STDC_WANT_IEC_60559_TYPES_EXT__ macro. */ | |||
#undef __GLIBC_USE_IEC_60559_TYPES_EXT | |||
#if defined __USE_GNU || defined __STDC_WANT_IEC_60559_TYPES_EXT__ | |||
# define __GLIBC_USE_IEC_60559_TYPES_EXT 1 | |||
#else | |||
# define __GLIBC_USE_IEC_60559_TYPES_EXT 0 | |||
#endif |
@ -1,21 +0,0 @@ | |||
/* Properties of long double type. ldbl-96 version. | |||
Copyright (C) 2016-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
/* long double is distinct from double, so there is nothing to | |||
define here. */ | |||
#define __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI 0 |
@ -1,55 +0,0 @@ | |||
/* Copyright (C) 2002-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_PTHREADTYPES_ARCH_H | |||
#define _BITS_PTHREADTYPES_ARCH_H 1 | |||
#include <bits/wordsize.h> | |||
#ifdef __x86_64__ | |||
# if __WORDSIZE == 64 | |||
# define __SIZEOF_PTHREAD_MUTEX_T 40 | |||
# define __SIZEOF_PTHREAD_ATTR_T 56 | |||
# define __SIZEOF_PTHREAD_RWLOCK_T 56 | |||
# define __SIZEOF_PTHREAD_BARRIER_T 32 | |||
# else | |||
# define __SIZEOF_PTHREAD_MUTEX_T 32 | |||
# define __SIZEOF_PTHREAD_ATTR_T 32 | |||
# define __SIZEOF_PTHREAD_RWLOCK_T 44 | |||
# define __SIZEOF_PTHREAD_BARRIER_T 20 | |||
# endif | |||
#else | |||
# define __SIZEOF_PTHREAD_MUTEX_T 24 | |||
# define __SIZEOF_PTHREAD_ATTR_T 36 | |||
# define __SIZEOF_PTHREAD_RWLOCK_T 32 | |||
# define __SIZEOF_PTHREAD_BARRIER_T 20 | |||
#endif | |||
#define __SIZEOF_PTHREAD_MUTEXATTR_T 4 | |||
#define __SIZEOF_PTHREAD_COND_T 48 | |||
#define __SIZEOF_PTHREAD_CONDATTR_T 4 | |||
#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8 | |||
#define __SIZEOF_PTHREAD_BARRIERATTR_T 4 | |||
#define __LOCK_ALIGNMENT | |||
#define __ONCE_ALIGNMENT | |||
#ifndef __x86_64__ | |||
/* Extra attributes for the cleanup functions. */ | |||
# define __cleanup_fct_attribute __attribute__ ((__regparm__ (1))) | |||
#endif | |||
#endif /* bits/pthreadtypes.h */ |
@ -1,121 +0,0 @@ | |||
/* Declaration of common pthread types for all architectures. | |||
Copyright (C) 2017-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_PTHREADTYPES_COMMON_H | |||
# define _BITS_PTHREADTYPES_COMMON_H 1 | |||
/* For internal mutex and condition variable definitions. */ | |||
#include <bits/thread-shared-types.h> | |||
/* Thread identifiers. The structure of the attribute type is not | |||
exposed on purpose. */ | |||
typedef unsigned long int pthread_t; | |||
/* Data structures for mutex handling. The structure of the attribute | |||
type is not exposed on purpose. */ | |||
typedef union | |||
{ | |||
char __size[__SIZEOF_PTHREAD_MUTEXATTR_T]; | |||
int __align; | |||
} pthread_mutexattr_t; | |||
/* Data structure for condition variable handling. The structure of | |||
the attribute type is not exposed on purpose. */ | |||
typedef union | |||
{ | |||
char __size[__SIZEOF_PTHREAD_CONDATTR_T]; | |||
int __align; | |||
} pthread_condattr_t; | |||
/* Keys for thread-specific data */ | |||
typedef unsigned int pthread_key_t; | |||
/* Once-only execution */ | |||
typedef int __ONCE_ALIGNMENT pthread_once_t; | |||
union pthread_attr_t | |||
{ | |||
char __size[__SIZEOF_PTHREAD_ATTR_T]; | |||
long int __align; | |||
}; | |||
#ifndef __have_pthread_attr_t | |||
typedef union pthread_attr_t pthread_attr_t; | |||
# define __have_pthread_attr_t 1 | |||
#endif | |||
typedef union | |||
{ | |||
struct __pthread_mutex_s __data; | |||
char __size[__SIZEOF_PTHREAD_MUTEX_T]; | |||
long int __align; | |||
} pthread_mutex_t; | |||
typedef union | |||
{ | |||
struct __pthread_cond_s __data; | |||
char __size[__SIZEOF_PTHREAD_COND_T]; | |||
__extension__ long long int __align; | |||
} pthread_cond_t; | |||
#if defined __USE_UNIX98 || defined __USE_XOPEN2K | |||
/* Data structure for reader-writer lock variable handling. The | |||
structure of the attribute type is deliberately not exposed. */ | |||
typedef union | |||
{ | |||
struct __pthread_rwlock_arch_t __data; | |||
char __size[__SIZEOF_PTHREAD_RWLOCK_T]; | |||
long int __align; | |||
} pthread_rwlock_t; | |||
typedef union | |||
{ | |||
char __size[__SIZEOF_PTHREAD_RWLOCKATTR_T]; | |||
long int __align; | |||
} pthread_rwlockattr_t; | |||
#endif | |||
#ifdef __USE_XOPEN2K | |||
/* POSIX spinlock data type. */ | |||
typedef volatile int pthread_spinlock_t; | |||
/* POSIX barriers data type. The structure of the type is | |||
deliberately not exposed. */ | |||
typedef union | |||
{ | |||
char __size[__SIZEOF_PTHREAD_BARRIER_T]; | |||
long int __align; | |||
} pthread_barrier_t; | |||
typedef union | |||
{ | |||
char __size[__SIZEOF_PTHREAD_BARRIERATTR_T]; | |||
int __align; | |||
} pthread_barrierattr_t; | |||
#endif | |||
#endif |
@ -1,37 +0,0 @@ | |||
/* Copyright (C) 1997-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _SYS_SELECT_H | |||
# error "Never use <bits/select.h> directly; include <sys/select.h> instead." | |||
#endif | |||
/* We don't use `memset' because this would require a prototype and | |||
the array isn't too big. */ | |||
#define __FD_ZERO(s) \ | |||
do { \ | |||
unsigned int __i; \ | |||
fd_set *__arr = (s); \ | |||
for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) \ | |||
__FDS_BITS (__arr)[__i] = 0; \ | |||
} while (0) | |||
#define __FD_SET(d, s) \ | |||
((void) (__FDS_BITS (s)[__FD_ELT(d)] |= __FD_MASK(d))) | |||
#define __FD_CLR(d, s) \ | |||
((void) (__FDS_BITS (s)[__FD_ELT(d)] &= ~__FD_MASK(d))) | |||
#define __FD_ISSET(d, s) \ | |||
((__FDS_BITS (s)[__FD_ELT (d)] & __FD_MASK (d)) != 0) |
@ -1,29 +0,0 @@ | |||
/* Define intN_t types. | |||
Copyright (C) 2017-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_STDINT_INTN_H | |||
#define _BITS_STDINT_INTN_H 1 | |||
#include <bits/types.h> | |||
typedef __int8_t int8_t; | |||
typedef __int16_t int16_t; | |||
typedef __int32_t int32_t; | |||
typedef __int64_t int64_t; | |||
#endif /* bits/stdint-intn.h */ |
@ -1,29 +0,0 @@ | |||
/* Define uintN_t types. | |||
Copyright (C) 2017-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_STDINT_UINTN_H | |||
#define _BITS_STDINT_UINTN_H 1 | |||
#include <bits/types.h> | |||
typedef __uint8_t uint8_t; | |||
typedef __uint16_t uint16_t; | |||
typedef __uint32_t uint32_t; | |||
typedef __uint64_t uint64_t; | |||
#endif /* bits/stdint-uintn.h */ |
@ -1,63 +0,0 @@ | |||
/* x86 internal mutex struct definitions. | |||
Copyright (C) 2019-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<http://www.gnu.org/licenses/>. */ | |||
#ifndef _THREAD_MUTEX_INTERNAL_H | |||
#define _THREAD_MUTEX_INTERNAL_H 1 | |||
struct __pthread_mutex_s | |||
{ | |||
int __lock; | |||
unsigned int __count; | |||
int __owner; | |||
#ifdef __x86_64__ | |||
unsigned int __nusers; | |||
#endif | |||
/* KIND must stay at this position in the structure to maintain | |||
binary compatibility with static initializers. */ | |||
int __kind; | |||
#ifdef __x86_64__ | |||
short __spins; | |||
short __elision; | |||
__pthread_list_t __list; | |||
# define __PTHREAD_MUTEX_HAVE_PREV 1 | |||
#else | |||
unsigned int __nusers; | |||
__extension__ union | |||
{ | |||
struct | |||
{ | |||
short __espins; | |||
short __eelision; | |||
# define __spins __elision_data.__espins | |||
# define __elision __elision_data.__eelision | |||
} __elision_data; | |||
__pthread_slist_t __list; | |||
}; | |||
# define __PTHREAD_MUTEX_HAVE_PREV 0 | |||
#endif | |||
}; | |||
#ifdef __x86_64__ | |||
# define __PTHREAD_MUTEX_INITIALIZER(__kind) \ | |||
0, 0, 0, 0, __kind, 0, 0, { 0, 0 } | |||
#else | |||
# define __PTHREAD_MUTEX_INITIALIZER(__kind) \ | |||
0, 0, 0, __kind, 0, { { 0, 0 } } | |||
#endif | |||
#endif |
@ -1,65 +0,0 @@ | |||
/* x86 internal rwlock struct definitions. | |||
Copyright (C) 2019-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<http://www.gnu.org/licenses/>. */ | |||
#ifndef _RWLOCK_INTERNAL_H | |||
#define _RWLOCK_INTERNAL_H | |||
struct __pthread_rwlock_arch_t | |||
{ | |||
unsigned int __readers; | |||
unsigned int __writers; | |||
unsigned int __wrphase_futex; | |||
unsigned int __writers_futex; | |||
unsigned int __pad3; | |||
unsigned int __pad4; | |||
#ifdef __x86_64__ | |||
int __cur_writer; | |||
int __shared; | |||
signed char __rwelision; | |||
# ifdef __ILP32__ | |||
unsigned char __pad1[3]; | |||
# define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0 } | |||
# else | |||
unsigned char __pad1[7]; | |||
# define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0, 0, 0, 0, 0 } | |||
# endif | |||
unsigned long int __pad2; | |||
/* FLAGS must stay at this position in the structure to maintain | |||
binary compatibility. */ | |||
unsigned int __flags; | |||
#else /* __x86_64__ */ | |||
/* FLAGS must stay at this position in the structure to maintain | |||
binary compatibility. */ | |||
unsigned char __flags; | |||
unsigned char __shared; | |||
signed char __rwelision; | |||
unsigned char __pad2; | |||
int __cur_writer; | |||
#endif | |||
}; | |||
#ifdef __x86_64__ | |||
# define __PTHREAD_RWLOCK_INITIALIZER(__flags) \ | |||
0, 0, 0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, __flags | |||
#else | |||
# define __PTHREAD_RWLOCK_INITIALIZER(__flags) \ | |||
0, 0, 0, 0, 0, 0, __flags, 0, 0, 0, 0 | |||
#endif | |||
#endif |
@ -1,129 +0,0 @@ | |||
/* Common threading primitives definitions for both POSIX and C11. | |||
Copyright (C) 2017-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _THREAD_SHARED_TYPES_H | |||
#define _THREAD_SHARED_TYPES_H 1 | |||
/* Arch-specific definitions. Each architecture must define the following | |||
macros to define the expected sizes of pthread data types: | |||
__SIZEOF_PTHREAD_ATTR_T - size of pthread_attr_t. | |||
__SIZEOF_PTHREAD_MUTEX_T - size of pthread_mutex_t. | |||
__SIZEOF_PTHREAD_MUTEXATTR_T - size of pthread_mutexattr_t. | |||
__SIZEOF_PTHREAD_COND_T - size of pthread_cond_t. | |||
__SIZEOF_PTHREAD_CONDATTR_T - size of pthread_condattr_t. | |||
__SIZEOF_PTHREAD_RWLOCK_T - size of pthread_rwlock_t. | |||
__SIZEOF_PTHREAD_RWLOCKATTR_T - size of pthread_rwlockattr_t. | |||
__SIZEOF_PTHREAD_BARRIER_T - size of pthread_barrier_t. | |||
__SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t. | |||
The additional macro defines any constraint for the lock alignment | |||
inside the thread structures: | |||
__LOCK_ALIGNMENT - for internal lock/futex usage. | |||
Same idea but for the once locking primitive: | |||
__ONCE_ALIGNMENT - for pthread_once_t/once_flag definition. */ | |||
#include <bits/pthreadtypes-arch.h> | |||
/* Common definition of pthread_mutex_t. */ | |||
typedef struct __pthread_internal_list | |||
{ | |||
struct __pthread_internal_list *__prev; | |||
struct __pthread_internal_list *__next; | |||
} __pthread_list_t; | |||
typedef struct __pthread_internal_slist | |||
{ | |||
struct __pthread_internal_slist *__next; | |||
} __pthread_slist_t; | |||
/* Arch-specific mutex definitions. A generic implementation is provided | |||
by sysdeps/nptl/bits/struct_mutex.h. If required, an architecture | |||
can override it by defining: | |||
1. struct __pthread_mutex_s (used on both pthread_mutex_t and mtx_t | |||
definition). It should contains at least the internal members | |||
defined in the generic version. | |||
2. __LOCK_ALIGNMENT for any extra attribute for internal lock used with | |||
atomic operations. | |||
3. The macro __PTHREAD_MUTEX_INITIALIZER used for static initialization. | |||
It should initialize the mutex internal flag. */ | |||
#include <bits/struct_mutex.h> | |||
/* Arch-sepecific read-write lock definitions. A generic implementation is | |||
provided by struct_rwlock.h. If required, an architecture can override it | |||
by defining: | |||
1. struct __pthread_rwlock_arch_t (used on pthread_rwlock_t definition). | |||
It should contain at least the internal members defined in the | |||
generic version. | |||
2. The macro __PTHREAD_RWLOCK_INITIALIZER used for static initialization. | |||
It should initialize the rwlock internal type. */ | |||
#include <bits/struct_rwlock.h> | |||
/* Common definition of pthread_cond_t. */ | |||
struct __pthread_cond_s | |||
{ | |||
__extension__ union | |||
{ | |||
__extension__ unsigned long long int __wseq; | |||
struct | |||
{ | |||
unsigned int __low; | |||
unsigned int __high; | |||
} __wseq32; | |||
}; | |||
__extension__ union | |||
{ | |||
__extension__ unsigned long long int __g1_start; | |||
struct | |||
{ | |||
unsigned int __low; | |||
unsigned int __high; | |||
} __g1_start32; | |||
}; | |||
unsigned int __g_refs[2] __LOCK_ALIGNMENT; | |||
unsigned int __g_size[2]; | |||
unsigned int __g1_orig_size; | |||
unsigned int __wrefs; | |||
unsigned int __g_signals[2]; | |||
}; | |||
typedef unsigned int __tss_t; | |||
typedef unsigned long int __thrd_t; | |||
typedef struct | |||
{ | |||
int __data __ONCE_ALIGNMENT; | |||
} __once_flag; | |||
#define __ONCE_FLAG_INIT { 0 } | |||
#endif /* _THREAD_SHARED_TYPES_H */ |
@ -1,36 +0,0 @@ | |||
/* bits/time64.h -- underlying types for __time64_t. Generic version. | |||
Copyright (C) 2018-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_TYPES_H | |||
# error "Never include <bits/time64.h> directly; use <sys/types.h> instead." | |||
#endif | |||
#ifndef _BITS_TIME64_H | |||
#define _BITS_TIME64_H 1 | |||
/* Define __TIME64_T_TYPE so that it is always a 64-bit type. */ | |||
#if __TIMESIZE == 64 | |||
/* If we already have 64-bit time type then use it. */ | |||
# define __TIME64_T_TYPE __TIME_T_TYPE | |||
#else | |||
/* Define a 64-bit time type alongsize the 32-bit one. */ | |||
# define __TIME64_T_TYPE __SQUAD_TYPE | |||
#endif | |||
#endif /* bits/time64.h */ |
@ -1,25 +0,0 @@ | |||
/* Bit size of the time_t type at glibc build time, x86-64 and x32 case. | |||
Copyright (C) 2018-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#if defined __x86_64__ && defined __ILP32__ | |||
/* For x32, time is 64-bit even though word size is 32-bit. */ | |||
# define __TIMESIZE 64 | |||
#else | |||
/* For others, time size is word size. */ | |||
# define __TIMESIZE __WORDSIZE | |||
#endif |
@ -1,228 +0,0 @@ | |||
/* bits/types.h -- definitions of __*_t types underlying *_t types. | |||
Copyright (C) 2002-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
/* | |||
* Never include this file directly; use <sys/types.h> instead. | |||
*/ | |||
#ifndef _BITS_TYPES_H | |||
#define _BITS_TYPES_H 1 | |||
#include <features.h> | |||
#include <bits/wordsize.h> | |||
#include <bits/timesize.h> | |||
/* Convenience types. */ | |||
typedef unsigned char __u_char; | |||
typedef unsigned short int __u_short; | |||
typedef unsigned int __u_int; | |||
typedef unsigned long int __u_long; | |||
/* Fixed-size types, underlying types depend on word size and compiler. */ | |||
typedef signed char __int8_t; | |||
typedef unsigned char __uint8_t; | |||
typedef signed short int __int16_t; | |||
typedef unsigned short int __uint16_t; | |||
typedef signed int __int32_t; | |||
typedef unsigned int __uint32_t; | |||
#if __WORDSIZE == 64 | |||
typedef signed long int __int64_t; | |||
typedef unsigned long int __uint64_t; | |||
#else | |||
__extension__ typedef signed long long int __int64_t; | |||
__extension__ typedef unsigned long long int __uint64_t; | |||
#endif | |||
/* Smallest types with at least a given width. */ | |||
typedef __int8_t __int_least8_t; | |||
typedef __uint8_t __uint_least8_t; | |||
typedef __int16_t __int_least16_t; | |||
typedef __uint16_t __uint_least16_t; | |||
typedef __int32_t __int_least32_t; | |||
typedef __uint32_t __uint_least32_t; | |||
typedef __int64_t __int_least64_t; | |||
typedef __uint64_t __uint_least64_t; | |||
/* quad_t is also 64 bits. */ | |||
#if __WORDSIZE == 64 | |||
typedef long int __quad_t; | |||
typedef unsigned long int __u_quad_t; | |||
#else | |||
__extension__ typedef long long int __quad_t; | |||
__extension__ typedef unsigned long long int __u_quad_t; | |||
#endif | |||
/* Largest integral types. */ | |||
#if __WORDSIZE == 64 | |||
typedef long int __intmax_t; | |||
typedef unsigned long int __uintmax_t; | |||
#else | |||
__extension__ typedef long long int __intmax_t; | |||
__extension__ typedef unsigned long long int __uintmax_t; | |||
#endif | |||
/* The machine-dependent file <bits/typesizes.h> defines __*_T_TYPE | |||
macros for each of the OS types we define below. The definitions | |||
of those macros must use the following macros for underlying types. | |||
We define __S<SIZE>_TYPE and __U<SIZE>_TYPE for the signed and unsigned | |||
variants of each of the following integer types on this machine. | |||
16 -- "natural" 16-bit type (always short) | |||
32 -- "natural" 32-bit type (always int) | |||
64 -- "natural" 64-bit type (long or long long) | |||
LONG32 -- 32-bit type, traditionally long | |||
QUAD -- 64-bit type, traditionally long long | |||
WORD -- natural type of __WORDSIZE bits (int or long) | |||
LONGWORD -- type of __WORDSIZE bits, traditionally long | |||
We distinguish WORD/LONGWORD, 32/LONG32, and 64/QUAD so that the | |||
conventional uses of `long' or `long long' type modifiers match the | |||
types we define, even when a less-adorned type would be the same size. | |||
This matters for (somewhat) portably writing printf/scanf formats for | |||
these types, where using the appropriate l or ll format modifiers can | |||
make the typedefs and the formats match up across all GNU platforms. If | |||
we used `long' when it's 64 bits where `long long' is expected, then the | |||
compiler would warn about the formats not matching the argument types, | |||
and the programmer changing them to shut up the compiler would break the | |||
program's portability. | |||
Here we assume what is presently the case in all the GCC configurations | |||
we support: long long is always 64 bits, long is always word/address size, | |||
and int is always 32 bits. */ | |||
#define __S16_TYPE short int | |||
#define __U16_TYPE unsigned short int | |||
#define __S32_TYPE int | |||
#define __U32_TYPE unsigned int | |||
#define __SLONGWORD_TYPE long int | |||
#define __ULONGWORD_TYPE unsigned long int | |||
#if __WORDSIZE == 32 | |||
# define __SQUAD_TYPE __int64_t | |||
# define __UQUAD_TYPE __uint64_t | |||
# define __SWORD_TYPE int | |||
# define __UWORD_TYPE unsigned int | |||
# define __SLONG32_TYPE long int | |||
# define __ULONG32_TYPE unsigned long int | |||
# define __S64_TYPE __int64_t | |||
# define __U64_TYPE __uint64_t | |||
/* We want __extension__ before typedef's that use nonstandard base types | |||
such as `long long' in C89 mode. */ | |||
# define __STD_TYPE __extension__ typedef | |||
#elif __WORDSIZE == 64 | |||
# define __SQUAD_TYPE long int | |||
# define __UQUAD_TYPE unsigned long int | |||
# define __SWORD_TYPE long int | |||
# define __UWORD_TYPE unsigned long int | |||
# define __SLONG32_TYPE int | |||
# define __ULONG32_TYPE unsigned int | |||
# define __S64_TYPE long int | |||
# define __U64_TYPE unsigned long int | |||
/* No need to mark the typedef with __extension__. */ | |||
# define __STD_TYPE typedef | |||
#else | |||
# error | |||
#endif | |||
#include <bits/typesizes.h> /* Defines __*_T_TYPE macros. */ | |||
#include <bits/time64.h> /* Defines __TIME*_T_TYPE macros. */ | |||
__STD_TYPE __DEV_T_TYPE __dev_t; /* Type of device numbers. */ | |||
__STD_TYPE __UID_T_TYPE __uid_t; /* Type of user identifications. */ | |||
__STD_TYPE __GID_T_TYPE __gid_t; /* Type of group identifications. */ | |||
__STD_TYPE __INO_T_TYPE __ino_t; /* Type of file serial numbers. */ | |||
__STD_TYPE __INO64_T_TYPE __ino64_t; /* Type of file serial numbers (LFS).*/ | |||
__STD_TYPE __MODE_T_TYPE __mode_t; /* Type of file attribute bitmasks. */ | |||
__STD_TYPE __NLINK_T_TYPE __nlink_t; /* Type of file link counts. */ | |||
__STD_TYPE __OFF_T_TYPE __off_t; /* Type of file sizes and offsets. */ | |||
__STD_TYPE __OFF64_T_TYPE __off64_t; /* Type of file sizes and offsets (LFS). */ | |||
__STD_TYPE __PID_T_TYPE __pid_t; /* Type of process identifications. */ | |||
__STD_TYPE __FSID_T_TYPE __fsid_t; /* Type of file system IDs. */ | |||
__STD_TYPE __CLOCK_T_TYPE __clock_t; /* Type of CPU usage counts. */ | |||
__STD_TYPE __RLIM_T_TYPE __rlim_t; /* Type for resource measurement. */ | |||
__STD_TYPE __RLIM64_T_TYPE __rlim64_t; /* Type for resource measurement (LFS). */ | |||
__STD_TYPE __ID_T_TYPE __id_t; /* General type for IDs. */ | |||
__STD_TYPE __TIME_T_TYPE __time_t; /* Seconds since the Epoch. */ | |||
__STD_TYPE __USECONDS_T_TYPE __useconds_t; /* Count of microseconds. */ | |||
__STD_TYPE __SUSECONDS_T_TYPE __suseconds_t; /* Signed count of microseconds. */ | |||
__STD_TYPE __SUSECONDS64_T_TYPE __suseconds64_t; | |||
__STD_TYPE __DADDR_T_TYPE __daddr_t; /* The type of a disk address. */ | |||
__STD_TYPE __KEY_T_TYPE __key_t; /* Type of an IPC key. */ | |||
/* Clock ID used in clock and timer functions. */ | |||
__STD_TYPE __CLOCKID_T_TYPE __clockid_t; | |||
/* Timer ID returned by `timer_create'. */ | |||
__STD_TYPE __TIMER_T_TYPE __timer_t; | |||
/* Type to represent block size. */ | |||
__STD_TYPE __BLKSIZE_T_TYPE __blksize_t; | |||
/* Types from the Large File Support interface. */ | |||
/* Type to count number of disk blocks. */ | |||
__STD_TYPE __BLKCNT_T_TYPE __blkcnt_t; | |||
__STD_TYPE __BLKCNT64_T_TYPE __blkcnt64_t; | |||
/* Type to count file system blocks. */ | |||
__STD_TYPE __FSBLKCNT_T_TYPE __fsblkcnt_t; | |||
__STD_TYPE __FSBLKCNT64_T_TYPE __fsblkcnt64_t; | |||
/* Type to count file system nodes. */ | |||
__STD_TYPE __FSFILCNT_T_TYPE __fsfilcnt_t; | |||
__STD_TYPE __FSFILCNT64_T_TYPE __fsfilcnt64_t; | |||
/* Type of miscellaneous file system fields. */ | |||
__STD_TYPE __FSWORD_T_TYPE __fsword_t; | |||
__STD_TYPE __SSIZE_T_TYPE __ssize_t; /* Type of a byte count, or error. */ | |||
/* Signed long type used in system calls. */ | |||
__STD_TYPE __SYSCALL_SLONG_TYPE __syscall_slong_t; | |||
/* Unsigned long type used in system calls. */ | |||
__STD_TYPE __SYSCALL_ULONG_TYPE __syscall_ulong_t; | |||
/* These few don't really vary by system, they always correspond | |||
to one of the other defined types. */ | |||
typedef __off64_t __loff_t; /* Type of file sizes and offsets (LFS). */ | |||
typedef char *__caddr_t; | |||
/* Duplicates info from stdint.h but this is used in unistd.h. */ | |||
__STD_TYPE __SWORD_TYPE __intptr_t; | |||
/* Duplicate info from sys/socket.h. */ | |||
__STD_TYPE __U32_TYPE __socklen_t; | |||
/* C99: An integer type that can be accessed as an atomic entity, | |||
even in the presence of asynchronous interrupts. | |||
It is not currently necessary for this to be machine-specific. */ | |||
typedef int __sig_atomic_t; | |||
/* Seconds since the Epoch, visible to user code when time_t is too | |||
narrow only for consistency with the old way of widening too-narrow | |||
types. User code should never use __time64_t. */ | |||
#if __TIMESIZE == 64 && defined __LIBC | |||
# define __time64_t __time_t | |||
#elif __TIMESIZE != 64 | |||
__STD_TYPE __TIME64_T_TYPE __time64_t; | |||
#endif | |||
#undef __STD_TYPE | |||
#endif /* bits/types.h */ |
@ -1,10 +0,0 @@ | |||
#ifndef ____sigset_t_defined | |||
#define ____sigset_t_defined | |||
#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int))) | |||
typedef struct | |||
{ | |||
unsigned long int __val[_SIGSET_NWORDS]; | |||
} __sigset_t; | |||
#endif |
@ -1,9 +0,0 @@ | |||
#ifndef __clock_t_defined | |||
#define __clock_t_defined 1 | |||
#include <bits/types.h> | |||
/* Returned by `clock'. */ | |||
typedef __clock_t clock_t; | |||
#endif |
@ -1,9 +0,0 @@ | |||
#ifndef __clockid_t_defined | |||
#define __clockid_t_defined 1 | |||
#include <bits/types.h> | |||
/* Clock ID used in clock and timer functions. */ | |||
typedef __clockid_t clockid_t; | |||
#endif |
@ -1,9 +0,0 @@ | |||
#ifndef __sigset_t_defined | |||
#define __sigset_t_defined 1 | |||
#include <bits/types/__sigset_t.h> | |||
/* A set of signals to be blocked, unblocked, or waited for. */ | |||
typedef __sigset_t sigset_t; | |||
#endif |
@ -1,28 +0,0 @@ | |||
/* NB: Include guard matches what <linux/time.h> uses. */ | |||
#ifndef _STRUCT_TIMESPEC | |||
#define _STRUCT_TIMESPEC 1 | |||
#include <bits/types.h> | |||
#include <bits/endian.h> | |||
/* POSIX.1b structure for a time value. This is like a `struct timeval' but | |||
has nanoseconds instead of microseconds. */ | |||
struct timespec | |||
{ | |||
__time_t tv_sec; /* Seconds. */ | |||
#if __WORDSIZE == 64 \ | |||
|| (defined __SYSCALL_WORDSIZE && __SYSCALL_WORDSIZE == 64) \ | |||
|| __TIMESIZE == 32 | |||
__syscall_slong_t tv_nsec; /* Nanoseconds. */ | |||
#else | |||
# if __BYTE_ORDER == __BIG_ENDIAN | |||
int: 32; /* Padding. */ | |||
long int tv_nsec; /* Nanoseconds. */ | |||
# else | |||
long int tv_nsec; /* Nanoseconds. */ | |||
int: 32; /* Padding. */ | |||
# endif | |||
#endif | |||
}; | |||
#endif |
@ -1,13 +0,0 @@ | |||
#ifndef __timeval_defined | |||
#define __timeval_defined 1 | |||
#include <bits/types.h> | |||
/* A time value that is accurate to the nearest | |||
microsecond but also has a range of years. */ | |||
struct timeval | |||
{ | |||
__time_t tv_sec; /* Seconds. */ | |||
__suseconds_t tv_usec; /* Microseconds. */ | |||
}; | |||
#endif |
@ -1,9 +0,0 @@ | |||
#ifndef __time_t_defined | |||
#define __time_t_defined 1 | |||
#include <bits/types.h> | |||
/* Returned by `time'. */ | |||
typedef __time_t time_t; | |||
#endif |
@ -1,9 +0,0 @@ | |||
#ifndef __timer_t_defined | |||
#define __timer_t_defined 1 | |||
#include <bits/types.h> | |||
/* Timer ID returned by `timer_create'. */ | |||
typedef __timer_t timer_t; | |||
#endif |
@ -1,106 +0,0 @@ | |||
/* bits/typesizes.h -- underlying types for *_t. Linux/x86-64 version. | |||
Copyright (C) 2012-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_TYPES_H | |||
# error "Never include <bits/typesizes.h> directly; use <sys/types.h> instead." | |||
#endif | |||
#ifndef _BITS_TYPESIZES_H | |||
#define _BITS_TYPESIZES_H 1 | |||
/* See <bits/types.h> for the meaning of these macros. This file exists so | |||
that <bits/types.h> need not vary across different GNU platforms. */ | |||
/* X32 kernel interface is 64-bit. */ | |||
#if defined __x86_64__ && defined __ILP32__ | |||
# define __SYSCALL_SLONG_TYPE __SQUAD_TYPE | |||
# define __SYSCALL_ULONG_TYPE __UQUAD_TYPE | |||
#else | |||
# define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE | |||
# define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE | |||
#endif | |||
#define __DEV_T_TYPE __UQUAD_TYPE | |||
#define __UID_T_TYPE __U32_TYPE | |||
#define __GID_T_TYPE __U32_TYPE | |||
#define __INO_T_TYPE __SYSCALL_ULONG_TYPE | |||
#define __INO64_T_TYPE __UQUAD_TYPE | |||
#define __MODE_T_TYPE __U32_TYPE | |||
#ifdef __x86_64__ | |||
# define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE | |||
# define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE | |||
#else | |||
# define __NLINK_T_TYPE __UWORD_TYPE | |||
# define __FSWORD_T_TYPE __SWORD_TYPE | |||
#endif | |||
#define __OFF_T_TYPE __SYSCALL_SLONG_TYPE | |||
#define __OFF64_T_TYPE __SQUAD_TYPE | |||
#define __PID_T_TYPE __S32_TYPE | |||
#define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE | |||
#define __RLIM64_T_TYPE __UQUAD_TYPE | |||
#define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE | |||
#define __BLKCNT64_T_TYPE __SQUAD_TYPE | |||
#define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE | |||
#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE | |||
#define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE | |||
#define __FSFILCNT64_T_TYPE __UQUAD_TYPE | |||
#define __ID_T_TYPE __U32_TYPE | |||
#define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE | |||
#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE | |||
#define __USECONDS_T_TYPE __U32_TYPE | |||
#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE | |||
#define __SUSECONDS64_T_TYPE __SQUAD_TYPE | |||
#define __DADDR_T_TYPE __S32_TYPE | |||
#define __KEY_T_TYPE __S32_TYPE | |||
#define __CLOCKID_T_TYPE __S32_TYPE | |||
#define __TIMER_T_TYPE void * | |||
#define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE | |||
#define __FSID_T_TYPE struct { int __val[2]; } | |||
#define __SSIZE_T_TYPE __SWORD_TYPE | |||
#define __CPU_MASK_TYPE __SYSCALL_ULONG_TYPE | |||
#ifdef __x86_64__ | |||
/* Tell the libc code that off_t and off64_t are actually the same type | |||
for all ABI purposes, even if possibly expressed as different base types | |||
for C type-checking purposes. */ | |||
# define __OFF_T_MATCHES_OFF64_T 1 | |||
/* Same for ino_t and ino64_t. */ | |||
# define __INO_T_MATCHES_INO64_T 1 | |||
/* And for __rlim_t and __rlim64_t. */ | |||
# define __RLIM_T_MATCHES_RLIM64_T 1 | |||
/* And for fsblkcnt_t, fsblkcnt64_t, fsfilcnt_t and fsfilcnt64_t. */ | |||
# define __STATFS_MATCHES_STATFS64 1 | |||
/* And for getitimer, setitimer and rusage */ | |||
# define __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 1 | |||
#else | |||
# define __RLIM_T_MATCHES_RLIM64_T 0 | |||
# define __STATFS_MATCHES_STATFS64 0 | |||
# define __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 0 | |||
#endif | |||
/* Number of descriptors that can fit in an `fd_set'. */ | |||
#define __FD_SETSIZE 1024 | |||
#endif /* bits/typesizes.h */ |
@ -1,50 +0,0 @@ | |||
/* Inline functions to return unsigned integer values unchanged. | |||
Copyright (C) 2017-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#if !defined _NETINET_IN_H && !defined _ENDIAN_H | |||
# error "Never use <bits/uintn-identity.h> directly; include <netinet/in.h> or <endian.h> instead." | |||
#endif | |||
#ifndef _BITS_UINTN_IDENTITY_H | |||
#define _BITS_UINTN_IDENTITY_H 1 | |||
#include <bits/types.h> | |||
/* These inline functions are to ensure the appropriate type | |||
conversions and associated diagnostics from macros that convert to | |||
a given endianness. */ | |||
static __inline __uint16_t | |||
__uint16_identity (__uint16_t __x) | |||
{ | |||
return __x; | |||
} | |||
static __inline __uint32_t | |||
__uint32_identity (__uint32_t __x) | |||
{ | |||
return __x; | |||
} | |||
static __inline __uint64_t | |||
__uint64_identity (__uint64_t __x) | |||
{ | |||
return __x; | |||
} | |||
#endif /* _BITS_UINTN_IDENTITY_H. */ |
@ -1,49 +0,0 @@ | |||
/* wchar_t type related definitions. | |||
Copyright (C) 2000-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _BITS_WCHAR_H | |||
#define _BITS_WCHAR_H 1 | |||
/* The fallback definitions, for when __WCHAR_MAX__ or __WCHAR_MIN__ | |||
are not defined, give the right value and type as long as both int | |||
and wchar_t are 32-bit types. Adding L'\0' to a constant value | |||
ensures that the type is correct; it is necessary to use (L'\0' + | |||
0) rather than just L'\0' so that the type in C++ is the promoted | |||
version of wchar_t rather than the distinct wchar_t type itself. | |||
Because wchar_t in preprocessor #if expressions is treated as | |||
intmax_t or uintmax_t, the expression (L'\0' - 1) would have the | |||
wrong value for WCHAR_MAX in such expressions and so cannot be used | |||
to define __WCHAR_MAX in the unsigned case. */ | |||
#ifdef __WCHAR_MAX__ | |||
# define __WCHAR_MAX __WCHAR_MAX__ | |||
#elif L'\0' - 1 > 0 | |||
# define __WCHAR_MAX (0xffffffffu + L'\0') | |||
#else | |||
# define __WCHAR_MAX (0x7fffffff + L'\0') | |||
#endif | |||
#ifdef __WCHAR_MIN__ | |||
# define __WCHAR_MIN __WCHAR_MIN__ | |||
#elif L'\0' - 1 > 0 | |||
# define __WCHAR_MIN (L'\0' + 0) | |||
#else | |||
# define __WCHAR_MIN (-__WCHAR_MAX - 1) | |||
#endif | |||
#endif /* bits/wchar.h */ |
@ -1,17 +0,0 @@ | |||
/* Determine the wordsize from the preprocessor defines. */ | |||
#if defined __x86_64__ && !defined __ILP32__ | |||
# define __WORDSIZE 64 | |||
#else | |||
# define __WORDSIZE 32 | |||
#define __WORDSIZE32_SIZE_ULONG 0 | |||
#define __WORDSIZE32_PTRDIFF_LONG 0 | |||
#endif | |||
#ifdef __x86_64__ | |||
# define __WORDSIZE_TIME64_COMPAT32 1 | |||
/* Both x86-64 and x32 use the 64-bit system call interface. */ | |||
# define __SYSCALL_WORDSIZE 64 | |||
#else | |||
# define __WORDSIZE_TIME64_COMPAT32 0 | |||
#endif |
@ -1,72 +0,0 @@ | |||
/* Copyright (C) 1992-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _ENDIAN_H | |||
#define _ENDIAN_H 1 | |||
#include <features.h> | |||
/* Get the definitions of __*_ENDIAN, __BYTE_ORDER, and __FLOAT_WORD_ORDER. */ | |||
#include <bits/endian.h> | |||
#ifdef __USE_MISC | |||
# define LITTLE_ENDIAN __LITTLE_ENDIAN | |||
# define BIG_ENDIAN __BIG_ENDIAN | |||
# define PDP_ENDIAN __PDP_ENDIAN | |||
# define BYTE_ORDER __BYTE_ORDER | |||
#endif | |||
#if defined __USE_MISC && !defined __ASSEMBLER__ | |||
/* Conversion interfaces. */ | |||
# include <bits/byteswap.h> | |||
# include <bits/uintn-identity.h> | |||
# if __BYTE_ORDER == __LITTLE_ENDIAN | |||
# define htobe16(x) __bswap_16 (x) | |||
# define htole16(x) __uint16_identity (x) | |||
# define be16toh(x) __bswap_16 (x) | |||
# define le16toh(x) __uint16_identity (x) | |||
# define htobe32(x) __bswap_32 (x) | |||
# define htole32(x) __uint32_identity (x) | |||
# define be32toh(x) __bswap_32 (x) | |||
# define le32toh(x) __uint32_identity (x) | |||
# define htobe64(x) __bswap_64 (x) | |||
# define htole64(x) __uint64_identity (x) | |||
# define be64toh(x) __bswap_64 (x) | |||
# define le64toh(x) __uint64_identity (x) | |||
# else | |||
# define htobe16(x) __uint16_identity (x) | |||
# define htole16(x) __bswap_16 (x) | |||
# define be16toh(x) __uint16_identity (x) | |||
# define le16toh(x) __bswap_16 (x) | |||
# define htobe32(x) __uint32_identity (x) | |||
# define htole32(x) __bswap_32 (x) | |||
# define be32toh(x) __uint32_identity (x) | |||
# define le32toh(x) __bswap_32 (x) | |||
# define htobe64(x) __uint64_identity (x) | |||
# define htole64(x) __bswap_64 (x) | |||
# define be64toh(x) __uint64_identity (x) | |||
# define le64toh(x) __bswap_64 (x) | |||
# endif | |||
#endif | |||
#endif /* endian.h */ |
@ -1,500 +0,0 @@ | |||
/* Copyright (C) 1991-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _FEATURES_H | |||
#define _FEATURES_H 1 | |||
/* These are defined by the user (or the compiler) | |||
to specify the desired environment: | |||
__STRICT_ANSI__ ISO Standard C. | |||
_ISOC99_SOURCE Extensions to ISO C89 from ISO C99. | |||
_ISOC11_SOURCE Extensions to ISO C99 from ISO C11. | |||
_ISOC2X_SOURCE Extensions to ISO C99 from ISO C2X. | |||
__STDC_WANT_LIB_EXT2__ | |||
Extensions to ISO C99 from TR 27431-2:2010. | |||
__STDC_WANT_IEC_60559_BFP_EXT__ | |||
Extensions to ISO C11 from TS 18661-1:2014. | |||
__STDC_WANT_IEC_60559_FUNCS_EXT__ | |||
Extensions to ISO C11 from TS 18661-4:2015. | |||
__STDC_WANT_IEC_60559_TYPES_EXT__ | |||
Extensions to ISO C11 from TS 18661-3:2015. | |||
_POSIX_SOURCE IEEE Std 1003.1. | |||
_POSIX_C_SOURCE If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2; | |||
if >=199309L, add IEEE Std 1003.1b-1993; | |||
if >=199506L, add IEEE Std 1003.1c-1995; | |||
if >=200112L, all of IEEE 1003.1-2004 | |||
if >=200809L, all of IEEE 1003.1-2008 | |||
_XOPEN_SOURCE Includes POSIX and XPG things. Set to 500 if | |||
Single Unix conformance is wanted, to 600 for the | |||
sixth revision, to 700 for the seventh revision. | |||
_XOPEN_SOURCE_EXTENDED XPG things and X/Open Unix extensions. | |||
_LARGEFILE_SOURCE Some more functions for correct standard I/O. | |||
_LARGEFILE64_SOURCE Additional functionality from LFS for large files. | |||
_FILE_OFFSET_BITS=N Select default filesystem interface. | |||
_ATFILE_SOURCE Additional *at interfaces. | |||
_GNU_SOURCE All of the above, plus GNU extensions. | |||
_DEFAULT_SOURCE The default set of features (taking precedence over | |||
__STRICT_ANSI__). | |||
_FORTIFY_SOURCE Add security hardening to many library functions. | |||
Set to 1 or 2; 2 performs stricter checks than 1. | |||
_REENTRANT, _THREAD_SAFE | |||
Obsolete; equivalent to _POSIX_C_SOURCE=199506L. | |||
The `-ansi' switch to the GNU C compiler, and standards conformance | |||
options such as `-std=c99', define __STRICT_ANSI__. If none of | |||
these are defined, or if _DEFAULT_SOURCE is defined, the default is | |||
to have _POSIX_SOURCE set to one and _POSIX_C_SOURCE set to | |||
200809L, as well as enabling miscellaneous functions from BSD and | |||
SVID. If more than one of these are defined, they accumulate. For | |||
example __STRICT_ANSI__, _POSIX_SOURCE and _POSIX_C_SOURCE together | |||
give you ISO C, 1003.1, and 1003.2, but nothing else. | |||
These are defined by this file and are used by the | |||
header files to decide what to declare or define: | |||
__GLIBC_USE (F) Define things from feature set F. This is defined | |||
to 1 or 0; the subsequent macros are either defined | |||
or undefined, and those tests should be moved to | |||
__GLIBC_USE. | |||
__USE_ISOC11 Define ISO C11 things. | |||
__USE_ISOC99 Define ISO C99 things. | |||
__USE_ISOC95 Define ISO C90 AMD1 (C95) things. | |||
__USE_ISOCXX11 Define ISO C++11 things. | |||
__USE_POSIX Define IEEE Std 1003.1 things. | |||
__USE_POSIX2 Define IEEE Std 1003.2 things. | |||
__USE_POSIX199309 Define IEEE Std 1003.1, and .1b things. | |||
__USE_POSIX199506 Define IEEE Std 1003.1, .1b, .1c and .1i things. | |||
__USE_XOPEN Define XPG things. | |||
__USE_XOPEN_EXTENDED Define X/Open Unix things. | |||
__USE_UNIX98 Define Single Unix V2 things. | |||
__USE_XOPEN2K Define XPG6 things. | |||
__USE_XOPEN2KXSI Define XPG6 XSI things. | |||
__USE_XOPEN2K8 Define XPG7 things. | |||
__USE_XOPEN2K8XSI Define XPG7 XSI things. | |||
__USE_LARGEFILE Define correct standard I/O things. | |||
__USE_LARGEFILE64 Define LFS things with separate names. | |||
__USE_FILE_OFFSET64 Define 64bit interface as default. | |||
__USE_MISC Define things from 4.3BSD or System V Unix. | |||
__USE_ATFILE Define *at interfaces and AT_* constants for them. | |||
__USE_GNU Define GNU extensions. | |||
__USE_FORTIFY_LEVEL Additional security measures used, according to level. | |||
The macros `__GNU_LIBRARY__', `__GLIBC__', and `__GLIBC_MINOR__' are | |||
defined by this file unconditionally. `__GNU_LIBRARY__' is provided | |||
only for compatibility. All new code should use the other symbols | |||
to test for features. | |||
All macros listed above as possibly being defined by this file are | |||
explicitly undefined if they are not explicitly defined. | |||
Feature-test macros that are not defined by the user or compiler | |||
but are implied by the other feature-test macros defined (or by the | |||
lack of any definitions) are defined by the file. | |||
ISO C feature test macros depend on the definition of the macro | |||
when an affected header is included, not when the first system | |||
header is included, and so they are handled in | |||
<bits/libc-header-start.h>, which does not have a multiple include | |||
guard. Feature test macros that can be handled from the first | |||
system header included are handled here. */ | |||
/* Undefine everything, so we get a clean slate. */ | |||
#undef __USE_ISOC11 | |||
#undef __USE_ISOC99 | |||
#undef __USE_ISOC95 | |||
#undef __USE_ISOCXX11 | |||
#undef __USE_POSIX | |||
#undef __USE_POSIX2 | |||
#undef __USE_POSIX199309 | |||
#undef __USE_POSIX199506 | |||
#undef __USE_XOPEN | |||
#undef __USE_XOPEN_EXTENDED | |||
#undef __USE_UNIX98 | |||
#undef __USE_XOPEN2K | |||
#undef __USE_XOPEN2KXSI | |||
#undef __USE_XOPEN2K8 | |||
#undef __USE_XOPEN2K8XSI | |||
#undef __USE_LARGEFILE | |||
#undef __USE_LARGEFILE64 | |||
#undef __USE_FILE_OFFSET64 | |||
#undef __USE_MISC | |||
#undef __USE_ATFILE | |||
#undef __USE_GNU | |||
#undef __USE_FORTIFY_LEVEL | |||
#undef __KERNEL_STRICT_NAMES | |||
#undef __GLIBC_USE_ISOC2X | |||
#undef __GLIBC_USE_DEPRECATED_GETS | |||
#undef __GLIBC_USE_DEPRECATED_SCANF | |||
/* Suppress kernel-name space pollution unless user expressedly asks | |||
for it. */ | |||
#ifndef _LOOSE_KERNEL_NAMES | |||
# define __KERNEL_STRICT_NAMES | |||
#endif | |||
/* Convenience macro to test the version of gcc. | |||
Use like this: | |||
#if __GNUC_PREREQ (2,8) | |||
... code requiring gcc 2.8 or later ... | |||
#endif | |||
Note: only works for GCC 2.0 and later, because __GNUC_MINOR__ was | |||
added in 2.0. */ | |||
#if defined __GNUC__ && defined __GNUC_MINOR__ | |||
# define __GNUC_PREREQ(maj, min) \ | |||
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) | |||
#else | |||
# define __GNUC_PREREQ(maj, min) 0 | |||
#endif | |||
/* Similarly for clang. Features added to GCC after version 4.2 may | |||
or may not also be available in clang, and clang's definitions of | |||
__GNUC(_MINOR)__ are fixed at 4 and 2 respectively. Not all such | |||
features can be queried via __has_extension/__has_feature. */ | |||
#if defined __clang_major__ && defined __clang_minor__ | |||
# define __glibc_clang_prereq(maj, min) \ | |||
((__clang_major__ << 16) + __clang_minor__ >= ((maj) << 16) + (min)) | |||
#else | |||
# define __glibc_clang_prereq(maj, min) 0 | |||
#endif | |||
/* Whether to use feature set F. */ | |||
#define __GLIBC_USE(F) __GLIBC_USE_ ## F | |||
/* _BSD_SOURCE and _SVID_SOURCE are deprecated aliases for | |||
_DEFAULT_SOURCE. If _DEFAULT_SOURCE is present we do not | |||
issue a warning; the expectation is that the source is being | |||
transitioned to use the new macro. */ | |||
#if (defined _BSD_SOURCE || defined _SVID_SOURCE) \ | |||
&& !defined _DEFAULT_SOURCE | |||
# warning "_BSD_SOURCE and _SVID_SOURCE are deprecated, use _DEFAULT_SOURCE" | |||
# undef _DEFAULT_SOURCE | |||
# define _DEFAULT_SOURCE 1 | |||
#endif | |||
/* If _GNU_SOURCE was defined by the user, turn on all the other features. */ | |||
#ifdef _GNU_SOURCE | |||
# undef _ISOC95_SOURCE | |||
# define _ISOC95_SOURCE 1 | |||
# undef _ISOC99_SOURCE | |||
# define _ISOC99_SOURCE 1 | |||
# undef _ISOC11_SOURCE | |||
# define _ISOC11_SOURCE 1 | |||
# undef _ISOC2X_SOURCE | |||
# define _ISOC2X_SOURCE 1 | |||
# undef _POSIX_SOURCE | |||
# define _POSIX_SOURCE 1 | |||
# undef _POSIX_C_SOURCE | |||
# define _POSIX_C_SOURCE 200809L | |||
# undef _XOPEN_SOURCE | |||
# define _XOPEN_SOURCE 700 | |||
# undef _XOPEN_SOURCE_EXTENDED | |||
# define _XOPEN_SOURCE_EXTENDED 1 | |||
# undef _LARGEFILE64_SOURCE | |||
# define _LARGEFILE64_SOURCE 1 | |||
# undef _DEFAULT_SOURCE | |||
# define _DEFAULT_SOURCE 1 | |||
# undef _ATFILE_SOURCE | |||
# define _ATFILE_SOURCE 1 | |||
#endif | |||
/* If nothing (other than _GNU_SOURCE and _DEFAULT_SOURCE) is defined, | |||
define _DEFAULT_SOURCE. */ | |||
#if (defined _DEFAULT_SOURCE \ | |||
|| (!defined __STRICT_ANSI__ \ | |||
&& !defined _ISOC99_SOURCE && !defined _ISOC11_SOURCE \ | |||
&& !defined _ISOC2X_SOURCE \ | |||
&& !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE \ | |||
&& !defined _XOPEN_SOURCE)) | |||
# undef _DEFAULT_SOURCE | |||
# define _DEFAULT_SOURCE 1 | |||
#endif | |||
/* This is to enable the ISO C2X extension. */ | |||
#if (defined _ISOC2X_SOURCE \ | |||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L)) | |||
# define __GLIBC_USE_ISOC2X 1 | |||
#else | |||
# define __GLIBC_USE_ISOC2X 0 | |||
#endif | |||
/* This is to enable the ISO C11 extension. */ | |||
#if (defined _ISOC11_SOURCE || defined _ISOC2X_SOURCE \ | |||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L)) | |||
# define __USE_ISOC11 1 | |||
#endif | |||
/* This is to enable the ISO C99 extension. */ | |||
#if (defined _ISOC99_SOURCE || defined _ISOC11_SOURCE \ | |||
|| defined _ISOC2X_SOURCE \ | |||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)) | |||
# define __USE_ISOC99 1 | |||
#endif | |||
/* This is to enable the ISO C90 Amendment 1:1995 extension. */ | |||
#if (defined _ISOC99_SOURCE || defined _ISOC11_SOURCE \ | |||
|| defined _ISOC2X_SOURCE \ | |||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199409L)) | |||
# define __USE_ISOC95 1 | |||
#endif | |||
#ifdef __cplusplus | |||
/* This is to enable compatibility for ISO C++17. */ | |||
# if __cplusplus >= 201703L | |||
# define __USE_ISOC11 1 | |||
# endif | |||
/* This is to enable compatibility for ISO C++11. | |||
Check the temporary macro for now, too. */ | |||
# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ | |||
# define __USE_ISOCXX11 1 | |||
# define __USE_ISOC99 1 | |||
# endif | |||
#endif | |||
/* If none of the ANSI/POSIX macros are defined, or if _DEFAULT_SOURCE | |||
is defined, use POSIX.1-2008 (or another version depending on | |||
_XOPEN_SOURCE). */ | |||
#ifdef _DEFAULT_SOURCE | |||
# if !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE | |||
# define __USE_POSIX_IMPLICITLY 1 | |||
# endif | |||
# undef _POSIX_SOURCE | |||
# define _POSIX_SOURCE 1 | |||
# undef _POSIX_C_SOURCE | |||
# define _POSIX_C_SOURCE 200809L | |||
#endif | |||
#if ((!defined __STRICT_ANSI__ \ | |||
|| (defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) >= 500)) \ | |||
&& !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE) | |||
# define _POSIX_SOURCE 1 | |||
# if defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 500 | |||
# define _POSIX_C_SOURCE 2 | |||
# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 600 | |||
# define _POSIX_C_SOURCE 199506L | |||
# elif defined _XOPEN_SOURCE && (_XOPEN_SOURCE - 0) < 700 | |||
# define _POSIX_C_SOURCE 200112L | |||
# else | |||
# define _POSIX_C_SOURCE 200809L | |||
# endif | |||
# define __USE_POSIX_IMPLICITLY 1 | |||
#endif | |||
/* Some C libraries once required _REENTRANT and/or _THREAD_SAFE to be | |||
defined in all multithreaded code. GNU libc has not required this | |||
for many years. We now treat them as compatibility synonyms for | |||
_POSIX_C_SOURCE=199506L, which is the earliest level of POSIX with | |||
comprehensive support for multithreaded code. Using them never | |||
lowers the selected level of POSIX conformance, only raises it. */ | |||
#if ((!defined _POSIX_C_SOURCE || (_POSIX_C_SOURCE - 0) < 199506L) \ | |||
&& (defined _REENTRANT || defined _THREAD_SAFE)) | |||
# define _POSIX_SOURCE 1 | |||
# undef _POSIX_C_SOURCE | |||
# define _POSIX_C_SOURCE 199506L | |||
#endif | |||
#if (defined _POSIX_SOURCE \ | |||
|| (defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 1) \ | |||
|| defined _XOPEN_SOURCE) | |||
# define __USE_POSIX 1 | |||
#endif | |||
#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 2 || defined _XOPEN_SOURCE | |||
# define __USE_POSIX2 1 | |||
#endif | |||
#if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 199309L | |||
# define __USE_POSIX199309 1 | |||
#endif | |||
#if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 199506L | |||
# define __USE_POSIX199506 1 | |||
#endif | |||
#if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 200112L | |||
# define __USE_XOPEN2K 1 | |||
# undef __USE_ISOC95 | |||
# define __USE_ISOC95 1 | |||
# undef __USE_ISOC99 | |||
# define __USE_ISOC99 1 | |||
#endif | |||
#if defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE - 0) >= 200809L | |||
# define __USE_XOPEN2K8 1 | |||
# undef _ATFILE_SOURCE | |||
# define _ATFILE_SOURCE 1 | |||
#endif | |||
#ifdef _XOPEN_SOURCE | |||
# define __USE_XOPEN 1 | |||
# if (_XOPEN_SOURCE - 0) >= 500 | |||
# define __USE_XOPEN_EXTENDED 1 | |||
# define __USE_UNIX98 1 | |||
# undef _LARGEFILE_SOURCE | |||
# define _LARGEFILE_SOURCE 1 | |||
# if (_XOPEN_SOURCE - 0) >= 600 | |||
# if (_XOPEN_SOURCE - 0) >= 700 | |||
# define __USE_XOPEN2K8 1 | |||
# define __USE_XOPEN2K8XSI 1 | |||
# endif | |||
# define __USE_XOPEN2K 1 | |||
# define __USE_XOPEN2KXSI 1 | |||
# undef __USE_ISOC95 | |||
# define __USE_ISOC95 1 | |||
# undef __USE_ISOC99 | |||
# define __USE_ISOC99 1 | |||
# endif | |||
# else | |||
# ifdef _XOPEN_SOURCE_EXTENDED | |||
# define __USE_XOPEN_EXTENDED 1 | |||
# endif | |||
# endif | |||
#endif | |||
#ifdef _LARGEFILE_SOURCE | |||
# define __USE_LARGEFILE 1 | |||
#endif | |||
#ifdef _LARGEFILE64_SOURCE | |||
# define __USE_LARGEFILE64 1 | |||
#endif | |||
#if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64 | |||
# define __USE_FILE_OFFSET64 1 | |||
#endif | |||
#if defined _DEFAULT_SOURCE | |||
# define __USE_MISC 1 | |||
#endif | |||
#ifdef _ATFILE_SOURCE | |||
# define __USE_ATFILE 1 | |||
#endif | |||
#ifdef _GNU_SOURCE | |||
# define __USE_GNU 1 | |||
#endif | |||
#if defined _FORTIFY_SOURCE && _FORTIFY_SOURCE > 0 | |||
# if !defined __OPTIMIZE__ || __OPTIMIZE__ <= 0 | |||
# warning _FORTIFY_SOURCE requires compiling with optimization (-O) | |||
# elif !__GNUC_PREREQ (4, 1) | |||
# warning _FORTIFY_SOURCE requires GCC 4.1 or later | |||
# elif _FORTIFY_SOURCE > 2 && __glibc_clang_prereq (9, 0) | |||
# if _FORTIFY_SOURCE > 3 | |||
# warning _FORTIFY_SOURCE > 3 is treated like 3 on this platform | |||
# endif | |||
# define __USE_FORTIFY_LEVEL 3 | |||
# elif _FORTIFY_SOURCE > 1 | |||
# if _FORTIFY_SOURCE > 2 | |||
# warning _FORTIFY_SOURCE > 2 is treated like 2 on this platform | |||
# endif | |||
# define __USE_FORTIFY_LEVEL 2 | |||
# else | |||
# define __USE_FORTIFY_LEVEL 1 | |||
# endif | |||
#endif | |||
#ifndef __USE_FORTIFY_LEVEL | |||
# define __USE_FORTIFY_LEVEL 0 | |||
#endif | |||
/* The function 'gets' existed in C89, but is impossible to use | |||
safely. It has been removed from ISO C11 and ISO C++14. Note: for | |||
compatibility with various implementations of <cstdio>, this test | |||
must consider only the value of __cplusplus when compiling C++. */ | |||
#if defined __cplusplus ? __cplusplus >= 201402L : defined __USE_ISOC11 | |||
# define __GLIBC_USE_DEPRECATED_GETS 0 | |||
#else | |||
# define __GLIBC_USE_DEPRECATED_GETS 1 | |||
#endif | |||
/* GNU formerly extended the scanf functions with modified format | |||
specifiers %as, %aS, and %a[...] that allocate a buffer for the | |||
input using malloc. This extension conflicts with ISO C99, which | |||
defines %a as a standalone format specifier that reads a floating- | |||
point number; moreover, POSIX.1-2008 provides the same feature | |||
using the modifier letter 'm' instead (%ms, %mS, %m[...]). | |||
We now follow C99 unless GNU extensions are active and the compiler | |||
is specifically in C89 or C++98 mode (strict or not). For | |||
instance, with GCC, -std=gnu11 will have C99-compliant scanf with | |||
or without -D_GNU_SOURCE, but -std=c89 -D_GNU_SOURCE will have the | |||
old extension. */ | |||
#if (defined __USE_GNU \ | |||
&& (defined __cplusplus \ | |||
? (__cplusplus < 201103L && !defined __GXX_EXPERIMENTAL_CXX0X__) \ | |||
: (!defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L))) | |||
# define __GLIBC_USE_DEPRECATED_SCANF 1 | |||
#else | |||
# define __GLIBC_USE_DEPRECATED_SCANF 0 | |||
#endif | |||
/* Get definitions of __STDC_* predefined macros, if the compiler has | |||
not preincluded this header automatically. */ | |||
#include <stdc-predef.h> | |||
/* This macro indicates that the installed library is the GNU C Library. | |||
For historic reasons the value now is 6 and this will stay from now | |||
on. The use of this variable is deprecated. Use __GLIBC__ and | |||
__GLIBC_MINOR__ now (see below) when you want to test for a specific | |||
GNU C library version and use the values in <gnu/lib-names.h> to get | |||
the sonames of the shared libraries. */ | |||
#undef __GNU_LIBRARY__ | |||
#define __GNU_LIBRARY__ 6 | |||
/* Major and minor version number of the GNU C library package. Use | |||
these macros to test for features in specific releases. */ | |||
#define __GLIBC__ 2 | |||
#define __GLIBC_MINOR__ 33 | |||
#define __GLIBC_PREREQ(maj, min) \ | |||
((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min)) | |||
/* This is here only because every header file already includes this one. */ | |||
#ifndef __ASSEMBLER__ | |||
# ifndef _SYS_CDEFS_H | |||
# include <sys/cdefs.h> | |||
# endif | |||
/* If we don't have __REDIRECT, prototypes will be missing if | |||
__USE_FILE_OFFSET64 but not __USE_LARGEFILE[64]. */ | |||
# if defined __USE_FILE_OFFSET64 && !defined __REDIRECT | |||
# define __USE_LARGEFILE 1 | |||
# define __USE_LARGEFILE64 1 | |||
# endif | |||
#endif /* !ASSEMBLER */ | |||
/* Decide whether we can define 'extern inline' functions in headers. */ | |||
#if __GNUC_PREREQ (2, 7) && defined __OPTIMIZE__ \ | |||
&& !defined __OPTIMIZE_SIZE__ && !defined __NO_INLINE__ \ | |||
&& defined __extern_inline | |||
# define __USE_EXTERN_INLINES 1 | |||
#endif | |||
/* This is here only because every header file already includes this one. | |||
Get the definitions of all the appropriate `__stub_FUNCTION' symbols. | |||
<gnu/stubs.h> contains `#define __stub_FUNCTION' when FUNCTION is a stub | |||
that will always return failure (and set errno to ENOSYS). */ | |||
#include <gnu/stubs.h> | |||
#endif /* features.h */ |
@ -1,17 +0,0 @@ | |||
/* This file is automatically generated. | |||
It defines a symbol `__stub_FUNCTION' for each function | |||
in the C library which is a stub, meaning it will fail | |||
every time called, usually setting errno to ENOSYS. */ | |||
#ifdef _LIBC | |||
#error Applications may not define the macro _LIBC | |||
#endif | |||
#define __stub___compat_bdflush | |||
#define __stub_chflags | |||
#define __stub_fchflags | |||
#define __stub_gtty | |||
#define __stub_revoke | |||
#define __stub_setlogin | |||
#define __stub_sigreturn | |||
#define __stub_stty |
@ -1,14 +0,0 @@ | |||
/* This file is automatically generated. | |||
This file selects the right generated file of `__stub_FUNCTION' macros | |||
based on the architecture being compiled for. */ | |||
#if !defined __x86_64__ | |||
# include <gnu/stubs-32.h> | |||
#endif | |||
#if defined __x86_64__ && defined __LP64__ | |||
# include <gnu/stubs-64.h> | |||
#endif | |||
#if defined __x86_64__ && defined __ILP32__ | |||
# include <gnu/stubs-x32.h> | |||
#endif |
@ -1,60 +0,0 @@ | |||
/* Copyright (C) 1991-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _STDC_PREDEF_H | |||
#define _STDC_PREDEF_H 1 | |||
/* This header is separate from features.h so that the compiler can | |||
include it implicitly at the start of every compilation. It must | |||
not itself include <features.h> or any other header that includes | |||
<features.h> because the implicit include comes before any feature | |||
test macros that may be defined in a source file before it first | |||
explicitly includes a system header. GCC knows the name of this | |||
header in order to preinclude it. */ | |||
/* glibc's intent is to support the IEC 559 math functionality, real | |||
and complex. If the GCC (4.9 and later) predefined macros | |||
specifying compiler intent are available, use them to determine | |||
whether the overall intent is to support these features; otherwise, | |||
presume an older compiler has intent to support these features and | |||
define these macros by default. */ | |||
#ifdef __GCC_IEC_559 | |||
# if __GCC_IEC_559 > 0 | |||
# define __STDC_IEC_559__ 1 | |||
# endif | |||
#else | |||
# define __STDC_IEC_559__ 1 | |||
#endif | |||
#ifdef __GCC_IEC_559_COMPLEX | |||
# if __GCC_IEC_559_COMPLEX > 0 | |||
# define __STDC_IEC_559_COMPLEX__ 1 | |||
# endif | |||
#else | |||
# define __STDC_IEC_559_COMPLEX__ 1 | |||
#endif | |||
/* wchar_t uses Unicode 10.0.0. Version 10.0 of the Unicode Standard is | |||
synchronized with ISO/IEC 10646:2017, fifth edition, plus | |||
the following additions from Amendment 1 to the fifth edition: | |||
- 56 emoji characters | |||
- 285 hentaigana | |||
- 3 additional Zanabazar Square characters */ | |||
#define __STDC_ISO_10646__ 201706L | |||
#endif |
@ -1,319 +0,0 @@ | |||
/* Copyright (C) 1997-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
/* | |||
* ISO C99: 7.18 Integer types <stdint.h> | |||
*/ | |||
#ifndef _STDINT_H | |||
#define _STDINT_H 1 | |||
#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION | |||
#include <bits/libc-header-start.h> | |||
#include <bits/types.h> | |||
#include <bits/wchar.h> | |||
#include <bits/wordsize.h> | |||
/* Exact integral types. */ | |||
/* Signed. */ | |||
#include <bits/stdint-intn.h> | |||
/* Unsigned. */ | |||
#include <bits/stdint-uintn.h> | |||
/* Small types. */ | |||
/* Signed. */ | |||
typedef __int_least8_t int_least8_t; | |||
typedef __int_least16_t int_least16_t; | |||
typedef __int_least32_t int_least32_t; | |||
typedef __int_least64_t int_least64_t; | |||
/* Unsigned. */ | |||
typedef __uint_least8_t uint_least8_t; | |||
typedef __uint_least16_t uint_least16_t; | |||
typedef __uint_least32_t uint_least32_t; | |||
typedef __uint_least64_t uint_least64_t; | |||
/* Fast types. */ | |||
/* Signed. */ | |||
typedef signed char int_fast8_t; | |||
#if __WORDSIZE == 64 | |||
typedef long int int_fast16_t; | |||
typedef long int int_fast32_t; | |||
typedef long int int_fast64_t; | |||
#else | |||
typedef int int_fast16_t; | |||
typedef int int_fast32_t; | |||
__extension__ | |||
typedef long long int int_fast64_t; | |||
#endif | |||
/* Unsigned. */ | |||
typedef unsigned char uint_fast8_t; | |||
#if __WORDSIZE == 64 | |||
typedef unsigned long int uint_fast16_t; | |||
typedef unsigned long int uint_fast32_t; | |||
typedef unsigned long int uint_fast64_t; | |||
#else | |||
typedef unsigned int uint_fast16_t; | |||
typedef unsigned int uint_fast32_t; | |||
__extension__ | |||
typedef unsigned long long int uint_fast64_t; | |||
#endif | |||
/* Types for `void *' pointers. */ | |||
#if __WORDSIZE == 64 | |||
# ifndef __intptr_t_defined | |||
typedef long int intptr_t; | |||
# define __intptr_t_defined | |||
# endif | |||
typedef unsigned long int uintptr_t; | |||
#else | |||
# ifndef __intptr_t_defined | |||
typedef int intptr_t; | |||
# define __intptr_t_defined | |||
# endif | |||
typedef unsigned int uintptr_t; | |||
#endif | |||
/* Largest integral types. */ | |||
typedef __intmax_t intmax_t; | |||
typedef __uintmax_t uintmax_t; | |||
# if __WORDSIZE == 64 | |||
# define __INT64_C(c) c ## L | |||
# define __UINT64_C(c) c ## UL | |||
# else | |||
# define __INT64_C(c) c ## LL | |||
# define __UINT64_C(c) c ## ULL | |||
# endif | |||
/* Limits of integral types. */ | |||
/* Minimum of signed integral types. */ | |||
# define INT8_MIN (-128) | |||
# define INT16_MIN (-32767-1) | |||
# define INT32_MIN (-2147483647-1) | |||
# define INT64_MIN (-__INT64_C(9223372036854775807)-1) | |||
/* Maximum of signed integral types. */ | |||
# define INT8_MAX (127) | |||
# define INT16_MAX (32767) | |||
# define INT32_MAX (2147483647) | |||
# define INT64_MAX (__INT64_C(9223372036854775807)) | |||
/* Maximum of unsigned integral types. */ | |||
# define UINT8_MAX (255) | |||
# define UINT16_MAX (65535) | |||
# define UINT32_MAX (4294967295U) | |||
# define UINT64_MAX (__UINT64_C(18446744073709551615)) | |||
/* Minimum of signed integral types having a minimum size. */ | |||
# define INT_LEAST8_MIN (-128) | |||
# define INT_LEAST16_MIN (-32767-1) | |||
# define INT_LEAST32_MIN (-2147483647-1) | |||
# define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1) | |||
/* Maximum of signed integral types having a minimum size. */ | |||
# define INT_LEAST8_MAX (127) | |||
# define INT_LEAST16_MAX (32767) | |||
# define INT_LEAST32_MAX (2147483647) | |||
# define INT_LEAST64_MAX (__INT64_C(9223372036854775807)) | |||
/* Maximum of unsigned integral types having a minimum size. */ | |||
# define UINT_LEAST8_MAX (255) | |||
# define UINT_LEAST16_MAX (65535) | |||
# define UINT_LEAST32_MAX (4294967295U) | |||
# define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615)) | |||
/* Minimum of fast signed integral types having a minimum size. */ | |||
# define INT_FAST8_MIN (-128) | |||
# if __WORDSIZE == 64 | |||
# define INT_FAST16_MIN (-9223372036854775807L-1) | |||
# define INT_FAST32_MIN (-9223372036854775807L-1) | |||
# else | |||
# define INT_FAST16_MIN (-2147483647-1) | |||
# define INT_FAST32_MIN (-2147483647-1) | |||
# endif | |||
# define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1) | |||
/* Maximum of fast signed integral types having a minimum size. */ | |||
# define INT_FAST8_MAX (127) | |||
# if __WORDSIZE == 64 | |||
# define INT_FAST16_MAX (9223372036854775807L) | |||
# define INT_FAST32_MAX (9223372036854775807L) | |||
# else | |||
# define INT_FAST16_MAX (2147483647) | |||
# define INT_FAST32_MAX (2147483647) | |||
# endif | |||
# define INT_FAST64_MAX (__INT64_C(9223372036854775807)) | |||
/* Maximum of fast unsigned integral types having a minimum size. */ | |||
# define UINT_FAST8_MAX (255) | |||
# if __WORDSIZE == 64 | |||
# define UINT_FAST16_MAX (18446744073709551615UL) | |||
# define UINT_FAST32_MAX (18446744073709551615UL) | |||
# else | |||
# define UINT_FAST16_MAX (4294967295U) | |||
# define UINT_FAST32_MAX (4294967295U) | |||
# endif | |||
# define UINT_FAST64_MAX (__UINT64_C(18446744073709551615)) | |||
/* Values to test for integral types holding `void *' pointer. */ | |||
# if __WORDSIZE == 64 | |||
# define INTPTR_MIN (-9223372036854775807L-1) | |||
# define INTPTR_MAX (9223372036854775807L) | |||
# define UINTPTR_MAX (18446744073709551615UL) | |||
# else | |||
# define INTPTR_MIN (-2147483647-1) | |||
# define INTPTR_MAX (2147483647) | |||
# define UINTPTR_MAX (4294967295U) | |||
# endif | |||
/* Minimum for largest signed integral type. */ | |||
# define INTMAX_MIN (-__INT64_C(9223372036854775807)-1) | |||
/* Maximum for largest signed integral type. */ | |||
# define INTMAX_MAX (__INT64_C(9223372036854775807)) | |||
/* Maximum for largest unsigned integral type. */ | |||
# define UINTMAX_MAX (__UINT64_C(18446744073709551615)) | |||
/* Limits of other integer types. */ | |||
/* Limits of `ptrdiff_t' type. */ | |||
# if __WORDSIZE == 64 | |||
# define PTRDIFF_MIN (-9223372036854775807L-1) | |||
# define PTRDIFF_MAX (9223372036854775807L) | |||
# else | |||
# if __WORDSIZE32_PTRDIFF_LONG | |||
# define PTRDIFF_MIN (-2147483647L-1) | |||
# define PTRDIFF_MAX (2147483647L) | |||
# else | |||
# define PTRDIFF_MIN (-2147483647-1) | |||
# define PTRDIFF_MAX (2147483647) | |||
# endif | |||
# endif | |||
/* Limits of `sig_atomic_t'. */ | |||
# define SIG_ATOMIC_MIN (-2147483647-1) | |||
# define SIG_ATOMIC_MAX (2147483647) | |||
/* Limit of `size_t' type. */ | |||
# if __WORDSIZE == 64 | |||
# define SIZE_MAX (18446744073709551615UL) | |||
# else | |||
# if __WORDSIZE32_SIZE_ULONG | |||
# define SIZE_MAX (4294967295UL) | |||
# else | |||
# define SIZE_MAX (4294967295U) | |||
# endif | |||
# endif | |||
/* Limits of `wchar_t'. */ | |||
# ifndef WCHAR_MIN | |||
/* These constants might also be defined in <wchar.h>. */ | |||
# define WCHAR_MIN __WCHAR_MIN | |||
# define WCHAR_MAX __WCHAR_MAX | |||
# endif | |||
/* Limits of `wint_t'. */ | |||
# define WINT_MIN (0u) | |||
# define WINT_MAX (4294967295u) | |||
/* Signed. */ | |||
# define INT8_C(c) c | |||
# define INT16_C(c) c | |||
# define INT32_C(c) c | |||
# if __WORDSIZE == 64 | |||
# define INT64_C(c) c ## L | |||
# else | |||
# define INT64_C(c) c ## LL | |||
# endif | |||
/* Unsigned. */ | |||
# define UINT8_C(c) c | |||
# define UINT16_C(c) c | |||
# define UINT32_C(c) c ## U | |||
# if __WORDSIZE == 64 | |||
# define UINT64_C(c) c ## UL | |||
# else | |||
# define UINT64_C(c) c ## ULL | |||
# endif | |||
/* Maximal type. */ | |||
# if __WORDSIZE == 64 | |||
# define INTMAX_C(c) c ## L | |||
# define UINTMAX_C(c) c ## UL | |||
# else | |||
# define INTMAX_C(c) c ## LL | |||
# define UINTMAX_C(c) c ## ULL | |||
# endif | |||
#if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) | |||
# define INT8_WIDTH 8 | |||
# define UINT8_WIDTH 8 | |||
# define INT16_WIDTH 16 | |||
# define UINT16_WIDTH 16 | |||
# define INT32_WIDTH 32 | |||
# define UINT32_WIDTH 32 | |||
# define INT64_WIDTH 64 | |||
# define UINT64_WIDTH 64 | |||
# define INT_LEAST8_WIDTH 8 | |||
# define UINT_LEAST8_WIDTH 8 | |||
# define INT_LEAST16_WIDTH 16 | |||
# define UINT_LEAST16_WIDTH 16 | |||
# define INT_LEAST32_WIDTH 32 | |||
# define UINT_LEAST32_WIDTH 32 | |||
# define INT_LEAST64_WIDTH 64 | |||
# define UINT_LEAST64_WIDTH 64 | |||
# define INT_FAST8_WIDTH 8 | |||
# define UINT_FAST8_WIDTH 8 | |||
# define INT_FAST16_WIDTH __WORDSIZE | |||
# define UINT_FAST16_WIDTH __WORDSIZE | |||
# define INT_FAST32_WIDTH __WORDSIZE | |||
# define UINT_FAST32_WIDTH __WORDSIZE | |||
# define INT_FAST64_WIDTH 64 | |||
# define UINT_FAST64_WIDTH 64 | |||
# define INTPTR_WIDTH __WORDSIZE | |||
# define UINTPTR_WIDTH __WORDSIZE | |||
# define INTMAX_WIDTH 64 | |||
# define UINTMAX_WIDTH 64 | |||
# define PTRDIFF_WIDTH __WORDSIZE | |||
# define SIG_ATOMIC_WIDTH 32 | |||
# define SIZE_WIDTH __WORDSIZE | |||
# define WCHAR_WIDTH 32 | |||
# define WINT_WIDTH 32 | |||
#endif | |||
#endif /* stdint.h */ |
@ -1,580 +0,0 @@ | |||
/* Copyright (C) 1992-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
#ifndef _SYS_CDEFS_H | |||
#define _SYS_CDEFS_H 1 | |||
/* We are almost always included from features.h. */ | |||
#ifndef _FEATURES_H | |||
# include <features.h> | |||
#endif | |||
/* The GNU libc does not support any K&R compilers or the traditional mode | |||
of ISO C compilers anymore. Check for some of the combinations not | |||
supported anymore. */ | |||
#if defined __GNUC__ && !defined __STDC__ | |||
# error "You need a ISO C conforming compiler to use the glibc headers" | |||
#endif | |||
/* Some user header file might have defined this before. */ | |||
#undef __P | |||
#undef __PMT | |||
#ifdef __GNUC__ | |||
/* All functions, except those with callbacks or those that | |||
synchronize memory, are leaf functions. */ | |||
# if __GNUC_PREREQ (4, 6) && !defined _LIBC | |||
# define __LEAF , __leaf__ | |||
# define __LEAF_ATTR __attribute__ ((__leaf__)) | |||
# else | |||
# define __LEAF | |||
# define __LEAF_ATTR | |||
# endif | |||
/* GCC can always grok prototypes. For C++ programs we add throw() | |||
to help it optimize the function calls. But this only works with | |||
gcc 2.8.x and egcs. For gcc 3.2 and up we even mark C functions | |||
as non-throwing using a function attribute since programs can use | |||
the -fexceptions options for C code as well. */ | |||
# if !defined __cplusplus && __GNUC_PREREQ (3, 3) | |||
# define __THROW __attribute__ ((__nothrow__ __LEAF)) | |||
# define __THROWNL __attribute__ ((__nothrow__)) | |||
# define __NTH(fct) __attribute__ ((__nothrow__ __LEAF)) fct | |||
# define __NTHNL(fct) __attribute__ ((__nothrow__)) fct | |||
# else | |||
# if defined __cplusplus && __GNUC_PREREQ (2,8) | |||
# if __cplusplus >= 201103L | |||
# define __THROW noexcept (true) | |||
# else | |||
# define __THROW throw () | |||
# endif | |||
# define __THROWNL __THROW | |||
# define __NTH(fct) __LEAF_ATTR fct __THROW | |||
# define __NTHNL(fct) fct __THROW | |||
# else | |||
# define __THROW | |||
# define __THROWNL | |||
# define __NTH(fct) fct | |||
# define __NTHNL(fct) fct | |||
# endif | |||
# endif | |||
#else /* Not GCC. */ | |||
# if (defined __cplusplus \ | |||
|| (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)) | |||
# define __inline inline | |||
# else | |||
# define __inline /* No inline functions. */ | |||
# endif | |||
# define __THROW | |||
# define __THROWNL | |||
# define __NTH(fct) fct | |||
#endif /* GCC. */ | |||
/* Compilers that are not clang may object to | |||
#if defined __clang__ && __has_extension(...) | |||
even though they do not need to evaluate the right-hand side of the &&. */ | |||
#if defined __clang__ && defined __has_extension | |||
# define __glibc_clang_has_extension(ext) __has_extension (ext) | |||
#else | |||
# define __glibc_clang_has_extension(ext) 0 | |||
#endif | |||
/* These two macros are not used in glibc anymore. They are kept here | |||
only because some other projects expect the macros to be defined. */ | |||
#define __P(args) args | |||
#define __PMT(args) args | |||
/* For these things, GCC behaves the ANSI way normally, | |||
and the non-ANSI way under -traditional. */ | |||
#define __CONCAT(x,y) x ## y | |||
#define __STRING(x) #x | |||
/* This is not a typedef so `const __ptr_t' does the right thing. */ | |||
#define __ptr_t void * | |||
/* C++ needs to know that types and declarations are C, not C++. */ | |||
#ifdef __cplusplus | |||
# define __BEGIN_DECLS extern "C" { | |||
# define __END_DECLS } | |||
#else | |||
# define __BEGIN_DECLS | |||
# define __END_DECLS | |||
#endif | |||
/* Fortify support. */ | |||
#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) | |||
#define __bos0(ptr) __builtin_object_size (ptr, 0) | |||
/* Use __builtin_dynamic_object_size at _FORTIFY_SOURCE=3 when available. */ | |||
#if __USE_FORTIFY_LEVEL == 3 && __glibc_clang_prereq (9, 0) | |||
# define __glibc_objsize0(__o) __builtin_dynamic_object_size (__o, 0) | |||
# define __glibc_objsize(__o) __builtin_dynamic_object_size (__o, 1) | |||
#else | |||
# define __glibc_objsize0(__o) __bos0 (__o) | |||
# define __glibc_objsize(__o) __bos (__o) | |||
#endif | |||
#if __GNUC_PREREQ (4,3) | |||
# define __warnattr(msg) __attribute__((__warning__ (msg))) | |||
# define __errordecl(name, msg) \ | |||
extern void name (void) __attribute__((__error__ (msg))) | |||
#else | |||
# define __warnattr(msg) | |||
# define __errordecl(name, msg) extern void name (void) | |||
#endif | |||
/* Support for flexible arrays. | |||
Headers that should use flexible arrays only if they're "real" | |||
(e.g. only if they won't affect sizeof()) should test | |||
#if __glibc_c99_flexarr_available. */ | |||
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L | |||
# define __flexarr [] | |||
# define __glibc_c99_flexarr_available 1 | |||
#elif __GNUC_PREREQ (2,97) | |||
/* GCC 2.97 supports C99 flexible array members as an extension, | |||
even when in C89 mode or compiling C++ (any version). */ | |||
# define __flexarr [] | |||
# define __glibc_c99_flexarr_available 1 | |||
#elif defined __GNUC__ | |||
/* Pre-2.97 GCC did not support C99 flexible arrays but did have | |||
an equivalent extension with slightly different notation. */ | |||
# define __flexarr [0] | |||
# define __glibc_c99_flexarr_available 1 | |||
#else | |||
/* Some other non-C99 compiler. Approximate with [1]. */ | |||
# define __flexarr [1] | |||
# define __glibc_c99_flexarr_available 0 | |||
#endif | |||
/* __asm__ ("xyz") is used throughout the headers to rename functions | |||
at the assembly language level. This is wrapped by the __REDIRECT | |||
macro, in order to support compilers that can do this some other | |||
way. When compilers don't support asm-names at all, we have to do | |||
preprocessor tricks instead (which don't have exactly the right | |||
semantics, but it's the best we can do). | |||
Example: | |||
int __REDIRECT(setpgrp, (__pid_t pid, __pid_t pgrp), setpgid); */ | |||
#if defined __GNUC__ && __GNUC__ >= 2 | |||
# define __REDIRECT(name, proto, alias) name proto __asm__ (__ASMNAME (#alias)) | |||
# ifdef __cplusplus | |||
# define __REDIRECT_NTH(name, proto, alias) \ | |||
name proto __THROW __asm__ (__ASMNAME (#alias)) | |||
# define __REDIRECT_NTHNL(name, proto, alias) \ | |||
name proto __THROWNL __asm__ (__ASMNAME (#alias)) | |||
# else | |||
# define __REDIRECT_NTH(name, proto, alias) \ | |||
name proto __asm__ (__ASMNAME (#alias)) __THROW | |||
# define __REDIRECT_NTHNL(name, proto, alias) \ | |||
name proto __asm__ (__ASMNAME (#alias)) __THROWNL | |||
# endif | |||
# define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname) | |||
# define __ASMNAME2(prefix, cname) __STRING (prefix) cname | |||
/* | |||
#elif __SOME_OTHER_COMPILER__ | |||
# define __REDIRECT(name, proto, alias) name proto; \ | |||
_Pragma("let " #name " = " #alias) | |||
*/ | |||
#endif | |||
/* GCC has various useful declarations that can be made with the | |||
`__attribute__' syntax. All of the ways we use this do fine if | |||
they are omitted for compilers that don't understand it. */ | |||
#if !defined __GNUC__ || __GNUC__ < 2 | |||
# define __attribute__(xyz) /* Ignore */ | |||
#endif | |||
/* At some point during the gcc 2.96 development the `malloc' attribute | |||
for functions was introduced. We don't want to use it unconditionally | |||
(although this would be possible) since it generates warnings. */ | |||
#if __GNUC_PREREQ (2,96) | |||
# define __attribute_malloc__ __attribute__ ((__malloc__)) | |||
#else | |||
# define __attribute_malloc__ /* Ignore */ | |||
#endif | |||
/* Tell the compiler which arguments to an allocation function | |||
indicate the size of the allocation. */ | |||
#if __GNUC_PREREQ (4, 3) | |||
# define __attribute_alloc_size__(params) \ | |||
__attribute__ ((__alloc_size__ params)) | |||
#else | |||
# define __attribute_alloc_size__(params) /* Ignore. */ | |||
#endif | |||
/* At some point during the gcc 2.96 development the `pure' attribute | |||
for functions was introduced. We don't want to use it unconditionally | |||
(although this would be possible) since it generates warnings. */ | |||
#if __GNUC_PREREQ (2,96) | |||
# define __attribute_pure__ __attribute__ ((__pure__)) | |||
#else | |||
# define __attribute_pure__ /* Ignore */ | |||
#endif | |||
/* This declaration tells the compiler that the value is constant. */ | |||
#if __GNUC_PREREQ (2,5) | |||
# define __attribute_const__ __attribute__ ((__const__)) | |||
#else | |||
# define __attribute_const__ /* Ignore */ | |||
#endif | |||
/* At some point during the gcc 3.1 development the `used' attribute | |||
for functions was introduced. We don't want to use it unconditionally | |||
(although this would be possible) since it generates warnings. */ | |||
#if __GNUC_PREREQ (3,1) | |||
# define __attribute_used__ __attribute__ ((__used__)) | |||
# define __attribute_noinline__ __attribute__ ((__noinline__)) | |||
#else | |||
# define __attribute_used__ __attribute__ ((__unused__)) | |||
# define __attribute_noinline__ /* Ignore */ | |||
#endif | |||
/* Since version 3.2, gcc allows marking deprecated functions. */ | |||
#if __GNUC_PREREQ (3,2) | |||
# define __attribute_deprecated__ __attribute__ ((__deprecated__)) | |||
#else | |||
# define __attribute_deprecated__ /* Ignore */ | |||
#endif | |||
/* Since version 4.5, gcc also allows one to specify the message printed | |||
when a deprecated function is used. clang claims to be gcc 4.2, but | |||
may also support this feature. */ | |||
#if __GNUC_PREREQ (4,5) \ | |||
|| __glibc_clang_has_extension (__attribute_deprecated_with_message__) | |||
# define __attribute_deprecated_msg__(msg) \ | |||
__attribute__ ((__deprecated__ (msg))) | |||
#else | |||
# define __attribute_deprecated_msg__(msg) __attribute_deprecated__ | |||
#endif | |||
/* At some point during the gcc 2.8 development the `format_arg' attribute | |||
for functions was introduced. We don't want to use it unconditionally | |||
(although this would be possible) since it generates warnings. | |||
If several `format_arg' attributes are given for the same function, in | |||
gcc-3.0 and older, all but the last one are ignored. In newer gccs, | |||
all designated arguments are considered. */ | |||
#if __GNUC_PREREQ (2,8) | |||
# define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x))) | |||
#else | |||
# define __attribute_format_arg__(x) /* Ignore */ | |||
#endif | |||
/* At some point during the gcc 2.97 development the `strfmon' format | |||
attribute for functions was introduced. We don't want to use it | |||
unconditionally (although this would be possible) since it | |||
generates warnings. */ | |||
#if __GNUC_PREREQ (2,97) | |||
# define __attribute_format_strfmon__(a,b) \ | |||
__attribute__ ((__format__ (__strfmon__, a, b))) | |||
#else | |||
# define __attribute_format_strfmon__(a,b) /* Ignore */ | |||
#endif | |||
/* The nonull function attribute allows to mark pointer parameters which | |||
must not be NULL. */ | |||
#if __GNUC_PREREQ (3,3) | |||
# define __nonnull(params) __attribute__ ((__nonnull__ params)) | |||
#else | |||
# define __nonnull(params) | |||
#endif | |||
/* If fortification mode, we warn about unused results of certain | |||
function calls which can lead to problems. */ | |||
#if __GNUC_PREREQ (3,4) | |||
# define __attribute_warn_unused_result__ \ | |||
__attribute__ ((__warn_unused_result__)) | |||
# if __USE_FORTIFY_LEVEL > 0 | |||
# define __wur __attribute_warn_unused_result__ | |||
# endif | |||
#else | |||
# define __attribute_warn_unused_result__ /* empty */ | |||
#endif | |||
#ifndef __wur | |||
# define __wur /* Ignore */ | |||
#endif | |||
/* Forces a function to be always inlined. */ | |||
#if __GNUC_PREREQ (3,2) | |||
/* The Linux kernel defines __always_inline in stddef.h (283d7573), and | |||
it conflicts with this definition. Therefore undefine it first to | |||
allow either header to be included first. */ | |||
# undef __always_inline | |||
# define __always_inline __inline __attribute__ ((__always_inline__)) | |||
#else | |||
# undef __always_inline | |||
# define __always_inline __inline | |||
#endif | |||
/* Associate error messages with the source location of the call site rather | |||
than with the source location inside the function. */ | |||
#if __GNUC_PREREQ (4,3) | |||
# define __attribute_artificial__ __attribute__ ((__artificial__)) | |||
#else | |||
# define __attribute_artificial__ /* Ignore */ | |||
#endif | |||
/* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 | |||
inline semantics, unless -fgnu89-inline is used. Using __GNUC_STDC_INLINE__ | |||
or __GNUC_GNU_INLINE is not a good enough check for gcc because gcc versions | |||
older than 4.3 may define these macros and still not guarantee GNU inlining | |||
semantics. | |||
clang++ identifies itself as gcc-4.2, but has support for GNU inlining | |||
semantics, that can be checked for by using the __GNUC_STDC_INLINE_ and | |||
__GNUC_GNU_INLINE__ macro definitions. */ | |||
#if (!defined __cplusplus || __GNUC_PREREQ (4,3) \ | |||
|| (defined __clang__ && (defined __GNUC_STDC_INLINE__ \ | |||
|| defined __GNUC_GNU_INLINE__))) | |||
# if defined __GNUC_STDC_INLINE__ || defined __cplusplus | |||
# define __extern_inline extern __inline __attribute__ ((__gnu_inline__)) | |||
# define __extern_always_inline \ | |||
extern __always_inline __attribute__ ((__gnu_inline__)) | |||
# else | |||
# define __extern_inline extern __inline | |||
# define __extern_always_inline extern __always_inline | |||
# endif | |||
#endif | |||
#ifdef __extern_always_inline | |||
# define __fortify_function __extern_always_inline __attribute_artificial__ | |||
#endif | |||
/* GCC 4.3 and above allow passing all anonymous arguments of an | |||
__extern_always_inline function to some other vararg function. */ | |||
#if __GNUC_PREREQ (4,3) | |||
# define __va_arg_pack() __builtin_va_arg_pack () | |||
# define __va_arg_pack_len() __builtin_va_arg_pack_len () | |||
#endif | |||
/* It is possible to compile containing GCC extensions even if GCC is | |||
run in pedantic mode if the uses are carefully marked using the | |||
`__extension__' keyword. But this is not generally available before | |||
version 2.8. */ | |||
#if !__GNUC_PREREQ (2,8) | |||
# define __extension__ /* Ignore */ | |||
#endif | |||
/* __restrict is known in EGCS 1.2 and above. */ | |||
#if !__GNUC_PREREQ (2,92) | |||
# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L | |||
# define __restrict restrict | |||
# else | |||
# define __restrict /* Ignore */ | |||
# endif | |||
#endif | |||
/* ISO C99 also allows to declare arrays as non-overlapping. The syntax is | |||
array_name[restrict] | |||
GCC 3.1 supports this. */ | |||
#if __GNUC_PREREQ (3,1) && !defined __GNUG__ | |||
# define __restrict_arr __restrict | |||
#else | |||
# ifdef __GNUC__ | |||
# define __restrict_arr /* Not supported in old GCC. */ | |||
# else | |||
# if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L | |||
# define __restrict_arr restrict | |||
# else | |||
/* Some other non-C99 compiler. */ | |||
# define __restrict_arr /* Not supported. */ | |||
# endif | |||
# endif | |||
#endif | |||
#if __GNUC__ >= 3 | |||
# define __glibc_unlikely(cond) __builtin_expect ((cond), 0) | |||
# define __glibc_likely(cond) __builtin_expect ((cond), 1) | |||
#else | |||
# define __glibc_unlikely(cond) (cond) | |||
# define __glibc_likely(cond) (cond) | |||
#endif | |||
#ifdef __has_attribute | |||
# define __glibc_has_attribute(attr) __has_attribute (attr) | |||
#else | |||
# define __glibc_has_attribute(attr) 0 | |||
#endif | |||
#if (!defined _Noreturn \ | |||
&& (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ | |||
&& !__GNUC_PREREQ (4,7)) | |||
# if __GNUC_PREREQ (2,8) | |||
# define _Noreturn __attribute__ ((__noreturn__)) | |||
# else | |||
# define _Noreturn | |||
# endif | |||
#endif | |||
#if __GNUC_PREREQ (8, 0) | |||
/* Describes a char array whose address can safely be passed as the first | |||
argument to strncpy and strncat, as the char array is not necessarily | |||
a NUL-terminated string. */ | |||
# define __attribute_nonstring__ __attribute__ ((__nonstring__)) | |||
#else | |||
# define __attribute_nonstring__ | |||
#endif | |||
/* Undefine (also defined in libc-symbols.h). */ | |||
#undef __attribute_copy__ | |||
#if __GNUC_PREREQ (9, 0) | |||
/* Copies attributes from the declaration or type referenced by | |||
the argument. */ | |||
# define __attribute_copy__(arg) __attribute__ ((__copy__ (arg))) | |||
#else | |||
# define __attribute_copy__(arg) | |||
#endif | |||
#if (!defined _Static_assert && !defined __cplusplus \ | |||
&& (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ | |||
&& (!__GNUC_PREREQ (4, 6) || defined __STRICT_ANSI__)) | |||
# define _Static_assert(expr, diagnostic) \ | |||
extern int (*__Static_assert_function (void)) \ | |||
[!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })] | |||
#endif | |||
#include <bits/wordsize.h> | |||
#include <bits/long-double.h> | |||
#if __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 | |||
# ifdef __REDIRECT | |||
/* Alias name defined automatically. */ | |||
# define __LDBL_REDIR(name, proto) ... unused__ldbl_redir | |||
# define __LDBL_REDIR_DECL(name) \ | |||
extern __typeof (name) name __asm (__ASMNAME ("__" #name "ieee128")); | |||
/* Alias name defined automatically, with leading underscores. */ | |||
# define __LDBL_REDIR2_DECL(name) \ | |||
extern __typeof (__##name) __##name \ | |||
__asm (__ASMNAME ("__" #name "ieee128")); | |||
/* Alias name defined manually. */ | |||
# define __LDBL_REDIR1(name, proto, alias) ... unused__ldbl_redir1 | |||
# define __LDBL_REDIR1_DECL(name, alias) \ | |||
extern __typeof (name) name __asm (__ASMNAME (#alias)); | |||
# define __LDBL_REDIR1_NTH(name, proto, alias) \ | |||
__REDIRECT_NTH (name, proto, alias) | |||
# define __REDIRECT_NTH_LDBL(name, proto, alias) \ | |||
__LDBL_REDIR1_NTH (name, proto, __##alias##ieee128) | |||
/* Unused. */ | |||
# define __REDIRECT_LDBL(name, proto, alias) ... unused__redirect_ldbl | |||
# define __LDBL_REDIR_NTH(name, proto) ... unused__ldbl_redir_nth | |||
# else | |||
_Static_assert (0, "IEEE 128-bits long double requires redirection on this platform"); | |||
# endif | |||
#elif defined __LONG_DOUBLE_MATH_OPTIONAL && defined __NO_LONG_DOUBLE_MATH | |||
# define __LDBL_COMPAT 1 | |||
# ifdef __REDIRECT | |||
# define __LDBL_REDIR1(name, proto, alias) __REDIRECT (name, proto, alias) | |||
# define __LDBL_REDIR(name, proto) \ | |||
__LDBL_REDIR1 (name, proto, __nldbl_##name) | |||
# define __LDBL_REDIR1_NTH(name, proto, alias) __REDIRECT_NTH (name, proto, alias) | |||
# define __LDBL_REDIR_NTH(name, proto) \ | |||
__LDBL_REDIR1_NTH (name, proto, __nldbl_##name) | |||
# define __LDBL_REDIR2_DECL(name) \ | |||
extern __typeof (__##name) __##name __asm (__ASMNAME ("__nldbl___" #name)); | |||
# define __LDBL_REDIR1_DECL(name, alias) \ | |||
extern __typeof (name) name __asm (__ASMNAME (#alias)); | |||
# define __LDBL_REDIR_DECL(name) \ | |||
extern __typeof (name) name __asm (__ASMNAME ("__nldbl_" #name)); | |||
# define __REDIRECT_LDBL(name, proto, alias) \ | |||
__LDBL_REDIR1 (name, proto, __nldbl_##alias) | |||
# define __REDIRECT_NTH_LDBL(name, proto, alias) \ | |||
__LDBL_REDIR1_NTH (name, proto, __nldbl_##alias) | |||
# endif | |||
#endif | |||
#if (!defined __LDBL_COMPAT && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0) \ | |||
|| !defined __REDIRECT | |||
# define __LDBL_REDIR1(name, proto, alias) name proto | |||
# define __LDBL_REDIR(name, proto) name proto | |||
# define __LDBL_REDIR1_NTH(name, proto, alias) name proto __THROW | |||
# define __LDBL_REDIR_NTH(name, proto) name proto __THROW | |||
# define __LDBL_REDIR2_DECL(name) | |||
# define __LDBL_REDIR_DECL(name) | |||
# ifdef __REDIRECT | |||
# define __REDIRECT_LDBL(name, proto, alias) __REDIRECT (name, proto, alias) | |||
# define __REDIRECT_NTH_LDBL(name, proto, alias) \ | |||
__REDIRECT_NTH (name, proto, alias) | |||
# endif | |||
#endif | |||
/* __glibc_macro_warning (MESSAGE) issues warning MESSAGE. This is | |||
intended for use in preprocessor macros. | |||
Note: MESSAGE must be a _single_ string; concatenation of string | |||
literals is not supported. */ | |||
#if __GNUC_PREREQ (4,8) || __glibc_clang_prereq (3,5) | |||
# define __glibc_macro_warning1(message) _Pragma (#message) | |||
# define __glibc_macro_warning(message) \ | |||
__glibc_macro_warning1 (GCC warning message) | |||
#else | |||
# define __glibc_macro_warning(msg) | |||
#endif | |||
/* Generic selection (ISO C11) is a C-only feature, available in GCC | |||
since version 4.9. Previous versions do not provide generic | |||
selection, even though they might set __STDC_VERSION__ to 201112L, | |||
when in -std=c11 mode. Thus, we must check for !defined __GNUC__ | |||
when testing __STDC_VERSION__ for generic selection support. | |||
On the other hand, Clang also defines __GNUC__, so a clang-specific | |||
check is required to enable the use of generic selection. */ | |||
#if !defined __cplusplus \ | |||
&& (__GNUC_PREREQ (4, 9) \ | |||
|| __glibc_clang_has_extension (c_generic_selections) \ | |||
|| (!defined __GNUC__ && defined __STDC_VERSION__ \ | |||
&& __STDC_VERSION__ >= 201112L)) | |||
# define __HAVE_GENERIC_SELECTION 1 | |||
#else | |||
# define __HAVE_GENERIC_SELECTION 0 | |||
#endif | |||
#if __GNUC_PREREQ (10, 0) | |||
/* Designates a 1-based positional argument ref-index of pointer type | |||
that can be used to access size-index elements of the pointed-to | |||
array according to access mode, or at least one element when | |||
size-index is not provided: | |||
access (access-mode, <ref-index> [, <size-index>]) */ | |||
#define __attr_access(x) __attribute__ ((__access__ x)) | |||
#else | |||
# define __attr_access(x) | |||
#endif | |||
/* Specify that a function such as setjmp or vfork may return | |||
twice. */ | |||
#if __GNUC_PREREQ (4, 1) | |||
# define __attribute_returns_twice__ __attribute__ ((__returns_twice__)) | |||
#else | |||
# define __attribute_returns_twice__ /* Ignore. */ | |||
#endif | |||
#endif /* sys/cdefs.h */ |
@ -1,128 +0,0 @@ | |||
/* `fd_set' type and related macros, and `select'/`pselect' declarations. | |||
Copyright (C) 1996-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
/* POSIX 1003.1g: 6.2 Select from File Descriptor Sets <sys/select.h> */ | |||
#ifndef _SYS_SELECT_H | |||
#define _SYS_SELECT_H 1 | |||
#include <features.h> | |||
/* Get definition of needed basic types. */ | |||
#include <bits/types.h> | |||
/* Get __FD_* definitions. */ | |||
#include <bits/select.h> | |||
/* Get sigset_t. */ | |||
#include <bits/types/sigset_t.h> | |||
/* Get definition of timer specification structures. */ | |||
#include <bits/types/time_t.h> | |||
#include <bits/types/struct_timeval.h> | |||
#ifdef __USE_XOPEN2K | |||
# include <bits/types/struct_timespec.h> | |||
#endif | |||
#ifndef __suseconds_t_defined | |||
typedef __suseconds_t suseconds_t; | |||
# define __suseconds_t_defined | |||
#endif | |||
/* The fd_set member is required to be an array of longs. */ | |||
typedef long int __fd_mask; | |||
/* Some versions of <linux/posix_types.h> define this macros. */ | |||
#undef __NFDBITS | |||
/* It's easier to assume 8-bit bytes than to get CHAR_BIT. */ | |||
#define __NFDBITS (8 * (int) sizeof (__fd_mask)) | |||
#define __FD_ELT(d) ((d) / __NFDBITS) | |||
#define __FD_MASK(d) ((__fd_mask) (1UL << ((d) % __NFDBITS))) | |||
/* fd_set for select and pselect. */ | |||
typedef struct | |||
{ | |||
/* XPG4.2 requires this member name. Otherwise avoid the name | |||
from the global namespace. */ | |||
#ifdef __USE_XOPEN | |||
__fd_mask fds_bits[__FD_SETSIZE / __NFDBITS]; | |||
# define __FDS_BITS(set) ((set)->fds_bits) | |||
#else | |||
__fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS]; | |||
# define __FDS_BITS(set) ((set)->__fds_bits) | |||
#endif | |||
} fd_set; | |||
/* Maximum number of file descriptors in `fd_set'. */ | |||
#define FD_SETSIZE __FD_SETSIZE | |||
#ifdef __USE_MISC | |||
/* Sometimes the fd_set member is assumed to have this type. */ | |||
typedef __fd_mask fd_mask; | |||
/* Number of bits per word of `fd_set' (some code assumes this is 32). */ | |||
# define NFDBITS __NFDBITS | |||
#endif | |||
/* Access macros for `fd_set'. */ | |||
#define FD_SET(fd, fdsetp) __FD_SET (fd, fdsetp) | |||
#define FD_CLR(fd, fdsetp) __FD_CLR (fd, fdsetp) | |||
#define FD_ISSET(fd, fdsetp) __FD_ISSET (fd, fdsetp) | |||
#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp) | |||
__BEGIN_DECLS | |||
/* Check the first NFDS descriptors each in READFDS (if not NULL) for read | |||
readiness, in WRITEFDS (if not NULL) for write readiness, and in EXCEPTFDS | |||
(if not NULL) for exceptional conditions. If TIMEOUT is not NULL, time out | |||
after waiting the interval specified therein. Returns the number of ready | |||
descriptors, or -1 for errors. | |||
This function is a cancellation point and therefore not marked with | |||
__THROW. */ | |||
extern int select (int __nfds, fd_set *__restrict __readfds, | |||
fd_set *__restrict __writefds, | |||
fd_set *__restrict __exceptfds, | |||
struct timeval *__restrict __timeout); | |||
#ifdef __USE_XOPEN2K | |||
/* Same as above only that the TIMEOUT value is given with higher | |||
resolution and a sigmask which is been set temporarily. This version | |||
should be used. | |||
This function is a cancellation point and therefore not marked with | |||
__THROW. */ | |||
extern int pselect (int __nfds, fd_set *__restrict __readfds, | |||
fd_set *__restrict __writefds, | |||
fd_set *__restrict __exceptfds, | |||
const struct timespec *__restrict __timeout, | |||
const __sigset_t *__restrict __sigmask); | |||
#endif | |||
/* Define some inlines helping to catch common problems. */ | |||
#if __USE_FORTIFY_LEVEL > 0 && defined __GNUC__ | |||
# include <bits/select2.h> | |||
#endif | |||
__END_DECLS | |||
#endif /* sys/select.h */ |
@ -1,232 +0,0 @@ | |||
/* Copyright (C) 1991-2021 Free Software Foundation, Inc. | |||
This file is part of the GNU C Library. | |||
The GNU C Library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
The GNU C Library is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General Public | |||
License along with the GNU C Library; if not, see | |||
<https://www.gnu.org/licenses/>. */ | |||
/* | |||
* POSIX Standard: 2.6 Primitive System Data Types <sys/types.h> | |||
*/ | |||
#ifndef _SYS_TYPES_H | |||
#define _SYS_TYPES_H 1 | |||
#include <features.h> | |||
__BEGIN_DECLS | |||
#include <bits/types.h> | |||
#ifdef __USE_MISC | |||
# ifndef __u_char_defined | |||
typedef __u_char u_char; | |||
typedef __u_short u_short; | |||
typedef __u_int u_int; | |||
typedef __u_long u_long; | |||
typedef __quad_t quad_t; | |||
typedef __u_quad_t u_quad_t; | |||
typedef __fsid_t fsid_t; | |||
# define __u_char_defined | |||
# endif | |||
typedef __loff_t loff_t; | |||
#endif | |||
#ifndef __ino_t_defined | |||
# ifndef __USE_FILE_OFFSET64 | |||
typedef __ino_t ino_t; | |||
# else | |||
typedef __ino64_t ino_t; | |||
# endif | |||
# define __ino_t_defined | |||
#endif | |||
#if defined __USE_LARGEFILE64 && !defined __ino64_t_defined | |||
typedef __ino64_t ino64_t; | |||
# define __ino64_t_defined | |||
#endif | |||
#ifndef __dev_t_defined | |||
typedef __dev_t dev_t; | |||
# define __dev_t_defined | |||
#endif | |||
#ifndef __gid_t_defined | |||
typedef __gid_t gid_t; | |||
# define __gid_t_defined | |||
#endif | |||
#ifndef __mode_t_defined | |||
typedef __mode_t mode_t; | |||
# define __mode_t_defined | |||
#endif | |||
#ifndef __nlink_t_defined | |||
typedef __nlink_t nlink_t; | |||
# define __nlink_t_defined | |||
#endif | |||
#ifndef __uid_t_defined | |||
typedef __uid_t uid_t; | |||
# define __uid_t_defined | |||
#endif | |||
#ifndef __off_t_defined | |||
# ifndef __USE_FILE_OFFSET64 | |||
typedef __off_t off_t; | |||
# else | |||
typedef __off64_t off_t; | |||
# endif | |||
# define __off_t_defined | |||
#endif | |||
#if defined __USE_LARGEFILE64 && !defined __off64_t_defined | |||
typedef __off64_t off64_t; | |||
# define __off64_t_defined | |||
#endif | |||
#ifndef __pid_t_defined | |||
typedef __pid_t pid_t; | |||
# define __pid_t_defined | |||
#endif | |||
#if (defined __USE_XOPEN || defined __USE_XOPEN2K8) \ | |||
&& !defined __id_t_defined | |||
typedef __id_t id_t; | |||
# define __id_t_defined | |||
#endif | |||
#ifndef __ssize_t_defined | |||
typedef __ssize_t ssize_t; | |||
# define __ssize_t_defined | |||
#endif | |||
#ifdef __USE_MISC | |||
# ifndef __daddr_t_defined | |||
typedef __daddr_t daddr_t; | |||
typedef __caddr_t caddr_t; | |||
# define __daddr_t_defined | |||
# endif | |||
#endif | |||
#if (defined __USE_MISC || defined __USE_XOPEN) && !defined __key_t_defined | |||
typedef __key_t key_t; | |||
# define __key_t_defined | |||
#endif | |||
#if defined __USE_XOPEN || defined __USE_XOPEN2K8 | |||
# include <bits/types/clock_t.h> | |||
#endif | |||
#include <bits/types/clockid_t.h> | |||
#include <bits/types/time_t.h> | |||
#include <bits/types/timer_t.h> | |||
#ifdef __USE_XOPEN | |||
# ifndef __useconds_t_defined | |||
typedef __useconds_t useconds_t; | |||
# define __useconds_t_defined | |||
# endif | |||
# ifndef __suseconds_t_defined | |||
typedef __suseconds_t suseconds_t; | |||
# define __suseconds_t_defined | |||
# endif | |||
#endif | |||
#define __need_size_t | |||
#include <stddef.h> | |||
#ifdef __USE_MISC | |||
/* Old compatibility names for C types. */ | |||
typedef unsigned long int ulong; | |||
typedef unsigned short int ushort; | |||
typedef unsigned int uint; | |||
#endif | |||
/* These size-specific names are used by some of the inet code. */ | |||
#include <bits/stdint-intn.h> | |||
/* These were defined by ISO C without the first `_'. */ | |||
typedef __uint8_t u_int8_t; | |||
typedef __uint16_t u_int16_t; | |||
typedef __uint32_t u_int32_t; | |||
typedef __uint64_t u_int64_t; | |||
#if __GNUC_PREREQ (2, 7) | |||
typedef int register_t __attribute__ ((__mode__ (__word__))); | |||
#else | |||
typedef int register_t; | |||
#endif | |||
/* Some code from BIND tests this macro to see if the types above are | |||
defined. */ | |||
#define __BIT_TYPES_DEFINED__ 1 | |||
#ifdef __USE_MISC | |||
/* In BSD <sys/types.h> is expected to define BYTE_ORDER. */ | |||
# include <endian.h> | |||
/* It also defines `fd_set' and the FD_* macros for `select'. */ | |||
# include <sys/select.h> | |||
#endif /* Use misc. */ | |||
#if (defined __USE_UNIX98 || defined __USE_XOPEN2K8) \ | |||
&& !defined __blksize_t_defined | |||
typedef __blksize_t blksize_t; | |||
# define __blksize_t_defined | |||
#endif | |||
/* Types from the Large File Support interface. */ | |||
#ifndef __USE_FILE_OFFSET64 | |||
# ifndef __blkcnt_t_defined | |||
typedef __blkcnt_t blkcnt_t; /* Type to count number of disk blocks. */ | |||
# define __blkcnt_t_defined | |||
# endif | |||
# ifndef __fsblkcnt_t_defined | |||
typedef __fsblkcnt_t fsblkcnt_t; /* Type to count file system blocks. */ | |||
# define __fsblkcnt_t_defined | |||
# endif | |||
# ifndef __fsfilcnt_t_defined | |||
typedef __fsfilcnt_t fsfilcnt_t; /* Type to count file system inodes. */ | |||
# define __fsfilcnt_t_defined | |||
# endif | |||
#else | |||
# ifndef __blkcnt_t_defined | |||
typedef __blkcnt64_t blkcnt_t; /* Type to count number of disk blocks. */ | |||
# define __blkcnt_t_defined | |||
# endif | |||
# ifndef __fsblkcnt_t_defined | |||
typedef __fsblkcnt64_t fsblkcnt_t; /* Type to count file system blocks. */ | |||
# define __fsblkcnt_t_defined | |||
# endif | |||
# ifndef __fsfilcnt_t_defined | |||
typedef __fsfilcnt64_t fsfilcnt_t; /* Type to count file system inodes. */ | |||
# define __fsfilcnt_t_defined | |||
# endif | |||
#endif | |||
#ifdef __USE_LARGEFILE64 | |||
typedef __blkcnt64_t blkcnt64_t; /* Type to count number of disk blocks. */ | |||
typedef __fsblkcnt64_t fsblkcnt64_t; /* Type to count file system blocks. */ | |||
typedef __fsfilcnt64_t fsfilcnt64_t; /* Type to count file system inodes. */ | |||
#endif | |||
/* Now add the thread types. */ | |||
#if defined __USE_POSIX199506 || defined __USE_UNIX98 | |||
# include <bits/pthreadtypes.h> | |||
#endif | |||
__END_DECLS | |||
#endif /* sys/types.h */ |
@ -1,121 +0,0 @@ | |||
/*===---- stddef.h - Basic type definitions --------------------------------=== | |||
* | |||
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
* See https://llvm.org/LICENSE.txt for license information. | |||
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
* | |||
*===-----------------------------------------------------------------------=== | |||
*/ | |||
#if !defined(__STDDEF_H) || defined(__need_ptrdiff_t) || \ | |||
defined(__need_size_t) || defined(__need_wchar_t) || \ | |||
defined(__need_NULL) || defined(__need_wint_t) | |||
#if !defined(__need_ptrdiff_t) && !defined(__need_size_t) && \ | |||
!defined(__need_wchar_t) && !defined(__need_NULL) && \ | |||
!defined(__need_wint_t) | |||
/* Always define miscellaneous pieces when modules are available. */ | |||
#if !__has_feature(modules) | |||
#define __STDDEF_H | |||
#endif | |||
#define __need_ptrdiff_t | |||
#define __need_size_t | |||
#define __need_wchar_t | |||
#define __need_NULL | |||
#define __need_STDDEF_H_misc | |||
/* __need_wint_t is intentionally not defined here. */ | |||
#endif | |||
#if defined(__need_ptrdiff_t) | |||
#if !defined(_PTRDIFF_T) || __has_feature(modules) | |||
/* Always define ptrdiff_t when modules are available. */ | |||
#if !__has_feature(modules) | |||
#define _PTRDIFF_T | |||
#endif | |||
typedef __PTRDIFF_TYPE__ ptrdiff_t; | |||
#endif | |||
#undef __need_ptrdiff_t | |||
#endif /* defined(__need_ptrdiff_t) */ | |||
#if defined(__need_size_t) | |||
#if !defined(_SIZE_T) || __has_feature(modules) | |||
/* Always define size_t when modules are available. */ | |||
#if !__has_feature(modules) | |||
#define _SIZE_T | |||
#endif | |||
typedef __SIZE_TYPE__ size_t; | |||
#endif | |||
#undef __need_size_t | |||
#endif /*defined(__need_size_t) */ | |||
#if defined(__need_STDDEF_H_misc) | |||
/* ISO9899:2011 7.20 (C11 Annex K): Define rsize_t if __STDC_WANT_LIB_EXT1__ is | |||
* enabled. */ | |||
#if (defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1 && \ | |||
!defined(_RSIZE_T)) || __has_feature(modules) | |||
/* Always define rsize_t when modules are available. */ | |||
#if !__has_feature(modules) | |||
#define _RSIZE_T | |||
#endif | |||
typedef __SIZE_TYPE__ rsize_t; | |||
#endif | |||
#endif /* defined(__need_STDDEF_H_misc) */ | |||
#if defined(__need_wchar_t) | |||
#ifndef __cplusplus | |||
/* Always define wchar_t when modules are available. */ | |||
#if !defined(_WCHAR_T) || __has_feature(modules) | |||
#if !__has_feature(modules) | |||
#define _WCHAR_T | |||
#if defined(_MSC_EXTENSIONS) | |||
#define _WCHAR_T_DEFINED | |||
#endif | |||
#endif | |||
typedef __WCHAR_TYPE__ wchar_t; | |||
#endif | |||
#endif | |||
#undef __need_wchar_t | |||
#endif /* defined(__need_wchar_t) */ | |||
#if defined(__need_NULL) | |||
#undef NULL | |||
#ifdef __cplusplus | |||
# if !defined(__MINGW32__) && !defined(_MSC_VER) | |||
# define NULL __null | |||
# else | |||
# define NULL 0 | |||
# endif | |||
#else | |||
# define NULL ((void*)0) | |||
#endif | |||
#ifdef __cplusplus | |||
#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED) | |||
namespace std { typedef decltype(nullptr) nullptr_t; } | |||
using ::std::nullptr_t; | |||
#endif | |||
#endif | |||
#undef __need_NULL | |||
#endif /* defined(__need_NULL) */ | |||
#if defined(__need_STDDEF_H_misc) | |||
#if __STDC_VERSION__ >= 201112L || __cplusplus >= 201103L | |||
#include "__stddef_max_align_t.h" | |||
#endif | |||
#define offsetof(t, d) __builtin_offsetof(t, d) | |||
#undef __need_STDDEF_H_misc | |||
#endif /* defined(__need_STDDEF_H_misc) */ | |||
/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use | |||
__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */ | |||
#if defined(__need_wint_t) | |||
/* Always define wint_t when modules are available. */ | |||
#if !defined(_WINT_T) || __has_feature(modules) | |||
#if !__has_feature(modules) | |||
#define _WINT_T | |||
#endif | |||
typedef __WINT_TYPE__ wint_t; | |||
#endif | |||
#undef __need_wint_t | |||
#endif /* __need_wint_t */ | |||
#endif |
@ -1,693 +0,0 @@ | |||
/*===---- stdint.h - Standard header for sized integer types --------------===*\ | |||
* | |||
* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
* See https://llvm.org/LICENSE.txt for license information. | |||
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
* | |||
\*===----------------------------------------------------------------------===*/ | |||
#ifndef __CLANG_STDINT_H | |||
// AIX system headers need stdint.h to be re-enterable while _STD_TYPES_T | |||
// is defined until an inclusion of it without _STD_TYPES_T occurs, in which | |||
// case the header guard macro is defined. | |||
#if !defined(_AIX) || !defined(_STD_TYPES_T) || !defined(__STDC_HOSTED__) | |||
#define __CLANG_STDINT_H | |||
#endif | |||
/* If we're hosted, fall back to the system's stdint.h, which might have | |||
* additional definitions. | |||
*/ | |||
#if __STDC_HOSTED__ && __has_include_next(<stdint.h>) | |||
// C99 7.18.3 Limits of other integer types | |||
// | |||
// Footnote 219, 220: C++ implementations should define these macros only when | |||
// __STDC_LIMIT_MACROS is defined before <stdint.h> is included. | |||
// | |||
// Footnote 222: C++ implementations should define these macros only when | |||
// __STDC_CONSTANT_MACROS is defined before <stdint.h> is included. | |||
// | |||
// C++11 [cstdint.syn]p2: | |||
// | |||
// The macros defined by <cstdint> are provided unconditionally. In particular, | |||
// the symbols __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS (mentioned in | |||
// footnotes 219, 220, and 222 in the C standard) play no role in C++. | |||
// | |||
// C11 removed the problematic footnotes. | |||
// | |||
// Work around this inconsistency by always defining those macros in C++ mode, | |||
// so that a C library implementation which follows the C99 standard can be | |||
// used in C++. | |||
# ifdef __cplusplus | |||
# if !defined(__STDC_LIMIT_MACROS) | |||
# define __STDC_LIMIT_MACROS | |||
# define __STDC_LIMIT_MACROS_DEFINED_BY_CLANG | |||
# endif | |||
# if !defined(__STDC_CONSTANT_MACROS) | |||
# define __STDC_CONSTANT_MACROS | |||
# define __STDC_CONSTANT_MACROS_DEFINED_BY_CLANG | |||
# endif | |||
# endif | |||
# include_next <stdint.h> | |||
# ifdef __STDC_LIMIT_MACROS_DEFINED_BY_CLANG | |||
# undef __STDC_LIMIT_MACROS | |||
# undef __STDC_LIMIT_MACROS_DEFINED_BY_CLANG | |||
# endif | |||
# ifdef __STDC_CONSTANT_MACROS_DEFINED_BY_CLANG | |||
# undef __STDC_CONSTANT_MACROS | |||
# undef __STDC_CONSTANT_MACROS_DEFINED_BY_CLANG | |||
# endif | |||
#else | |||
/* C99 7.18.1.1 Exact-width integer types. | |||
* C99 7.18.1.2 Minimum-width integer types. | |||
* C99 7.18.1.3 Fastest minimum-width integer types. | |||
* | |||
* The standard requires that exact-width type be defined for 8-, 16-, 32-, and | |||
* 64-bit types if they are implemented. Other exact width types are optional. | |||
* This implementation defines an exact-width types for every integer width | |||
* that is represented in the standard integer types. | |||
* | |||
* The standard also requires minimum-width types be defined for 8-, 16-, 32-, | |||
* and 64-bit widths regardless of whether there are corresponding exact-width | |||
* types. | |||
* | |||
* To accommodate targets that are missing types that are exactly 8, 16, 32, or | |||
* 64 bits wide, this implementation takes an approach of cascading | |||
* redefinitions, redefining __int_leastN_t to successively smaller exact-width | |||
* types. It is therefore important that the types are defined in order of | |||
* descending widths. | |||
* | |||
* We currently assume that the minimum-width types and the fastest | |||
* minimum-width types are the same. This is allowed by the standard, but is | |||
* suboptimal. | |||
* | |||
* In violation of the standard, some targets do not implement a type that is | |||
* wide enough to represent all of the required widths (8-, 16-, 32-, 64-bit). | |||
* To accommodate these targets, a required minimum-width type is only | |||
* defined if there exists an exact-width type of equal or greater width. | |||
*/ | |||
#ifdef __INT64_TYPE__ | |||
# ifndef __int8_t_defined /* glibc sys/types.h also defines int64_t*/ | |||
typedef __INT64_TYPE__ int64_t; | |||
# endif /* __int8_t_defined */ | |||
typedef __UINT64_TYPE__ uint64_t; | |||
# define __int_least64_t int64_t | |||
# define __uint_least64_t uint64_t | |||
# define __int_least32_t int64_t | |||
# define __uint_least32_t uint64_t | |||
# define __int_least16_t int64_t | |||
# define __uint_least16_t uint64_t | |||
# define __int_least8_t int64_t | |||
# define __uint_least8_t uint64_t | |||
#endif /* __INT64_TYPE__ */ | |||
#ifdef __int_least64_t | |||
typedef __int_least64_t int_least64_t; | |||
typedef __uint_least64_t uint_least64_t; | |||
typedef __int_least64_t int_fast64_t; | |||
typedef __uint_least64_t uint_fast64_t; | |||
#endif /* __int_least64_t */ | |||
#ifdef __INT56_TYPE__ | |||
typedef __INT56_TYPE__ int56_t; | |||
typedef __UINT56_TYPE__ uint56_t; | |||
typedef int56_t int_least56_t; | |||
typedef uint56_t uint_least56_t; | |||
typedef int56_t int_fast56_t; | |||
typedef uint56_t uint_fast56_t; | |||
# define __int_least32_t int56_t | |||
# define __uint_least32_t uint56_t | |||
# define __int_least16_t int56_t | |||
# define __uint_least16_t uint56_t | |||
# define __int_least8_t int56_t | |||
# define __uint_least8_t uint56_t | |||
#endif /* __INT56_TYPE__ */ | |||
#ifdef __INT48_TYPE__ | |||
typedef __INT48_TYPE__ int48_t; | |||
typedef __UINT48_TYPE__ uint48_t; | |||
typedef int48_t int_least48_t; | |||
typedef uint48_t uint_least48_t; | |||
typedef int48_t int_fast48_t; | |||
typedef uint48_t uint_fast48_t; | |||
# define __int_least32_t int48_t | |||
# define __uint_least32_t uint48_t | |||
# define __int_least16_t int48_t | |||
# define __uint_least16_t uint48_t | |||
# define __int_least8_t int48_t | |||
# define __uint_least8_t uint48_t | |||
#endif /* __INT48_TYPE__ */ | |||
#ifdef __INT40_TYPE__ | |||
typedef __INT40_TYPE__ int40_t; | |||
typedef __UINT40_TYPE__ uint40_t; | |||
typedef int40_t int_least40_t; | |||
typedef uint40_t uint_least40_t; | |||
typedef int40_t int_fast40_t; | |||
typedef uint40_t uint_fast40_t; | |||
# define __int_least32_t int40_t | |||
# define __uint_least32_t uint40_t | |||
# define __int_least16_t int40_t | |||
# define __uint_least16_t uint40_t | |||
# define __int_least8_t int40_t | |||
# define __uint_least8_t uint40_t | |||
#endif /* __INT40_TYPE__ */ | |||
#ifdef __INT32_TYPE__ | |||
# ifndef __int8_t_defined /* glibc sys/types.h also defines int32_t*/ | |||
typedef __INT32_TYPE__ int32_t; | |||
# endif /* __int8_t_defined */ | |||
# ifndef __uint32_t_defined /* more glibc compatibility */ | |||
# define __uint32_t_defined | |||
typedef __UINT32_TYPE__ uint32_t; | |||
# endif /* __uint32_t_defined */ | |||
# define __int_least32_t int32_t | |||
# define __uint_least32_t uint32_t | |||
# define __int_least16_t int32_t | |||
# define __uint_least16_t uint32_t | |||
# define __int_least8_t int32_t | |||
# define __uint_least8_t uint32_t | |||
#endif /* __INT32_TYPE__ */ | |||
#ifdef __int_least32_t | |||
typedef __int_least32_t int_least32_t; | |||
typedef __uint_least32_t uint_least32_t; | |||
typedef __int_least32_t int_fast32_t; | |||
typedef __uint_least32_t uint_fast32_t; | |||
#endif /* __int_least32_t */ | |||
#ifdef __INT24_TYPE__ | |||
typedef __INT24_TYPE__ int24_t; | |||
typedef __UINT24_TYPE__ uint24_t; | |||
typedef int24_t int_least24_t; | |||
typedef uint24_t uint_least24_t; | |||
typedef int24_t int_fast24_t; | |||
typedef uint24_t uint_fast24_t; | |||
# define __int_least16_t int24_t | |||
# define __uint_least16_t uint24_t | |||
# define __int_least8_t int24_t | |||
# define __uint_least8_t uint24_t | |||
#endif /* __INT24_TYPE__ */ | |||
#ifdef __INT16_TYPE__ | |||
#ifndef __int8_t_defined /* glibc sys/types.h also defines int16_t*/ | |||
typedef __INT16_TYPE__ int16_t; | |||
#endif /* __int8_t_defined */ | |||
typedef __UINT16_TYPE__ uint16_t; | |||
# define __int_least16_t int16_t | |||
# define __uint_least16_t uint16_t | |||
# define __int_least8_t int16_t | |||
# define __uint_least8_t uint16_t | |||
#endif /* __INT16_TYPE__ */ | |||
#ifdef __int_least16_t | |||
typedef __int_least16_t int_least16_t; | |||
typedef __uint_least16_t uint_least16_t; | |||
typedef __int_least16_t int_fast16_t; | |||
typedef __uint_least16_t uint_fast16_t; | |||
#endif /* __int_least16_t */ | |||
#ifdef __INT8_TYPE__ | |||
#ifndef __int8_t_defined /* glibc sys/types.h also defines int8_t*/ | |||
typedef __INT8_TYPE__ int8_t; | |||
#endif /* __int8_t_defined */ | |||
typedef __UINT8_TYPE__ uint8_t; | |||
# define __int_least8_t int8_t | |||
# define __uint_least8_t uint8_t | |||
#endif /* __INT8_TYPE__ */ | |||
#ifdef __int_least8_t | |||
typedef __int_least8_t int_least8_t; | |||
typedef __uint_least8_t uint_least8_t; | |||
typedef __int_least8_t int_fast8_t; | |||
typedef __uint_least8_t uint_fast8_t; | |||
#endif /* __int_least8_t */ | |||
/* prevent glibc sys/types.h from defining conflicting types */ | |||
#ifndef __int8_t_defined | |||
# define __int8_t_defined | |||
#endif /* __int8_t_defined */ | |||
/* C99 7.18.1.4 Integer types capable of holding object pointers. | |||
*/ | |||
#define __stdint_join3(a,b,c) a ## b ## c | |||
#ifndef _INTPTR_T | |||
#ifndef __intptr_t_defined | |||
typedef __INTPTR_TYPE__ intptr_t; | |||
#define __intptr_t_defined | |||
#define _INTPTR_T | |||
#endif | |||
#endif | |||
#ifndef _UINTPTR_T | |||
typedef __UINTPTR_TYPE__ uintptr_t; | |||
#define _UINTPTR_T | |||
#endif | |||
/* C99 7.18.1.5 Greatest-width integer types. | |||
*/ | |||
typedef __INTMAX_TYPE__ intmax_t; | |||
typedef __UINTMAX_TYPE__ uintmax_t; | |||
/* C99 7.18.4 Macros for minimum-width integer constants. | |||
* | |||
* The standard requires that integer constant macros be defined for all the | |||
* minimum-width types defined above. As 8-, 16-, 32-, and 64-bit minimum-width | |||
* types are required, the corresponding integer constant macros are defined | |||
* here. This implementation also defines minimum-width types for every other | |||
* integer width that the target implements, so corresponding macros are | |||
* defined below, too. | |||
* | |||
* These macros are defined using the same successive-shrinking approach as | |||
* the type definitions above. It is likewise important that macros are defined | |||
* in order of decending width. | |||
* | |||
* Note that C++ should not check __STDC_CONSTANT_MACROS here, contrary to the | |||
* claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]). | |||
*/ | |||
#define __int_c_join(a, b) a ## b | |||
#define __int_c(v, suffix) __int_c_join(v, suffix) | |||
#define __uint_c(v, suffix) __int_c_join(v##U, suffix) | |||
#ifdef __INT64_TYPE__ | |||
# ifdef __INT64_C_SUFFIX__ | |||
# define __int64_c_suffix __INT64_C_SUFFIX__ | |||
# define __int32_c_suffix __INT64_C_SUFFIX__ | |||
# define __int16_c_suffix __INT64_C_SUFFIX__ | |||
# define __int8_c_suffix __INT64_C_SUFFIX__ | |||
# else | |||
# undef __int64_c_suffix | |||
# undef __int32_c_suffix | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT64_C_SUFFIX__ */ | |||
#endif /* __INT64_TYPE__ */ | |||
#ifdef __int_least64_t | |||
# ifdef __int64_c_suffix | |||
# define INT64_C(v) __int_c(v, __int64_c_suffix) | |||
# define UINT64_C(v) __uint_c(v, __int64_c_suffix) | |||
# else | |||
# define INT64_C(v) v | |||
# define UINT64_C(v) v ## U | |||
# endif /* __int64_c_suffix */ | |||
#endif /* __int_least64_t */ | |||
#ifdef __INT56_TYPE__ | |||
# ifdef __INT56_C_SUFFIX__ | |||
# define INT56_C(v) __int_c(v, __INT56_C_SUFFIX__) | |||
# define UINT56_C(v) __uint_c(v, __INT56_C_SUFFIX__) | |||
# define __int32_c_suffix __INT56_C_SUFFIX__ | |||
# define __int16_c_suffix __INT56_C_SUFFIX__ | |||
# define __int8_c_suffix __INT56_C_SUFFIX__ | |||
# else | |||
# define INT56_C(v) v | |||
# define UINT56_C(v) v ## U | |||
# undef __int32_c_suffix | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT56_C_SUFFIX__ */ | |||
#endif /* __INT56_TYPE__ */ | |||
#ifdef __INT48_TYPE__ | |||
# ifdef __INT48_C_SUFFIX__ | |||
# define INT48_C(v) __int_c(v, __INT48_C_SUFFIX__) | |||
# define UINT48_C(v) __uint_c(v, __INT48_C_SUFFIX__) | |||
# define __int32_c_suffix __INT48_C_SUFFIX__ | |||
# define __int16_c_suffix __INT48_C_SUFFIX__ | |||
# define __int8_c_suffix __INT48_C_SUFFIX__ | |||
# else | |||
# define INT48_C(v) v | |||
# define UINT48_C(v) v ## U | |||
# undef __int32_c_suffix | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT48_C_SUFFIX__ */ | |||
#endif /* __INT48_TYPE__ */ | |||
#ifdef __INT40_TYPE__ | |||
# ifdef __INT40_C_SUFFIX__ | |||
# define INT40_C(v) __int_c(v, __INT40_C_SUFFIX__) | |||
# define UINT40_C(v) __uint_c(v, __INT40_C_SUFFIX__) | |||
# define __int32_c_suffix __INT40_C_SUFFIX__ | |||
# define __int16_c_suffix __INT40_C_SUFFIX__ | |||
# define __int8_c_suffix __INT40_C_SUFFIX__ | |||
# else | |||
# define INT40_C(v) v | |||
# define UINT40_C(v) v ## U | |||
# undef __int32_c_suffix | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT40_C_SUFFIX__ */ | |||
#endif /* __INT40_TYPE__ */ | |||
#ifdef __INT32_TYPE__ | |||
# ifdef __INT32_C_SUFFIX__ | |||
# define __int32_c_suffix __INT32_C_SUFFIX__ | |||
# define __int16_c_suffix __INT32_C_SUFFIX__ | |||
# define __int8_c_suffix __INT32_C_SUFFIX__ | |||
#else | |||
# undef __int32_c_suffix | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT32_C_SUFFIX__ */ | |||
#endif /* __INT32_TYPE__ */ | |||
#ifdef __int_least32_t | |||
# ifdef __int32_c_suffix | |||
# define INT32_C(v) __int_c(v, __int32_c_suffix) | |||
# define UINT32_C(v) __uint_c(v, __int32_c_suffix) | |||
# else | |||
# define INT32_C(v) v | |||
# define UINT32_C(v) v ## U | |||
# endif /* __int32_c_suffix */ | |||
#endif /* __int_least32_t */ | |||
#ifdef __INT24_TYPE__ | |||
# ifdef __INT24_C_SUFFIX__ | |||
# define INT24_C(v) __int_c(v, __INT24_C_SUFFIX__) | |||
# define UINT24_C(v) __uint_c(v, __INT24_C_SUFFIX__) | |||
# define __int16_c_suffix __INT24_C_SUFFIX__ | |||
# define __int8_c_suffix __INT24_C_SUFFIX__ | |||
# else | |||
# define INT24_C(v) v | |||
# define UINT24_C(v) v ## U | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT24_C_SUFFIX__ */ | |||
#endif /* __INT24_TYPE__ */ | |||
#ifdef __INT16_TYPE__ | |||
# ifdef __INT16_C_SUFFIX__ | |||
# define __int16_c_suffix __INT16_C_SUFFIX__ | |||
# define __int8_c_suffix __INT16_C_SUFFIX__ | |||
#else | |||
# undef __int16_c_suffix | |||
# undef __int8_c_suffix | |||
# endif /* __INT16_C_SUFFIX__ */ | |||
#endif /* __INT16_TYPE__ */ | |||
#ifdef __int_least16_t | |||
# ifdef __int16_c_suffix | |||
# define INT16_C(v) __int_c(v, __int16_c_suffix) | |||
# define UINT16_C(v) __uint_c(v, __int16_c_suffix) | |||
# else | |||
# define INT16_C(v) v | |||
# define UINT16_C(v) v ## U | |||
# endif /* __int16_c_suffix */ | |||
#endif /* __int_least16_t */ | |||
#ifdef __INT8_TYPE__ | |||
# ifdef __INT8_C_SUFFIX__ | |||
# define __int8_c_suffix __INT8_C_SUFFIX__ | |||
#else | |||
# undef __int8_c_suffix | |||
# endif /* __INT8_C_SUFFIX__ */ | |||
#endif /* __INT8_TYPE__ */ | |||
#ifdef __int_least8_t | |||
# ifdef __int8_c_suffix | |||
# define INT8_C(v) __int_c(v, __int8_c_suffix) | |||
# define UINT8_C(v) __uint_c(v, __int8_c_suffix) | |||
# else | |||
# define INT8_C(v) v | |||
# define UINT8_C(v) v ## U | |||
# endif /* __int8_c_suffix */ | |||
#endif /* __int_least8_t */ | |||
/* C99 7.18.2.1 Limits of exact-width integer types. | |||
* C99 7.18.2.2 Limits of minimum-width integer types. | |||
* C99 7.18.2.3 Limits of fastest minimum-width integer types. | |||
* | |||
* The presence of limit macros are completely optional in C99. This | |||
* implementation defines limits for all of the types (exact- and | |||
* minimum-width) that it defines above, using the limits of the minimum-width | |||
* type for any types that do not have exact-width representations. | |||
* | |||
* As in the type definitions, this section takes an approach of | |||
* successive-shrinking to determine which limits to use for the standard (8, | |||
* 16, 32, 64) bit widths when they don't have exact representations. It is | |||
* therefore important that the definitions be kept in order of decending | |||
* widths. | |||
* | |||
* Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the | |||
* claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]). | |||
*/ | |||
#ifdef __INT64_TYPE__ | |||
# define INT64_MAX INT64_C( 9223372036854775807) | |||
# define INT64_MIN (-INT64_C( 9223372036854775807)-1) | |||
# define UINT64_MAX UINT64_C(18446744073709551615) | |||
# define __INT_LEAST64_MIN INT64_MIN | |||
# define __INT_LEAST64_MAX INT64_MAX | |||
# define __UINT_LEAST64_MAX UINT64_MAX | |||
# define __INT_LEAST32_MIN INT64_MIN | |||
# define __INT_LEAST32_MAX INT64_MAX | |||
# define __UINT_LEAST32_MAX UINT64_MAX | |||
# define __INT_LEAST16_MIN INT64_MIN | |||
# define __INT_LEAST16_MAX INT64_MAX | |||
# define __UINT_LEAST16_MAX UINT64_MAX | |||
# define __INT_LEAST8_MIN INT64_MIN | |||
# define __INT_LEAST8_MAX INT64_MAX | |||
# define __UINT_LEAST8_MAX UINT64_MAX | |||
#endif /* __INT64_TYPE__ */ | |||
#ifdef __INT_LEAST64_MIN | |||
# define INT_LEAST64_MIN __INT_LEAST64_MIN | |||
# define INT_LEAST64_MAX __INT_LEAST64_MAX | |||
# define UINT_LEAST64_MAX __UINT_LEAST64_MAX | |||
# define INT_FAST64_MIN __INT_LEAST64_MIN | |||
# define INT_FAST64_MAX __INT_LEAST64_MAX | |||
# define UINT_FAST64_MAX __UINT_LEAST64_MAX | |||
#endif /* __INT_LEAST64_MIN */ | |||
#ifdef __INT56_TYPE__ | |||
# define INT56_MAX INT56_C(36028797018963967) | |||
# define INT56_MIN (-INT56_C(36028797018963967)-1) | |||
# define UINT56_MAX UINT56_C(72057594037927935) | |||
# define INT_LEAST56_MIN INT56_MIN | |||
# define INT_LEAST56_MAX INT56_MAX | |||
# define UINT_LEAST56_MAX UINT56_MAX | |||
# define INT_FAST56_MIN INT56_MIN | |||
# define INT_FAST56_MAX INT56_MAX | |||
# define UINT_FAST56_MAX UINT56_MAX | |||
# define __INT_LEAST32_MIN INT56_MIN | |||
# define __INT_LEAST32_MAX INT56_MAX | |||
# define __UINT_LEAST32_MAX UINT56_MAX | |||
# define __INT_LEAST16_MIN INT56_MIN | |||
# define __INT_LEAST16_MAX INT56_MAX | |||
# define __UINT_LEAST16_MAX UINT56_MAX | |||
# define __INT_LEAST8_MIN INT56_MIN | |||
# define __INT_LEAST8_MAX INT56_MAX | |||
# define __UINT_LEAST8_MAX UINT56_MAX | |||
#endif /* __INT56_TYPE__ */ | |||
#ifdef __INT48_TYPE__ | |||
# define INT48_MAX INT48_C(140737488355327) | |||
# define INT48_MIN (-INT48_C(140737488355327)-1) | |||
# define UINT48_MAX UINT48_C(281474976710655) | |||
# define INT_LEAST48_MIN INT48_MIN | |||
# define INT_LEAST48_MAX INT48_MAX | |||
# define UINT_LEAST48_MAX UINT48_MAX | |||
# define INT_FAST48_MIN INT48_MIN | |||
# define INT_FAST48_MAX INT48_MAX | |||
# define UINT_FAST48_MAX UINT48_MAX | |||
# define __INT_LEAST32_MIN INT48_MIN | |||
# define __INT_LEAST32_MAX INT48_MAX | |||
# define __UINT_LEAST32_MAX UINT48_MAX | |||
# define __INT_LEAST16_MIN INT48_MIN | |||
# define __INT_LEAST16_MAX INT48_MAX | |||
# define __UINT_LEAST16_MAX UINT48_MAX | |||
# define __INT_LEAST8_MIN INT48_MIN | |||
# define __INT_LEAST8_MAX INT48_MAX | |||
# define __UINT_LEAST8_MAX UINT48_MAX | |||
#endif /* __INT48_TYPE__ */ | |||
#ifdef __INT40_TYPE__ | |||
# define INT40_MAX INT40_C(549755813887) | |||
# define INT40_MIN (-INT40_C(549755813887)-1) | |||
# define UINT40_MAX UINT40_C(1099511627775) | |||
# define INT_LEAST40_MIN INT40_MIN | |||
# define INT_LEAST40_MAX INT40_MAX | |||
# define UINT_LEAST40_MAX UINT40_MAX | |||
# define INT_FAST40_MIN INT40_MIN | |||
# define INT_FAST40_MAX INT40_MAX | |||
# define UINT_FAST40_MAX UINT40_MAX | |||
# define __INT_LEAST32_MIN INT40_MIN | |||
# define __INT_LEAST32_MAX INT40_MAX | |||
# define __UINT_LEAST32_MAX UINT40_MAX | |||
# define __INT_LEAST16_MIN INT40_MIN | |||
# define __INT_LEAST16_MAX INT40_MAX | |||
# define __UINT_LEAST16_MAX UINT40_MAX | |||
# define __INT_LEAST8_MIN INT40_MIN | |||
# define __INT_LEAST8_MAX INT40_MAX | |||
# define __UINT_LEAST8_MAX UINT40_MAX | |||
#endif /* __INT40_TYPE__ */ | |||
#ifdef __INT32_TYPE__ | |||
# define INT32_MAX INT32_C(2147483647) | |||
# define INT32_MIN (-INT32_C(2147483647)-1) | |||
# define UINT32_MAX UINT32_C(4294967295) | |||
# define __INT_LEAST32_MIN INT32_MIN | |||
# define __INT_LEAST32_MAX INT32_MAX | |||
# define __UINT_LEAST32_MAX UINT32_MAX | |||
# define __INT_LEAST16_MIN INT32_MIN | |||
# define __INT_LEAST16_MAX INT32_MAX | |||
# define __UINT_LEAST16_MAX UINT32_MAX | |||
# define __INT_LEAST8_MIN INT32_MIN | |||
# define __INT_LEAST8_MAX INT32_MAX | |||
# define __UINT_LEAST8_MAX UINT32_MAX | |||
#endif /* __INT32_TYPE__ */ | |||
#ifdef __INT_LEAST32_MIN | |||
# define INT_LEAST32_MIN __INT_LEAST32_MIN | |||
# define INT_LEAST32_MAX __INT_LEAST32_MAX | |||
# define UINT_LEAST32_MAX __UINT_LEAST32_MAX | |||
# define INT_FAST32_MIN __INT_LEAST32_MIN | |||
# define INT_FAST32_MAX __INT_LEAST32_MAX | |||
# define UINT_FAST32_MAX __UINT_LEAST32_MAX | |||
#endif /* __INT_LEAST32_MIN */ | |||
#ifdef __INT24_TYPE__ | |||
# define INT24_MAX INT24_C(8388607) | |||
# define INT24_MIN (-INT24_C(8388607)-1) | |||
# define UINT24_MAX UINT24_C(16777215) | |||
# define INT_LEAST24_MIN INT24_MIN | |||
# define INT_LEAST24_MAX INT24_MAX | |||
# define UINT_LEAST24_MAX UINT24_MAX | |||
# define INT_FAST24_MIN INT24_MIN | |||
# define INT_FAST24_MAX INT24_MAX | |||
# define UINT_FAST24_MAX UINT24_MAX | |||
# define __INT_LEAST16_MIN INT24_MIN | |||
# define __INT_LEAST16_MAX INT24_MAX | |||
# define __UINT_LEAST16_MAX UINT24_MAX | |||
# define __INT_LEAST8_MIN INT24_MIN | |||
# define __INT_LEAST8_MAX INT24_MAX | |||
# define __UINT_LEAST8_MAX UINT24_MAX | |||
#endif /* __INT24_TYPE__ */ | |||
#ifdef __INT16_TYPE__ | |||
#define INT16_MAX INT16_C(32767) | |||
#define INT16_MIN (-INT16_C(32767)-1) | |||
#define UINT16_MAX UINT16_C(65535) | |||
# define __INT_LEAST16_MIN INT16_MIN | |||
# define __INT_LEAST16_MAX INT16_MAX | |||
# define __UINT_LEAST16_MAX UINT16_MAX | |||
# define __INT_LEAST8_MIN INT16_MIN | |||
# define __INT_LEAST8_MAX INT16_MAX | |||
# define __UINT_LEAST8_MAX UINT16_MAX | |||
#endif /* __INT16_TYPE__ */ | |||
#ifdef __INT_LEAST16_MIN | |||
# define INT_LEAST16_MIN __INT_LEAST16_MIN | |||
# define INT_LEAST16_MAX __INT_LEAST16_MAX | |||
# define UINT_LEAST16_MAX __UINT_LEAST16_MAX | |||
# define INT_FAST16_MIN __INT_LEAST16_MIN | |||
# define INT_FAST16_MAX __INT_LEAST16_MAX | |||
# define UINT_FAST16_MAX __UINT_LEAST16_MAX | |||
#endif /* __INT_LEAST16_MIN */ | |||
#ifdef __INT8_TYPE__ | |||
# define INT8_MAX INT8_C(127) | |||
# define INT8_MIN (-INT8_C(127)-1) | |||
# define UINT8_MAX UINT8_C(255) | |||
# define __INT_LEAST8_MIN INT8_MIN | |||
# define __INT_LEAST8_MAX INT8_MAX | |||
# define __UINT_LEAST8_MAX UINT8_MAX | |||
#endif /* __INT8_TYPE__ */ | |||
#ifdef __INT_LEAST8_MIN | |||
# define INT_LEAST8_MIN __INT_LEAST8_MIN | |||
# define INT_LEAST8_MAX __INT_LEAST8_MAX | |||
# define UINT_LEAST8_MAX __UINT_LEAST8_MAX | |||
# define INT_FAST8_MIN __INT_LEAST8_MIN | |||
# define INT_FAST8_MAX __INT_LEAST8_MAX | |||
# define UINT_FAST8_MAX __UINT_LEAST8_MAX | |||
#endif /* __INT_LEAST8_MIN */ | |||
/* Some utility macros */ | |||
#define __INTN_MIN(n) __stdint_join3( INT, n, _MIN) | |||
#define __INTN_MAX(n) __stdint_join3( INT, n, _MAX) | |||
#define __UINTN_MAX(n) __stdint_join3(UINT, n, _MAX) | |||
#define __INTN_C(n, v) __stdint_join3( INT, n, _C(v)) | |||
#define __UINTN_C(n, v) __stdint_join3(UINT, n, _C(v)) | |||
/* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */ | |||
/* C99 7.18.3 Limits of other integer types. */ | |||
#define INTPTR_MIN (-__INTPTR_MAX__-1) | |||
#define INTPTR_MAX __INTPTR_MAX__ | |||
#define UINTPTR_MAX __UINTPTR_MAX__ | |||
#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1) | |||
#define PTRDIFF_MAX __PTRDIFF_MAX__ | |||
#define SIZE_MAX __SIZE_MAX__ | |||
/* ISO9899:2011 7.20 (C11 Annex K): Define RSIZE_MAX if __STDC_WANT_LIB_EXT1__ | |||
* is enabled. */ | |||
#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1 | |||
#define RSIZE_MAX (SIZE_MAX >> 1) | |||
#endif | |||
/* C99 7.18.2.5 Limits of greatest-width integer types. */ | |||
#define INTMAX_MIN (-__INTMAX_MAX__-1) | |||
#define INTMAX_MAX __INTMAX_MAX__ | |||
#define UINTMAX_MAX __UINTMAX_MAX__ | |||
/* C99 7.18.3 Limits of other integer types. */ | |||
#define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__) | |||
#define SIG_ATOMIC_MAX __INTN_MAX(__SIG_ATOMIC_WIDTH__) | |||
#ifdef __WINT_UNSIGNED__ | |||
# define WINT_MIN __UINTN_C(__WINT_WIDTH__, 0) | |||
# define WINT_MAX __UINTN_MAX(__WINT_WIDTH__) | |||
#else | |||
# define WINT_MIN __INTN_MIN(__WINT_WIDTH__) | |||
# define WINT_MAX __INTN_MAX(__WINT_WIDTH__) | |||
#endif | |||
#ifndef WCHAR_MAX | |||
# define WCHAR_MAX __WCHAR_MAX__ | |||
#endif | |||
#ifndef WCHAR_MIN | |||
# if __WCHAR_MAX__ == __INTN_MAX(__WCHAR_WIDTH__) | |||
# define WCHAR_MIN __INTN_MIN(__WCHAR_WIDTH__) | |||
# else | |||
# define WCHAR_MIN __UINTN_C(__WCHAR_WIDTH__, 0) | |||
# endif | |||
#endif | |||
/* 7.18.4.2 Macros for greatest-width integer constants. */ | |||
#define INTMAX_C(v) __int_c(v, __INTMAX_C_SUFFIX__) | |||
#define UINTMAX_C(v) __int_c(v, __UINTMAX_C_SUFFIX__) | |||
#endif /* __STDC_HOSTED__ */ | |||
#endif /* __CLANG_STDINT_H */ |
@ -1,505 +0,0 @@ | |||
/* See LICENSE file for copyright and license details. */ | |||
/* | |||
* appearance | |||
* | |||
* font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html | |||
*/ | |||
static char *font = "CaskaydiaCove Nerd Font Mono:pixelsize=16:antialias=true:autohint=true"; | |||
static char *font2[] = { | |||
"Symbola:pixelsize=16:antialias=true:autohint=true", | |||
}; | |||
char *iso14755_cmd = "cat /home/yigit/.local/share/nerdfont_icons | dmenu -w \"$WINDOWID\" -p \"Select icon\" -l 10 | cut -d\"(\" -f2 | cut -c 1-4"; | |||
static int borderpx = 2; | |||
/* | |||
* What program is execed by st depends of these precedence rules: | |||
* 1: program passed with -e | |||
* 2: scroll and/or utmp | |||
* 3: SHELL environment variable | |||
* 4: value of shell in /etc/passwd | |||
* 5: value of shell in config.h | |||
*/ | |||
static char *shell = "/bin/zsh"; | |||
char *utmp = NULL; | |||
/* scroll program: to enable use a string like "scroll" */ | |||
char *scroll = "scroll"; | |||
char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400"; | |||
float alpha = 1, alphaUnfocused = 0.9; | |||
/* identification sequence returned in DA and DECID */ | |||
char *vtiden = "\033[?6c"; | |||
/* Kerning / character bounding-box multipliers */ | |||
static float cwscale = 1.0; | |||
static float chscale = 1.0; | |||
/* | |||
* word delimiter string | |||
* | |||
* More advanced example: L" `'\"()[]{}" | |||
*/ | |||
wchar_t *worddelimiters = L" "; | |||
/* selection timeouts (in milliseconds) */ | |||
static unsigned int doubleclicktimeout = 300; | |||
static unsigned int tripleclicktimeout = 600; | |||
/* alt screens */ | |||
int allowaltscreen = 1; | |||
/* allow certain non-interactive (insecure) window operations such as: | |||
setting the clipboard text */ | |||
int allowwindowops = 0; | |||
/* | |||
* draw latency range in ms - from new content/keypress/etc until drawing. | |||
* within this range, st draws when content stops arriving (idle). mostly it's | |||
* near minlatency, but it waits longer for slow updates to avoid partial draw. | |||
* low minlatency will tear/flicker more, as it can "detect" idle too early. | |||
*/ | |||
static double minlatency = 8; | |||
static double maxlatency = 33; | |||
/* | |||
* blinking timeout (set to 0 to disable blinking) for the terminal blinking | |||
* attribute. | |||
*/ | |||
static unsigned int blinktimeout = 800; | |||
/* | |||
* thickness of underline and bar cursors | |||
*/ | |||
static unsigned int cursorthickness = 2; | |||
/* | |||
* bell volume. It must be a value between -100 and 100. Use 0 for disabling | |||
* it | |||
*/ | |||
static int bellvolume = 0; | |||
/* default TERM value */ | |||
char *termname = "st-256color"; | |||
/* | |||
* spaces per tab | |||
* | |||
* When you are changing this value, don't forget to adapt the »it« value in | |||
* the st.info and appropriately install the st.info in the environment where | |||
* you use this st version. | |||
* | |||
* it#$tabspaces, | |||
* | |||
* Secondly make sure your kernel is not expanding tabs. When running `stty | |||
* -a` »tab0« should appear. You can tell the terminal to not expand tabs by | |||
* running following command: | |||
* | |||
* stty tabs | |||
*/ | |||
unsigned int tabspaces = 8; | |||
static const char *colorname[] = { | |||
/* 8 normal colors */ | |||
[0] = "#3b4252", /* black */ | |||
[1] = "#bf616a", /* red */ | |||
[2] = "#a3be8c", /* green */ | |||
[3] = "#ebcb8b", /* yellow */ | |||
[4] = "#81a1c1", /* blue */ | |||
[5] = "#b48ead", /* magenta */ | |||
[6] = "#88c0d0", /* cyan */ | |||
[7] = "#e5e9f0", /* white */ | |||
/* 8 bright colors */ | |||
[8] = "#4c566a", /* black */ | |||
[9] = "#bf616a", /* red */ | |||
[10] = "#a3be8c", /* green */ | |||
[11] = "#ebcb8b", /* yellow */ | |||
[12] = "#81a1c1", /* blue */ | |||
[13] = "#b48ead", /* magenta */ | |||
[14] = "#8fbcbb", /* cyan */ | |||
[15] = "#eceff4", /* white */ | |||
/* special colors */ | |||
[256] = "#0f111a", /* background */ | |||
[257] = "#d8dee9", /* foreground */ | |||
/* More special colors */ | |||
}; | |||
/* | |||
* Default colors (colorname index) | |||
* foreground, background, cursor, reverse cursor | |||
*/ | |||
unsigned int defaultfg = 257; | |||
unsigned int defaultbg = 256; | |||
unsigned int bg = 256, bgUnfocused = 16; | |||
static unsigned int defaultcs = 257; | |||
static unsigned int defaultrcs = 256; | |||
static unsigned int defaultitalic = 7; | |||
static unsigned int defaultunderline = 7; | |||
/* | |||
* Default shape of cursor | |||
* 2: Block ("█") | |||
* 4: Underline ("_") | |||
* 6: Bar ("|") | |||
* 7: Snowman ("☃") | |||
*/ | |||
static unsigned int cursorshape = 2; | |||
/* | |||
* Default columns and rows numbers | |||
*/ | |||
static unsigned int cols = 80; | |||
static unsigned int rows = 24; | |||
/* | |||
* Default colour and shape of the mouse cursor | |||
*/ | |||
static unsigned int mouseshape = XC_xterm; | |||
static unsigned int mousefg = 7; | |||
static unsigned int mousebg = 0; | |||
/* | |||
* Color used to display font attributes when fontconfig selected a font which | |||
* doesn't match the ones requested. | |||
*/ | |||
static unsigned int defaultattr = 11; | |||
/* | |||
* Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set). | |||
* Note that if you want to use ShiftMask with selmasks, set this to an other | |||
* modifier, set to 0 to not use it. | |||
*/ | |||
static uint forcemousemod = ShiftMask; | |||
/* | |||
* Internal mouse shortcuts. | |||
* Beware that overloading Button1 will disable the selection. | |||
*/ | |||
static MouseShortcut mshortcuts[] = { | |||
/* mask button function argument release */ | |||
{ XK_ANY_MOD, Button2, selpaste, {.i = 0}, 1 }, | |||
{ ShiftMask, Button4, kscrollup, {.i = 5} }, | |||
{ ShiftMask, Button5, kscrolldown, {.i = 5} }, | |||
}; | |||
/* Internal keyboard shortcuts. */ | |||
#define MODKEY Mod1Mask | |||
#define TERMMOD (ControlMask|ShiftMask) | |||
#define ALTMOD (Mod1Mask|ShiftMask) | |||
static char *openurlcmd[] = { "/bin/sh", "-c", "/home/yigit/.local/bin/st-urlhandler -o", "externalpipe", NULL }; | |||
static char *copyurlcmd[] = { "/bin/sh", "-c", "/home/yigit/.local/bin/st-urlhandler -c", "externalpipe", NULL }; | |||
static char *copyoutput[] = { "/bin/sh", "-c", "/home/yigit/.local/bin/st-copyout", "externalpipe", NULL }; | |||
static unsigned int cursorstyle = 1; | |||
static Rune stcursor = 0x2603; /* snowman (U+2603) */ | |||
static Shortcut shortcuts[] = { | |||
/* mask keysym function argument */ | |||
{ XK_ANY_MOD, XK_Break, sendbreak, {.i = 0} }, | |||
{ ControlMask, XK_Print, toggleprinter, {.i = 0} }, | |||
{ ShiftMask, XK_Print, printscreen, {.i = 0} }, | |||
{ XK_ANY_MOD, XK_Print, printsel, {.i = 0} }, | |||
{ TERMMOD, XK_Prior, zoom, {.f = +1} }, | |||
{ TERMMOD, XK_Next, zoom, {.f = -1} }, | |||
{ TERMMOD, XK_Home, zoomreset, {.f = 0} }, | |||
{ TERMMOD, XK_C, clipcopy, {.i = 0} }, | |||
{ TERMMOD, XK_V, clippaste, {.i = 0} }, | |||
{ TERMMOD, XK_Y, selpaste, {.i = 0} }, | |||
{ ShiftMask, XK_Insert, selpaste, {.i = 0} }, | |||
{ TERMMOD, XK_Num_Lock, numlock, {.i = 0} }, | |||
{ TERMMOD, XK_I, iso14755, {.i = 0} }, | |||
{ ALTMOD, XK_Up, zoom, {.f = +1} }, | |||
{ ALTMOD, XK_Down, zoom, {.f = -1} }, | |||
{ ALTMOD, XK_K, zoom, {.f = +1} }, | |||
{ ALTMOD, XK_J, zoom, {.f = -1} }, | |||
{ ALTMOD, XK_U, zoom, {.f = +2} }, | |||
{ ALTMOD, XK_D, zoom, {.f = -2} }, | |||
{ MODKEY, XK_l, externalpipe, {.v = openurlcmd } }, | |||
{ MODKEY, XK_y, externalpipe, {.v = copyurlcmd } }, | |||
{ MODKEY, XK_o, externalpipe, {.v = copyoutput } }, | |||
{ MODKEY, XK_u, kscrollup, {.i = -1} }, | |||
{ MODKEY, XK_d, kscrolldown, {.i = -1} }, | |||
{ MODKEY, XK_k, kscrollup, {.i = 2} }, | |||
{ MODKEY, XK_j, kscrolldown, {.i = 2} }, | |||
{ MODKEY, XK_s, changealpha, {.f = -0.05} }, | |||
{ MODKEY, XK_a, changealpha, {.f = +0.05} }, | |||
}; | |||
/* | |||
* Special keys (change & recompile st.info accordingly) | |||
* | |||
* Mask value: | |||
* * Use XK_ANY_MOD to match the key no matter modifiers state | |||
* * Use XK_NO_MOD to match the key alone (no modifiers) | |||
* appkey value: | |||
* * 0: no value | |||
* * > 0: keypad application mode enabled | |||
* * = 2: term.numlock = 1 | |||
* * < 0: keypad application mode disabled | |||
* appcursor value: | |||
* * 0: no value | |||
* * > 0: cursor application mode enabled | |||
* * < 0: cursor application mode disabled | |||
* | |||
* Be careful with the order of the definitions because st searches in | |||
* this table sequentially, so any XK_ANY_MOD must be in the last | |||
* position for a key. | |||
*/ | |||
/* | |||
* If you want keys other than the X11 function keys (0xFD00 - 0xFFFF) | |||
* to be mapped below, add them to this array. | |||
*/ | |||
static KeySym mappedkeys[] = { -1 }; | |||
/* | |||
* State bits to ignore when matching key or button events. By default, | |||
* numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored. | |||
*/ | |||
static uint ignoremod = Mod2Mask|XK_SWITCH_MOD; | |||
/* | |||
* This is the huge key array which defines all compatibility to the Linux | |||
* world. Please decide about changes wisely. | |||
*/ | |||
static Key key[] = { | |||
/* keysym mask string appkey appcursor */ | |||
{ XK_KP_Home, ShiftMask, "\033[2J", 0, -1}, | |||
{ XK_KP_Home, ShiftMask, "\033[1;2H", 0, +1}, | |||
{ XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1}, | |||
{ XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1}, | |||
{ XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0}, | |||
{ XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1}, | |||
{ XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1}, | |||
{ XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0}, | |||
{ XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1}, | |||
{ XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1}, | |||
{ XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0}, | |||
{ XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1}, | |||
{ XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1}, | |||
{ XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0}, | |||
{ XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1}, | |||
{ XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1}, | |||
{ XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0}, | |||
{ XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, | |||
{ XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0}, | |||
{ XK_KP_End, ControlMask, "\033[J", -1, 0}, | |||
{ XK_KP_End, ControlMask, "\033[1;5F", +1, 0}, | |||
{ XK_KP_End, ShiftMask, "\033[K", -1, 0}, | |||
{ XK_KP_End, ShiftMask, "\033[1;2F", +1, 0}, | |||
{ XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0}, | |||
{ XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0}, | |||
{ XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0}, | |||
{ XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0}, | |||
{ XK_KP_Insert, ShiftMask, "\033[4l", -1, 0}, | |||
{ XK_KP_Insert, ControlMask, "\033[L", -1, 0}, | |||
{ XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0}, | |||
{ XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, | |||
{ XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, | |||
{ XK_KP_Delete, ControlMask, "\033[M", -1, 0}, | |||
{ XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0}, | |||
{ XK_KP_Delete, ShiftMask, "\033[2K", -1, 0}, | |||
{ XK_KP_Delete, ShiftMask, "\033[3;2~", +1, 0}, | |||
{ XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0}, | |||
{ XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, | |||
{ XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0}, | |||
{ XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0}, | |||
{ XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0}, | |||
{ XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0}, | |||
{ XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0}, | |||
{ XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0}, | |||
{ XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0}, | |||
{ XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0}, | |||
{ XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0}, | |||
{ XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0}, | |||
{ XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0}, | |||
{ XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0}, | |||
{ XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0}, | |||
{ XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0}, | |||
{ XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0}, | |||
{ XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0}, | |||
{ XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0}, | |||
{ XK_Up, ShiftMask, "\033[1;2A", 0, 0}, | |||
{ XK_Up, Mod1Mask, "\033[1;3A", 0, 0}, | |||
{ XK_Up, ShiftMask|Mod1Mask,"\033[1;4A", 0, 0}, | |||
{ XK_Up, ControlMask, "\033[1;5A", 0, 0}, | |||
{ XK_Up, ShiftMask|ControlMask,"\033[1;6A", 0, 0}, | |||
{ XK_Up, ControlMask|Mod1Mask,"\033[1;7A", 0, 0}, | |||
{ XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A", 0, 0}, | |||
{ XK_Up, XK_ANY_MOD, "\033[A", 0, -1}, | |||
{ XK_Up, XK_ANY_MOD, "\033OA", 0, +1}, | |||
{ XK_Down, ShiftMask, "\033[1;2B", 0, 0}, | |||
{ XK_Down, Mod1Mask, "\033[1;3B", 0, 0}, | |||
{ XK_Down, ShiftMask|Mod1Mask,"\033[1;4B", 0, 0}, | |||
{ XK_Down, ControlMask, "\033[1;5B", 0, 0}, | |||
{ XK_Down, ShiftMask|ControlMask,"\033[1;6B", 0, 0}, | |||
{ XK_Down, ControlMask|Mod1Mask,"\033[1;7B", 0, 0}, | |||
{ XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0, 0}, | |||
{ XK_Down, XK_ANY_MOD, "\033[B", 0, -1}, | |||
{ XK_Down, XK_ANY_MOD, "\033OB", 0, +1}, | |||
{ XK_Left, ShiftMask, "\033[1;2D", 0, 0}, | |||
{ XK_Left, Mod1Mask, "\033[1;3D", 0, 0}, | |||
{ XK_Left, ShiftMask|Mod1Mask,"\033[1;4D", 0, 0}, | |||
{ XK_Left, ControlMask, "\033[1;5D", 0, 0}, | |||
{ XK_Left, ShiftMask|ControlMask,"\033[1;6D", 0, 0}, | |||
{ XK_Left, ControlMask|Mod1Mask,"\033[1;7D", 0, 0}, | |||
{ XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0, 0}, | |||
{ XK_Left, XK_ANY_MOD, "\033[D", 0, -1}, | |||
{ XK_Left, XK_ANY_MOD, "\033OD", 0, +1}, | |||
{ XK_Right, ShiftMask, "\033[1;2C", 0, 0}, | |||
{ XK_Right, Mod1Mask, "\033[1;3C", 0, 0}, | |||
{ XK_Right, ShiftMask|Mod1Mask,"\033[1;4C", 0, 0}, | |||
{ XK_Right, ControlMask, "\033[1;5C", 0, 0}, | |||
{ XK_Right, ShiftMask|ControlMask,"\033[1;6C", 0, 0}, | |||
{ XK_Right, ControlMask|Mod1Mask,"\033[1;7C", 0, 0}, | |||
{ XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0, 0}, | |||
{ XK_Right, XK_ANY_MOD, "\033[C", 0, -1}, | |||
{ XK_Right, XK_ANY_MOD, "\033OC", 0, +1}, | |||
{ XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0}, | |||
{ XK_Return, Mod1Mask, "\033\r", 0, 0}, | |||
{ XK_Return, XK_ANY_MOD, "\r", 0, 0}, | |||
{ XK_Insert, ShiftMask, "\033[4l", -1, 0}, | |||
{ XK_Insert, ShiftMask, "\033[2;2~", +1, 0}, | |||
{ XK_Insert, ControlMask, "\033[L", -1, 0}, | |||
{ XK_Insert, ControlMask, "\033[2;5~", +1, 0}, | |||
{ XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, | |||
{ XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, | |||
{ XK_Delete, ControlMask, "\033[M", -1, 0}, | |||
{ XK_Delete, ControlMask, "\033[3;5~", +1, 0}, | |||
{ XK_Delete, ShiftMask, "\033[2K", -1, 0}, | |||
{ XK_Delete, ShiftMask, "\033[3;2~", +1, 0}, | |||
{ XK_Delete, XK_ANY_MOD, "\033[P", -1, 0}, | |||
{ XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, | |||
{ XK_BackSpace, XK_NO_MOD, "\177", 0, 0}, | |||
{ XK_BackSpace, Mod1Mask, "\033\177", 0, 0}, | |||
{ XK_Home, ShiftMask, "\033[2J", 0, -1}, | |||
{ XK_Home, ShiftMask, "\033[1;2H", 0, +1}, | |||
{ XK_Home, XK_ANY_MOD, "\033[H", 0, -1}, | |||
{ XK_Home, XK_ANY_MOD, "\033[1~", 0, +1}, | |||
{ XK_End, ControlMask, "\033[J", -1, 0}, | |||
{ XK_End, ControlMask, "\033[1;5F", +1, 0}, | |||
{ XK_End, ShiftMask, "\033[K", -1, 0}, | |||
{ XK_End, ShiftMask, "\033[1;2F", +1, 0}, | |||
{ XK_End, XK_ANY_MOD, "\033[4~", 0, 0}, | |||
{ XK_Prior, ControlMask, "\033[5;5~", 0, 0}, | |||
{ XK_Prior, ShiftMask, "\033[5;2~", 0, 0}, | |||
{ XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, | |||
{ XK_Next, ControlMask, "\033[6;5~", 0, 0}, | |||
{ XK_Next, ShiftMask, "\033[6;2~", 0, 0}, | |||
{ XK_Next, XK_ANY_MOD, "\033[6~", 0, 0}, | |||
{ XK_F1, XK_NO_MOD, "\033OP" , 0, 0}, | |||
{ XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0}, | |||
{ XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0}, | |||
{ XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0}, | |||
{ XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0}, | |||
{ XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0}, | |||
{ XK_F2, XK_NO_MOD, "\033OQ" , 0, 0}, | |||
{ XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0}, | |||
{ XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0}, | |||
{ XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0}, | |||
{ XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0}, | |||
{ XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0}, | |||
{ XK_F3, XK_NO_MOD, "\033OR" , 0, 0}, | |||
{ XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0}, | |||
{ XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0}, | |||
{ XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0}, | |||
{ XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0}, | |||
{ XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0}, | |||
{ XK_F4, XK_NO_MOD, "\033OS" , 0, 0}, | |||
{ XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0}, | |||
{ XK_F4, /* F28 */ ControlMask, "\033[1;5S", 0, 0}, | |||
{ XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0}, | |||
{ XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0}, | |||
{ XK_F5, XK_NO_MOD, "\033[15~", 0, 0}, | |||
{ XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0}, | |||
{ XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0}, | |||
{ XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0}, | |||
{ XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0}, | |||
{ XK_F6, XK_NO_MOD, "\033[17~", 0, 0}, | |||
{ XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0}, | |||
{ XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0}, | |||
{ XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0}, | |||
{ XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0}, | |||
{ XK_F7, XK_NO_MOD, "\033[18~", 0, 0}, | |||
{ XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0}, | |||
{ XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0}, | |||
{ XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0}, | |||
{ XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0}, | |||
{ XK_F8, XK_NO_MOD, "\033[19~", 0, 0}, | |||
{ XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0}, | |||
{ XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0}, | |||
{ XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0}, | |||
{ XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0}, | |||
{ XK_F9, XK_NO_MOD, "\033[20~", 0, 0}, | |||
{ XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0}, | |||
{ XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0}, | |||
{ XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0}, | |||
{ XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0}, | |||
{ XK_F10, XK_NO_MOD, "\033[21~", 0, 0}, | |||
{ XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0}, | |||
{ XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0}, | |||
{ XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0}, | |||
{ XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0}, | |||
{ XK_F11, XK_NO_MOD, "\033[23~", 0, 0}, | |||
{ XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0}, | |||
{ XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0}, | |||
{ XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0}, | |||
{ XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0}, | |||
{ XK_F12, XK_NO_MOD, "\033[24~", 0, 0}, | |||
{ XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0}, | |||
{ XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0}, | |||
{ XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0}, | |||
{ XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0}, | |||
{ XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0}, | |||
{ XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0}, | |||
{ XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0}, | |||
{ XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0}, | |||
{ XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0}, | |||
{ XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0}, | |||
{ XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0}, | |||
{ XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0}, | |||
{ XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0}, | |||
{ XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0}, | |||
{ XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0}, | |||
{ XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0}, | |||
{ XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0}, | |||
{ XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0}, | |||
{ XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0}, | |||
{ XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0}, | |||
{ XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0}, | |||
{ XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0}, | |||
{ XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0}, | |||
{ XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0}, | |||
{ XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0}, | |||
{ XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0}, | |||
{ XK_F35, XK_NO_MOD, "\033[23;5~", 0, 0}, | |||
}; | |||
/* | |||
* Selection types' masks. | |||
* Use the same masks as usual. | |||
* Button1Mask is always unset, to make masks match between ButtonPress. | |||
* ButtonRelease and MotionNotify. | |||
* If no match is found, regular selection is used. | |||
*/ | |||
static uint selmasks[] = { | |||
[SEL_RECTANGULAR] = Mod1Mask, | |||
}; | |||
/* | |||
* Printable characters in ASCII, used to estimate the advance width | |||
* of single wide characters. | |||
*/ | |||
static char ascii_printable[] = | |||
" !\"#$%&'()*+,-./0123456789:;<=>?" | |||
"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" | |||
"`abcdefghijklmnopqrstuvwxyz{|}~"; |
@ -1,136 +0,0 @@ | |||
/* See LICENSE for license details. */ | |||
#include <stdint.h> | |||
#include <sys/types.h> | |||
/* macros */ | |||
#define MIN(a, b) ((a) < (b) ? (a) : (b)) | |||
#define MAX(a, b) ((a) < (b) ? (b) : (a)) | |||
#define LEN(a) (sizeof(a) / sizeof(a)[0]) | |||
#define BETWEEN(x, a, b) ((a) <= (x) && (x) <= (b)) | |||
#define DIVCEIL(n, d) (((n) + ((d) - 1)) / (d)) | |||
#define DEFAULT(a, b) (a) = (a) ? (a) : (b) | |||
#define LIMIT(x, a, b) (x) = (x) < (a) ? (a) : (x) > (b) ? (b) : (x) | |||
#define ATTRCMP(a, b) ((a).mode != (b).mode || (a).fg != (b).fg || \ | |||
(a).bg != (b).bg) | |||
#define TIMEDIFF(t1, t2) ((t1.tv_sec-t2.tv_sec)*1000 + \ | |||
(t1.tv_nsec-t2.tv_nsec)/1E6) | |||
#define MODBIT(x, set, bit) ((set) ? ((x) |= (bit)) : ((x) &= ~(bit))) | |||
#define TRUECOLOR(r,g,b) (1 << 24 | (r) << 16 | (g) << 8 | (b)) | |||
#define IS_TRUECOL(x) (1 << 24 & (x)) | |||
enum glyph_attribute { | |||
ATTR_NULL = 0, | |||
ATTR_BOLD = 1 << 0, | |||
ATTR_FAINT = 1 << 1, | |||
ATTR_ITALIC = 1 << 2, | |||
ATTR_UNDERLINE = 1 << 3, | |||
ATTR_BLINK = 1 << 4, | |||
ATTR_REVERSE = 1 << 5, | |||
ATTR_INVISIBLE = 1 << 6, | |||
ATTR_STRUCK = 1 << 7, | |||
ATTR_WRAP = 1 << 8, | |||
ATTR_WIDE = 1 << 9, | |||
ATTR_WDUMMY = 1 << 10, | |||
ATTR_BOLD_FAINT = ATTR_BOLD | ATTR_FAINT, | |||
}; | |||
enum selection_mode { | |||
SEL_IDLE = 0, | |||
SEL_EMPTY = 1, | |||
SEL_READY = 2 | |||
}; | |||
enum selection_type { | |||
SEL_REGULAR = 1, | |||
SEL_RECTANGULAR = 2 | |||
}; | |||
enum selection_snap { | |||
SNAP_WORD = 1, | |||
SNAP_LINE = 2 | |||
}; | |||
typedef unsigned char uchar; | |||
typedef unsigned int uint; | |||
typedef unsigned long ulong; | |||
typedef unsigned short ushort; | |||
typedef uint_least32_t Rune; | |||
#define Glyph Glyph_ | |||
typedef struct { | |||
Rune u; /* character code */ | |||
ushort mode; /* attribute flags */ | |||
uint32_t fg; /* foreground */ | |||
uint32_t bg; /* background */ | |||
} Glyph; | |||
typedef Glyph *Line; | |||
typedef union { | |||
int i; | |||
uint ui; | |||
float f; | |||
const void *v; | |||
const char *s; | |||
} Arg; | |||
void die(const char *, ...); | |||
void redraw(void); | |||
void tfulldirt(void); | |||
void draw(void); | |||
void iso14755(const Arg *); | |||
void externalpipe(const Arg *); | |||
void kscrolldown(const Arg *); | |||
void kscrollup(const Arg *); | |||
void printscreen(const Arg *); | |||
void printsel(const Arg *); | |||
void sendbreak(const Arg *); | |||
void toggleprinter(const Arg *); | |||
int tattrset(int); | |||
void tnew(int, int); | |||
void tresize(int, int); | |||
void tsetdirtattr(int); | |||
void ttyhangup(void); | |||
int ttynew(char *, char *, char *, char **); | |||
size_t ttyread(void); | |||
void ttyresize(int, int); | |||
void ttywrite(const char *, size_t, int); | |||
void resettitle(void); | |||
void selclear(void); | |||
void selinit(void); | |||
void selstart(int, int, int); | |||
void selextend(int, int, int, int); | |||
int selected(int, int); | |||
char *getsel(void); | |||
size_t utf8encode(Rune, char *); | |||
void *xmalloc(size_t); | |||
void *xrealloc(void *, size_t); | |||
char *xstrdup(char *); | |||
/* config.h globals */ | |||
extern char *utmp; | |||
extern char *scroll; | |||
extern char *stty_args; | |||
extern char *vtiden; | |||
extern wchar_t *worddelimiters; | |||
extern int allowaltscreen; | |||
extern int allowwindowops; | |||
extern char *termname; | |||
extern unsigned int tabspaces; | |||
extern unsigned int defaultfg; | |||
extern unsigned int defaultbg; | |||
<<<<<<< | |||
extern float alpha; | |||
extern char *iso14755_cmd; | |||
======= | |||
extern float alpha, alphaUnfocused; | |||
>>>>>>> |